def initConnection(self):
qr = qrcode.QRCode()
qr.add_data(self.HOST)
qr.make()
self.qrImage = qr.make_image()
main = Tk()
photo = ImageTk.PhotoImage(self.qrImage)
label = Label(image=photo)
label.pack()
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def task():
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind((self.HOST, self.PORT))
self.socket.listen(1)
self.conn, self.addr = self.socket.accept()
print 'connected by ' + repr(self.addr)
data = self.conn.recv(1024)
if "123" in str(data):
self.conn.sendall("456")
main.destroy()
main.after(100, task)
main.title("Scan this QR")
main.mainloop()
def main():
root = Tk()
# w, h = root.winfo_screenwidth(), root.winfo_screenheight()
w, h = 960, 540
# get value from arduino
# ser = serial.Serial('/dev/tty.usbserial', 9600)
pos = 0
root.overrideredirect(1)
root.focus_set()
root.bind("<Escape>", lambda e: e.widget.quit())
root.geometry("%dx%d+300+300" % (w, h))
canvas = Canvas(root, width=w, height=h, background="black")
rect0 = canvas.create_rectangle(w/2-75, h/2-20, w/2+75, h/2+20, fill="#05f", outline="#05f")
rect1 = canvas.create_rectangle(w/2-20, h/2-75, w/2+20, h/2+75, fill="#05f", outline="#05f")
canvas.pack()
while (True):
# gets angle and moves accordingly
# pos = ser.readline()
canvas.move(rect0, 1, 0)
canvas.move(rect1, 1, 0)
root.update()
root.after(30)
app = App(root)
time.sleep(0.5)
root.mainloop()
class App(object):
def __init__(self, update, fps=8):
self.t = 0
self.period = 1000/fps
self.update = update
self.master = Tk()
m = self.update(self.t)
self.W, self.H = m3d.shape(m)
self.img = PhotoImage(width=self.W, height=self.H)
canvas = Canvas(self.master, width=self.W, height=self.H)
canvas.pack()
canvas.create_image((self.W/2, self.H/2), image=self.img, state="normal")
self._on_tick()
def _on_tick(self):
def _formatcolor(c):
return '#{0:02X}{1:02X}{2:02X}'.format(*c)
m = self.update(self.t)
self.img.blank()
lines = []
for j in xrange(self.H):
line = ' '.join(_formatcolor(m[j][i]) for i in xrange(self.W))
lines.append( '{' + line + '}')
self.img.put(' '.join(lines))
self.master.after(self.period, self._on_tick)
self.t += self.period
def start(self):
self.master.mainloop()
def job(stockUrl, stockName, stockReferenceId, stockReferencePer, count,
alert):
r = urllib.urlopen(stockUrl).read()
soup = BeautifulSoup(r, "html.parser")
stockVal = soup.find_all("span", class_="pr")
stockPercentage = soup.find_all("span", class_="ch bld")
for element in stockPercentage:
tempPercentage = element.find(id=stockReferencePer).get_text()
percentage = tempPercentage.split("(")[1].split("%)")[0]
print stockName + "\t" + percentage + "%"
if abs(float(percentage)) <= (4.00):
alert = 1
if abs(float(percentage)) >= (8.50):
sendSMS(stockName, percentage, count)
hasSent[count] = 1
for element in stockVal:
price = element.find(id=stockReferenceId).get_text()
print stockName + "\t" + price
value = stockName + " " + str(
price) + " INR \n and Stock is changed " + percentage + "%"
if alert != 1:
root = Tk()
prompt = str(stockName) + '\n' + value
label1 = Label(root, text=prompt, width=len(prompt))
label1.pack()
def close_after_2s():
root.destroy()
root.after(8000, close_after_2s)
root.mainloop()
def initialize(caller_instance):
root = Tk()
root.resizable(0, 0)
app = MainForm(parent=root, caller_instance=caller_instance)
root.after(ms=100, func=app.checkStatus)
root.mainloop()
SHUTDOWN.set()
def main():
def writeData():
data = app.getNewData()
if data:
if data == "\exit":
bluetooth.write('\x03')
else:
bluetooth.write(data + "\n")
def readBluetoothData():
bluetoothData = bluetooth.readline()
for i in range(0, 36):
bluetoothData = bluetoothData.replace("[01;{0}m".format(i), "")
bluetoothData = bluetoothData.replace("[0m", "")
if bluetoothData:
app.writeToConsole(bluetoothData)
def communication():
writeData()
readBluetoothData()
root.after(2, communication)
root = Tk()
root.geometry("600x430+300+300")
app = application(root)
root.after(2, communication)
root.mainloop()
def main():
# Default the port number
port = 5002
if (len(sys.argv) > 1):
if (sys.argv[1].isdigit()):
port = int(sys.argv[1])
# Start listener and wait for a connection
event = threading.Event()
io = Listener("", port, event)
while True:
time.sleep(0.1)
if event.is_set():
break
# Have conneciton -->Start the GUI
print "Starting GUI..."
switches = Switch_state(io.get_socket(), False, False, False)
switches.update_app()
root = Tk()
sim = Sim(root, switches)
hdlr = Input_handler(root, sim, sim.lcd, sim.led, io.get_socket())
root.geometry("560x440")
root.after(10, hdlr.read_socket)
root.mainloop()
def __init__(self, _text):
root = Tk()
root.title("Steep Hound alert")
label = Label(root, text=_text)
label.pack(ipadx=5, ipady=5, padx=5, pady=5)
root.after(5000, root.destroy)
root.mainloop()
def expired(cur_dir, amount):
"""
Displays a "deadline expired" picture
"""
root = Tk()
root.focus_set()
# Get the size of the screen and place the splash screen in the center
img = Image.open(str(cur_dir) + '/Images/Expired.gif')
width = img.size[0]
height = img.size[1]
flog = root.winfo_screenwidth()/2-width/2
blog = root.winfo_screenheight()/2-height/2
root.overrideredirect(True)
root.geometry('%dx%d+%d+%d' % (width*1, height + 44, flog, blog))
# Pack a canvas into the top level window.
# This will be used to place the image
expired_canvas = Canvas(root)
expired_canvas.pack(fill="both", expand=True)
# Open the image
imgtk = PhotoImage(img)
# Get the top level window size
# Need a call to update first, or else size is wrong
root.update()
cwidth = root.winfo_width()
cheight = root.winfo_height()
# create the image on the canvas
expired_canvas.create_image(cwidth/2, cheight/2.1, image=imgtk)
Button(root, text='Deadline Expired by ' + str(amount
) + '. Assignment Submitted, time '\
'noted', width=80, height=2, command=root.destroy).pack()
root.after(5000, root.destroy)
root.mainloop()
def success(cur_dir):
"""
Displays a "successful submission" picture
"""
root = Tk()
root.focus_set()
# Get the size of the screen and place the splash screen in the center
img = Image.open(str(cur_dir) + '/Images/Success.gif')
width = img.size[0]
height = img.size[1]
flog = (root.winfo_screenwidth()/2-width/2)
blog = (root.winfo_screenheight()/2-height/2)
root.overrideredirect(1)
root.geometry('%dx%d+%d+%d' % (width, height, flog, blog))
# Pack a canvas into the top level window.
# This will be used to place the image
success_canvas = Canvas(root)
success_canvas.pack(fill = "both", expand = True)
# Open the image
imgtk = PhotoImage(img)
# Get the top level window size
# Need a call to update first, or else size is wrong
root.update()
cwidth = root.winfo_width()
cheight = root.winfo_height()
# create the image on the canvas
success_canvas.create_image(cwidth/2, cheight/2, image = imgtk)
root.after(4000, root.destroy)
root.mainloop()
def show(text, background="#fff", timeout_ms=DEFAULT_TIMEOUT, font_size=100):
root = Tk()
root.attributes("-topmost", True)
root.lift()
# Set Timeout
root.after(timeout_ms, root.destroy)
# Create Frame
frame = Frame(root)
frame.pack(side=TOP, fill=BOTH, expand=YES)
# Set frame size and position
screen_width = frame.master.winfo_screenwidth()
screen_heigh = frame.master.winfo_screenheight()
w = screen_width * 0.8
h = screen_heigh * 0.6
# Center the window
x = (screen_width/2) - (w/2)
y = (screen_heigh/2) - (h/2)
frame.master.geometry('%dx%d+%d+%d' % (w, h, x, y))
# Adjust frame properties
frame.master.overrideredirect(True) # Set no border or title
frame.config(bg=background)
# Create text label
label = Label(frame, text=text, wraplength=screen_width * 0.8)
label.pack(side=TOP, expand=YES)
label.config(bg=background, justify=CENTER, font=("calibri", font_size))
# Set transparency
root.wait_visibility(root) # Needed for linux (and must come after overrideredirect)
root.attributes('-alpha', 0.6)
# Run Event loop
root.mainloop()
def alert(title, message):
box = Tk()
box.title(title)
Message(box, text = message, bg='red', fg = 'ivory').pack(padx=1, pady=1)
Button(box, text = "Close", command=box.destroy).pack(side=BOTTOM)
box.geometry('300x150')
box.after(0, hello)
def showPopup(s):
popupRoot = Tk()
popupRoot.after(2000)
popupButton = Button(popupRoot,
text=s,
font=("Verdana", 12),
bg="yellow",
command=exit)
popupButton.pack()
popupRoot.geometry('400x50+700+500')
popupRoot.mainloop()
def main():
global game, master, window, IAs
#global game, IAs, actual_it
IAs = [Border, Learner, Chaser, Killer]
game = Game(800, 800, IAs)
master = Tk()
window = Canvas(master, width=game.width, height=game.height)
window.pack()
master.after(1, step)
master.mainloop()
class TkMonitor(Monitor):
"""
An interface over a dictionary {taskno: scrolledtext widget}, with
methods add_listener, del_listener, notify_listener and start/stop.
"""
def __init__(self, name, queue=None):
Monitor.__init__(self, name, queue)
self.widgets = {}
@plac_core.annotations(taskno=('task number', 'positional', None, int))
def add_listener(self, taskno):
"There is a ScrolledText for each task"
st = ScrolledText(self.root, height=5)
st.insert('end', 'Output of task %d\n' % taskno)
st.pack()
self.widgets[taskno] = st
@plac_core.annotations(taskno=('task number', 'positional', None, int))
def del_listener(self, taskno):
del self.widgets[taskno]
@plac_core.annotations(taskno=('task number', 'positional', None, int))
def notify_listener(self, taskno, msg):
w = self.widgets[taskno]
w.insert('end', msg + '\n')
w.update()
def start(self):
'Start the mainloop'
self.root = Tk()
self.root.title(self.name)
self.root.wm_protocol("WM_DELETE_WINDOW", self.stop)
self.root.after(0, self.read_queue)
try:
self.root.mainloop()
except KeyboardInterrupt:
print('Process %d killed by CTRL-C' % os.getpid(), file=sys.stderr)
except TerminatedProcess:
pass
def stop(self):
self.root.quit()
def read_queue(self):
try:
cmd_args = self.queue.get_nowait()
except Queue.Empty:
pass
else:
getattr(self, cmd_args[0])(*cmd_args[1:])
self.root.after(100, self.read_queue)
class TkMonitor(Monitor):
"""
An interface over a dictionary {taskno: scrolledtext widget}, with
methods add_listener, del_listener, notify_listener and start/stop.
"""
def __init__(self, name, queue=None):
Monitor.__init__(self, name, queue)
self.widgets = {}
@plac_core.annotations(taskno=('task number', 'positional', None, int))
def add_listener(self, taskno):
"There is a ScrolledText for each task"
st = ScrolledText(self.root, height=5)
st.insert('end', 'Output of task %d\n' % taskno)
st.pack()
self.widgets[taskno] = st
@plac_core.annotations(taskno=('task number', 'positional', None, int))
def del_listener(self, taskno):
del self.widgets[taskno]
@plac_core.annotations(taskno=('task number', 'positional', None, int))
def notify_listener(self, taskno, msg):
w = self.widgets[taskno]
w.insert('end', msg + '\n')
w.update()
def start(self):
'Start the mainloop'
self.root = Tk()
self.root.title(self.name)
self.root.wm_protocol("WM_DELETE_WINDOW", self.stop)
self.root.after(0, self.read_queue)
try:
self.root.mainloop()
except KeyboardInterrupt:
print >> sys.stderr, 'Process %d killed by CTRL-C' % os.getpid()
except TerminatedProcess:
pass
def stop(self):
self.root.quit()
def read_queue(self):
try:
cmd_args = self.queue.get_nowait()
except Queue.Empty:
pass
else:
getattr(self, cmd_args[0])(*cmd_args[1:])
self.root.after(100, self.read_queue)
class GUI():
def __init__(self):
self.root = Tk()
self.show()
def show(self):
self.root.deiconify()
#self.root.attributes('-topmost', 1)
#self.root.attributes('-topmost', 0)
self.root.after(2000, self.hide)
def hide(self):
self.root.iconify()
self.root.after(2000, self.show)
class Display:
def __init__(self, fps=FPS, width=WIDTH, height=HEIGHT,
board_offset_bottom=BOARD_OFFSET_BOTTOM,
board_width=BOARD_WIDTH,
board_height=BOARD_HEIGHT):
self.root=Tk()
self.root.protocol("WM_DELETE_WINDOW", self.root.destroy)
self.width = width
self.height = height
self.canvas=Canvas(self.root, bg="black",width=width,height=height)
self.board_width = board_width
self.board_height = board_height
self.board_offset_bottom = board_offset_bottom
self.canvas.pack()
self.fps = fps
self.controllers = []
#For reset
self.root.bind("<space>", lambda e:self.reset_all())
self.root.bind("<Escape>", lambda e:self.root.destroy())
def run(self):
self.root.after(1000//self.fps, self.loop)
try:
self.root.mainloop()
except KeyboardInterrupt:
self.root.destroy()
def loop(self):
actions = [controller.get_action(self.model) for controller in self.controllers]
self.model.update(1./self.fps, actions)
self.draw()
self.root.after(1000//self.fps, self.loop)
def draw(self):
self.canvas.delete('all')
self.board = self.canvas.create_rectangle(
self.model.x()-self.board_width/2,
self.board_offset_bottom+self.height-self.board_height,
self.model.x()+self.board_width/2,
self.board_offset_bottom+self.height, fill="green")
self.pendulum = self.canvas.create_line(
self.model.x(),
self.board_offset_bottom+self.height-self.board_height,
self.model.x()+self.model.arm_length*math.sin(self.model.alpha()),
self.board_offset_bottom+self.height-self.board_height-self.model.arm_length*math.cos(self.model.alpha()),
fill="blue", width=20)
def attach_model(self, model):
self.model = model
self.draw()
def attach_controller(self, controller):
self.controllers.append(controller)
def reset_all(self):
self.model.randomize()
class KindleCodeFormater():
def __init__(self):
self._root = Tk()
self._roughKindleCode = self._root.clipboard_get()
self._formatedKindleCode = ''
def formatCode(self):
codeWithNoSpaceInMatrix = self._removeSpaceInMatrices(self._roughKindleCode)
fixedPlottingComment = self._fixPlottingComment(codeWithNoSpaceInMatrix)
codeWithLineBreak = re.sub(r"; ", r";\n", fixedPlottingComment)
self._formatedKindleCode = codeWithLineBreak
def formatedCodeToClipboard(self):
self._root.clipboard_append(self._formatedKindleCode)
self.showTempConfirmAndDestroy()
def showTempConfirmAndDestroy(self):
'''
Displays a temporary MessageBox to inform that the job was done and
close the app.
'''
from tkinter import messagebox
self._root.update() # now it stays on the clipboard after the window is closed
self._root.after(1500, self._root.destroy) # Destroy the widget after 1.5 seconds
try:
if messagebox.showinfo('formatkindlecode', 'Formatted code copied to clipboard'):
self._root.destroy()
except:
pass
def _removeSpaceInMatrices(self, codeStr):
pattern = r"(\[[\d\w ;]+\])"
noSpaceMatrix = ''
for match in re.finditer(pattern, codeStr):
roughMatrix = match.group()
if '; ' in roughMatrix:
noSpaceMatrix = roughMatrix.replace('; ', ';')
codeStr = codeStr.replace(roughMatrix, noSpaceMatrix)
return codeStr
def _fixPlottingComment(self, codeStr):
codeStr = codeStr.replace("%plotting ", "\n\n%plotting\n")
return codeStr
class Game(object):
def __init__(self, in_queue, out_queue):
self.players = {}
self.root = Tk()
self.ground = Canvas(self.root, width=WIDTH, height=HEIGHT)
self.ground.pack()
self.in_queue = in_queue
self.out_queue = out_queue
def start(self):
self.root.after(1, self.place_players)
worker = Thread(target=self.loop)
worker.setDaemon(True)
worker.start()
def place_players(self):
for player in self.players.values():
player.place()
self.root.after(1, self.place_players)
def loop(self):
while True:
self.animate()
def animate(self):
while not self.in_queue.empty():
command, args = self.in_queue.get_nowait()
if command == "s":
print "added"
self.add_player(args[0])
self.out_queue.put_nowait(("ok", args[0]))
if command == "m":
is_wall = self.move_player(args[0], args[1])
if is_wall:
print "wall", args[1]
self.out_queue.put_nowait(("wall", args[0]))
else:
self.out_queue.put_nowait(("ok", args[0]))
def add_player(self, player_id):
self.players[player_id] = Player(self.ground)
def move_player(self, player_id, direction):
return self.players[player_id].move(direction)
def check_wall_player(self, player_id, direction):
return self.players[player_id].check_wall(direction)
class gui:
def __init__(self):
self.tk = Tk()
self.canvas = Canvas(self.tk)
self.tk.after_idle(self.test)
self.tk.mainloop()
def test(self):
print 'boom'
self.tk.after(200, self.test2)
def test2(self):
print 'bang'
self.tk.after(200, self.test)
def main():
root = Tk()
root.overrideredirect(True)
root.geometry('{0}x{1}+0+0'.format(root.winfo_screenwidth(),
root.winfo_screenheight()))
root.focus_set()
color, text = instruction()
label = Label(root, text=text, fg=color, font='-size 100 -weight bold')
label.pack(fill=BOTH, expand=1)
root.after(0, lambda: Popen(['say', '--voice', SAY_VOICE, text]))
root.after(5000, lambda: root.quit())
root.mainloop()
def main():
root = Tk()
def kludge():
root.after(100, kludge)
root.after(100, kludge)
def handle_sigusr1(signum, frame):
root.quit()
signal.signal(signal.SIGUSR1, handle_sigusr1)
root.geometry("250x150+300+300")
root.attributes("-fullscreen", True)
app = Example(root)
root.mainloop()
print("Here we are cleaning up.")
class DCGreenLantern(object):
"""
This class is responsible for redrawing UI widget
"""
dimensions = DIMENSIONS
title = 'Green Lantern'
widget_class = DCGreenLanternWidget
def __init__(self, message_q, initial_state):
self.root = Tk()
self.widget = self.widget_class(self.root, initial_state)
self.root.title(self.title)
self.root.geometry(self.dimensions)
self.root.after(REFRESH_RATE, self.check_commands, message_q)
def check_commands(self, message_q):
"""
Check queue for messages with new lantern state and redraw UI.
Close UI if there is None value in the queue.
:type message_q: multiprocessing.Queue
"""
try:
new_state = message_q.get(block=True,
timeout=REFRESH_RATE /
1000.0) # timeout value in seconds
if new_state is None:
logger.debug('termination signal received')
self.root.quit()
return
self.redraw(new_state)
except Empty:
pass
self.root.after(REFRESH_RATE, self.check_commands, message_q)
def show(self):
self.root.mainloop()
def redraw(self, state):
assert isinstance(state[1], basestring), 'color must be a string'
self.widget.change_color(state[1])
class App:
def __init__(self):
self.window = Tk()
self.display = Display(self.window)
self.display.pack()
self.label = Label(master=self.window)
self.label.pack()
self.camera = Camera()
self.state='keine Bewegung'
self.detect()
self.window.mainloop()
def detect(self):
self.camera.takePhoto()
left, right = self.camera.checkMotion()
print "Links", left
print "Rechts", right
if self.state =='keine Bewegung':
if left and not right:
self.state = 'zuerst links'
elif right and not left:
self.state = 'zuerst rechts'
elif self.state == 'zuerst links':
if left and rigth:
self.state = 'zuerst links, dann rechts'
elif not(left or rigth):
self.state = 'keine Bewegung'
elif self.state == 'zuerst rehts':
if left and right:
self.state = 'zuerst, dann links'
elif not(left or right):
self.state = 'keine Bewegung'
elif self.state == 'zuerst links, dann rechts':
if not (left or right):
self.state = 'keine Bewegung'
self.display.motion('von links')
elif self.state == 'zuerst rechts, dann links':
if not (left or right):
self.state = 'keine Bewegung'
self.display.motion('von rechts')
self.label.config(text=time.asctime()+''+ self.state)
self.window.after(100, self.detect)
self.detect()
def show_word(word):
t = time()
select = [0]
root = Tk()
root.title('CrazyEnglish')
try:
root.call('wm', 'iconphoto', root._w, PhotoImage(file='english.png'))
except Exception:
print 'Error loading icon'
root.geometry(
str(root.winfo_screenwidth()) + 'x' + str(root.winfo_screenheight()) +
'+0+0') #root.winfo_screenheight()
root.resizable(False, False)
root.protocol('WM_DELETE_WINDOW', lambda: exit(root, select))
canvas = Canvas(root) #,bg='green')
canvas.place(x=100, y=100, width=800, height=50)
canvas.create_text(0,
0,
text=word[0],
anchor='nw',
font=('', 14),
fill='red')
canvas.create_text(0, 30, text='(' + word[1] + ')', anchor='nw')
entry = Entry(root, font=('', 10))
entry.place(x=100, y=200, width=800, height=30)
Button(root, text='OK',
command=lambda: press_btn(root, entry, word[0])).place(x=100,
y=250,
height=30,
width=80)
root.after(0, lambda: close_window(root, t))
entry.focus_force()
root.mainloop()
return select[0]
class GUI:
def __init__(self, num_labels):
self.root = Tk()
self.labels = []
for i in xrange(num_labels):
l=Label(self.root, width=10, height=5)
l.grid(row=0, column=i)
self.labels.append(l)
def color(self, i, value):
self.labels[i].configure(bg=value)
def mainloop(self):
self.root.mainloop()
def delay_color(self, delay, i, color):
self.root.after(delay, lambda: self.color(i, value))
def after(self, delay, cb):
self.root.after(delay, cb)
def tk(timeout=5):
root = Tk() # default root
root.withdraw() # remove from the screen
# destroy all widgets in `timeout` seconds
func_id = root.after(int(1000 * timeout), root.quit)
try:
yield root
finally: # cleanup
root.after_cancel(func_id) # cancel callback
root.destroy()
def prompt(msg):
root = Tk()
prompt = msg
label1 = Label(root,
text='\n' + prompt + '\n',
width=len(prompt),
bg="black",
fg="green",
font="Time 16 bold")
label1.pack()
#makes the popup the center of the screen
root.eval('tk::PlaceWindow %s center' %
root.winfo_pathname(root.winfo_id()))
def close_after_3s():
root.destroy()
if 'scanning complete' not in msg:
root.after(3000, close_after_3s)
root.mainloop()
class intro(object):
def __init__(self):
self.master=Tk()
self.x = (self.master.winfo_screenwidth()/3) - (self.master.winfo_width())
self.y = (self.master.winfo_screenheight()/3) - (self.master.winfo_height())
self.master.geometry("+%d+%d" % (self.x, self.y))
self.master.overrideredirect(True)
self.master.resizable(False,False)
self.logointroimg=Image.open(r'img/Logo-introscreenmin.jpg')
self.Tkimage3= ImageTk.PhotoImage(self.logointroimg)
self.canvas = Canvas(self.master, height=378,width=672 )
self.canvas.create_image(336,186, image=self.Tkimage3)
self.canvas.pack()
self.master.after(1250,self.master.destroy)
self.master.mainloop()
def main():
# Authenticate using your Google Docs email address and password.
client.ClientLogin(config.username, config.password)
## Query the server for an Atom feed containing a list of your documents.
#documents_feed = client.GetDocumentListFeed()
## Loop through the feed and extract each document entry.
#for document_entry in documents_feed.entry:
# # Display the title of the document on the command line.
# print document_entry.title.text
## This is a simple GUI, so we allow the root singleton to do the legwork
root = Tk()
WIDTH, HEIGHT = root.winfo_screenwidth(), root.winfo_screenheight()
# root.overrideredirect(1)
root.geometry("%dx%d+0+0" % (WIDTH, HEIGHT))
root.focus_set() # <-- move focus to this widget
root.wm_attributes("-topmost", True)
root.wm_title("Wedding Photobooth")
frame = Frame(root)
frame.pack()
photobooth = Photobooth(root)
## add a software button in case hardware button is not available
#interface_frame = Frame(root)
#snap_button = Button(interface_frame, text="*snap*", command=takePicture)
#snap_button.pack(side=RIGHT)
#interface_frame.pack(side=RIGHT)
### check button after waiting for 200 ms
#root.after(200, check_and_snap)
# Instead of the preview, we might write an image every half second or so
root.after(200, photobooth.start)
root.mainloop()
def execute(self, msg, unit, address, when, printer, print_copies):
def orange():
text_widget.config(bg="Orange")
root.after(180000, red)
def red():
text_widget.config(bg="Red")
root.after(180000, kill)
def kill():
root.destroy()
mseg = str('%s - %s' % (msg, unit))
root = Tk()
text_widget = Text(root, font='times 40 bold', bg='Green')
text_widget.pack(fill=BOTH, expand=0)
text_widget.tag_configure('tag-center', wrap='word', justify='center')
text_widget.insert(INSERT, "\n" + "\n" + "\n" + mseg, 'tag-center')
root.after(180000, orange)
# TODO: this needs to spawn a thread
root.mainloop()
def execute(self, msg, unit, address, when, printer, print_copies):
def orange():
text_widget.config(bg="Orange")
root.after(180000, red)
def red():
text_widget.config(bg="Red")
root.after(180000, kill)
def kill():
root.destroy()
mseg = str('%s - %s' % (msg, unit))
root = Tk()
text_widget = Text(root, font='times 40 bold', bg='Green')
text_widget.pack(fill=BOTH, expand=0)
text_widget.tag_configure('tag-center', wrap='word', justify='center')
text_widget.insert(INSERT, "\n" + "\n" + "\n" + mseg, 'tag-center')
root.after(180000, orange)
# TODO: this needs to spawn a thread
root.mainloop()
def initConnection(self):
qr = qrcode.QRCode()
qr.add_data(self.HOST)
qr.make()
self.qrImage = qr.make_image()
main = Tk()
photo = ImageTk.PhotoImage(self.qrImage)
label = Label(image=photo)
label.pack()
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def task():
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind((self.HOST, self.PORT))
self.socket.listen(1)
self.conn, self.addr = self.socket.accept()
print 'connected by ' + repr(self.addr)
data = self.conn.recv(1024)
if "123" in str(data):
self.conn.sendall("456")
main.destroy()
main.after(100, task)
main.title("Scan this QR")
main.mainloop()
def vis_thread():
global txt, color, txt2, color2
def update():
global txt, color, txt2, color2
msg.config(text=txt, background=color)
msg2.config(text=txt2, background=color2)
root.after(250, update)
root = Tk()
root.geometry("900x600")
msg = Message(root, text=txt, background=color)
msg.config(font=('times', 200, 'italic bold'))
msg.pack()
msg2 = Message(root, text=txt2, background=color2)
msg2.config(font=('times', 70, 'italic bold'))
msg2.pack()
root.after(250, update)
root.mainloop()
if message != None:
if message == 'show':
display.show()
elif message == 'clear':
display.clear()
else:
message = message.split(',')
display.show_q(message)
##display.set_pixel(int(message[0]),int(message[1]),int(message[2]),int(message[3]),int(message[4]))
except Queue.Empty:
pass
window.after(5, processqueue)
window.after(5, processqueue)
sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sck.settimeout(0)
port = 7676
bound = False
while not bound:
try:
sck.bind(('127.0.0.1', port))
bound = True
print("Bound to", port)
except socket.error:
port += 1
sck.listen(50)
n = (n+1)%len(pics)
elif direction == "prev":
n = (n-1)%len(pics)
else:
raise Exception("Got invalid direction")
if n == current:
updatePos(direction)
def changePic(direction):
global n
updatePos(direction)
img = Image.open("../slideshow/"+slides[n])
img = resize(img)
photo = ImageTk.PhotoImage(img)
panel.configure(image = photo)
panel.image = photo
def resize(image):
width, height = image.size
print "ratio", width/float(height)
ratio = max(width/float(size[0]), height/float(size[1]))
return image.resize((int(width/ratio), int(height/ratio)), Image.ANTIALIAS)
root.after(0, autoChange) # set the initial image, no delay
root.bind("<Right>", callbackRight) # debug key control
root.bind("<Left>", callbackLeft) # debug key control
root.mainloop()
# Stop the program execution after the slideshow is closed
running = False
print "Terminating"
class TkApplication:
# these are passed to Tk() and must be redefined by the subclasses:
tk_basename = ''
tk_class_name = ''
def __init__(self, screen_name=None, geometry=None):
self.init_tk(screen_name, geometry)
def init_tk(self, screen_name=None, geometry=None):
self.root = Tk(screenName=screen_name, baseName=self.tk_basename, className=self.tk_class_name)
app.root = self.root
from sk1.managers.uimanager import UIManager
app.uimanager = UIManager(self.root)
self.splash = SplashScreen(self.root)
self.splash.show()
self.splash.set_val(.1, 'DialogManager initialization...')
from sk1.managers.dialogmanager import DialogManager
app.dialogman = DialogManager(self.root)
self.splash.set_val(.15, 'Setting appication data...')
app.info1 = StringVar(self.root, '')
app.info2 = StringVar(self.root, '')
app.info3 = DoubleVar(self.root, 0)
# Reset locale again to make sure we get properly translated
# messages if desired by the user. For some reason it may
# have been reset by Tcl/Tk.
# if this fails it will already have failed in
# app/__init__.py which also prints a warning.
try:
import locale
except ImportError:
pass
else:
try:
locale.setlocale(locale.LC_MESSAGES, "")
except:
pass
if not geometry:
# try to read geometry from resource database
geometry = self.root.option_get('geometry', 'Geometry')
if geometry:
try:
self.root.geometry(geometry)
except TclError:
sys.stderr.write('%s: invalid geometry specification %s' % (self.tk_basename, geometry))
def Mainloop(self):
self.splash.set_val(1)
self.root.update()
self.root.deiconify()
self.root.after(300, self.splash.hide)
self.root.mainloop()
def MessageBox(self, *args, **kw):
return apply(tkext.MessageDialog, (self.root,) + args, kw)
def GetOpenFilename(self, **kwargs):
return apply(tkext.GetOpenFilename, (self.root,), kwargs)
def GetSaveFilename(self, **kwargs):
return apply(tkext.GetSaveFilename, (self.root,), kwargs)
clipboard = None
def EmptyClipboard(self):
self.SetClipboard(None)
def SetClipboard(self, data):
self.clipboard = data
def GetClipboard(self):
return self.clipboard
def ClipboardContainsData(self):
return self.clipboard is not None
class Visualiser(object):
'''
Generic Offline Visualiser. Subclasses need to be used that specify
how to handle a data source.
'''
### Public functions ###
def __init__(self,
title="Visualisation",
width=400,
height=400,
recording=False,
recordPattern=None,
paused=False,
source=None):
'''
Constructor.
Params:
title: string - Title of the visualisation window
width: int - Width of the visualisation window
height: int - Height of the visualisation window
recording: boolean - Start with recording enabled?
recordPattern: string - Pattern for recorded images,
e.g., cylinders%05g.png
paused: boolean - Start with playback paused?
source:- The data source to read.
What is required here varies by visualiser.
'''
# Visualisation options
self.vis_features = []
self.vis_frame = 0
self.vis_frameStep = 1
self.vis_jumping = False
self.vis_recording = recording
self.vis_recordPattern = recordPattern
self.vis_paused = paused
self.vis_source = source
# VTK structures
self.vtk_cells = vtkCellArray()
self.vtk_renderer = vtkRenderer()
# Tk structures
self.tk_root = Tk()
self.tk_root.title(title)
self.tk_root.grid_rowconfigure(0, weight=1)
self.tk_root.grid_columnconfigure(0, weight=3)
self.tk_root.bind('<Destroy>', self.destroyed)
if not self.vis_paused: self.tk_root.after(100, self.animate)
self.tk_renderWidget = vtkTkRenderWidget(self.tk_root,
width=width,
height=height)
self.tk_renderWidget.grid(row=0, column=0, sticky=N+S+E+W)
self.tk_renderWidget.GetRenderWindow().AddRenderer(self.vtk_renderer)
self.tk_featureFrame = Frame(self.tk_root)
self.tk_featureFrame.grid(row=0, column=1, rowspan=2)
Label(self.tk_featureFrame, text='Features:').grid(row=0, column=0)
self.tk_controlFrame = Frame(self.tk_root)
self.tk_controlFrame.grid(row=1, column=0)
self.tk_quit = Button(self.tk_controlFrame, text="Quit",
command=self.shutdown)
self.tk_quit.grid(row=0, column=0, columnspan=2)
def pause():
if self.vis_paused:
self.tk_pause.config(text='Pause')
self.tk_root.after(100, self.animate)
else:
self.tk_pause.config(text='Resume')
self.vis_paused ^= True
self.tk_pause = Button(self.tk_controlFrame, text="Pause", command=pause)
self.tk_pause.grid(row=0, column=2, columnspan=2)
if self.vis_recordPattern is not None:
def record():
if self.vis_recording:
self.tk_record.config(text='Start Recording')
else:
self.tk_record.config(text='Stop Recording')
self.vis_recording ^= True
self.tk_record = Button(self.tk_controlFrame, text="Start Recording", command=record)
self.tk_record.grid(row=0, column=4, columnspan=2)
if self.vis_recording:
self.tk_record.config(text="Stop Recording")
def make_seek_button(label, column, frame):
def jump():
self.jumpTo(frame)
b = Button(self.tk_controlFrame,
text=label,
command=jump)
b.grid(row=1, column=column, sticky=W+E)
return b
self.tk_seek_start = make_seek_button("|<", 0, 0)
self.tk_seek_back10 = make_seek_button("<<", 1,
lambda: self.vis_frame - 10)
self.tk_seek_back1 = make_seek_button("<", 2,
lambda: self.vis_frame - 1)
self.tk_seek_forward1 = make_seek_button(">", 3,
lambda: self.vis_frame + 1)
self.tk_seek_forward10 = make_seek_button(">>", 4,
lambda: self.vis_frame + 10)
self.tk_seek_end = make_seek_button(">|", 5,
self.getMaxFrameNumber)
Label(self.tk_controlFrame, text='Frame').grid(row=2, column=0,
sticky=W+E)
def changeFrame(frame):
if not self.vis_jumping:
self.vis_jumping = True
self.jumpTo(self.tk_frame.get())
self.vis_jumping = False
self.tk_frame = Scale(self.tk_controlFrame, command=changeFrame,
from_=0, to=0, orient=HORIZONTAL)
self.tk_frame.grid(row=2, column=1, columnspan=2, sticky=W+E)
Label(self.tk_controlFrame, text='Step').grid(row=2, column=3,
sticky=W+E)
def changeFrameStep(step):
self.vis_frameStep = int(step)
self.tk_frameStep = Scale(self.tk_controlFrame, command=changeFrameStep,
from_=1, to=1, orient=HORIZONTAL)
self.tk_frameStep.grid(row=2, column=4, columnspan=2, sticky=W+E)
self.setupGrid()
def add_feature(self, feature):
'''Add a feature to this visualiser'''
self.vis_features.append(feature)
feature.button(self.tk_featureFrame).grid(row=len(self.vis_features),
column=0, sticky=W+E)
feature.visualiser = self
def run(self):
'''Start the visualiser'''
self.redraw()
self.tk_root.mainloop()
### Private funcitions ###
def resetSliders(self):
'''
Recalculate the upper bound on the frame and frameStep
sliders.
'''
maxFrame = self.getMaxFrameNumber()
self.tk_frame.config(to=maxFrame)
self.tk_frameStep.config(to=maxFrame)
def jumpTo(self, frame):
'''
Jump to a given frame. If frame is a function, jump to the
return value of frame().
'''
oldFrame = self.vis_frame
if hasattr(frame, '__call__'):
self.vis_frame = frame()
else:
self.vis_frame = frame
maxFrame = self.getMaxFrameNumber()
if self.vis_frame < 0:
self.vis_frame = 0
elif self.vis_frame > maxFrame:
self.vis_frame = maxFrame
self.vis_paused = True
self.tk_pause.config(text='Resume')
self.tk_frame.set(self.vis_frame)
self.redraw(oldFrame != self.vis_frame)
def redraw(self, update=False):
self.resetSliders()
for feature in [ f for f in self.vis_features if not f.dynamic ]:
feature.draw(self.vtk_renderer)
if update:
for feature in [ f for f in self.vis_features if f.dynamic]:
f.redraw(self.vtk_renderer)
self.tk_renderWidget.GetRenderWindow().Render()
self.tk_root.update_idletasks()
### Gui events ###
def destroyed(self, event):
if event.widget == self.tk_root:
self.shutdown()
def shutdown(self):
self.tk_root.withdraw()
self.tk_root.destroy()
def animate(self):
if not self.vis_paused:
self.jumpTo(self.vis_frame + self.vis_frameStep)
if self.vis_recording and self.vis_recordPattern is not None:
self.save_image()
self.tk_root.after(100, self.animate)
def save_image(self):
extmap = {'.jpg' : vtkJPEGWriter,
'.jpeg' : vtkJPEGWriter,
'.png' : vtkPNGWriter,
'.pnm' : vtkPNMWriter}
_, ext = splitext(self.vis_recordPattern)
try: writer = extmap[ext.lower()]()
except KeyError:
print 'ERROR: Can\'t handle %s extension. Recording disabled.' % ext
self.vis_recordPattern = None
return
win = self.vtk_renderer.GetRenderWindow()
w2i = vtkWindowToImageFilter()
w2i.SetInput(win)
w2i.Update()
writer.SetInput(w2i.GetOutput())
writer.SetFileName(self.vis_recordPattern % self.vis_frame)
win.Render()
writer.Write()
### Things subclasses need to override ###
def setupGrid(self):
'''
Populate the vtkCellArray instance at
self.vtk_cells. Subclasses are required to override this
function to read from their source as appropriate.
'''
raise NotImplementedError('Subclass needs to override Visualiser::setupGrid!')
def getMaxFrameNumber(self):
'''
Return the maximum frame number. This will need to be defined
by a subclass.
'''
raise NotImplementedError('Subclass needs to override Visualiser::getMaxFrameNumber!')
def getQuantityPoints(self, quantityName, dynamic=True, frameNumber=0):
'''
Return the points of a quantity at a given frame as a list
[float]. Subclasses need to override this.
'''
raise NotImplementedError('Subclass needs to override Visualiser::getQuantityPoints!')
def getQuantityDict(self):
'''
Return the values of all quantities at a given time as a
dictionary. Sublclasses need to override this.
'''
raise NotImplementedError('Subclass needs to override Visualiser::getQuantityDict!')
class Visualiser(Thread):
"""Superclass of both the realtime and offline VTK visualisers
"""
def __init__(self, source):
Thread.__init__(self)
self.source = source
# Structures for Height Based quantities
self.height_quantities = []
self.height_zScales = {}
self.height_dynamic = {}
self.height_offset = {}
self.height_opacity = {}
self.height_wireframe = {}
# Structures for colouring quantities
self.colours_height = {}
# Structures used for VTK
self.vtk_actors = {}
self.vtk_axesSet = False
self.vtk_drawAxes = False
self.vtk_mappers = {}
self.vtk_polyData = {}
# A list of operations to be performed on the cube axes. Type: [(func, (args))]
self.conf_axesAlterations = []
# A list of all polygons to overlay. Type: [([coords], height, (colour)]
self.conf_overlaidPolygons = []
# A list of alterations to be performed on the Tk root. Type: [(func, (args))]
self.conf_tkAlterations = []
def run(self):
self.vtk_renderer = vtkRenderer()
self.setup_gui()
self.setup_grid()
# Handle any deferred configuration
# Overlaid polygons
for args in self.conf_overlaidPolygons:
self.overlay_polygon_internal(*args)
# Draw (and maybe alter) the axes
if self.vtk_drawAxes:
self.vtk_axes = vtkCubeAxesActor2D()
# Perform all of the alterations required, by applying func to the vtk_axes instance (with the given args).
for func, args in self.conf_axesAlterations:
func(*((self.vtk_axes,) + args))
# Alter the Tk root as necessary.
for func, args in self.conf_tkAlterations:
func(*((self.tk_root,) + args))
# Finished with deferred configuration.
# Draw Height Quantities
for q in self.height_quantities:
self.update_height_quantity(q, self.height_dynamic[q])
self.draw_height_quantity(q)
self.tk_root.mainloop()
def redraw_quantities(self):
"""Redraw all dynamic quantities.
"""
# Height quantities
for q in self.height_quantities:
if (self.height_dynamic[q]):
self.update_height_quantity(q, self.height_dynamic[q])
self.draw_height_quantity(q)
if self.vtk_drawAxes is True:
self.draw_axes()
# --- Axes --- #
def render_axes(self):
"""Intstruct the visualiser to render cube axes around the render.
"""
self.vtk_drawAxes = True
def draw_axes(self):
"""Update the 3D bounds on the axes and add them to the pipeline if not yet connected.
"""
self.vtk_axes.SetBounds(self.get_3d_bounds())
if not self.vtk_axesSet:
self.vtk_axesSet = True
self.vtk_axes.SetCamera(self.vtk_renderer.GetActiveCamera())
self.vtk_renderer.AddActor(self.vtk_axes)
self.vtk_renderer.ResetCamera(self.get_3d_bounds())
def alter_axes(self, func, args):
"""Attempt to apply the function 'func' with args tuple 'args' to the
vtkCubeAxesActor2D instance set up by render_axes. This is done this way to ensure
the axes setup is handled in the visualiser thread.
Example call:
from vtk import vtkCubeAxesActor2D
alter_axes(vtkCubeAxesActor2D.SetNumberOfPoints, (5,))
"""
self.conf_axesAlterations.append((func, args))
# --- Height Based Rendering --- #
def setup_grid(self):
"""Create the vtkCellArray instance that represents the
triangles. Subclasses are expected to override this function
to read from their source as appropriate. The vtkCellArray should
be stored to self.vtk_cells.
"""
pass
def render_quantity_height(self, quantityName, zScale=1.0, offset=0.0, opacity=1.0, dynamic=True, wireframe=False):
"""Instruct the visualiser to render a quantity using the
value at a point as its height. The value at each point is
multiplied by z_scale and is added to offset, and if
dynamic=False, the quantity is not recalculated on each
update.
"""
self.height_quantities.append(quantityName)
self.height_zScales[quantityName] = zScale
self.height_offset[quantityName] = offset
self.height_dynamic[quantityName] = dynamic
self.height_opacity[quantityName] = opacity
self.height_wireframe[quantityName] = wireframe
def update_height_quantity(self, quantityName, dynamic=True):
"""Create a vtkPolyData object and store it in
self.vtk_polyData[quantityName]. Subclasses are expected to override this
function.
"""
pass
def get_3d_bounds(self):
"""Get the minimum and maximum bounds for the x, y and z directions.
Return as a list of double in the order (xmin, xmax, ymin, ymax, zmin, zmax),
suitable for passing to vtkCubeAxesActor2D::SetRanges(). Subclasses are expected
to override this function.
"""
pass
def store_height_quantity(self, quantityName, fileName=None):
if fileName is None:
fileName = quantityName + '.vtk'
quantity_polyData = self.vtk_polyData[quantityName]
import vtk
w = vtk.vtkPolyDataWriter()
#print quantity_polyData
w.SetInput(quantity_polyData)
w.SetFileName(fileName)
w.Write()
def draw_height_quantity(self, quantityName):
"""Use the vtkPolyData and prepare/update the rest of the VTK
rendering pipeline.
"""
if self.vtk_mappers.has_key(quantityName):
mapper = self.vtk_mappers[quantityName]
else:
mapper = self.vtk_mappers[quantityName] = vtkPolyDataMapper()
mapper.SetInput(self.vtk_polyData[quantityName])
mapper.Update()
if not self.vtk_actors.has_key(quantityName):
actor = self.vtk_actors[quantityName] = vtkActor()
actor.GetProperty().SetOpacity(self.height_opacity[quantityName])
if self.height_wireframe[quantityName]:
actor.GetProperty().SetRepresentationToWireframe()
actor.SetMapper(mapper)
self.vtk_renderer.AddActor(actor)
else:
actor = self.vtk_actors[quantityName]
if self.colours_height.has_key(quantityName):
colour = self.colours_height[quantityName]
if type(colour) == TupleType:
if type(colour[0]) == FunctionType:
# It's a function, so take colour[1] as the
# lower bound on the scalar range and
# colour[2] as the upper bound on the scalar
# range.
scalars = vtkFloatArray()
map(scalars.InsertNextValue, colour[0](self.build_quantity_dict()))
self.vtk_polyData[quantityName].GetPointData().SetScalars(scalars)
mapper.SetScalarRange(colour[1:])
mapper.Update()
else:
# It's a 3-tuple representing an RGB value.
actor.GetProperty().SetColor(colour)
else:
actor.GetProperty().SetColor(0.5, 0.5, 0.5)
else:
actor.GetProperty().SetColor(0.5, 0.5, 0.5)
# --- Colour Coding --- #
def build_quantity_dict(self):
"""Build and return a dictionary mapping quantity name->Numeric array of vertex
values for that quantity. Subclasses are expected to override
this function."""
pass
def colour_height_quantity(self, quantityName, colour=(0.5, 0.5, 0.5)):
"""Add colouring to a height based quantity.
The colour parameter can be one of the following:
- a 3-tuple of values in [0,1] to specify R, G, B values
- a 3-tuple of values:
- a function that takes a dictionary mapping quantity name->Numeric array of vertex values.
This function returns a list of vertex values to be used in the colour coding.
- a float for the lower bound on the colouring
- a float for the upper bound on the colouring
"""
self.colours_height[quantityName] = colour
# --- Overlaid Polygons --- #
def overlay_polygon(self, coords, height=0.0, colour=(1.0, 0.0, 0.0)):
"""Add a polygon to the output of the visualiser.
coords is a list of 2-tuples representing x and y coordinates.
These are triangulated by vtkDelaunay2D.
height is the z-value given to all points.
colour is the colour of the polygon, as a 3-tuple representing
r, g, b values between 0 and 1."""
self.conf_overlaidPolygons.append((coords, height, colour))
def overlay_polygon_internal(self, coords, height, colour):
"""Add a polygon to the output of the visualiser.
coords is a list of 2-tuples representing x and y coordinates.
These are triangulated by vtkDelaunay2D.
height is the z-value given to all points.
colour is the colour of the polygon, as a 3-tuple representing
r, g, b values between 0 and 1.
This function should not be called from outside the visualiser thread.
Use overlay_polygon instead.
"""
points = vtkPoints()
for coord in coords:
points.InsertNextPoint(coord[0], coord[1], height)
profile = vtkPolyData()
profile.SetPoints(points)
delny = vtkDelaunay2D()
delny.SetInput(profile)
mesh = vtkPolyDataMapper()
mesh.SetInput(delny.GetOutput())
actor = vtkActor()
actor.SetMapper(mesh)
actor.GetProperty().SetColor(colour)
self.vtk_renderer.AddActor(actor)
# --- Vector Fields --- #
# --- GUI Setup --- #
def setup_gui(self):
self.tk_root = Tk()
self.tk_root.title("Visualisation")
self.tk_root.after(100, self.redraw)
self.tk_root.bind("<Destroy>", self.destroyed)
self.tk_root.grid_rowconfigure(0, weight=1)
self.tk_root.grid_columnconfigure(0, weight=1)
self.tk_renderWidget = vtkTkRenderWidget(self.tk_root, width=400, height=400)
self.tk_renderWidget.grid(row=0, column=0, sticky=N+S+E+W)
self.tk_controlFrame = Frame(self.tk_root)
self.tk_controlFrame.grid(row=1, column=0, sticky=E+W)
self.tk_controlFrame.grid_rowconfigure(0, weight=1)
self.tk_controlFrame.grid_columnconfigure(0, weight=1)
self.tk_quit = Button(self.tk_controlFrame, text="Quit", command=self.shutdown)
self.tk_quit.grid(row=0, column=0, sticky=E+W)
self.tk_renderWidget.GetRenderWindow().AddRenderer(self.vtk_renderer)
def alter_tkroot(self, func, args):
"""Apply func, with arguments tuple args to the root tk window for this visualiser.
"""
self.conf_tkAlterations.append((func, args))
# --- GUI Events --- #
def destroyed(self, event):
if event.widget == self.tk_root:
self.shutdown()
def redraw(self):
self.tk_renderWidget.GetRenderWindow().Render()
self.tk_root.update_idletasks()
self.tk_root.after(100, self.redraw)
def shutdown(self):
self.tk_root.withdraw()
self.tk_root.destroy()
class InputDevice(object):
def __init__(self):
# root is the Tkinter root widget
self.root = Tk()
self.root.title("Input Device Utility")
# self.root.configure(background='grey')
self.root.resizable(False,False)
# define response to main window closing
self.root.protocol ("WM_DELETE_WINDOW", self.app_exit)
self.my_device =''
self.my_device_display = StringVar()
self.device_list=[]
self.matches=0
# overall display
root_frame=Frame(self.root)
root_frame.pack(side=LEFT)
devices_frame=Frame(root_frame,padx=5,pady=10)
devices_frame.pack(side=LEFT)
devices_label = Label(devices_frame, text="Devices in dev/input")
devices_label.pack(side=TOP)
devices_list_frame=Frame(devices_frame,padx=5,pady=10)
devices_list_frame.pack(side=TOP)
selected_device_title=Label(devices_frame,text='Selected device')
selected_device_title.pack(side=TOP)
self.selected_device_var=StringVar()
selected_device=Label(devices_frame,textvariable=self.selected_device_var,fg="red")
selected_device.pack(side=TOP)
events_frame=Frame(root_frame,padx=5,pady=10)
events_frame.pack(side=LEFT)
events_title=Label(events_frame,text='Received Events')
events_title.pack(side=TOP)
events_list_frame=Frame(events_frame,padx=5,pady=10)
events_list_frame.pack(side=TOP)
# list of devices
scrollbar = Scrollbar(devices_list_frame, orient=VERTICAL)
self.devices_display = Listbox(devices_list_frame, selectmode=SINGLE, height=20,
width = 60, bg="white",activestyle=NONE,
fg="black", yscrollcommand=scrollbar.set)
scrollbar.config(command=self.devices_display.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.devices_display.pack(side=LEFT, fill=BOTH, expand=1)
self.devices_display.bind("<ButtonRelease-1>", self.e_select_device)
# events display
scrollbar = Scrollbar(events_list_frame, orient=VERTICAL)
self.events_display = Text(events_list_frame,width=40,height=20, wrap='word', font="arial 11",padx=5,yscrollcommand=scrollbar.set)
scrollbar.config(command=self.events_display.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.events_display.pack(side=LEFT, fill=BOTH, expand=1)
self.events_display.config(state=NORMAL)
self.events_display.delete(1.0, END)
self.events_display.config(state=DISABLED)
self.selected_device_index=-1
self.matches=0
self.get_all_devices()
self.refresh_devices_display()
self.root.after(10,self.event_loop)
# and enter Tkinter event loop
self.root.mainloop()
# ***************************************
# INIT AND EXIT
# ***************************************
def app_exit(self):
self.root.destroy()
exit()
def event_loop(self):
if self.matches>0:
self.get_events()
self.root.after(10,self.event_loop)
def refresh_devices_display(self):
self.devices_display.delete(0,self.devices_display.size())
for device in self.all_devices:
self.devices_display.insert(END, device[0]+ ' ' +device[1])
if self.selected_device_index >= 0:
self.devices_display.itemconfig(self.selected_device_index,fg='red')
self.devices_display.see(self.selected_device_index)
def e_select_device(self,event):
self.selected_device_index=-1
if len(self.all_devices)>0:
self.selected_device_index=int(event.widget.curselection()[0])
selected_device=self.all_devices[self.selected_device_index]
self.selected_device_name=selected_device[0]
self.selected_device_var.set(self.selected_device_name)
self.get_matching_devices()
self.refresh_devices_display()
def get_all_devices(self):
self.all_devices=[]
devices = [evdev.InputDevice(fn) for fn in evdev.list_devices()]
for device in devices:
self.all_devices.append([device.name,device.fn])
def get_matching_devices(self):
self.matches=0
self.matching_devices=[]
devices = [evdev.InputDevice(fn) for fn in evdev.list_devices()]
for device in devices:
if self.selected_device_name in device.name:
device_ref = evdev.InputDevice(device.fn)
self.matching_devices.append(device_ref)
self.matches+=1
def get_events(self):
r,w,x = select(self.matching_devices, [], [],0)
if r == []:
return
for event in r[0].read():
if event.type == evdev.ecodes.EV_KEY:
key_event = evdev.categorize(event)
if key_event.keystate == 1:
key_text='Down'
else:
key_text='Up'
# print key_event.keycode,key_text
if type(key_event.keycode) is list:
code_text=', '.join(key_event.keycode)
else:
code_text=key_event.keycode
self.events_display.config(state=NORMAL)
self.events_display.insert(END,'\n'+ code_text + ' ' + key_text)
self.events_display.config(state=DISABLED)
self.events_display.see(END)
class PiPresents(object):
def pipresents_version(self):
vitems=self.pipresents_issue.split('.')
if len(vitems)==2:
# cope with 2 digit version numbers before 1.3.2
return 1000*int(vitems[0])+100*int(vitems[1])
else:
return 1000*int(vitems[0])+100*int(vitems[1])+int(vitems[2])
def __init__(self):
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3.2"
self.pipresents_minorissue = '1.3.2a'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'GapShow','Show','ArtShow',
'AudioPlayer','BrowserPlayer','ImagePlayer','MenuPlayer','MessagePlayer','VideoPlayer','Player',
'MediaList','LiveList','ShowList',
'PathManager','ControlsManager','ShowManager','PluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'KbdDriver','GPIODriver','TimeOfDay','ScreenDriver','Animate','OSCDriver',
'Network','Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue + ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue+ ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as file:
self.mon.log(self,'\nRaspbian: '+file.read())
self.mon.log(self,'\n'+check_output(["omxplayer", "-v"]))
self.mon.log(self,'\nGPU Memory: '+check_output(["vcgencmd", "get_mem", "gpu"]))
if "DESKTOP_SESSION" not in os.environ:
print 'Pi Presents must be run from the Desktop'
self.mon.log(self,'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self,'Desktop is '+ os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.gpiodriver=None
self.oscdriver=None
self.osc_enabled=False
self.gpio_enabled=False
self.tod_enabled=False
self.email_enabled=False
if os.geteuid() == 0:
self.mon.err(self,'Do not run Pi Presents with sudo')
self.end('error','Do not run Pi Presents with sudo')
user=os.getenv('USER')
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected=False
self.network_details=False
self.interface=''
self.ip=''
self.unit=''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled=False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject= '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime("%Y-%m-%d %H:%M")
message = time.strftime("%Y-%m-%d %H:%M") + '\nUnit: ' + self.unit + ' Profile: '+ self.options['profile']+ '\n ' + self.interface + '\n ' + self.ip
self.send_email('start',subject,message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.mon.err(self,"Profile not specified in command ")
self.end('error','Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep+ 'home' + os.sep + user + os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found is True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self,"Failed to find pp_home directory at " + home)
self.end('error',"Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self,"Running profile: " + self.pp_profile_path)
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error',"Failed to find requested profile: "+ self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) is False:
self.mon.err(self,"Validation Failed")
self.end('error','Validation Failed')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error',"showlist not found at "+self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(self,"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
self.end('error',"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error',"Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.starter_show['background-colour'])
self.mon.log(self, 'monitor screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'forced screen dimensions (--screensize) are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvas cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.starter_show['background-colour'])
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile) is False:
self.end('error','cannot find, or error in keys.cfg')
kbd.bind_keys(self.root,self.handle_input_event)
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find, or error in screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.terminate_required=False
self.exitpipresents_required=False
# delete omxplayer dbus files
# if os.path.exists("/tmp/omxplayerdbus.{}".format(user)):
# os.remove("/tmp/omxplayerdbus.{}".format(user))
# if os.path.exists("/tmp/omxplayerdbus.{}.pid".format(user)):
# os.remove("/tmp/omxplayerdbus.{}.pid".format(user))
# kick off GPIO if enabled by command line option
self.gpio_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+os.sep+ 'gpio.cfg'):
# initialise the GPIO
self.gpiodriver=GPIODriver()
reason,message=self.gpiodriver.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.handle_input_event)
if reason == 'error':
self.end('error',message)
else:
self.gpio_enabled=True
# and start polling gpio
self.gpiodriver.poll()
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,self.handle_command,self.handle_input_event,self.e_osc_handle_output_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# enable ToD scheduler if schedule exists
if os.path.exists(self.pp_profile + os.sep + 'schedule.json'):
self.tod_enabled = True
else:
self.tod_enabled=False
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(self,'Network not connected so Time of Day scheduler may be using the internal clock')
# warn about start shows and scheduler
if self.starter_show['start-show']=='' and self.tod_enabled is False:
self.mon.sched(self,"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(self,"No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] !='' and self.tod_enabled is True:
self.mon.sched(self,"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(self,"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.root,self.handle_command)
self.tod.poll()
# start Tkinters event loop
self.root.mainloop( )
def parse_screen(self,size_text):
fields=size_text.split('*')
if len(fields)!=2:
return 'error','do not understand --screensize comand option',0,0
elif fields[0].isdigit() is False or fields[1].isdigit() is False:
return 'error','dimensions are not positive integers in --screensize',0,0
else:
return 'normal','',int(fields[0]),int(fields[1])
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self,'run start shows')
# parse the start shows field and start the initial shows
show_refs=self.starter_show['start-show'].split()
for show_ref in show_refs:
reason,message=self.show_manager.control_a_show(show_ref,'open')
if reason == 'error':
self.mon.err(self,message)
# *********************
# User inputs
# ********************
# handles one command provided as a line of text
def handle_command(self,command_text,source='',show=''):
# print 'PIPRESENTS ',command_text,source,'from',show
self.mon.log(self,"command received: " + command_text)
if command_text.strip()=="":
return
if command_text[0]=='/':
if self.osc_enabled is True:
self.oscdriver.send_command(command_text)
return
fields= command_text.split()
show_command=fields[0]
if len(fields)>1:
show_ref=fields[1]
else:
show_ref=''
if show_command in ('open','close'):
self.mon.sched(self, command_text + ' received from show:'+show)
if self.shutdown_required is False and self.terminate_required is False:
reason,message=self.show_manager.control_a_show(show_ref,show_command)
else:
return
elif show_command =='monitor':
self.handle_monitor_command(show_ref)
return
elif show_command == 'event':
self.handle_input_event(show_ref,'Show Control')
return
elif show_command == 'exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
else:
reason,message= self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1,self.e_shutdown_pressed)
return
else:
reason='error'
message = 'command not recognised: '+ show_command
if reason=='error':
self.mon.err(self,message)
return
def handle_monitor_command(self,command):
if command == 'on':
os.system('vcgencmd display_power 1 >/dev/null')
elif command == 'off':
os.system('vcgencmd display_power 0 >/dev/null')
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal','no shows running')
def e_shutdown_pressed(self):
self.shutdown_pressed('now')
def e_osc_handle_output_event(self,line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_output_event(arg))
def osc_handle_output_event(self,line):
self.mon.log(self,"output event received: "+ line)
#osc sends output events as a string
reason,message,delay,name,param_type,param_values=self.animate.parse_animate_fields(line)
if reason == 'error':
self.mon.err(self,message)
self.end(reason,message)
self.handle_output_event(name,param_type,param_values,0)
def handle_output_event(self,symbol,param_type,param_values,req_time):
if self.gpio_enabled is True:
reason,message=self.gpiodriver.handle_output_event(symbol,param_type,param_values,req_time)
if reason =='error':
self.mon.err(self,message)
self.end(reason,message)
else:
self.mon.warn(self,'GPIO not enabled')
# all input events call this callback with a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self,symbol,source):
self.mon.log(self,"event received: "+symbol + ' from '+ source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.shutdown_pressed('delay')
elif symbol == 'pp-shutdownnow':
# need root.after to grt out of st thread
self.root.after(1,self.e_shutdown_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
reason,message= self.show_manager.exit_all_shows()
else:
# events for shows affect the show and could cause it to exit.
for show in self.show_manager.shows:
show_obj=show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
def shutdown_pressed(self, when):
if when == 'delay':
self.root.after(5000,self.on_shutdown_delay)
else:
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def on_shutdown_delay(self):
# 5 second delay is up, if shutdown button still pressed then shutdown
if self.gpiodriver.shutdown_pressed() is True:
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self,signum,frame):
self.mon.log(self,'SIGTERM received - '+ str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self,'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
self.terminate_required=True
needs_termination=False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination=True
self.mon.log(self,"Sent terminate to show "+ show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed','killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self,reason,message):
self.canvas.config(bg=self.starter_show['background-colour'])
if reason in ('killed','error') or self.shutdown_required is True or self.exitpipresents_required is True:
self.end(reason,message)
def end(self,reason,message):
self.mon.log(self,"Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
# gc.collect()
# print gc.garbage
if reason == 'killed':
if self.email_enabled is True and self.mailer.email_on_terminate is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Terminated'
message = time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message)
self.mon.sched(self, "Pi Presents Terminated, au revoir\n")
self.mon.log(self, "Pi Presents Terminated, au revoir")
# close logging files
self.mon.finish()
sys.exit(101)
elif reason == 'error':
if self.email_enabled is True and self.mailer.email_on_error is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Error'
message_text = 'Error message: '+ message + '\n'+ time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message_text)
self.mon.sched(self, "Pi Presents closing because of error, sorry\n")
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
sys.exit(102)
else:
self.mon.sched(self,"Pi Presents exiting normally, bye\n")
self.mon.log(self,"Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.shutdown_required is True:
# print 'SHUTDOWN'
call (['sudo','shutdown','now','SHUTTING DOWN'])
sys.exit(100)
def init_network(self):
timeout=int(self.options['nonetwork'])
if timeout== 0:
self.network_connected=False
self.unit=''
self.ip=''
self.interface=''
return
self.network=Network()
self.network_connected=False
# try to connect to network
self.mon.log (self, 'Waiting up to '+ str(timeout) + ' seconds for network')
success=self.network.wait_for_network(timeout)
if success is False:
self.mon.warn(self,'Failed to connect to network after ' + str(timeout) + ' seconds')
# tkMessageBox.showwarning("Pi Presents","Failed to connect to network so using fake-hwclock")
return
self.network_connected=True
self.mon.sched (self, 'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, 'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
# Get web configuration
self.network_details=False
network_options_file_path=self.pp_dir+os.sep+'pp_config'+os.sep+'pp_web.cfg'
if not os.path.exists(network_options_file_path):
self.mon.warn(self,"pp_web.cfg not found at "+network_options_file_path)
return
self.mon.log(self, 'Found pp_web.cfg in ' + network_options_file_path)
self.network.read_config(network_options_file_path)
self.unit=self.network.unit
# get interface and IP details of preferred interface
self.interface,self.ip = self.network.get_preferred_ip()
if self.interface == '':
self.network_connected=False
return
self.network_details=True
self.mon.log (self, 'Network details ' + self.unit + ' ' + self.interface + ' ' +self.ip)
def init_mailer(self):
self.email_enabled=False
email_file_path = self.pp_dir+os.sep+'pp_config'+os.sep+'pp_email.cfg'
if not os.path.exists(email_file_path):
self.mon.log(self,'pp_email.cfg not found at ' + email_file_path)
return
self.mon.log(self,'Found pp_email.cfg at ' + email_file_path)
self.mailer=Mailer()
self.mailer.read_config(email_file_path)
# all Ok so can enable email if config file allows it.
if self.mailer.email_allowed is True:
self.email_enabled=True
self.mon.log (self,'Email Enabled')
def send_email(self,reason,subject,message):
if self.try_connect() is False:
return False
else:
success,error = self.mailer.send(subject,message)
if success is False:
self.mon.log(self, 'Failed to send email: ' + str(error))
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect after send:' + str(error))
return False
else:
self.mon.log(self,'Sent email for ' + reason)
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect from email server ' + str(error))
return True
def try_connect(self):
tries=1
while True:
success, error = self.mailer.connect()
if success is True:
return True
else:
self.mon.log(self,'Failed to connect to email SMTP server ' + str(tries) + '\n ' +str(error))
tries +=1
if tries >5:
self.mon.log(self,'Failed to connect to email SMTP server after ' + str(tries))
return False
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.handle_monitor_command('on')
self.mon.log(self, "Tidying Up")
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset","s", "on"])
call(["xset","s", "+dpms"])
# tidy up animation and gpio
if self.animate is not None:
self.animate.terminate()
if self.gpio_enabled==True:
self.gpiodriver.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
class rayCaster(object):
def __init__(self):
self.root = Tk()
self.root.title("Ray Tracer")
canvas = Canvas(self.root, width=WIN_SIZE, height=WIN_SIZE)
self.image = PhotoImage(master=self.root,
width=WIN_SIZE,
height=WIN_SIZE)
imageCentre = (WIN_SIZE / 2 + 2, WIN_SIZE / 2 + 2)
canvas.create_image(imageCentre, image=self.image)
canvas.pack()
# Enqueue a callback to the ray tracer to start it going
self.root.after(0, lambda: self.trace())
return
def putImageRow(self, row, colours):
"""Output a list of colours to the specified row of the image.
Tk uses horrible hexadecimal formatted colours, packed into
a string separated by spaces and all enclosed in braces."
"""
hexColours = ["#%02x%02x%02x" % colour for colour in colours]
rowColourString = "{" + " ".join(hexColours) + "}"
self.image.put(rowColourString, to=(0, row))
self.root.update()
# Main body. Set up an image then compute colour at each pixel
def trace(self):
camera = definition.camera
camera.img = Image.new("RGB", (camera.size, camera.size))
print "ScottTracer"
print "\tTracing Rays... 0%",
sys.stdout.flush()
count = 0
t0 = time.clock()
max = float(WIN_SIZE**2)
lastPercentage = 0
for row in range(WIN_SIZE):
ROW = []
for col in range(WIN_SIZE):
count += 1
pixel = camera.pixelColour(col, row)
camera.img.putpixel((col, row), pixel.intColour())
ROW.append(pixel.intColour())
percentage = (count / max * 100)
self.putImageRow(row, ROW)
if percentage - lastPercentage > .9:
print "\b\b\b\b\b\b%4.0f%%" % percentage,
sys.stdout.flush()
lastPercentage = percentage
print "\b\b\b\b\b\b Done (%f sec)" % (time.clock() - t0)
print "\tAnti-alasing... 0%",
sys.stdout.flush()
t0 = time.clock()
count = 0
lastPercentage = 0
for row in range(WIN_SIZE):
ROW = []
self.putImageRow(row, [(255, 255, 255)] * WIN_SIZE)
for col in range(WIN_SIZE):
count += 1
pixel = camera.aa(col, row)
camera.img.putpixel((col, row), pixel)
ROW.append(pixel)
percentage = (count / max * 100)
self.putImageRow(row, ROW)
if percentage - lastPercentage > .9:
print "\b\b\b\b\b\b%4.0f%%" % percentage,
sys.stdout.flush()
lastPercentage = percentage
print "\b\b\b\b\b\b (%f sec)" % (time.clock() - t0)
print camera.pixels
camera.img.save(
sys.argv[1] +
".png") # Display image in default image-viewer application
class TkApplication:
# these are passed to Tk() and must be redefined by the subclasses:
tk_basename = ''
tk_class_name = ''
def __init__(self, screen_name=None, geometry=None):
self.init_tk(screen_name, geometry)
def init_tk(self, screen_name=None, geometry=None):
self.root = Tk(screenName=screen_name,
baseName=self.tk_basename,
className=self.tk_class_name)
app.root = self.root
from sk1.managers.uimanager import UIManager
app.uimanager = UIManager(self.root)
self.splash = SplashScreen(self.root)
self.splash.show()
self.splash.set_val(.1, 'DialogManager initialization...')
from sk1.managers.dialogmanager import DialogManager
app.dialogman = DialogManager(self.root)
self.splash.set_val(.15, 'Setting appication data...')
app.info1 = StringVar(self.root, '')
app.info2 = StringVar(self.root, '')
app.info3 = DoubleVar(self.root, 0)
# Reset locale again to make sure we get properly translated
# messages if desired by the user. For some reason it may
# have been reset by Tcl/Tk.
# if this fails it will already have failed in
# app/__init__.py which also prints a warning.
try:
import locale
except ImportError:
pass
else:
try:
locale.setlocale(locale.LC_MESSAGES, "")
except:
pass
if not geometry:
# try to read geometry from resource database
geometry = self.root.option_get('geometry', 'Geometry')
if geometry:
try:
self.root.geometry(geometry)
except TclError:
sys.stderr.write('%s: invalid geometry specification %s' %
(self.tk_basename, geometry))
def Mainloop(self):
self.splash.set_val(1)
self.root.update()
self.root.deiconify()
self.root.after(300, self.splash.hide)
self.root.mainloop()
def MessageBox(self, *args, **kw):
return apply(tkext.MessageDialog, (self.root, ) + args, kw)
def GetOpenFilename(self, **kwargs):
return apply(tkext.GetOpenFilename, (self.root, ), kwargs)
def GetSaveFilename(self, **kwargs):
return apply(tkext.GetSaveFilename, (self.root, ), kwargs)
clipboard = None
def EmptyClipboard(self):
self.SetClipboard(None)
def SetClipboard(self, data):
self.clipboard = data
def GetClipboard(self):
return self.clipboard
def ClipboardContainsData(self):
return self.clipboard is not None
class ShiftReduceApp(object):
"""
A graphical tool for exploring the shift-reduce parser. The tool
displays the parser's stack and the remaining text, and allows the
user to control the parser's operation. In particular, the user
can shift tokens onto the stack, and can perform reductions on the
top elements of the stack. A "step" button simply steps through
the parsing process, performing the operations that
``nltk.parse.ShiftReduceParser`` would use.
"""
def __init__(self, grammar, sent, trace=0):
self._sent = sent
self._parser = SteppingShiftReduceParser(grammar, trace)
# Set up the main window.
self._top = Tk()
self._top.title('Shift Reduce Parser Application')
# Animations. animating_lock is a lock to prevent the demo
# from performing new operations while it's animating.
self._animating_lock = 0
self._animate = IntVar(self._top)
self._animate.set(10) # = medium
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Initialize fonts.
self._init_fonts(self._top)
# Set up key bindings.
self._init_bindings()
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_feedback(self._top)
self._init_grammar(self._top)
self._init_canvas(self._top)
# A popup menu for reducing.
self._reduce_menu = Menu(self._canvas, tearoff=0)
# Reset the demo, and set the feedback frame to empty.
self.reset()
self._lastoper1['text'] = ''
#########################################
## Initialization Helpers
#########################################
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = tkFont.Font(font=Button()["font"])
root.option_add("*Font", self._sysfont)
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(root)
self._size.set(self._sysfont.cget('size'))
self._boldfont = tkFont.Font(family='helvetica',
weight='bold',
size=self._size.get())
self._font = tkFont.Font(family='helvetica', size=self._size.get())
def _init_grammar(self, parent):
# Grammar view.
self._prodframe = listframe = Frame(parent)
self._prodframe.pack(fill='both', side='left', padx=2)
self._prodlist_label = Label(self._prodframe,
font=self._boldfont,
text='Available Reductions')
self._prodlist_label.pack()
self._prodlist = Listbox(self._prodframe,
selectmode='single',
relief='groove',
background='white',
foreground='#909090',
font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._prodlist.pack(side='right', fill='both', expand=1)
self._productions = list(self._parser.grammar().productions())
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
self._prodlist.config(height=min(len(self._productions), 25))
# Add a scrollbar if there are more than 25 productions.
if 1: #len(self._productions) > 25:
listscroll = Scrollbar(self._prodframe, orient='vertical')
self._prodlist.config(yscrollcommand=listscroll.set)
listscroll.config(command=self._prodlist.yview)
listscroll.pack(side='left', fill='y')
# If they select a production, apply it.
self._prodlist.bind('<<ListboxSelect>>', self._prodlist_select)
# When they hover over a production, highlight it.
self._hover = -1
self._prodlist.bind('<Motion>', self._highlight_hover)
self._prodlist.bind('<Leave>', self._clear_hover)
def _init_bindings(self):
# Quit
self._top.bind('<Control-q>', self.destroy)
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Alt-q>', self.destroy)
self._top.bind('<Alt-x>', self.destroy)
# Ops (step, shift, reduce, undo)
self._top.bind('<space>', self.step)
self._top.bind('<s>', self.shift)
self._top.bind('<Alt-s>', self.shift)
self._top.bind('<Control-s>', self.shift)
self._top.bind('<r>', self.reduce)
self._top.bind('<Alt-r>', self.reduce)
self._top.bind('<Control-r>', self.reduce)
self._top.bind('<Delete>', self.reset)
self._top.bind('<u>', self.undo)
self._top.bind('<Alt-u>', self.undo)
self._top.bind('<Control-u>', self.undo)
self._top.bind('<Control-z>', self.undo)
self._top.bind('<BackSpace>', self.undo)
# Misc
self._top.bind('<Control-p>', self.postscript)
self._top.bind('<Control-h>', self.help)
self._top.bind('<F1>', self.help)
self._top.bind('<Control-g>', self.edit_grammar)
self._top.bind('<Control-t>', self.edit_sentence)
# Animation speed control
self._top.bind('-', lambda e, a=self._animate: a.set(20))
self._top.bind('=', lambda e, a=self._animate: a.set(10))
self._top.bind('+', lambda e, a=self._animate: a.set(4))
def _init_buttons(self, parent):
# Set up the frames.
self._buttonframe = buttonframe = Frame(parent)
buttonframe.pack(fill='none', side='bottom')
Button(
buttonframe,
text='Step',
background='#90c0d0',
foreground='black',
command=self.step,
).pack(side='left')
Button(buttonframe,
text='Shift',
underline=0,
background='#90f090',
foreground='black',
command=self.shift).pack(side='left')
Button(buttonframe,
text='Reduce',
underline=0,
background='#90f090',
foreground='black',
command=self.reduce).pack(side='left')
Button(buttonframe,
text='Undo',
underline=0,
background='#f0a0a0',
foreground='black',
command=self.undo).pack(side='left')
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Reset Parser',
underline=0,
command=self.reset,
accelerator='Del')
filemenu.add_command(label='Print to Postscript',
underline=0,
command=self.postscript,
accelerator='Ctrl-p')
filemenu.add_command(label='Exit',
underline=1,
command=self.destroy,
accelerator='Ctrl-x')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label='Edit Grammar',
underline=5,
command=self.edit_grammar,
accelerator='Ctrl-g')
editmenu.add_command(label='Edit Text',
underline=5,
command=self.edit_sentence,
accelerator='Ctrl-t')
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
rulemenu = Menu(menubar, tearoff=0)
rulemenu.add_command(label='Step',
underline=1,
command=self.step,
accelerator='Space')
rulemenu.add_separator()
rulemenu.add_command(label='Shift',
underline=0,
command=self.shift,
accelerator='Ctrl-s')
rulemenu.add_command(label='Reduce',
underline=0,
command=self.reduce,
accelerator='Ctrl-r')
rulemenu.add_separator()
rulemenu.add_command(label='Undo',
underline=0,
command=self.undo,
accelerator='Ctrl-u')
menubar.add_cascade(label='Apply', underline=0, menu=rulemenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_checkbutton(label="Show Grammar",
underline=0,
variable=self._show_grammar,
command=self._toggle_grammar)
viewmenu.add_separator()
viewmenu.add_radiobutton(label='Tiny',
variable=self._size,
underline=0,
value=10,
command=self.resize)
viewmenu.add_radiobutton(label='Small',
variable=self._size,
underline=0,
value=12,
command=self.resize)
viewmenu.add_radiobutton(label='Medium',
variable=self._size,
underline=0,
value=14,
command=self.resize)
viewmenu.add_radiobutton(label='Large',
variable=self._size,
underline=0,
value=18,
command=self.resize)
viewmenu.add_radiobutton(label='Huge',
variable=self._size,
underline=0,
value=24,
command=self.resize)
menubar.add_cascade(label='View', underline=0, menu=viewmenu)
animatemenu = Menu(menubar, tearoff=0)
animatemenu.add_radiobutton(label="No Animation",
underline=0,
variable=self._animate,
value=0)
animatemenu.add_radiobutton(label="Slow Animation",
underline=0,
variable=self._animate,
value=20,
accelerator='-')
animatemenu.add_radiobutton(label="Normal Animation",
underline=0,
variable=self._animate,
value=10,
accelerator='=')
animatemenu.add_radiobutton(label="Fast Animation",
underline=0,
variable=self._animate,
value=4,
accelerator='+')
menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0, command=self.about)
helpmenu.add_command(label='Instructions',
underline=0,
command=self.help,
accelerator='F1')
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
def _init_feedback(self, parent):
self._feedbackframe = feedbackframe = Frame(parent)
feedbackframe.pack(fill='x', side='bottom', padx=3, pady=3)
self._lastoper_label = Label(feedbackframe,
text='Last Operation:',
font=self._font)
self._lastoper_label.pack(side='left')
lastoperframe = Frame(feedbackframe, relief='sunken', border=1)
lastoperframe.pack(fill='x', side='right', expand=1, padx=5)
self._lastoper1 = Label(lastoperframe,
foreground='#007070',
background='#f0f0f0',
font=self._font)
self._lastoper2 = Label(lastoperframe,
anchor='w',
width=30,
foreground='#004040',
background='#f0f0f0',
font=self._font)
self._lastoper1.pack(side='left')
self._lastoper2.pack(side='left', fill='x', expand=1)
def _init_canvas(self, parent):
self._cframe = CanvasFrame(parent,
background='white',
width=525,
closeenough=10,
border=2,
relief='sunken')
self._cframe.pack(expand=1, fill='both', side='top', pady=2)
canvas = self._canvas = self._cframe.canvas()
self._stackwidgets = []
self._rtextwidgets = []
self._titlebar = canvas.create_rectangle(0,
0,
0,
0,
fill='#c0f0f0',
outline='black')
self._exprline = canvas.create_line(0, 0, 0, 0, dash='.')
self._stacktop = canvas.create_line(0, 0, 0, 0, fill='#408080')
size = self._size.get() + 4
self._stacklabel = TextWidget(canvas,
'Stack',
color='#004040',
font=self._boldfont)
self._rtextlabel = TextWidget(canvas,
'Remaining Text',
color='#004040',
font=self._boldfont)
self._cframe.add_widget(self._stacklabel)
self._cframe.add_widget(self._rtextlabel)
#########################################
## Main draw procedure
#########################################
def _redraw(self):
scrollregion = self._canvas['scrollregion'].split()
(cx1, cy1, cx2, cy2) = [int(c) for c in scrollregion]
# Delete the old stack & rtext widgets.
for stackwidget in self._stackwidgets:
self._cframe.destroy_widget(stackwidget)
self._stackwidgets = []
for rtextwidget in self._rtextwidgets:
self._cframe.destroy_widget(rtextwidget)
self._rtextwidgets = []
# Position the titlebar & exprline
(x1, y1, x2, y2) = self._stacklabel.bbox()
y = y2 - y1 + 10
self._canvas.coords(self._titlebar, -5000, 0, 5000, y - 4)
self._canvas.coords(self._exprline, 0, y * 2 - 10, 5000, y * 2 - 10)
# Position the titlebar labels..
(x1, y1, x2, y2) = self._stacklabel.bbox()
self._stacklabel.move(5 - x1, 3 - y1)
(x1, y1, x2, y2) = self._rtextlabel.bbox()
self._rtextlabel.move(cx2 - x2 - 5, 3 - y1)
# Draw the stack.
stackx = 5
for tok in self._parser.stack():
if isinstance(tok, Tree):
attribs = {
'tree_color': '#4080a0',
'tree_width': 2,
'node_font': self._boldfont,
'node_color': '#006060',
'leaf_color': '#006060',
'leaf_font': self._font
}
widget = tree_to_treesegment(self._canvas, tok, **attribs)
widget.node()['color'] = '#000000'
else:
widget = TextWidget(self._canvas,
tok,
color='#000000',
font=self._font)
widget.bind_click(self._popup_reduce)
self._stackwidgets.append(widget)
self._cframe.add_widget(widget, stackx, y)
stackx = widget.bbox()[2] + 10
# Draw the remaining text.
rtextwidth = 0
for tok in self._parser.remaining_text():
widget = TextWidget(self._canvas,
tok,
color='#000000',
font=self._font)
self._rtextwidgets.append(widget)
self._cframe.add_widget(widget, rtextwidth, y)
rtextwidth = widget.bbox()[2] + 4
# Allow enough room to shift the next token (for animations)
if len(self._rtextwidgets) > 0:
stackx += self._rtextwidgets[0].width()
# Move the remaining text to the correct location (keep it
# right-justified, when possible); and move the remaining text
# label, if necessary.
stackx = max(stackx, self._stacklabel.width() + 25)
rlabelwidth = self._rtextlabel.width() + 10
if stackx >= cx2 - max(rtextwidth, rlabelwidth):
cx2 = stackx + max(rtextwidth, rlabelwidth)
for rtextwidget in self._rtextwidgets:
rtextwidget.move(4 + cx2 - rtextwidth, 0)
self._rtextlabel.move(cx2 - self._rtextlabel.bbox()[2] - 5, 0)
midx = (stackx + cx2 - max(rtextwidth, rlabelwidth)) / 2
self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
(x1, y1, x2, y2) = self._stacklabel.bbox()
# Set up binding to allow them to shift a token by dragging it.
if len(self._rtextwidgets) > 0:
def drag_shift(widget, midx=midx, self=self):
if widget.bbox()[0] < midx: self.shift()
else: self._redraw()
self._rtextwidgets[0].bind_drag(drag_shift)
self._rtextwidgets[0].bind_click(self.shift)
# Draw the stack top.
self._highlight_productions()
def _draw_stack_top(self, widget):
# hack..
midx = widget.bbox()[2] + 50
self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
def _highlight_productions(self):
# Highlight the productions that can be reduced.
self._prodlist.selection_clear(0, 'end')
for prod in self._parser.reducible_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
if self._top is None: return
self._top.destroy()
self._top = None
def reset(self, *e):
self._parser.initialize(self._sent)
self._lastoper1['text'] = 'Reset App'
self._lastoper2['text'] = ''
self._redraw()
def step(self, *e):
if self.reduce(): return 1
elif self.shift(): return 1
else:
if len(self._parser.parses()) > 0:
self._lastoper1['text'] = 'Finished:'
self._lastoper2['text'] = 'Success'
else:
self._lastoper1['text'] = 'Finished:'
self._lastoper2['text'] = 'Failure'
def shift(self, *e):
if self._animating_lock: return
if self._parser.shift():
tok = self._parser.stack()[-1]
self._lastoper1['text'] = 'Shift:'
self._lastoper2['text'] = '%r' % tok
if self._animate.get():
self._animate_shift()
else:
self._redraw()
return 1
return 0
def reduce(self, *e):
if self._animating_lock: return
production = self._parser.reduce()
if production:
self._lastoper1['text'] = 'Reduce:'
self._lastoper2['text'] = '%s' % production
if self._animate.get():
self._animate_reduce()
else:
self._redraw()
return production
def undo(self, *e):
if self._animating_lock: return
if self._parser.undo():
self._redraw()
def postscript(self, *e):
self._cframe.print_to_file()
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self._top.mainloop(*args, **kwargs)
#########################################
## Menubar callbacks
#########################################
def resize(self, size=None):
if size is not None: self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._boldfont.configure(size=-(abs(size)))
self._sysfont.configure(size=-(abs(size)))
#self._stacklabel['font'] = ('helvetica', -size-4, 'bold')
#self._rtextlabel['font'] = ('helvetica', -size-4, 'bold')
#self._lastoper_label['font'] = ('helvetica', -size)
#self._lastoper1['font'] = ('helvetica', -size)
#self._lastoper2['font'] = ('helvetica', -size)
#self._prodlist['font'] = ('helvetica', -size)
#self._prodlist_label['font'] = ('helvetica', -size-2, 'bold')
self._redraw()
def help(self, *e):
# The default font's not very legible; try using 'fixed' instead.
try:
ShowText(self._top,
'Help: Shift-Reduce Parser Application', (__doc__
or '').strip(),
width=75,
font='fixed')
except:
ShowText(self._top,
'Help: Shift-Reduce Parser Application', (__doc__
or '').strip(),
width=75)
def about(self, *e):
ABOUT = ("NLTK Shift-Reduce Parser Application\n" +
"Written by Edward Loper")
TITLE = 'About: Shift-Reduce Parser Application'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
def edit_grammar(self, *e):
CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
def set_grammar(self, grammar):
self._parser.set_grammar(grammar)
self._productions = list(grammar.productions())
self._prodlist.delete(0, 'end')
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
def edit_sentence(self, *e):
sentence = string.join(self._sent)
title = 'Edit Text'
instr = 'Enter a new sentence to parse.'
EntryDialog(self._top, sentence, instr, self.set_sentence, title)
def set_sentence(self, sent):
self._sent = sent.split() #[XX] use tagged?
self.reset()
#########################################
## Reduce Production Selection
#########################################
def _toggle_grammar(self, *e):
if self._show_grammar.get():
self._prodframe.pack(fill='both',
side='left',
padx=2,
after=self._feedbackframe)
self._lastoper1['text'] = 'Show Grammar'
else:
self._prodframe.pack_forget()
self._lastoper1['text'] = 'Hide Grammar'
self._lastoper2['text'] = ''
def _prodlist_select(self, event):
selection = self._prodlist.curselection()
if len(selection) != 1: return
index = int(selection[0])
production = self._parser.reduce(self._productions[index])
if production:
self._lastoper1['text'] = 'Reduce:'
self._lastoper2['text'] = '%s' % production
if self._animate.get():
self._animate_reduce()
else:
self._redraw()
else:
# Reset the production selections.
self._prodlist.selection_clear(0, 'end')
for prod in self._parser.reducible_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
def _popup_reduce(self, widget):
# Remove old commands.
productions = self._parser.reducible_productions()
if len(productions) == 0: return
self._reduce_menu.delete(0, 'end')
for production in productions:
self._reduce_menu.add_command(label=str(production),
command=self.reduce)
self._reduce_menu.post(self._canvas.winfo_pointerx(),
self._canvas.winfo_pointery())
#########################################
## Animations
#########################################
def _animate_shift(self):
# What widget are we shifting?
widget = self._rtextwidgets[0]
# Where are we shifting from & to?
right = widget.bbox()[0]
if len(self._stackwidgets) == 0: left = 5
else: left = self._stackwidgets[-1].bbox()[2] + 10
# Start animating.
dt = self._animate.get()
dx = (left - right) * 1.0 / dt
self._animate_shift_frame(dt, widget, dx)
def _animate_shift_frame(self, frame, widget, dx):
if frame > 0:
self._animating_lock = 1
widget.move(dx, 0)
self._top.after(10, self._animate_shift_frame, frame - 1, widget,
dx)
else:
# but: stacktop??
# Shift the widget to the stack.
del self._rtextwidgets[0]
self._stackwidgets.append(widget)
self._animating_lock = 0
# Display the available productions.
self._draw_stack_top(widget)
self._highlight_productions()
def _animate_reduce(self):
# What widgets are we shifting?
numwidgets = len(self._parser.stack()[-1]) # number of children
widgets = self._stackwidgets[-numwidgets:]
# How far are we moving?
if isinstance(widgets[0], TreeSegmentWidget):
ydist = 15 + widgets[0].node().height()
else:
ydist = 15 + widgets[0].height()
# Start animating.
dt = self._animate.get()
dy = ydist * 2.0 / dt
self._animate_reduce_frame(dt / 2, widgets, dy)
def _animate_reduce_frame(self, frame, widgets, dy):
if frame > 0:
self._animating_lock = 1
for widget in widgets:
widget.move(0, dy)
self._top.after(10, self._animate_reduce_frame, frame - 1, widgets,
dy)
else:
del self._stackwidgets[-len(widgets):]
for widget in widgets:
self._cframe.remove_widget(widget)
tok = self._parser.stack()[-1]
if not isinstance(tok, Tree): raise ValueError()
label = TextWidget(self._canvas,
str(tok.node),
color='#006060',
font=self._boldfont)
widget = TreeSegmentWidget(self._canvas, label, widgets, width=2)
(x1, y1, x2, y2) = self._stacklabel.bbox()
y = y2 - y1 + 10
if not self._stackwidgets: x = 5
else: x = self._stackwidgets[-1].bbox()[2] + 10
self._cframe.add_widget(widget, x, y)
self._stackwidgets.append(widget)
# Display the available productions.
self._draw_stack_top(widget)
self._highlight_productions()
# # Delete the old widgets..
# del self._stackwidgets[-len(widgets):]
# for widget in widgets:
# self._cframe.destroy_widget(widget)
#
# # Make a new one.
# tok = self._parser.stack()[-1]
# if isinstance(tok, Tree):
# attribs = {'tree_color': '#4080a0', 'tree_width': 2,
# 'node_font': bold, 'node_color': '#006060',
# 'leaf_color': '#006060', 'leaf_font':self._font}
# widget = tree_to_treesegment(self._canvas, tok.type(),
# **attribs)
# widget.node()['color'] = '#000000'
# else:
# widget = TextWidget(self._canvas, tok.type(),
# color='#000000', font=self._font)
# widget.bind_click(self._popup_reduce)
# (x1, y1, x2, y2) = self._stacklabel.bbox()
# y = y2-y1+10
# if not self._stackwidgets: x = 5
# else: x = self._stackwidgets[-1].bbox()[2] + 10
# self._cframe.add_widget(widget, x, y)
# self._stackwidgets.append(widget)
#self._redraw()
self._animating_lock = 0
#########################################
## Hovering.
#########################################
def _highlight_hover(self, event):
# What production are we hovering over?
index = self._prodlist.nearest(event.y)
if self._hover == index: return
# Clear any previous hover highlighting.
self._clear_hover()
# If the production corresponds to an available reduction,
# highlight the stack.
selection = [int(s) for s in self._prodlist.curselection()]
if index in selection:
rhslen = len(self._productions[index].rhs())
for stackwidget in self._stackwidgets[-rhslen:]:
if isinstance(stackwidget, TreeSegmentWidget):
stackwidget.node()['color'] = '#00a000'
else:
stackwidget['color'] = '#00a000'
# Remember what production we're hovering over.
self._hover = index
def _clear_hover(self, *event):
# Clear any previous hover highlighting.
if self._hover == -1: return
self._hover = -1
for stackwidget in self._stackwidgets:
if isinstance(stackwidget, TreeSegmentWidget):
stackwidget.node()['color'] = 'black'
else:
stackwidget['color'] = 'black'
def main():
if len(sys.argv) == 2:
configFileName = sys.argv[1]
else:
configFileName = "freeworld.config"
cfgReader = ConfigFileReader.ConfigFileReader(configFileName)
ret, height, width, numRobots, R, baseX, baseY, initLocs, obstacles = cfgReader.readCfg(
)
if ret == -1:
print 'readCfg() Unsuccessful!'
sys.exit(-1)
else:
print 'Read the config file', configFileName
k = 2
T = 100000
# algo = Faigl.Faigl(height, width, obstacles, numRobots, initLocs, T)
# algo = FrontierClusters.FrontierClusters(height, width, obstacles, numRobots, initLocs, T)
algo = CAC.CAC(height, width, obstacles, numRobots, initLocs, T)
# algo = Yamauchi.Yamauchi(height, width, obstacles, numRobots, initLocs, T)
# algo = Burgard.Burgard(height, width, obstacles, numRobots, initLocs, T)
# algo.printGrid()
# print ''
# print ''
# cfgc = algo.generateCfgcPopulation()
# for j in range(T):
# algo.runOneIterV2()
# timeTaken = algo.printVisitedStatus()
# if timeTaken == 0:
# return T
# return timeTaken
# Code that takes care of the GUI
if height <= 10:
xoffset = 300
else:
xoffset = 100
if width <= 10:
yoffset = 300
else:
yoffset = 100
maxScreenHeight = 700
cellSize = int(floor(maxScreenHeight / (height + 2)))
root = Tk()
gui = GridUI.GridUI(root, height, width, cellSize, algo.gridworld,
algo.robots, algo.frontier)
guiHeight = str((height + 2) * cellSize)
guiWidth = str((width + 2) * cellSize)
xOffset = str(xoffset)
yOffset = str(yoffset)
geometryParam = guiWidth + 'x' + guiHeight + '+' + xOffset + '+' + yOffset
root.geometry(geometryParam)
# Runs one iteration of the algorithm and updates the GUI
def run():
algo.runOneIter()
gui.redraw(height, width, cellSize, algo.gridworld, algo.robots,
algo.frontier)
root.after(1, run)
root.after(1, run)
root.mainloop()
#------replace images------------
from Tkinter import Label, Tk
import ImageTk
import Image
import threading
from PIL import ImageGrab
im = ImageGrab.grab() # shot the screen
im.save(r'd:\screen.png') # save the shot screen
path = 'd:\screen.png'
root = Tk() # get GUI
img = ImageTk.PhotoImage(Image.open(path)) # create img from shot screen
panel = Label(root, image=img)
panel.pack() # display image
def screenshot():
im1 = ImageGrab.grab()
im1.save(r'd:\screen.png')
img1 = ImageTk.PhotoImage(Image.open('d:\screen.png'))
panel.configure(
image=img1) # critical code --> update the configure new img
panel.image = img1 # update the img
root.after(40, screenshot) # recursive function delay 40ms
root.after(500, screenshot) # call function after 500ms
root.mainloop() # play GUI
else:
print "Please provide an arugment:\n\ttest: runs the test sets\n\tgame: runs the levels"
sys.exit(1)
def startFunction():
for i in range(0, len(_app.levels)):
_solver = solver.Solver("./data/data.json", _app.levels[i])
_app.displayLevel(_app.levels[i])
root.update()
_solver.solve()
raw_input("Press Enter to view solution...")
while(len(_solver.moveList) > 0):
root.update()
_solver.stepThroughSolution()
_app.displayLevel(_solver.getLevel())
time.sleep(0.13)
if i != len(_app.levels) -1:
raw_input("Press Enter to begin solving next level")
else:
raw_input("Done! Press enter to exit.")
sys.exit(0)
if __name__=='__main__':
root = Tk()
_app = app.App(root)
check_args(_app)
root.after(500, startFunction)
_app.run()
eye_left = c.create_oval(130, 110, 160, 170, outline='black', fill='white')
eye_right = c.create_oval(230, 110, 260, 170, outline='black', fill='white')
pupil_left = c.create_oval(140,145,150, 155, outline='black', fill='black')
pupil_right = c.create_oval(240, 145, 250, 155, outline='black',fill='black')
#Normal mouth
mouth_normal = c.create_line(170, 250, 200, 282, 230, 250, smooth=1, width=2, state=NORMAL)
#Petting face
mouth_happy = c.create_line(170, 250, 200, 292, 230, 250, smooth=1, width=2, state=HIDDEN)
blush_left = c.create_oval(70, 180, 120, 230, outline='hotpink', fill='hotpink', state=HIDDEN)
blush_right = c.create_oval(280, 180, 330, 230, outline='hotpink', fill='hotpink', state=HIDDEN)
#Sad face
mouth_sad = c.create_line(170, 250, 200, 232, 230, 250, smooth=1, width=2,state=HIDDEN)
#Tongue
tongue_main = c.create_rectangle(170, 250, 230, 290, outline='deeppink', fill='deeppink', state=HIDDEN)
tongue_tip = c.create_oval(170, 285, 230, 300, outline='deeppink', fill='deeppink', state=HIDDEN)
c.pack()
#Animations
c.bind('<Motion>', show_happy)
c.bind('<Leave>', hide_happy)
c.bind('<Double-1>', cheeky)
c.eyes_crossed = False
c.tongue_out = False
root.after(1000, blink)
root.mainloop()
class ShiftReduceApp(object):
"""
A graphical tool for exploring the shift-reduce parser. The tool
displays the parser's stack and the remaining text, and allows the
user to control the parser's operation. In particular, the user
can shift tokens onto the stack, and can perform reductions on the
top elements of the stack. A "step" button simply steps through
the parsing process, performing the operations that
``nltk.parse.ShiftReduceParser`` would use.
"""
def __init__(self, grammar, sent, trace=0):
self._sent = sent
self._parser = SteppingShiftReduceParser(grammar, trace)
# Set up the main window.
self._top = Tk()
self._top.title("Shift Reduce Parser Application")
# Animations. animating_lock is a lock to prevent the demo
# from performing new operations while it's animating.
self._animating_lock = 0
self._animate = IntVar(self._top)
self._animate.set(10) # = medium
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Initialize fonts.
self._init_fonts(self._top)
# Set up key bindings.
self._init_bindings()
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_feedback(self._top)
self._init_grammar(self._top)
self._init_canvas(self._top)
# A popup menu for reducing.
self._reduce_menu = Menu(self._canvas, tearoff=0)
# Reset the demo, and set the feedback frame to empty.
self.reset()
self._lastoper1["text"] = ""
#########################################
## Initialization Helpers
#########################################
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = tkFont.Font(font=Button()["font"])
root.option_add("*Font", self._sysfont)
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(root)
self._size.set(self._sysfont.cget("size"))
self._boldfont = tkFont.Font(family="helvetica", weight="bold", size=self._size.get())
self._font = tkFont.Font(family="helvetica", size=self._size.get())
def _init_grammar(self, parent):
# Grammar view.
self._prodframe = listframe = Frame(parent)
self._prodframe.pack(fill="both", side="left", padx=2)
self._prodlist_label = Label(self._prodframe, font=self._boldfont, text="Available Reductions")
self._prodlist_label.pack()
self._prodlist = Listbox(
self._prodframe,
selectmode="single",
relief="groove",
background="white",
foreground="#909090",
font=self._font,
selectforeground="#004040",
selectbackground="#c0f0c0",
)
self._prodlist.pack(side="right", fill="both", expand=1)
self._productions = list(self._parser.grammar().productions())
for production in self._productions:
self._prodlist.insert("end", (" %s" % production))
self._prodlist.config(height=min(len(self._productions), 25))
# Add a scrollbar if there are more than 25 productions.
if 1: # len(self._productions) > 25:
listscroll = Scrollbar(self._prodframe, orient="vertical")
self._prodlist.config(yscrollcommand=listscroll.set)
listscroll.config(command=self._prodlist.yview)
listscroll.pack(side="left", fill="y")
# If they select a production, apply it.
self._prodlist.bind("<<ListboxSelect>>", self._prodlist_select)
# When they hover over a production, highlight it.
self._hover = -1
self._prodlist.bind("<Motion>", self._highlight_hover)
self._prodlist.bind("<Leave>", self._clear_hover)
def _init_bindings(self):
# Quit
self._top.bind("<Control-q>", self.destroy)
self._top.bind("<Control-x>", self.destroy)
self._top.bind("<Alt-q>", self.destroy)
self._top.bind("<Alt-x>", self.destroy)
# Ops (step, shift, reduce, undo)
self._top.bind("<space>", self.step)
self._top.bind("<s>", self.shift)
self._top.bind("<Alt-s>", self.shift)
self._top.bind("<Control-s>", self.shift)
self._top.bind("<r>", self.reduce)
self._top.bind("<Alt-r>", self.reduce)
self._top.bind("<Control-r>", self.reduce)
self._top.bind("<Delete>", self.reset)
self._top.bind("<u>", self.undo)
self._top.bind("<Alt-u>", self.undo)
self._top.bind("<Control-u>", self.undo)
self._top.bind("<Control-z>", self.undo)
self._top.bind("<BackSpace>", self.undo)
# Misc
self._top.bind("<Control-p>", self.postscript)
self._top.bind("<Control-h>", self.help)
self._top.bind("<F1>", self.help)
self._top.bind("<Control-g>", self.edit_grammar)
self._top.bind("<Control-t>", self.edit_sentence)
# Animation speed control
self._top.bind("-", lambda e, a=self._animate: a.set(20))
self._top.bind("=", lambda e, a=self._animate: a.set(10))
self._top.bind("+", lambda e, a=self._animate: a.set(4))
def _init_buttons(self, parent):
# Set up the frames.
self._buttonframe = buttonframe = Frame(parent)
buttonframe.pack(fill="none", side="bottom")
Button(buttonframe, text="Step", background="#90c0d0", foreground="black", command=self.step).pack(side="left")
Button(
buttonframe, text="Shift", underline=0, background="#90f090", foreground="black", command=self.shift
).pack(side="left")
Button(
buttonframe, text="Reduce", underline=0, background="#90f090", foreground="black", command=self.reduce
).pack(side="left")
Button(buttonframe, text="Undo", underline=0, background="#f0a0a0", foreground="black", command=self.undo).pack(
side="left"
)
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Reset Parser", underline=0, command=self.reset, accelerator="Del")
filemenu.add_command(label="Print to Postscript", underline=0, command=self.postscript, accelerator="Ctrl-p")
filemenu.add_command(label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x")
menubar.add_cascade(label="File", underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label="Edit Grammar", underline=5, command=self.edit_grammar, accelerator="Ctrl-g")
editmenu.add_command(label="Edit Text", underline=5, command=self.edit_sentence, accelerator="Ctrl-t")
menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
rulemenu = Menu(menubar, tearoff=0)
rulemenu.add_command(label="Step", underline=1, command=self.step, accelerator="Space")
rulemenu.add_separator()
rulemenu.add_command(label="Shift", underline=0, command=self.shift, accelerator="Ctrl-s")
rulemenu.add_command(label="Reduce", underline=0, command=self.reduce, accelerator="Ctrl-r")
rulemenu.add_separator()
rulemenu.add_command(label="Undo", underline=0, command=self.undo, accelerator="Ctrl-u")
menubar.add_cascade(label="Apply", underline=0, menu=rulemenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_checkbutton(
label="Show Grammar", underline=0, variable=self._show_grammar, command=self._toggle_grammar
)
viewmenu.add_separator()
viewmenu.add_radiobutton(label="Tiny", variable=self._size, underline=0, value=10, command=self.resize)
viewmenu.add_radiobutton(label="Small", variable=self._size, underline=0, value=12, command=self.resize)
viewmenu.add_radiobutton(label="Medium", variable=self._size, underline=0, value=14, command=self.resize)
viewmenu.add_radiobutton(label="Large", variable=self._size, underline=0, value=18, command=self.resize)
viewmenu.add_radiobutton(label="Huge", variable=self._size, underline=0, value=24, command=self.resize)
menubar.add_cascade(label="View", underline=0, menu=viewmenu)
animatemenu = Menu(menubar, tearoff=0)
animatemenu.add_radiobutton(label="No Animation", underline=0, variable=self._animate, value=0)
animatemenu.add_radiobutton(
label="Slow Animation", underline=0, variable=self._animate, value=20, accelerator="-"
)
animatemenu.add_radiobutton(
label="Normal Animation", underline=0, variable=self._animate, value=10, accelerator="="
)
animatemenu.add_radiobutton(
label="Fast Animation", underline=0, variable=self._animate, value=4, accelerator="+"
)
menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", underline=0, command=self.about)
helpmenu.add_command(label="Instructions", underline=0, command=self.help, accelerator="F1")
menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
parent.config(menu=menubar)
def _init_feedback(self, parent):
self._feedbackframe = feedbackframe = Frame(parent)
feedbackframe.pack(fill="x", side="bottom", padx=3, pady=3)
self._lastoper_label = Label(feedbackframe, text="Last Operation:", font=self._font)
self._lastoper_label.pack(side="left")
lastoperframe = Frame(feedbackframe, relief="sunken", border=1)
lastoperframe.pack(fill="x", side="right", expand=1, padx=5)
self._lastoper1 = Label(lastoperframe, foreground="#007070", background="#f0f0f0", font=self._font)
self._lastoper2 = Label(
lastoperframe, anchor="w", width=30, foreground="#004040", background="#f0f0f0", font=self._font
)
self._lastoper1.pack(side="left")
self._lastoper2.pack(side="left", fill="x", expand=1)
def _init_canvas(self, parent):
self._cframe = CanvasFrame(parent, background="white", width=525, closeenough=10, border=2, relief="sunken")
self._cframe.pack(expand=1, fill="both", side="top", pady=2)
canvas = self._canvas = self._cframe.canvas()
self._stackwidgets = []
self._rtextwidgets = []
self._titlebar = canvas.create_rectangle(0, 0, 0, 0, fill="#c0f0f0", outline="black")
self._exprline = canvas.create_line(0, 0, 0, 0, dash=".")
self._stacktop = canvas.create_line(0, 0, 0, 0, fill="#408080")
size = self._size.get() + 4
self._stacklabel = TextWidget(canvas, "Stack", color="#004040", font=self._boldfont)
self._rtextlabel = TextWidget(canvas, "Remaining Text", color="#004040", font=self._boldfont)
self._cframe.add_widget(self._stacklabel)
self._cframe.add_widget(self._rtextlabel)
#########################################
## Main draw procedure
#########################################
def _redraw(self):
scrollregion = self._canvas["scrollregion"].split()
(cx1, cy1, cx2, cy2) = [int(c) for c in scrollregion]
# Delete the old stack & rtext widgets.
for stackwidget in self._stackwidgets:
self._cframe.destroy_widget(stackwidget)
self._stackwidgets = []
for rtextwidget in self._rtextwidgets:
self._cframe.destroy_widget(rtextwidget)
self._rtextwidgets = []
# Position the titlebar & exprline
(x1, y1, x2, y2) = self._stacklabel.bbox()
y = y2 - y1 + 10
self._canvas.coords(self._titlebar, -5000, 0, 5000, y - 4)
self._canvas.coords(self._exprline, 0, y * 2 - 10, 5000, y * 2 - 10)
# Position the titlebar labels..
(x1, y1, x2, y2) = self._stacklabel.bbox()
self._stacklabel.move(5 - x1, 3 - y1)
(x1, y1, x2, y2) = self._rtextlabel.bbox()
self._rtextlabel.move(cx2 - x2 - 5, 3 - y1)
# Draw the stack.
stackx = 5
for tok in self._parser.stack():
if isinstance(tok, Tree):
attribs = {
"tree_color": "#4080a0",
"tree_width": 2,
"node_font": self._boldfont,
"node_color": "#006060",
"leaf_color": "#006060",
"leaf_font": self._font,
}
widget = tree_to_treesegment(self._canvas, tok, **attribs)
widget.node()["color"] = "#000000"
else:
widget = TextWidget(self._canvas, tok, color="#000000", font=self._font)
widget.bind_click(self._popup_reduce)
self._stackwidgets.append(widget)
self._cframe.add_widget(widget, stackx, y)
stackx = widget.bbox()[2] + 10
# Draw the remaining text.
rtextwidth = 0
for tok in self._parser.remaining_text():
widget = TextWidget(self._canvas, tok, color="#000000", font=self._font)
self._rtextwidgets.append(widget)
self._cframe.add_widget(widget, rtextwidth, y)
rtextwidth = widget.bbox()[2] + 4
# Allow enough room to shift the next token (for animations)
if len(self._rtextwidgets) > 0:
stackx += self._rtextwidgets[0].width()
# Move the remaining text to the correct location (keep it
# right-justified, when possible); and move the remaining text
# label, if necessary.
stackx = max(stackx, self._stacklabel.width() + 25)
rlabelwidth = self._rtextlabel.width() + 10
if stackx >= cx2 - max(rtextwidth, rlabelwidth):
cx2 = stackx + max(rtextwidth, rlabelwidth)
for rtextwidget in self._rtextwidgets:
rtextwidget.move(4 + cx2 - rtextwidth, 0)
self._rtextlabel.move(cx2 - self._rtextlabel.bbox()[2] - 5, 0)
midx = (stackx + cx2 - max(rtextwidth, rlabelwidth)) / 2
self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
(x1, y1, x2, y2) = self._stacklabel.bbox()
# Set up binding to allow them to shift a token by dragging it.
if len(self._rtextwidgets) > 0:
def drag_shift(widget, midx=midx, self=self):
if widget.bbox()[0] < midx:
self.shift()
else:
self._redraw()
self._rtextwidgets[0].bind_drag(drag_shift)
self._rtextwidgets[0].bind_click(self.shift)
# Draw the stack top.
self._highlight_productions()
def _draw_stack_top(self, widget):
# hack..
midx = widget.bbox()[2] + 50
self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
def _highlight_productions(self):
# Highlight the productions that can be reduced.
self._prodlist.selection_clear(0, "end")
for prod in self._parser.reducible_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
if self._top is None:
return
self._top.destroy()
self._top = None
def reset(self, *e):
self._parser.initialize(self._sent)
self._lastoper1["text"] = "Reset App"
self._lastoper2["text"] = ""
self._redraw()
def step(self, *e):
if self.reduce():
return 1
elif self.shift():
return 1
else:
if len(self._parser.parses()) > 0:
self._lastoper1["text"] = "Finished:"
self._lastoper2["text"] = "Success"
else:
self._lastoper1["text"] = "Finished:"
self._lastoper2["text"] = "Failure"
def shift(self, *e):
if self._animating_lock:
return
if self._parser.shift():
tok = self._parser.stack()[-1]
self._lastoper1["text"] = "Shift:"
self._lastoper2["text"] = "%r" % tok
if self._animate.get():
self._animate_shift()
else:
self._redraw()
return 1
return 0
def reduce(self, *e):
if self._animating_lock:
return
production = self._parser.reduce()
if production:
self._lastoper1["text"] = "Reduce:"
self._lastoper2["text"] = "%s" % production
if self._animate.get():
self._animate_reduce()
else:
self._redraw()
return production
def undo(self, *e):
if self._animating_lock:
return
if self._parser.undo():
self._redraw()
def postscript(self, *e):
self._cframe.print_to_file()
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle():
return
self._top.mainloop(*args, **kwargs)
#########################################
## Menubar callbacks
#########################################
def resize(self, size=None):
if size is not None:
self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._boldfont.configure(size=-(abs(size)))
self._sysfont.configure(size=-(abs(size)))
# self._stacklabel['font'] = ('helvetica', -size-4, 'bold')
# self._rtextlabel['font'] = ('helvetica', -size-4, 'bold')
# self._lastoper_label['font'] = ('helvetica', -size)
# self._lastoper1['font'] = ('helvetica', -size)
# self._lastoper2['font'] = ('helvetica', -size)
# self._prodlist['font'] = ('helvetica', -size)
# self._prodlist_label['font'] = ('helvetica', -size-2, 'bold')
self._redraw()
def help(self, *e):
# The default font's not very legible; try using 'fixed' instead.
try:
ShowText(self._top, "Help: Shift-Reduce Parser Application", (__doc__).strip(), width=75, font="fixed")
except:
ShowText(self._top, "Help: Shift-Reduce Parser Application", (__doc__).strip(), width=75)
def about(self, *e):
ABOUT = "NLTK Shift-Reduce Parser Application\n" + "Written by Edward Loper"
TITLE = "About: Shift-Reduce Parser Application"
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
def edit_grammar(self, *e):
CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
def set_grammar(self, grammar):
self._parser.set_grammar(grammar)
self._productions = list(grammar.productions())
self._prodlist.delete(0, "end")
for production in self._productions:
self._prodlist.insert("end", (" %s" % production))
def edit_sentence(self, *e):
sentence = string.join(self._sent)
title = "Edit Text"
instr = "Enter a new sentence to parse."
EntryDialog(self._top, sentence, instr, self.set_sentence, title)
def set_sentence(self, sent):
self._sent = sent.split() # [XX] use tagged?
self.reset()
#########################################
## Reduce Production Selection
#########################################
def _toggle_grammar(self, *e):
if self._show_grammar.get():
self._prodframe.pack(fill="both", side="left", padx=2, after=self._feedbackframe)
self._lastoper1["text"] = "Show Grammar"
else:
self._prodframe.pack_forget()
self._lastoper1["text"] = "Hide Grammar"
self._lastoper2["text"] = ""
def _prodlist_select(self, event):
selection = self._prodlist.curselection()
if len(selection) != 1:
return
index = int(selection[0])
production = self._parser.reduce(self._productions[index])
if production:
self._lastoper1["text"] = "Reduce:"
self._lastoper2["text"] = "%s" % production
if self._animate.get():
self._animate_reduce()
else:
self._redraw()
else:
# Reset the production selections.
self._prodlist.selection_clear(0, "end")
for prod in self._parser.reducible_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
def _popup_reduce(self, widget):
# Remove old commands.
productions = self._parser.reducible_productions()
if len(productions) == 0:
return
self._reduce_menu.delete(0, "end")
for production in productions:
self._reduce_menu.add_command(label=str(production), command=self.reduce)
self._reduce_menu.post(self._canvas.winfo_pointerx(), self._canvas.winfo_pointery())
#########################################
## Animations
#########################################
def _animate_shift(self):
# What widget are we shifting?
widget = self._rtextwidgets[0]
# Where are we shifting from & to?
right = widget.bbox()[0]
if len(self._stackwidgets) == 0:
left = 5
else:
left = self._stackwidgets[-1].bbox()[2] + 10
# Start animating.
dt = self._animate.get()
dx = (left - right) * 1.0 / dt
self._animate_shift_frame(dt, widget, dx)
def _animate_shift_frame(self, frame, widget, dx):
if frame > 0:
self._animating_lock = 1
widget.move(dx, 0)
self._top.after(10, self._animate_shift_frame, frame - 1, widget, dx)
else:
# but: stacktop??
# Shift the widget to the stack.
del self._rtextwidgets[0]
self._stackwidgets.append(widget)
self._animating_lock = 0
# Display the available productions.
self._draw_stack_top(widget)
self._highlight_productions()
def _animate_reduce(self):
# What widgets are we shifting?
numwidgets = len(self._parser.stack()[-1]) # number of children
widgets = self._stackwidgets[-numwidgets:]
# How far are we moving?
if isinstance(widgets[0], TreeSegmentWidget):
ydist = 15 + widgets[0].node().height()
else:
ydist = 15 + widgets[0].height()
# Start animating.
dt = self._animate.get()
dy = ydist * 2.0 / dt
self._animate_reduce_frame(dt / 2, widgets, dy)
def _animate_reduce_frame(self, frame, widgets, dy):
if frame > 0:
self._animating_lock = 1
for widget in widgets:
widget.move(0, dy)
self._top.after(10, self._animate_reduce_frame, frame - 1, widgets, dy)
else:
del self._stackwidgets[-len(widgets) :]
for widget in widgets:
self._cframe.remove_widget(widget)
tok = self._parser.stack()[-1]
if not isinstance(tok, Tree):
raise ValueError()
label = TextWidget(self._canvas, str(tok.node), color="#006060", font=self._boldfont)
widget = TreeSegmentWidget(self._canvas, label, widgets, width=2)
(x1, y1, x2, y2) = self._stacklabel.bbox()
y = y2 - y1 + 10
if not self._stackwidgets:
x = 5
else:
x = self._stackwidgets[-1].bbox()[2] + 10
self._cframe.add_widget(widget, x, y)
self._stackwidgets.append(widget)
# Display the available productions.
self._draw_stack_top(widget)
self._highlight_productions()
# # Delete the old widgets..
# del self._stackwidgets[-len(widgets):]
# for widget in widgets:
# self._cframe.destroy_widget(widget)
#
# # Make a new one.
# tok = self._parser.stack()[-1]
# if isinstance(tok, Tree):
# attribs = {'tree_color': '#4080a0', 'tree_width': 2,
# 'node_font': bold, 'node_color': '#006060',
# 'leaf_color': '#006060', 'leaf_font':self._font}
# widget = tree_to_treesegment(self._canvas, tok.type(),
# **attribs)
# widget.node()['color'] = '#000000'
# else:
# widget = TextWidget(self._canvas, tok.type(),
# color='#000000', font=self._font)
# widget.bind_click(self._popup_reduce)
# (x1, y1, x2, y2) = self._stacklabel.bbox()
# y = y2-y1+10
# if not self._stackwidgets: x = 5
# else: x = self._stackwidgets[-1].bbox()[2] + 10
# self._cframe.add_widget(widget, x, y)
# self._stackwidgets.append(widget)
# self._redraw()
self._animating_lock = 0
#########################################
## Hovering.
#########################################
def _highlight_hover(self, event):
# What production are we hovering over?
index = self._prodlist.nearest(event.y)
if self._hover == index:
return
# Clear any previous hover highlighting.
self._clear_hover()
# If the production corresponds to an available reduction,
# highlight the stack.
selection = [int(s) for s in self._prodlist.curselection()]
if index in selection:
rhslen = len(self._productions[index].rhs())
for stackwidget in self._stackwidgets[-rhslen:]:
if isinstance(stackwidget, TreeSegmentWidget):
stackwidget.node()["color"] = "#00a000"
else:
stackwidget["color"] = "#00a000"
# Remember what production we're hovering over.
self._hover = index
def _clear_hover(self, *event):
# Clear any previous hover highlighting.
if self._hover == -1:
return
self._hover = -1
for stackwidget in self._stackwidgets:
if isinstance(stackwidget, TreeSegmentWidget):
stackwidget.node()["color"] = "black"
else:
stackwidget["color"] = "black"
def main():
cfgReader = ConfigFileReader.ConfigFileReader("barmaze.config")
ret, height, width, numRobots, R, baseX, baseY, initLocs, obstacles = cfgReader.readCfg()
if ret == -1:
print 'readCfg() Unsuccessful!'
sys.exit(-1)
print 'height', height
print 'width', width
print 'numRobots', numRobots
print 'R', R
print 'baseX', baseX
print 'baseY', baseY
print 'initLocs', initLocs
print 'obstacles', obstacles
k = 10
T = 1000
algo = CommExplore.CommExplore(height, width, obstacles, numRobots, initLocs, R, k)
algo.printGrid()
print ''
print ''
cfgc = algo.generateCfgcPopulation()
# for j in range(T):
# algo.runOneIter()
# timeTaken = algo.printVisitedStatus()
# if timeTaken == 0:
# return T
# return timeTaken
if height <= 10:
xoffset = 300
else:
xoffset = 100
if width <= 10:
yoffset = 300
else:
yoffset = 100
maxScreenHeight = 700
cellSize = int(floor(maxScreenHeight / (height + 2)))
root = Tk()
# ex = Example(root)
# root.geometry('400x100+500+500')
# root.mainloop()
gui = GridUI.GridUI(root, height, width, cellSize, algo.gridworld, algo.robots, algo.frontier)
guiHeight = str((height + 2) * cellSize)
guiWidth = str((width + 2) * cellSize)
xOffset = str(xoffset)
yOffset = str(yoffset)
geometryParam = guiWidth + 'x' + guiHeight + '+' + xOffset + '+' + yOffset
root.geometry(geometryParam)
def run():
algo.runOneIter()
gui.redraw(height, width, cellSize, algo.gridworld, algo.robots, algo.frontier)
root.after(50, run)
root.after(50, run)
root.mainloop()
class gui:
def __init__(self, sonar):
self.tk = Tk()
self.canvas = Canvas(self.tk, height=800, width=800)
self.canvas.pack()
self.next = Button(self.tk, text='next', command=self.step)
self.next.pack()
self.rb = Button(self.tk, text='run', command=self.run)
self.rb.pack()
self.sonar = sonar
self.draw_map()
self.draw_move_points()
self.delete_old = True
#self.tk.after(20,self.redraw)
self.tk.mainloop()
def run(self):
self.next.config(state='disabled')
self.rb.config(state='disabled')
self.manual = False
self.tk.after(50, self.redraw)
def step(self):
self.manual = True
self.redraw()
def redraw(self):
check = self.sonar.sim_step()
if self.delete_old:
self.canvas.delete('scan')
self.canvas.delete('intersect')
self.canvas.delete('particle')
self.canvas.delete('mvln')
self.draw_sonar_data()
self.draw_particle_data()
if check is not -1 and self.manual is False:
self.tk.after(50, self.redraw)
def draw_sonar_data(self):
#print 'data'
#for line in self.sonar.scan_lines:
#draw_line(self.canvas, line, tag='scan')
#for point in self.sonar.intersection_points:
#draw_point(self.canvas, point, tag='intersect')
draw_point(self.canvas, self.sonar.loc, tag='sonar', colour='red')
def draw_particle_data(self):
particles = self.sonar.particles.list()
for particle in particles:
draw_point(self.canvas, particle.loc, weight=particle.wt, tag='particle')
if particle.move_line:
draw_line(self.canvas, particle.move_line, tag='mvln')
#for line in particle.scan:
# draw_line(self.canvas, line, tag='scan')
#for intersect in particle.int:
#draw_point(self.canvas, intersect, tag='intersect')
def draw_map(self):
#print 'map'
for line in self.sonar.map.lines:
draw_line(self.canvas, line, tag='map')
def draw_move_points(self):
for point in self.sonar.get_move_list():
draw_point(self.canvas, point[0], tag='mvpt')
class UI(object):
def __init__(self):
self._root = Tk()
self._root.title("^ NotiFire ^")
self._name = StringVar()
self._is_osx = which_system() == 'Darwin'
self._version = None
##########################################################################
#### Public methods #####
##########################################################################
def get_name(self):
frame = DraggableFrame(self._root)
frame.pack(side=TOP, fill=BOTH, expand=YES)
frame.columnconfigure(0, weight=1)
frame.columnconfigure(4, weight=1)
frame.rowconfigure(0, weight=1)
frame.rowconfigure(4, weight=1)
w = self._set_frame_geo(frame, 0.3, 0.3)[2]
self._set_x_button(frame, w, self._close_get_name)
Label(frame, text="Name:").grid(column=1, row=1)
entry_style = SUNKEN if self._is_osx else FLAT
entry = Entry(frame, exportselection=0, relief=entry_style, textvariable=self._name)
entry.grid(column=2, row=1)
entry.focus_set()
error_label = Label(frame, fg='red')
error_label.grid(column=1, row=2, columnspan=3)
ok_cmd = partial(self._validate_name, error_label)
FlatButton(frame, text='OK', width=20, font=("calibri", 15),
command=ok_cmd).grid(column=1, row=3, columnspan=3)
self._root.bind('<Return>', ok_cmd)
self._root.bind('<Escape>', self._close_get_name)
self._run()
return self._name.get() if self._name else self._name
def main_window(self, name, ping_callback):
self._name.set(name)
self._ping_callback = ping_callback
# Create Frame
self.frame = DraggableFrame(self._root)
self.frame.pack(side=TOP, fill=BOTH, expand=YES)
w = self._set_frame_geo(self.frame, 0.5, 0.6)[2]
self._set_x_button(self.frame, w, self._root.destroy)
Label(self.frame, text="Name:").place(x=10, y=15)
Label(self.frame, text=self._name.get(), fg='blue').place(x=80, y=15)
self._version_label = Label(self.frame, text="Newer version detected, please restart the app", fg='#a00', font=("calibri", 25))
FlatButton(self.frame, text="Test", width=26, command=self._test_action).place(x=10, y=50)
FlatButton(self.frame, text='Refresh', width=26, command=self._generate_ping_buttons).place(x=10, y=90)
self.ping_buttons = []
self._auto_refresh()
self._check_version()
self._run()
##########################################################################
#### Private methods #####
##########################################################################
def _run(self):
# Set transparency
self._root.wait_visibility(self._root)
self._root.attributes('-alpha', 0.95)
self._root.lift()
# Run Event loop
self._root.mainloop()
def _close_get_name(self, event=None):
self._name = None
self._root.destroy()
def _set_frame_geo(self, frame, wf, hf):
# Set frame size and position
screen_width = frame.master.winfo_screenwidth()
screen_heigh = frame.master.winfo_screenheight()
w = screen_width * wf
h = screen_heigh * hf
# Center the window
x = (screen_width/2) - (w/2)
y = (screen_heigh/2) - (h/2)
frame.master.geometry('%dx%d+%d+%d' % (w, h, x, y))
if not self._is_osx:
frame.master.overrideredirect(True) # Set no border or title
return x, y, w, h
def _set_x_button(self, frame, w, callback):
x_button_x_coordinate = w-30 if self._is_osx else w-20
FlatButton(frame, text='×', no_bg=True, width=1, font=("calibri", 15), command=callback).place(x=x_button_x_coordinate, y=-10)
def _validate_name(self, error_label, event=None):
name = self._name.get()
if not 0 < len(name) < 25:
error_label.config(text="Name must be 1-25 chars long")
logger.error("Invalid name: %s" % (name))
elif not all(ord(c) < 128 for c in name):
error_label.config(text="Name must be ascii")
logger.error("Invalid Name: %s" % (name))
else:
self._root.destroy()
def _test_action(self):
self._ping_someone(self._name.get())
def _ping_someone(self, name):
ret = self._ping_callback(name)
if not ret:
self._generate_ping_buttons()
splash.error(name + ' is no longer available')
def _generate_ping_buttons(self):
logger.info("generating buttons")
#TODO put in a frame with a scrollbar
for button in self.ping_buttons:
button.destroy()
self.ping_buttons = []
next_y = 10
for name in sorted(NotiFireDb.get_all_names()):
if self._name.get() == name:
continue
cmd = partial(self._ping_someone, name)
button = FlatButton(self.frame, text="Ping " + name, width=20, command=cmd)
self.ping_buttons.append(button)
button.place(x=300, y=next_y)
next_y += 40
def _auto_refresh(self):
self._generate_ping_buttons()
self._root.after(600000, self._auto_refresh) # Run again in 10 mintues
def _check_version(self):
with open("version.txt") as f:
latest = StrictVersion(f.read())
if self._version is None:
self._version = latest
elif self._version < latest:
self._version_label.place(x=80, y=255)
return
self._root.after(86400000, self._check_version) # Run again in 1 day
class RecursiveDescentApp(object):
"""
A graphical tool for exploring the recursive descent parser. The tool
displays the parser's tree and the remaining text, and allows the
user to control the parser's operation. In particular, the user
can expand subtrees on the frontier, match tokens on the frontier
against the text, and backtrack. A "step" button simply steps
through the parsing process, performing the operations that
``RecursiveDescentParser`` would use.
"""
def __init__(self, grammar, sent, trace=0):
self._sent = sent
self._parser = SteppingRecursiveDescentParser(grammar, trace)
# Set up the main window.
self._top = Tk()
self._top.title('Recursive Descent Parser Application')
# Set up key bindings.
self._init_bindings()
# Initialize the fonts.
self._init_fonts(self._top)
# Animations. animating_lock is a lock to prevent the demo
# from performing new operations while it's animating.
self._animation_frames = IntVar(self._top)
self._animation_frames.set(5)
self._animating_lock = 0
self._autostep = 0
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_feedback(self._top)
self._init_grammar(self._top)
self._init_canvas(self._top)
# Initialize the parser.
self._parser.initialize(self._sent)
# Resize callback
self._canvas.bind('<Configure>', self._configure)
#########################################
## Initialization Helpers
#########################################
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = tkFont.Font(font=Button()["font"])
root.option_add("*Font", self._sysfont)
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(root)
self._size.set(self._sysfont.cget('size'))
self._boldfont = tkFont.Font(family='helvetica', weight='bold',
size=self._size.get())
self._font = tkFont.Font(family='helvetica',
size=self._size.get())
if self._size.get() < 0: big = self._size.get()-2
else: big = self._size.get()+2
self._bigfont = tkFont.Font(family='helvetica', weight='bold',
size=big)
def _init_grammar(self, parent):
# Grammar view.
self._prodframe = listframe = Frame(parent)
self._prodframe.pack(fill='both', side='left', padx=2)
self._prodlist_label = Label(self._prodframe, font=self._boldfont,
text='Available Expansions')
self._prodlist_label.pack()
self._prodlist = Listbox(self._prodframe, selectmode='single',
relief='groove', background='white',
foreground='#909090', font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._prodlist.pack(side='right', fill='both', expand=1)
self._productions = list(self._parser.grammar().productions())
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
self._prodlist.config(height=min(len(self._productions), 25))
# Add a scrollbar if there are more than 25 productions.
if len(self._productions) > 25:
listscroll = Scrollbar(self._prodframe,
orient='vertical')
self._prodlist.config(yscrollcommand = listscroll.set)
listscroll.config(command=self._prodlist.yview)
listscroll.pack(side='left', fill='y')
# If they select a production, apply it.
self._prodlist.bind('<<ListboxSelect>>', self._prodlist_select)
def _init_bindings(self):
# Key bindings are a good thing.
self._top.bind('<Control-q>', self.destroy)
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Escape>', self.destroy)
self._top.bind('e', self.expand)
#self._top.bind('<Alt-e>', self.expand)
#self._top.bind('<Control-e>', self.expand)
self._top.bind('m', self.match)
self._top.bind('<Alt-m>', self.match)
self._top.bind('<Control-m>', self.match)
self._top.bind('b', self.backtrack)
self._top.bind('<Alt-b>', self.backtrack)
self._top.bind('<Control-b>', self.backtrack)
self._top.bind('<Control-z>', self.backtrack)
self._top.bind('<BackSpace>', self.backtrack)
self._top.bind('a', self.autostep)
#self._top.bind('<Control-a>', self.autostep)
self._top.bind('<Control-space>', self.autostep)
self._top.bind('<Control-c>', self.cancel_autostep)
self._top.bind('<space>', self.step)
self._top.bind('<Delete>', self.reset)
self._top.bind('<Control-p>', self.postscript)
#self._top.bind('<h>', self.help)
#self._top.bind('<Alt-h>', self.help)
self._top.bind('<Control-h>', self.help)
self._top.bind('<F1>', self.help)
#self._top.bind('<g>', self.toggle_grammar)
#self._top.bind('<Alt-g>', self.toggle_grammar)
#self._top.bind('<Control-g>', self.toggle_grammar)
self._top.bind('<Control-g>', self.edit_grammar)
self._top.bind('<Control-t>', self.edit_sentence)
def _init_buttons(self, parent):
# Set up the frames.
self._buttonframe = buttonframe = Frame(parent)
buttonframe.pack(fill='none', side='bottom', padx=3, pady=2)
Button(buttonframe, text='Step',
background='#90c0d0', foreground='black',
command=self.step,).pack(side='left')
Button(buttonframe, text='Autostep',
background='#90c0d0', foreground='black',
command=self.autostep,).pack(side='left')
Button(buttonframe, text='Expand', underline=0,
background='#90f090', foreground='black',
command=self.expand).pack(side='left')
Button(buttonframe, text='Match', underline=0,
background='#90f090', foreground='black',
command=self.match).pack(side='left')
Button(buttonframe, text='Backtrack', underline=0,
background='#f0a0a0', foreground='black',
command=self.backtrack).pack(side='left')
# Replace autostep...
# self._autostep_button = Button(buttonframe, text='Autostep',
# underline=0, command=self.autostep)
# self._autostep_button.pack(side='left')
def _configure(self, event):
self._autostep = 0
(x1, y1, x2, y2) = self._cframe.scrollregion()
y2 = event.height - 6
self._canvas['scrollregion'] = '%d %d %d %d' % (x1,y1,x2,y2)
self._redraw()
def _init_feedback(self, parent):
self._feedbackframe = feedbackframe = Frame(parent)
feedbackframe.pack(fill='x', side='bottom', padx=3, pady=3)
self._lastoper_label = Label(feedbackframe, text='Last Operation:',
font=self._font)
self._lastoper_label.pack(side='left')
lastoperframe = Frame(feedbackframe, relief='sunken', border=1)
lastoperframe.pack(fill='x', side='right', expand=1, padx=5)
self._lastoper1 = Label(lastoperframe, foreground='#007070',
background='#f0f0f0', font=self._font)
self._lastoper2 = Label(lastoperframe, anchor='w', width=30,
foreground='#004040', background='#f0f0f0',
font=self._font)
self._lastoper1.pack(side='left')
self._lastoper2.pack(side='left', fill='x', expand=1)
def _init_canvas(self, parent):
self._cframe = CanvasFrame(parent, background='white',
#width=525, height=250,
closeenough=10,
border=2, relief='sunken')
self._cframe.pack(expand=1, fill='both', side='top', pady=2)
canvas = self._canvas = self._cframe.canvas()
# Initially, there's no tree or text
self._tree = None
self._textwidgets = []
self._textline = None
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Reset Parser', underline=0,
command=self.reset, accelerator='Del')
filemenu.add_command(label='Print to Postscript', underline=0,
command=self.postscript, accelerator='Ctrl-p')
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-x')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label='Edit Grammar', underline=5,
command=self.edit_grammar,
accelerator='Ctrl-g')
editmenu.add_command(label='Edit Text', underline=5,
command=self.edit_sentence,
accelerator='Ctrl-t')
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
rulemenu = Menu(menubar, tearoff=0)
rulemenu.add_command(label='Step', underline=1,
command=self.step, accelerator='Space')
rulemenu.add_separator()
rulemenu.add_command(label='Match', underline=0,
command=self.match, accelerator='Ctrl-m')
rulemenu.add_command(label='Expand', underline=0,
command=self.expand, accelerator='Ctrl-e')
rulemenu.add_separator()
rulemenu.add_command(label='Backtrack', underline=0,
command=self.backtrack, accelerator='Ctrl-b')
menubar.add_cascade(label='Apply', underline=0, menu=rulemenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_checkbutton(label="Show Grammar", underline=0,
variable=self._show_grammar,
command=self._toggle_grammar)
viewmenu.add_separator()
viewmenu.add_radiobutton(label='Tiny', variable=self._size,
underline=0, value=10, command=self.resize)
viewmenu.add_radiobutton(label='Small', variable=self._size,
underline=0, value=12, command=self.resize)
viewmenu.add_radiobutton(label='Medium', variable=self._size,
underline=0, value=14, command=self.resize)
viewmenu.add_radiobutton(label='Large', variable=self._size,
underline=0, value=18, command=self.resize)
viewmenu.add_radiobutton(label='Huge', variable=self._size,
underline=0, value=24, command=self.resize)
menubar.add_cascade(label='View', underline=0, menu=viewmenu)
animatemenu = Menu(menubar, tearoff=0)
animatemenu.add_radiobutton(label="No Animation", underline=0,
variable=self._animation_frames,
value=0)
animatemenu.add_radiobutton(label="Slow Animation", underline=0,
variable=self._animation_frames,
value=10, accelerator='-')
animatemenu.add_radiobutton(label="Normal Animation", underline=0,
variable=self._animation_frames,
value=5, accelerator='=')
animatemenu.add_radiobutton(label="Fast Animation", underline=0,
variable=self._animation_frames,
value=2, accelerator='+')
menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0,
command=self.about)
helpmenu.add_command(label='Instructions', underline=0,
command=self.help, accelerator='F1')
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
#########################################
## Helper
#########################################
def _get(self, widget, treeloc):
for i in treeloc: widget = widget.subtrees()[i]
if isinstance(widget, TreeSegmentWidget):
widget = widget.node()
return widget
#########################################
## Main draw procedure
#########################################
def _redraw(self):
canvas = self._canvas
# Delete the old tree, widgets, etc.
if self._tree is not None:
self._cframe.destroy_widget(self._tree)
for twidget in self._textwidgets:
self._cframe.destroy_widget(twidget)
if self._textline is not None:
self._canvas.delete(self._textline)
# Draw the tree.
helv = ('helvetica', -self._size.get())
bold = ('helvetica', -self._size.get(), 'bold')
attribs = {'tree_color': '#000000', 'tree_width': 2,
'node_font': bold, 'leaf_font': helv,}
tree = self._parser.tree()
self._tree = tree_to_treesegment(canvas, tree, **attribs)
self._cframe.add_widget(self._tree, 30, 5)
# Draw the text.
helv = ('helvetica', -self._size.get())
bottom = y = self._cframe.scrollregion()[3]
self._textwidgets = [TextWidget(canvas, word, font=self._font)
for word in self._sent]
for twidget in self._textwidgets:
self._cframe.add_widget(twidget, 0, 0)
twidget.move(0, bottom-twidget.bbox()[3]-5)
y = min(y, twidget.bbox()[1])
# Draw a line over the text, to separate it from the tree.
self._textline = canvas.create_line(-5000, y-5, 5000, y-5, dash='.')
# Highlight appropriate nodes.
self._highlight_nodes()
self._highlight_prodlist()
# Make sure the text lines up.
self._position_text()
def _redraw_quick(self):
# This should be more-or-less sufficient after an animation.
self._highlight_nodes()
self._highlight_prodlist()
self._position_text()
def _highlight_nodes(self):
# Highlight the list of nodes to be checked.
bold = ('helvetica', -self._size.get(), 'bold')
for treeloc in self._parser.frontier()[:1]:
self._get(self._tree, treeloc)['color'] = '#20a050'
self._get(self._tree, treeloc)['font'] = bold
for treeloc in self._parser.frontier()[1:]:
self._get(self._tree, treeloc)['color'] = '#008080'
def _highlight_prodlist(self):
# Highlight the productions that can be expanded.
# Boy, too bad tkinter doesn't implement Listbox.itemconfig;
# that would be pretty useful here.
self._prodlist.delete(0, 'end')
expandable = self._parser.expandable_productions()
untried = self._parser.untried_expandable_productions()
productions = self._productions
for index in range(len(productions)):
if productions[index] in expandable:
if productions[index] in untried:
self._prodlist.insert(index, ' %s' % productions[index])
else:
self._prodlist.insert(index, ' %s (TRIED)' %
productions[index])
self._prodlist.selection_set(index)
else:
self._prodlist.insert(index, ' %s' % productions[index])
def _position_text(self):
# Line up the text widgets that are matched against the tree
numwords = len(self._sent)
num_matched = numwords - len(self._parser.remaining_text())
leaves = self._tree_leaves()[:num_matched]
xmax = self._tree.bbox()[0]
for i in range(0, len(leaves)):
widget = self._textwidgets[i]
leaf = leaves[i]
widget['color'] = '#006040'
leaf['color'] = '#006040'
widget.move(leaf.bbox()[0] - widget.bbox()[0], 0)
xmax = widget.bbox()[2] + 10
# Line up the text widgets that are not matched against the tree.
for i in range(len(leaves), numwords):
widget = self._textwidgets[i]
widget['color'] = '#a0a0a0'
widget.move(xmax - widget.bbox()[0], 0)
xmax = widget.bbox()[2] + 10
# If we have a complete parse, make everything green :)
if self._parser.currently_complete():
for twidget in self._textwidgets:
twidget['color'] = '#00a000'
# Move the matched leaves down to the text.
for i in range(0, len(leaves)):
widget = self._textwidgets[i]
leaf = leaves[i]
dy = widget.bbox()[1] - leaf.bbox()[3] - 10.0
dy = max(dy, leaf.parent().node().bbox()[3] - leaf.bbox()[3] + 10)
leaf.move(0, dy)
def _tree_leaves(self, tree=None):
if tree is None: tree = self._tree
if isinstance(tree, TreeSegmentWidget):
leaves = []
for child in tree.subtrees(): leaves += self._tree_leaves(child)
return leaves
else:
return [tree]
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
self._autostep = 0
if self._top is None: return
self._top.destroy()
self._top = None
def reset(self, *e):
self._autostep = 0
self._parser.initialize(self._sent)
self._lastoper1['text'] = 'Reset Application'
self._lastoper2['text'] = ''
self._redraw()
def autostep(self, *e):
if self._animation_frames.get() == 0:
self._animation_frames.set(2)
if self._autostep:
self._autostep = 0
else:
self._autostep = 1
self._step()
def cancel_autostep(self, *e):
#self._autostep_button['text'] = 'Autostep'
self._autostep = 0
# Make sure to stop auto-stepping if we get any user input.
def step(self, *e): self._autostep = 0; self._step()
def match(self, *e): self._autostep = 0; self._match()
def expand(self, *e): self._autostep = 0; self._expand()
def backtrack(self, *e): self._autostep = 0; self._backtrack()
def _step(self):
if self._animating_lock: return
# Try expanding, matching, and backtracking (in that order)
if self._expand(): pass
elif self._parser.untried_match() and self._match(): pass
elif self._backtrack(): pass
else:
self._lastoper1['text'] = 'Finished'
self._lastoper2['text'] = ''
self._autostep = 0
# Check if we just completed a parse.
if self._parser.currently_complete():
self._autostep = 0
self._lastoper2['text'] += ' [COMPLETE PARSE]'
def _expand(self, *e):
if self._animating_lock: return
old_frontier = self._parser.frontier()
rv = self._parser.expand()
if rv is not None:
self._lastoper1['text'] = 'Expand:'
self._lastoper2['text'] = rv
self._prodlist.selection_clear(0, 'end')
index = self._productions.index(rv)
self._prodlist.selection_set(index)
self._animate_expand(old_frontier[0])
return 1
else:
self._lastoper1['text'] = 'Expand:'
self._lastoper2['text'] = '(all expansions tried)'
return 0
def _match(self, *e):
if self._animating_lock: return
old_frontier = self._parser.frontier()
rv = self._parser.match()
if rv is not None:
self._lastoper1['text'] = 'Match:'
self._lastoper2['text'] = rv
self._animate_match(old_frontier[0])
return 1
else:
self._lastoper1['text'] = 'Match:'
self._lastoper2['text'] = '(failed)'
return 0
def _backtrack(self, *e):
if self._animating_lock: return
if self._parser.backtrack():
elt = self._parser.tree()
for i in self._parser.frontier()[0]:
elt = elt[i]
self._lastoper1['text'] = 'Backtrack'
self._lastoper2['text'] = ''
if isinstance(elt, Tree):
self._animate_backtrack(self._parser.frontier()[0])
else:
self._animate_match_backtrack(self._parser.frontier()[0])
return 1
else:
self._autostep = 0
self._lastoper1['text'] = 'Finished'
self._lastoper2['text'] = ''
return 0
def about(self, *e):
ABOUT = ("NLTK Recursive Descent Parser Application\n"+
"Written by Edward Loper")
TITLE = 'About: Recursive Descent Parser Application'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
def help(self, *e):
self._autostep = 0
# The default font's not very legible; try using 'fixed' instead.
try:
ShowText(self._top, 'Help: Recursive Descent Parser Application',
(__doc__ or '').strip(), width=75, font='fixed')
except:
ShowText(self._top, 'Help: Recursive Descent Parser Application',
(__doc__ or '').strip(), width=75)
def postscript(self, *e):
self._autostep = 0
self._cframe.print_to_file()
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self._top.mainloop(*args, **kwargs)
def resize(self, size=None):
if size is not None: self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._boldfont.configure(size=-(abs(size)))
self._sysfont.configure(size=-(abs(size)))
self._bigfont.configure(size=-(abs(size+2)))
self._redraw()
#########################################
## Expand Production Selection
#########################################
def _toggle_grammar(self, *e):
if self._show_grammar.get():
self._prodframe.pack(fill='both', side='left', padx=2,
after=self._feedbackframe)
self._lastoper1['text'] = 'Show Grammar'
else:
self._prodframe.pack_forget()
self._lastoper1['text'] = 'Hide Grammar'
self._lastoper2['text'] = ''
# def toggle_grammar(self, *e):
# self._show_grammar = not self._show_grammar
# if self._show_grammar:
# self._prodframe.pack(fill='both', expand='y', side='left',
# after=self._feedbackframe)
# self._lastoper1['text'] = 'Show Grammar'
# else:
# self._prodframe.pack_forget()
# self._lastoper1['text'] = 'Hide Grammar'
# self._lastoper2['text'] = ''
def _prodlist_select(self, event):
selection = self._prodlist.curselection()
if len(selection) != 1: return
index = int(selection[0])
old_frontier = self._parser.frontier()
production = self._parser.expand(self._productions[index])
if production:
self._lastoper1['text'] = 'Expand:'
self._lastoper2['text'] = production
self._prodlist.selection_clear(0, 'end')
self._prodlist.selection_set(index)
self._animate_expand(old_frontier[0])
else:
# Reset the production selections.
self._prodlist.selection_clear(0, 'end')
for prod in self._parser.expandable_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
#########################################
## Animation
#########################################
def _animate_expand(self, treeloc):
oldwidget = self._get(self._tree, treeloc)
oldtree = oldwidget.parent()
top = not isinstance(oldtree.parent(), TreeSegmentWidget)
tree = self._parser.tree()
for i in treeloc:
tree = tree[i]
widget = tree_to_treesegment(self._canvas, tree,
node_font=self._boldfont,
leaf_color='white',
tree_width=2, tree_color='white',
node_color='white',
leaf_font=self._font)
widget.node()['color'] = '#20a050'
(oldx, oldy) = oldtree.node().bbox()[:2]
(newx, newy) = widget.node().bbox()[:2]
widget.move(oldx-newx, oldy-newy)
if top:
self._cframe.add_widget(widget, 0, 5)
widget.move(30-widget.node().bbox()[0], 0)
self._tree = widget
else:
oldtree.parent().replace_child(oldtree, widget)
# Move the children over so they don't overlap.
# Line the children up in a strange way.
if widget.subtrees():
dx = (oldx + widget.node().width()/2 -
widget.subtrees()[0].bbox()[0]/2 -
widget.subtrees()[0].bbox()[2]/2)
for subtree in widget.subtrees(): subtree.move(dx, 0)
self._makeroom(widget)
if top:
self._cframe.destroy_widget(oldtree)
else:
oldtree.destroy()
colors = ['gray%d' % (10*int(10*x/self._animation_frames.get()))
for x in range(self._animation_frames.get(),0,-1)]
# Move the text string down, if necessary.
dy = widget.bbox()[3] + 30 - self._canvas.coords(self._textline)[1]
if dy > 0:
for twidget in self._textwidgets: twidget.move(0, dy)
self._canvas.move(self._textline, 0, dy)
self._animate_expand_frame(widget, colors)
def _makeroom(self, treeseg):
"""
Make sure that no sibling tree bbox's overlap.
"""
parent = treeseg.parent()
if not isinstance(parent, TreeSegmentWidget): return
index = parent.subtrees().index(treeseg)
# Handle siblings to the right
rsiblings = parent.subtrees()[index+1:]
if rsiblings:
dx = treeseg.bbox()[2] - rsiblings[0].bbox()[0] + 10
for sibling in rsiblings: sibling.move(dx, 0)
# Handle siblings to the left
if index > 0:
lsibling = parent.subtrees()[index-1]
dx = max(0, lsibling.bbox()[2] - treeseg.bbox()[0] + 10)
treeseg.move(dx, 0)
# Keep working up the tree.
self._makeroom(parent)
def _animate_expand_frame(self, widget, colors):
if len(colors) > 0:
self._animating_lock = 1
widget['color'] = colors[0]
for subtree in widget.subtrees():
if isinstance(subtree, TreeSegmentWidget):
subtree.node()['color'] = colors[0]
else:
subtree['color'] = colors[0]
self._top.after(50, self._animate_expand_frame,
widget, colors[1:])
else:
widget['color'] = 'black'
for subtree in widget.subtrees():
if isinstance(subtree, TreeSegmentWidget):
subtree.node()['color'] = 'black'
else:
subtree['color'] = 'black'
self._redraw_quick()
widget.node()['color'] = 'black'
self._animating_lock = 0
if self._autostep: self._step()
def _animate_backtrack(self, treeloc):
# Flash red first, if we're animating.
if self._animation_frames.get() == 0: colors = []
else: colors = ['#a00000', '#000000', '#a00000']
colors += ['gray%d' % (10*int(10*x/(self._animation_frames.get())))
for x in range(1, self._animation_frames.get()+1)]
widgets = [self._get(self._tree, treeloc).parent()]
for subtree in widgets[0].subtrees():
if isinstance(subtree, TreeSegmentWidget):
widgets.append(subtree.node())
else:
widgets.append(subtree)
self._animate_backtrack_frame(widgets, colors)
def _animate_backtrack_frame(self, widgets, colors):
if len(colors) > 0:
self._animating_lock = 1
for widget in widgets: widget['color'] = colors[0]
self._top.after(50, self._animate_backtrack_frame,
widgets, colors[1:])
else:
for widget in widgets[0].subtrees():
widgets[0].remove_child(widget)
widget.destroy()
self._redraw_quick()
self._animating_lock = 0
if self._autostep: self._step()
def _animate_match_backtrack(self, treeloc):
widget = self._get(self._tree, treeloc)
node = widget.parent().node()
dy = (1.0 * (node.bbox()[3] - widget.bbox()[1] + 14) /
max(1, self._animation_frames.get()))
self._animate_match_backtrack_frame(self._animation_frames.get(),
widget, dy)
def _animate_match(self, treeloc):
widget = self._get(self._tree, treeloc)
dy = ((self._textwidgets[0].bbox()[1] - widget.bbox()[3] - 10.0) /
max(1, self._animation_frames.get()))
self._animate_match_frame(self._animation_frames.get(), widget, dy)
def _animate_match_frame(self, frame, widget, dy):
if frame > 0:
self._animating_lock = 1
widget.move(0, dy)
self._top.after(10, self._animate_match_frame,
frame-1, widget, dy)
else:
widget['color'] = '#006040'
self._redraw_quick()
self._animating_lock = 0
if self._autostep: self._step()
def _animate_match_backtrack_frame(self, frame, widget, dy):
if frame > 0:
self._animating_lock = 1
widget.move(0, dy)
self._top.after(10, self._animate_match_backtrack_frame,
frame-1, widget, dy)
else:
widget.parent().remove_child(widget)
widget.destroy()
self._animating_lock = 0
if self._autostep: self._step()
def edit_grammar(self, *e):
CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
def set_grammar(self, grammar):
self._parser.set_grammar(grammar)
self._productions = list(grammar.productions())
self._prodlist.delete(0, 'end')
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
def edit_sentence(self, *e):
sentence = " ".join(self._sent)
title = 'Edit Text'
instr = 'Enter a new sentence to parse.'
EntryDialog(self._top, sentence, instr, self.set_sentence, title)
def set_sentence(self, sentence):
self._sent = sentence.split() #[XX] use tagged?
self.reset()
class VisualizerUI:
def __init__(self, width, height, pixelSize, top=False):
self._maxWindowWidth = 1500
self._master = Tk()
self._q = Queue.Queue()
self._hasFrame = False
self.x = width
self.y = height
self._count = self.x * self.y
self._values = []
self._leds = []
self._pixelSize = pixelSize
self._pixelPad = int(pixelSize / 2)
self._pixelSpace = 0
self.initUI()
self.configure(self.x, self.y)
self.checkQ()
self._master.attributes("-topmost", top)
def checkQ(self):
if not self._q.empty():
data = self._q.get_nowait()
self.updateUI(data)
wait = 0
if "darwin" in platform.system().lower():
wait = 1
self._master.after(wait, self.checkQ)
self._master.update_idletasks()
def mainloop(self):
self._master.mainloop()
def updateUI(self, data):
size = len(data) / 3
if size != self._count:
log.warning("Bytecount mismatch")
return
for i in range(size):
r = data[i * 3 + 0]
g = data[i * 3 + 1]
b = data[i * 3 + 2]
self._values[i] = self.toHexColor(r, g, b)
try:
for i in range(self._count):
self._canvas.itemconfig(self._leds[i], fill=self._values[i])
except TclError:
# Looks like the UI closed!
pass
def toHexColor(self, r, g, b):
return "#{0:02x}{1:02x}{2:02x}".format(r, g, b)
def update(self, data):
self._q.put(data)
def hasFrame(self):
return not self._q.empty()
def configure(self, x, y):
self._type = type
self.x = x
self.y = y
self._count = x * y
self._values = []
# init colors to all black (off)
for i in range(self._count):
self._values.append("#101010")
c = self._canvas
c.delete(ALL)
self._leds = []
for i in range(self._count):
index = c.create_rectangle(0,
0,
self._pixelSize,
self._pixelSize,
fill=self._values[i])
self._leds.append(index)
self.layoutPixels()
def layoutPixels(self):
if len(self._leds) == 0:
return
x_off = 0
row = 0
count = 0
w = 0
h = 0
for y in range(self.y):
for x in range(self.x):
if y % 2 != 0:
x = self.x - x - 1
_x = self._pixelPad + \
((x - x_off) * (self._pixelSize + self._pixelSpace))
_y = self._pixelPad + \
((y + row) * (self._pixelSize + self._pixelSpace))
if row > 0:
_y += 3 * row
_w = _x + self._pixelSize + self._pixelSpace + self._pixelPad
if _w > w:
w = _w
_h = _y + self._pixelSize + self._pixelSpace + self._pixelPad
if _h > h:
h = _h
if self.y == 1 and _x + ((self._pixelSize + self._pixelSpace) *
2) > self._maxWindowWidth:
row += 1
x_off += (x - x_off + 1)
self._canvas.coords(self._leds[count], _x, _y,
_x + self._pixelSize, _y + self._pixelSize)
count += 1
self._master.geometry("{0}x{1}".format(w, h))
self._master.update()
self._canvas.config(width=w, height=h)
def __CancelCommand(self, event=None):
self._master.quit()
self._master.destroy()
sys.exit()
# def __resizeEvent(self, event):
# width = self._master.winfo_width()
# height = self._master.winfo_height()
# if width != self._width or height != self._height:
# self._width = width
# self._height = height
# self._master.after_idle(self.layoutPixels)
# def __handleResize(self):
# width = self._master.winfo_width()
# height = self._master.winfo_height()
# if width != self._width or height != self._height:
# self._width = width
# self._height = height
# self.layoutPixels()
# self._master.after_idle(self.__handleResize)
def initUI(self):
m = self._master
m.protocol('WM_DELETE_WINDOW', self.__CancelCommand)
m.title("BiblioPixel Visualizer")
m.geometry("10x10")
m.update()
self._width = m.winfo_width()
self._height = m.winfo_height()
m.minsize(self._width, self._height)
self._canvas = Canvas(self._master, background="#000000")
c = self._canvas
c.pack(side=TOP)
self.layoutPixels()
class Application(object):
def __init__(self):
self.logger = get_logger('dashboard')
self.server = SocketServer.UDPServer(
(settings.DASHBOARD_HOST, settings.DASHBOARD_PORT),
self.handle_request)
self.server.timeout = settings.DASHBOARD_REQUEST_TIMEOUT
self.raw_telem_time = 0
self.raw_telem_bat = 0
self.raw_telem_temp = 0
self.raw_telem_photo = 0
self.__init_main()
self.__init_motor()
self.__init_light()
self.__init_video()
self.__init_telem()
def __init_main(self):
self.window = Tk()
self.window.wm_minsize(400, 400)
def __init_motor(self):
self.w_lf_motor = LabelFrame(self.window, text=u'Моторы')
self.w_scale_motor1 = Scale(self.w_lf_motor, from_=-255, to=255)
self.w_scale_motor2 = Scale(self.w_lf_motor, from_=-255, to=255)
self.w_lf_motor.place(relx=0, rely=0, relwidth=1, relheight=0.3)
self.w_scale_motor1.place(relx=0, rely=0, relwidth=1, relheight=1)
self.w_scale_motor2.place(relx=0.5, rely=0, relwidth=1, relheight=1)
def __init_light(self):
self.w_lf_light = LabelFrame(self.window, text=u'Свет')
self.w_l_light = Label(self.w_lf_light,
text=u'Выключен',
fg='red',
font='Arial 20')
self.w_lf_light.place(relx=0, rely=0.3, relwidth=1, relheight=0.15)
self.w_l_light.place(relx=0, rely=0, relwidth=1, relheight=1)
def __init_video(self):
self.w_lf_video = LabelFrame(self.window, text=u'Видео')
self.w_l_video = Label(self.w_lf_video,
text=u'Выключен',
fg='red',
font='Arial 20')
self.w_b_show = Button(self.w_lf_video,
text=u'mplayer',
command=self.start_mplayer)
self.w_lf_video.place(relx=0, rely=0.45, relwidth=1, relheight=0.15)
self.w_l_video.place(relx=0, rely=0, relwidth=0.7, relheight=1)
self.w_b_show.place(relx=0.7, rely=0, relwidth=0.3, relheight=1)
def __init_telem(self):
# телеметрия
self.w_lf_telem = LabelFrame(self.window, text=u'Телеметрия')
self.w_l_telem_time = Label(self.w_lf_telem,
text=u'0',
font='Arial 15')
self.w_l_telem_bat = Label(self.w_lf_telem, text=u'0', font='Arial 15')
self.w_l_telem_temp = Label(self.w_lf_telem,
text=u'0',
font='Arial 15')
self.w_l_telem_photo = Label(self.w_lf_telem,
text=u'0',
font='Arial 15')
self.w_lf_telem.place(relx=0, rely=0.6, relwidth=1, relheight=0.4)
Label(self.w_lf_telem, text=u'Время:',
font='Arial 15').place(relx=0,
rely=0,
relwidth=0.5,
relheight=0.25)
Label(self.w_lf_telem, text=u'Батарея:',
font='Arial 15').place(relx=0,
rely=0.25,
relwidth=0.5,
relheight=0.25)
Label(self.w_lf_telem, text=u'Температура:',
font='Arial 15').place(relx=0,
rely=0.5,
relwidth=0.5,
relheight=0.25)
Label(self.w_lf_telem, text=u'Освещенность:',
font='Arial 15').place(relx=0,
rely=0.75,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_time.place(relx=0.5,
rely=0,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_bat.place(relx=0.5,
rely=0.25,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_temp.place(relx=0.5,
rely=0.5,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_photo.place(relx=0.5,
rely=0.75,
relwidth=0.5,
relheight=0.25)
def set_motor_value(self, left_value, right_value):
if left_value > 255:
left_value = 255
elif left_value < -255:
left_value = -255
self.w_scale_motor1.set(left_value)
if right_value > 255:
right_value = 255
elif right_value < -255:
right_value = -255
self.w_scale_motor2.set(right_value)
def set_light(self, value):
"""
устанавливает значение для фонарика
:param value:
"""
if value == 1:
self.w_l_light['text'] = u'Включен'
self.w_l_light['fg'] = 'green'
else:
self.w_l_light['text'] = u'Выключен'
self.w_l_light['fg'] = 'red'
def set_video(self, value):
"""
устанавливает значение для фонарика
:param value:
"""
if value == 1:
self.w_l_video['text'] = u'Включен'
self.w_l_video['fg'] = 'green'
else:
self.w_l_video['text'] = u'Выключен'
self.w_l_video['fg'] = 'red'
def set_time(self, value):
"""
устанавливает значение для даты
:param value:
"""
if self.raw_telem_time == value:
return
self.raw_telem_time = value
try:
value = datetime.fromtimestamp(value).strftime('%Y.%m.%d %H:%M:%S')
except Exception as err:
print(err)
self.logger.debug(str(err))
self.w_l_telem_time['text'] = value
def set_bat(self, value):
"""
устанавливает значение для батареи
:param value:
"""
if self.raw_telem_bat == value:
return
self.raw_telem_bat = value
self.w_l_telem_bat['text'] = value
def set_temp(self, value):
"""
устанавливает значение для температуры
:param value:
"""
if self.raw_telem_temp == value:
return
self.raw_telem_temp = value
self.w_l_telem_temp['text'] = '{0} ({1})'.format(
round((value * 3.3 / 1024 - 0.5) / 0.01, 3), value)
def set_photo(self, value):
"""
устанавливает значение для температуры
:param value:
"""
if self.raw_telem_photo == value:
return
self.raw_telem_photo = value
self.w_l_telem_photo['text'] = value
def start_mplayer(self):
"""
включает mplayer
"""
process = subprocess.Popen(settings.VIDEO_SHOW_CMD, shell=True)
def handle_request(self, request, client_address, server):
"""
обработка входных данных
:param request:
:param client_address:
:param server:
:return:
"""
_request, _socket = request
if ',' not in _request:
return
values = [int(i) for i in _request.split(',')]
self.set_motor_value(*values[:2])
self.set_light(values[2])
self.set_video(values[3])
self.set_time(values[4])
self.set_temp(values[5])
self.set_bat(values[6])
self.set_photo(values[7])
def wait_request(self):
""""""
self.server.handle_request()
self.register_mainloop()
def register_mainloop(self):
"""
регистриуем обработчик, который периодический будет обрабатывать события
"""
self.window.after(after_timeout, self.wait_request)
def run(self):
""""""
try:
self.register_mainloop()
self.window.mainloop()
except KeyboardInterrupt:
pass
except Exception as err:
self.logger.debug(err)
import traceback
self.logger.debug(traceback.format_exc())
raise
def failure(reason, cur_dir):
"""
Displays a "submission failure" picture and emails
a bug report to maintenance.
"""
bugmail = {"email": "*****@*****.**"}
send_email(bugmail, "QR Code Submission Failure", reason, None)
root = Tk()
root.focus_set()
# Get the size of the screen and place the splash screen in the center
gif = Image.open(str(cur_dir) + '/Images/Failure.gif')
width = gif.size[0]
height = gif.size[1]
flog = (root.winfo_screenwidth()/2-width/2)
blog = (root.winfo_screenheight()/2-height/2)
root.overrideredirect(1)
root.geometry('%dx%d+%d+%d' % (width*1, height + 44, flog, blog))
# Pack a canvas into the top level window.
# This will be used to place the image
failure_canvas = Canvas(root)
failure_canvas.pack(fill = "both", expand = True)
# Open the image
imgtk = PhotoImage(gif)
# Get the top level window size
# Need a call to update first, or else size is wrong
root.update()
cwidth = root.winfo_width()
cheight = root.winfo_height()
# create the image on the canvas
failure_canvas.create_image(cwidth/2, cheight/2.24, image=imgtk)
Button(root, text = str(
reason), width = 50, height = 2, command = root.destroy).pack()
root.after(5000, root.destroy)
root.mainloop()
class PiPresents(object):
def pipresents_version(self):
vitems=self.pipresents_issue.split('.')
if len(vitems)==2:
# cope with 2 digit version numbers before 1.3.2
return 1000*int(vitems[0])+100*int(vitems[1])
else:
return 1000*int(vitems[0])+100*int(vitems[1])+int(vitems[2])
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3.5"
self.pipresents_minorissue = '1.3.5d'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'GapShow','Show','ArtShow',
'AudioPlayer','BrowserPlayer','ImagePlayer','MenuPlayer','MessagePlayer','VideoPlayer','Player',
'MediaList','LiveList','ShowList',
'PathManager','ControlsManager','ShowManager','PluginManager','IOPluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'TimeOfDay','ScreenDriver','Animate','OSCDriver','CounterManager',
'Network','Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched (self,None, "Pi Presents is starting, Version:"+self.pipresents_minorissue + ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue+ ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self,'\nRaspbian: '+ifile.read())
self.mon.log(self,'\n'+check_output(["omxplayer", "-v"]))
self.mon.log(self,'\nGPU Memory: '+check_output(["vcgencmd", "get_mem", "gpu"]))
if os.geteuid() == 0:
print 'Do not run Pi Presents with sudo'
self.mon.log(self,'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print 'Pi Presents must be run from the Desktop'
self.mon.log(self,'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self,'Desktop is '+ os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.ioplugin_manager=None
self.oscdriver=None
self.osc_enabled=False
self.tod_enabled=False
self.email_enabled=False
user=os.getenv('USER')
if user is None:
tkMessageBox.showwarning("You must be logged in to run Pi Presents")
exit(102)
if user !='pi':
self.mon.warn(self,"You must be logged as pi to use GPIO")
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected=False
self.network_details=False
self.interface=''
self.ip=''
self.unit=''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled=False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject= '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime("%Y-%m-%d %H:%M")
message = time.strftime("%Y-%m-%d %H:%M") + '\nUnit: ' + self.unit + ' Profile: '+ self.options['profile']+ '\n ' + self.interface + '\n ' + self.ip
self.send_email('start',subject,message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.mon.err(self,"Profile not specified in command ")
self.end('error','Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep+ 'home' + os.sep + user + os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found is True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self,"Failed to find pp_home directory at " + home)
self.end('error',"Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self,None,"Running profile: " + self.pp_profile_path)
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error',"Failed to find requested profile: "+ self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
self.mon.err(self,"Validation option not supported - use the editor")
self.end('error','Validation option not supported - use the editor')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error',"showlist not found at "+self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(self,"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
self.end('error',"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error',"Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.starter_show['background-colour'])
self.mon.log(self, 'monitor screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'forced screen dimensions (--screensize) are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvas cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.starter_show['background-colour'])
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find, or error in screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.reboot_required=False
self.terminate_required=False
self.exitpipresents_required=False
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager=IOPluginManager()
reason,message=self.ioplugin_manager.init(self.pp_dir,self.pp_profile,self.root,self.handle_input_event)
if reason == 'error':
# self.mon.err(self,message)
self.end('error',message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,
self.unit,self.interface,self.ip,
self.handle_command,self.handle_input_event,self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod=TimeOfDay()
reason,message,self.tod_enabled = self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.showlist,self.root,self.handle_command)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(self,'Network not connected so Time of Day scheduler may be using the internal clock')
# init the counter manager
self.counter_manager=CounterManager()
self.counter_manager.init()
# warn about start shows and scheduler
if self.starter_show['start-show']=='' and self.tod_enabled is False:
self.mon.sched(self,None,"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(self,"No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] !='' and self.tod_enabled is True:
self.mon.sched(self,None,"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(self,"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop( )
def parse_screen(self,size_text):
fields=size_text.split('*')
if len(fields)!=2:
return 'error','do not understand --screensize comand option',0,0
elif fields[0].isdigit() is False or fields[1].isdigit() is False:
return 'error','dimensions are not positive integers in --screensize',0,0
else:
return 'normal','',int(fields[0]),int(fields[1])
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self,'run start shows')
# parse the start shows field and start the initial shows
show_refs=self.starter_show['start-show'].split()
for show_ref in show_refs:
reason,message=self.show_manager.control_a_show(show_ref,'open')
if reason == 'error':
self.mon.err(self,message)
# *********************
# User inputs
# ********************
def e_osc_handle_animate(self,line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_animate(arg))
def osc_handle_animate(self,line):
self.mon.log(self,"animate command received: "+ line)
#osc sends output events as a string
reason,message,delay,name,param_type,param_values=self.animate.parse_animate_fields(line)
if reason == 'error':
self.mon.err(self,message)
self.end(reason,message)
self.handle_output_event(name,param_type,param_values,0)
# output events are animate commands
def handle_output_event(self,symbol,param_type,param_values,req_time):
reason,message=self.ioplugin_manager.handle_output_event(symbol,param_type,param_values,req_time)
if reason =='error':
self.mon.err(self,message)
self.end(reason,message)
# all input events call this callback providing a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self,symbol,source):
self.mon.log(self,"event received: "+symbol + ' from '+ source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.mon.err(self,'pp-shutdown removed in version 1.3.3a, see Release Notes')
self.end('error','pp-shutdown removed in version 1.3.3a, see Release Notes')
elif symbol == 'pp-shutdownnow':
# need root.after to grt out of st thread
self.root.after(1,self.shutdownnow_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
reason,message= self.show_manager.exit_all_shows()
else:
# pass the input event to all registered shows
for show in self.show_manager.shows:
show_obj=show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
# commands are generaed by tracks and shows
# they can open or close shows, generate input events and do special tasks
# commands also generate osc outputs to other computers
# handles one command provided as a line of text
def handle_command(self,command_text,source='',show=''):
# print 'PIPRESENTS ',command_text,'\n Source',source,'from',show
self.mon.log(self,"command received: " + command_text)
if command_text.strip()=="":
return
fields= command_text.split()
if fields[0] in ('osc','OSC'):
if self.osc_enabled is True:
status,message=self.oscdriver.parse_osc_command(fields[1:])
if status=='warn':
self.mon.warn(self,message)
if status=='error':
self.mon.err(self,message)
self.end('error',message)
return
if fields[0] =='counter':
status,message=self.counter_manager.parse_counter_command(fields[1:])
if status=='error':
self.mon.err(self,message)
self.end('error',message)
return
show_command=fields[0]
if len(fields)>1:
show_ref=fields[1]
else:
show_ref=''
if show_command in ('open','close','closeall','openexclusive'):
self.mon.sched(self, TimeOfDay.now,command_text + ' received from show:'+show)
if self.shutdown_required is False and self.terminate_required is False:
reason,message=self.show_manager.control_a_show(show_ref,show_command)
else:
return
elif show_command =='monitor':
self.handle_monitor_command(show_ref)
return
elif show_command =='cec':
self.handle_cec_command(show_ref)
return
elif show_command == 'event':
self.handle_input_event(show_ref,'Show Control')
return
elif show_command == 'exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
else:
reason,message= self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1,self.shutdownnow_pressed)
return
elif show_command == 'reboot':
# need root.after to get out of st thread
self.root.after(1,self.reboot_pressed)
return
else:
reason='error'
message = 'command not recognised: '+ show_command
if reason=='error':
self.mon.err(self,message)
return
def handle_monitor_command(self,command):
if command == 'on':
os.system('vcgencmd display_power 1 >/dev/null')
elif command == 'off':
os.system('vcgencmd display_power 0 >/dev/null')
def handle_cec_command(self,command):
if command == 'on':
os.system('echo "on 0" | cec-client -s')
elif command == 'standby':
os.system('echo "standby 0" | cec-client -s')
elif command == 'scan':
os.system('echo scan | cec-client -s -d 1')
# deal with differnt commands/input events
def shutdownnow_pressed(self):
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def reboot_pressed(self):
self.reboot_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self,signum,fframe):
self.mon.log(self,'SIGTERM received - '+ str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self,'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
self.terminate_required=True
needs_termination=False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination=True
self.mon.log(self,"Sent terminate to show "+ show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed','killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal','no shows running')
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self,reason,message):
self.canvas.config(bg=self.starter_show['background-colour'])
if reason in ('killed','error') or self.shutdown_required is True or self.exitpipresents_required is True or self.reboot_required is True:
self.end(reason,message)
def end(self,reason,message):
self.mon.log(self,"Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
if reason == 'killed':
if self.email_enabled is True and self.mailer.email_on_terminate is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Terminated'
message = time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message)
self.mon.sched(self, None,"Pi Presents Terminated, au revoir\n")
self.mon.log(self, "Pi Presents Terminated, au revoir")
# close logging files
self.mon.finish()
print 'Uncollectable Garbage',gc.collect()
# objgraph.show_backrefs(objgraph.by_type('Monitor'))
sys.exit(101)
elif reason == 'error':
if self.email_enabled is True and self.mailer.email_on_error is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Error'
message_text = 'Error message: '+ message + '\n'+ time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message_text)
self.mon.sched(self,None, "Pi Presents closing because of error, sorry\n")
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
print 'uncollectable garbage',gc.collect()
sys.exit(102)
else:
self.mon.sched(self,None,"Pi Presents exiting normally, bye\n")
self.mon.log(self,"Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.reboot_required is True:
# print 'REBOOT'
call (['sudo','reboot'])
if self.shutdown_required is True:
# print 'SHUTDOWN'
call (['sudo','shutdown','now','SHUTTING DOWN'])
print 'uncollectable garbage',gc.collect()
sys.exit(100)
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.handle_monitor_command('on')
self.mon.log(self, "Tidying Up")
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset","s", "on"])
call(["xset","s", "+dpms"])
# tidy up animation
if self.animate is not None:
self.animate.terminate()
# tidy up i/o plugins
if self.ioplugin_manager != None:
self.ioplugin_manager.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
# *******************************
# Connecting to network and email
# *******************************
def init_network(self):
timeout=int(self.options['nonetwork'])
if timeout== 0:
self.network_connected=False
self.unit=''
self.ip=''
self.interface=''
return
self.network=Network()
self.network_connected=False
# try to connect to network
self.mon.log (self, 'Waiting up to '+ str(timeout) + ' seconds for network')
success=self.network.wait_for_network(timeout)
if success is False:
self.mon.warn(self,'Failed to connect to network after ' + str(timeout) + ' seconds')
# tkMessageBox.showwarning("Pi Presents","Failed to connect to network so using fake-hwclock")
return
self.network_connected=True
self.mon.sched (self, None,'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, 'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
# Get web configuration
self.network_details=False
network_options_file_path=self.pp_dir+os.sep+'pp_config'+os.sep+'pp_web.cfg'
if not os.path.exists(network_options_file_path):
self.mon.warn(self,"pp_web.cfg not found at "+network_options_file_path)
return
self.mon.log(self, 'Found pp_web.cfg in ' + network_options_file_path)
self.network.read_config(network_options_file_path)
self.unit=self.network.unit
# get interface and IP details of preferred interface
self.interface,self.ip = self.network.get_preferred_ip()
if self.interface == '':
self.network_connected=False
return
self.network_details=True
self.mon.log (self, 'Network details ' + self.unit + ' ' + self.interface + ' ' +self.ip)
def init_mailer(self):
self.email_enabled=False
email_file_path = self.pp_dir+os.sep+'pp_config'+os.sep+'pp_email.cfg'
if not os.path.exists(email_file_path):
self.mon.log(self,'pp_email.cfg not found at ' + email_file_path)
return
self.mon.log(self,'Found pp_email.cfg at ' + email_file_path)
self.mailer=Mailer()
self.mailer.read_config(email_file_path)
# all Ok so can enable email if config file allows it.
if self.mailer.email_allowed is True:
self.email_enabled=True
self.mon.log (self,'Email Enabled')
def try_connect(self):
tries=1
while True:
success, error = self.mailer.connect()
if success is True:
return True
else:
self.mon.log(self,'Failed to connect to email SMTP server ' + str(tries) + '\n ' +str(error))
tries +=1
if tries >5:
self.mon.log(self,'Failed to connect to email SMTP server after ' + str(tries))
return False
def send_email(self,reason,subject,message):
if self.try_connect() is False:
return False
else:
success,error = self.mailer.send(subject,message)
if success is False:
self.mon.log(self, 'Failed to send email: ' + str(error))
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect after send:' + str(error))
return False
else:
self.mon.log(self,'Sent email for ' + reason)
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect from email server ' + str(error))
return True
