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()
def demo():
root = Tk()
root.bind('<Control-q>', lambda e: root.destroy())
table = Table(root, 'Word Synset Hypernym Hyponym'.split(),
column_weights=[0, 1, 1, 1],
reprfunc=(lambda i,j,s: ' %s' % s))
table.pack(expand=True, fill='both')
from nltk.corpus import wordnet
from nltk.corpus import brown
for word, pos in sorted(set(brown.tagged_words()[:500])):
if pos[0] != 'N': continue
word = word.lower()
for synset in wordnet.synsets(word):
hyper = (synset.hypernyms()+[''])[0]
hypo = (synset.hyponyms()+[''])[0]
table.append([word,
getattr(synset, 'definition', '*none*'),
getattr(hyper, 'definition', '*none*'),
getattr(hypo, 'definition', '*none*')])
table.columnconfig('Word', background='#afa')
table.columnconfig('Synset', background='#efe')
table.columnconfig('Hypernym', background='#fee')
table.columnconfig('Hyponym', background='#ffe')
for row in range(len(table)):
for column in ('Hypernym', 'Hyponym'):
if table[row, column] == '*none*':
table.itemconfig(row, column, foreground='#666',
selectforeground='#666')
root.mainloop()
def main():
fileWords = open('wordList.txt')
fileWords = fileWords.read()
fileWords = fileWords.split()
def clear():
os.system('cls' if platform.system() == "Windows" else "clear")
def whenClicked(*args):
prefix = pattern.get()
labelText.set("")
for word in fileWords:
if word.startswith(prefix):
labelText.set(str(labelText.get())+'\n'+word)
root = Tk()
root.title('AutoComplete')
ttk.Label(root, text='Enter search pattern').pack()
pattern = StringVar()
ttk.Entry(root, textvariable=pattern).pack()
ttk.Button(root, text='Submit', command=whenClicked).pack()
labelText = StringVar()
ttk.Label(root, textvariable=labelText).pack()
root.bind('<Return>', whenClicked)
root.mainloop()
class TokenInputGUI(object):
def show_entry_fields(self, event=None):
self.code = self.e1.get()
self.master.withdraw()
self.master.quit()
def quit(self):
self.master.quit()
self.code = None
def doGUI(self, hostname=None):
self.master = Tk()
self.master.title('Blessclient - MFA')
textmsg = 'Enter your AWS MFA code: '
if hostname:
textmsg = 'Enter your AWS MFA code to connect to {}: '.format(
hostname)
Label(self.master, text=textmsg).grid(row=0)
self.e1 = Entry(self.master)
self.e1.grid(row=0, column=1, padx=4)
Button(self.master,
text='OK',
command=self.show_entry_fields,
default=ACTIVE).grid(row=3, column=0, sticky=W, pady=4)
Button(self.master, text='Cancel', command=self.quit).grid(row=3,
column=1,
sticky=W,
pady=4)
self.center()
self.master.bind('<Return>', self.show_entry_fields)
self.master.lift()
self.master.attributes('-topmost', True)
self.master.focus_force()
self.e1.focus_set()
if platform.system() == 'Darwin':
try:
from Cocoa import (NSRunningApplication,
NSApplicationActivateIgnoringOtherApps)
app = NSRunningApplication.runningApplicationWithProcessIdentifier_(
os.getpid())
app.activateWithOptions_(
NSApplicationActivateIgnoringOtherApps)
except ImportError:
pass
mainloop()
# http://stackoverflow.com/questions/3352918/how-to-center-a-window-on-the-screen-in-tkinter
def center(self):
self.master.update_idletasks()
w = self.master.winfo_screenwidth()
h = self.master.winfo_screenheight()
size = tuple(
int(_) for _ in self.master.geometry().split('+')[0].split('x'))
x = w / 2 - size[0] / 2
y = h / 2 - size[1] / 2
self.master.geometry("%dx%d+%d+%d" % (size + (x, y)))
def talker():
motion = Twist()
rospy.init_node('talker', anonymous=True)
rate = rospy.Rate(10) # 10hz
root = Tk()
root.geometry("750x300+500+-1000")
root.bind('<Key>', onKeyPress)
app = DronControll(root,pubControllDron,pubControllTakeoff,pubControllLanding,pubControllCamera)
root.mainloop()
def main():
global root
# Populate the content
populate_content()
# Launch the GUI
root = Tk()
# Center the window
center(root, (800, 800))
app = MainFrame(root)
root.bind('<Control-c>', root.quit)
root.mainloop()
def main():
global root
# Populate the content
populate_content()
# Launch the GUI
root = Tk()
# Center the window
center(root, (800, 800))
app = MainFrame(root)
root.bind('<Control-c>', root.quit)
root.mainloop()
def _init_ui(self):
root = Tk()
root.title("parakeet")
root.bind("<FocusOut>", self.close)
root.bind("<Escape>", self.close)
text = Text(root)
text.config(width=60, height=1)
text.pack(side=LEFT, fill=Y)
text.bind("<Return>", self.handle_query)
text.focus_force()
return root, text
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()
def quickentry(labels, callback, title='', defaults=None):
"Simple dialog from grabbing parameters from the user."
if defaults is None:
defaults = {}
root = Tk()
root.title(title)
root['padx'] = 20
root['pady'] = 10
widgets = {}
for label in labels:
# Create a text frame to hold the text Label and the Entry widget
f = Frame(root)
#Create a Label in textFrame
l = Label(f)
l['text'] = label
l['width'] = 10
l.pack(side=LEFT)
w = Entry(f)
w['width'] = 20
w.pack(side=LEFT)
w.insert(0, defaults.get(label, ''))
widgets[label] = w
f.pack()
def cb():
callback({label: widgets[label].get().strip() for label in labels})
Button(root, text="Quit",
command=lambda root=root: root.destroy()).pack(side=RIGHT)
Button(root, text='Submit', command=cb).pack(side=RIGHT)
root.protocol("WM_DELETE_WINDOW", lambda root=root: root.destroy())
print '[quickentry] running'
root.bind("<Return>", lambda e: cb())
root.bind("<Escape>", lambda e: root.destroy())
root.mainloop()
print '[quickentry] done'
return root
def quickentry(labels, callback, title='', defaults=None):
"Simple dialog from grabbing parameters from the user."
if defaults is None:
defaults = {}
root = Tk()
root.title(title)
root['padx'] = 20
root['pady'] = 10
widgets = {}
for label in labels:
# Create a text frame to hold the text Label and the Entry widget
f = Frame(root)
#Create a Label in textFrame
l = Label(f)
l['text'] = label
l['width'] = 10
l.pack(side=LEFT)
w = Entry(f)
w['width'] = 20
w.pack(side=LEFT)
w.insert(0, defaults.get(label, ''))
widgets[label] = w
f.pack()
def cb():
callback({label: widgets[label].get().strip() for label in labels})
Button(root, text="Quit", command=lambda root=root: root.destroy()).pack(side=RIGHT)
Button(root, text='Submit', command=cb).pack(side=RIGHT)
root.protocol("WM_DELETE_WINDOW", lambda root=root: root.destroy())
print '[quickentry] running'
root.bind("<Return>", lambda e: cb())
root.bind("<Escape>", lambda e: root.destroy())
root.mainloop()
print '[quickentry] done'
return root
def run(): # Main function that triggers the rest of the game
root = Tk() # Initializes a new root
root.resizable(width = FALSE, height = FALSE) # The canvas is not resizable
root.title("Boggle - Aayush Tekriwal - (15-112 Term Project)") # Title
(width, height) = (1000,600) # Width and height of
canvas = Canvas(root, width = width, height = height)
canvas.pack()
root.canvas = canvas.canvas = canvas
class Struct: pass
canvas.data = Struct() # Struct stores all data for global access
canvas.data.width = width
canvas.data.height = height
initGame(root, canvas)
#root.bind("<Button-1>", printCoords) # Unhash to help modify graphics
root.bind("<space >", lambda event: getWord(canvas, event))
root.bind("<Return>", lambda event: getWord(canvas, event))
root.mainloop()
def demo3():
from nltk import Production
(S, VP, NP, PP, P, N, Name, V, Det) = \
nonterminals('S, VP, NP, PP, P, N, Name, V, Det')
productions = (
# Syntactic Productions
Production(S, [NP, VP]),
Production(NP, [Det, N]),
Production(NP, [NP, PP]),
Production(VP, [VP, PP]),
Production(VP, [V, NP, PP]),
Production(VP, [V, NP]),
Production(PP, [P, NP]),
Production(PP, []),
Production(PP, ['up', 'over', NP]),
# Lexical Productions
Production(NP, ['I']),
Production(Det, ['the']),
Production(Det, ['a']),
Production(N, ['man']),
Production(V, ['saw']),
Production(P, ['in']),
Production(P, ['with']),
Production(N, ['park']),
Production(N, ['dog']),
Production(N, ['statue']),
Production(Det, ['my']),
)
t = Tk()
def destroy(e, t=t):
t.destroy()
t.bind('q', destroy)
p = ProductionList(t, productions)
p.pack(expand=1, fill='both')
p.add_callback('select', p.markonly)
p.add_callback('move', p.markonly)
p.focus()
p.mark(productions[2])
p.mark(productions[8])
class TokenInputGUI(object):
def show_entry_fields(self, event=None):
self.code = self.e1.get()
self.master.withdraw()
self.master.quit()
def quit(self):
self.master.quit()
self.code = None
def doGUI(self, hostname=None):
self.master = Tk()
self.master.title('Blessclient - MFA')
textmsg = 'Enter your AWS MFA code: '
if hostname:
textmsg = 'Enter your AWS MFA code to connect to {}: '.format(hostname)
Label(self.master, text=textmsg).grid(row=0)
self.e1 = Entry(self.master)
self.e1.grid(row=0, column=1, padx=4)
Button(self.master, text='OK', command=self.show_entry_fields, default=ACTIVE).grid(row=3, column=0, sticky=W, pady=4)
Button(self.master, text='Cancel', command=self.quit).grid(row=3, column=1, sticky=W, pady=4)
self.center()
self.master.bind('<Return>', self.show_entry_fields)
self.master.lift()
self.master.attributes('-topmost', True)
self.master.focus_force()
self.e1.focus_set()
if platform.system() == 'Darwin':
# Hack to get the GUI dialog focused in OSX
os.system('/usr/bin/osascript -e \'tell app "Finder" to set frontmost of process "python" to true\'')
mainloop()
# http://stackoverflow.com/questions/3352918/how-to-center-a-window-on-the-screen-in-tkinter
def center(self):
self.master.update_idletasks()
w = self.master.winfo_screenwidth()
h = self.master.winfo_screenheight()
size = tuple(int(_) for _ in self.master.geometry().split('+')[0].split('x'))
x = w / 2 - size[0] / 2
y = h / 2 - size[1] / 2
self.master.geometry("%dx%d+%d+%d" % (size + (x, y)))
def guiLogin():
root = Tk()
root.title("Enter Lastpass login")
mainframe = ttk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)
username = StringVar()
password = StringVar()
ret = []
def done(*args):
ret.append((username.get(), password.get()))
root.destroy()
ttk.Label(mainframe, text="Username:"******"Password:"******"Login", command=done).grid(column=2,
row=3,
sticky=W)
for child in mainframe.winfo_children():
child.grid_configure(padx=5, pady=2)
username_entry.focus()
root.bind('<Return>', done)
root.bind('<Escape>', lambda event: root.destroy())
root.lift()
root.call('wm', 'attributes', '.', '-topmost', True)
root.after_idle(root.call, 'wm', 'attributes', '.', '-topmost', False)
root.mainloop()
return ret and ret[-1] or None
def demo3():
from nltk import Production
(S, VP, NP, PP, P, N, Name, V, Det) = nonterminals("S, VP, NP, PP, P, N, Name, V, Det")
productions = (
# Syntactic Productions
Production(S, [NP, VP]),
Production(NP, [Det, N]),
Production(NP, [NP, PP]),
Production(VP, [VP, PP]),
Production(VP, [V, NP, PP]),
Production(VP, [V, NP]),
Production(PP, [P, NP]),
Production(PP, []),
Production(PP, ["up", "over", NP]),
# Lexical Productions
Production(NP, ["I"]),
Production(Det, ["the"]),
Production(Det, ["a"]),
Production(N, ["man"]),
Production(V, ["saw"]),
Production(P, ["in"]),
Production(P, ["with"]),
Production(N, ["park"]),
Production(N, ["dog"]),
Production(N, ["statue"]),
Production(Det, ["my"]),
)
t = Tk()
def destroy(e, t=t):
t.destroy()
t.bind("q", destroy)
p = ProductionList(t, productions)
p.pack(expand=1, fill="both")
p.add_callback("select", p.markonly)
p.add_callback("move", p.markonly)
p.focus()
p.mark(productions[2])
p.mark(productions[8])
def prompt_gui(self, name, propagate_exception = False):
''' Returns None if failed to load tkinter or open display.
(unless propagate_exception == True).'''
''' I thought about caching and reusing the tkinter instance, but it might be hard
to properly temporarily exit from mainloop and suspend the application.
Anyway, it takes like 10ms to restart it.'''
try:
from Tkinter import Tk, Label, Frame, Entry, StringVar
root = Tk()
except:
if propagate_exception:
raise
return None
root.title('Enter value for \'%s\':' % name)
frame = Frame(root)
frame.pack(fill = 'y', expand = True)
label = Label(frame, text='Enter value for \'%s\':' % name)
label.pack(side='left')
var = StringVar()
entry = Entry(frame, textvariable = var)
entry.pack(side='left')
result = []
root.bind('<Return>', lambda ev: (result.append(var.get()), root.destroy()))
ws = root.winfo_screenwidth()
hs = root.winfo_screenheight()
root.geometry('+%d+%d' % (ws * 0.4, hs * 0.4))
entry.focus()
# If I don't do this then for some reason the window doesn't get focus
# on the second and following invocations.
root.focus_force()
root.mainloop()
if not len(result):
# mimic the behaviour of CLI version
raise KeyboardInterrupt()
return result[0]
def _init_ui(self):
root = Tk()
root.title("pylens")
root.bind("<FocusOut>", self.close)
root.bind("<Escape>", self.close)
# center the window
root.withdraw()
root.update_idletasks() # Update "requested size" from geometry manager
x = (root.winfo_screenwidth() - root.winfo_reqwidth()) / 2
y = (root.winfo_screenheight() - root.winfo_reqheight()) / 2
root.geometry("+%d+%d" % (x, y))
root.deiconify()
text = Text(root)
text.config(width=60, height=1)
text.pack(side=LEFT, fill=Y)
text.bind("<Return>", self.handle_query)
text.focus_force()
return root, text
def main():
from optparse import OptionParser
parser = OptionParser()
parser.add_option('-W', '--width', type='int', default=300)
parser.add_option('-H', '--height', type='int', default=300)
parser.add_option('-c', '--center', type='complex', default=0+0j)
parser.add_option('-s', '--side', type='float', default=4)
(options, args) = parser.parse_args()
root = Tk()
l = Label(root)
l.pack()
W, H = options.width, options.height
center, side = options.center, options.side
im = Image.new('P', (W, H), 0)
im.putpalette([randrange(256) for n in range(3 * 256)])
p = im.load()
z = z_converter(W, H, center, side)
l.pim = PhotoImage(im)
l.config(image=l.pim)
def paint_column(x):
if x % 10 == 0: print "Column %d" % x
for y in range(H):
p[x, y] = pixel(z(x, y))
l.pim = PhotoImage(im)
l.config(image=l.pim)
if x + 1 < W:
root.after(1, paint_column, x + 1)
def start(event):
root.after(1, paint_column, 0)
root.bind('<FocusIn>', start)
root.mainloop()
def captcha_handler(captcha):
root = Tk()
root.title('captcha')
def executor(event):
global text
text = entry.get()
root.destroy()
r = requests.get(captcha.get_url())
with open('captcha.jpg', 'wb') as image:
image.write(r.content)
img = Image.open('captcha.jpg')
photo = ImageTk.PhotoImage(img)
label = Label(root, image=photo)
entry = Entry()
root.bind('<Return>', executor)
root.focus_force()
label.pack()
entry.pack()
entry.focus_force()
root.mainloop()
return captcha.try_again(text)
def demo():
root = Tk()
root.bind('<Control-q>', lambda e: root.destroy())
table = Table(root,
'Word Synset Hypernym Hyponym'.split(),
column_weights=[0, 1, 1, 1],
reprfunc=(lambda i, j, s: ' %s' % s))
table.pack(expand=True, fill='both')
from nltk.corpus import wordnet
from nltk.corpus import brown
for word, pos in sorted(set(brown.tagged_words()[:500])):
if pos[0] != 'N': continue
word = word.lower()
for synset in wordnet.synsets(word):
hyper = (synset.hypernyms() + [''])[0]
hypo = (synset.hyponyms() + [''])[0]
table.append([
word,
getattr(synset, 'definition', '*none*'),
getattr(hyper, 'definition', '*none*'),
getattr(hypo, 'definition', '*none*')
])
table.columnconfig('Word', background='#afa')
table.columnconfig('Synset', background='#efe')
table.columnconfig('Hypernym', background='#fee')
table.columnconfig('Hyponym', background='#ffe')
for row in range(len(table)):
for column in ('Hypernym', 'Hyponym'):
if table[row, column] == '*none*':
table.itemconfig(row,
column,
foreground='#666',
selectforeground='#666')
root.mainloop()
def demo():
root = Tk()
root.bind("<Control-q>", lambda e: root.destroy())
table = Table(
root, "Word Synset Hypernym Hyponym".split(), column_weights=[0, 1, 1, 1], reprfunc=(lambda i, j, s: " %s" % s)
)
table.pack(expand=True, fill="both")
from nltk.corpus import wordnet
from nltk.corpus import brown
for word, pos in sorted(set(brown.tagged_words()[:500])):
if pos[0] != "N":
continue
word = word.lower()
for synset in wordnet.synsets(word):
hyper = (synset.hypernyms() + [""])[0]
hypo = (synset.hyponyms() + [""])[0]
table.append(
[
word,
getattr(synset, "definition", "*none*"),
getattr(hyper, "definition", "*none*"),
getattr(hypo, "definition", "*none*"),
]
)
table.columnconfig("Word", background="#afa")
table.columnconfig("Synset", background="#efe")
table.columnconfig("Hypernym", background="#fee")
table.columnconfig("Hyponym", background="#ffe")
for row in range(len(table)):
for column in ("Hypernym", "Hyponym"):
if table[row, column] == "*none*":
table.itemconfig(row, column, foreground="#666", selectforeground="#666")
root.mainloop()
def demo3():
from nltk import Production
(S, VP, NP, PP, P, N, Name, V, Det) = \
nonterminals('S, VP, NP, PP, P, N, Name, V, Det')
productions = (
# Syntactic Productions
Production(S, [NP, VP]),
Production(NP, [Det, N]),
Production(NP, [NP, PP]),
Production(VP, [VP, PP]),
Production(VP, [V, NP, PP]),
Production(VP, [V, NP]),
Production(PP, [P, NP]),
Production(PP, []),
Production(PP, ['up', 'over', NP]),
# Lexical Productions
Production(NP, ['I']), Production(Det, ['the']),
Production(Det, ['a']), Production(N, ['man']),
Production(V, ['saw']), Production(P, ['in']),
Production(P, ['with']), Production(N, ['park']),
Production(N, ['dog']), Production(N, ['statue']),
Production(Det, ['my']),
)
t = Tk()
def destroy(e, t=t): t.destroy()
t.bind('q', destroy)
p = ProductionList(t, productions)
p.pack(expand=1, fill='both')
p.add_callback('select', p.markonly)
p.add_callback('move', p.markonly)
p.focus()
p.mark(productions[2])
p.mark(productions[8])
def main():
"""Set up the stopwatch and the buttons/keyboard shortcuts to control it"""
root = Tk()
# Add stopwatch frame
stopwatch = StopWatch(root)
stopwatch.pack(side=TOP)
# Add buttons
Button(root, text='Start/Stop',
command=stopwatch.start_stop, takefocus=False).pack(side=LEFT)
Button(root, text='Reset',
command=stopwatch.reset, takefocus=False).pack(side=LEFT)
Button(root, text='Quit',
command=root.quit, takefocus=False).pack(side=LEFT)
# Add keyboard shurtcuts
root.bind("<space>", lambda x: stopwatch.start_stop())
root.bind("<BackSpace>", lambda x: stopwatch.reset())
root.bind("<Escape>", lambda x: root.quit())
root.focus_set()
root.mainloop()
## print
screenedge.draw(mycanvas)
mycanvas.postscript(file="circles.eps")
############################################
# MAIN PROGRAM STARTS HERE
############################################
if __name__ == "__main__":
root = Tk()
root.title('BVHPlay')
mymenu = Menubar(root)
mymenu.filemenu.entryconfig(0, command=open_file)
root.bind('<Control-Key-o>', open_file2)
mymenu.settingsmenu.entryconfig(0, command=toggle_grid)
mymenu.settingsmenu.entryconfig(1, command=toggle_axes)
mymenu.settingsmenu.entryconfig(2, command=toggle_readout)
mytransport = Transport() # Create and pack a frame of transport buttons
mytransport.btn_begin.config(command=onBegin)
mytransport.btn_end.config(command=onEnd)
mytransport.btn_stop.config(command=onStop)
mytransport.btn_play.config(command=onPlay)
mytransport.btn_stepback.config(command=onStepback)
mytransport.btn_stepfd.config(command=onStepfd)
myplaybar = Playbar()
slidert = IntVar() # Special magic integer that allows me to tie it
# to a Tk widget "variable" option, in this case
root = Tk()
root.title("Feet to Meters")
mainframe = Tk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)
feet = StringVar()
meters = StringVar()
feet_entry = Tk.Entry(mainframe, width=7, textvariable=feet)
feet_entry.grid(column=2, row=1, sticky=(W, E))
Tk.Label(mainframe, textvariable=meters).grid(column=2, row=2, sticky=(W, E))
Tk.Button(mainframe, text="Calculate", command=calculate).grid(column=3,
row=3,
sticky=W)
Tk.Label(mainframe, text="feet").grid(column=3, row=1, sticky=W)
Tk.Label(mainframe, text="is equivalent to").grid(column=1, row=2, sticky=E)
Tk.Label(mainframe, text="meters").grid(column=3, row=2, sticky=W)
for child in mainframe.winfo_children():
child.grid_configure(padx=5, pady=5)
feet_entry.focus()
root.bind('<Return>', calculate)
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__
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'
class tk_window(object):
_ret = None
_frame = None
_master = None
_child = None
_destroyed = False
_parent = None
def __init__(self, classname, classtitle):
self._master = Tk(className=classname)
self._master.protocol('WM_DELETE_WINDOW', self.destroy)
super(tk_window, self).__init__()
self._parent = None
self._child = None
self.set_class(classtitle)
self._master.bind('<FocusIn>', self.focus_in)
@property
def master(self):
return self._master
@master.setter
def master(self, value):
self._master = value
@property
def parent(self):
return self._parent
@parent.setter
def parent(self, value):
self._parent = value
@property
def child(self):
return self._child
@child.setter
def child(self, value):
self._child = value
@property
def leaf(self):
leaf = self.child
while leaf.child is not None:
leaf = leaf.child
return leaf
@property
def trunk(self):
trunk = self.parent
while trunk.parent is not None:
trunk = trunk.parent
return trunk
@property
def is_destroyed(self):
return self._destroyed
def destroy(self, event=None):
if not self.is_destroyed:
self.destroy_child()
try:
self.master.quit()
self.master.destroy()
except TclError:
pass
self._destroyed = True
if self.parent is not None:
self.parent.child = None
def set_class(self, classname):
self.master.wm_iconname(classname)
def set_title(self, title):
self.master.wm_title(title)
def set_size(self, width=None, height=None):
if width is not None and height is not None:
self.master.geometry('{}x{}'.format(width, height))
else:
(old_width, old_height) = [
int(x) for x in self.master.geometry().split('+')[0].split('x')
]
if width is not None:
self.master.geometry('{}x{}'.format(width, old_height))
elif height is not None:
self.master.geometry('{}x{}'.format(old_width, height))
#else: # do nothing, nothing specified
def focus_in(self, event_instance):
self.focus_child()
def focus_child(self):
if self.child is not None and not self.child.is_destroyed:
self.child.master.lift()
self.child.master.focus()
def spawn_child(self, child):
if self.child is not None:
self.destroy_child()
self.child = child
child.parent = self
return child.run()
def destroy_child(self):
if self.child is not None and not self.child.is_destroyed:
self.child.destroy()
self.child = None
def run(self):
try:
self.master.mainloop()
except KeyboardInterrupt:
pass
self.destroy()
return self._ret
class DrtGlueDemo(object):
def __init__(self, examples):
# Set up the main window.
self._top = Tk()
self._top.title('DRT Glue Demo')
# Set up key bindings.
self._init_bindings()
# Initialize the fonts.self._error = None
self._init_fonts(self._top)
self._examples = examples
self._readingCache = [None for example in examples]
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Set the data to None
self._curExample = -1
self._readings = []
self._drs = None
self._drsWidget = None
self._error = None
self._init_glue()
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_exampleListbox(self._top)
self._init_readingListbox(self._top)
self._init_canvas(self._top)
# Resize callback
self._canvas.bind('<Configure>', self._configure)
#########################################
## Initialization Helpers
#########################################
def _init_glue(self):
tagger = RegexpTagger([
('^(David|Mary|John)$', 'NNP'),
('^(walks|sees|eats|chases|believes|gives|sleeps|chases|persuades|tries|seems|leaves)$',
'VB'), ('^(go|order|vanish|find|approach)$', 'VB'),
('^(a)$', 'ex_quant'), ('^(every)$', 'univ_quant'),
('^(sandwich|man|dog|pizza|unicorn|cat|senator)$', 'NN'),
('^(big|gray|former)$', 'JJ'), ('^(him|himself)$', 'PRP')
])
depparser = MaltParser(tagger=tagger)
self._glue = DrtGlue(depparser=depparser, remove_duplicates=False)
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = 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 = Font(family='helvetica',
weight='bold',
size=self._size.get())
self._font = 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 = Font(family='helvetica', weight='bold', size=big)
def _init_exampleListbox(self, parent):
self._exampleFrame = listframe = Frame(parent)
self._exampleFrame.pack(fill='both', side='left', padx=2)
self._exampleList_label = Label(self._exampleFrame,
font=self._boldfont,
text='Examples')
self._exampleList_label.pack()
self._exampleList = Listbox(self._exampleFrame,
selectmode='single',
relief='groove',
background='white',
foreground='#909090',
font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._exampleList.pack(side='right', fill='both', expand=1)
for example in self._examples:
self._exampleList.insert('end', (' %s' % example))
self._exampleList.config(height=min(len(self._examples), 25), width=40)
# Add a scrollbar if there are more than 25 examples.
if len(self._examples) > 25:
listscroll = Scrollbar(self._exampleFrame, orient='vertical')
self._exampleList.config(yscrollcommand=listscroll.set)
listscroll.config(command=self._exampleList.yview)
listscroll.pack(side='left', fill='y')
# If they select a example, apply it.
self._exampleList.bind('<<ListboxSelect>>', self._exampleList_select)
def _init_readingListbox(self, parent):
self._readingFrame = listframe = Frame(parent)
self._readingFrame.pack(fill='both', side='left', padx=2)
self._readingList_label = Label(self._readingFrame,
font=self._boldfont,
text='Readings')
self._readingList_label.pack()
self._readingList = Listbox(self._readingFrame,
selectmode='single',
relief='groove',
background='white',
foreground='#909090',
font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._readingList.pack(side='right', fill='both', expand=1)
# Add a scrollbar if there are more than 25 examples.
listscroll = Scrollbar(self._readingFrame, orient='vertical')
self._readingList.config(yscrollcommand=listscroll.set)
listscroll.config(command=self._readingList.yview)
listscroll.pack(side='right', fill='y')
self._populate_readingListbox()
def _populate_readingListbox(self):
# Populate the listbox with integers
self._readingList.delete(0, 'end')
for i in range(len(self._readings)):
self._readingList.insert('end', (' %s' % (i + 1)))
self._readingList.config(height=min(len(self._readings), 25), width=5)
# If they select a example, apply it.
self._readingList.bind('<<ListboxSelect>>', self._readingList_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('n', self.next)
self._top.bind('<space>', self.next)
self._top.bind('p', self.prev)
self._top.bind('<BackSpace>', self.prev)
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='Prev',
background='#90c0d0',
foreground='black',
command=self.prev,
).pack(side='left')
Button(
buttonframe,
text='Next',
background='#90c0d0',
foreground='black',
command=self.next,
).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_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='Exit',
underline=1,
command=self.destroy,
accelerator='q')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
actionmenu = Menu(menubar, tearoff=0)
actionmenu.add_command(label='Next',
underline=0,
command=self.next,
accelerator='n, Space')
actionmenu.add_command(label='Previous',
underline=0,
command=self.prev,
accelerator='p, Backspace')
menubar.add_cascade(label='Action', underline=0, menu=actionmenu)
optionmenu = Menu(menubar, tearoff=0)
optionmenu.add_checkbutton(label='Remove Duplicates',
underline=0,
variable=self._glue.remove_duplicates,
command=self._toggle_remove_duplicates,
accelerator='r')
menubar.add_cascade(label='Options', underline=0, menu=optionmenu)
viewmenu = Menu(menubar, tearoff=0)
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)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0, command=self.about)
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
#########################################
## Main draw procedure
#########################################
def _redraw(self):
canvas = self._canvas
# Delete the old DRS, widgets, etc.
if self._drsWidget is not None:
self._drsWidget.clear()
if self._drs:
self._drsWidget = DrsWidget(self._canvas, self._drs)
self._drsWidget.draw()
if self._error:
self._drsWidget = DrsWidget(self._canvas, self._error)
self._drsWidget.draw()
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
self._autostep = 0
if self._top is None: return
self._top.destroy()
self._top = None
def prev(self, *e):
selection = self._readingList.curselection()
readingListSize = self._readingList.size()
# there are readings
if readingListSize > 0:
# if one reading is currently selected
if len(selection) == 1:
index = int(selection[0])
# if it's on (or before) the first item
if index <= 0:
self._select_previous_example()
else:
self._readingList_store_selection(index - 1)
else:
#select its first reading
self._readingList_store_selection(readingListSize - 1)
else:
self._select_previous_example()
def _select_previous_example(self):
#if the current example is not the first example
if self._curExample > 0:
self._exampleList_store_selection(self._curExample - 1)
else:
#go to the last example
self._exampleList_store_selection(len(self._examples) - 1)
def next(self, *e):
selection = self._readingList.curselection()
readingListSize = self._readingList.size()
# if there are readings
if readingListSize > 0:
# if one reading is currently selected
if len(selection) == 1:
index = int(selection[0])
# if it's on (or past) the last item
if index >= (readingListSize - 1):
self._select_next_example()
else:
self._readingList_store_selection(index + 1)
else:
#select its first reading
self._readingList_store_selection(0)
else:
self._select_next_example()
def _select_next_example(self):
#if the current example is not the last example
if self._curExample < len(self._examples) - 1:
self._exampleList_store_selection(self._curExample + 1)
else:
#go to the first example
self._exampleList_store_selection(0)
def about(self, *e):
ABOUT = (
"NLTK Discourse Representation Theory (DRT) Glue Semantics Demo\n"
+ "Written by Daniel H. Garrette")
TITLE = 'About: NLTK DRT Glue Demo'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
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()
def _toggle_remove_duplicates(self):
self._glue.remove_duplicates = not self._glue.remove_duplicates
self._exampleList.selection_clear(0, 'end')
self._readings = []
self._populate_readingListbox()
self._readingCache = [None for ex in self._examples]
self._curExample = -1
self._error = None
self._drs = None
self._redraw()
def _exampleList_select(self, event):
selection = self._exampleList.curselection()
if len(selection) != 1: return
self._exampleList_store_selection(int(selection[0]))
def _exampleList_store_selection(self, index):
self._curExample = index
example = self._examples[index]
self._exampleList.selection_clear(0, 'end')
if example:
cache = self._readingCache[index]
if cache:
if isinstance(cache, list):
self._readings = cache
self._error = None
else:
self._readings = []
self._error = cache
else:
try:
self._readings = self._glue.parse_to_meaning(example)
self._error = None
self._readingCache[index] = self._readings
except Exception as e:
self._readings = []
self._error = DrtVariableExpression(
Variable('Error: ' + str(e)))
self._readingCache[index] = self._error
#add a star to the end of the example
self._exampleList.delete(index)
self._exampleList.insert(index, (' %s *' % example))
self._exampleList.config(height=min(
len(self._examples), 25),
width=40)
self._populate_readingListbox()
self._exampleList.selection_set(index)
self._drs = None
self._redraw()
def _readingList_select(self, event):
selection = self._readingList.curselection()
if len(selection) != 1: return
self._readingList_store_selection(int(selection[0]))
def _readingList_store_selection(self, index):
reading = self._readings[index]
self._readingList.selection_clear(0, 'end')
if reading:
self._readingList.selection_set(index)
self._drs = reading.simplify().normalize().resolve_anaphora()
self._redraw()
#!/usr/bin/python
import os
from Tkinter import Tk, Label, Button, Entry, ACTIVE
root = Tk()
root.wm_title("Enter MFA Token")
Label(root, text="Token").pack()
entry = Entry(root)
entry.pack(padx=5)
def done():
print entry.get()
root.destroy()
b = Button(root, text="OK", default=ACTIVE, command=done)
b.pack(pady=5)
entry.focus_force()
root.bind('<Return>', (lambda e, b=b: b.invoke()))
os.system(('''/usr/bin/osascript -e 'tell app "Finder" to set '''
'''frontmost of process "Python" to true' '''))
root.mainloop()
survive_rule = [2, 3]
born_rule = [3]
root = Tk()
root.title("Game of Life")
frame = Frame(root, width=720, height=720)
frame.pack()
canvas = Canvas(frame, width=720, height=720)
canvas.pack()
universe = set()
create_grid()
#frame = Frame(root)
start = Button(root, text="Start", command=begin)
start.pack(side=LEFT)
stop = Button(root, text="Stop", command=stop)
stop.pack(side=LEFT)
clear = Button(root, text="Erase", command=clear)
clear.pack(side=LEFT)
text = Entry(root)
text.insert(0, "23/3")
text.pack(side=LEFT)
canvas.bind("<Button-1>", change_colour_on_click)
canvas.bind("<Button-3>", change_colour_on_click)
canvas.bind("<B1-Motion>", fill_on_click)
canvas.bind("<B3-Motion>", clear_on_click)
root.bind("<space>", step_ev)
#frame.pack()
root.mainloop()
if y >= 0.0:
canvas.after(1, tick)
def space(evt):
global vy, space_count
if space_count < 20:
vy += 1
space_count += 1
root = Tk()
canvas = Canvas(root, width=w, height=h, bg='black')
canvas.pack()
root.bind('<space>', space)
#creates background
img1 = Image.open('earthrise.jpg').resize((w, h))
pmg1 = ImageTk.PhotoImage(img1)
canvas.create_image(w / 2, h / 2, image=pmg1)
#opens eagle.jpg
img2 = Image.open('eagle.jpg').resize((200, 200))
pmg2 = ImageTk.PhotoImage(img2)
ship = canvas.create_image(w / 4, 0, image=pmg2)
#creates landing pad
canvas.create_rectangle(w/4-150,int(0.5+0.7*h)+100,w/4+150,\
int(0.5+0.7*h)+125,outline = 'green',fill = 'green')
f = ('Times', 36, 'bold')
return vals
def reset_station():
# listbox.delete(0, END)
#listbox.insert(END, '')
tree.delete(*tree.get_children())
if __name__ == '__main__':
root = Tk()
Label(root, text = "GoBike Station Recommendation", fg = "blue", font = "Verdana 20 bold").pack()
# listbox = Listbox(root, width = 150, height = 10)
# listbox.pack(expand = True)
ents = makeform(root, fields, OPTIONS)
root.bind('<Return>', (lambda event, e=ents: fetch(e)))
global vals
vals = fetch(ents)
print vals
fm = Frame(root)
b1 = Button(fm, text='Show', command=(lambda e=ents: fetch(e)))
b1.pack(side=LEFT, padx=5, pady=5)
# lb = Listbox(root)
b = Button(fm, text="Reset",
command=reset_station)
b.pack(side=LEFT, padx=5, pady=5)
fm.pack(fill=BOTH, expand = YES)
car_header = ['rank', 'station_name', 'distance', 'duration', 'metric']
root.title("GoApp")
Btn08.bind('<ButtonPress-1>', x_decrease)
Btn09.bind('<ButtonPress-1>', y_decrease)
Btn10.bind('<ButtonPress-1>', y_increase)
Btn11.bind('<ButtonPress-1>', xy_home)
# Btn07.bind('<ButtonRelease-1>', home_fun)
# Btn08.bind('<ButtonRelease-1>', home_fun)
# Btn09.bind('<ButtonRelease-1>', home_fun)
# Btn10.bind('<ButtonRelease-1>', home_fun)
# Btn11.bind('<ButtonRelease-1>', home_fun)
# =============================================================================
# Bind buttons on the keyboard with the corresponding callback function to
# control the car remotely with the keyboard.
# =============================================================================
top.bind(
'<KeyPress-q>',
left_fun) # Press down key 'A' on the keyboard and the car will turn left.
top.bind('<KeyPress-d>', right_fun)
top.bind('<KeyPress-s>', backward_fun)
top.bind('<KeyPress-z>', forward_fun)
top.bind('<KeyPress-h>', home_fun)
top.bind('<KeyRelease-q>',
home_fun) # Release key 'A' and the car will turn back.
top.bind('<KeyRelease-d>', home_fun)
top.bind('<KeyRelease-s>', stop_fun)
top.bind('<KeyRelease-z>', stop_fun)
spd = 50
def changeSpeed(ev=None):
DOOR_CABLES = 4
def end_fullscreen(self, event=None):
win.state = False
win.attributes("-fullscreen", False)
win.geometry("200x200")
return "break"
logging.basicConfig(filename='logfile.log',
level=logging.DEBUG,
format='%(asctime)s %(message)s')
win = Tk()
win.attributes("-fullscreen", True)
win.bind("<Escape>", end_fullscreen)
myFont = tkFont.Font(family='Helvetica', size=24, weight='bold')
#python don't have switch or case
def decrement_stock(num_door):
global STOCK_HEADSETS
global STOCK_MOUSES
global STOCK_KEYBOARDS
global STOCK_CABLES
if num_door == DOOR_HEADSETS:
STOCK_HEADSETS -= 1
if STOCK_HEADSETS == 0:
headsetButton.config(state="disabled")
elif num_door == DOOR_MOUSES:
STOCK_MOUSES -= 1
blue.walk(0.1, 0)
def bluebackward(event):
blue.walk(-0.1, 0)
def blueleft(event):
blue.walk(0, 0, angle=20)
def blueright(event):
blue.walk(0, 0, angle=-20)
tkinst.bind("w", redfoward)
tkinst.bind("s", redbackward)
tkinst.bind("a", redleft)
tkinst.bind("d", redright)
tkinst.bind("i", bluefoward)
tkinst.bind("k", bluebackward)
tkinst.bind("j", blueleft)
tkinst.bind("l", blueright)
frame = Frame(tkinst, height=1000, width=1280)
if __name__ == "__main__":
if usevid:
thread0 = myThread(0, "video", frame)
#thread1 = myThread(1, "red")
output_label.grid(row=3,column=0,rowspan=1,columnspan=1,sticky=N+S+W+E,padx=PADDING,pady=PADDING)
output_box.grid(row=4,column=0,rowspan=2,columnspan=3,sticky=N+S+W+E,padx=PADDING,pady=PADDING)
submit_button.grid(row=5, column=3,sticky=N+S+W+E,padx=PADDING,pady=PADDING)
submit_button.bind("<Button-1>", click_down)
submit_button.bind("<ButtonRelease-1>", click_up)
for x in range(1,root.grid_size()[0] - 1):
root.grid_columnconfigure(x, weight=1,minsize=20)
root.grid_rowconfigure(0, weight=0,minsize=5)
root.grid_rowconfigure(1, weight=0,minsize=10)
root.grid_rowconfigure(2, weight=0,minsize=10)
root.grid_rowconfigure(3, weight=0,minsize=5)
root.grid_rowconfigure(4, weight=1,minsize=10)
root.grid_rowconfigure(5, weight=0,minsize=10)
input_box.bind("<Command-Return>", return_press)
output_box.bind("<Command-Return>", return_press)
root.bind("<Command-Return>", return_press)
input_box.bind("<Command-a>", select_all)
output_box.bind("<Command-a>", select_all)
root.title("Latin Translator")
root.geometry(str(WIDTH)+"x"+str(HEIGHT))
root.minsize(str(WIDTH),str(HEIGHT))
root.configure(background='#757575')
root.after(500, focus)
root.mainloop()
lines[1][0].set_data(t2, amplit)
lines[1][1].set_data(t2, fdamp)
lines[2][0].set_data(t2, signal)
lines[2][1].set_data(t2, instfreq)
lines[3][0].set_data(fdamp2, instfreq)
lines[3][1].set_data(fdamp2, tswafit)
for ax in axes:
ax.relim()
ax.autoscale_view(tight=True, scalex=True, scaley=True)
fig.canvas.draw()
return
root.bind('<<update_plots>>', update_plots)
q['update_results'] = Queue()
def update_results(event):
resultsdata = q['update_results'].get()
res_amp, res_tau, res_tswa = resultsdata
if res_tau[1]/res_tau[0] < 0.05:
if epics['write_amp'].get():
pv.ampl.put(res_amp[0])
if epics['write_tau'].get():
pv.tau.put(res_tau[0])
if epics['write_tswa'].get():
pv.tswa.put(res_tswa[0])
results['amp'].set(('{0:.2f} ' + u'\u00B1' + ' {1:.2f} mm').format(*res_amp))
results['tau'].set(('{0:.2f} ' + u'\u00B1' + ' {1:.2f} ms').format(*res_tau))
results['tswa'].set(('{0:.2f} ' + u'\u00B1' + ' {1:.2f} Hz/mm' + u'\u00B2').format(*res_tswa))
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()
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"
#Terminal_window.config(yscrollcommand=terminal_scroll.set)
label_filename = Label(root, text="File path")
label_chip = Label(root, text="Chip")
label_frequency = Label(root, text="Frequency")
label_programmer = Label(root, text="Programmer")
label_lfuse = Label(root, text="Low fuse")
label_hfuse = Label(root, text="High fuse")
label_key_comp = Label(root, text="Compile : Ctrl+R")
label_key_flash = Label(root, text="Flash : Ctrl+F")
fuse_deact()
###----------Keys press-----------###
root.bind('<Control-r>', lambda e: key_comp())
root.bind('<Control-f>', lambda e: key_flash())
#####-------------- grid------------
label_filename.grid(row=0, column=0, padx=5, pady=5, sticky=E)
file_path_entry.grid(row=0, column=1, columnspan=3, padx=5, pady=5, sticky=W)
button_open.grid(row=0, column=5, padx=5, pady=5)
label_chip.grid(row=1, column=0, pady=5, sticky=E)
Chip_combobox.grid(row=1, column=1, pady=5, padx=5, sticky=W)
label_frequency.grid(row=1, column=2, pady=5, sticky=E)
frequency_entry.grid(row=1, column=3, sticky=W)
button_compile.grid(row=1, column=5, padx=5, pady=5)
class DrtGlueDemo(object):
def __init__(self, examples):
# Set up the main window.
self._top = Tk()
self._top.title('DRT Glue Demo')
# Set up key bindings.
self._init_bindings()
# Initialize the fonts.self._error = None
self._init_fonts(self._top)
self._examples = examples
self._readingCache = [None for example in examples]
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Set the data to None
self._curExample = -1
self._readings = []
self._drs = None
self._drsWidget = None
self._error = None
self._init_glue()
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_exampleListbox(self._top)
self._init_readingListbox(self._top)
self._init_canvas(self._top)
# Resize callback
self._canvas.bind('<Configure>', self._configure)
#########################################
## Initialization Helpers
#########################################
def _init_glue(self):
tagger = RegexpTagger(
[('^(David|Mary|John)$', 'NNP'),
('^(walks|sees|eats|chases|believes|gives|sleeps|chases|persuades|tries|seems|leaves)$', 'VB'),
('^(go|order|vanish|find|approach)$', 'VB'),
('^(a)$', 'ex_quant'),
('^(every)$', 'univ_quant'),
('^(sandwich|man|dog|pizza|unicorn|cat|senator)$', 'NN'),
('^(big|gray|former)$', 'JJ'),
('^(him|himself)$', 'PRP')
])
depparser = MaltParser(tagger=tagger)
self._glue = DrtGlue(depparser=depparser, remove_duplicates=False)
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = 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 = Font(family='helvetica', weight='bold',
size=self._size.get())
self._font = 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 = Font(family='helvetica', weight='bold',
size=big)
def _init_exampleListbox(self, parent):
self._exampleFrame = listframe = Frame(parent)
self._exampleFrame.pack(fill='both', side='left', padx=2)
self._exampleList_label = Label(self._exampleFrame, font=self._boldfont,
text='Examples')
self._exampleList_label.pack()
self._exampleList = Listbox(self._exampleFrame, selectmode='single',
relief='groove', background='white',
foreground='#909090', font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._exampleList.pack(side='right', fill='both', expand=1)
for example in self._examples:
self._exampleList.insert('end', (' %s' % example))
self._exampleList.config(height=min(len(self._examples), 25), width=40)
# Add a scrollbar if there are more than 25 examples.
if len(self._examples) > 25:
listscroll = Scrollbar(self._exampleFrame,
orient='vertical')
self._exampleList.config(yscrollcommand = listscroll.set)
listscroll.config(command=self._exampleList.yview)
listscroll.pack(side='left', fill='y')
# If they select a example, apply it.
self._exampleList.bind('<<ListboxSelect>>', self._exampleList_select)
def _init_readingListbox(self, parent):
self._readingFrame = listframe = Frame(parent)
self._readingFrame.pack(fill='both', side='left', padx=2)
self._readingList_label = Label(self._readingFrame, font=self._boldfont,
text='Readings')
self._readingList_label.pack()
self._readingList = Listbox(self._readingFrame, selectmode='single',
relief='groove', background='white',
foreground='#909090', font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._readingList.pack(side='right', fill='both', expand=1)
# Add a scrollbar if there are more than 25 examples.
listscroll = Scrollbar(self._readingFrame,
orient='vertical')
self._readingList.config(yscrollcommand = listscroll.set)
listscroll.config(command=self._readingList.yview)
listscroll.pack(side='right', fill='y')
self._populate_readingListbox()
def _populate_readingListbox(self):
# Populate the listbox with integers
self._readingList.delete(0, 'end')
for i in range(len(self._readings)):
self._readingList.insert('end', (' %s' % (i+1)))
self._readingList.config(height=min(len(self._readings), 25), width=5)
# If they select a example, apply it.
self._readingList.bind('<<ListboxSelect>>', self._readingList_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('n', self.next)
self._top.bind('<space>', self.next)
self._top.bind('p', self.prev)
self._top.bind('<BackSpace>', self.prev)
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='Prev',
background='#90c0d0', foreground='black',
command=self.prev,).pack(side='left')
Button(buttonframe, text='Next',
background='#90c0d0', foreground='black',
command=self.next,).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_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='Exit', underline=1,
command=self.destroy, accelerator='q')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
actionmenu = Menu(menubar, tearoff=0)
actionmenu.add_command(label='Next', underline=0,
command=self.next, accelerator='n, Space')
actionmenu.add_command(label='Previous', underline=0,
command=self.prev, accelerator='p, Backspace')
menubar.add_cascade(label='Action', underline=0, menu=actionmenu)
optionmenu = Menu(menubar, tearoff=0)
optionmenu.add_checkbutton(label='Remove Duplicates', underline=0,
variable=self._glue.remove_duplicates,
command=self._toggle_remove_duplicates,
accelerator='r')
menubar.add_cascade(label='Options', underline=0, menu=optionmenu)
viewmenu = Menu(menubar, tearoff=0)
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)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0,
command=self.about)
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
#########################################
## Main draw procedure
#########################################
def _redraw(self):
canvas = self._canvas
# Delete the old DRS, widgets, etc.
if self._drsWidget is not None:
self._drsWidget.clear()
if self._drs:
self._drsWidget = DrsWidget( self._canvas, self._drs )
self._drsWidget.draw()
if self._error:
self._drsWidget = DrsWidget( self._canvas, self._error )
self._drsWidget.draw()
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
self._autostep = 0
if self._top is None: return
self._top.destroy()
self._top = None
def prev(self, *e):
selection = self._readingList.curselection()
readingListSize = self._readingList.size()
# there are readings
if readingListSize > 0:
# if one reading is currently selected
if len(selection) == 1:
index = int(selection[0])
# if it's on (or before) the first item
if index <= 0:
self._select_previous_example()
else:
self._readingList_store_selection(index-1)
else:
#select its first reading
self._readingList_store_selection(readingListSize-1)
else:
self._select_previous_example()
def _select_previous_example(self):
#if the current example is not the first example
if self._curExample > 0:
self._exampleList_store_selection(self._curExample-1)
else:
#go to the last example
self._exampleList_store_selection(len(self._examples)-1)
def next(self, *e):
selection = self._readingList.curselection()
readingListSize = self._readingList.size()
# if there are readings
if readingListSize > 0:
# if one reading is currently selected
if len(selection) == 1:
index = int(selection[0])
# if it's on (or past) the last item
if index >= (readingListSize-1):
self._select_next_example()
else:
self._readingList_store_selection(index+1)
else:
#select its first reading
self._readingList_store_selection(0)
else:
self._select_next_example()
def _select_next_example(self):
#if the current example is not the last example
if self._curExample < len(self._examples)-1:
self._exampleList_store_selection(self._curExample+1)
else:
#go to the first example
self._exampleList_store_selection(0)
def about(self, *e):
ABOUT = ("NLTK Discourse Representation Theory (DRT) Glue Semantics Demo\n"+
"Written by Daniel H. Garrette")
TITLE = 'About: NLTK DRT Glue Demo'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
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()
def _toggle_remove_duplicates(self):
self._glue.remove_duplicates = not self._glue.remove_duplicates
self._exampleList.selection_clear(0, 'end')
self._readings = []
self._populate_readingListbox()
self._readingCache = [None for ex in self._examples]
self._curExample = -1
self._error = None
self._drs = None
self._redraw()
def _exampleList_select(self, event):
selection = self._exampleList.curselection()
if len(selection) != 1: return
self._exampleList_store_selection(int(selection[0]))
def _exampleList_store_selection(self, index):
self._curExample = index
example = self._examples[index]
self._exampleList.selection_clear(0, 'end')
if example:
cache = self._readingCache[index]
if cache:
if isinstance(cache, list):
self._readings = cache
self._error = None
else:
self._readings = []
self._error = cache
else:
try:
self._readings = self._glue.parse_to_meaning(example)
self._error = None
self._readingCache[index] = self._readings
except Exception, e:
self._readings = []
self._error = DrtVariableExpression(Variable('Error: ' + str(e)))
self._readingCache[index] = self._error
#add a star to the end of the example
self._exampleList.delete(index)
self._exampleList.insert(index, (' %s *' % example))
self._exampleList.config(height=min(len(self._examples), 25), width=40)
self._populate_readingListbox()
self._exampleList.selection_set(index)
self._drs = None
self._redraw()
def main():
settings_file = "settings.yaml"
photos = []
gauth = GoogleAuth(settings_file=settings_file)
gauth.CommandLineAuth()
drive = GoogleDrive(gauth)
print "All files in root:"
# Auto-iterate through all files that matches this query
file_list = drive.ListFile({
'q': "'root' in parents and trashed=false"
}).GetList()
print "List folders"
for file1 in file_list:
#print 'title: %s, id: %s' % (file1['title'], file1['id'])
#print 'mime: %s' % (file1['mimeType'])
if file1['mimeType'] == "application/vnd.google-apps.folder":
if file1['title'] == "Google Photos":
print "Found your photos:"
print 'Folder: %s, Id: %s' % (file1['title'], file1['id'])
found = True
if found == False:
print "Error, no Google Photos folder found"
sys.exit()
# Google Photos folder id =1Q4Xk107tDLn4SdoHOqZwy5AGyvIm2bNO1uubxlMqx34
# (found above)
#folder_id="1Q4Xk107tDLn4SdoHOqZwy5AGyvIm2bNO1uubxlMqx34"
#title: 2016, id: 1efl45Zs9_cFLEXzRERqqxIQp3Q
folder_id = "1efl45Zs9_cFLEXzRERqqxIQp3Q" #
print "List files in folder 2016"
_q = {'q': "'{}' in parents and trashed=false".format(folder_id)}
photolist = drive.ListFile(_q).GetList()
for file1 in photolist:
#print 'title: %s, id: %s' % (file1['title'], file1['id'])
#print 'mime: %s' % (file1['mimeType'])
if file1['mimeType'] == "image/jpeg":
imageurl = file1['title']
imageid = file1['id']
#print 'title: %s' % (file1['title'])
print "Open " + str(imageurl) + " id: " + str(imageid)
# Download and show an image
myFile = drive.CreateFile({'id': imageid})
myFile.GetContentFile(imageurl)
print '%s downloaded ' % (imageurl) + " and it looks like this:"
# Create fullscreen window
root = Tk()
root.overrideredirect(True)
root.geometry("{0}x{1}+0+0".format(root.winfo_screenwidth(),
root.winfo_screenheight()))
# Keyboard input
root.bind('<Key>', keyinput)
# Screen size?
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
#print str(screen_width) + "-" + str(screen_height)
image = Image.open(imageurl)
width, height = image.size
#print str(width) + "-" + str(height)
image = image.resize((screen_width, screen_height), Image.ANTIALIAS)
img = ImageTk.PhotoImage(image)
panel = Label(root, image=img)
panel.pack(side="bottom", fill="both", expand="yes")
root.mainloop()
time.sleep(10)
def sunfounder_client(ip, key):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from Tkinter import Tk, Button, Label, Scale, HORIZONTAL
print "Connecting to IP", ip
ctrl_cmd = ['forward', 'backward', 'left', 'right', 'stop', 'read cpu_temp', 'home', 'distance', 'x+', 'x-', 'y+', 'y-', 'xy_home']
top = Tk() # Create a top window
top.title('Sunfounder Raspberry Pi Smart Video Car')
HOST = ip # Server(Raspberry Pi) IP address
PORT = 21567
BUFSIZ = 1024 # buffer size
ADDR = (HOST, PORT)
tcpCliSock = socket(AF_INET, SOCK_STREAM) # Create a socket
tcpCliSock.connect(ADDR) # Connect with the server
# =============================================================================
# The function is to send the command forward to the server, so as to make the
# car move forward.
# =============================================================================
def forward_fun(event):
print "\nUser command = forward"
print "Encrypted command = ",crypto.AES_encrypt('forward',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('forward',key)))
def backward_fun(event):
print '\nUser command = backward'
print "Encrypted command = ",crypto.AES_encrypt('backward',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('backward',key)))
def left_fun(event):
print '\nUser command = left'
print "Encrypted command = ",crypto.AES_encrypt('left',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('left',key)))
def right_fun(event):
print '\nUser command = right'
print "Encrypted command = ",crypto.AES_encrypt('right',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('right',key)))
def stop_fun(event):
print '\nUser command = stop'
print "Encrypted command = ",crypto.AES_encrypt('stop',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('stop',key)))
def home_fun(event):
print '\nUser command = home'
print "Encrypted command = ",crypto.AES_encrypt('home',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('home',key)))
def x_increase(event):
print '\nUser command = x+'
print "Encrypted command = ",crypto.AES_encrypt('x+',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('x+',key)))
def x_decrease(event):
print '\nUser command = x-'
print "Encrypted command = ",crypto.AES_encrypt('x-',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('x-',key)))
def y_increase(event):
print '\nUser command = y+'
print "Encrypted command = ",crypto.AES_encrypt('y+',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('y+',key)))
def y_decrease(event):
print '\nUser command = y-'
print "Encrypted command = ",crypto.AES_encrypt('y-',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('y-',key)))
def xy_home(event):
print '\nUser command = xy_home'
print "Encrypted command = ",crypto.AES_encrypt('xy_home',key)[2]
tcpCliSock.send(str(crypto.AES_encrypt('xy_home',key)))
# =============================================================================
# Exit the GUI program and close the network connection between the client
# and server.
# =============================================================================
def quit_fun(event):
print "\nShutting down program..."
top.quit()
tcpCliSock.send(str(crypto.AES_encrypt('stop',key)))
tcpCliSock.close()
# =============================================================================
# Create buttons
# =============================================================================
Btn0 = Button(top, width=5, text='Forward')
Btn1 = Button(top, width=5, text='Backward')
Btn2 = Button(top, width=5, text='Left')
Btn3 = Button(top, width=5, text='Right')
Btn4 = Button(top, width=5, text='Quit')
Btn5 = Button(top, width=5, height=2, text='Home')
# =============================================================================
# Buttons layout
# =============================================================================
Btn0.grid(row=0,column=1)
Btn1.grid(row=2,column=1)
Btn2.grid(row=1,column=0)
Btn3.grid(row=1,column=2)
Btn4.grid(row=3,column=2)
Btn5.grid(row=1,column=1)
# =============================================================================
# Bind the buttons with the corresponding callback function.
# =============================================================================
Btn0.bind('<ButtonPress-1>', forward_fun) # When button0 is pressed down, call the function forward_fun().
Btn1.bind('<ButtonPress-1>', backward_fun)
Btn2.bind('<ButtonPress-1>', left_fun)
Btn3.bind('<ButtonPress-1>', right_fun)
Btn0.bind('<ButtonRelease-1>', stop_fun) # When button0 is released, call the function stop_fun().
Btn1.bind('<ButtonRelease-1>', stop_fun)
Btn2.bind('<ButtonRelease-1>', stop_fun)
Btn3.bind('<ButtonRelease-1>', stop_fun)
Btn4.bind('<ButtonRelease-1>', quit_fun)
Btn5.bind('<ButtonRelease-1>', home_fun)
# =============================================================================
# Create buttons
# =============================================================================
Btn07 = Button(top, width=5, text='X+', bg='red')
Btn08 = Button(top, width=5, text='X-', bg='red')
Btn09 = Button(top, width=5, text='Y-', bg='red')
Btn10 = Button(top, width=5, text='Y+', bg='red')
Btn11 = Button(top, width=5, height=2, text='HOME', bg='red')
# =============================================================================
# Buttons layout
# =============================================================================
Btn07.grid(row=1,column=5)
Btn08.grid(row=1,column=3)
Btn09.grid(row=2,column=4)
Btn10.grid(row=0,column=4)
Btn11.grid(row=1,column=4)
# =============================================================================
# Bind button events
# =============================================================================
Btn07.bind('<ButtonPress-1>', x_increase)
Btn08.bind('<ButtonPress-1>', x_decrease)
Btn09.bind('<ButtonPress-1>', y_decrease)
Btn10.bind('<ButtonPress-1>', y_increase)
Btn11.bind('<ButtonPress-1>', xy_home)
#Btn07.bind('<ButtonRelease-1>', home_fun)
#Btn08.bind('<ButtonRelease-1>', home_fun)
#Btn09.bind('<ButtonRelease-1>', home_fun)
#Btn10.bind('<ButtonRelease-1>', home_fun)
#Btn11.bind('<ButtonRelease-1>', home_fun)
# =============================================================================
# Bind buttons on the keyboard with the corresponding callback function to
# control the car remotely with the keyboard.
# =============================================================================
top.bind('<KeyPress-a>', left_fun) # Press down key 'A' on the keyboard and the car will turn left.
top.bind('<KeyPress-d>', right_fun)
top.bind('<KeyPress-s>', backward_fun)
top.bind('<KeyPress-w>', forward_fun)
top.bind('<KeyPress-h>', home_fun)
top.bind('<KeyRelease-a>', home_fun) # Release key 'A' and the car will turn back.
top.bind('<KeyRelease-d>', home_fun)
top.bind('<KeyRelease-s>', stop_fun)
top.bind('<KeyRelease-w>', stop_fun)
spd = 50
def changeSpeed(ev=None):
tmp = 'speed'
global spd
spd = speed.get()
data = tmp + str(spd) # Change the integers into strings and combine them with the string 'speed'.
#print 'sendData = %s' % data
print '\nUser command = ', data
print "Encrypted command = ",crypto.AES_encrypt(data,key)[2]
tcpCliSock.send(str(crypto.AES_encrypt(data,key))) # Send the speed data to the server(Raspberry Pi)
label = Label(top, text='Speed:', fg='red') # Create a label
label.grid(row=6, column=0) # Label layout
speed = Scale(top, from_=0, to=100, orient=HORIZONTAL, command=changeSpeed) # Create a scale
speed.set(50)
speed.grid(row=6, column=1)
def main():
top.mainloop()
if __name__ == '__main__':
main()
canv.delete(rects[i][j])
rects[i][j]=canv.create_rectangle(w*i/n, h*j/n, w*(i+1)/n, h*(j+1)/n, fill="lightblue", outline="lightblue")
else: new_grid[i][j]=grid[i][j]
for i in range(len(new_grid)):
for j in range(len(new_grid[i])):
grid[i][j]=new_grid[i][j]
canv.after(20, tick, grid, rects)
w, h = 600, 600
n, m = 20, 20
paused = True
grid=[]; new_grid=[]; rects=[]
root = Tk()
canv = Canvas(root, width=w, height=h, bg="white")
##for i in range(n+1):canv.create_line(w*i/n,0,w*i/n,h, fill = "lightblue")
##for i in range(m+1):canv.create_line(0,h*i/m,w,h*i/m, fill = "lightblue")
for i in range(n):
grid.append([])
rects.append([])
for j in range(m):
grid[i].append(0)
rects[i].append(canv.create_rectangle(w*i/n, h*j/n, w*(i+1)/n, h*(j+1)/n, fill="white", outline="lightblue"))
for (i, j) in [(0, 1), (0, 2), (1, 0), (1, 1), (2, 1)]:
grid[i][j]=1
canv.delete(rects[i][j])
rects[i][j]=canv.create_rectangle(w*i/n, h*j/n, w*(i+1)/n, h*(j+1)/n, fill="lightblue", outline="lightblue")
canv.pack()
root.bind('<1>', lambda e: left(e, grid, rects))
root.bind('<space>', begin)
root.mainloop()
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 == 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 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()
def main():
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
def initUI(self):
w = self.parent.winfo_screenwidth()/1
h = self.parent.winfo_screenheight()/1
sw = self.parent.winfo_screenwidth()
sh = self.parent.winfo_screenheight()
x = (sw - w)/2
y = (sh - h)/2
self.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))
self.parent.title("Cool Positioning")
self.pack(fill=BOTH, expand=1)
Style().configure("TFrame", background="#000")
def changeImage(event):
## print "clicked at", event.x, event.y, "typed ", event.char
if event.char == "1":
print event.char
myImg = resizeImg(Image.open("bardejov.jpg"), root.winfo_screenwidth())
myImage = ImageTk.PhotoImage(myImg)
label = Label(root, image=myImage)
label.image = myImage
xLabel = (root.winfo_screenwidth() - myImg.size[0])/2
yLabel = (root.winfo_screenheight() - myImg.size[1])/2
label.place(x=xLabel, y=yLabel)
if event.char == "2":
print event.char
myImg = resizeImg(Image.open("rotunda.jpg"), root.winfo_screenwidth())
myImage = ImageTk.PhotoImage(myImg)
label = Label(root, image=myImage)
label.image = myImage
xLabel = (root.winfo_screenwidth() - myImg.size[0])/2
yLabel = (root.winfo_screenheight() - myImg.size[1])/2
label.place(x=xLabel, y=yLabel)
if event.char == "3":
print event.char
myImg = resizeImg(Image.open("mincol.jpg"), root.winfo_screenwidth())
myImage = ImageTk.PhotoImage(myImg)
label = Label(root, image=myImage)
label.image = myImage
xLabel = (root.winfo_screenwidth() - myImg.size[0])/2
yLabel = (root.winfo_screenheight() - myImg.size[1])/2
label.place(x=xLabel, y=yLabel)
def resizeImg(img, finalWidth):
finalHeight = int(round((finalWidth * img.size[1])/img.size[0]))
resizedImage = img.resize((finalWidth, finalHeight), Image.ANTIALIAS)
print("final width",resizedImage.size[0],"final height",resizedImage.size[1])
return resizedImage
root = Tk()
app = Example(root)
# This is how to display the image, needs to be done once in the main function
# this way label object and all its friends are defined
myImg = resizeImg(Image.open("bardejov.jpg"), root.winfo_screenwidth())
myImage = ImageTk.PhotoImage(myImg)
label = Label(root, image=myImage)
label.image = myImage
xLabel = (root.winfo_screenwidth() - myImg.size[0])/2
yLabel = (root.winfo_screenheight() - myImg.size[1])/2
label.place(x=xLabel, y=yLabel)
root.bind("<Key>", changeImage)
root.bind("<Escape>", lambda e: e.widget.quit())
root.mainloop()
def setUpCanvas():
root = Tk()
root.title("Comma Gets a Cure")
canvas = Canvas(root, width=640, height=480, bg="white")
canvas.pack(expand=YES, fill=BOTH)
root.bind("<Right>", highlight)
root.bind("<q>", quit)
root.bind("<Left>", dehighlight)
root.bind("<space>", play)
root.bind("<d>", delete)
root.bind("<Delete>", delete)
root.bind("<Down>", lambda evt: [highlight(None) for i in range(5)])
root.bind("<Up>", lambda evt: [dehighlight(None) for i in range(5)])
return root, canvas
class TreeView(object):
def __init__(self, *trees):
from math import sqrt, ceil
self._trees = trees
self._top = Tk()
self._top.title('NLTK')
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Control-q>', self.destroy)
cf = self._cframe = CanvasFrame(self._top)
self._top.bind('<Control-p>', self._cframe.print_to_file)
# Size is variable.
self._size = IntVar(self._top)
self._size.set(12)
bold = ('helvetica', -self._size.get(), 'bold')
helv = ('helvetica', -self._size.get())
# Lay the trees out in a square.
self._width = int(ceil(sqrt(len(trees))))
self._widgets = []
for i in range(len(trees)):
widget = TreeWidget(cf.canvas(), trees[i], node_font=bold,
leaf_color='#008040', node_color='#004080',
roof_color='#004040', roof_fill='white',
line_color='#004040', draggable=1,
leaf_font=helv)
widget.bind_click_trees(widget.toggle_collapsed)
self._widgets.append(widget)
cf.add_widget(widget, 0, 0)
self._layout()
self._cframe.pack(expand=1, fill='both')
self._init_menubar()
def _layout(self):
i = x = y = ymax = 0
width = self._width
for i in range(len(self._widgets)):
widget = self._widgets[i]
(oldx, oldy) = widget.bbox()[:2]
if i % width == 0:
y = ymax
x = 0
widget.move(x-oldx, y-oldy)
x = widget.bbox()[2] + 10
ymax = max(ymax, widget.bbox()[3] + 10)
def _init_menubar(self):
menubar = Menu(self._top)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Print to Postscript', underline=0,
command=self._cframe.print_to_file,
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)
zoommenu = Menu(menubar, tearoff=0)
zoommenu.add_radiobutton(label='Tiny', variable=self._size,
underline=0, value=10, command=self.resize)
zoommenu.add_radiobutton(label='Small', variable=self._size,
underline=0, value=12, command=self.resize)
zoommenu.add_radiobutton(label='Medium', variable=self._size,
underline=0, value=14, command=self.resize)
zoommenu.add_radiobutton(label='Large', variable=self._size,
underline=0, value=28, command=self.resize)
zoommenu.add_radiobutton(label='Huge', variable=self._size,
underline=0, value=50, command=self.resize)
menubar.add_cascade(label='Zoom', underline=0, menu=zoommenu)
self._top.config(menu=menubar)
def resize(self, *e):
bold = ('helvetica', -self._size.get(), 'bold')
helv = ('helvetica', -self._size.get())
xspace = self._size.get()
yspace = self._size.get()
for widget in self._widgets:
widget['node_font'] = bold
widget['leaf_font'] = helv
widget['xspace'] = xspace
widget['yspace'] = yspace
if self._size.get() < 20: widget['line_width'] = 1
elif self._size.get() < 30: widget['line_width'] = 2
else: widget['line_width'] = 3
self._layout()
def destroy(self, *e):
if self._top is None: return
self._top.destroy()
self._top = None
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)
if "CASEDIR" not in environ:
environ["CASEDIR"] = "distri/opensuse"
pat = environ["CASEDIR"] + "/needles/%s.%s"
shutil.copyfile(png, pat % (options.new, "png"))
filename = pat % (options.new, "json")
json.dump(needle,
open(filename, "w"),
sort_keys=True,
indent=4,
separators=(",", ": "))
print("saved %s" % filename)
master.quit()
master.bind("<Shift-Up>", resize)
master.bind("<Shift-Down>", resize)
master.bind("<Shift-Left>", resize)
master.bind("<Shift-Right>", resize)
master.bind("<Up>", move)
master.bind("<Down>", move)
master.bind("<Left>", move)
master.bind("<Right>", move)
master.bind("+", increment)
master.bind("-", increment)
master.bind("s", save_quit)
master.bind("q", quit)
master.bind("<Escape>", quit)
master.bind("<Tab>", switch)
master.bind("<Insert>", addrect)
master.bind("<Delete>", delrect)
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 Game:
def __init__(self):
self.root = Tk()
self.frame1 = None
self.frame2 = None
self.w = None
self.scoreC = None
self.score = 0
self.hor = True
self.upid = self.downid = self.rightid = self.leftid = 0
self.head = -1
self.time = 700
def home(self):
self.frame1 = Frame(self.root, width=750, height=350, padx=250, bg="black")
self.frame2 = Frame(self.root, height=250, width=750, bg="black", padx=25)
self.root.wm_minsize(width=750, height=666)
self.root.configure(bg="black")
self.frame1.pack_propagate(0)
self.frame1.update()
self.frame1.configure(pady=self.frame1.cget("height") / 2.5)
logo = PhotoImage(file="Game_Logo.gif")
starth = Button(self.frame1, text="Hard", bg="orange", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(40))
startm = Button(self.frame1, text="Medium", bg="teal", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(60))
starte = Button(self.frame1, text="Easy", bg="orange", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(75))
self.frame2.pack_propagate(0)
exp = """ This is a game in which
the arrow keys are used
to move the snake around
and to get points"""
exf = Font(family="comic sans MS", size=20)
Label(self.frame2, image=logo, bg="black", text=exp, padx=10).pack(side="right")
Label(self.frame2, fg="white", bg="black", text=exp, justify="left", font=exf).pack(side="left")
starte.grid(row=0, columnspan=2)
startm.grid(row=0, columnspan=2, column=4, padx=18)
starth.grid(row=0, columnspan=2, column=8)
head = Font(family="comic sans MS", size=30)
self.H=Label(self.root, text="SNAKES", font=head, fg="orange", bg="black", pady=10)
self.H.pack()
self.frame2.pack(expand=True)
self.frame1.pack(expand=True)
self.root.mainloop()
def callgame(self, time):
self.time = time
self.game()
def calldown(self, key):
if self.hor:
self.w.after_cancel(self.leftid)
self.w.after_cancel(self.rightid)
self.down(0)
def callup(self, key):
if self.hor:
self.w.after_cancel(self.leftid)
self.w.after_cancel(self.rightid)
self.up(0)
def callright(self, key):
if not self.hor:
self.w.after_cancel(self.upid)
self.w.after_cancel(self.downid)
self.right(0)
def callleft(self, key):
if not self.hor:
self.w.after_cancel(self.upid)
self.w.after_cancel(self.downid)
self.left(0)
def game(self):
self.score = 0
self.w = Canvas(self.root, width=750, height=500, relief="flat", highlightbackground="grey",
highlightthickness=10)
self.frame1.destroy()
self.frame2.destroy()
self.root.configure(width=1000, padx=10)
self.root.pack_propagate(0)
self.w.configure(background="black")
self.w.pack(side="left")
self.w.create_line(300, 250, 450, 250, width=10, fill="teal")
self.scoreC = Label(self.root, text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35,
font=Font(family="comic sans MS", size=25))
self.head = self.w.create_line(450, 250, 455, 250, width=10, fill="white")
self.scoreC.pack(side="top")
self.root.bind("<Up>", self.callup)
self.root.bind("<Down>", self.calldown)
self.root.bind("<Right>", self.callright)
self.root.bind("<Left>", self.callleft)
self.createFood()
self.right(0)
def down(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] + 5, width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.downid = self.w.after(self.time, self.down, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def up(self, i):
crd = self.w.coords(1)
if len(crd)>0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] - 5, width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.upid = self.w.after(self.time, self.up, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def right(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] + 5, crd[-1], width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.rightid = self.w.after(self.time, self.right, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def left(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] - 5, crd[-1], width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.leftid = self.w.after(self.time, self.left, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def createFood(self):
# self.w.delete(self.food) #deleting old food.
crd = self.w.coords(1)
ext = []
for i in crd:
ext.append(i)
for j in range(-50, 50):
ext.append(i + j)
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
while randx not in ext and randy not in ext:
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
self.food = self.w.create_line(randx, randy, randx + 12, randy, width=10, fill="yellow")
def checkEaten(self):
headcoords = self.w.coords(self.head)
foodcoords = self.w.coords(self.food)
# self.w.delete(self.food)
flag = False
# print(headcoords[-4])
# print(foodcoords[-4])
# print(foodcoords[-2])
if int(headcoords[-4]) in range(int(foodcoords[-4]) - 7, int(foodcoords[-2]) + 7) and int(
headcoords[-3]) in range(int(foodcoords[-1]) - 10, int(foodcoords[-1] + 10)):
flag = True
if flag:
self.grow()
self.score += 10
self.scoreC.configure(text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35,
font=Font(family="comic sans MS", size=25))
self.w.delete(self.food)
self.createFood()
def grow(self):
crd = self.w.coords(1)
if crd[0] != crd[2]: # horizontal condition
if crd[0] < crd[2]:
crd[0] -= 20
else:
crd[0] += 20
self.w.coords(1, *crd)
else:
if crd[3] < crd[1]:
crd[1] += 20
else:
crd[1] -= 20
self.w.coords(1, *crd)
def end(self):
crd = self.w.coords(1)
h = self.w.coords(self.head)
a = 0
while a < len(crd) - 2:
if crd[a] == crd[a + 2]:
if (h[0] == crd[a] and crd[a + 1] < h[1] < crd[a + 3]) or (
h[0] == crd[a] and crd[a + 1] > h[1] > crd[a + 3]):
return True
else:
if (h[1] == crd[a + 1] and crd[a] < h[0] < crd[a + 2]) or (h[1] == crd[a + 1] and crd[a] > h[0] > crd[a + 2]):
return True
a += 2
if (h[0] == 0 and 0 < h[1] < 500) or (h[1] == 0 and 0 < h[0] < 750) or (h[1] == 510 and 0 < h[0] < 750) or (h[0] == 760 and 0<h[1]<500):
return True
return False
def callhome(self):
self.w.destroy()
self.start.destroy()
self.H.destroy()
self.scoreC.destroy()
self.home()
def guiLogin(title, default_username="", default_password=""):
from Tkinter import Tk, N, S, W, E, StringVar
import ttk
root = Tk()
root.title(title)
mainframe = ttk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)
username = StringVar()
username.set(default_username)
password = StringVar()
password.set(default_password)
def done(*args):
root.destroy()
ttk.Label(mainframe, text="Username:"******"Password:"******"*")
pass_entry.grid(column=2, row=2, sticky=(W, E))
ttk.Button(mainframe, text="Login", command=done).grid(column=2, row=3, sticky=W)
for child in mainframe.winfo_children(): child.grid_configure(padx=5, pady=2)
username_entry.focus()
root.bind('<Return>', done)
root.bind('<Escape>', lambda event: root.destroy())
root.lift()
root.call('wm', 'attributes', '.', '-topmost', True)
root.after_idle(root.call, 'wm', 'attributes', '.', '-topmost', False)
root.mainloop()
return username.get(), password.get()
def guiLogin():
root = Tk()
root.title("Enter Lastpass login")
mainframe = ttk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)
username = StringVar()
password = StringVar()
ret = []
def done(*args):
ret.append((username.get(), password.get()))
root.destroy()
ttk.Label(mainframe, text="Username:"******"Password:"******"Login", command=done).grid(column=2, row=3, sticky=W)
for child in mainframe.winfo_children(): child.grid_configure(padx=5, pady=2)
username_entry.focus()
root.bind('<Return>', done)
root.bind('<Escape>', lambda event: root.destroy())
root.lift()
root.call('wm', 'attributes', '.', '-topmost', True)
root.after_idle(root.call, 'wm', 'attributes', '.', '-topmost', False)
root.mainloop()
return ret and ret[-1] or None
class gephiController:
def __init__(self, data, appCallback=None, minValue=0.0, maxValue=1.0, logScale=False):
self.data = data
numBins = len(data)-1
self.master = Tk()
self.master.geometry("%dx%d%+d%+d" % (WIDTH,HEIGHT,50,50))
self.master.resizable(False, False)
self.histogram = histogramWidget(self.master,0,0,WIDTH,HEIGHT,self.data,logScale=logScale,callback=self.callApp)
self.current = numBins
self.currentValue = self.data[maxValue][0]
self.appCallback = appCallback
if self.appCallback != None:
self.master.bind("<<appCallback>>",self.runAppCall)
self.master.bind("<<Update>>",self.runUpdate)
def mainloop(self):
self.master.mainloop()
def runUpdate(self, event):
self.histogram.update(self.current)
def runAppCall(self,event):
self.appCallback(self.currentValue)
def callApp(self, value):
self.currentValue = value
self.master.event_generate("<<appCallback>>",when="tail")
def update(self, current):
self.current = current
self.master.event_generate("<<Update>>",when="tail")
class ConcordanceSearchView(object):
_BACKGROUND_COLOUR='#FFF' #white
#Colour of highlighted results
_HIGHLIGHT_WORD_COLOUR='#F00' #red
_HIGHLIGHT_WORD_TAG='HL_WRD_TAG'
_HIGHLIGHT_LABEL_COLOUR='#C0C0C0' # dark grey
_HIGHLIGHT_LABEL_TAG='HL_LBL_TAG'
#Percentage of text left of the scrollbar position
_FRACTION_LEFT_TEXT=0.30
def __init__(self):
self.model = ConcordanceSearchModel()
self.model.add_listener(self)
self.top = Tk()
self._init_top(self.top)
self._init_menubar()
self._init_widgets(self.top)
self._bind_event_handlers()
self.load_corpus(self.model.DEFAULT_CORPUS)
def _init_top(self, top):
top.geometry('950x680+50+50')
top.title('NLTK Concordance Search')
top.bind('<Control-q>', self.destroy)
top.minsize(950,680)
def _init_widgets(self, parent):
self.main_frame = Frame(parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1))
self._init_corpus_select(self.main_frame)
self._init_query_box(self.main_frame)
self._init_results_box(self.main_frame)
self._init_paging(self.main_frame)
self._init_status(self.main_frame)
self.main_frame.pack(fill='both', expand=True)
def _init_menubar(self):
self._result_size = IntVar(self.top)
self._cntx_bf_len = IntVar(self.top)
self._cntx_af_len = IntVar(self.top)
menubar = Menu(self.top)
filemenu = Menu(menubar, tearoff=0, borderwidth=0)
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-q')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
rescntmenu = Menu(editmenu, tearoff=0)
rescntmenu.add_radiobutton(label='20', variable=self._result_size,
underline=0, value=20,
command=self.set_result_size)
rescntmenu.add_radiobutton(label='50', variable=self._result_size,
underline=0, value=50,
command=self.set_result_size)
rescntmenu.add_radiobutton(label='100', variable=self._result_size,
underline=0, value=100,
command=self.set_result_size)
rescntmenu.invoke(1)
editmenu.add_cascade(label='Result Count', underline=0, menu=rescntmenu)
cntxmenu = Menu(editmenu, tearoff=0)
cntxbfmenu = Menu(cntxmenu, tearoff=0)
cntxbfmenu.add_radiobutton(label='60 characters',
variable=self._cntx_bf_len,
underline=0, value=60,
command=self.set_cntx_bf_len)
cntxbfmenu.add_radiobutton(label='80 characters',
variable=self._cntx_bf_len,
underline=0, value=80,
command=self.set_cntx_bf_len)
cntxbfmenu.add_radiobutton(label='100 characters',
variable=self._cntx_bf_len,
underline=0, value=100,
command=self.set_cntx_bf_len)
cntxbfmenu.invoke(1)
cntxmenu.add_cascade(label='Before', underline=0, menu=cntxbfmenu)
cntxafmenu = Menu(cntxmenu, tearoff=0)
cntxafmenu.add_radiobutton(label='70 characters',
variable=self._cntx_af_len,
underline=0, value=70,
command=self.set_cntx_af_len)
cntxafmenu.add_radiobutton(label='90 characters',
variable=self._cntx_af_len,
underline=0, value=90,
command=self.set_cntx_af_len)
cntxafmenu.add_radiobutton(label='110 characters',
variable=self._cntx_af_len,
underline=0, value=110,
command=self.set_cntx_af_len)
cntxafmenu.invoke(1)
cntxmenu.add_cascade(label='After', underline=0, menu=cntxafmenu)
editmenu.add_cascade(label='Context', underline=0, menu=cntxmenu)
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
self.top.config(menu=menubar)
def set_result_size(self, **kwargs):
self.model.result_count = self._result_size.get()
def set_cntx_af_len(self, **kwargs):
self._char_after = self._cntx_af_len.get()
def set_cntx_bf_len(self, **kwargs):
self._char_before = self._cntx_bf_len.get()
def _init_corpus_select(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.var = StringVar(innerframe)
self.var.set(self.model.DEFAULT_CORPUS)
Label(innerframe, justify=LEFT, text=' Corpus: ',
background=self._BACKGROUND_COLOUR, padx = 2, pady = 1, border = 0).pack(side='left')
other_corpora = self.model.CORPORA.keys().remove(self.model.DEFAULT_CORPUS)
om = OptionMenu(innerframe, self.var, self.model.DEFAULT_CORPUS, command=self.corpus_selected, *self.model.non_default_corpora())
om['borderwidth'] = 0
om['highlightthickness'] = 1
om.pack(side='left')
innerframe.pack(side='top', fill='x', anchor='n')
def _init_status(self, parent):
self.status = Label(parent, justify=LEFT, relief=SUNKEN, background=self._BACKGROUND_COLOUR, border=0, padx = 1, pady = 0)
self.status.pack(side='top', anchor='sw')
def _init_query_box(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
another = Frame(innerframe, background=self._BACKGROUND_COLOUR)
self.query_box = Entry(another, width=60)
self.query_box.pack(side='left', fill='x', pady=25, anchor='center')
self.search_button = Button(another, text='Search', command=self.search, borderwidth=1, highlightthickness=1)
self.search_button.pack(side='left', fill='x', pady=25, anchor='center')
self.query_box.bind('<KeyPress-Return>', self.search_enter_keypress_handler)
another.pack()
innerframe.pack(side='top', fill='x', anchor='n')
def search_enter_keypress_handler(self, *event):
self.search()
def _init_results_box(self, parent):
innerframe = Frame(parent)
i1 = Frame(innerframe)
i2 = Frame(innerframe)
vscrollbar = Scrollbar(i1, borderwidth=1)
hscrollbar = Scrollbar(i2, borderwidth=1, orient='horiz')
self.results_box = Text(i1,
font=tkFont.Font(family='courier', size='16'),
state='disabled', borderwidth=1,
yscrollcommand=vscrollbar.set,
xscrollcommand=hscrollbar.set, wrap='none', width='40', height = '20', exportselection=1)
self.results_box.pack(side='left', fill='both', expand=True)
self.results_box.tag_config(self._HIGHLIGHT_WORD_TAG, foreground=self._HIGHLIGHT_WORD_COLOUR)
self.results_box.tag_config(self._HIGHLIGHT_LABEL_TAG, foreground=self._HIGHLIGHT_LABEL_COLOUR)
vscrollbar.pack(side='left', fill='y', anchor='e')
vscrollbar.config(command=self.results_box.yview)
hscrollbar.pack(side='left', fill='x', expand=True, anchor='w')
hscrollbar.config(command=self.results_box.xview)
#there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
Label(i2, text=' ', background=self._BACKGROUND_COLOUR).pack(side='left', anchor='e')
i1.pack(side='top', fill='both', expand=True, anchor='n')
i2.pack(side='bottom', fill='x', anchor='s')
innerframe.pack(side='top', fill='both', expand=True)
def _init_paging(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.prev = prev = Button(innerframe, text='Previous', command=self.previous, width='10', borderwidth=1, highlightthickness=1, state='disabled')
prev.pack(side='left', anchor='center')
self.next = next = Button(innerframe, text='Next', command=self.next, width='10', borderwidth=1, highlightthickness=1, state='disabled')
next.pack(side='right', anchor='center')
innerframe.pack(side='top', fill='y')
self.current_page = 0
def previous(self):
self.clear_results_box()
self.freeze_editable()
self.model.prev(self.current_page - 1)
def next(self):
self.clear_results_box()
self.freeze_editable()
self.model.next(self.current_page + 1)
def about(self, *e):
ABOUT = ("NLTK Concordance Search Demo\n")
TITLE = 'About: NLTK Concordance Search Demo'
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE, parent=self.main_frame).show()
except:
ShowText(self.top, TITLE, ABOUT)
def _bind_event_handlers(self):
self.top.bind(CORPUS_LOADED_EVENT, self.handle_corpus_loaded)
self.top.bind(SEARCH_TERMINATED_EVENT, self.handle_search_terminated)
self.top.bind(SEARCH_ERROR_EVENT, self.handle_search_error)
self.top.bind(ERROR_LOADING_CORPUS_EVENT, self.handle_error_loading_corpus)
def handle_error_loading_corpus(self, event):
self.status['text'] = 'Error in loading ' + self.var.get()
self.unfreeze_editable()
self.clear_all()
self.freeze_editable()
def handle_corpus_loaded(self, event):
self.status['text'] = self.var.get() + ' is loaded'
self.unfreeze_editable()
self.clear_all()
self.query_box.focus_set()
def handle_search_terminated(self, event):
#todo: refactor the model such that it is less state sensitive
results = self.model.get_results()
self.write_results(results)
self.status['text'] = ''
if len(results) == 0:
self.status['text'] = 'No results found for ' + self.model.query
else:
self.current_page = self.model.last_requested_page
self.unfreeze_editable()
self.results_box.xview_moveto(self._FRACTION_LEFT_TEXT)
def handle_search_error(self, event):
self.status['text'] = 'Error in query ' + self.model.query
self.unfreeze_editable()
def corpus_selected(self, *args):
new_selection = self.var.get()
self.load_corpus(new_selection)
def load_corpus(self, selection):
if self.model.selected_corpus != selection:
self.status['text'] = 'Loading ' + selection + '...'
self.freeze_editable()
self.model.load_corpus(selection)
def search(self):
self.current_page = 0
self.clear_results_box()
self.model.reset_results()
query = self.query_box.get()
if (len(query.strip()) == 0): return
self.status['text'] = 'Searching for ' + query
self.freeze_editable()
self.model.search(query, self.current_page + 1, )
def write_results(self, results):
self.results_box['state'] = 'normal'
row = 1
for each in results:
sent, pos1, pos2 = each[0].strip(), each[1], each[2]
if len(sent) != 0:
if (pos1 < self._char_before):
sent, pos1, pos2 = self.pad(sent, pos1, pos2)
sentence = sent[pos1-self._char_before:pos1+self._char_after]
if not row == len(results):
sentence += '\n'
self.results_box.insert(str(row) + '.0', sentence)
word_markers, label_markers = self.words_and_labels(sent, pos1, pos2)
for marker in word_markers: self.results_box.tag_add(self._HIGHLIGHT_WORD_TAG, str(row) + '.' + str(marker[0]), str(row) + '.' + str(marker[1]))
for marker in label_markers: self.results_box.tag_add(self._HIGHLIGHT_LABEL_TAG, str(row) + '.' + str(marker[0]), str(row) + '.' + str(marker[1]))
row += 1
self.results_box['state'] = 'disabled'
def words_and_labels(self, sentence, pos1, pos2):
search_exp = sentence[pos1:pos2]
words, labels = [], []
labeled_words = search_exp.split(' ')
index = 0
for each in labeled_words:
if each == '':
index += 1
else:
word, label = each.split('/')
words.append((self._char_before + index, self._char_before + index + len(word)))
index += len(word) + 1
labels.append((self._char_before + index, self._char_before + index + len(label)))
index += len(label)
index += 1
return words, labels
def pad(self, sent, hstart, hend):
if hstart >= self._char_before:
return sent, hstart, hend
d = self._char_before - hstart
sent = ''.join([' '] * d) + sent
return sent, hstart + d, hend + d
def destroy(self, *e):
if self.top is None: return
self.top.destroy()
self.top = None
def clear_all(self):
self.query_box.delete(0, END)
self.model.reset_query()
self.clear_results_box()
def clear_results_box(self):
self.results_box['state'] = 'normal'
self.results_box.delete("1.0", END)
self.results_box['state'] = 'disabled'
def freeze_editable(self):
self.query_box['state'] = 'disabled'
self.search_button['state'] = 'disabled'
self.prev['state'] = 'disabled'
self.next['state'] = 'disabled'
def unfreeze_editable(self):
self.query_box['state'] = 'normal'
self.search_button['state'] = 'normal'
self.set_paging_button_states()
def set_paging_button_states(self):
if self.current_page == 0 or self.current_page == 1:
self.prev['state'] = 'disabled'
else:
self.prev['state'] = 'normal'
if self.model.has_more_pages(self.current_page):
self.next['state'] = 'normal'
else:
self.next['state'] = 'disabled'
def fire_event(self, event):
#Firing an event so that rendering of widgets happen in the mainloop thread
self.top.event_generate(event, when='tail')
def mainloop(self, *args, **kwargs):
if in_idle(): return
self.top.mainloop(*args, **kwargs)
