class DCGreenLanternWidget(Frame):
"""
Green Lantern logo from DC comics
(yeah yeah, i'm shitty artist, i know)
"""
green = "#07A007"
outline = "#FFFFFF"
unpowered = '#C0C0C0'
def __init__(self, parent, initial_state):
Frame.__init__(self, parent)
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self, cnf={'background': BACKGROUND_COLOR})
# outer circle
kw = {'outline': self.outline, 'fill': self.green}
base = 30 * SCALE
d = 190 * SCALE
s = 10 * SCALE
outer_circle = ((base, base, base + d - s, base + d),
(base + s, base + s, base + d - s - s, base + d - s))
self.canvas.create_oval(*outer_circle[0], **kw)
kw['fill'] = BACKGROUND_COLOR
self.canvas.create_oval(*outer_circle[1], **kw)
# inner circle
kw = {'outline': self.outline, 'fill': self.green}
base = 70 * SCALE
d = 100 * SCALE
s = 14 * SCALE
outer_circle = ((base, base + s, base + d, base + d),
(base + s, base + s + s, base + d - s, base + d - s))
self.canvas.create_oval(*outer_circle[0], **kw)
kw['fill'] = initial_state[1] if initial_state[0] else self.unpowered
self.item = self.canvas.create_oval(*outer_circle[1], **kw)
# top bar
self.canvas.create_rectangle(base,
base,
base + d,
base + s,
outline=self.green,
fill=self.green)
# bottom bar
self.canvas.create_rectangle(base,
base + d,
base + d,
base + d + s,
outline=self.green,
fill=self.green)
self.canvas.pack(fill=BOTH, expand=1)
def change_color(self, color):
self.canvas.itemconfig(self.item, outline=color, fill=color)
class TkFrame(Frame):
BORDER = 5
LED_SIZE = 20
def __init__(self, parent, controller):
Frame.__init__(self, parent)
self.CONTROLLER = controller
# Setup the layout method
self.pack(fill=BOTH, expand=1)
# Add a canvas
self.canvas = Canvas(self)
self.canvas.pack(fill=BOTH, expand=1)
# Setup the correct geometry
total_width = 2*self.BORDER + self.CONTROLLER.WIDTH*self.LED_SIZE
total_height = 2*self.BORDER + self.CONTROLLER.HEIGHT*self.LED_SIZE
parent.geometry('{w}x{h}+300+300'.format(
w=total_width,
h=total_height
))
# Add all the LEDs
def make_led(x, y):
y_top = self.BORDER + y*self.LED_SIZE
x_left = self.BORDER + x*self.LED_SIZE
return self.canvas.create_oval(
x_left, y_top,
x_left + self.LED_SIZE, y_top + self.LED_SIZE,
outline='white',
fill='white',
width=1
)
self.LEDS = [
[
make_led(x, y)
for y in xrange(self.CONTROLLER.HEIGHT)
]
for x in xrange(self.CONTROLLER.WIDTH)
]
def update(self):
# Update all the LEDs
for y in xrange(self.CONTROLLER.HEIGHT):
for x in xrange(self.CONTROLLER.WIDTH):
colour = self.CONTROLLER.get_rgba_xy(x, y)
self.canvas.itemconfig(
self.LEDS[x][y],
fill=rgba_to_hex(*colour),
)
class StartFrame(Frame):
"""Class which controls start screen of spelling aid"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
#Create UI elements
self.start_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.start_canvas.pack()
buttonStart = Button(self, text="Start", width=10,
command=self.start)
buttonEdit = Button(self, text="Edit Lists",
command=self.parent.show_editor)
self.list_menu_var = StringVar(self)
self.list_menu_var.set("Random List")
self.start_canvas.create_window(300, 200, window=buttonStart)
self.menu = self.start_canvas.create_window(300, 150)
self.start_canvas.create_window(520, 230, window=buttonEdit)
self.start_canvas.create_text(300, 100, font=("Helvetica", 25),
text="Select a list:")
self.update_list()
self.update()
def start(self):
"""Start the game with the selected list"""
self.parent.start_game(self.selected_list)
def update(self, event=None):
"""Change the current list to match selection"""
list_name = self.list_menu_var.get()
for word_list in self.parent.list_list:
if word_list.name == list_name:
self.selected_list = word_list
def update_list(self):
"""Refreshes the list of lists"""
list_menu = OptionMenu(self, self.list_menu_var,
*self.parent.list_list, command=self.update)
list_menu.configure(width=30)
self.start_canvas.itemconfig(self.menu, window=list_menu)
def welcomeMessage(self):
"""Show the welcome message"""
self.start_canvas.create_text((10, 10), anchor=NW, text="Welcome, %s."
%(self.parent.user.username),
font=("Helvetica", 15))
class DrawGrid(Frame):
def __init__(self, parent, langton_ant):
Frame.__init__(self, parent)
self.parent = parent
self.pack(fill=BOTH, expand=1)
self.title = self.parent.title()
self.rows = 101
self.columns = 82
self.cell_width = 6
self.cell_height = 6
self.canvas = Canvas(self, width=self.cell_width * self.columns, height=self.cell_height * self.rows,
borderwidth=0, highlightthickness=0)
self.canvas.pack(side="top", fill="both", expand="true")
self.rect = {}
for column in range(self.columns):
for row in range(self.rows):
x1 = column * self.cell_width
y1 = row * self.cell_height
x2 = x1 + self.cell_width
y2 = y1 + self.cell_height
self.rect[row, column] = self.canvas.create_rectangle(x1, y1, x2, y2, fill="white", tags="rect",
outline="gray")
self.langton_ant = langton_ant
self.draw_result(300)
def draw_result(self, delay, step=0):
"""
draw the grid and refresh
"""
self.parent.title(self.title+" step: " + str(step))
self.canvas.itemconfig("rect", fill="white")
data = np.matrix(self.langton_ant.grid)
nonzero_idx = data.nonzero()
# dealing living cells (non zero matrix)
for row,col in zip(nonzero_idx[0], nonzero_idx[1]):
item_id = self.rect[row, col]
self.canvas.itemconfig(item_id, fill="black")
print_out_file(len(nonzero_idx[0]), "w" if step==0 else "a")
self.langton_ant.next()
self.after(delay, lambda: self.draw_result(delay, step+1))
class CaCanvas(Frame):
def __init__(self, root, ca_width, ca_height, x_max, y_max):
Frame.__init__(self, root)
self.x_max = x_max
self.y_max = y_max
self.canvas = Canvas(self,
width=ca_width,
height=ca_height,
bg='white')
self.canvas.pack()
self.cell = [[None for x in range(x_max)] for y in range(y_max)]
self.cell_count = [[0 for x in range(x_max)] for y in range(y_max)]
self.x_scale = ca_width / x_max
self.y_scale = ca_height / y_max
self.create_grid()
def create_grid(self):
for x in range(self.x_max):
for y in range(self.y_max):
self.cell[x][y] = self.canvas.create_rectangle(
(x * self.x_scale, y * self.y_scale,
(x + 1) * self.x_scale, (y + 1) * self.y_scale),
outline='white',
fill='white')
def set_on(self, x, y):
self.canvas.itemconfig(self.cell[x][y], fill="black")
self.cell_count[x][y] = 1
def set_off(self, x, y):
self.canvas.itemconfig(self.cell[x][y], fill="white")
self.cell_count[x][y] = 0
def count_cells(self):
count = 0
for x in range(self.x_max):
for y in range(self.y_max):
count += self.cell_count[x][y]
return count
def clear_cells(self):
for x in range(self.x_max):
for y in range(self.y_max):
self.set_off(x, y)
class StartFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.start_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.start_canvas.pack()
buttonStart = Button(self, text="Start", width=10,
command=self.start)
buttonEdit = Button(self, text="Edit Lists",
command=self.parent.show_editor)
self.list_menu_var = StringVar(self)
self.list_menu_var.set("Random List")
self.start_canvas.create_window(300, 200, window=buttonStart)
self.menu = self.start_canvas.create_window(300, 150)
self.start_canvas.create_window(520, 230, window=buttonEdit)
self.start_canvas.create_text(300, 100, font=("Helvetica", 25),
text="Select a list:")
self.update_list()
self.update()
def start(self):
self.parent.start_game(self.selected_list)
def update(self, event=None):
list_name = self.list_menu_var.get()
for word_list in self.parent.list_list:
if word_list.name == list_name:
self.selected_list = word_list
def update_list(self):
list_menu = OptionMenu(self, self.list_menu_var,
*self.parent.list_list, command=self.update)
list_menu.configure(width=30)
self.start_canvas.itemconfig(self.menu, window=list_menu)
def welcomeMessage(self):
self.start_canvas.create_text((10, 10), anchor=NW, text="Welcome, %s."
%(self.parent.user.username),
font=("Helvetica", 15))
class CaCanvas(Frame):
def __init__(self,root,ca_width,ca_height,x_max,y_max):
Frame.__init__(self,root)
self.x_max = x_max
self.y_max = y_max
self.canvas = Canvas(self,width=ca_width,height=ca_height,bg='white')
self.canvas.pack()
self.cell = [[None for x in range(x_max)] for y in range(y_max)]
self.cell_count = [[0 for x in range(x_max)] for y in range(y_max)]
self.x_scale = ca_width/x_max
self.y_scale = ca_height/y_max
self.create_grid()
def create_grid(self):
for x in range(self.x_max):
for y in range(self.y_max):
self.cell[x][y] = self.canvas.create_rectangle((x*self.x_scale,y*self.y_scale,(x+1)*self.x_scale,(y+1)*self.y_scale),outline='white',fill='white')
def set_on(self,x,y):
self.canvas.itemconfig(self.cell[x][y], fill="black")
self.cell_count[x][y]=1
def set_off(self,x,y):
self.canvas.itemconfig(self.cell[x][y], fill="white")
self.cell_count[x][y]=0
def count_cells(self):
count = 0
for x in range(self.x_max):
for y in range(self.y_max):
count+=self.cell_count[x][y]
return count
def clear_cells(self):
for x in range(self.x_max):
for y in range(self.y_max):
self.set_off(x,y)
class GameGui(Tk):
score = None
autorun = False
def __init__(self, parent):
Tk.__init__(self)
self.parent = parent
# Game title
self.title("gamelogic")
# Geometry
self.geometry("{0}x{1}+0+0".format(545, (self.winfo_screenheight() / 2) + 250))
self.columnconfigure(1, weight=5)
# Game
self.game = Game()
# MinMax
self.algorithm = None
# Key Bindings
self.bind('<Left>', self.move)
self.bind('<Right>', self.move)
self.bind('<Up>', self.move)
self.bind('<Down>', self.move)
self.bind('<n>', self.move)
self.bind('<a>', self.move)
# Outline of the gui
#########################
## Game Score here ##
#########################
## Game Board here ##
#########################
## Menu Button here ##
#########################
## Score ##
self.score_label = Label(self, text='Sum', font=("Helvetica", 32, "bold")).grid(row=0, column=0, padx=20,
pady=0)
self.score = Label(self, text="0", font=("Helvetica", 32, "bold")).grid(row=0, column=1)
self.move = 0
self.moves_label = Label(self, text='Moves', font=("Helvetica", 32, "bold")).grid(row=1, column=0, padx=20,
pady=0)
self.moves = Label(self, text="0", font=("Helvetica", 32, "bold")).grid(row=1, column=1)
## Board ##
self.board = Canvas(self, width=(self.winfo_screenwidth() / 2) - 400, height=(self.winfo_screenheight() / 2),
highlightthickness=0, borderwidth=0)
self.board.grid(row=2, column=0, columnspan=2, sticky=E + W, padx=10, pady=10)
## Menu ##
how_to = Label(self, text='Move with arrow keys \n <a> to auto-run \n <n> to jump one step',
font=("Helvetica", 12)).grid(row=3, column=0, padx=20, pady=20)
# btn = Button(self, text="Close", command=partial(parent.openMenuFrame, self))
# btn.grid(row=2, column=0)
btn = Button(self, text="End Game", command=partial(parent.openMenuFrame, self))
btn.grid(row=3, column=1, padx=20, pady=20)
# Draw the initial grid
self.draw(self.game.grid)
def draw(self, grid):
self.board.delete("all")
for y in range(0, 4, 1):
for x in range(0, 4, 1):
top = y * sq_size
left = x * sq_size
bottom = y * sq_size + sq_size - 2
right = x * sq_size + sq_size - 2
# Create tiles and text
item = self.board.create_rectangle(left, top, right, bottom)
# Add the items
self.board.itemconfig(item, fill=colors[grid[y][x]], outline="#ff0000")
self.board.create_text((right - sq_size) + (sq_size / 2), (top + sq_size) - (sq_size / 2),
text=str(grid[y][x]), font=("Helvetica", 32, "bold"))
# self.board.itemconfig(item_text)
# self.board.create_rectangle(left, top, right, bottom, fill=colors[grid[y][x]])
def move(self, key, keycode=None):
# Stop autorun
self.autorun = False
if keycode:
code = keycode
else:
code = key.keycode
if code == 8320768 or code == 38:
self.game.move(Direction.Up)
elif code == 8189699 or code == 39:
self.game.move(Direction.Right)
elif code == 8255233 or code == 40:
self.game.move(Direction.Down)
elif code == 8124162 or code == 37:
self.game.move(Direction.Left)
# Algorithm
# one next
elif code == 2949230 or code == 78:
if not self.algorithm:
self.algorithm = MinMax(self, self.game)
dir, highest = self.algorithm.run()
self.game.move(dir)
# auto
elif code == 97 or code == 65:
if not self.algorithm:
self.algorithm = MinMax(self, self.game)
self.autorun = True
self.auto()
self.draw(self.game.grid)
self.score = Label(self, text=str(self.game.calculate_score()), font=("Helvetica", 32, "bold")).grid(row=0,
column=1)
def auto(self):
dir, highest = self.algorithm.run()
# No direction returned, game over
if not dir:
self.autorun = False
print 'Game over!'
print self.score
gameOver(highest, self)
return
self.game.move(dir)
self.draw(self.game.grid)
#Update labels
self.score = Label(self, text=str(self.game.calculate_score()), font=("Helvetica", 32, "bold")).grid(row=0,
column=1)
self.move += 1
self.moves = Label(self, text=str(self.move), font=("Helvetica", 32, "bold")).grid(row=1, column=1)
if self.autorun:
self.after(1, lambda: self.auto())
class World(Tk):
def __init__(self,filename=None,block=50,debug=True,delay=0.25,image=False,width=10,height=10):
# def __init__(self,filename=None,block=50,debug=True,delay=0.25,image=True,width=10,height=10):
Tk.__init__(self)
self.title("")
arg, self.width, self.height = block, width, height
# self.photos = [PhotoImage(file=(k+".gif")) for k in ["east","north","west","south"]]
self.beepers, self.ovals, self.numbers, self.robots, self.walls = {},{},{},{},{}
self.m, self.n, self.t, self.delay = arg*(width+3), arg*(height+3), arg, delay
self.debug, self.useImage = debug, image
a, b, c = self.t+self.t/2, self.m-self.t-self.t/2, self.n-self.t-self.t/2
self.canvas = Canvas(self, bg="white", width=self.m, height=self.n)
self.canvas.pack()
count = 1
for k in range(2*self.t, max(self.m,self.n)-self.t, self.t):
if k < b:
self.canvas.create_line(k, c, k, a, fill="red")
self.canvas.create_text(k, c+self.t/2, text=str(count), font=("Times",max(-self.t*2/3,-15),""))
if k < c:
self.canvas.create_line(b, k, a, k, fill="red")
self.canvas.create_text(a-self.t/2, self.n-k, text=str(count), font=("Times",max(-self.t*2/3,-15),""))
count += 1
self.canvas.create_line(a, c, b, c, fill="black", width=3)
self.canvas.create_line(a, a, a, c, fill="black", width=3)
if filename is not None:
self.readWorld(filename)
self.refresh()
def readWorld(self,filename):
try:
infile = open("worlds\\%s.wld" % filename, "r")
except IOError:
try:
infile = open("worlds/%s.wld" % filename, "r")
except IOError:
infile = open(filename, "r")
text = infile.read().split("\n")
infile.close()
for t in text:
if t.startswith("eastwestwalls"):
s = t.split(" ")
y, x = int(s[1]), int(s[2])
self.addWall(x, y, -1, y)
if t.startswith("northsouthwalls"):
s = t.split(" ")
x, y = int(s[1]), int(s[2])
self.addWall(x, y, x, -1)
if t.startswith("beepers"):
s = t.split(" ")
y, x, n = int(s[1]), int(s[2]), int(s[3])
if n is infinity:
self.addInfiniteBeepers(x, y)
else:
for k in range(n):
self.addBeeper(x, y)
def pause(self):
sleep(self.delay)
def isBeeper(self,x,y):
return (x,y) in self.beepers.keys() and not self.beepers[(x,y)] == 0
def countRobots(self,x,y):
if (x,y) not in self.robots.keys():
return 0
return len(self.robots[(x,y)])
def crash(self,x1,y1,x2,y2):
if 0 in (x1,y1,x2,y2):
return True
if (x2,y2) in self.walls.keys() and (x1,y1) in self.walls[(x2,y2)]:
return True
if (x1,y1) in self.walls.keys() and (x2,y2) in self.walls[(x1,y1)]:
return True
return False
def addInfiniteBeepers(self,x,y):
flag = (x,y) not in self.beepers.keys() or self.beepers[(x,y)] is 0
self.beepers[(x,y)] = infinity
text = "oo"
a, b = self.t+x*self.t, self.n-(self.t+y*self.t)
t = self.t/3
if flag:
self.ovals[(x,y)] = self.canvas.create_oval(a-t, b-t, a+t, b+t, fill="black")
self.numbers[(x,y)] = self.canvas.create_text(a, b, text=text, fill="white", font=("Times",max(-self.t/2,-20),""))
else:
self.canvas.itemconfig(self.numbers[(x,y)], text=text)
if (x,y) in self.robots.keys():
for robot in self.robots[(x,y)]:
robot.lift()
def addBeeper(self,x,y):
if (x,y) in self.beepers.keys() and self.beepers[(x,y)] is infinity:
return
flag = (x,y) not in self.beepers.keys() or self.beepers[(x,y)] is 0
if flag:
self.beepers[(x,y)] = 1
else:
self.beepers[(x,y)] += 1
text = str(self.beepers[(x,y)])
a, b = self.t+x*self.t, self.n-(self.t+y*self.t)
t = self.t/3
if flag:
self.ovals[(x,y)] = self.canvas.create_oval(a-t, b-t, a+t, b+t, fill="black")
self.numbers[(x,y)] = self.canvas.create_text(a, b, text=text, fill="white", font=("Times",max(-self.t/2,-20),""))
else:
self.canvas.itemconfig(self.numbers[(x,y)], text=text)
if (x,y) in self.robots.keys():
for robot in self.robots[(x,y)]:
robot.lift()
def removeBeeper(self,x,y):
if self.beepers[(x,y)] is infinity:
return
self.beepers[(x,y)] -= 1
flag = self.beepers[(x,y)] is 0
text = str(self.beepers[(x,y)])
if flag:
self.canvas.delete(self.ovals[(x,y)])
self.canvas.delete(self.numbers[(x,y)])
else:
self.canvas.itemconfig(self.numbers[(x,y)], text=text)
if (x,y) in self.robots.keys():
for robot in self.robots[(x,y)]:
robot.lift()
def addWall(self,x1,y1,x2,y2):
if not x1 == x2 and not y1 == y2:
return
if x1 == x2:
y1, y2 = min(y1, y2), max(y1, y2)
if y1 == -1:
y1 = y2
for k in range(y1, y2+1):
self.walls.setdefault((x1,k), []).append((x1+1,k))
a, b = self.t+x1*self.t+self.t/2, self.n-(self.t+k*self.t)+self.t/2
c, d = self.t+x1*self.t+self.t/2, self.n-(self.t+k*self.t)-self.t/2
self.canvas.create_line(a, b+1, c, d-1, fill="black", width=3)
else:
x1, x2 = min(x1, x2), max(x1, x2)
if x1 == -1:
x1 = x2
for k in range(x1, x2+1):
self.walls.setdefault((k,y1), []).append((k,y1+1))
a, b = self.t+k*self.t-self.t/2, self.n-(self.t+y1*self.t)-self.t/2
c, d = self.t+k*self.t+self.t/2, self.n-(self.t+y1*self.t)-self.t/2
self.canvas.create_line(a-1, b, c+1, d, fill="black", width=3)
def draw(self,x,y,d,img):
# if self.useImage:
# if img is not None:
# self.canvas.delete(img)
# x, y = self.t+x*self.t, self.n-(self.t+y*self.t)
# photo = self.photos[d/90]
# img = self.canvas.create_image(x, y, image=photo)
# return img
# else:
t, angle = self.t/2, 120
x, y = self.t+x*self.t, self.n-(self.t+y*self.t)
x1, y1 = x+3**0.5*t/2*cos(radians(d)), y-3**0.5*t/2*sin(radians(d))
x2, y2 = x+t*cos(radians(d+angle)), y-t*sin(radians(d+angle))
x3, y3 = x+t/4*cos(radians(d+180)), y-t/4*sin(radians(d+180))
x4, y4 = x+t*cos(radians(d-angle)), y-t*sin(radians(d-angle))
if img is not None:
self.canvas.delete(img)
img = self.canvas.create_polygon(x1, y1, x2, y2, x3, y3, x4, y4, fill="blue")
return img
def erase(self,img):
self.canvas.delete(img)
def recordMove(self,count,x1,y1,x2,y2):
for robot in self.robots[(x1,y1)]:
if robot.count == count:
self.robots[(x1,y1)].remove(robot)
self.robots.setdefault((x2,y2), []).append(robot)
break
def lift(self,img):
self.canvas.lift(img)
def refresh(self):
self.canvas.update()
self.pause()
def register(self,x,y,robot):
self.robots.setdefault((x,y), []).append(robot)
def remove(self,x,y,robot):
self.robots[(x,y)].remove(robot)
class Ex(Frame):
def __init__(self,parent):
Frame.__init__(self,parent)
self.parent = parent
self.x_before = 20
self.x_current = 20
self.y_before = 200
self.y_current = 200
self.FirstRun = True
self.initUI()
self.runRandWalk(STEPS)
self.FirstRun = False
def initUI(self):
self.parent.title("Random Walk Lines 1")
self.pack(fill=BOTH,expand=1)
self.style = Style()
self.style.theme_use("default")
frame = Frame(self,relief=RAISED,borderwidth=2)
frame.pack(fill=BOTH,expand=True)
self.canvas = Canvas(frame)
self.canvas.create_line(10,200,390,200,dash=(4,2), width=2)
self.canvas.pack(fill=BOTH,expand=1)
self.newWalkButton = Button(self,text="New Walk",
command=self.newWalk)
self.closeButton = Button(self,text="Close",
command=self.closeAll)
# pack the buttons here
self.closeButton.pack(side=RIGHT,padx=5,pady=5)
self.newWalkButton.pack(side=RIGHT)
def newWalk(self):
for x in range(0,STEPS):
getTag = "step"+str(x)
self.canvas.coords(getTag,(0,0,0,0))
self.x_current = 20
self.x_before = 20
self.y_current = 200
self.y_before = 200
self.runRandWalk(STEPS)
def closeAll(self):
Frame.quit(self)
def RandWalk(self,whichStep):
r = random.randint(0,1)
addval = 0;
toTag = "step"+str(whichStep)
if r == 0:
addval = ADDVAL
else:
addval = -ADDVAL
self.y_current = self.y_before + addval
self.x_current = self.x_before + XSTEP
if self.y_current < 200:
if self.y_before == 200:
if self.FirstRun == True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "green", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current),)
self.canvas.itemconfig(toTag,fill="green")
else:
if self.FirstRun == True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "green", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current))
self.canvas.itemconfig(toTag,fill="green")
else:
if self.y_before<200:
if self.FirstRun==True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "green", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current))
self.canvas.itemconfig(toTag,fill="green")
else:
if self.FirstRun==True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "red", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current))
self.canvas.itemconfig(toTag,fill="red")
self.canvas.pack(fill=BOTH,expand=1)
self.x_before = self.x_current
self.y_before = self.y_current
def runRandWalk(self,steps):
for x in range(0,steps):
self.RandWalk(x)
class NvimTk(object):
"""Wraps all nvim/tk event handling."""
def __init__(self, nvim):
"""Initialize with a Nvim instance."""
self._nvim = nvim
self._attrs = {}
self._nvim_updates = deque()
self._canvas = None
self._fg = '#000000'
self._bg = '#ffffff'
def run(self):
"""Start the UI."""
self._tk_setup()
t = Thread(target=self._nvim_event_loop)
t.daemon = True
t.start()
self._root.mainloop()
def _tk_setup(self):
self._root = Tk()
self._root.bind('<<nvim_redraw>>', self._tk_nvim_redraw)
self._root.bind('<<nvim_detach>>', self._tk_nvim_detach)
self._root.bind('<Key>', self._tk_key)
def _tk_nvim_redraw(self, *args):
update = self._nvim_updates.popleft()
for update in update:
handler = getattr(self, '_tk_nvim_' + update[0])
for args in update[1:]:
handler(*args)
def _tk_nvim_detach(self, *args):
self._root.destroy()
def _tk_nvim_resize(self, width, height):
self._tk_redraw_canvas(width, height)
def _tk_nvim_clear(self):
self._tk_clear_region(0, self._height - 1, 0, self._width - 1)
def _tk_nvim_eol_clear(self):
row, col = (
self._cursor_row,
self._cursor_col,
)
self._tk_clear_region(row, row, col, self._scroll_right)
def _tk_nvim_cursor_goto(self, row, col):
self._cursor_row = row
self._cursor_col = col
def _tk_nvim_cursor_on(self):
pass
def _tk_nvim_cursor_off(self):
pass
def _tk_nvim_mouse_on(self):
pass
def _tk_nvim_mouse_off(self):
pass
def _tk_nvim_insert_mode(self):
pass
def _tk_nvim_normal_mode(self):
pass
def _tk_nvim_set_scroll_region(self, top, bot, left, right):
self._scroll_top = top
self._scroll_bot = bot
self._scroll_left = left
self._scroll_right = right
def _tk_nvim_scroll(self, count):
top, bot = (
self._scroll_top,
self._scroll_bot,
)
left, right = (
self._scroll_left,
self._scroll_right,
)
if count > 0:
destroy_top = top
destroy_bot = top + count - 1
move_top = destroy_bot + 1
move_bot = bot
fill_top = move_bot + 1
fill_bot = fill_top + count - 1
else:
destroy_top = bot + count + 1
destroy_bot = bot
move_top = top
move_bot = destroy_top - 1
fill_bot = move_top - 1
fill_top = fill_bot + count + 1
# destroy items that would be moved outside the scroll region after
# scrolling
# self._tk_clear_region(destroy_top, destroy_bot, left, right)
# self._tk_clear_region(move_top, move_bot, left, right)
self._tk_destroy_region(destroy_top, destroy_bot, left, right)
self._tk_tag_region('move', move_top, move_bot, left, right)
self._canvas.move('move', 0, -count * self._rowsize)
self._canvas.dtag('move', 'move')
# self._tk_fill_region(fill_top, fill_bot, left, right)
def _tk_nvim_highlight_set(self, attrs):
self._attrs = attrs
def _tk_nvim_put(self, data):
# choose a Font instance
font = self._fnormal
if self._attrs.get('bold', False):
font = self._fbold
if self._attrs.get('italic', False):
font = self._fbolditalic if font == self._fbold else self._fitalic
# colors
fg = "#{0:0{1}x}".format(self._attrs.get('foreground', self._fg), 6)
bg = "#{0:0{1}x}".format(self._attrs.get('background', self._bg), 6)
# get the "text" and "rect" which correspond to the current cell
x, y = self._tk_get_coords(self._cursor_row, self._cursor_col)
items = self._canvas.find_overlapping(x, y, x + 1, y + 1)
if len(items) != 2:
# caught part the double-width character in the cell to the left,
# filter items which dont have the same horizontal coordinate as
# "x"
predicate = lambda item: self._canvas.coords(item)[0] == x
items = filter(predicate, items)
# rect has lower id than text, sort to unpack correctly
rect, text = sorted(items)
self._canvas.itemconfig(text, fill=fg, font=font, text=data or ' ')
self._canvas.itemconfig(rect, fill=bg)
self._tk_nvim_cursor_goto(self._cursor_row, self._cursor_col + 1)
def _tk_nvim_bell(self):
self._root.bell()
def _tk_nvim_update_fg(self, fg):
self._fg = "#{0:0{1}x}".format(fg, 6)
def _tk_nvim_update_bg(self, bg):
self._bg = "#{0:0{1}x}".format(bg, 6)
def _tk_redraw_canvas(self, width, height):
if self._canvas:
self._canvas.destroy()
self._fnormal = Font(family='Monospace', size=13)
self._fbold = Font(family='Monospace', weight='bold', size=13)
self._fitalic = Font(family='Monospace', slant='italic', size=13)
self._fbolditalic = Font(family='Monospace',
weight='bold',
slant='italic',
size=13)
self._colsize = self._fnormal.measure('A')
self._rowsize = self._fnormal.metrics('linespace')
self._canvas = Canvas(self._root,
width=self._colsize * width,
height=self._rowsize * height)
self._tk_fill_region(0, height - 1, 0, width - 1)
self._cursor_row = 0
self._cursor_col = 0
self._scroll_top = 0
self._scroll_bot = height - 1
self._scroll_left = 0
self._scroll_right = width - 1
self._width, self._height = (
width,
height,
)
self._canvas.pack()
def _tk_fill_region(self, top, bot, left, right):
# create columns from right to left so the left columns have a
# higher z-index than the right columns. This is required to
# properly display characters that cross cell boundary
for rownum in range(bot, top - 1, -1):
for colnum in range(right, left - 1, -1):
x1 = colnum * self._colsize
y1 = rownum * self._rowsize
x2 = (colnum + 1) * self._colsize
y2 = (rownum + 1) * self._rowsize
# for each cell, create two items: The rectangle is used for
# filling background and the text is for cell contents.
self._canvas.create_rectangle(x1,
y1,
x2,
y2,
fill=self._bg,
width=0)
self._canvas.create_text(x1,
y1,
anchor='nw',
font=self._fnormal,
width=1,
fill=self._fg,
text=' ')
def _tk_clear_region(self, top, bot, left, right):
self._tk_tag_region('clear', top, bot, left, right)
self._canvas.itemconfig('clear', fill=self._bg)
self._canvas.dtag('clear', 'clear')
def _tk_destroy_region(self, top, bot, left, right):
self._tk_tag_region('destroy', top, bot, left, right)
self._canvas.delete('destroy')
self._canvas.dtag('destroy', 'destroy')
def _tk_tag_region(self, tag, top, bot, left, right):
x1, y1 = self._tk_get_coords(top, left)
x2, y2 = self._tk_get_coords(bot, right)
self._canvas.addtag_overlapping(tag, x1, y1, x2 + 1, y2 + 1)
def _tk_get_coords(self, row, col):
x = col * self._colsize
y = row * self._rowsize
return x, y
def _tk_key(self, event):
if 0xffe1 <= event.keysym_num <= 0xffee:
# this is a modifier key, ignore. Source:
# https://www.tcl.tk/man/tcl8.4/TkCmd/keysyms.htm
return
# Translate to Nvim representation of keys
send = []
if event.state & 0x1:
send.append('S')
if event.state & 0x4:
send.append('C')
if event.state & (0x8 | 0x80):
send.append('A')
special = len(send) > 0
key = event.char
if _is_invalid_key(key):
special = True
key = event.keysym
send.append(SPECIAL_KEYS.get(key, key))
send = '-'.join(send)
if special:
send = '<' + send + '>'
nvim = self._nvim
nvim.session.threadsafe_call(lambda: nvim.input(send))
def _nvim_event_loop(self):
self._nvim.session.run(self._nvim_request, self._nvim_notification,
lambda: self._nvim.attach_ui(80, 24))
self._root.event_generate('<<nvim_detach>>', when='tail')
def _nvim_request(self, method, args):
raise Exception('This UI does not implement any methods')
def _nvim_notification(self, method, args):
if method == 'redraw':
self._nvim_updates.append(args)
self._root.event_generate('<<nvim_redraw>>', when='tail')
fill_color = "pink"
root.geometry(config_string)
cell_size = 20
canvas = Canvas(root, height = win_height)
canvas.pack(fill='both', expand = 'yes')
field_height = win_height // cell_size
field_width = win_width // cell_size
cell_matrix = []
cell_matrix_verif = []
for i in range(field_height):
for j in range(field_width):
square = canvas.create_rectangle(2 + cell_size * j, 2 + cell_size * i, cell_size + cell_size * j - 2, cell_size + cell_size * i - 2, fill = fill_color)
canvas.itemconfig(square, state=HIDDEN, tags=('hid','0'))
cell_matrix.append(square)
cell_matrix_verif.append(square)
fict_square = canvas.create_rectangle(0,0,0,0, state=HIDDEN, tags=('hid','0'))
cell_matrix.append(fict_square)
cell_matrix_verif.append(fict_square)
#configuration de base a l'ouverture du programme
canvas.itemconfig(cell_matrix[addpoint(8, 8)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addpoint(10, 9)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addpoint(9, 9)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addpoint(9, 8)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addpoint(9, 7)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addpoint(10, 7)], state=NORMAL, tags='vis')
iii = 0
jjj = 0
class GameFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, width=600, height=250)
self.parent = parent
def init_gui(self):
correct = """R0lGODlhQABAAOeqAAAAAAABAAACAAADAAAEAAAFAAAFAQAGAQAHAQEHAQEIAQEJAQEKAQEKAgEL
AgEMAgENAgEPAgIPAgIQAgIRAwITAwIUAwIVBAMVBAIWAwIWBAIXBAMXBAMYAwIZBAMZBAMaBQMb
BAMdBQMeBQMfBQMgBQQgBQQiBgQkBgQlBgQmBwQnBwUnBgUoBwUqBwUrBwUsBwUsCAUtCAUuCAUv
CAYvCAUxCAYyCQYzCAY0CQY1CgY2CQY3CQc3CgY5Cgc5Cgc7Cgc+Cwg/CwdACwhACwhBCwhCCwhG
DAhHDAhIDQlLDQlMDglNDglPDglQDglRDglSDgpUDwpWDwtWDwpXDwpZDwtaEAtfEQtgEQthEQxk
EQxkEgxlEgxnEgxoEw1oEgxpEgxqEw1qEg1rEwxsEw1sEg1tEw1vEw1wFA1yFA5yFA1zFA50FA50
FQ51FA52FQ95Fg56FQ57Fg97FQ99Fg9+Fg9/Fg+AFhCAFg+BFhCCFhCEFxCGFxCHGBCIGBCKGBGK
GBCLGBGMGRGNGRGOGRGQGRGRGRGRGhGSGRGTGhKTGRKTGhGUGhKVGhKXGhKXGxKYGhKaGxKbGxKc
GxKdGxKdHBOdGxOdHBKeHBOeGxOeHBOfHBOgHBOhHBOiHBOiHROjHBOjHROkHRSkHROlHRSlHRSm
HRSnHRSoHRSrHv//////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////yH+EUNyZWF0ZWQgd2l0aCBH
SU1QACH5BAEKAP8ALAAAAABAAEAAAAj+AP8JHEiwoMGDCBMqPAhgocOHEB0CaBixosWFEyde3MhR
YEaKHUNC/CiyJMYHCTSaXGkQgAcVKVnKHAhgBZIIIGeanAiki4acOkVOlJInBNCgHQEIELOIxFGk
GwFASLNJxVOoFgFUiFOKx1WsEQFY0GOqiQCwIQF0ECSqi4KvaDGKWNRJjgW4cRMCOEGI06AWePMy
ROGnU6QggQUXBIBij6dPUBIrptk4lKkuAiRPBpCCT6hQdipoVgxgBB9PnAzBGC0YQAY7mzRJWsI6
L4AIazTpVkNg8kgFXDhpwqTorm+JA6aE0kRpk47acQEkMUVJU6cs0NEC8FGKEiVOfQb+ZMcKgMWk
TM0joRgPFQCIQMw1bXpy9rjC22+Ea+IUZwJ7pAZcIVx1jdjwX1AAKFHJJt5lgsWBOgGwAyScUHKJ
JoJIAKFMpRlSIXOj3LAhSwAkgMeHlIDixYgkauGdJpds4ggFLO5EhCOaWMKcKUMEEGFaJfzBoG6d
vAEBgipl9cAZoFRXXSQ41OgRAAHUJgATp1Sn2yZjJNBeARi8FZYMoGByoW6IrEbeD04Y9RAAFBwy
JHOYdCFlS1T8UQROCwVgxocwapIIB3cuBsAWppgxQ5KLGfGibpSI4kShLTnQRiqEWPHBUQCYAJ9u
zHHCxwGUtiQCH6RwYscRBOS0QBjKsYGqCSk1lMpQDoxs0okjaVjVEABCVBIfc6CwccBxADwxCaiF
VEHqBosAqhsnMdiaUABoDCsJIDq40YmZkIJCBgP2/VMiIAxWd4kkTsr6SA7W3ndBJMPJai8naSBQ
Lk0zxKalvZo00kO8DgXAxID2UmLJHARLtAAYsdorCQ0NS/TBHcMytwkdFb8JgyHDYuKJCx2/OcQm
mFhCSScM73tfFNRhMsoLJY+UwBeneAKHly7fZ0EdqOxQc0UAvFBGBT0/JEAD9SWN0XEBAQA7
"""
wrong = """R0lGODlhQABAAOexAAAAAAEAAAIAAAMAAAQAAAUAAAYAAAgAAAkAAAoAAAwAAA0AAA4AAA8AABAA
ABEAABIAABMAABQAABUAABYAABcAABgAABkAABoAABsAABwAAB0AAB4AAB8AACAAACEAACIAACMA
ACQAACUAACYAACgAACkAACoAACsAACwAAC0AAC4AADEAADMAADQAADUAADYAADgAADkAADoAADsA
ADwAAD0AAD4AAD8AAEEAAEIAAEQAAEUAAEkAAEoAAEsAAFQAAFUAAFgAAFkAAF0AAF8AAGEAAGIA
AGQAAGcAAGgAAGoAAGsAAG0AAG4AAG8AAHAAAHMAAHgAAHsAAHwAAIEAAIYAAIoAAI4AAJMAAJQA
AJUAAJYAAJcAAJgAAJkAAJoAAJsAAJwAAJ0AAJ4AAKAAAKEAAKQAAKcAAKgAAKkAAKoAAK0AAK4A
AK8AALAAALEAALMAALUAALcAALgAALkAALoAALsAAL4AAL8AAMAAAMEAAMQAAMUAAMYAAMgAAMkA
AMoAAMwAAM0AAM4AAM8AANAAANEAANIAANMAANQAANUAANYAANcAANgAANkAANoAANsAAN0AAN4A
AOAAAOEAAOIAAOMAAOQAAOYAAOgAAOkAAOoAAOwAAO0AAO4AAO8AAPAAAPEAAPIAAPMAAPQAAPUA
APYAAPcAAPgAAPkAAPoAAPsAAPwAAP0AAP4AAP8AAP//////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////yH+EUNyZWF0ZWQgd2l0aCBH
SU1QACH5BAEKAP8ALAAAAABAAEAAAAj+AP8JHEhwIAAABRMqXLjwIMOHCQFAgIAQosWGFjRUvNhQ
A5sxDTZyvAggwhpAK0SOFAigwxxXo7aEXGmxZBlSqwbFUMmx5Z1To0qN4oKAJ02DCsiQEmqKUA2j
DwFsoFOKFKlRpE55CQB1JQABZE5dtVqqEIyuES28STXW6ihWXxweNQhAzCqsVq+eMpQCrUEKamCN
wpt3VKsvBPwyBEDASyvChVcdKuEXQIU0giEXVtVFgWKFCbKo0lyY1SEVXQFcaJM5r+u8pbY4+ExQ
AZbXuK+uQjTDKAAMckaTdh00pueRCK6IEpqb+ClEOVSqliN0+OugpbgkrinASinmzYn+l0KEYyMA
Cm3EWseNVZUXuQ0BVFnVNvxrU4peIATQ4AzM9c0ZtlVqVAhmX4CpKBLCQR8UYkp9BxLHShdFKUTA
FDBFyB4ppugBwn4m8CGWhuydIpNKBkxhCoD2mXLHhwad8MeKJLKnBQMbFSAFKODVeJUpe4ggHQiH
0OjjVUJtcQBCAkTBI4u5jXLKIBz4VsEjQB05FipdHLTEKdUdKWUjE6QmQSMPQskeK1sQ4QqEGmJl
SiMSVKbBIOppOYoqj6lJXFaFbPAZACT0kaeYcEaI1SmBnEDbPwCgYKiWlOZ1iiAsPMoSCYMYWSmJ
QTGS0lwAaNBIlp8qWoolJGhaEAD+EjziaapRlpIJjHMZVEGRiaYqJyWU5foqCH8cSuuWjrTgalQn
iHisa6csYsOyEAFgAiCzVhqUJOUJG5UHiWSL6Ca9eVstBYw8mKonZ5lbUxOspJoKGvC5q1AASbDi
Z4CrgFGhvQkN0ESatI6CChgPUAvRAFB40uOxYkSg8EIBONGJuNpWZcYCE7+qxFKDPesWh2psZy4A
R7TS67F7viFAxwAg8UrIIrO3ShwJKCwAE6nQXDN7qLxBwbIDPBHKyj9bZUobGq0kwBOdPJz0dUvB
cQFtADARSpg+yrlvYRzaMVtNSLDlM6ikdJLu1yOfwse/DR0xM9tYlcLJCxIgQrD+mKgAMtO9SvSJ
6CmUTAsAB37s3TUqfmTA0wBOjKwlKpDsUBGheIyo5yl6tEoQw1Gz/eMkPIgEwAh5oKrlKXl4/s8B
DWN8IFaadPtqBn2gIrqcf6BwUAaCCIdoKDs1xMAfPW+uiQv7vaCIumiX8ol+USHg7NelYPKDeTgg
InWAWWFSbrUN1KG4fVhVIoR0OSCiOvioRKID1mpVxWJQlhDhmwyI3HXgKZEonVcywAboBegUmghC
alRwCH0FKHvzOwoAJuAG3R3QEz2oTAkM4T+qfWJ8EkwAHDronE9EsCYpKMT7sBIK6gkLAAFow2jE
wwkfPAoAMCBEVcZiCk0U72RWBEiD4jAxBFcBgAaEoBEqJmE7dwFgATcRSikuYQRqASAGg1DFKSAh
QIBBCgJh4NAmijAxAKxAEJiwnBcN4gAwdAIIHYNUB24Qx8U8QFn2guEaI/KZgAAAOw=="""
self.correct_img = PhotoImage(data=correct)
self.wrong_img = PhotoImage(data=wrong)
self.entry = Entry(self.parent, width=15,
font=('Helvetica', 20, 'normal'), justify=CENTER)
self.entry.bind("<Return>", lambda x:self.buttonSubmit.invoke())
self.buttonNext = Button(self.parent, width=10, text="Next Word",
command=self.next_word, state=DISABLED)
self.buttonSubmit = Button(self.parent, width=10, text="Submit",
command=self.submit_word)
buttonReplay = Button(self.parent, width=10, text="Repeat Word",
command=self.replay_word)
self.game_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.word_display = self.game_canvas.create_text((300, 105), text="?",
font=("Helvetica", 50, "bold"), fill="#004183")
self.progress_display = self.game_canvas.create_text((593, 5),
text="%d/%d"%(1, self.parent.list_length),
font=("Helvetica", 25, "bold"), anchor=NE)
self.timer_display = self.game_canvas.create_text(10, 5, anchor=NW,
font=("Helvetica", 25))
self.progress_bar = ProgressBar(self, width=300,
increments=len(self.parent.current_list.words))
self.game_canvas.create_window(500, 10, anchor=NE, window=self.progress_bar)
self.game_canvas.create_window(300, 180, window=self.entry)
self.game_canvas_image = self.game_canvas.create_image(500, 170)
self.game_canvas.create_window(150, 230, window=buttonReplay)
self.game_canvas.create_window(300, 230, window=self.buttonSubmit)
self.game_canvas.create_window(450, 230, window=self.buttonNext)
self.game_canvas.pack()
def start(self):
self.current_list_iter = iter(self.parent.current_list.words)
self.current_word = self.current_list_iter.next()
self.parent.festival.speech(self.current_word)
self.time_elapsed = 0
self.init_gui()
self.tick()
def next_word(self):
try:
self.current_word = self.current_list_iter.next()
index = self.parent.current_list.words.index(self.current_word) + 1
self.game_canvas.itemconfig(self.progress_display, text="%d/%d"
%(index, self.parent.list_length))
if index == self.parent.list_length:
self.buttonNext.configure(text="Finish")
self.game_canvas.itemconfig(self.word_display, text="?", fill="#004183")
self.game_canvas.itemconfig(self.game_canvas_image, state=HIDDEN)
self.buttonSubmit.configure(state=NORMAL)
self.buttonNext.configure(state=DISABLED)
self.parent.festival.speech(self.current_word)
except StopIteration:
self.list_complete()
def list_complete(self):
self.parent.after_cancel(self.timer)
self.parent.show_results(self.time_elapsed)
def replay_word(self):
self.parent.festival.speech(self.current_word)
def submit_word(self, event=None):
guess = self.entry.get()
self.entry.delete(0, END)
if guess == self.current_word.word:
self.correct(guess)
else:
self.incorrect(guess)
self.game_canvas.itemconfig(self.word_display, text='%s'%(self.current_word))
self.buttonNext.configure(state=NORMAL)
self.buttonSubmit.configure(state=DISABLED)
self.game_canvas.itemconfig(self.game_canvas_image, state=NORMAL)
def correct(self, guess):
self.current_word.setAnswer(guess, True)
self.game_canvas.itemconfig(self.game_canvas_image, image=self.correct_img)
self.game_canvas.itemconfig(self.word_display, fill="#139E1C")
self.progress_bar.increment(True)
def incorrect(self, guess):
self.current_word.setAnswer(guess, False)
self.game_canvas.itemconfig(self.game_canvas_image, image=self.wrong_img)
self.game_canvas.itemconfig(self.word_display, fill="#F30000")
self.progress_bar.increment(False)
def tick(self):
seconds = (self.time_elapsed)%60
minutes = self.time_elapsed/60
separator = ":" if seconds > 9 else ":0"
formatted_time = "%d%s%d"%(minutes, separator, seconds)
self.game_canvas.itemconfig(self.timer_display, text=formatted_time)
self.time_elapsed +=1
self.timer = self.parent.after(1000, self.tick)
gen_root.geometry(config_string)
gen_cell_size = 20
gen_canvas = Canvas(gen_root, height=gen_height)
gen_canvas.pack(fill=BOTH)
gen_field_height = gen_height / gen_cell_size
gen_field_width = gen_width / gen_cell_size
# Make a 2D array of cell
gen_cell_matrix = []
for i in xrange(gen_field_height):
for j in xrange(gen_field_width):
# Create a cell
gen_square = gen_canvas.create_rectangle(2 + gen_cell_size*j, 2 + gen_cell_size*i, gen_cell_size + gen_cell_size*j - 2, gen_cell_size + gen_cell_size*i - 2, fill=gen_color)
# Make this cell hidden
gen_canvas.itemconfig(gen_square, state=HIDDEN, tags=('hid', '0'))
gen_cell_matrix.append(gen_square)
# It is a dummy element, it's kind of out of the box everywhere
gen_fict_square = gen_canvas.create_rectangle(0, 0, 0, 0, state=HIDDEN, tags=('hid', '0'))
gen_cell_matrix.append(gen_fict_square)
# Add glider
gen_canvas.itemconfig(gen_cell_matrix[gen_addr(3, 3)], state=NORMAL, tags='vis')
gen_canvas.itemconfig(gen_cell_matrix[gen_addr(3, 4)], state=NORMAL, tags='vis')
gen_canvas.itemconfig(gen_cell_matrix[gen_addr(3, 5)], state=NORMAL, tags='vis')
gen_canvas.itemconfig(gen_cell_matrix[gen_addr(4, 2)], state=NORMAL, tags='vis')
gen_canvas.itemconfig(gen_cell_matrix[gen_addr(4, 3)], state=NORMAL, tags='vis')
gen_canvas.itemconfig(gen_cell_matrix[gen_addr(4, 4)], state=NORMAL, tags='vis')
# Add board. It is diferent representation the game fild
board = set()
class carGUI:
carDict = {}
carIDs = []
def __init__(self, master):
self.master = master
master.title("A simple GUI")
# Initialize Canvas
self.canv = Canvas(master)
self.canv.pack(fill='both', expand=True)
# Initialize X-Lane
self.xTop = self.canv.create_line(0,
470,
1000,
470,
fill='black',
tags=('top'))
self.xBottom = self.canv.create_line(0,
510,
1000,
510,
fill='black',
tags=('left'))
# Initialize Y-Lane
self.yLeft = self.canv.create_line(470,
0,
470,
1000,
fill='blue',
tags='right')
self.yRight = self.canv.create_line(510,
0,
510,
1000,
fill='blue',
tags='bottom')
# Highlight Intersection
self.rect = self.canv.create_rectangle(470,
470,
510,
510,
fill='green')
# Show Regulation Lines
self.xLimit = self.canv.create_line(470 - 40,
450,
470 - 40,
530,
fill="red")
self.yLimit = self.canv.create_line(450,
470 - 40,
530,
470 - 40,
fill="red")
# Create button to begin simulation
b = Button(text="Start Simluation!", command=self.simClickListener)
b.pack()
# Create checkbox to differentiate real world sim from autonomous sim
self.CheckVar = IntVar()
self.checkConventional = Checkbutton(text="Conventional System", variable=self.CheckVar, \
onvalue=1, offvalue=0, height=5)
self.checkConventional.pack()
# Create text fields to show first in queue cars
self.carDisplayX = self.canv.create_text(10,
10,
anchor="nw",
fill="red")
self.carDisplayY = self.canv.create_text(600,
10,
anchor="nw",
fill="black")
def drawCar(self, lane, ID):
if (lane == 1):
# Draw an X car
self.rect = self.canv.create_rectangle(0,
485,
10,
495,
fill='black')
elif (lane == 2):
# Draw a Y car
self.rect = self.canv.create_rectangle(485, 0, 495, 10, fill='red')
self.canv.addtag_below(self.rect, "HELLO")
# Register the ID of the car
self.carIDs.append(ID)
# Ad the key value pair to the car dictionary for the GUI
self.carDict[ID] = self.rect
def moveCars(self, carList, timeInterval):
self.master.update_idletasks() # THIS UPDATES THE GUI
for i in range(0, len(carList)):
self.canv.move(self.carDict[carList[i].ID],
carList[i].velocityX * timeInterval,
carList[i].velocityY * timeInterval)
def highlightCar(self, car, color):
self.canv.itemconfig(self.carDict[car.ID], fill=color)
def simClickListener(self):
from Simulation import simulation as sim
sim(self)
def updateCarInformationDisplay(self, car):
carData = "position X = " + str(car.positionX) + "\nposition Y = " + \
str(car.positionY) + "\nvelocity X = " + str(car.velocityX) + \
"\nvelocity Y = " + str(car.velocityY)
if (car.velocityX > 0):
self.canv.itemconfig(self.carDisplayX, text=carData)
else:
self.canv.itemconfig(self.carDisplayY, text=carData)
class TronClient(object):
"""non-threadsafe client which mimics the Turing API"""
OUTCOME="tie","win","lose","tie"
def __init__(self,*args):
self._t=self._x=self._y=self.t=self.x=self.y=-1
self.outcome="ongoing"
self.sock=None
self.full=[[False]*49 for _ in xrange(50)]
self.show=False
self.root=self.cvs=None
self.dropped=0
if args:
self.start(*args)
def start(self,user=None,pw=None,host="",port=PORT):
if isinstance(user,str)and not isinstance(pw,str):
user,pw,host,port=None,None,user,pw if pw is not None else port
self.sock=create_connection((host,port))
setsockopt(self.sock,option=TCP_NODELAY)
buf=""
if user is not None:
buf+='L'+pack(STRUCT_UP_LOGIN,user,pw)
buf+='S'
self.sock.sendall(buf)
startlogin=start
def _recv(self):
self._t,self._x,self._y,a=unpack(STRUCT_DOWN_FRAME,self.sock.recv(calcsize(STRUCT_DOWN_FRAME)))
setsockopt(self.sock)
self._t-=1
self._x-=1
self._y-=1
if self._x!=-1:
self.t=self._t+1
if self._t>1 and(self.x!=self._x or self.y!=self._y):
self.dropped+=1
self.x=self._x
self.y=self._y
else:
self._close()
outcome=self.OUTCOME[self._y+1]
self.__init__()
self.outcome=outcome
for i in xrange(50):
for j in xrange(49):
k=i*49+j
self.full[i][j]=(ord(a[k/8])>>(k%8))&1==1
if self.show:
if not self.root:
self.root=Tk()
self.root.resizable(0,0)
self.root.protocol("WM_DELETE_WINDOW",self._close)
self.root.wm_title(argv[0])
self.cvs=Canvas(self.root,width=201,height=197,highlightthickness=0)
self.cvs.pack()
self.rects=[[self.cvs.create_rectangle(4*i,4*j,4*(i+1),4*(j+1))for j in reversed(xrange(49))]for i in xrange(50)]
for i in xrange(50):
for j in xrange(49):
self.cvs.itemconfig(self.rects[i][j],fill="#088"if i==self.x and j==self.y else"#ccc"if self.full[i][j]else"white")
self.root.update()
elif self.root:
self.root.destroy()
self.root=self.cvs=self.rects=None
def ended(self):
if not self.sock:
return True
err=False
if self.t>=0:
assert abs(self._x-self.x)+abs(self._y-self.y)<=self.t-self._t and(self.t!=self._t+1 or(self._x-self.x)**2+(self._y-self.y)**2==1)
try:
self.sock.sendall(pack(STRUCT_UP_MOVE,self.t+1,self.x+1,self.y+1))
except IOError:
err=True
try:
self._recv()
except IOError:
err=True
if err:
self._close()
return not self.sock
def _close(self):
if self.sock:
try:
self.sock.shutdown(SHUT_RDWR)
except error:
pass
try:
self.sock.close()
except:
pass
self.sock=None
def __iter__(self):
while not self.ended():
yield self
def __repr__(self):
return"<"+self.__class__.__name__+"@%(dropped)d/%(t)d (%(x)d,%(y)d) %(outcome)s>"%self.__dict__
class PlayerApp(Frame):
def __init__(self, root, player):
Frame.__init__(self, root)
self.root = root
self.config(bd=0, bg='black', highlightbackground='black')
self.pack()
self._canvas = Canvas(root,
width=(WIN_WIDTH),
height=WIN_HEIGHT,
bd=0,
bg='black',
highlightbackground='black')
self._canvas.pack()
self.player = player
self._img_mode = 4
self._img_mode_count = 6
# Scale the size to with the entire width of our window.
# TODO(igorc): Avoid scaling? Or auto-rescale when window resizes.
frame1_size = self.player.get_frame_size()
img1_aspect = frame1_size[0] / 2 / frame1_size[1]
img1_width = int(WIN_WIDTH * 0.95)
self._img1_size = (img1_width, int(img1_width / img1_aspect))
if self.player.is_fin_enabled() or self.player.is_kinect_enabled():
text_y = 0.07
img1_y = 0.28
img2_y = 0.56
else:
text_y = 0.04
img1_y = 0.23
img2_y = 0.54
# Undo gamma correction in LED preview, otherwise it is too dark.
# Keep a fixed value to have better feedback on LED gamma changes.
left_x = int(WIN_WIDTH * 0.025)
self._img1 = ImageTk.PhotoImage('RGBA', self._img1_size, gamma=2.2)
self._img2 = ImageTk.PhotoImage('RGBA', self._img1_size)
self._canvas.create_image(left_x,
int(WIN_HEIGHT * img1_y),
anchor='nw',
image=self._img1)
self._canvas.create_image(left_x,
int(WIN_HEIGHT * img2_y),
anchor='nw',
image=self._img2)
if self.player.is_fin_enabled():
img3_width = int(WIN_WIDTH * 0.15)
# The fin dimensions are 150x240 inches.
self._img3_size = (img3_width, int(img3_width * 1.1))
self._img3 = ImageTk.PhotoImage('RGBA', self._img3_size, gamma=2.2)
left_scale = 0.60 if self.player.is_kinect_enabled() else 0.65
self._canvas.create_image(int(WIN_WIDTH * left_scale),
int(WIN_HEIGHT * 0.05),
anchor='nw',
image=self._img3)
if self.player.is_kinect_enabled():
img4_width = int(WIN_WIDTH * 0.15)
self._img4_size = (img4_width, int(img4_width * 0.7))
self._img4 = ImageTk.PhotoImage('RGB', self._img4_size, gamma=2.2)
self._canvas.create_image(int(WIN_WIDTH * 0.8),
int(WIN_HEIGHT * 0.08),
anchor='nw',
image=self._img4)
self._main_label = self._canvas.create_text(
(left_x, WIN_HEIGHT * text_y),
fill='#fff',
anchor='nw',
justify='left',
font=("Sans Serif", 16))
self._canvas.itemconfig(self._main_label, text="this is the text")
self.root.bind('q', lambda e: player.volume_up())
self.root.bind('a', lambda e: player.volume_down())
self.root.bind('m', lambda e: self.switch_mask())
self.root.bind('g', lambda e: player.gamma_up())
self.root.bind('b', lambda e: player.gamma_down())
self.root.bind('h', lambda e: player.visualization_volume_up())
self.root.bind('n', lambda e: player.visualization_volume_down())
self.root.bind('v', lambda e: player.toggle_visualization())
self.root.bind('t', lambda e: self.toggle_visualizer_render())
self.root.bind('d', lambda e: player.toggle_hdr_mode())
self.root.bind('o', lambda e: player.select_next_preset(False))
self.root.bind('p', lambda e: player.select_next_preset(True))
self.root.bind('l', lambda e: player.lock_screen())
self.root.bind('0', lambda e: player.stop_effect())
self.root.bind('1', lambda e: player.play_effect('slowblink'))
self.root.bind('2', lambda e: player.play_effect('radiaterainbow'))
self.root.bind('3', lambda e: player.play_effect('threesine'))
self.root.bind('4', lambda e: player.play_effect('plasma'))
self.root.bind('5', lambda e: player.play_effect('rider'))
self.root.bind('6', lambda e: player.play_effect('flame'))
self.root.bind('7', lambda e: player.play_effect('glitter'))
self.root.bind('8', lambda e: player.play_effect('slantbars'))
self.root.bind('9', lambda e: player.play_effect('textticker'))
self.root.bind('!', lambda e: player.play_effect('solidcolor'))
self.root.bind('@', lambda e: player.play_effect('randompixels'))
self.root.bind('#', lambda e: player.play_effect('teststripes'))
self.root.bind('$', lambda e: player.play_effect('blink'))
self.root.bind('%', lambda e: player.play_effect('chameleon'))
self.root.bind('^', lambda e: player.play_effect('indicator'))
self.root.bind('&', lambda e: player.play_effect('flick'))
self.root.bind('*', lambda e: player.play_effect('textstay'))
self.root.bind('<space>', lambda e: player.toggle())
self.root.bind('<Up>', lambda e: player.prev())
self.root.bind('<Down>', lambda e: player.next())
self.root.bind('<Left>', lambda e: player.skip_backward())
self.root.bind('<Right>', lambda e: player.skip_forward())
self.root.protocol('WM_DELETE_WINDOW', lambda: self.quit())
self.root.after(1000 / FPS / 4, lambda: self.update())
self.running = True
def run_effect(self, effect):
self.player.effect = effect
def switch_mask(self):
self._img_mode += 1
self._img_mode = self._img_mode % self._img_mode_count
def toggle_visualizer_render(self):
if (self._img_mode % 3) == 0:
self._img_mode += 1
elif (self._img_mode % 3) == 2:
self._img_mode += 2
else:
self._img_mode += 2
self._img_mode = self._img_mode % self._img_mode_count
def quit(self):
self.running = False
def _paste_images(self, images, mode):
# Always use LED image as the first image.
frame1 = images[2].copy() if images[2] else None
frame3 = images[3].copy() if images[3] else None
frame4 = images[4].copy() if images[4] else None
crop_rect = None
frame_size = self.player.get_frame_size()
if mode < 3:
crop_rect = (0, 0, frame_size[0] / 2, frame_size[1])
else:
crop_rect = (frame_size[0] / 2, 0, frame_size[0], frame_size[1])
if frame1:
frame1 = frame1.crop(crop_rect)
if (mode % 3) == 0:
# Second is intermediate image by default.
frame2 = images[1].copy() if images[1] else None
if frame2:
frame2 = frame2.crop(crop_rect)
elif (mode % 3) == 1:
# Otherwise show original image.
frame2 = images[0].copy() if images[0] else None
if frame2 and mode >= 3:
frame2 = frame2.transpose(Image.FLIP_LEFT_RIGHT)
else:
# Show black if disabled.
frame2 = Image.new('RGBA', self._img1_size, (0, 0, 0, 0))
if frame1:
self._img1.paste(frame1.resize(self._img1_size))
if frame2:
self._img2.paste(frame2.resize(self._img1_size))
if frame3:
# Dorsal fin
self._img3.paste(frame3.resize(self._img3_size))
if frame4:
# Kinect
self._img4.paste(frame4.resize(self._img4_size))
def update(self):
try:
mode = self._img_mode
if (mode % 3) == 1 and self.player.is_playing_effect():
mode -= 1
need_original = (mode % 3) == 1
need_intermediate = (mode % 3) == 0
images = self.player.get_frame_images(need_original,
need_intermediate)
if images:
self._paste_images(images, mode)
status_lines = self.player.get_status_lines()
self._canvas.itemconfig(self._main_label,
text='\n'.join(status_lines))
# TODO(igorc): Reschedule after errors.
self.root.after(1000 / FPS / 4, lambda: self.update())
except KeyboardInterrupt:
self.quit()
class SudokuGraphicalUserInterface(Interface, Frame):
"""GUI class for the PAC Sudoku game."""
def __init__(self, config_file_handler, master=None):
"""Builds and initializes the GUI as a Interface type if instance.
First, the Interface instance attributes are created, additionally
the following instance attributes are created:
solve_action_set -- Set of methods for the solve menu actions
settings_action_set -- Set of methods for the settings menu actions
play_action_set -- Set of methods for the play menu actions
gui_builder -- Set of methods for building the PAC Sudoku GUI
config_file -- XMLFileHandler object with the config file loaded
interactive -- Sudokuinteractive initialized as None
violation -- Violation flag set to False
currently_editing -- Canvas image ID of a square initialized as None
timer -- Sudoku timer
_timer_increment -- Used to increment by 1 second the timer
"""
Interface.__init__(self, config_file_handler)
self.solve_action_set = SudokuGUISolveActionSet(self)
self.settings_action_set = SudokuGUISettingsActionSet(self)
self.play_action_set = SudokuGUIPlayActionSet(self)
self.gui_builder = SudokuGUIBuilder(self)
self.config_file = config_file_handler
self.interactive = None
self.violation = False
self.currently_editing = None
self.timer = datetime(1900, 1, 1)
self._timer_increment = timedelta(seconds=1)
Frame.__init__(self, master)
self.pack()
self._create_widgets()
def run(self):
"""Starts the graphical User Interface for the PAC Sudoku game."""
print "\n\nStarting the graphical user interface ..."
self.master.title("PAC Sudoku")
self.master.minsize(362, 462)
self.master.protocol("WM_DELETE_WINDOW", self.quit_handler)
self.mainloop()
def start_interactive_mode(self):
"""Initializes the interactive mode for solving sudokus.
A new Sudokuinteractive instance is created since which will
be handled all interactive actions.
Additionally 2 new event bindings will be used:
Left Mouse Button: For selecting a square in the sudoku field.
Key Pressed: For populating the selected square.
And one new instance attribute is created:
last_game_start -- Records the start time of the new game.
"""
self.reset_interactive()
self.interactive = SudokuInteractive(self.input_matrix.first_matrix)
self.sudoku_canvas.bind("<Button-1>", self._init_update_square)
self.sudoku_canvas.bind_all(
"<Key>",
self.play_action_set.update_square_action
)
self.last_game_start = self.interactive.game_start()
self._init_update_time()
def continue_interactive_mode(self, memory_pos):
"""Initializes the interactive mode for saved sudokus.
Any Sudokuinteractive instance need to be reset, afterwards
memory.pos will be read from interactive.memory to get time
and input matrix. Interactive.matrix will also be restored
according to memory data.
"""
previous_time, interactive_matrix, input_matrix, name = \
self.interactive.load_game(memory_pos)
if not interactive_matrix:
return False
self._reset_input_matrix()
self.input_matrix = MatrixHandler(input_matrix)
self.reset_interactive()
self.interactive = SudokuInteractive(input_matrix)
del(self.interactive.matrix)
self.interactive.matrix = MatrixHandler(interactive_matrix)
self.build_squares_from_interactive_matrix()
self.sudoku_canvas.bind("<Button-1>", self._init_update_square)
self.sudoku_canvas.bind_all(
"<Key>",
self.play_action_set.update_square_action
)
self.last_game_start = time.clock() - previous_time
self.timer += timedelta(seconds=int(previous_time))
self._init_update_time()
return True
def build_squares_from_input_matrix(self):
"""Draws a new sudoku from input_matrix and starts interactive mode.
Once a sudoku has been loaded or generated, draw the sudoku canvas
with fix squares for the numbers fix numbers in input_matrix using
small GIF images built by gui_builder. The zeroes are left blank.
This method also creates a new instance attribute:
square_item_matrix -- 9x9 matrix containing all canvas image item IDs
"""
self.square_item_matrix = []
for i in range(9):
current_square_item_list = []
for j in range(9):
current_square_item_list.append(
self.sudoku_canvas.create_image(
40 * j + 22,
40 * i + 22,
image=self.list_fix_squares[
self.input_matrix.first_matrix[i][j]
]
)
)
self.square_item_matrix.append(current_square_item_list)
def build_squares_from_interactive_matrix(self):
"""Draws a saved sudoku and starts interactive mode.
Once a sudoku has been loaded or generated, draw the sudoku canvas
with fix squares for the numbers fix numbers in input_matrix and
draw open numbers for the numbers in saved sudoku using
interactive.matrix.
This method also creates a new instance attribute:
square_item_matrix -- 9x9 matrix containing all canvas image item IDs
"""
self.square_item_matrix = []
for i in range(9):
current_square_item_list = []
for j in range(9):
input_value = self.input_matrix.first_matrix[i][j]
interactive_value = self.interactive.matrix.first_matrix[i][j]
if input_value:
target_square = self.list_fix_squares[input_value]
else:
target_square = self.list_open_squares[interactive_value]
current_square_item_list.append(
self.sudoku_canvas.create_image(
40 * j + 22,
40 * i + 22,
image=target_square
)
)
self.square_item_matrix.append(current_square_item_list)
def reset_interactive(self):
"""Terminates interactive mode.
Instance attribute interactive is set to None and events created by
start_interactive_mode are disabled.
Also violation and currently_editing instance attributes are reset.
"""
if self.interactive is not None:
self._reset_time()
del(self.interactive)
self.violation = False
self.currently_editing = None
self.interactive = None
self.sudoku_canvas.unbind("<Button-1>")
self.sudoku_canvas.unbind_all("<Key>")
def reset_display(self):
"""Cleans the canvas and resets timer and input_matrix."""
self._reset_input_matrix()
self.sudoku_canvas.destroy()
self.sudoku_canvas = Canvas(
self.sudoku_frame,
width=360,
height=360,
bg="white"
)
self.sudoku_canvas.pack(side="top")
self.sudoku_canvas.create_line(122, 0, 122, 362, width=2)
self.sudoku_canvas.create_line(242, 0, 242, 362, width=2)
self.sudoku_canvas.create_line(0, 122, 362, 122, width=2)
self.sudoku_canvas.create_line(0, 242, 362, 242, width=2)
self.timer = datetime(1900, 1, 1)
self.time_label.configure(text=self.timer.strftime("%H:%M:%S"))
def _create_widgets(self):
"""Calls the gui_builder methods to build the PAC Sudoku GUI"""
self.gui_builder.build_gui_frames()
self.gui_builder.build_top_frame_content()
self.gui_builder.build_main_frame_content()
self.gui_builder.build_bottom_frame_content()
def _reset_time(self):
"""Resets the sudoku timer.
Protected attribute _job may not exist at this point. Handle
this gracefully.
"""
try:
self.after_cancel(self._job)
del(self._job)
except AttributeError:
pass
del(self.timer)
self.timer = datetime(1900, 1, 1)
def _init_update_square(self, event):
"""Starts the process to update a clicked square in the sudoku canvas.
This method is launched with the Left Mouse Button event in
interactive mode.
The clicked square will be updated with a edit_* image corresponding:
edit_empty -- If the user did not add a number to it.
edit_number -- If the user previously add a number to it.
If a previous square was highlighted for edit, turn it back to:
blank -- If the user did not add any number to it
number -- If the user add a number to it
If a violation is found, or the game is not in interactive mode, or
the user is trying to update a fix square, this method won't do
anything.
"""
if self.violation:
return None
if self.interactive is None:
return None
self._set_clicked_square_position_in_canvas()
row = self.current_square_y
column = self.current_square_x
if self.input_matrix.first_matrix[row][column] != 0:
return None
to_edit = self.square_item_matrix[row][column]
current_digit = self.interactive.matrix.first_matrix[row][column]
if self.currently_editing is not None:
self.sudoku_canvas.itemconfig(
self.currently_editing,
image=self.list_open_squares[self.last_digit]
)
self.currently_editing = to_edit
self.last_digit = current_digit
self.sudoku_canvas.itemconfig(
to_edit,
image=self.list_edit_squares[current_digit]
)
def _init_update_time(self):
"""Starts the process to update timer each second."""
self.time_label.configure(text=self.timer.strftime("%H:%M:%S"))
self.timer += self._timer_increment
self._job = self.after(1000, self._init_update_time)
def _set_clicked_square_position_in_canvas(self):
"""Set square coordinates in the canvas after clicking on one.
Two new instance attributes are created:
current_square_x -- column in the sudoku canvas of clicked square
current_square_y -- row in the sudoku canvas of clicked square
"""
pionterx = self.sudoku_canvas.winfo_pointerx()
piontery = self.sudoku_canvas.winfo_pointery()
rootx = self.sudoku_canvas.winfo_rootx()
rooty = self.sudoku_canvas.winfo_rooty()
self.current_square_x = (pionterx - rootx)//40
self.current_square_y = (piontery - rooty)//40
def quit_handler(self):
"""Handler for verifying if changes to config should be saved."""
selection = False
if self.config_changes_not_saved(self.config_file):
selection = tkMessageBox.askyesno(
"Changes to Config settings not saved",
"Changes to config settings have not been saved.\n" +
"Would you like to save settings before closing?"
)
if selection:
self.settings_action_set.save_settings_action()
self.quit()
class histogramWidget:
BACKGROUND = "#222222"
EDGE_HISTOGRAM_COLOR = "#999999"
NODE_HISTOGRAM_COLOR = "#555555"
TOOLTIP_COLOR="#FFFF55"
PADDING = 8
CENTER_WIDTH = 1
CENTER_COLOR = "#444444"
ZERO_GAP = 1
UPDATE_WIDTH = 9
UPDATE_COLOR = "#FFFFFF"
HANDLE_WIDTH = 5
HANDLE_COLOR = "#FFFFFF"
HANDLE_LENGTH = (HEIGHT-2*PADDING)
TICK_COLOR = "#FFFFFF"
TICK_WIDTH = 10
TICK_FACTOR = 2
LOG_BASE = 10.0
def __init__(self, parent, x, y, width, height, data, logScale=False, callback=None):
self.canvas = Canvas(parent,background=histogramWidget.BACKGROUND, highlightbackground=histogramWidget.BACKGROUND,width=width,height=height)
self.canvas.place(x=x,y=y,width=width,height=height,bordermode="inside")
self.logScale = logScale
self.callback = callback
self.edgeBars = []
self.nodeBars = []
self.binValues = []
self.numBins = len(data) - 1
self.currentBin = self.numBins # start the slider at the highest bin
edgeRange = 0.0
nodeRange = 0.0
for values in data.itervalues():
if values[0] > edgeRange:
edgeRange = values[0]
if values[1] > nodeRange:
nodeRange = values[1]
edgeRange = float(edgeRange) # ensure that it will yield floats when used in calculations...
nodeRange = float(nodeRange)
if logScale:
edgeRange = math.log(edgeRange,histogramWidget.LOG_BASE)
nodeRange = math.log(nodeRange,histogramWidget.LOG_BASE)
# calculate the center line - but don't draw it yet
self.center_x = histogramWidget.PADDING
if self.logScale:
self.center_x += histogramWidget.TICK_WIDTH+histogramWidget.PADDING
self.center_y = height/2
self.center_x2 = width-histogramWidget.PADDING
self.center_y2 = self.center_y + histogramWidget.CENTER_WIDTH
# draw the histograms with background-colored baseline rectangles (these allow tooltips to work on very short bars with little area)
self.bar_interval = float(self.center_x2 - self.center_x) / (self.numBins+1)
bar_x = self.center_x
edge_y2 = self.center_y-histogramWidget.PADDING
edge_space = edge_y2-histogramWidget.PADDING
node_y = self.center_y2+histogramWidget.PADDING
node_space = (height-node_y)-histogramWidget.PADDING
thresholds = sorted(data.iterkeys())
for threshold in thresholds:
self.binValues.append(threshold)
edgeWeight = data[threshold][0]
nodeWeight = data[threshold][1]
if logScale:
if edgeWeight > 0:
edgeWeight = math.log(edgeWeight,histogramWidget.LOG_BASE)
else:
edgeWeight = 0
if nodeWeight > 0:
nodeWeight = math.log(nodeWeight,histogramWidget.LOG_BASE)
else:
nodeWeight = 0
bar_x2 = bar_x + self.bar_interval
edge_y = histogramWidget.PADDING + int(edge_space*(1.0-edgeWeight/edgeRange))
edge = self.canvas.create_rectangle(bar_x,edge_y,bar_x2,edge_y2,fill=histogramWidget.EDGE_HISTOGRAM_COLOR,width=0)
baseline = self.canvas.create_rectangle(bar_x,edge_y2+histogramWidget.ZERO_GAP,bar_x2,edge_y2+histogramWidget.PADDING,fill=histogramWidget.BACKGROUND,width=0)
self.canvas.addtag_withtag("Threshold: %f" % threshold,edge)
self.canvas.addtag_withtag("No. Edges: %i" % data[threshold][0],edge)
self.canvas.tag_bind(edge,"<Enter>",self.updateToolTip)
self.canvas.tag_bind(edge,"<Leave>",self.updateToolTip)
self.edgeBars.append(edge)
self.canvas.addtag_withtag("Threshold: %f" % threshold,baseline)
self.canvas.addtag_withtag("No. Edges: %i" % data[threshold][0],baseline)
self.canvas.tag_bind(baseline,"<Enter>",self.updateToolTip)
self.canvas.tag_bind(baseline,"<Leave>",self.updateToolTip)
node_y2 = node_y + int(node_space*(nodeWeight/nodeRange))
node = self.canvas.create_rectangle(bar_x,node_y,bar_x2,node_y2,fill=histogramWidget.NODE_HISTOGRAM_COLOR,width=0)
baseline = self.canvas.create_rectangle(bar_x,node_y-histogramWidget.PADDING,bar_x2,node_y-histogramWidget.ZERO_GAP,fill=histogramWidget.BACKGROUND,width=0)
self.canvas.addtag_withtag("Threshold: %f" % threshold,node)
self.canvas.addtag_withtag("No. Nodes: %i" % data[threshold][1],node)
self.canvas.tag_bind(node,"<Enter>",self.updateToolTip)
self.canvas.tag_bind(node,"<Leave>",self.updateToolTip)
self.nodeBars.append(node)
self.canvas.addtag_withtag("Threshold: %f" % threshold,baseline)
self.canvas.addtag_withtag("No. Nodes: %i" % data[threshold][1],baseline)
self.canvas.tag_bind(baseline,"<Enter>",self.updateToolTip)
self.canvas.tag_bind(baseline,"<Leave>",self.updateToolTip)
bar_x = bar_x2
# now draw the center line
self.centerLine = self.canvas.create_rectangle(self.center_x,self.center_y,self.center_x2,self.center_y2,fill=histogramWidget.CENTER_COLOR,width=0)
# draw the tick marks if logarithmic
if self.logScale:
tick_x = histogramWidget.PADDING
tick_x2 = histogramWidget.PADDING+histogramWidget.TICK_WIDTH
start_y = edge_y2
end_y = histogramWidget.PADDING
dist = start_y-end_y
while dist > 1:
dist /= histogramWidget.TICK_FACTOR
self.canvas.create_rectangle(tick_x,end_y+dist-1,tick_x2,end_y+dist,fill=histogramWidget.TICK_COLOR,width=0)
start_y = node_y
end_y = height-histogramWidget.PADDING
dist = end_y-start_y
while dist > 1:
dist /= histogramWidget.TICK_FACTOR
self.canvas.create_rectangle(tick_x,end_y-dist,tick_x2,end_y-dist+1,fill=histogramWidget.TICK_COLOR,width=0)
# draw the update bar
bar_x = self.currentBin*self.bar_interval + self.center_x
bar_x2 = self.center_x2
bar_y = self.center_y-histogramWidget.UPDATE_WIDTH/2
bar_y2 = bar_y+histogramWidget.UPDATE_WIDTH
self.updateBar = self.canvas.create_rectangle(bar_x,bar_y,bar_x2,bar_y2,fill=histogramWidget.UPDATE_COLOR,width=0)
# draw the handle
handle_x = self.currentBin*self.bar_interval-histogramWidget.HANDLE_WIDTH/2+self.center_x
handle_x2 = handle_x+histogramWidget.HANDLE_WIDTH
handle_y = self.center_y-histogramWidget.HANDLE_LENGTH/2
handle_y2 = handle_y+histogramWidget.HANDLE_LENGTH
self.handleBar = self.canvas.create_rectangle(handle_x,handle_y,handle_x2,handle_y2,fill=histogramWidget.HANDLE_COLOR,width=0)
self.canvas.tag_bind(self.handleBar, "<Button-1>",self.adjustHandle)
self.canvas.tag_bind(self.handleBar, "<B1-Motion>",self.adjustHandle)
self.canvas.tag_bind(self.handleBar, "<ButtonRelease-1>",self.adjustHandle)
parent.bind("<Left>",lambda e: self.nudgeHandle(e,-1))
parent.bind("<Right>",lambda e: self.nudgeHandle(e,1))
# init the tooltip as nothing
self.toolTipBox = self.canvas.create_rectangle(0,0,0,0,state="hidden",fill=histogramWidget.TOOLTIP_COLOR,width=0)
self.toolTip = self.canvas.create_text(0,0,state="hidden",anchor="nw")
self.canvas.bind("<Enter>",self.updateToolTip)
self.canvas.bind("<Leave>",self.updateToolTip)
def adjustHandle(self, event):
newBin = int(self.numBins*(event.x-self.center_x)/float(self.center_x2-self.center_x)+0.5)
if newBin == self.currentBin or newBin < 0 or newBin > self.numBins:
return
self.canvas.move(self.handleBar,(newBin-self.currentBin)*self.bar_interval,0)
self.currentBin = newBin
if self.callback != None:
self.callback(self.binValues[newBin])
def nudgeHandle(self, event, distance):
temp = self.currentBin+distance
if temp < 0 or temp > self.numBins:
return
self.canvas.move(self.handleBar,distance*self.bar_interval,0)
self.currentBin += distance
if self.callback != None:
self.callback(self.binValues[self.currentBin])
def update(self, currentBins):
currentBar = self.canvas.coords(self.updateBar)
self.canvas.coords(self.updateBar,currentBins*self.bar_interval+self.center_x,currentBar[1],currentBar[2],currentBar[3])
def updateToolTip(self, event):
allTags = self.canvas.gettags(self.canvas.find_overlapping(event.x,event.y,event.x+1,event.y+1))
if len(allTags) == 0:
self.canvas.itemconfig(self.toolTipBox,state="hidden")
self.canvas.itemconfig(self.toolTip,state="hidden")
return
outText = ""
for t in allTags:
if t == "current":
continue
outText += t + "\n"
outText = outText[:-1] # strip the last return
self.canvas.coords(self.toolTip,event.x+20,event.y)
self.canvas.itemconfig(self.toolTip,state="normal",text=outText,anchor="nw")
# correct if our tooltip is off screen
textBounds = self.canvas.bbox(self.toolTip)
if textBounds[2] >= WIDTH-2*histogramWidget.PADDING:
self.canvas.itemconfig(self.toolTip, anchor="ne")
self.canvas.coords(self.toolTip,event.x-20,event.y)
if textBounds[3] >= HEIGHT-2*histogramWidget.PADDING:
self.canvas.itemconfig(self.toolTip, anchor="se")
elif textBounds[3] >= HEIGHT-2*histogramWidget.PADDING:
self.canvas.itemconfig(self.toolTip, anchor="sw")
# draw the box behind it
self.canvas.coords(self.toolTipBox,self.canvas.bbox(self.toolTip))
self.canvas.itemconfig(self.toolTipBox, state="normal")
class ProgressBar:
def __init__(self, master=None, orientation="horizontal",
min=0, max=100, width=100, height=18,
doLabel=1, appearance="sunken",
fillColor="blue", background="gray",
labelColor="yellow", labelFont="Verdana",
labelText="", labelFormat="%d%%",
value=0, bd=2):
# preserve various values
self.master=master
self.orientation=orientation
self.min=min
self.max=max
self.width=width
self.height=height
self.doLabel=doLabel
self.fillColor=fillColor
self.labelFont= labelFont
self.labelColor=labelColor
self.background=background
self.labelText=labelText
self.labelFormat=labelFormat
self.value=value
self.frame=Frame(master, relief=appearance, bd=bd)
self.canvas=Canvas(self.frame, height=height, width=width, bd=0,
highlightthickness=0, background=background)
self.scale=self.canvas.create_rectangle(0, 0, width, height,
fill=fillColor)
self.label=self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
height / 2, text=labelText,
anchor="c", fill=labelColor,
font=self.labelFont)
self.update()
self.canvas.pack(side='top', fill='x', expand='no')
def updateProgress(self, newValue, newMax=None):
if newMax:
self.max = newMax
self.value = newValue
self.update()
def update(self):
# Trim the values to be between min and max
value=self.value
if value > self.max:
value = self.max
if value < self.min:
value = self.min
# Adjust the rectangle
if self.orientation == "horizontal":
self.canvas.coords(self.scale, 0, 0,
float(value) / self.max * self.width, self.height)
else:
self.canvas.coords(self.scale, 0,
self.height - (float(value) /
self.max*self.height),
self.width, self.height)
# Now update the colors
self.canvas.itemconfig(self.scale, fill=self.fillColor)
self.canvas.itemconfig(self.label, fill=self.labelColor)
# And update the label
if self.doLabel:
if value:
if value >= 0:
pvalue = int((float(value) / float(self.max)) *
100.0)
else:
pvalue = 0
self.canvas.itemconfig(self.label, text=self.labelFormat
% pvalue)
else:
self.canvas.itemconfig(self.label, text='')
else:
self.canvas.itemconfig(self.label, text=self.labelFormat %
self.labelText)
self.canvas.update_idletasks()
class Window(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, background="white")
self.parent = parent
self.initUI()
home='/home/little_light/Desktop/workspace/python/data/GSTRB'
modelFile=home+'/model/demo2.pkl'
input_var = T.tensor4('inputs',dtype=theano.config.floatX)
target_var = T.ivector('targets')
network,loss,params=build_2f(input_var,target_var,regularW=0.0001)
pvals=cPickle.load(open(modelFile))
[p.set_value(pval) for (p, pval) in zip(lasagne.layers.get_all_params(network), pvals)]
predict=lasagne.layers.get_output(network, deterministic=True)
input=lasagne.layers.get_all_layers(network)[0].input_var
#lasagne.layers.input.input
self.predict_fn=theano.function(inputs=[input],outputs=predict)
def initUI(self):
self.parent.title("Simple")
self.pack(fill=BOTH, expand=1)
self.tbImg=Entry(self.parent,width=50)
self.tbImg.place(x=10,y=10)
self.bLoad=Button(master=self,text="Load", command = self.load)
self.bLoad.pack()
self.bLoad.place(x=10,y=30)
self.canvas = Canvas(self, width=400, height=400)
self.canvas.pack()
fileName='/home/little_light/Desktop/workspace/python/data/GSTRB/Final_Training/Images/00000/00004_00029.ppm'
img = ImageTk.PhotoImage(Image.open(fileName))
self.canvas.image=img
self.image_on_canvas=self.canvas.create_image(0,0,image=img,anchor='nw')
self.canvas.place(x=10,y=60)
self.v = StringVar()
self.label=Label(master=self,textvariable=self.v)
self.v.set("Target label:")
self.label.place(x=10,y=470)
def load(self):
print "load"
fileName=self.tbImg.get()
img = ImageTk.PhotoImage(Image.open(fileName))
self.canvas.image=img
#self.canvas.create_image(0,0,image=img)
self.canvas.itemconfig(self.image_on_canvas, image =self.canvas.image)
img=Image.open(fileName)
img.load()
img2=img.resize((32,32))
img2.load()
data = np.asarray(img2, dtype="int32")
mean=86.2111433696
data=np.transpose(data,(2,0,1))
data=np.asarray((data-mean)/256.0,dtype=theano.config.floatX)
data2=np.zeros((1,3,32,32),dtype=theano.config.floatX)
data2[0]=data
data=data2
print np.argmax(self.predict_fn(data)[0])
self.v.set("Target label:"+str(np.argmax(self.predict_fn(data)[0])))
class App(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.levels = list()
self.signs = list()
self.items = [i for i in range(0,64)]
self.items.remove(16)
self.current_item = 0
self.parent = parent
self.max_width = 600
self.max_height = 600
self.client = Client()
self.initDimensions()
self.initUI()
self.event = None
self.reset_canvas()
def connect(self):
res = self.client.regis()
if(res == 1):
time.sleep(1)
self.connect_button.config(state = 'disabled')
self.disconnect_button.config(state = 'normal')
def disconnect(self):
self.client.close()
self.connect_button.config(state = 'normal')
self.disconnect_button.config(state = 'disabled')
def initDimensions(self):
self.canvas_width = self.max_width
self.canvas_height = self.max_height
self.rows = 10
self.cols = 10
# self.h = 1;
self.cellwidth = self.canvas_width/self.cols
self.cellheight = self.canvas_height/self.rows
self.initData()
def add_new_level(self):
temp=dict()
temp2 = dict()
self.levels.append(temp)
self.signs.append(temp2)
def insert_new_level(self, loc):
temp=dict()
temp2 = dict()
self.levels.insert(loc,temp)
self.signs.insert(loc,temp2)
def initData(self):
self.levels = list()
self.signs = list()
self.rect = dict()
self.rect_text = dict()
self.curr_level = 0
self.overlay_level = 0
self.overlayToggle = False
self.levels.append(dict())
self.signs.append(dict())
self.current_item = 1
def reset_canvas(self):
self.canvas.delete(ALL)
self.parent.title("Craft Builder: Dimensions: " + str(self.rows) + 'x' + str(len(self.levels)) +'x' + str(self.cols))
def redraw_overlay(self):
c = set(self.levels[self.overlay_level].keys())
if self.overlayToggle == 1:
for key in c:
x1 = key[1] * self.cellwidth
y1 = (self.rows - key[0] - 1) * self.cellheight
x2 = x1 + self.cellwidth
y2 = y1 + self.cellheight
if (key[0], key[1]) in self.rect:
self.canvas.itemconfig(self.rect[key[0],key[1]], width = OVERLAYWIDTH)
else:
self.rect[key[0],key[1]] = self.canvas.create_rectangle(x1,y1,x2,y2, fill='white', outline = 'black', width = OVERLAYWIDTH, tag = 'block')
self.rect_text[key[0],key[1]] = self.canvas.create_text((x1+x2)/2,(y1+y2)/2, text = '', font=('verdana', 7), tag = 'blocktext')
def redraw_level(self):
# self.canvas.delete(ALL)
# self.rect=dict()
# self.rect_text = dict()
start = time.clock()
b = set(self.levels[self.curr_level].keys())
for key in b:
val = self.levels[self.curr_level][key]
if (key[0], key[1]) in self.rect:
self.canvas.itemconfig(self.rect[key[0],key[1]], fill = COLORS[val], outline = 'black', width = DEFAULTWIDTH)
self.canvas.itemconfig(self.rect_text[key[0],key[1]], text = val)
else:
x1 = key[1] * self.cellwidth
y1 = (self.rows - key[0] - 1) * self.cellheight
x2 = x1 + self.cellwidth
y2 = y1 + self.cellheight
self.rect[key[0],key[1]] = self.canvas.create_rectangle(x1,y1,x2,y2, fill = COLORS[val], outline = 'black', width = DEFAULTWIDTH, tag = 'block')
self.rect_text[key[0],key[1]] = self.canvas.create_text((x1+x2)/2,(y1+y2)/2, text = val, font=('verdana', 7), tag = 'blocktext')
items_to_remove = list()
for key in self.rect:
if key not in self.levels[self.curr_level]:
self.canvas.delete(self.rect[key[0],key[1]])
self.canvas.delete(self.rect_text[key[0],key[1]])
items_to_remove.append(key)
for i in items_to_remove:
self.rect.pop(i)
self.rect_text.pop(i)
self.parent.title("Craft Builder: Dimensions: " + str(self.rows) + 'x' + str(len(self.levels)) +'x' + str(self.cols))
self.redraw_overlay()
def updateDimensions(self,r,c,y=1):
self.rows = r
self.cols = c
self.cellwidth = self.max_width/self.cols
self.cellheight = self.max_height/self.rows
if(self.cellwidth<=self.cellheight):
self.cellheight = self.cellwidth
else:
self.cellwidth = self.cellheight
self.canvas_height = self.rows * self.cellheight
self.canvas_width = self.cols * self.cellwidth
self.canvas.config(width = self.canvas_width, height = self.canvas_height)
self.canvas.delete(ALL)
self.initData()
for i in range(y-1):
self.levels.append(dict())
self.signs.append(dict())
def altMenu(self, event):
# print "Keycode:", event.keycode, "State:", event.keysym, event.type
self.event = event
if event.type == '2':
self.altAction = True
self.clear_button.config(text = 'Multi Clear', bg = 'white')
self.delete_button.config(text = 'Multi Delete', bg='white')
self.insert_button.config(text = 'Multi Insert', bg='white')
self.copy_level_button.config(text = 'Multi Copy', bg = 'white')
elif event.type == '3':
defaultbg = self.parent.cget('bg')
self.altAction = False
self.clear_button.config(text = 'Clear Level', bg = defaultbg)
self.delete_button.config(text = 'Delete', bg = defaultbg)
self.insert_button.config(text = 'Insert', bg = defaultbg)
self.copy_level_button.config(text = 'Copy overlay level', bg = defaultbg)
sys.stdout.flush()
def initUI(self):
self.altAction = False
self.parent.title("Craft Builder")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=0)
self.columnconfigure(0, pad = 7)
self.columnconfigure(1, pad = 7)
self.columnconfigure(2, pad = 7)
self.columnconfigure(9, weight =1 )
self.columnconfigure(3, pad=7)
self.columnconfigure(5, pad=7)
self.rowconfigure(1, weight=1)
self.rowconfigure(5, pad=7)
self.rowconfigure(6, pad=7)
self.rowconfigure(7, pad=7)
self.rowconfigure(8, pad=7)
area = Frame(self, width=500, height=500, borderwidth = 2, relief = 'sunken')
area.grid(row=1, column=0, columnspan=11, rowspan=4,
padx=5, sticky=E+W+S+N)
self.canvas = Canvas(area, bg='white', width=self.canvas_width, height=self.canvas_height)
self.canvas.pack()
self.canvas.bind("<Button-1>", self.callbackLeftClick)
self.canvas.bind("<B1-Motion>", self.callbackLeftClick)
self.canvas.bind("<Button-3>", self.callbackRightClick)
self.canvas.bind("<B3-Motion>", self.callbackRightClick)
self.canvas.bind("<Button-5>", self.scrollWheel)
self.canvas.bind("<Button-4>", self.scrollWheel)
self.parent.bind("<Shift_L>", self.altMenu)
self.parent.bind("<KeyRelease-Shift_L>", self.altMenu)
self.new_button = Button(self, text="New", command = self.onNew, width = 6)
self.new_button.grid(row=5, column=0)
save_button = Button(self, text="Save", command = self.onSave, width = 6)
save_button.grid(row=6, column=0)
load_button = Button(self, text="Load", command = self.onLoad, width = 6)
load_button.grid(row=7, column=0)
self.connect_button = Button(self, text="Connect", command = self.connect, width = 6)
self.connect_button.grid(row=8, column=0)
self.clear_button = Button(self, text="Clear Level", command = self.onClear, width =8)
self.clear_button.grid(row=5, column=1)
self.delete_button = Button(self, text="Delete Level", command = self.onDelete, width =8)
self.delete_button.grid(row=6, column=1)
self.insert_button = Button(self, text="Insert Level", command = self.onInsertLevel, width =8)
self.insert_button.grid(row=7, column=1)
self.disconnect_button = Button(self, text="Disconnect", command = self.disconnect, width = 8)
self.disconnect_button.grid(row=8, column=1)
self.disconnect_button['state'] = 'disabled'
lbl_a = Label(self, text="Curr. Level", font=("Verdana", 10))
lbl_a.grid(row = 5, column = 2)
lbl_b = Label(self, text="Overlay Level", font=("Verdana", 10))
lbl_b.grid(row = 6, column = 2)
self.copy_level_button = Button(self, text="Copy overlay level", command = self.onCopy, width = 12)
self.copy_level_button.grid(row=7, column=2, columnspan=1)
load_world_button = Button(self, text="Load from world", command = self.onLoadFromWorld, width = 12)
load_world_button.grid(row=8, column=2)
self.currLevelCombo = Combobox(self, values = range(len(self.levels)), width = 5, state = 'readonly')
self.currLevelCombo.grid(row = 5, column = 3)
self.currLevelCombo.bind("<<ComboboxSelected>>", self.currLevelChooser)
self.currLevelCombo.set(0)
self.overlayLevelCombo = Combobox(self, values = range(len(self.levels)), width = 5, state = 'readonly')
self.overlayLevelCombo.grid(row = 6, column = 3)
self.overlayLevelCombo.bind("<<ComboboxSelected>>", self.overlayLevelChooser)
self.overlayLevelCombo.set(0)
self.new_level_button = Button(self, text="New Level", command = self.onNewLevel, width = 12)
self.new_level_button.grid(row=7, column=3,columnspan=1)
paste_button = Button(self, text="Paste in world", command = self.onPaste, width = 12)
paste_button.grid(row=8, column=3)
lbl_d = Label(self, text="Item", font=("Verdana", 10))
lbl_d.grid(row = 5, column = 4)
self.toggle = Checkbutton(self, text="Overlay Toggle", command = self.onToggle)
self.toggle.grid(row=6, column=4)
rotate_button = Button(self, text="Rotate", command = self.onRotate, width = 12)
rotate_button.grid(row=7, column=4,columnspan=1)
paste_sign_button = Button(self, text="Paste Signs", command = self.onPasteSign, width = 12)
paste_sign_button.grid(row=8, column=4)
self.itemCombo = Combobox(self, values = self.items, width = 5, state = 'readonly')
self.itemCombo.grid(row = 5, column = 5)
self.itemCombo.bind("<<ComboboxSelected>>", self.itemChooser)
self.itemCombo.set(1)
self.current_item = 1
self.lbl_e = Label(self, text="", font=("Verdana", 8), width = 12, relief = 'ridge')
self.lbl_e.grid(row = 6, column = 5)
add_geo_button = Button(self, text="Add Geometry", command = self.addGeo, width = 12)
add_geo_button.grid(row=8, column=5)
try:
global builder
import builder
except ImportError:
add_geo_button.config(state = 'disabled')
def scrollWheel(self, event):
if event.num == 5:
#scroll down
if self.curr_level==len(self.levels) -1:
pass
else:
self.curr_level = self.curr_level + 1
self.currLevelCombo.set(self.curr_level)
self.redraw_level()
else:
#scroll up
if self.curr_level == 0:
pass
else:
self.curr_level = self.curr_level - 1
self.currLevelCombo.set(self.curr_level)
self.redraw_level()
def onInsertLevel(self):
if self.altAction == 1:
self.w=popupWindow(self,title = "Enter num_levels to insert and level below which to insert\n" +
"seperated by a space.")
self.wait_window(self.w.top)
self.altAction = 0
data = self.w.value.split(' ')
try:
if len(data) == 2:
for i in range(int(data[0])):
self.insert_new_level(int(data[1]))
self.redraw_level()
else:
print 'Not enough arguments'
except ValueError:
print 'Error in values'
else:
self.insert_new_level(self.curr_level)
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
self.redraw_level()
def onCopy(self):
if self.altAction == 1:
self.w=popupWindow(self,title = "Enter the arguments start_level end_level num_times\n" +
"and level above which to copy, all seperated by spaces.")
self.wait_window(self.w.top)
self.altAction = 0
data = self.w.value.split(' ')
try:
if len(data) == 4:
st,sto = sorted((data[0],data[1]))
st = int(st)
sto = int(sto)
n = data[2]
l = int(data[3]) + 1
for i in range(int(n)):
for j in range(st, sto +1):
for col in range(self.cols):
for row in range(self.rows):
if (row,col) in self.levels[j]:
if l+j-st < len(self.levels) :
self.levels[l+j-st][row,col] = self.levels[j][row,col]
l = l +(sto-st+1)
else:
print 'Not enough arguments'
except ValueError:
print 'Error in values'
else:
for col in range(self.cols):
for row in range(self.rows):
if (row,col) in self.levels[self.overlay_level]:
self.levels[self.curr_level][row,col] = self.levels[self.overlay_level][row,col]
sys.stdout.flush()
self.redraw_level()
def onClear(self):
if self.altAction == 1:
self.w=popupWindow(self,title = "Enter the arguments start_level end_levels to clear\n" +
"seperated by a space.")
self.wait_window(self.w.top)
self.altAction = 0
data = self.w.value.split()
try:
if len(data) == 2:
st,sto = sorted((data[0],data[1]))
st = int(st)
sto = int(sto)
for i in range(st,sto+1):
if i < len(self.levels):
self.levels[i] = dict()
self.signs[i] = dict()
self.redraw_level()
else:
print 'Not enough arguments'
except ValueError:
print 'Error in values'
else:
if tkMessageBox.askquestion('Clear', "Clear Level: " + str(self.curr_level)) == 'yes':
self.levels[self.curr_level] = dict()
self.signs[self.curr_level] = dict()
self.redraw_level()
else:
pass
def onDelete(self):
if self.altAction == 1:
self.w=popupWindow(self,title = "Enter the arguments start_level end_levels to delete\n" +
"seperated by a space.")
self.wait_window(self.w.top)
self.altAction = 0
data = self.w.value.split()
try:
if len(data) == 2:
st,sto = sorted((data[0],data[1]))
st = int(st)
sto = int(sto)
for i in range(sto,st-1,-1):
if i < len(self.levels) and i >=0 and len(self.levels)>1:
self.levels.pop(i)
self.signs.pop(i)
elif i < len(self.levels) and i ==0 :
self.levels[i] = dict()
self.signs[i] = dict()
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
self.curr_level = 0
self.currLevelCombo.set(0)
self.overlayLevelCombo.set(0)
self.redraw_level()
else:
print 'Not enough arguments'
except ValueError:
print 'Error in values'
else:
if tkMessageBox.askquestion('Delete', "Delete Level: " + str(self.curr_level)) == 'yes':
if len(self.levels) == 1:
self.onClear()
else:
self.levels.pop(self.curr_level)
self.signs.pop(self.curr_level)
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
if self.overlayToggle == 1:
self.toggle.invoke()
self.overlayToggle = 0
if self.curr_level != 0:
self.curr_level = self.curr_level - 1
self.currLevelCombo.set(self.curr_level)
else:
self.currLevelCombo.set(self.curr_level)
self.redraw_level()
def addGeo(self):
self.w=popupWindow(self,title = "Enter Command: help for Help")
self.wait_window(self.w.top)
try:
c = self.w.value.split(' ')
if c[0] == 'help':
self.h = HelpWindow(self, title = 'Enter command followed by args seperated by spaces\n' +
'Available commands (sphere, pyramid, cuboid)\n' +
'1. pyramid x1 x2 y z1 z2 fill(0/1) \n' +
'2. sphere cx cy cz r fill(0/1) \n' +
'4. circle_x x y z r fill(0/1) \n' +
'5. circle_y x y z r fill(0/1) \n' +
'6. circle_z x y z r fill(0/1) \n' +
'7. cylinder_x x1 x2 y z r fill(0/1) \n' +
'8. cylinder_y x y1 y2 z r fill(0/1) \n' +
'9. cylinder_z x y z1 z2 r fill(0/1) \n' +
'10. cuboid x1 x2 y1 y2 z1 z2 fill(0/1) \n' )
elif c[0] == 'sphere':
if len(c) - 1 == 5:
result = builder.sphere(int(c[1]),int(c[2]),int(c[3]),int(c[4]),int(c[5]))
for i in result:
if i[1] < len(self.levels) and i[1] >=0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'pyramid':
if len(c) - 1 == 6:
result = builder.pyramid(int(c[1]),int(c[2]),int(c[3]),int(c[4]),int(c[5]),int(c[6]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'circle_x':
if len(c) - 1 == 5:
result = builder.circle_x(int(c[1]),int(c[2]),int(c[3]),int(c[4]),int(c[5]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'circle_y':
if len(c) - 1 == 5:
result = builder.circle_y(int(c[1]),int(c[2]),int(c[3]),int(c[4]),int(c[5]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'circle_z':
if len(c) - 1 == 5:
result = builder.circle_z(int(c[1]),int(c[2]),int(c[3]),int(c[4]),int(c[5]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'cylinder_x':
if len(c) - 1 == 6:
x1,x2 = sorted([int(c[1]),int(c[2])])
result = builder.cylinder_x(x1,x2,int(c[3]),int(c[4]),int(c[5]),int(c[6]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'cylinder_y':
if len(c) - 1 == 6:
y1,y2 = sorted([int(c[2]),int(c[3])])
result = builder.cylinder_y(int(c[1]),y1,y2,int(c[4]),int(c[5]),int(c[6]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'cylinder_z':
if len(c) - 1 == 6:
z1,z2 = sorted([int(c[3]),int(c[4])])
result = builder.cylinder_z(int(c[1]),int(c[2]),z1,z2,int(c[5]),int(c[6]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
elif c[0] == 'cuboid':
if len(c) - 1 == 7:
result = builder.cuboid(int(c[1]),int(c[2]),int(c[3]),int(c[4]),int(c[5]),int(c[6]),int(c[7]))
for i in result:
if i[1] < len(self.levels) and i[1] >= 0:
if i[0] < self.rows and i[0] >=0 and i[2] < self.cols and i[2] >=0:
self.levels[i[1]][i[0],i[2]] = self.current_item
pass
newLevels = list()
for i, j in enumerate(self.levels):
temp = dict()
for key, val in j.iteritems():
if int(val) != 0:
temp[key] = val
newLevels.append(temp)
self.levels = newLevels
self.redraw_level()
except RuntimeError:
pass
def onPaste(self):
self.w=popupWindow(self,title = "On world, facing north (i.e x increases ahead of you,\n"+
"and z increases to your right.\n" +
"Enter origin point (x y z) seperated by spaces: eg. 12 12 12:")
self.wait_window(self.w.top)
data = self.w.value.split(' ')
try:
xo = int(data[0])
yo = int(data[1])
zo = int(data[2])
if tkMessageBox.askquestion('Coords', "Is this (x,y,z) correct: " + str(xo) +',' +str(yo) + ',' + str(zo)) == 'yes':
print 'Pasting'
count = 0
for j,i in enumerate(self.levels):
for key,value in i.iteritems():
xr = int(xo + key[0])
yr = int(yo + j)
zr = int(zo + key[1])
# self.client.client_send(xr,yr,zr,0)
if int(value) != 0:
self.client.client_send(xr,yr,zr,int(value))
count = count + 1
if count % NUMPERSEC == 0:
time.sleep(1)
else:
pass
except ValueError:
pass
def onPasteSign(self):
self.w=popupWindow(self,title = "Facing north, enter origin point(x y z): eg. 12 12 12:")
self.wait_window(self.w.top)
data = self.w.value.split(' ')
try:
xo = int(data[0])
yo = int(data[1])
zo = int(data[2])
if tkMessageBox.askquestion('Coords', "Is this (x,y,z) correct: " + str(xo) +',' +str(yo) + ',' + str(zo)) == 'yes':
print 'Pasting'
count = 0
for j,i in enumerate(self.signs):
for key,value in i.iteritems():
xr = int(xo + key[0])
yr = int(yo + j)
zr = int(zo + key[1])
for num,val in enumerate(value):
if val!=-1:
# print j,i,num, val
self.client.client_send_sign(xr, yr, zr, num, val)
sys.stdout.flush()
except ValueError:
pass
def onLoadFromWorld(self):
self.w=popupWindow(self,title = "Enter bottom left point: (x y z)")
self.wait_window(self.w.top)
try:
[x1,y1,z1] = [int(i) for i in self.w.value.split(' ')]
self.w=popupWindow(self,title = "Enter top right point: (x y z)")
self.wait_window(self.w.top)
[x2,y2,z2] = [int(i) for i in self.w.value.split(' ')]
x1,x2 = sorted([x1,x2])
y1,y2 = sorted([y1,y2])
z1,z2 = sorted([z1,z2])
if tkMessageBox.askquestion('Coords', "Bottom left: " + str(x1) +',' +str(y1) + ',' + str(z1) + '\n' + \
"Top right: " + str(x2) +',' +str(y2) + ',' + str(z2)) == 'yes':
print 'Copying',x1,y1,z1,' to',x2,y2,z2
data = self.client.read_db(x1,y1,z1,x2,y2,z2, db_name)
signs = self.client.read_signs(x1,y1,z1,x2,y2,z2, db_name)
newData = list()
for i in data:
temp = dict()
for key,value in i.iteritems():
if value != 0:
temp[key[0], key[1]] = value
newData.append(temp)
newSignData = list()
for i in signs:
temp = dict()
for key,value in i.iteritems():
temp[key[0], key[1]] = value
newSignData.append(temp)
if self.overlayToggle == 1:
self.toggle.invoke()
self.overlayToggle = 0
self.updateDimensions(x2-x1+1, z2-z1+1, len(newData))
self.reset_canvas()
self.levels = newData
self.signs = newSignData
sys.stdout.flush()
self.redraw_level()
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
except ValueError:
pass
def onSave(self):
filename = asksaveasfilename(parent=self)
pickle.dump({'Dimensions' : [self.rows,self.cols,len(self.levels)],'Levels' : self.levels, 'Signs' : self.signs}, open(filename, 'wb'))
def onLoad(self):
if self.overlayToggle == 1:
self.toggle.invoke()
self.overlayToggle = 0
filename = askopenfilename(parent=self)
try:
obj = pickle.load(open(filename, 'rb'))
self.updateDimensions(int(obj['Dimensions'][0]), int(obj['Dimensions'][1]), int(obj['Dimensions'][2]))
self.reset_canvas()
self.levels = obj['Levels']
if 'Signs' in obj:
self.signs = obj['Signs']
self.redraw_level()
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
except IOError:
pass
def onToggle(self):
if self.overlayToggle == 0:
self.overlayToggle =1
self.redraw_level()
else:
self.overlayToggle = 0
self.redraw_level()
def onNewLevel(self):
self.add_new_level()
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
self.redraw_level()
def onRotate(self):
self.rotatedData = list()
self.rotatedSignData = list()
for i in self.levels:
temp = dict()
for key,value in i.iteritems():
xr = (key[0] * math.cos(math.radians(-90)) - (key[1]) * math.sin(math.radians(-90)))
zr = (key[0] * math.sin(math.radians(-90)) + (key[1]) * math.cos(math.radians(-90)))
temp[int(math.floor(xr)),int(math.floor(zr))] = value
self.rotatedData.append(temp)
sign_map = {0:2, 3:0, 1:3, 2:1, 6:5, 7:6, 4:7, 5:4} #FOR ROTATION CALCULATION
for i in self.signs:
temp = dict()
for key,value in i.iteritems():
xr = (key[0] * math.cos(math.radians(-90)) - (key[1]) * math.sin(math.radians(-90)))
zr = (key[0] * math.sin(math.radians(-90)) + (key[1]) * math.cos(math.radians(-90)))
new_value = [value[sign_map[0]],
value[sign_map[1]],
value[sign_map[2]],
value[sign_map[3]],
value[sign_map[4]],
value[sign_map[5]],
value[sign_map[6]],
value[sign_map[7]]]
temp[int(math.floor(xr)),int(math.floor(zr))] = new_value
self.rotatedSignData.append(temp)
#Moving to origin x,z : 0,0
self.newData=list()
self.newSignData=list()
for i in self.rotatedData:
temp=dict()
for key,value in i.iteritems():
temp[key[0], int(key[1])+int((self.rows-1))] = value
self.newData.append(temp)
for i in self.rotatedSignData:
temp=dict()
for key,value in i.iteritems():
temp[key[0], int(key[1])+int((self.rows-1))] = value
self.newSignData.append(temp)
temp = self.rows
self.rows = self.cols
self.cols = temp
temp = self.curr_level
temp2 = self.overlay_level
temp3 = self.overlayToggle
temp4 = self.current_item
self.updateDimensions(self.rows, self.cols,len(self.newData))
self.reset_canvas()
self.levels = self.newData
self.signs = self.newSignData
self.curr_level = temp
self.overlay_level = temp2
self.overlayToggle = temp3
self.itemCombo.set(temp4)
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
self.currLevelCombo.set(self.curr_level)
self.overlayLevelCombo.set(self.overlay_level)
self.redraw_level()
def onNew(self):
if self.overlayToggle == 1:
self.toggle.invoke()
self.overlayToggle = 0
self.w=popupWindow(self,title = "Enter Dimensions in XxZxY format (e.g. 10x20x3)")
self.wait_window(self.w.top)
try:
data = self.w.value.split('x')
if len(data) == 2:
self.updateDimensions(int(data[0]), int(data[1]),1)
else:
self.updateDimensions(int(data[0]), int(data[1]),int(data[2]))
# self.initData()
self.reset_canvas()
self.currLevelCombo.config(values = range(len(self.levels)))
self.overlayLevelCombo.config(values = range(len(self.levels)))
except ValueError:
pass
def currLevelChooser(self, event):
self.curr_level = int(self.currLevelCombo.get())
self.redraw_level()
def overlayLevelChooser(self, event):
self.overlay_level = int(self.overlayLevelCombo.get())
self.redraw_level()
def itemChooser(self, event):
self.current_item = int(self.itemCombo.get())
def callbackLeftClick(self,event):
if self.current_item == 0:
return
col = int(math.floor((event.x)/self.cellwidth))
row = int(math.floor((event.y)/self.cellheight))
x1 = col * self.cellwidth
y1 = row * self.cellheight
x2 = x1 + self.cellwidth
y2 = y1 + self.cellheight
if (self.rows - row - 1,col) in self.rect:
self.canvas.itemconfig(self.rect[self.rows - row - 1,col],fill=COLORS[self.current_item])
self.canvas.itemconfig(self.rect_text[self.rows - row - 1,col], text = str(self.current_item))
else:
self.rect[self.rows - row - 1,col] = self.canvas.create_rectangle(x1,y1,x2,y2, fill=COLORS[self.current_item], outline = 'black', width = DEFAULTWIDTH, tag = 'block')
self.rect_text[self.rows - row - 1,col] = self.canvas.create_text((x1+x2)/2,(y1+y2)/2, text = self.current_item, font=('verdana', 7), tag = 'blocktext')
self.levels[self.curr_level][self.rows - row - 1,col] = self.current_item
if row < self.rows and row >=0 and col < self.cols and col >= 0:
self.lbl_e.config(text = 'x,y,z: ' + str(self.rows-row-1) + ',' + str(self.curr_level) + ',' + str(col))
def callbackRightClick(self,event):
col = int(math.floor((event.x)/self.cellwidth))
row = int(math.floor((event.y)/self.cellheight))
if (self.rows - row - 1,col) in self.rect:
self.canvas.delete(self.rect[self.rows - row - 1,col])
self.canvas.delete(self.rect_text[self.rows - row - 1,col])
self.rect.pop((self.rows - row -1, col))
self.rect_text.pop((self.rows - row -1, col))
self.levels[self.curr_level].pop((self.rows - row - 1,col),None)
if row < self.rows and row >=0 and col < self.cols and col >= 0:
self.lbl_e.config(text = 'x,y,z: ' + str(self.rows-row-1) + ',' + str(self.curr_level) + ',' + str(col))
class MazePlannerCanvas(Frame):
"""
MazePlannerCanvas contains the main frontend workhorse functionality of the entire
application.
it allows the user to graphically place nodes and define the edges between them
"""
def __init__(self, parent, status=None, manager=DataStore()):
"""
Construct an instance of the MazePlannerCanvas
:param parent: The parent widget that the mazePlannerCanvas will sit in
:param status: The statusbar that will receive mouse updates
:type manager: DataStore
:return:
"""
Frame.__init__(self, parent)
self._manager = manager
self._canvas = Canvas(self, bg="grey", cursor="tcross")
self._canvas.pack(fill=BOTH, expand=1)
self._commands = {
(ControlSpecifier.DRAG_NODE, ExecutionStage.START) : self._begin_node_drag,
(ControlSpecifier.CREATE_EDGE, ExecutionStage.START) : self._begin_edge,
(ControlSpecifier.DRAG_NODE, ExecutionStage.END) : self._end_node_drag,
(ControlSpecifier.CREATE_EDGE, ExecutionStage.END) : self._end_edge,
(ControlSpecifier.DRAG_NODE, ExecutionStage.EXECUTE) : self._execute_drag,
(ControlSpecifier.CREATE_EDGE, ExecutionStage.EXECUTE) : self._execute_edge,
(ControlSpecifier.MENU, ExecutionStage.EXECUTE) : self._launch_menu,
(ControlSpecifier.CREATE_NODE, ExecutionStage.EXECUTE) : self.create_new_node,
}
self._commands = load_controls(self._commands)
self._edge_cache = \
{
"x_start" : None,
"y_start" : None,
"x_end" : None,
"y_end" : None,
"item_start" : None,
"item_end" : None,
"edge" : None
}
self._command_cache = None
self._cache = \
{
"item" : None,
"x" : 0,
"y" : 0,
"event" : None
}
self._status = status
self._edge_bindings = {}
self._node_listing = {}
self._object_listing = {}
self._curr_start = None
self._construct(parent)
def _construct(self, parent):
"""
Construct all of the event bindings and callbacks for mouse events
"""
self._canvas.focus_set()
self._canvas.bind("<B1-Motion>", lambda event, m_event=Input_Event.DRAG_M1: self._handle_mouse_events(m_event, event))
self._canvas.bind("<B2-Motion>", lambda event, m_event=Input_Event.DRAG_M2: self._handle_mouse_events(m_event, event))
self._canvas.bind("<B3-Motion>", lambda event, m_event=Input_Event.DRAG_M3: self._handle_mouse_events(m_event, event))
self._canvas.bind("<ButtonPress-2>", lambda event, m_event=Input_Event.CLICK_M2: self._handle_mouse_events(m_event, event))
self._canvas.bind("<ButtonRelease-2>", lambda event, m_event=Input_Event.RELEASE_M2: self._handle_mouse_events(m_event, event))
self._canvas.bind("<ButtonPress-1>", lambda event, m_event=Input_Event.CLICK_M1: self._handle_mouse_events(m_event, event))
self._canvas.bind("<ButtonPress-3>", lambda event, m_event=Input_Event.CLICK_M3: self._handle_mouse_events(m_event, event))
self._canvas.bind("<ButtonRelease-1>", lambda event, m_event=Input_Event.RELEASE_M1: self._handle_mouse_events(m_event, event))
self._canvas.bind("<ButtonRelease-3>", lambda event, m_event=Input_Event.RELEASE_M3: self._handle_mouse_events(m_event, event))
self._canvas.bind("<Return>", lambda event, m_event=Input_Event.RETURN: self._handle_mouse_events(m_event, event))
self._canvas.bind("<Double-Button-1>", lambda event, m_event=Input_Event.D_CLICK_M1: self._handle_mouse_events(m_event, event))
self._canvas.bind("<Double-Button-2>", lambda event, m_event=Input_Event.D_CLICK_M2: self._handle_mouse_events(m_event, event))
self._canvas.bind("<Double-Button-3>", lambda event, m_event=Input_Event.D_CLICK_M3: self._handle_mouse_events(m_event, event))
self._canvas.bind("<Motion>", lambda event, m_event=None : self._handle_mot(m_event, event))
self._canvas.bind("<Enter>", lambda event: self._canvas.focus_set())
self._canvas.bind("<space>", lambda event, m_event=Input_Event.SPACE: self._handle_mouse_events(m_event, event))
def _handle_mot(self, m_event, event):
"""
Callback function to handle movement of the mouse
Function updates the mouse location status bar as well as setting cache values to the current location
of the mouse
:m_event: The specifier for the type of event that has been generated
:event: The tk provided event object
"""
event.x = int(self._canvas.canvasx(event.x))
event.y = int(self._canvas.canvasy(event.y))
self._status.set_text("Mouse X:" + str(event.x) + "\tMouse Y:" + str(event.y))
item = self._get_current_item((event.x, event.y))
if self._is_node(item):
Debug.printi("Node: " + str(item), Debug.Level.INFO)
if self._is_edge(item):
d_x = self._edge_bindings[item].x_start - self._edge_bindings[item].x_end
d_y = self._edge_bindings[item].y_start - self._edge_bindings[item].y_end
square = (d_x * d_x) + (d_y * d_y)
distance = int(math.sqrt(square))
Debug.printi("Edge: " + str(item) + " | Source: "
+ str(self._edge_bindings[item].item_start) + " | Target: "
+ str(self._edge_bindings[item].item_end) + " | Length: "
+ str(distance))
self._cache["x"] = event.x
self._cache["y"] = event.y
def _handle_mouse_events(self, m_event, event):
"""
Function that routes mouse events to the appropriate handlers
Prints logging and UI information about the state of the mouse and then routes
the mouse event to the appropriate handler
:m_event: The specifier for the tupe of event that has been generated
:event: The tk provided event object
"""
event.x = int(self._canvas.canvasx(event.x))
event.y = int(self._canvas.canvasy(event.y))
self._status.set_text("Mouse X:" + str(self._cache["x"]) + "\tMouse Y:" + str(self._cache["y"]))
Debug.printet(event, m_event, Debug.Level.INFO)
self._cache["event"] = event
try:
self._commands[m_event]((event.x, event.y))
except KeyError:
Debug.printi("Warning, no control mapped to " + m_event, Debug.Level.ERROR)
self._command_cache = m_event
def _begin_node_drag(self, coords):
"""
Handles starting operations for dragging a node
Updates the cache information regarding a node drag event, we will used this cache value
as the handle on which node to update the information for
:coords: The mouse coordinates associated with this event
"""
# Determine which node has been selected, cache this information
item = self._get_current_item(coords)
if item in self._node_listing:
self._update_cache(item, coords)
def _end_node_drag(self, coords):
"""
Performs actions to complete a node drag operation
Validates node location, and other associated object information and updates the cache
when a node drag is completed
:coords: The coordinates associated with this event
"""
if self._cache["item"] is None:
return
# Obtain the final points
x = coords[0]
y = coords[1]
item = self._cache["item"]
self._validate_node_position(coords)
container = self._manager.request(DataStore.DATATYPE.NODE, item)
container.x_coordinate = x
container.y_coordinate = y
self._manager.inform(DataStore.EVENT.NODE_EDIT, container.empty_container(), self._cache["item"])
Debug.printi("Node " + str(self._cache["item"]) + " has been moved", Debug.Level.INFO)
# Clean the cache
self._clear_cache(coords)
def _validate_node_position(self, coords):
"""
if x < 0:
x = 0
if y < 0:
y = 0
if x > self._canvas.winfo_width():
x = self._canvas.winfo_width()-25
if y > self._canvas.winfo_height():
y = self._canvas.winfo_height()-25
self._canvas.move(item, x, y)
"""
pass
def _execute_drag(self, coords):
"""
Updates object position on canvas when user is dragging a node
:param coords: The coordinates associated with this event
"""
# Abort drag if the item is not a node
if self._cache["item"] not in self._node_listing:
return
# Update the drawing information
delta_x = coords[0] - self._cache["x"]
delta_y = coords[1] - self._cache["y"]
# move the object the appropriate amount as long as the drag event has not been done on the empty canvas
if not self._cache["item"] is None:
self._canvas.move(self._cache["item"], delta_x, delta_y)
# record the new position
self._cache["x"] = coords[0]
self._cache["y"] = coords[1]
self._update_attached_edges(self._cache["item"], coords)
self._update_attached_objects(self._cache["item"], coords)
def _update_attached_objects(self, item, coords):
if item not in self._object_listing:
return
container = self._manager.request(DataStore.DATATYPE.OBJECT, item)
container.x_coordinate = coords[0]
container.y_coordinate = coords[1]
self._manager.inform(DataStore.EVENT.OBJECT_EDIT, container.empty_container(), item)
def _update_attached_edges(self, node, coords):
"""
Updates all associated edges related to a node drag event
:param node: The node that has been dragged
:param coords: The mouse coordinates which are the new coordinates of the node
"""
# Go through dictionary and gather list of all attached edge bindings for a node
start_bindings = []
for key, binding in self._edge_bindings.iteritems():
if binding.item_start == node:
start_bindings.append(binding)
end_bindings = []
for key, binding in self._edge_bindings.iteritems():
if binding.item_end == node:
end_bindings.append(binding)
# Adjust the bindings with this node as the starting edge
for binding in start_bindings:
self._canvas.delete(binding.edge)
del self._edge_bindings[binding.edge]
old_edge = binding.edge
binding.edge = self._canvas.create_line(coords[0], coords[1], binding.x_end,
binding.y_end, tags="edge", activefill="RoyalBlue1", tag="edge")
self._edge_bindings[binding.edge] = binding
self._manager.update_key(DataStore.EVENT.EDGE_EDIT, binding.edge, old_edge)
binding.x_start = coords[0]
binding.y_start = coords[1]
# Adjust the bindings with this node as the ending edge
for binding in end_bindings:
self._canvas.delete(binding.edge)
del self._edge_bindings[binding.edge]
old_edge = binding.edge
binding.edge = self._canvas.create_line(binding.x_start, binding.y_start,
coords[0], coords[1], tags="edge", activefill="RoyalBlue1", tag="edge")
self._edge_bindings[binding.edge] = binding
self._manager.update_key(DataStore.EVENT.EDGE_EDIT, binding.edge, old_edge)
binding.x_end = coords[0]
binding.y_end = coords[1]
# Remember to adjust all of the edges so that they sit under the node images
self._canvas.tag_lower("edge")
def _launch_menu(self, coords):
"""
Callback function in response to the pressing of the Return key
Launches a context menu based on the location of the mouse
:param coords:
:return:
"""
# Configure the "static" menu entries -- they can't be static without seriously destroying readability
# due to the Python version that is being used -.- so now it has to be not optimal until I find a better
# solution
p_menu = Menu(self._canvas)
item = self._get_current_item((self._cache["x"], self._cache["y"]))
updated_coords = self._canvas_to_screen((self._cache["x"], self._cache["y"]))
if item is None:
# No node is currently selected, create the general menu
p_menu.add_command(label="Place Room", command=lambda: self.create_new_node((self._cache["x"], self._cache["y"])))
p_menu.add_command(label="Delete All", command=lambda: self.delete_all())
p_menu.tk_popup(updated_coords[0], updated_coords[1])
return
if self._is_node(item):
# Create the node specific menu
p_menu.add_command(label="Place Object", command=lambda: self._mark_object((self._cache["x"], self._cache["y"])))
p_menu.add_command(label="Edit Room", command=lambda: self._selection_operation((self._cache["x"], self._cache["y"])))
p_menu.add_command(label="Delete Room", command=lambda: self.delete_node(self._get_current_item((self._cache["x"], self._cache["y"]))))
p_menu.add_command(label="Mark as start", command=lambda: self._mark_start_node(self._get_current_item((self._cache["x"], self._cache["y"]))))
if self._is_object(item):
# Launch the node menu as well as an an added option for selecting stuff to edit an object
p_menu.add_command(label="Edit Object", command=lambda: self._edit_object(coords))
p_menu.add_command(label="Delete Object", command=lambda: self._delete_object(self._get_current_item((self._cache["x"], self._cache["y"]))))
p_menu.delete(0)
p_menu.tk_popup(updated_coords[0], updated_coords[1])
return
if self._is_edge(item):
p_menu.add_command(label="Edit Corridor", command=lambda: self._selection_operation((self._cache["x"], self._cache["y"])))
p_menu.add_command(label="Delete Corridor", command=lambda: self.delete_edge(self._get_current_item((self._cache["x"], self._cache["y"]))))
p_menu.tk_popup(updated_coords[0], updated_coords[1])
return
self._clear_cache(coords)
def _edit_object(self, coords):
"""
Awkward moment when you find a threading related bug in the Tkinter library, caused by some
Tcl issue or something like that.
The below line must be left commented out otherwise the window_wait call in the dialog will crash
out with a Tcl ponter based issue :/
item = self._get_current_item((self._cache["x"], self._cache["y"]))
This means that we can only use the mouse to edit objects
"""
item = self._get_current_item(coords)
if item not in self._object_listing:
Debug.printi("Not a valid object to edit", Debug.Level.ERROR)
return
obj = ObjectDialog(self, coords[0] + 10, coords[1] + 10, populator=self._manager.request(DataStore.DATATYPE.OBJECT, item))
Debug.printi("Editing object " + str(item), Debug.Level.INFO)
self._manager.inform(DataStore.EVENT.OBJECT_EDIT, obj._entries, item)
Debug.printi("Editing object " + str(item), Debug.Level.INFO)
def _delete_object(self, item):
if item not in self._object_listing:
Debug.printi("Object does not exist to delete", Debug.Level.ERROR)
return
del self._object_listing[item]
self._manager.inform(DataStore.EVENT.OBJECT_DELETE, data_id=item)
self._canvas.itemconfig(item, outline="red", fill="black", activeoutline="black", activefill="red")
def _mark_object(self, coords, prog=False, data=None):
"""
Mark a node as containing an object
:param coords:
:return:
"""
# Retrieve the item
item = self._get_current_item(coords)
if not prog:
if item not in self._node_listing:
Debug.printi("Invalid object placement selection", Debug.Level.ERROR)
return
if item in self._object_listing:
Debug.printi("This room already has an object in it", Debug.Level.ERROR)
return
# Retrieve its coordinates
# Launch the object maker dialog
obj = ObjectDialog(self, coords[0] + 10, coords[1] + 10, populator=Containers.ObjectContainer(key_val={
"x_coordinate" : coords[0],
"y_coordinate" : coords[1],
"name" : "Object_"+str(item),
"mesh" : None,
"scale" : None
}))
entries = obj._entries
else:
entries = {
"x_coordinate": coords[0],
"y_coordinate": coords[1],
"name": data["name"],
"mesh": data["mesh"],
"scale": data["scale"]
}
# Save informatoin to the manager
self._manager.inform(DataStore.EVENT.OBJECT_CREATE, entries, item)
self._object_listing[item] = item
self._canvas.itemconfig(item, fill="blue")
Debug.printi("Object created in room " + str(item), Debug.Level.INFO)
def _valid_edge_cache(self):
"""
Return true if the edge cache contains a valid edge descriptor
A valid edge descriptor is when the edge has a valid starting node, if the
edge does not contain a valid starting node, this means that the edge was not
created in the proper manner and should thus be ignored by any edge operations
"""
valid = not self._edge_cache["item_start"] == (None,)
return valid
def _canvas_to_screen(self, coords):
"""
Convert canvas coordinates into screen coordinates
:param coords: The current canvas coordinates
:return:
"""
"""
# upper left corner of the visible region
x0 = self._canvas.winfo_rootx()
y0 = self._canvas.winfo_rooty()
# given a canvas coordinate cx/cy, convert it to window coordinates:
wx0 = x0 + coords[0]
wy0 = y0 + coords[1]
# upper left corner of the visible region
x0 = self._canvas.canvasx(0)
y0 = self._canvas.canvasy(0)
# given a canvas coordinate cx/cy, convert it to window coordinates:
wx0 = coords[0] - x0
wy0 = coords[1] - y0
#"""
return (self._cache["event"].x_root, self._cache["event"].y_root)
def _begin_edge(self, coords):
"""
Begin recording information regarding the placement of an edge
:param coords: The coordinates associated with this event
"""
# Record the starting node
self._edge_cache["item_start"] = self._get_current_item((self._cache["x"], self._cache["y"]))
# Abort the operation if the item was not a valid node to be selecting
if self._edge_cache["item_start"] is None or self._edge_cache["item_start"] not in self._node_listing:
self._clear_edge_cache()
return
self._edge_cache["x_start"] = self._cache["x"]
self._edge_cache["y_start"] = self._cache["y"]
def _end_edge(self, coords, prog=False, data=None):
"""
Perform the operations required to complete an edge creation operation
:param coords:
:return:
"""
# Check if the cursor is over a node, if so continue, else abort
curr = self._get_current_item((coords[0], coords[1]))
if not prog:
if curr is None or not self._valid_edge_cache() or curr not in self._node_listing:
# Abort the edge creation process
self._canvas.delete(self._edge_cache["edge"])
self._clear_edge_cache()
return
# Check if this edge already exists in the program
if self._check_duplicate_edges(self._edge_cache["item_start"], curr):
self.delete_edge(self._edge_cache["edge"])
Debug.printi("Multiple edges between rooms not permitted", Debug.Level.ERROR)
return
#Ensure that edges arent made between the same room
if curr == self._edge_cache["item_start"]:
Debug.printi("Cannot allow paths starting and ending in the same room", Debug.Level.ERROR)
return
self._canvas.tag_lower("edge")
self._edge_cache["item_end"] = curr
# Note that we use the edge ID as the key
self._edge_bindings[self._edge_cache["edge"]] = EdgeBind(self._edge_cache)
self._edge_bindings[self._edge_cache["edge"]].x_end = coords[0]
self._edge_bindings[self._edge_cache["edge"]].y_end = coords[1]
# Inform the manager
if not prog:
self._manager.inform(
DataStore.EVENT.EDGE_CREATE,
{
"source" : self._edge_cache["item_start"],
"target" : self._edge_cache["item_end"],
"height" : None,
"wall1" : {
"height":Defaults.Edge.WALL_HEIGHT,
"textures":{
Defaults.Wall.PATH: {
"path":Defaults.Wall.PATH,
"tile_x":Defaults.Wall.TILE_X,
"tile_y":Defaults.Wall.TILE_Y,
"height":None
}
}
} if Defaults.Config.EASY_MAZE else None,
"wall2" : {
"height": Defaults.Edge.WALL_HEIGHT,
"textures": {
Defaults.Wall.PATH: {
"path": Defaults.Wall.PATH,
"tile_x": Defaults.Wall.TILE_X,
"tile_y": Defaults.Wall.TILE_Y,
"height":None
}
}
}
} if Defaults.Config.EASY_MAZE else None,
self._edge_cache["edge"])
else:
# We are programmatically adding the edges in
self._manager.inform(
DataStore.EVENT.EDGE_CREATE,
{
"source": self._edge_cache["item_start"],
"target": self._edge_cache["item_end"],
"height": None,
"wall1": data["wall1"],
"wall2": data["wall2"]
},
self._edge_cache["edge"])
Debug.printi("Edge created between rooms "
+ str(self._edge_cache["item_start"])
+ " and "
+ str(self._edge_cache["item_end"])
, Debug.Level.INFO)
self._clear_edge_cache()
self._clear_cache(coords)
def _check_duplicate_edges(self, start_node, end_node):
for binding in self._edge_bindings.itervalues():
if ( start_node == binding.item_start and end_node == binding.item_end )\
or ( start_node == binding.item_end and end_node == binding.item_start):
return True
return False
def _execute_edge(self, coords):
"""
Perform the operations that occur during the motion of an edge drag
:param coords:
:return:
"""
# Update the line position
# We will update the line position by deleting and redrawing
if not self._valid_edge_cache():
return
self._canvas.delete(self._edge_cache["edge"])
self._edge_cache["edge"] = self._canvas.create_line( \
self._edge_cache["x_start"], self._edge_cache["y_start"],
coords[0]-1, coords[1]-1, tags="edge", activefill="RoyalBlue1", tag="edge")
d_x = self._edge_cache["x_start"] - coords[0]
d_y = self._edge_cache["y_start"] - coords[1]
square = (d_x * d_x) + (d_y * d_y)
distance = math.sqrt(square)
Debug.printi("Current corridor distance: " + str(int(distance)))
def _update_cache(self, item, coords):
"""
Update the local cache with the item id and coordinates of the mouse
:param item: The item with which to update the cache
:param coords: The current event coordinates
"""
self._cache["item"] = item
self._cache["x"] = coords[0]
self._cache["y"] = coords[1]
def _clear_cache(self, coords):
"""
Clear the cache
Set the cache values to the current mouse position and None the item
:param coords: The coordinates of the mouse at that event time
"""
self._cache["item"] = None
self._cache["x"] = coords[0]
self._cache["y"] = coords[1]
def _clear_edge_cache(self):
"""
Clear the edge cache to None for all values
:return:
"""
self._edge_cache["x_start"] = None,
self._edge_cache["y_start"] = None,
self._edge_cache["x_end"] = None,
self._edge_cache["y_end"] = None,
self._edge_cache["item_start"] = None,
self._edge_cache["item_end"] = None,
self._edge_cache["edge"] = None
def _get_current_item(self, coords):
"""
Return the item(if any) that the mouse is currently over
:param coords: The current coordinates of the mouse
:return:
"""
item = self._canvas.find_overlapping(coords[0]-1, coords[1]-1, coords[0]+1, coords[1]+1)
if item is ():
return None
# Hacky solution
# Return the first node that we come across, since they seem to be returned by tkinter
# in reverse order to their visual positioning, we'll go through the list backwards
for val in item[::-1]:
if val in self._node_listing:
return val
# Else, just return the first item and be done with it
return item[0]
def _is_node(self, obj):
"""
Returns true if the supplied object is a node
:param obj: The object id to id
:return:
"""
return obj in self._node_listing
def _is_edge(self, obj):
"""
Returns true if the supplied object is an edge
:param obj: The object id to id
:return:
"""
return obj in self._edge_bindings
def _is_object(self, obj):
"""
Returns true if the supplied object is an object
:param obj: The object id to id
:return:
"""
return obj in self._object_listing
def _get_obj_type(self, obj):
"""
Returns the Object type of the supplied object
:param obj: The object to identify
:return:
"""
if self._is_node(obj):
return EditableObject.NODE
if self._is_edge(obj):
return EditableObject.EDGE
if self._is_object(obj):
return EditableObject.OBJECT
return None
def _selection_operation(self, coords):
"""
Contextually create or edit a node
:param coords:
:return:
"""
# Determine the item ID
item = self._get_current_item(coords)
self._cache["item"] = item
true_coords = self._canvas_to_screen((self._cache["x"], self._cache["y"]))
if self._is_node(item):
Debug.printi("Node Selected : " + str(item) + " | Launching Editor", Debug.Level.INFO)
# Make request from object manager using the tag assigned
populator = self._manager.request(DataStore.DATATYPE.NODE, item)
updated_node = NodeDialog(self, true_coords[0] + 10, true_coords[1] + 10, populator=populator)
# post information to object manager, or let the dialog handle it, or whatever
self._manager.inform(DataStore.EVENT.NODE_EDIT, updated_node._entries, item)
return
if self._is_edge(item):
Debug.printi("Edge Selected : " + str(item) + " | Launching Editor", Debug.Level.INFO)
# Make a request from the object manager to populate the dialog
populator = self._manager.request(DataStore.DATATYPE.EDGE, item)
updated_edge = EdgeDialog(self, true_coords[0] + 10, true_coords[1] + 10, populator=populator)
# Make sure that information is posted to the object manager
self._manager.inform(DataStore.EVENT.EDGE_EDIT, updated_edge._entries, item)
return
if self._is_object(item):
self._edit_object(coords)
return
def create_new_node(self, coords, prog = False, data=None):
"""
Creates a new node on the Canvas and adds it to the datastore
:param coords:
:return:
"""
# Create the node on Canvas
self._cache["item"] = self._canvas.create_rectangle(coords[0], coords[1], coords[0]+25, coords[1]+25,
outline="red", fill="black", activeoutline="black", activefill="red", tag="node")
self._node_listing[self._cache["item"]] = self._cache["item"]
if not prog:
if not Defaults.Config.EASY_MAZE:
true_coords = self._canvas_to_screen((self._cache["x"], self._cache["y"]))
new_node = NodeDialog(self, true_coords[0] + 25, true_coords[1] + 25,
populator=Containers.NodeContainer(
{
"node_id": self._cache["item"],
"x_coordinate": self._cache["x"],
"y_coordinate": self._cache["y"],
"room_texture": None,
"wall_pictures": None
}))
entries = new_node._entries
else:
entries = {
"node_id": self._cache["item"],
"x_coordinate": self._cache["x"],
"y_coordinate": self._cache["y"],
"room_texture": Defaults.Node.ROOM_TEXTURE,
"wall_pictures": None
}
else:
pics = data[1]
data = data[0]
entries = {
"node_id": data["id"],
"x_coordinate": data["x"],
"y_coordinate": data["y"],
"room_texture": data["texture"],
"wall_pictures": pics
}
# Inform the datastore
self._manager.inform(DataStore.EVENT.NODE_CREATE, entries, self._cache["item"])
self._clear_cache(coords)
def delete_all(self):
"""
Delete all nodes and associated edges and objects from the canvas
"""
# Iterate over each node in the node listing and delete it using delete node
for key in self._node_listing.keys():
self.delete_node(key)
# Delete any rouge edge bindings that may exist
for binding in self._edge_bindings:
self.delete_edge(binding)
self._object_listing.clear()
# Delete any naughty objects that are left
self._canvas.delete("all")
self._manager.inform(DataStore.EVENT.DELETE_ALL)
def delete_node(self, node_id):
"""
Delete a node and all its associated edges and object from the canvas
:param node_id: The tkinter id of the node to be deleted
"""
# Delete from our internal representations
if node_id not in self._node_listing:
return
del self._node_listing[node_id]
# Delete from the canvas
self._canvas.delete(node_id)
# Iterate through the edge bindings and delete all of those
for key in self._edge_bindings.keys():
if self._edge_bindings[key].item_start == node_id or self._edge_bindings[key].item_end == node_id:
self.delete_edge(key)
# Inform the object manager that a node as been deleted
if node_id in self._object_listing:
self._delete_object(node_id)
self._manager.inform(DataStore.EVENT.NODE_DELETE, data_id=node_id)
def delete_edge(self, edge_id):
"""
Delete the specified edge from the MazeCanvas
:param edge_id: The edge to be deleted
:return:
"""
# Go through the edge bindings and delete the appropriate edge
try:
# try to delete the edge binding if it exists
del self._edge_bindings[edge_id]
except KeyError:
# Terrible I know, but I dont have the time to find the root cause
pass
# Delete the edge from the canvas
self._canvas.delete(edge_id)
# Inform the object manager that an edge has been deleted
self._manager.inform(DataStore.EVENT.EDGE_DELETE, data_id=edge_id)
def _mark_start_node(self, node_id):
"""
Mark the passed in node as the starting node
:param node_id:
:return:
"""
# Print the debug information
# Mark as the new starting node on the canvas, first check that it is a node
if node_id in self._node_listing:
Debug.printi("Node:" + str(node_id) + " has been marked as the new starting node", Debug.Level.INFO)
if self._curr_start is not None:
# Return the old starting node to its normal colour
self._canvas.itemconfig(self._curr_start, outline="red", fill="black", activeoutline="black", activefill="red")
self._curr_start = node_id
self._canvas.itemconfig(node_id, outline="black", fill="green", activeoutline="green", activefill="black")
# Inform the object manager that there is a new starting node
environment_container = self._manager.request(DataStore.DATATYPE.ENVIRONMENT)
environment_container.start_node = node_id
self._manager.inform(DataStore.EVENT.ENVIRONMENT_EDIT, environment_container)
cell_size = 20
canvas = Canvas(root, height=win_height)
canvas.pack(fill=BOTH)
field_height = win_height / cell_size
field_width = win_width / cell_size
cell_matrix = []
for i in xrange(field_height):
for j in xrange(field_width):
square = canvas.create_rectangle(2 + cell_size * j,
2 + cell_size * i,
cell_size + cell_size * j - 2,
cell_size + cell_size * i - 2,
fill=fill_color)
canvas.itemconfig(square, state=HIDDEN, tags=('hid', '0'))
cell_matrix.append(square)
fict_square = canvas.create_rectangle(0,
0,
0,
0,
state=HIDDEN,
tags=('hid', '0'))
cell_matrix.append(fict_square)
canvas.itemconfig(cell_matrix[addr(8, 8)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addr(10, 9)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addr(9, 9)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addr(9, 8)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addr(9, 7)], state=NORMAL, tags='vis')
canvas.itemconfig(cell_matrix[addr(10, 7)], state=NORMAL, tags='vis')
class StlFrame(Frame):
def __init__(self, root, scale=1):
Frame.__init__(self, root)
self.app = root
self.gridOffset = 10
self.arrangeMargin = 2
self.centerOnLoad = True
self.offsetx = 0
self.offsety = 0
self.scale = scale
self.zoom = 1
self.selection = None
self.selectable = []
self.itemMap = {}
self.canvas = Canvas(self, width=200*self.scale+13, height=200*self.scale+13, bd=2, relief=RIDGE, bg="white")
self.canvas.config(takefocus="1")
self.canvas.bind("<Key>", self.keyCanvas)
self.canvas.bind("<Button-1>", self.clickCanvas)
self.canvas.bind("<B1-Motion>", self.dragCanvas)
self.canvas.bind("<MouseWheel>", self.wheelCanvas)
self.canvas.bind("<Button-4>", self.wheelCanvas)
self.canvas.bind("<Button-5>", self.wheelCanvas)
self.root = root
self.buildarea = [200, 200]
self.canvas.grid(row=1,column=1,columnspan=5)
self.drawGrid()
def keyCanvas(self, event):
self.app.setModified()
if event.keysym == "Left":
self.moveStl(-1, 0)
elif event.keysym == "Right":
self.moveStl(1, 0)
elif event.keysym == "Up":
if (event.state & SHIFT_MASK) != 0:
self.rotateStl(1)
else:
self.moveStl(0, 1)
elif event.keysym == "Down":
if (event.state & SHIFT_MASK) != 0:
self.rotateStl(-1)
else:
self.moveStl(0, -1)
def clickCanvas(self, event):
self.app.setModified()
self.canvas.focus_set()
self.startx = event.x/float(self.scale)
self.starty = event.y/float(self.scale)
itemIdList = self.canvas.find_closest(event.x, event.y)
for itemId in itemIdList:
if itemId in self.selectable:
self.setSelection(itemId)
self.app.setSelection(self.itemMap[itemId])
return
def dragCanvas(self, event):
self.app.setModified()
self.canvas.focus_set()
x = event.x/float(self.scale)
y = event.y/float(self.scale)
self.moveStl((x - self.startx), (self.starty - y))
self.startx = x
self.starty = y
def wheelCanvas(self, event):
self.app.setModified()
if event.num == 4 or event.delta == 120:
self.rotateStl(1)
elif event.num == 5 or event.delta == -120:
self.rotateStl(-1)
def moveStl(self, dx, dy):
if self.selection is None:
return
self.canvas.move(self.selection, dx*self.scale, -dy*self.scale)
stlObj = self.itemMap[self.selection]
stlObj.deltaTranslation(dx, dy)
def rotateStl(self, angle):
if self.selection is None:
return
#self.canvas.move(self.selection, dx, -dy)
stlObj = self.itemMap[self.selection]
rads = math.radians(angle+stlObj.rotation)
cos = math.cos(rads)
sin = math.sin(rads)
d = []
xMin = yMin = 99999
xMax = yMax = -99999
for x,y in stlObj.hull:
xp = (x-stlObj.hxCenter)*cos - (y-stlObj.hyCenter)*sin + stlObj.hxCenter
if xp < xMin: xMin=xp
if xp > xMax: xMax=xp
xp += stlObj.translatex
yp = (x-stlObj.hxCenter)*sin + (y-stlObj.hyCenter)*cos + stlObj.hyCenter
if yp < yMin: yMin=yp
if yp > yMax: yMax=yp
yp += stlObj.translatey
d.extend(self.transform(xp,self.buildarea[1]-yp))
self.canvas.delete(stlObj.name)
self.selectable.remove(self.selection)
del self.itemMap[self.selection]
itemId = self.canvas.create_polygon(d, fill=hilite, outline="black", tag=stlObj.name, width=3)
self.selectable.append(itemId)
self.itemMap[itemId] = stlObj
self.setSelection(itemId)
stlObj.deltaRotation(angle)
stlObj.hxSize = xMax-xMin
stlObj.hySize = yMax-yMin
stlObj.hArea = stlObj.hxSize * stlObj.hySize
def setSelection(self, itemId):
if itemId not in self.selectable:
return
if self.selection is not None:
self.canvas.itemconfig(self.selection, fill=gray)
self.canvas.itemconfig(itemId, fill=hilite)
self.selection = itemId
def setSelectionByName(self, name):
for i in self.itemMap.keys():
if self.itemMap[i].name == name:
self.setSelection(i)
return
def getSelection(self):
return self.selection
def getSelectedStl(self):
if self.selection is None:
return None
return self.itemMap[self.selection]
def drawGrid(self):
self.canvas.delete("GRID")
ltGray = "#C0C0C0"
dkGray = "#808080"
yleft = 0
yright = self.buildarea[1]*self.zoom*self.scale
if yright > self.buildarea[1]*self.scale: yright = self.buildarea[1]*self.scale
for x in range(0, self.buildarea[0]+1, 10):
if x%50 == 0:
c = dkGray
else:
c = ltGray
x = x*self.zoom*self.scale
if x >= 0 and x <= self.buildarea[0]*self.scale:
self.canvas.create_line(x+self.gridOffset, yleft+self.gridOffset, x+self.gridOffset, yright+self.gridOffset, fill=c, tags="GRID")
xtop = 0
xbottom = self.buildarea[0]*self.zoom*self.scale
if xbottom > self.buildarea[0]*self.scale: xbottom = self.buildarea[0]*self.scale
for y in range(0, self.buildarea[1]+1, 10):
if y%50 == 0:
c = dkGray
else:
c = ltGray
y = y*self.zoom*self.scale
if y >= 0 and y <= self.buildarea[1]*self.scale:
self.canvas.create_line(xtop+self.gridOffset, y+self.gridOffset, xbottom+self.gridOffset, y+self.gridOffset, fill=c, tags="GRID")
def addStl(self, stlObject, highlight=False, process=True):
self.canvas.delete(stlObject.name)
if highlight:
col = hilite
else:
col = gray
if self.centerOnLoad and process:
dx = (self.buildarea[0]/2) - stlObject.hxCenter
dy = (self.buildarea[1]/2) - stlObject.hyCenter
stlObject.deltaTranslation(dx, dy)
stlObject.applyDeltas()
d = []
for x,y in stlObject.hull:
d.extend(self.transform(x,self.buildarea[1]-y))
itemId = self.canvas.create_polygon(d, fill=col, outline="black", tag=stlObject.name, width=3)
self.selectable.append(itemId)
self.itemMap[itemId] = stlObject
if highlight:
self.setSelection(itemId)
def delStl(self):
if self.selection is None:
return
stlObj = self.itemMap[self.selection]
self.canvas.delete(stlObj.name)
self.selectable.remove(self.selection)
del self.itemMap[self.selection]
self.selection = None
def delAll(self):
objs = self.itemMap.values()
for o in objs:
self.canvas.delete(o.name)
self.selectable = []
self.itemMap = {}
self.selection = None
def commit(self):
if self.selection is not None:
o = self.itemMap[self.selection]
name = o.name
else:
name = ""
objs = self.itemMap.values()
self.selectable = []
self.itemMap = {}
for o in objs:
self.canvas.delete(o.name)
o.applyDeltas()
self.addStl(o, highlight=(o.name == name), process=False)
def getItemIdFromObject(self, obj):
for itemId in self.itemMap.keys():
if obj.name == self.itemMap[itemId].name:
return itemId
return None
def arrange(self):
def cmpobj(a, b):
return cmp(b.hArea, a.hArea)
omap = Map(self.buildarea)
maxx = maxy = -99999
minx = miny = 99999
objs = sorted(self.itemMap.values(), cmpobj)
for o in objs:
itemId = self.getItemIdFromObject(o)
if itemId is None: continue
x, y = omap.find(o.hxSize+self.arrangeMargin*2, o.hySize+self.arrangeMargin*2)
if x is None or y is None:
showinfo("Plate full", "Object %s does not fit" % o.name, parent=self)
else:
dx = x - o.hxCenter - o.translatex + o.hxSize/2 + self.arrangeMargin
dy = y - o.hyCenter - o.translatey + o.hySize/2 + self.arrangeMargin
self.setSelection(itemId)
self.app.setSelection(o)
self.moveStl(dx, dy)
deltax = o.hxSize+self.arrangeMargin*2
deltay = o.hySize+self.arrangeMargin*2
omap.mark(x, y, deltax, deltay)
if x < minx: minx=x
if x+deltax > maxx: maxx=x+deltax
if y < miny: miny=y
if y+deltay > maxy: maxy=y+deltay
dx = self.buildarea[0]/2-(maxx+minx)/2
dy = self.buildarea[1]/2-(maxy+miny)/2
for o in objs:
itemId = self.getItemIdFromObject(o)
if itemId is None: continue
self.setSelection(itemId)
self.app.setSelection(o)
self.moveStl(dx, dy)
def getStls(self):
return self.itemMap.values()
def countObjects(self):
return len(self.selectable)
def transform(self, ptx, pty):
x = (ptx+self.offsetx)*self.zoom*self.scale+self.gridOffset
y = (pty-self.offsety)*self.zoom*self.scale+self.gridOffset
return (x, y)
def triangulate(self, p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
d = math.sqrt(dx*dx + dy*dy)
return d
class Ex(Frame):
def __init__(self,parent):
Frame.__init__(self,parent)
self.parent = parent
self.x_before = 400
self.x_current = 400
self.y_before = 400
self.y_current = 400
self.FirstRun = True
self.AddVal = ADDVAL
self.AddVal_X = ADDVAL_X
self.initUI()
self.runRandWalk(STEPS)
self.FirstRun = False
self.Steps = STEPS
self.newSteps = STEPS
self.XStep = XSTEP
def initUI(self):
self.parent.title("Random Walk Lines 1")
self.pack(fill=BOTH,expand=1)
self.style = Style()
self.style.theme_use("default")
frame = Frame(self,relief=RAISED,borderwidth=2)
frame.pack(fill=BOTH,expand=True)
self.canvas = Canvas(frame)
self.canvas.create_line(10,400,790,400,dash=(4,2), width=2)
self.canvas.create_line(400,10,400,790,dash=(4,2), width=2)
self.canvas.pack(fill=BOTH,expand=1)
self.newWalkButton = Button(self,text="New Walk",
command=self.newWalk)
self.closeButton = Button(self,text="Close",
command=self.closeAll)
self.stepsButton = Button(self,text="Send Steps",
command=self.sendSteps)
self.xSizeButton = Button(self,text="Set X Step",
command=self.xSize)
self.ySizeButton = Button(self,text="Set Y Step",
command=self.ySize)
self.xSizeBox = Entry(self,width=10)
self.ySizeBox = Entry(self,width=10)
self.stepsBox = Entry(self,width=10)
# pack the buttons here
self.closeButton.pack(side=RIGHT,padx=5,pady=5)
self.newWalkButton.pack(side=RIGHT)
self.stepsButton.pack(side=RIGHT)
self.stepsBox.pack(side=RIGHT)
self.xSizeButton.pack(side=RIGHT)
self.xSizeBox.pack(side=RIGHT)
self.ySizeButton.pack(side=RIGHT)
self.ySizeBox.pack(side=RIGHT)
def ySize(self):
self.AddVal = int(self.ySizeBox.get())
def xSize(self):
self.AddVal_X = int(self.xSizeBox.get())
def sendSteps(self):
self.newSteps = int(self.stepsBox.get())
def newWalk(self):
for x in range(0,self.Steps):
getTag = "step"+str(x)
self.canvas.coords(getTag,(0,0,0,0))
self.Steps = self.newSteps
self.x_current = 400
self.x_before = 400
self.y_current = 400
self.y_before = 400
self.runRandWalk(self.Steps)
def closeAll(self):
Frame.quit(self)
def RandWalk(self,whichStep):
r = random.randint(0,1)
rx = random.randint(0,1)
addval = 0;
addval_x = 0;
toTag = "step"+str(whichStep)
if r == 0:
addval = (self.AddVal)
else:
addval = -(self.AddVal)
if rx==0:
addval_x = (self.AddVal_X)
else:
addval_x = -(self.AddVal_X)
self.y_current = self.y_before + addval
self.x_current = self.x_before + addval_x
if self.y_current < 200:
if self.y_before == 200:
if self.FirstRun == True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "green", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current),)
self.canvas.itemconfig(toTag,fill="green")
else:
if self.FirstRun == True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "green", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current))
self.canvas.itemconfig(toTag,fill="green")
else:
if self.y_before<200:
if self.FirstRun==True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "green", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current))
self.canvas.itemconfig(toTag,fill="green")
else:
if self.FirstRun==True:
self.canvas.create_line(self.x_before,self.y_before,
self.x_current,self.y_current,
fill = "red", width = 5,
tags=toTag)
else:
self.canvas.coords(toTag,(self.x_before,self.y_before,
self.x_current,self.y_current))
self.canvas.itemconfig(toTag,fill="red")
self.canvas.pack(fill=BOTH,expand=1)
self.x_before = self.x_current
self.y_before = self.y_current
def runRandWalk(self,steps):
for x in range(0,steps):
self.RandWalk(x)
class App(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.rect=dict()
self.max_width = 600
self.max_height = 600
self.initDimensions()
self.initUI()
self.reset_canvas()
for i in range(10):
self.updateCanvas()
for i in range(100):
self.newUpdate()
self.canvas.update_idletasks()
def initDimensions(self):
self.canvas_width = self.max_width
self.canvas_height = self.max_height
self.rows = 44
self.cols = 44
# self.h = 1;
self.cellwidth = self.canvas_width/self.cols
self.cellheight = self.canvas_height/self.rows
print self.cellheight,self.cellwidth
def updateDimensions(self,r,c,y=1):
self.rows = r
self.cols = c
self.cellwidth = self.max_width/self.cols
self.cellheight = self.max_height/self.rows
if(self.cellwidth<=self.cellheight):
self.cellheight = self.cellwidth
else:
self.cellwidth = self.cellheight
self.canvas_height = self.rows * self.cellheight
self.canvas_width = self.cols * self.cellwidth
def initUI(self):
self.parent.title("Test")
self.pack(fill=BOTH, expand=0)
area = Frame(self, width=500, height=500, borderwidth = 2, relief = 'sunken')
area.grid(row=1, column=0, columnspan=11, rowspan=4,
padx=5, sticky=E+W+S+N)
# self.updateDimensions(10, 70)
self.canvas = Canvas(area, bg='white', width=self.canvas_width, height=self.canvas_height)
self.canvas.pack()
# self.rowconfigure(0, pad =10)
# self.rowconfigure(1, pad =10)
def reset_canvas(self):
self.canvas.delete(ALL)
for col in range(self.cols):
for row in range(self.rows):
x1 = col * self.cellwidth
y1 = row * self.cellheight
x2 = x1 + self.cellwidth
y2 = y1 + self.cellheight
self.rect[self.rows - row - 1,col] = self.canvas.create_rectangle(x1,y1,x2,y2, fill="red", tags="rect", outline = 'black', width = 1)
def newUpdate(self):
start = time.clock()
self.canvas.delete(ALL)
self.rect=dict()
t = time.clock()
a = [random.randint(0, self.rows-1) for i in range(500)]
b = [random.randint(0, self.cols-1) for i in range(500)]
t1 = time.clock()
# print 'Random: ', time.clock() - t
for (row,col) in zip(a,b):
x1 = col * self.cellwidth
y1 = row * self.cellheight
x2 = x1 + self.cellwidth
y2 = y1 + self.cellheight
if (row,col) not in self.rect:
self.rect[row,col] = self.canvas.create_rectangle(x1,y1,x2,y2, fill="red", tags="rect", outline = 'black', width = 0)
# print 'Time : ', time.clock() - start - (t1-t)
# print 'Size of data(2):', len(self.rect)
# print a
# print b
def updateCanvas(self):
start = time.clock()
for col in range(self.rows):
for row in range(self.cols):
self.canvas.itemconfig(self.rect[row,col],fill='white')
def start():
""" Calaculates several values for the game's run."""
global canvas, mainChar, root, i, k, bob, Link, bill, f, g, enemy
user32 = ctypes.windll.user32 #renders size to fullscreen
w = int(user32.GetSystemMetrics(0))
h = int(user32.GetSystemMetrics(1))
f = int(w/40) # calculates how many tiles needed
g = int(h/40)
print w
root = Tk()
root.title("Transparency")
frame = Frame(root)
canvas = Canvas(frame, bg="black", width=w, height=h)
w, h = root.winfo_screenwidth(), root.winfo_screenheight()
print w, h
root.overrideredirect(1)
root.geometry("%dx%d+0+0" % (w, h))
root.focus_set() # <-- move focus to this widget
root.bind("<Escape>", quitApp) # All root bindings
root.bind("w", moveUp)
root.bind("s", moveDown)
root.bind("a", moveLeft)
root.bind("d", moveRight)
#root.bind("h", healthPotion)
root.bind("<space>", useItem)
root.bind("b", bossSpawn)
canvas.pack()
photoimage = ImageTk.PhotoImage(Image.open("dungeonTile.jpg"))
mainChar = ImageTk.PhotoImage(Image.open("CobaltKnight.png"))
enemy = ImageTk.PhotoImage(Image.open("LobsterRoach.png"))
im = Image.open("Karel.png")
print im.mode
x = 0
y = 0
print bill, "bill"
if bill == 0:
for i in range(f+1):
for k in range(g+1):
canvas.create_image(i*40, k*40, image=photoimage)
bill = 1
mainSpawn() #spawns main
mobSpawn(canvas,enemy) #spawns mobs
#bob = Label(canvas,width=w,height=h, text = "health", fg = 'red', font = ('Times', 30, 'bold'), anchor = 'nw')
#bob.pack()
bob = canvas.create_text(40,40, text = "bob", fill = "red", font = ('Times', 30, 'bold'), anchor = 'nw')
bar = "health " + str(Link.getHealth()) + "/" + str(Link.getMaxHealth())
canvas.itemconfig(bob, text=bar)
canvas.create_rectangle(w-120, 40 , w-40, 120, fill='black', outline = 'white')
canvas.create_rectangle(w-240, 40 , w-160, 120, fill='black', outline = 'white')
#createInterface(bob,canvas,i,k,Link.getHealth(),Link.getMaxHealth()) #creates user interface
#bob.pack()
frame.pack()
print "music"
#canvas.create_text(i,k, text = "health", fill = 'red', font = ('Times', 30, 'bold'), anchor = 'nw')
#f= wave.open( 'Naruto-Breakdown.wav', 'rb' )
#sampleRate= f.getframerate()
#channels= f.getnchannels()
#format = sound.AFMT_S16_LE
#snd= sound.Output( sampleRate, channels, format )
#s= f.readframes( 300000 )
#snd.play( s )
#while snd.isPlaying(): time.sleep( 0.05 )
#canvas.pack()
root.mainloop()
class ProgressBar:
def __init__(self,
master=None,
orientation="horizontal",
min=0,
max=100,
width=100,
height=18,
doLabel=1,
appearance="sunken",
fillColor="blue",
background="gray",
labelColor="yellow",
labelFont="Verdana",
labelText="",
labelFormat="%d%%",
value=0,
bd=2):
# preserve various values
self.master = master
self.orientation = orientation
self.min = min
self.max = max
self.width = width
self.height = height
self.doLabel = doLabel
self.fillColor = fillColor
self.labelFont = labelFont
self.labelColor = labelColor
self.background = background
self.labelText = labelText
self.labelFormat = labelFormat
self.value = value
self.frame = Frame(master, relief=appearance, bd=bd)
self.canvas = Canvas(self.frame,
height=height,
width=width,
bd=0,
highlightthickness=0,
background=background)
self.scale = self.canvas.create_rectangle(0,
0,
width,
height,
fill=fillColor)
self.label = self.canvas.create_text(self.canvas.winfo_reqwidth() / 2,
height / 2,
text=labelText,
anchor="c",
fill=labelColor,
font=self.labelFont)
self.update()
self.canvas.pack(side='top', fill='x', expand='no')
def updateProgress(self, newValue, newMax=None):
if newMax:
self.max = newMax
self.value = newValue
self.update()
def update(self):
# Trim the values to be between min and max
value = self.value
if value > self.max:
value = self.max
if value < self.min:
value = self.min
# Adjust the rectangle
if self.orientation == "horizontal":
self.canvas.coords(self.scale, 0, 0,
float(value) / self.max * self.width,
self.height)
else:
self.canvas.coords(
self.scale, 0,
self.height - (float(value) / self.max * self.height),
self.width, self.height)
# Now update the colors
self.canvas.itemconfig(self.scale, fill=self.fillColor)
self.canvas.itemconfig(self.label, fill=self.labelColor)
# And update the label
if self.doLabel:
if value:
if value >= 0:
pvalue = int((float(value) / float(self.max)) * 100.0)
else:
pvalue = 0
self.canvas.itemconfig(self.label,
text=self.labelFormat % pvalue)
else:
self.canvas.itemconfig(self.label, text='')
else:
self.canvas.itemconfig(self.label,
text=self.labelFormat % self.labelText)
self.canvas.update_idletasks()
class World(Tk):
# def __init__(self,filename=None,block=50,debug=True,delay=0.25,image=False,width=10,height=10):
def __init__(self,
filename=None,
block=50,
debug=True,
delay=0.25,
image=True,
width=10,
height=10):
Tk.__init__(self)
self.title("")
arg, self.width, self.height = block, width, height
self.photos = [
PhotoImage(file=(k + ".gif"))
for k in ["east", "north", "west", "south"]
]
self.beepers, self.ovals, self.numbers, self.robots, self.walls = {},{},{},{},{}
self.m, self.n, self.t, self.delay = arg * (width + 3), arg * (
height + 3), arg, delay
self.debug, self.useImage = debug, image
a, b, c = self.t + self.t / 2, self.m - self.t - self.t / 2, self.n - self.t - self.t / 2
self.canvas = Canvas(self, bg="white", width=self.m, height=self.n)
self.canvas.pack()
count = 1
for k in range(2 * self.t, max(self.m, self.n) - self.t, self.t):
if k < b:
self.canvas.create_line(k, c, k, a, fill="red")
self.canvas.create_text(k,
c + self.t / 2,
text=str(count),
font=("Times",
max(-self.t * 2 / 3, -15), ""))
if k < c:
self.canvas.create_line(b, k, a, k, fill="red")
self.canvas.create_text(a - self.t / 2,
self.n - k,
text=str(count),
font=("Times",
max(-self.t * 2 / 3, -15), ""))
count += 1
self.canvas.create_line(a, c, b, c, fill="black", width=3)
self.canvas.create_line(a, a, a, c, fill="black", width=3)
if filename is not None:
self.readWorld(filename)
self.refresh()
def readWorld(self, filename):
try:
infile = open("worlds\\%s.wld" % filename, "r")
except IOError:
try:
infile = open("worlds/%s.wld" % filename, "r")
except IOError:
infile = open(filename, "r")
text = infile.read().split("\n")
infile.close()
for t in text:
if t.startswith("eastwestwalls"):
s = t.split(" ")
y, x = int(s[1]), int(s[2])
self.addWall(x, y, -1, y)
if t.startswith("northsouthwalls"):
s = t.split(" ")
x, y = int(s[1]), int(s[2])
self.addWall(x, y, x, -1)
if t.startswith("beepers"):
s = t.split(" ")
y, x, n = int(s[1]), int(s[2]), int(s[3])
if n is infinity:
self.addInfiniteBeepers(x, y)
else:
for k in range(n):
self.addBeeper(x, y)
def pause(self):
sleep(self.delay)
def isBeeper(self, x, y):
return (x, y) in self.beepers.keys() and not self.beepers[(x, y)] == 0
def countRobots(self, x, y):
if (x, y) not in self.robots.keys():
return 0
return len(self.robots[(x, y)])
def crash(self, x1, y1, x2, y2):
if 0 in (x1, y1, x2, y2):
return True
if (x2, y2) in self.walls.keys() and (x1, y1) in self.walls[(x2, y2)]:
return True
if (x1, y1) in self.walls.keys() and (x2, y2) in self.walls[(x1, y1)]:
return True
return False
def addInfiniteBeepers(self, x, y):
flag = (x, y) not in self.beepers.keys() or self.beepers[(x, y)] is 0
self.beepers[(x, y)] = infinity
text = "oo"
a, b = self.t + x * self.t, self.n - (self.t + y * self.t)
t = self.t / 3
if flag:
self.ovals[(x, y)] = self.canvas.create_oval(a - t,
b - t,
a + t,
b + t,
fill="black")
self.numbers[(x, y)] = self.canvas.create_text(
a,
b,
text=text,
fill="white",
font=("Times", max(-self.t / 2, -20), ""))
else:
self.canvas.itemconfig(self.numbers[(x, y)], text=text)
if (x, y) in self.robots.keys():
for robot in self.robots[(x, y)]:
robot.lift()
def addBeeper(self, x, y):
if (x, y) in self.beepers.keys() and self.beepers[(x, y)] is infinity:
return
flag = (x, y) not in self.beepers.keys() or self.beepers[(x, y)] is 0
if flag:
self.beepers[(x, y)] = 1
else:
self.beepers[(x, y)] += 1
text = str(self.beepers[(x, y)])
a, b = self.t + x * self.t, self.n - (self.t + y * self.t)
t = self.t / 3
if flag:
self.ovals[(x, y)] = self.canvas.create_oval(a - t,
b - t,
a + t,
b + t,
fill="black")
self.numbers[(x, y)] = self.canvas.create_text(
a,
b,
text=text,
fill="white",
font=("Times", max(-self.t / 2, -20), ""))
else:
self.canvas.itemconfig(self.numbers[(x, y)], text=text)
if (x, y) in self.robots.keys():
for robot in self.robots[(x, y)]:
robot.lift()
def removeBeeper(self, x, y):
if self.beepers[(x, y)] is infinity:
return
self.beepers[(x, y)] -= 1
flag = self.beepers[(x, y)] is 0
text = str(self.beepers[(x, y)])
if flag:
self.canvas.delete(self.ovals[(x, y)])
self.canvas.delete(self.numbers[(x, y)])
else:
self.canvas.itemconfig(self.numbers[(x, y)], text=text)
if (x, y) in self.robots.keys():
for robot in self.robots[(x, y)]:
robot.lift()
def addWall(self, x1, y1, x2, y2):
if not x1 == x2 and not y1 == y2:
return
if x1 == x2:
y1, y2 = min(y1, y2), max(y1, y2)
if y1 == -1:
y1 = y2
for k in range(y1, y2 + 1):
self.walls.setdefault((x1, k), []).append((x1 + 1, k))
a, b = self.t + x1 * self.t + self.t / 2, self.n - (
self.t + k * self.t) + self.t / 2
c, d = self.t + x1 * self.t + self.t / 2, self.n - (
self.t + k * self.t) - self.t / 2
self.canvas.create_line(a,
b + 1,
c,
d - 1,
fill="black",
width=3)
else:
x1, x2 = min(x1, x2), max(x1, x2)
if x1 == -1:
x1 = x2
for k in range(x1, x2 + 1):
self.walls.setdefault((k, y1), []).append((k, y1 + 1))
a, b = self.t + k * self.t - self.t / 2, self.n - (
self.t + y1 * self.t) - self.t / 2
c, d = self.t + k * self.t + self.t / 2, self.n - (
self.t + y1 * self.t) - self.t / 2
self.canvas.create_line(a - 1,
b,
c + 1,
d,
fill="black",
width=3)
def draw(self, x, y, d, img):
if self.useImage:
if img is not None:
self.canvas.delete(img)
x, y = self.t + x * self.t, self.n - (self.t + y * self.t)
photo = self.photos[d / 90]
img = self.canvas.create_image(x, y, image=photo)
return img
else:
t, angle = self.t / 2, 120
x, y = self.t + x * self.t, self.n - (self.t + y * self.t)
x1, y1 = x + 3**0.5 * t / 2 * cos(
radians(d)), y - 3**0.5 * t / 2 * sin(radians(d))
x2, y2 = x + t * cos(radians(d + angle)), y - t * sin(
radians(d + angle))
x3, y3 = x + t / 4 * cos(radians(d + 180)), y - t / 4 * sin(
radians(d + 180))
x4, y4 = x + t * cos(radians(d - angle)), y - t * sin(
radians(d - angle))
if img is not None:
self.canvas.delete(img)
img = self.canvas.create_polygon(x1,
y1,
x2,
y2,
x3,
y3,
x4,
y4,
fill="blue")
return img
def erase(self, img):
self.canvas.delete(img)
def recordMove(self, count, x1, y1, x2, y2):
for robot in self.robots[(x1, y1)]:
if robot.count == count:
self.robots[(x1, y1)].remove(robot)
self.robots.setdefault((x2, y2), []).append(robot)
break
def lift(self, img):
self.canvas.lift(img)
def refresh(self):
self.canvas.update()
self.pause()
def register(self, x, y, robot):
self.robots.setdefault((x, y), []).append(robot)
def remove(self, x, y, robot):
self.robots[(x, y)].remove(robot)
class ResultsFrame(Frame):
"Class which controls the results screen of the spelling aid"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
#Create UI elements
self.results_list = ResultsTable(self.parent, height=160, width=250)
buttonRetry = Button(self.parent, text="Retry", width=10,
command=self.restart)
buttonNewlist = Button(self.parent, text="New List", width=10,
command=self.new_selection)
buttonExit = Button(self.parent, text="Quit", width=10,
command=self.parent.destroy)
self.results_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
font = ("Helvetica", 20)
self.results_canvas.create_text(300, 15, text="Results", fill="#004183",
font=font)
self.results_canvas.create_window(310, 35, window=self.results_list,
anchor=NW)
self.results_canvas.create_window(150, 230, window=buttonRetry)
self.results_canvas.create_window(300, 230, window=buttonNewlist)
self.results_canvas.create_window(450, 230, window=buttonExit)
self.results_canvas.create_text(25, 55, font=font, text="List:",
anchor=W)
self.results_canvas.create_text(25, 85, font=font, text="Score:",
anchor=W)
self.results_canvas.create_text(25, 115, font=font, text="Time:",
anchor=W)
self.results_canvas.create_text(25, 145, font=font, text="Best Score:",
anchor=W)
self.results_canvas.create_text(25, 175, font=font, text="Best Time:",
anchor=W)
self.list_name = self.results_canvas.create_text(300, 55, font=font,
anchor=E)
self.score_number = self.results_canvas.create_text(300, 85, font=font,
anchor=E)
self.time_number = self.results_canvas.create_text(300, 115, font=font,
anchor=E)
self.best_score = self.results_canvas.create_text(300, 145, font=font,
anchor=E)
self.best_time = self.results_canvas.create_text(300, 175, font=font,
anchor=E)
self.results_canvas.pack()
def calculate(self, word_list, time_elapsed):
"""Calculate and display the users score and time, as well as personal
bests"""
score = 0
user_id = self.parent.user.uid
list_id = word_list.l_id
self.results_list.add_list(word_list.words)
for word in word_list.words:
if word.isCorrect:
score += 1
previous_records = self.parent.db.sql("""SELECT best_score, best_time
FROM user_list_map WHERE list_id = '%d'
AND user_id = '%d'"""
%(list_id, user_id))
try:
best_score = max(score, previous_records[0][0])
best_time = min(time_elapsed, previous_records[0][1])
self.parent.db.sql("""UPDATE user_list_map SET best_score='%d',
best_time='%d' WHERE list_id = '%d' AND
user_id = '%d'"""
%(best_score, best_time, list_id, user_id))
except IndexError:
#If the list has not been played before, create a record
best_score = score
best_time = time_elapsed
print "Creating"
self.parent.db.sql("""INSERT INTO user_list_map VALUES
('%d', '%d', '%d', '%d')"""
%(user_id, list_id, best_score, best_time))
self.results_canvas.itemconfig(self.list_name, text=word_list.name)
self.results_canvas.itemconfig(self.score_number, text=score)
self.results_canvas.itemconfig(self.time_number, text=time_elapsed)
self.results_canvas.itemconfig(self.best_score, text=best_score)
self.results_canvas.itemconfig(self.best_time, text=best_time)
def restart(self):
"""Clear the results page and restart the game with the current list"""
self.results_list.clear()
self.parent.start_game(self.parent.current_list)
def new_selection(self):
"""Clear the results page and return to the start screen"""
self.results_list.clear()
self.parent.new_list()
def draw_board(root):
"""
Create the graphical user interface.
"""
# provide the title that will be shown in the header
root.title("Bonbon Crumble")
# Indicate which variables of the program will be altered
# ! In order to manipulate variables that are part of the program
# ! but exist outside of the function, you need to indicate that you want
# ! to use and alter these variables by declaring them as "global"
global canvas, board, ovals, progress_label, points_label, points_field, \
max_label, max_field, swaps_left_label, swaps_left_field
# canvas will be the main board used for mastermind
# ! to create a canvas, the constructor is called
# ! (i.e. name of the class and required parameters)
canvas = Canvas(root, bg="white",
height=DIMENSION * (BONBON_SIZE + BONBON_SPACING) + 100,
width=DIMENSION * (BONBON_SIZE + BONBON_SPACING))
# Draw the empty circles representing the guesses
create_ovals(DIMENSION, DIMENSION)
# Fill circles with initial colors
init_board(DIMENSION)
canvas.create_line(0,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING),
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 10,
width=2)
# Draw the progress label
progress_label = Label(canvas, text=">> Select first bonbon.")
canvas.create_window(10, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 15,
anchor=NW, window=progress_label)
canvas.create_line(0,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 40,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING),
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 40,
width=1)
# Draw the swaps left label and field
swaps_left_label = Label(canvas, text="Swaps left:")
canvas.create_window(10, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=swaps_left_label)
swaps_left_field = Label(canvas, text=remaining_swaps, bg="white")
canvas.create_window(2 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=swaps_left_field)
# Draw the points label and field
points_label = Label(canvas, text="Score:", font=16)
canvas.create_window(3 * (BONBON_SIZE + BONBON_SPACING),
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=points_label)
points_field = Label(canvas, text="0", font=16)
canvas.create_window(4 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=points_field)
# Draw the max points label and field
max_label = Label(canvas, text="Max score:")
canvas.create_window(5 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=max_label)
max_field = Label(canvas, text="n/a", bg="white")
canvas.create_window(7 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=max_field)
canvas.itemconfig(max_field, fill="red")
# Draw the quit button
quit_button = Button(canvas, text="Quit", command=root.destroy)
quit_button.configure(width=5, relief=FLAT)
canvas.create_window(10, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 75,
anchor=NW, window=quit_button)
# Draw the max button
max_button = Button(canvas, text="Calculate maximum score", command=get_maximum_score)
max_button.configure(width=20, relief=FLAT)
canvas.create_window(100, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 75,
anchor=NW, window=max_button)
# draw the canvas
canvas.pack()
class MoveControl(LabelFrame):
def __init__(self, root, prtr, settings, log, *arg):
fn = os.path.join(settings.cmdFolder, "images", "control_xyz.png")
self.image = Image.open(fn)
self.photo = ImageTk.PhotoImage(self.image)
LabelFrame.__init__(self, root, *arg, text="Movement")
self.app = root
self.hilite = None
self.hilitemask = None
self.settings = settings
self.printer = prtr
self.log = log
l = Label(self, text="mm/min")
l.grid(row=1, column=2)
l = Label(self, text="X/Y Feed Rate:")
l.grid(row=2, column=1, sticky=E)
self.xyfeed = Spinbox(self, width=10, justify=RIGHT, from_=0, to=MAXFEED)
self.xyfeed.grid(row=2, column=2)
self.xyfeed.delete(0, END)
self.xyfeed.insert(0, settings.xyfeed)
self.xyfeed.bind("<FocusOut>", self.valxyFeed)
self.xyfeed.bind("<Leave>", self.valxyFeed)
l = Label(self, text="Z Feed Rate:")
l.grid(row=3, column=1, sticky=E)
self.zfeed = Spinbox(self, width=10, justify=RIGHT, from_=0, to=MAXFEED)
self.zfeed.grid(row=3, column=2)
self.zfeed.delete(0, END)
self.zfeed.insert(0, settings.zfeed)
self.zfeed.bind("<FocusOut>", self.valzFeed)
self.zfeed.bind("<Leave>", self.valzFeed)
self.canvas = Canvas(self, width=self.image.size[0], height=self.image.size[1], *arg)
self.canvas.create_image((0, 0), image=self.photo, anchor=N+W)
self.canvas.grid(row=4, column=1, columnspan=2)
for m in imageMasks:
self.canvas.create_oval((m[0][0]-mask_rad, m[0][1]-mask_rad, m[0][0]+mask_rad, m[0][1]+mask_rad),
outline="#FF0000", width=4, tags=m[1], state=HIDDEN)
self.canvas.bind("<Button-1>", self.OnLeftDown)
self.canvas.bind("<Motion>", self.OnMotion)
self.canvas.bind("<Enter>", self.OnEnter)
self.canvas.bind("<Leave>", self.OnLeave)
self.bAllOff = Button(self, text="Release Motors", command=self.allMotorsOff)
self.bAllOff.grid(row=5, column=1, columnspan=2)
def valxyFeed(self, *arg):
x = self.validFeed(self.xyfeed.get(), 'XY')
if x == None:
self.xyfeed.delete(0, END)
self.xyfeed.insert(0, "%d" % self.settings.xyfeed)
return True
if self.settings.xyfeed != x:
self.settings.xyfeed = x
self.settings.setModified()
return True
def valzFeed(self, *arg):
x = self.validFeed(self.zfeed.get(), 'Z')
if x == None:
self.zfeed.delete(0, END)
self.zfeed.insert(0, "%d" % self.settings.zfeed)
return True
if self.settings.zfeed != x:
self.settings.zfeed = x
self.settings.setModified()
return True
def validFeed(self, fv, axis):
try:
x = int(fv)
except:
self.log.logMsg("Value for %s feed rate not a valid integer" % axis)
return None
if x <=0 or x >MAXFEED:
self.log.logMsg("Value for %s feed rate out of range(0-5000)" % axis)
return None
return x
def allMotorsOff(self):
if self.app.printerAvailable(cmd="M84"):
self.printer.send_now("M84")
def OnMotion(self, e):
for i in range(len(imageGeometry)):
if boundBy((e.x, e.y), imageGeometry[i][0]):
self.setHilite(i)
return
if self.hilite != None:
self.clearHilite()
def OnEnter(self, e):
self.clearHilite()
def OnLeave(self, e):
self.clearHilite()
def setHilite(self, i):
if i != self.hilite:
self.canvas.delete("HILITE")
self.canvas.create_rectangle(imageGeometry[i][0], outline="#C85E5D", width=3, fill="gray", stipple="gray50", tags="HILITE")
self.hilite = i
if self.hilitemask:
self.canvas.itemconfig(self.hilitemask, state=HIDDEN)
if imageGeometry[i][2]:
self.hilitemask = imageGeometry[i][2]
self.canvas.itemconfig(self.hilitemask, state=NORMAL)
def clearHilite(self):
self.canvas.delete("HILITE")
self.hilite = None
self.hilitemask = None
for m in imageMasks:
self.canvas.itemconfig(m[1], state=HIDDEN)
def OnLeftDown(self, e):
if self.app.printerAvailable(cmd="G1"):
for g in imageGeometry:
if boundBy((e.x, e.y), g[0]):
if "G1" in g[1]:
if "X" in g[1]:
feed = self.settings.xyfeed
elif "Y" in g[1]:
feed = self.settings.xyfeed
elif "Z" in g[1]:
feed = self.settings.zfeed
else:
feed = 100
self.printer.send_now("G91")
self.printer.send_now(g[1] + " F" + str(feed))
self.printer.send_now("G90")
else:
self.printer.send_now(g[1])
break
class Plotter(GenericPlotter):
def __init__(self, windowTitle='TopoVis', params=None):
GenericPlotter.__init__(self, params)
self.nodes = {}
self.links = {}
self.nodeLinks = {}
self.lineStyles = {}
self.shapes = {}
self.windowTitle = windowTitle
self.prepareCanvas()
self.lastShownTime = 0
###################
def prepareCanvas(self):
self.tk = Tk()
self.tk.title(self.windowTitle)
self.canvas = Canvas(self.tk, width=850, height=850)
self.canvas.pack(fill=BOTH, expand=YES)
self.createText('time', 0, 0, text="time=0.0 seconds")
###################
def setTime(self, time):
if time - self.lastShownTime > 0.00001:
self.updateText('time', text='Time: %.5f seconds' % time)
self.lastShownTime = time
###################
def updateNodePosAndSize(self, ident):
p = self.params
c = self.canvas
if ident not in self.nodes.keys():
node_tag = c.create_oval(0, 0, 0, 0)
label_tag = c.create_text(0, 0, text=str(ident))
self.nodes[ident] = (node_tag, label_tag)
else:
(node_tag, label_tag) = self.nodes[ident]
node = self.scene.nodes[ident]
nodesize = node.scale * p.nodesize
x1 = node.pos[0] - nodesize
y1 = node.pos[1] - nodesize
(x2, y2) = (x1 + nodesize * 2, y1 + nodesize * 2)
c.coords(node_tag, x1, y1, x2, y2)
c.coords(label_tag, node.pos)
for link in self.nodeLinks[ident]:
self.updateLink(*link)
###################
def configLine(self, tagOrId, style):
config = {}
config['fill'] = colorStr(style.color)
config['width'] = style.width
config['arrow'] = arrowMap[style.arrow]
config['dash'] = style.dash
self.canvas.itemconfigure(tagOrId, **config)
###################
def configPolygon(self, tagOrId, lineStyle, fillStyle):
config = {}
config['outline'] = colorStr(lineStyle.color)
config['width'] = lineStyle.width
config['dash'] = lineStyle.dash
config['fill'] = colorStr(fillStyle.color)
self.canvas.itemconfigure(tagOrId, **config)
###################
def createLink(self, src, dst, style):
if src == dst:
raise RuntimeError('Source and destination are the same node')
p = self.params
c = self.canvas
(x1, y1, x2, y2) = computeLinkEndPoints(self.scene.nodes[src],
self.scene.nodes[dst],
p.nodesize)
link_obj = c.create_line(x1, y1, x2, y2, tags='link')
self.configLine(link_obj, self.scene.lineStyles[style])
return link_obj
###################
def updateLink(self, src, dst, style):
p = self.params
c = self.canvas
link_obj = self.links[(src, dst, style)]
(x1, y1, x2, y2) = computeLinkEndPoints(self.scene.nodes[src],
self.scene.nodes[dst],
p.nodesize)
c.coords(link_obj, x1, y1, x2, y2)
###################
def node(self, ident, x, y):
self.nodeLinks[ident] = []
self.updateNodePosAndSize(ident)
self.tk.update()
###################
def nodemove(self, ident, x, y):
self.updateNodePosAndSize(ident)
self.tk.update()
###################
def nodecolor(self, ident, r, g, b):
(node_tag, label_tag) = self.nodes[ident]
self.canvas.itemconfig(node_tag, outline=colorStr((r, g, b)))
self.canvas.itemconfigure(label_tag, fill=colorStr((r, g, b)))
self.tk.update()
###################
def nodewidth(self, ident, width):
(node_tag, label_tag) = self.nodes[ident]
self.canvas.itemconfig(node_tag, width=width)
self.tk.update()
###################
def nodescale(self, ident, scale):
# scale attribute has been set by TopoVis
# just update the node
self.updateNodePosAndSize(ident)
self.tk.update()
###################
def nodelabel(self, ident, label):
(node_tag, label_tag) = self.nodes[ident]
self.canvas.itemconfigure(label_tag,
text=self.scene.nodes[ident].label)
self.tk.update()
###################
def addlink(self, src, dst, style):
self.nodeLinks[src].append((src, dst, style))
self.nodeLinks[dst].append((src, dst, style))
self.links[(src, dst, style)] = self.createLink(src, dst, style)
self.tk.update()
###################
def dellink(self, src, dst, style):
self.nodeLinks[src].remove((src, dst, style))
self.nodeLinks[dst].remove((src, dst, style))
self.canvas.delete(self.links[(src, dst, style)])
del self.links[(src, dst, style)]
self.tk.update()
###################
def clearlinks(self):
self.canvas.delete('link')
self.links.clear()
for n in self.nodes:
self.nodeLinks[n] = []
self.tk.update()
###################
def circle(self, x, y, r, ident, linestyle, fillstyle):
if ident in self.shapes.keys():
self.canvas.delete(self.shapes[ident])
del self.shapes[ident]
self.shapes[ident] = self.canvas.create_oval(x - r, y - r, x + r,
y + r)
self.configPolygon(self.shapes[ident], linestyle, fillstyle)
self.tk.update()
###################
def line(self, x1, y1, x2, y2, ident, linestyle):
if ident in self.shapes.keys():
self.canvas.delete(self.shapes[ident])
del self.shapes[ident]
self.shapes[ident] = self.canvas.create_line(x1, y1, x2, y2)
self.configLine(self.shapes[ident], linestyle)
self.tk.update()
###################
def rect(self, x1, y1, x2, y2, ident, linestyle, fillstyle):
if ident in self.shapes.keys():
self.canvas.delete(self.shapes[ident])
del self.shapes[ident]
self.shapes[ident] = self.canvas.create_rectangle(x1, y1, x2, y2)
self.configPolygon(self.shapes[ident], linestyle, fillstyle)
self.tk.update()
###################
def createText(self, ident, *args, **kwargs):
self.shapes[ident] = self.canvas.create_text(*args,
anchor=NW,
**kwargs)
###################
def updateText(self, ident, text):
self.canvas.itemconfigure(self.shapes[ident], text=text)
###################
def delshape(self, ident):
if ident in self.shapes.keys():
self.canvas.delete(self.shapes[ident])
self.tk.update()
class NvimTk(object):
"""Wraps all nvim/tk event handling."""
def __init__(self, nvim):
"""Initialize with a Nvim instance."""
self._nvim = nvim
self._attrs = {}
self._nvim_updates = deque()
self._canvas = None
self._fg = '#000000'
self._bg = '#ffffff'
def run(self):
"""Start the UI."""
self._tk_setup()
t = Thread(target=self._nvim_event_loop)
t.daemon = True
t.start()
self._root.mainloop()
def _tk_setup(self):
self._root = Tk()
self._root.bind('<<nvim_redraw>>', self._tk_nvim_redraw)
self._root.bind('<<nvim_detach>>', self._tk_nvim_detach)
self._root.bind('<Key>', self._tk_key)
def _tk_nvim_redraw(self, *args):
update = self._nvim_updates.popleft()
for update in update:
handler = getattr(self, '_tk_nvim_' + update[0])
for args in update[1:]:
handler(*args)
def _tk_nvim_detach(self, *args):
self._root.destroy()
def _tk_nvim_resize(self, width, height):
self._tk_redraw_canvas(width, height)
def _tk_nvim_clear(self):
self._tk_clear_region(0, self._height - 1, 0, self._width - 1)
def _tk_nvim_eol_clear(self):
row, col = (self._cursor_row, self._cursor_col,)
self._tk_clear_region(row, row, col, self._scroll_right)
def _tk_nvim_cursor_goto(self, row, col):
self._cursor_row = row
self._cursor_col = col
def _tk_nvim_cursor_on(self):
pass
def _tk_nvim_cursor_off(self):
pass
def _tk_nvim_mouse_on(self):
pass
def _tk_nvim_mouse_off(self):
pass
def _tk_nvim_insert_mode(self):
pass
def _tk_nvim_normal_mode(self):
pass
def _tk_nvim_set_scroll_region(self, top, bot, left, right):
self._scroll_top = top
self._scroll_bot = bot
self._scroll_left = left
self._scroll_right = right
def _tk_nvim_scroll(self, count):
top, bot = (self._scroll_top, self._scroll_bot,)
left, right = (self._scroll_left, self._scroll_right,)
if count > 0:
destroy_top = top
destroy_bot = top + count - 1
move_top = destroy_bot + 1
move_bot = bot
fill_top = move_bot + 1
fill_bot = fill_top + count - 1
else:
destroy_top = bot + count + 1
destroy_bot = bot
move_top = top
move_bot = destroy_top - 1
fill_bot = move_top - 1
fill_top = fill_bot + count + 1
# destroy items that would be moved outside the scroll region after
# scrolling
# self._tk_clear_region(destroy_top, destroy_bot, left, right)
# self._tk_clear_region(move_top, move_bot, left, right)
self._tk_destroy_region(destroy_top, destroy_bot, left, right)
self._tk_tag_region('move', move_top, move_bot, left, right)
self._canvas.move('move', 0, -count * self._rowsize)
self._canvas.dtag('move', 'move')
# self._tk_fill_region(fill_top, fill_bot, left, right)
def _tk_nvim_highlight_set(self, attrs):
self._attrs = attrs
def _tk_nvim_put(self, data):
# choose a Font instance
font = self._fnormal
if self._attrs.get('bold', False):
font = self._fbold
if self._attrs.get('italic', False):
font = self._fbolditalic if font == self._fbold else self._fitalic
# colors
fg = "#{0:0{1}x}".format(self._attrs.get('foreground', self._fg), 6)
bg = "#{0:0{1}x}".format(self._attrs.get('background', self._bg), 6)
# get the "text" and "rect" which correspond to the current cell
x, y = self._tk_get_coords(self._cursor_row, self._cursor_col)
items = self._canvas.find_overlapping(x, y, x + 1, y + 1)
if len(items) != 2:
# caught part the double-width character in the cell to the left,
# filter items which dont have the same horizontal coordinate as
# "x"
predicate = lambda item: self._canvas.coords(item)[0] == x
items = filter(predicate, items)
# rect has lower id than text, sort to unpack correctly
rect, text = sorted(items)
self._canvas.itemconfig(text, fill=fg, font=font, text=data or ' ')
self._canvas.itemconfig(rect, fill=bg)
self._tk_nvim_cursor_goto(self._cursor_row, self._cursor_col + 1)
def _tk_nvim_bell(self):
self._root.bell()
def _tk_nvim_update_fg(self, fg):
self._fg = "#{0:0{1}x}".format(fg, 6)
def _tk_nvim_update_bg(self, bg):
self._bg = "#{0:0{1}x}".format(bg, 6)
def _tk_redraw_canvas(self, width, height):
if self._canvas:
self._canvas.destroy()
self._fnormal = Font(family='Monospace', size=13)
self._fbold = Font(family='Monospace', weight='bold', size=13)
self._fitalic = Font(family='Monospace', slant='italic', size=13)
self._fbolditalic = Font(family='Monospace', weight='bold',
slant='italic', size=13)
self._colsize = self._fnormal.measure('A')
self._rowsize = self._fnormal.metrics('linespace')
self._canvas = Canvas(self._root, width=self._colsize * width,
height=self._rowsize * height)
self._tk_fill_region(0, height - 1, 0, width - 1)
self._cursor_row = 0
self._cursor_col = 0
self._scroll_top = 0
self._scroll_bot = height - 1
self._scroll_left = 0
self._scroll_right = width - 1
self._width, self._height = (width, height,)
self._canvas.pack()
def _tk_fill_region(self, top, bot, left, right):
# create columns from right to left so the left columns have a
# higher z-index than the right columns. This is required to
# properly display characters that cross cell boundary
for rownum in range(bot, top - 1, -1):
for colnum in range(right, left - 1, -1):
x1 = colnum * self._colsize
y1 = rownum * self._rowsize
x2 = (colnum + 1) * self._colsize
y2 = (rownum + 1) * self._rowsize
# for each cell, create two items: The rectangle is used for
# filling background and the text is for cell contents.
self._canvas.create_rectangle(x1, y1, x2, y2,
fill=self._background, width=0)
self._canvas.create_text(x1, y1, anchor='nw',
font=self._fnormal, width=1,
fill=self._foreground, text=' ')
def _tk_clear_region(self, top, bot, left, right):
self._tk_tag_region('clear', top, bot, left, right)
self._canvas.itemconfig('clear', fill=self._bg)
self._canvas.dtag('clear', 'clear')
def _tk_destroy_region(self, top, bot, left, right):
self._tk_tag_region('destroy', top, bot, left, right)
self._canvas.delete('destroy')
self._canvas.dtag('destroy', 'destroy')
def _tk_tag_region(self, tag, top, bot, left, right):
x1, y1 = self._tk_get_coords(top, left)
x2, y2 = self._tk_get_coords(bot, right)
self._canvas.addtag_overlapping(tag, x1, y1, x2 + 1, y2 + 1)
def _tk_get_coords(self, row, col):
x = col * self._colsize
y = row * self._rowsize
return x, y
def _tk_key(self, event):
if 0xffe1 <= event.keysym_num <= 0xffee:
# this is a modifier key, ignore. Source:
# https://www.tcl.tk/man/tcl8.4/TkCmd/keysyms.htm
return
# Translate to Nvim representation of keys
send = []
if event.state & 0x1:
send.append('S')
if event.state & 0x4:
send.append('C')
if event.state & (0x8 | 0x80):
send.append('A')
special = len(send) > 0
key = event.char
if _is_invalid_key(key):
special = True
key = event.keysym
send.append(SPECIAL_KEYS.get(key, key))
send = '-'.join(send)
if special:
send = '<' + send + '>'
nvim = self._nvim
nvim.session.threadsafe_call(lambda: nvim.input(send))
def _nvim_event_loop(self):
self._nvim.session.run(self._nvim_request,
self._nvim_notification,
lambda: self._nvim.attach_ui(80, 24))
self._root.event_generate('<<nvim_detach>>', when='tail')
def _nvim_request(self, method, args):
raise Exception('This UI does not implement any methods')
def _nvim_notification(self, method, args):
if method == 'redraw':
self._nvim_updates.append(args)
self._root.event_generate('<<nvim_redraw>>', when='tail')
