class filterswindow:
'''
Interface graphique recapitulant les caracteristique du sismogramme
presentant les options de filtrage et de calculs du noyau de sensibilite
'''
def __init__(self,racine):
self.canvas = Canvas(racine, borderwidth=1, background="#ffffff")
self.frame = Frame(self.canvas, background="#ffffff")
self.vsb = Scrollbar(racine, orient="vertical", command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.vsb.set)
self.vsb.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
self.canvas.create_window((4,4), window=self.frame, anchor="nw", tags="self.frame")
self.frame.bind("<Configure>", self.OnFrameConfigure)
self.data()
def data(self):
global filterVar
filterVar = 1
global text6a
text6a = "1"
global text6c1
text6c1 = StringVar()
global text6c2
text6c2 = StringVar()
global text6c3
text6c3 = StringVar()
Label(self.frame, text="Option Filter").grid(row=0)
Label(self.frame, text="\n").grid(row=1)
Label(self.frame, text="lowest frequency ?").grid(row=4)
e1 = Entry(self.frame, textvariable=text6c1)
e1.grid(row=5)
Label(self.frame, text="highest frequency ?").grid(row=20)
e2 = Entry(self.frame, textvariable=text6c2)
e2.grid(row=21)
Label(self.frame, text="number of poles ?").grid(row=22)
e3 = Entry(self.frame, textvariable=text6c3)
e3.grid(row=23)
Button(self.frame, text="continue", command=self.quitter).grid(row=24)
def quitter(self):
global racine
racine.destroy()
afficheSismoFiltre(textPath.get(), float(text6c1.get()), float(text6c2.get()), float(text6c3.get()))
def OnFrameConfigure(self, event):
'''Reset the scroll region to encompass the inner frame'''
self.canvas.configure(scrollregion=self.canvas.bbox("all"))
def __init__(self, filename, parentnotebook):
"""Create a new EditTab
Argument
filename -- name and path to the file being edited
parentnotebook -- the NoteBook in which this tab will be added
"""
Frame.__init__(self)
self._filename = filename
self._parentnotebook = parentnotebook
self._inputs = []
self.path = os.path.dirname(filename)
self._dirty = False
parentnotebook.add(self, state = 'normal')
self._setLabel()
#Set up GUI
self.rowconfigure(0, weight = 1)
self.columnconfigure(0, weight = 1)
vscroll = Scrollbar(self, orient = VERTICAL)
self._vscroll = vscroll
vscroll.grid(row=0, column=1, sticky=N+S)
hscroll = Scrollbar(self, orient = HORIZONTAL)
self._hscroll = hscroll
hscroll.grid(row=1, column=0, sticky=E+W)
canvas = Canvas(self, yscrollcommand = vscroll.set, xscrollcommand = hscroll.set)
self._canvas = canvas
canvas.grid(row = 0, column = 0, padx = 5, pady = 5, sticky = NSEW)
vscroll['command'] = canvas.yview
hscroll['command'] = canvas.xview
scrollframe = Frame(canvas)
self._scrollframe = scrollframe
canvas.create_window(0, 0, window = scrollframe, anchor = N + W)
scrollframe.rowconfigure(0, weight = 1)
scrollframe.columnconfigure(0, weight = 1)
self._mainframe = Frame(scrollframe)
self._mainframe.grid(row = 0, column = 0, padx = 5, pady = 5, sticky = NSEW)
cf = Frame(scrollframe)
self._control_frame = cf
cf.grid(row = 1, column = 0, padx = 5, pady = 5, sticky = E)
b = Button(cf, text = lang[lng.txtCopyImages], command = self._ehCopyImages)
self._btnCopy = b
b.grid(row = 0, column = 0, padx = 5, pady = 5)
b = Button(cf, text = lang[lng.txtSave], command = self._ehSave, state = DISABLED)
self._btnSave = b
b.grid(row = 0, column = 1, padx = 5, pady = 5)
b = Button(cf, text = lang[lng.txtClose], command = self._ehClose)
b.grid(row = 0, column = 2, padx = 5, pady = 5)
parentnotebook.after_idle(self._setCanvas)
def init_ui(self):
self.rowconfigure(3, weight=1)
self.columnconfigure(0, weight=1)
self.button_load_type = Button(self, text="Load Type JSON", command=lambda: browse_file(self, 1, ))
self.button_load_type.grid(
row=0, columnspan=2, sticky=W + E, pady=4, padx=5)
self.button_load_color = Button(
self, text="Load Color JSON", command=lambda: browse_file(self, 2))
self.button_load_color.grid(
row=1, columnspan=2, sticky=W + E, pady=4, padx=5)
button_load = Button(
self, text="Load Images", command=lambda: browse_images(self))
button_load.grid(row=2, columnspan=2, sticky=W + E, pady=4, padx=5)
button_learn = Button(
self,
text="Test",
command=
lambda: start_testing(self.dtype, self.dcolor, self.picture_frames)
)
button_learn.grid(row=4, columnspan=2, sticky=W + E, pady=4, padx=5)
canvas = Canvas(self)
canvas.grid(row=3, sticky=W + E + N + S, column=0, pady=4, padx=5)
frame = self.picture_frame = Frame(canvas)
canvas.create_window(0, 0, window=frame, anchor='nw')
scroll_bar = Scrollbar(self, orient="vertical", command=canvas.yview)
scroll_bar.grid(sticky=E + N + S, padx=5, row=3, column=1)
canvas.configure(yscrollcommand=scroll_bar.set)
# track changes to the canvas and frame width and sync them,
# also updating the scrollbar
def _configure_interior(event):
# update the scrollbars to match the size of the inner frame
size = (frame.winfo_reqwidth(), frame.winfo_reqheight())
canvas.config(scrollregion="0 0 %s %s" % size)
if frame.winfo_reqwidth() != canvas.winfo_width():
# update the canvas's width to fit the inner frame
canvas.config(width=frame.winfo_reqwidth())
frame.bind('<Configure>', _configure_interior)
def _configure_canvas(event):
if frame.winfo_reqwidth() != canvas.winfo_width():
# update the inner frame's width to fill the canvas
canvas.itemconfigure(frame, width=canvas.winfo_width())
canvas.bind('<Configure>', _configure_canvas)
class StartFrame(Frame):
"""Class which controls start screen of spelling aid"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
#Create UI elements
self.start_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.start_canvas.pack()
buttonStart = Button(self, text="Start", width=10,
command=self.start)
buttonEdit = Button(self, text="Edit Lists",
command=self.parent.show_editor)
self.list_menu_var = StringVar(self)
self.list_menu_var.set("Random List")
self.start_canvas.create_window(300, 200, window=buttonStart)
self.menu = self.start_canvas.create_window(300, 150)
self.start_canvas.create_window(520, 230, window=buttonEdit)
self.start_canvas.create_text(300, 100, font=("Helvetica", 25),
text="Select a list:")
self.update_list()
self.update()
def start(self):
"""Start the game with the selected list"""
self.parent.start_game(self.selected_list)
def update(self, event=None):
"""Change the current list to match selection"""
list_name = self.list_menu_var.get()
for word_list in self.parent.list_list:
if word_list.name == list_name:
self.selected_list = word_list
def update_list(self):
"""Refreshes the list of lists"""
list_menu = OptionMenu(self, self.list_menu_var,
*self.parent.list_list, command=self.update)
list_menu.configure(width=30)
self.start_canvas.itemconfig(self.menu, window=list_menu)
def welcomeMessage(self):
"""Show the welcome message"""
self.start_canvas.create_text((10, 10), anchor=NW, text="Welcome, %s."
%(self.parent.user.username),
font=("Helvetica", 15))
class RecapCalculs:
'''
Interface graphique recapitulant les caracteristique du sismogramme
presentant les options de filtrage et de calculs du noyau de sensibilite
'''
def __init__(self,root):
self.canvas = Canvas(root, borderwidth=1, background="#ffffff")
self.frame = Frame(self.canvas, background="#ffffff")
self.vsb = Scrollbar(root, orient="vertical", command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.vsb.set)
self.vsb.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
self.canvas.create_window((4,4), window=self.frame, anchor="nw", tags="self.frame")
self.frame.bind("<Configure>", self.OnFrameConfigure)
self.data()
def data(self):
self.message = Label(self.frame, text="Recapitulatif du sismogramme").grid(row=0)
global X
X=read(textPath.get())
self.recap = Listbox(self.frame, height = 15, width = 50)
self.recap.insert(1, "network: {}\n".format(X[0].stats.network))
self.recap.insert(2, "station: {}\n".format(X[0].stats.station))
self.recap.insert(3, "location: {}\n".format(X[0].stats.location))
self.recap.insert(4, "channel: {}\n".format(X[0].stats.channel))
self.recap.insert(5, "start time: {}\n".format(X[0].stats.starttime))
self.recap.insert(6, "end time: {}\n".format(X[0].stats.endtime))
self.recap.insert(7, "sampling rate: {}\n".format(X[0].stats.sampling_rate))
self.recap.insert(8, "delta: {}\n".format(X[0].stats.delta))
self.recap.insert(9, "number points: {}\n".format(X[0].stats.npts))
self.recap.insert(10, "calibration: {}\n".format(X[0].stats.calib))
self.recap.insert(11, "event latitude: {}\n".format(X[0].stats.sac.evla))
self.recap.insert(12, "event longitude: {}\n".format(X[0].stats.sac.evlo))
self.recap.insert(13, "event depth: {}\n".format(X[0].stats.sac.evdp))
self.recap.insert(14, "station latitude: {}\n".format(X[0].stats.sac.stla))
self.recap.insert(15, "station longitude: {}\n".format(X[0].stats.sac.stlo))
self.recap.grid(row=0)
#afficheGraphique()
def OnFrameConfigure(self, event):
'''Reset the scroll region to encompass the inner frame'''
self.canvas.configure(scrollregion=self.canvas.bbox("all"))
def addScrollingFigure(figure, frame):
global canvas, mplCanvas, interior, interior_id, cwid
# set up a canvas with scrollbars
canvas = Canvas(frame)
canvas.grid(row=1, column=1, sticky=Tkconstants.NSEW)
xScrollbar = Scrollbar(frame, orient=Tkconstants.HORIZONTAL)
yScrollbar = Scrollbar(frame)
xScrollbar.grid(row=2, column=1, sticky=Tkconstants.EW)
yScrollbar.grid(row=1, column=2, sticky=Tkconstants.NS)
canvas.config(xscrollcommand=xScrollbar.set)
xScrollbar.config(command=canvas.xview)
canvas.config(yscrollcommand=yScrollbar.set)
yScrollbar.config(command=canvas.yview)
# plug in the figure
figAgg = FigureCanvasTkAgg(figure, canvas)
mplCanvas = figAgg.get_tk_widget()
# and connect figure with scrolling region
cwid = canvas.create_window(0, 0, window=mplCanvas, anchor=Tkconstants.NW)
printBboxes("Init")
changeSize(figure, 1)
def __init__(self, parent, *args, **kw):
Frame.__init__(self, parent, *args, **kw)
vscrollbar = Scrollbar(self, orient=VERTICAL)
vscrollbar.pack(fill=Y, side=RIGHT, expand=FALSE)
canvas = Canvas(
self, bd=0, highlightthickness=0, yscrollcommand=vscrollbar.set)
canvas.pack(side=LEFT, fill=BOTH, expand=TRUE)
vscrollbar.config(command=canvas.yview)
canvas.xview_moveto(0)
canvas.yview_moveto(0)
self.interior = interior = Frame(canvas)
interior_id = canvas.create_window(0, 0, window=interior, anchor=NW)
self.canv = canvas # @UndefinedVariable
self.scroller = vscrollbar
def _configure_interior(event):
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
canvas.config(scrollregion="0 0 %s %s" % size)
if interior.winfo_reqwidth() != canvas.winfo_width():
canvas.config(width=interior.winfo_reqwidth())
interior.bind('<Configure>', _configure_interior)
def _configure_canvas(event):
if interior.winfo_reqwidth() != canvas.winfo_width():
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
canvas.bind('<Configure>', _configure_canvas)
class ScrolledCanvas(Frame):
"""
A scrolling canvas of frames with checkboxes.
"""
def __init__(self, master, name=None, scrollregion=(0, 0, '5i', '5i'),
items=[], window_size=[160, 30], **canvaskw):
Frame.__init__(self, master, name=name)
self.scrollcanvas = Canvas(self, name='scrollcanvas',
scrollregion=scrollregion, **canvaskw)
self.yscroll = Scrollbar(self, name='yscroll',
command=self.scrollcanvas.yview)
self.scrollcanvas['yscrollcommand'] = self.yscroll.set
self.yscroll.pack(side=RIGHT, fill=Y)
self.scrollcanvas.pack(side=LEFT, fill=BOTH, expand=YES)
self.items = dict.fromkeys(items)
for n, i in enumerate(items):
self.items[i] = {'frame': Frame(self, name=(i.lower() + '_frame'))}
self.items[i]['frame'].config(relief=GROOVE, padding=5)
self.items[i]['chbx'] = Checkbutton(self.items[i]['frame'],
name=(i.lower() + '_chbx'))
self.items[i]['chbx']['text'] = i
self.items[i]['chbx'].pack(side=LEFT, fill=X)
y = window_size[1] / 2 + window_size[1] * n
self.items[i]['window'] = self.scrollcanvas.create_window(0, y)
self.scrollcanvas.itemconfigure(self.items[i]['window'],
window=self.items[i]['frame'],
anchor=W, width=window_size[0],
height=window_size[1])
def __init__(self, parent, *args, **kw):
Frame.__init__(self, parent, *args, **kw)
vscrollbar = Scrollbar(self, orient=VERTICAL)
vscrollbar.pack(fill=Y, side=RIGHT, expand=FALSE)
canvas = Canvas(self,
bd=0,
highlightthickness=0,
yscrollcommand=vscrollbar.set)
canvas.pack(side=LEFT, fill=BOTH, expand=TRUE)
vscrollbar.config(command=canvas.yview)
canvas.xview_moveto(0)
canvas.yview_moveto(0)
self.interior = interior = Frame(canvas)
interior_id = canvas.create_window(0, 0, window=interior, anchor=NW)
self.canv = canvas # @UndefinedVariable
self.scroller = vscrollbar
def _configure_interior(event):
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
canvas.config(scrollregion="0 0 %s %s" % size)
if interior.winfo_reqwidth() != canvas.winfo_width():
canvas.config(width=interior.winfo_reqwidth())
interior.bind('<Configure>', _configure_interior)
def _configure_canvas(event):
if interior.winfo_reqwidth() != canvas.winfo_width():
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
canvas.bind('<Configure>', _configure_canvas)
def __init__(self, parent, *args, **kw):
Frame.__init__(self, parent, *args, **kw)
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient=Tkinter.VERTICAL)
vscrollbar.pack(fill=Tkinter.Y,
side=Tkinter.RIGHT,
expand=Tkinter.FALSE)
hscrollbar = Scrollbar(self, orient=Tkinter.HORIZONTAL)
hscrollbar.pack(fill=Tkinter.X,
side=Tkinter.BOTTOM,
expand=Tkinter.FALSE)
canvas = Canvas(self,
bd=0,
highlightthickness=0,
yscrollcommand=vscrollbar.set,
xscrollcommand=hscrollbar.set)
canvas.pack(side=Tkinter.LEFT, fill=Tkinter.BOTH, expand=Tkinter.TRUE)
vscrollbar.config(command=canvas.yview)
hscrollbar.config(command=canvas.xview)
# reset the view
canvas.xview_moveto(0)
canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(canvas)
interior_id = canvas.create_window(0,
0,
window=interior,
anchor=Tkinter.NW)
# track changes to the canvas and frame width and sync them,
# also updating the scrollbar
def _configure_interior(event):
'''
update the scrollbars to match the size of the inner frame
'''
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
canvas.config(scrollregion='0 0 %s %s' % size)
if interior.winfo_reqwidth() != canvas.winfo_width():
# update the canvas's width to fit the inner frame
canvas.config(width=interior.winfo_reqwidth())
interior.bind('<Configure>', _configure_interior)
def _configure_canvas(event):
'''
_configure_canvas is used to resize the window size to fit content.
Can be used when changing window.
'''
if interior.winfo_reqwidth() != canvas.winfo_width():
# update the inner frame's width to fill the canvas
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
def __init__(self, parent, *args, **kw):
Frame.__init__(self, parent, *args, **kw)
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient=VERTICAL)
vscrollbar.pack(fill=Y, side=RIGHT, expand=FALSE)
canvas = Canvas(self, bd=0, highlightthickness=0,
yscrollcommand=vscrollbar.set)
canvas.pack(side=LEFT, fill=BOTH, expand=TRUE)
vscrollbar.config(command=canvas.yview)
# reset the view
canvas.xview_moveto(0)
canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(canvas)
interior_id = canvas.create_window(0, 0, window=interior,
anchor=NW)
# track changes to the canvas and frame width and sync them,
# also updating the scrollbar
def _configure_interior(event=None):
# update the scrollbars to match the size of the inner frame
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
canvas.config(scrollregion="0 0 %s %s" % size)
if interior.winfo_reqwidth() != canvas.winfo_width():
# update the canvas's width to fit the inner frame
canvas.config(width=interior.winfo_reqwidth())
interior.bind('<Configure>', _configure_interior)
def _configure_canvas(event=None):
if interior.winfo_reqwidth() != canvas.winfo_width():
# update the inner frame's width to fill the canvas
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
canvas.bind('<Configure>', _configure_canvas)
def __init__(self, parent):
master = Frame(parent, bg = 'green')
master.grid(sticky = W + N + E + S)
master.rowconfigure(0, weight = 1)
master.columnconfigure(0, weight = 1)
canvas = Canvas(master)
self._canvas = canvas
canvas.grid(row = 0, column = 0, sticky = W + N + E + S)
hScroll = Scrollbar(master, orient = HORIZONTAL, command = canvas.xview)
hScroll.grid(row = 1, column = 0, sticky = W + E)
vScroll = Scrollbar(master, orient = VERTICAL, command = canvas.yview)
vScroll.grid(row = 0, column = 1, sticky = N + S)
canvas.configure(xscrollcommand = hScroll.set, yscrollcommand = vScroll.set)
Frame.__init__(self, canvas, bg = 'blue')
canvas.create_window(0, 0, window = self, anchor = N + W)
class StartFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.start_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.start_canvas.pack()
buttonStart = Button(self, text="Start", width=10,
command=self.start)
buttonEdit = Button(self, text="Edit Lists",
command=self.parent.show_editor)
self.list_menu_var = StringVar(self)
self.list_menu_var.set("Random List")
self.start_canvas.create_window(300, 200, window=buttonStart)
self.menu = self.start_canvas.create_window(300, 150)
self.start_canvas.create_window(520, 230, window=buttonEdit)
self.start_canvas.create_text(300, 100, font=("Helvetica", 25),
text="Select a list:")
self.update_list()
self.update()
def start(self):
self.parent.start_game(self.selected_list)
def update(self, event=None):
list_name = self.list_menu_var.get()
for word_list in self.parent.list_list:
if word_list.name == list_name:
self.selected_list = word_list
def update_list(self):
list_menu = OptionMenu(self, self.list_menu_var,
*self.parent.list_list, command=self.update)
list_menu.configure(width=30)
self.start_canvas.itemconfig(self.menu, window=list_menu)
def welcomeMessage(self):
self.start_canvas.create_text((10, 10), anchor=NW, text="Welcome, %s."
%(self.parent.user.username),
font=("Helvetica", 15))
def StartUI():
def close_window():
# print(entry.get())
name = entry.get()
data = {"Name": name}
pickle.dump
file = open("Name.txt", 'wb')
pickle.dump(data, file)
root.destroy()
# quit()
root = Tk()
# quit()
entry_pady = 9
height_text = 5
photoimage2 = ImageTk.PhotoImage(file='pops.png')
root.title('Harp')
canvas = Canvas(root,
width=600,
height=500,
bg="Green",
bd="0",
highlightthickness=0,
relief='ridge')
canvas.create_image((0, 0), image=photoimage2, anchor="nw")
canvas.pack()
root.geometry("+250+250")
root.overrideredirect(True)
root.wm_attributes("-transparentcolor", "Green")
root.lift()
entry = Entry(canvas, background="white")
button = Button(canvas,
background="white",
text="Submit",
command=close_window)
canvas.create_window((125, 40 + height_text + entry_pady + 90),
window=entry,
anchor="nw")
canvas.create_window((265, 40 + height_text + entry_pady + 85),
window=button,
anchor="nw")
root.mainloop()
def run():
"""
Esegue l'emulatore del pdp8
"""
CD = pdp8()
principale = Tk()
principale.title("Pdp8 Emulator : Assembly Editor")
emulatore = Toplevel()
emulatore.title("Pdp8 Emulator")
emulatore.geometry("1015x589")
edit = Editor(principale, CD)
scrollbar1 = AutoScrollbar(emulatore)
scrollbar1.grid(row=0, column=1, sticky=N + S)
scrollbar2 = AutoScrollbar(emulatore, orient=HORIZONTAL)
scrollbar2.grid(row=1, column=0, sticky=E + W)
finestra = Canvas(emulatore,
yscrollcommand=scrollbar1.set,
xscrollcommand=scrollbar2.set)
finestra.grid(row=0, column=0, sticky=N + S + E + W)
scrollbar1.config(command=finestra.yview)
scrollbar2.config(command=finestra.xview)
emulatore.grid_rowconfigure(0, weight=1)
emulatore.grid_columnconfigure(0, weight=1)
emul = Emulatore(finestra, edit, CD, emulatore)
finestra.create_window(0, 0, anchor=NW, window=emul.master)
emul.master.update_idletasks()
finestra.config(scrollregion=finestra.bbox("all"))
principale.protocol("WM_DELETE_WINDOW", edit.exit)
emulatore.protocol("WM_DELETE_WINDOW", emul.exit)
principale.mainloop()
emulatore.mainloop()
def run():
"""
Esegue l'emulatore del pdp8
"""
CD = pdp8()
principale = Tk()
principale.title("Pdp8 Emulator : Assembly Editor")
emulatore = Toplevel()
emulatore.title("Pdp8 Emulator")
emulatore.geometry("1015x589")
edit = Editor(principale, CD)
scrollbar1 = AutoScrollbar(emulatore)
scrollbar1.grid(row=0, column=1, sticky=N + S)
scrollbar2 = AutoScrollbar(emulatore, orient=HORIZONTAL)
scrollbar2.grid(row=1, column=0, sticky=E + W)
finestra = Canvas(emulatore,
yscrollcommand=scrollbar1.set,
xscrollcommand=scrollbar2.set)
finestra.grid(row=0, column=0, sticky=N + S + E + W)
scrollbar1.config(command=finestra.yview)
scrollbar2.config(command=finestra.xview)
emulatore.grid_rowconfigure(0, weight=1)
emulatore.grid_columnconfigure(0, weight=1)
emul = Emulatore(finestra, edit, CD, emulatore)
finestra.create_window(0, 0, anchor=NW, window=emul.master)
emul.master.update_idletasks()
finestra.config(scrollregion=finestra.bbox("all"))
principale.protocol("WM_DELETE_WINDOW", edit.exit)
emulatore.protocol("WM_DELETE_WINDOW", emul.exit)
principale.mainloop()
emulatore.mainloop()
def __init__(self, parent, *args, **kw):
Frame.__init__(self, parent, *args, **kw)
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient=Tkinter.VERTICAL)
vscrollbar.pack(fill=Tkinter.Y, side=Tkinter.RIGHT, expand=Tkinter.FALSE)
hscrollbar = Scrollbar(self, orient=Tkinter.HORIZONTAL)
hscrollbar.pack(fill=Tkinter.X, side=Tkinter.BOTTOM, expand=Tkinter.FALSE)
canvas = Canvas(self, bd=0, highlightthickness=0,
yscrollcommand=vscrollbar.set, xscrollcommand=hscrollbar.set)
canvas.pack(side=Tkinter.LEFT, fill=Tkinter.BOTH, expand=Tkinter.TRUE)
vscrollbar.config(command=canvas.yview)
hscrollbar.config(command=canvas.xview)
# reset the view
canvas.xview_moveto(0)
canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(canvas)
interior_id = canvas.create_window(0, 0, window=interior, anchor=Tkinter.NW)
# track changes to the canvas and frame width and sync them,
# also updating the scrollbar
def _configure_interior(event):
'''
update the scrollbars to match the size of the inner frame
'''
size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
canvas.config(scrollregion='0 0 %s %s' % size)
if interior.winfo_reqwidth() != canvas.winfo_width():
# update the canvas's width to fit the inner frame
canvas.config(width=interior.winfo_reqwidth())
interior.bind('<Configure>', _configure_interior)
def _configure_canvas(event):
'''
_configure_canvas is used to resize the window size to fit content.
Can be used when changing window.
'''
if interior.winfo_reqwidth() != canvas.winfo_width():
# update the inner frame's width to fill the canvas
canvas.itemconfigure(interior_id, width=canvas.winfo_width())
class MixerFrame(Frame):
def __init__(self, master, mixer):
Frame.__init__(self, master)
scrollbar_h = Scrollbar(self, orient='horizontal')
scrollbar_v = Scrollbar(self, orient='vertical')
self.canvas = Canvas(self,
background='gray',
scrollregion=(0, 0, (3 + len(mixer) * FADER_WIDTH), FADER_HEIGHT),
yscrollcommand=scrollbar_v.set,
xscrollcommand=scrollbar_h.set)
scrollbar_v.config(command=self.canvas.yview)
scrollbar_h.config(command=self.canvas.xview)
master.bind("<MouseWheel>",
lambda e: self.canvas.yview_scroll(-e.delta, 'units'))
master.bind("<Shift-MouseWheel>",
lambda e: self.canvas.xview_scroll(-e.delta, 'units'))
Sizegrip(self).grid(column=2, row=1, sticky='se')
self.canvas.grid(column=0, row=0, sticky='nwes')
scrollbar_h.grid(column=0, row=1, sticky='we')
scrollbar_v.grid(column=1, row=0, sticky='sn')
master_fader = AudioFader(self, mixer.getVolume, mixer.setVolume, "Master")
master_fader.grid(column=2, row=0, sticky='nwes')
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
for i, channel in enumerate(mixer):
if channel.device.id_variable is not None:
name = channel.device.id_variable
else:
name = channel.device.name_id
fader = AudioFader(self.canvas, channel.get_gain, channel.set_gain, name)
self.canvas.create_window(i * FADER_WIDTH, 0, anchor='nw', window=fader)
class VerticalScrolledFrame(Frame):
"""A pure Tkinter scrollable frame that actually works!
* Use the 'interior' attribute to place widgets inside the scrollable frame
* Construct and pack/place/grid normally
* This frame only allows vertical scrolling
"""
def _configure_interior(self, event):
# update the scrollbars to match the size of the inner frame
size = (self.interior.winfo_reqwidth(),
self.interior.winfo_reqheight())
self.canvas.config(scrollregion="0 0 %s %s" % size)
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the canvas's width to fit the inner frame
self.canvas.config(width=self.interior.winfo_reqwidth())
self.interior.bind('<Configure>', _configure_interior)
def _configure_canvas(self, event):
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the inner frame's width to fill the canvas
self.canvas.itemconfigure(self.interior_id,
width=self.canvas.winfo_width())
self.canvas.bind('<Configure>', _configure_canvas)
return
def configure_scrolling(self):
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient='vertical')
vscrollbar.grid(row=0, column=1, sticky='nsw')
self.canvas = Canvas(self,
bd=0,
highlightthickness=0,
yscrollcommand=vscrollbar.set)
self.canvas.grid(row=0, column=0, sticky='nsew')
vscrollbar.config(command=self.canvas.yview)
# reset the view
self.canvas.xview_moveto(0)
self.canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(self.canvas)
self.interior.grid(row=0, column=0, sticky='nsew')
self.interior_id = self.canvas.create_window(0,
0,
window=interior,
anchor='nw')
class VerticalScrolledFrame(Frame):
"""A pure Tkinter scrollable frame that actually works!
* Use the 'interior' attribute to place widgets inside the scrollable frame
* Construct and pack/place/grid normally
* This frame only allows vertical scrolling
"""
def _configure_interior(self,event):
# update the scrollbars to match the size of the inner frame
size = (self.interior.winfo_reqwidth(), self.interior.winfo_reqheight())
self.canvas.config(scrollregion="0 0 %s %s" % size)
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the canvas's width to fit the inner frame
self.canvas.config(width=self.interior.winfo_reqwidth())
self.interior.bind('<Configure>', _configure_interior)
def _configure_canvas(self,event):
if self.interior.winfo_reqwidth() != self.canvas.winfo_width():
# update the inner frame's width to fill the canvas
self.canvas.itemconfigure(self.interior_id, width=self.canvas.winfo_width())
self.canvas.bind('<Configure>', _configure_canvas)
return
def configure_scrolling(self):
# create a canvas object and a vertical scrollbar for scrolling it
vscrollbar = Scrollbar(self, orient='vertical')
vscrollbar.grid(row=0,column=1,sticky='nsw')
self.canvas = Canvas(self, bd=0, highlightthickness=0,
yscrollcommand=vscrollbar.set)
self.canvas.grid(row=0,column=0,sticky='nsew')
vscrollbar.config(command=self.canvas.yview)
# reset the view
self.canvas.xview_moveto(0)
self.canvas.yview_moveto(0)
# create a frame inside the canvas which will be scrolled with it
self.interior = interior = Frame(self.canvas)
self.interior.grid(row=0,column=0,sticky='nsew')
self.interior_id = self.canvas.create_window(0, 0, window=interior,
anchor='nw')
def __init__(self):
self.dimx = 0
self.dimy = 0
self.popup_dim = Tk()
self.popup_dim.title("Dimensions")
center(self.popup_dim, 200, 120)
self.popup_dim.resizable(False, False)
canvas = Canvas(self.popup_dim, width=200, height=120, bg="#eff")
dimx = Entry(self.popup_dim, width=5, relief="raised")
dimy = Entry(self.popup_dim, width=5, relief="raised")
ok = Button(self.popup_dim, text="OK",
command=lambda: self.setrootdimension(dimx.get(), dimy.get()),
width=1, font="../font/myfont 6 bold", fg="#eee")
canvas.create_window(100, 30, window=dimx)
canvas.create_text(65, 30, text="X=")
canvas.create_window(100, 60, window=dimy)
canvas.create_text(65, 60, text="Y=")
canvas.create_window(100, 85, window=ok)
canvas.pack()
class GetRoot:
def __init__(self, root, dimx, dimy):
self.root = root
self.root.title("Projet Python DIC1")
center(self.root, dimx, dimy)
self.dimx = dimx
self.dimy = dimy
self.canvas = Canvas(self.root, width=self.dimx, height=self.dimy, bg="#eee")
def root_fermer(self):
if askyesno('Confirmer la fermeture', 'Êtes-vous sûr de vouloir quitter?'):
self.root.quit()
def clear_root(self):
for w in self.root.winfo_children():
w.destroy()
def presentation(self):
self.canvas.create_text(self.dimx / 2, self.dimy / 2, text="Mamour Tall - Cheikh Tidiane Diop")
self.canvas.pack()
def navigation(self):
bouton_effacer = Button(self.root, text="Effacer", relief="raised", font="/font/myfont 8 bold",
command=lambda: self.clear_root,
bg="#eee", fg="black", activebackground="#dcc")
bouton_prec = Button(self.root, text="Precedent", relief="raised", font="/font/myfont 8 bold",
command="",
bg="#eee", fg="black", activebackground="#dcc")
bouton_quitt = Button(self.root, text="Quitter", command=self.root_fermer, relief="raised",
font="/font/myfont 8 bold",
bg="#eee",
fg="black", activebackground="#dcc")
bouton_effacer.pack()
bouton_prec.pack()
bouton_quitt.pack()
self.canvas.create_window(self.dimx / 2 + 18, self.dimy - 20, window=bouton_effacer)
self.canvas.create_window(60, self.dimy - 20, window=bouton_prec)
self.canvas.create_window(self.dimx - 40, self.dimy - 20, window=bouton_quitt)
def draw_board(root):
"""
Create the graphical user interface.
"""
# provide the title that will be shown in the header
root.title("Mastermind")
# Indicate which variables of the program will be altered
# ! In order to manipulate variables that are part of the program
# ! but exist outside of the function, you need to indicate that you want
# ! to use and alter these variables by declaring them as "global"
global canvas, ovals, matching_position_label, correct_color_label
# canvas will be the main board used for mastermind
# ! to create a canvas, the constructor is called
# ! (i.e. name of the class and required parameters)
canvas = Canvas(root, bg="white", height=MAX_NUMBER_OF_MOVES*40+170, width=NUMBER_OF_CIRCLES*50+100)
# Draw the empty circles representing the guesses
ovals = MasterMindAsked.create_empty_circles(canvas, NUMBER_OF_CIRCLES, MAX_NUMBER_OF_MOVES)
# Draw a line to separate the circles form the buttons
canvas.create_line(NUMBER_OF_CIRCLES*50, 10, NUMBER_OF_CIRCLES*50, 400, width=3, fill="black")
# Draw the color buttons that will be used throughout the game
# ! Every available color (listed here as strings in the global variable
# ! ALL_COLORS) is represented in the GUI by a button
# ! when the user clicks the button the function color(color_name)
# ! is called
for i in range(len(ALL_COLORS)):
canvas.create_window(NUMBER_OF_CIRCLES*50+10, 20+i*45, anchor=NW, window=Button(canvas, command=lambda color_name=ALL_COLORS[i]: color(color_name), width=5, text=ALL_COLORS[i]))
# Draw the result labels
# ! matching_position_label and correct_color_label can be used later on
# ! to show the user the number of correct positions and colors
# ! (e.g. matching_position_label["text"] = "2")
canvas.create_window(50, MAX_NUMBER_OF_MOVES*40+30, anchor=NW,
window=Label(canvas, text="Correct position: "))
matching_position_label = Label(canvas)
canvas.create_window(200, MAX_NUMBER_OF_MOVES*40+30, anchor=NW, window=matching_position_label)
canvas.create_window(50, MAX_NUMBER_OF_MOVES*40+60, anchor=NW,
window=Label(canvas, text="Correct color: "))
correct_color_label = Label(canvas)
canvas.create_window(200, MAX_NUMBER_OF_MOVES*40+60, anchor=NW, window=correct_color_label)
# Draw the submit button
# ! when the user clicks the button,
# ! the function check_combination is called
submit_button = Button(canvas, text="Check", command=check_combination)
submit_button.configure(width=10, relief=FLAT)
canvas.create_window(50, MAX_NUMBER_OF_MOVES*40+90, anchor=NW, window=submit_button)
# Draw the quit button
quit_button = Button(canvas, text="Quit", command=root.destroy)
quit_button.configure(width=5, relief=FLAT)
canvas.create_window(200, MAX_NUMBER_OF_MOVES*40+130, anchor=NW, window=quit_button)
# draw the canvas
canvas.pack()
def initialize(self):
#create canvas with specified size and add
w = Canvas(self, width=700, height=600)
w.pack()
#Declare two lists, one for front labels, anthoer for answer labels
self.flabels = []
self.alabels = []
#Define x and y cordinates for lables
self.flblx = 280
self.flbly = 40
self.alblx = 380
self.albly = 40
#Dummy list1
self.my_list = []
#Text to set on front lables
self.str_label = ['POTI0', 'POTI1','POTI2','POTI3','POTI4']
#Trigger to check if we want to program or pause
self.running = True
#Define environment varibales for input text fields
#We can change/update this during runtime
self.entry_pot_var = Tkinter.StringVar()
self.entry_res_var = Tkinter.StringVar()
#Define text areas for input onr for poti selection and one for resistence value
self.entry_pot = Entry(self,textvariable=self.entry_pot_var, validate="focusout")
self.entry_res = Entry(self,textvariable=self.entry_res_var, validate="focusout")
#Initial text to display on above text fields
self.entry_pot_var.set("Enter Pot selection")
self.entry_res_var.set("Enter resistor value - 2000 to 100000")
#Set pot selection entry as highlighted
self.entry_pot.selection_range(0,Tkinter.END)
#self.entry_res.selection_range(0,Tkinter.END)
#Set keyboard focus on pot text field
self.entry_pot.focus_set()
#Add pot text field to canvas
self.entry_pot.pack()
#ToDO
#validate input for pot selection
#self.entry_pot["validatecommand"] = (self.register(self.check_pot), "%P")
#Add resistence text field to canvas
self.entry_res.pack()
#Create two text on the canvas with x and y coodrinates
w.create_window(120, 40, window=self.entry_pot)
w.create_window(120, 70,window=self.entry_res)
#We declare 5 front lables and add them to canvas with x and y co ordinates
for x in range(5):
print self.str_label[x]
self.label = Label(self, text=self.str_label[x], fg='white', bg='black')
self.label.pack()
self.flabels.append(self.label)
#We declare 5 answer lables and add them to canvas with x and y co ordinates
for x in range(5):
self.label = Label(self, text='values', fg='white', bg='blue')
self.label.pack()
self.alabels.append(self.label)
#Create front label in canvas
for label in self.flabels:
w.create_window(self.flblx,self.flbly,window=label)
self.flbly = self.flbly + 19
#Create answer label in cavas
for label in self.alabels:
w.create_window(self.alblx,self.albly,window=label)
self.albly = self.albly + 20
###
#Button definitions
###
#Start button, and add callback to start_app function when this button is clicked
self.start_button = Button(self, text="Set", height=2, width=10, command=self.start_app)
self.start_button.pack()
#Clear button, and add callback to clear_app function when this button is clicked
self.clear_button = Button(self, text="Clear", height=2, width=10, command=self.clear_app, state="disabled")
self.clear_button.pack()
#Clear button, and add quit function of tkinter master when this button is clicked
self.close_button = Button(self, text="Close", height=2, width=10, command=self.quit)
self.close_button.pack()
#Add buttons to canvas
w.create_window(70, 170, window=self.start_button)
w.create_window(190, 170, window=self.close_button)
w.create_window(310, 170, window=self.clear_button)
photoimage = ImageTk.PhotoImage(image)
Label(root, image=photoimage).place(x=0, y=0)
entry_pady = 7
Entry(root, background="white").place(x=text_x,
y=text_y + height_text + entry_pady)
###################################################
# Another example
toplevel = Toplevel(root)
toplevel.resizable(width=False, height=False)
image_file = io.BytesIO(base64.b64decode(BASE64_BACKGROUND))
image = Image.open(image_file)
photoimage2 = ImageTk.PhotoImage(image)
canvas = Canvas(toplevel, width=width, height=height)
canvas.create_image((0, 0), image=photoimage2, anchor="nw")
canvas.create_text((text_x, text_y), text=text, fill="white", anchor="nw")
canvas.pack()
entry = Entry(canvas, background="white")
canvas.create_window((text_x, text_y + height_text + entry_pady),
window=entry,
anchor="nw")
root.mainloop()
class LoginFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.db = self.parent.db
font = ("Helvetica", 20)
self.userEntry = Entry(self.parent, width=15, font=font)
self.passEntry = Entry(self.parent, width=15, show='*', font=font)
self.passEntry.bind('<Return>', self.login)
buttonSubmit = Button(self.parent, text="Login", command=self.login, width=10)
buttonRegSwitch = Button(self.parent, text="New User",
command=self.viewRegister, width=10)
self.userRegEntry = Entry(self.parent, width=15, font=font)
self.passRegEntry = Entry(self.parent, width=15, show='*',
font=font)
self.passRegEntry.bind('<Return>', self.register)
buttonRegister = Button(self.parent, text="Register",
command=self.register, width=10)
buttonBack = Button(self.parent, text="Back",
command=self.viewLogin, width=10)
self.login_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.register_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.login_canvas.create_text(300, 40, text="Login", font=font, fill="#004183")
self.login_canvas.create_text(170, 80, text="Username:"******"Password:"******"Register", font=font, fill="#004183")
self.register_canvas.create_text(170, 80, text="Username:"******"Password:"******"""SELECT * FROM
users WHERE username='******'"""
%(usernameGiven.lower().strip()))
if len(userDetails)==1:
passHash = userDetails[0][2]
if (hashlib.sha1(passwordGiven).hexdigest() == passHash):
self.parent.login(User(userDetails[0]))
loginFailed = False
else:
loginFailed = True
else:
loginFailed = True
if loginFailed:
tkMessageBox.showerror("Login Failed",
"Invalid username or password")
self.userEntry.delete(0, END)
self.passEntry.delete(0, END)
def register(self):
username = self.userRegEntry.get()
passwd = self.passRegEntry.get()
if username != '' and passwd != '':
username = username.lower().strip()
passHash = hashlib.sha1(passwd).hexdigest()
self.db.sql("""INSERT INTO users (username, passwd) VALUES
('%s', '%s')"""%(username, passHash))
self.viewLogin()
def viewRegister(self):
self.login_canvas.pack_forget()
self.register_canvas.pack()
def viewLogin(self):
self.register_canvas.pack_forget()
self.login_canvas.pack()
def __init__(self):
def onresize(event):
data_canvas.configure(scrollregion=data_canvas.bbox("all"))
self.root.update_idletasks()
def on_mousewheel(event):
data_canvas.yview_scroll(-1 * (event.delta / 120), "units")
self.root.update_idletasks()
self.root = Tk()
self.root.wm_title("Micro-Tensile Testing Machine")
self.root.state("zoomed")
########################################################################################################################
# Title
header = Frame(self.root)
Label(header, text="Micro-Tensile Testing Machine", font=("Helvetica", 40, "bold"), bg="green", relief=RAISED).grid(row=0)
header.columnconfigure(0, weight=1)
header.grid(row=0, sticky=E + W)
########################################################################################################################
# Parameters
par_frame = Frame(self.root)
choice_frame = Frame(par_frame, bd=2, relief=RAISED)
self.choice = IntVar()
self.choice.set(1)
Radiobutton(choice_frame, text="ELONGATION", font=("Courier", 15),
variable=self.choice, value=1).grid(row=0, column=0, padx=50)
Radiobutton(choice_frame, text="BENDING", font=("Courier", 15),
variable=self.choice, value=2).grid(row=1, column=0, padx=50)
choice_frame.grid(row=0, column=0, sticky=W)
spec_frame = Frame(par_frame, bd=2, relief=RAISED)
Label(spec_frame, text="Specimen\nDimensions", font=("arial", 15)).grid(row=0, column=0, rowspan=2)
Label(spec_frame, text="LENGTH(mm)", font=("Courier", 15),
relief=SUNKEN, bg="yellow", fg="brown").grid(row=0, column=1, ipadx=5, ipady=1)
self.L = Entry(spec_frame, fg="blue", font=("Courier", 15), width=7)
self.L.insert(0, 25.4)
self.L.grid(row=0, column=2)
Label(spec_frame, text="Area(mm^2)", font=("Courier", 15),
relief=SUNKEN, bg="yellow", fg="brown").grid(row=1, column=1, ipadx=5, ipady=1)
self.area_box = Entry(spec_frame, fg="blue", font=("Courier", 15), width=7)
self.area_box.insert(0, 40.3765)
self.area_box.grid(row=1, column=2)
spec_frame.grid(row=0, column=1, rowspan=2, sticky=E)
par_frame.grid_columnconfigure(1, weight=1)
par_frame.grid(row=1, sticky=E + W)
########################################################################################################################
# Main Frame containing Curve and data display
curve = Frame(self.root)
self.no_reading = 0
# Stress, Strain value arrays
self.stress = np.array([0.0])
self.strain = np.array([0.0])
# Figure
main_curve = plot.figure(figsize=(18.5, 10))
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 2])
###################################################################
# # Live diagram
live_plot = main_curve.add_subplot(gs[0, 0])
live_plot.set_title("Live Diagram")
live_plot.grid(True)
live_plot.set_xlabel("in mm")
live_plot.set_xlim([0, float(self.L.get())])
live_plot.set_ylim([0, 50.0]) # Set y axis limits for live diagram
self.lines = live_plot.plot([0.0], [0.0], 'b-', [0.0], [0.0], 'r--')
self.live_plot = live_plot
###################################################################
# # Stress-Strain Curve
curve_plot = main_curve.add_subplot(gs[0, 1])
curve_plot.set_title("Curve")
curve_plot.grid(True)
curve_plot.set_xlim([0.0, 0.01])
curve_plot.set_ylim([0.0, 100.0])
curve_plot.set_xlabel("")
curve_plot.set_ylabel("")
self.points = curve_plot.plot(self.strain, self.stress, 'k-')
self.curve_plot = curve_plot
###################################################################
# # Save and show Figure
main_curve.tight_layout()
self.main_curve = main_curve
self.canvas_main = FigureCanvasTkAgg(self.main_curve, master=curve)
self.canvas_main.show()
self.canvas_main.get_tk_widget().grid(row=0, column=0, sticky=N + S + E + W)
# Displaying data
disp_data = Frame(curve, relief=RAISED, bd=2)
yscrollbar = AutoScrollbar(disp_data)
yscrollbar.grid(row=0, column=1, rowspan=4, sticky=N + S)
xscrollbar = AutoScrollbar(disp_data, orient=HORIZONTAL)
xscrollbar.grid(row=2, column=0, sticky=E + W)
data_canvas = Canvas(disp_data, yscrollcommand=yscrollbar.set, xscrollcommand=xscrollbar.set)
data_canvas.grid(row=0, column=0, rowspan=4, sticky=N + S + W + E)
yscrollbar.config(command=data_canvas.yview)
xscrollbar.config(command=data_canvas.xview)
label_frame = Frame(disp_data)
Label(label_frame, text="DATA\nS.No Load(N) Elongation(mm)\n",
font=("COMIC SANS MS", 17, "bold")).grid(row=0, column=0, sticky=N + S + W + E)
self.data = StringVar()
self.data_str = ""
self.data.set(self.data_str)
Label(label_frame, textvariable=self.data,
font=("Helvetica", 16, "italic")).grid(row=1, column=0, sticky=N + S + W + E)
data_canvas.create_window(0, 0, window=label_frame)
label_frame.bind("<Configure>", onresize)
label_frame.bind_all("<MouseWheel>", on_mousewheel)
disp_data.rowconfigure(1, weight=1)
disp_data.columnconfigure(0, weight=1)
disp_data.columnconfigure(1, weight=1)
disp_data.grid(row=0, column=1, sticky=N + S + W + E)
curve.columnconfigure(0, weight=1)
curve.grid(row=2, sticky=N + S + E + W)
########################################################################################################################
footer = Frame(self.root)
Button(footer, text="Run", font=('Comic Sans MS', 25, "bold italic"),
command=self.run_program).grid(row=0, column=0)
footer.columnconfigure(0, weight=1)
footer.grid(row=3, sticky=N + S + E + W)
self.root.mainloop()
class DisplayQuadTree(object):
def __init__(self, width, height, scale=1, show_grid=False):
self._scale = scale
self._grid_width = 1 if show_grid else 0
self.size = (width*scale, height*scale)
self._is_animate = False
self._anime_time = 0.1
self._tk_root = Tk()
self._canvas = Canvas(self._tk_root, width=self.size[0], height=self.size[1])
self._canvas.pack()
self._button = Button(self._tk_root, text='Finished', command=self._stop_animate)
self._button.configure(width=10, relief=FLAT)
self._canvas.create_window(10, 10, anchor=NW, window=self._button)
self._labelstr = StringVar()
self._labelstr.set('0%')
self._label = Label(self._tk_root, textvariable=self._labelstr)
self._canvas.create_window(self.size[0] - 10,
self.size[1] - 10,
anchor=SE,
window=self._label)
def static(self, qtree):
""" Draw the final output.
"""
if qtree is None:
return
stack = [qtree]
while len(stack):
qnode = stack.pop()
if qnode.children:
for child in qnode.children:
stack.append(child)
else:
colour = '#{0:02x}{1:02x}{2:02x}'.format(*qnode.ave_color)
self._canvas.create_rectangle(qnode.x * self._scale,
qnode.y * self._scale,
(qnode.x + qnode.width) * self._scale,
(qnode.y + qnode.height) * self._scale,
width=self._grid_width,
outline='grey',
fill=colour)
self._labelstr.set('100%')
def _stop_animate(self):
""" Stop the animation. Called by the "Stop" button
"""
self._is_animate = False
self._button.configure(text='Finished')
def animate(self, qtree):
""" Animate the development of the quadtree as it was generated.
Press the "Stop" to stop the animation
"""
if qtree is None:
return
self._is_animate = True
self._button.configure(text='Stop')
q = Queue.Queue()
q.put(qtree)
count, max_qtrees = 0.0, qtree.sq_num
while not q.empty() and self._is_animate:
qnode = q.get()
if qnode.children:
for child in qnode.children:
q.put(child)
count += 1.0
colour = '#{0:02x}{1:02x}{2:02x}'.format(*qnode.ave_color)
self._canvas.create_rectangle(qnode.x * self._scale,
qnode.y * self._scale,
(qnode.x + qnode.width) * self._scale,
(qnode.y + qnode.height) * self._scale,
width=self._grid_width,
outline='grey',
fill=colour)
self._canvas.update()
self._labelstr.set('{}%'.format(int(count/max_qtrees * 100)))
time.sleep(self._anime_time)
self._stop_animate()
def show(self):
""" Call this to start the display.
"""
self._tk_root.mainloop()
def __init__(self, filename, parentnotebook):
"""Create a new EditTab
Argument
filename -- name and path to the file being edited
parentnotebook -- the NoteBook in which this tab will be added
"""
Frame.__init__(self)
self._filename = filename
self._parentnotebook = parentnotebook
self._inputs = []
self.path = os.path.dirname(filename)
self._dirty = False
parentnotebook.add(self, state='normal')
self._setLabel()
#Set up GUI
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
vscroll = Scrollbar(self, orient=VERTICAL)
self._vscroll = vscroll
vscroll.grid(row=0, column=1, sticky=N + S)
hscroll = Scrollbar(self, orient=HORIZONTAL)
self._hscroll = hscroll
hscroll.grid(row=1, column=0, sticky=E + W)
canvas = Canvas(self,
yscrollcommand=vscroll.set,
xscrollcommand=hscroll.set)
self._canvas = canvas
canvas.grid(row=0, column=0, padx=5, pady=5, sticky=NSEW)
vscroll['command'] = canvas.yview
hscroll['command'] = canvas.xview
scrollframe = Frame(canvas)
self._scrollframe = scrollframe
canvas.create_window(0, 0, window=scrollframe, anchor=N + W)
scrollframe.rowconfigure(0, weight=1)
scrollframe.columnconfigure(0, weight=1)
self._mainframe = Frame(scrollframe)
self._mainframe.grid(row=0, column=0, padx=5, pady=5, sticky=NSEW)
cf = Frame(scrollframe)
self._control_frame = cf
cf.grid(row=1, column=0, padx=5, pady=5, sticky=E)
b = Button(cf,
text=lang[lng.txtCopyImages],
command=self._ehCopyImages)
self._btnCopy = b
b.grid(row=0, column=0, padx=5, pady=5)
b = Button(cf,
text=lang[lng.txtSave],
command=self._ehSave,
state=DISABLED)
self._btnSave = b
b.grid(row=0, column=1, padx=5, pady=5)
b = Button(cf, text=lang[lng.txtClose], command=self._ehClose)
b.grid(row=0, column=2, padx=5, pady=5)
parentnotebook.after_idle(self._setCanvas)
class Path:
def __init__(self, root):
self.canvas = Canvas(root, borderwidth=1, background="#ffffff")
self.frame = Frame(self.canvas, background="#ffffff")
self.vsb = Scrollbar(root, orient="vertical", command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.vsb.set)
self.vsb.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
self.canvas.create_window((4,4), window=self.frame, anchor="nw", tags="self.frame")
self.frame.bind("<Configure>", self.OnFrameConfigure)
self.data()
def data(self):
global textPath
textPath = StringVar()
global text0a
text0a = StringVar()
global text0b
text0b = StringVar()
global text2a
text2a = StringVar()
global text3
text3 = StringVar()
global alphaVar
alphaVar = IntVar()
global betaVar
betaVar = IntVar()
global allVar
allVar = IntVar()
global text6a0
text6a0 = IntVar()
global text6a1
text6a1 = IntVar()
global text6b
text6b = StringVar()
global text6c1
text6c1 = StringVar()
global text6c2
text6c2 = StringVar()
global text6c3
text6c3 = StringVar()
global text7_1
text7_1 = StringVar()
global text7_2
text7_2 = StringVar()
global text7_3
text7_3 = StringVar()
global text7_4
text7_4 = StringVar()
global text8
text8 = StringVar()
Label(self.frame,text="Path ? ").grid(row=0, column=0)
Entry(self.frame,textvariable=textPath).grid(row=1, column=0)
Button(self.frame, text="Valider et afficher", command = affiche_recap).grid(row=1, column=1)
Label(self.frame, text="Green function database information file\n (for a certain depth only for the instance) ?").grid(row=3)
Entry(self.frame, textvariable=text0a).grid(row=4)
Label(self.frame, text="Output directory (parentdir) ?").grid(row=5)
Entry(self.frame, textvariable=text0b).grid(row=6)
Label(self.frame, text="Phase name ?").grid(row=9)
Entry(self.frame, textvariable=text3).grid(row=10)
def afficheAlpha():
seismicPara["text"]="alpha"
betaVar.set(0)
allVar.set(0)
def afficheBeta():
seismicPara["text"]="beta"
alphaVar.set(0)
allVar.set(0)
def afficheAll():
seismicPara["text"]="all"
alphaVar.set(0)
betaVar.set(0)
seismicPara = Menubutton(self.frame, text="Seismic Parameter", relief=RAISED)
seismicPara.grid(row=0)
seismicPara.menu = Menu(seismicPara, tearoff = 0)
seismicPara["menu"] = seismicPara.menu
seismicPara.menu.add_checkbutton(label="alpha", variable = alphaVar, command = afficheAlpha)
seismicPara.menu.add_checkbutton(label="beta", variable = betaVar, command = afficheBeta)
seismicPara.menu.add_checkbutton(label="all", variable = allVar, command = afficheAll)
seismicPara.grid(row=11)
def affiche0():
filterPara["text"]="Filter Off"
text6a1.set(0)
def affiche1():
filterPara["text"]="Filter On"
text6a0.set(0)
filterPara = Menubutton(self.frame, text="Butterworth filter ", relief=RAISED)
filterPara.grid(row=0)
filterPara.menu = Menu(filterPara, tearoff = 0)
filterPara["menu"] = filterPara.menu
filterPara.menu.add_checkbutton(label="Filter Off", variable = text6a0, command = affiche0)
filterPara.menu.add_checkbutton(label="Filter On", variable = text6a1, command = affiche1)
filterPara.grid(row=12)
Label(self.frame, text="Filter name ?").grid(row=15)
Entry(self.frame, textvariable=text6b).grid(row=16)
Label(self.frame, text="\nIf butterworth = 0; \n just comment out those 3 parameters").grid(row=17)
Label(self.frame, text="lowest frequency ?").grid(row=18,column=1)
Entry(self.frame, textvariable=text6c1).grid(row=19, column=1)
Label(self.frame, text="highest frequency ?").grid(row=20, column=1)
Entry(self.frame, textvariable=text6c2).grid(row=21, column=1)
Label(self.frame, text="number of poles ?").grid(row=22, column=1)
Entry(self.frame, textvariable=text6c3).grid(row=23, column =1)
Label(self.frame, text="time window t1 ?").grid(row=24)
Entry(self.frame, textvariable=text7_1).grid(row=25)
Label(self.frame, text="time window t2 ?").grid(row=26)
Entry(self.frame, textvariable=text7_2).grid(row=27)
Label(self.frame, text="time window t3 ?").grid(row=28)
Entry(self.frame, textvariable=text7_3).grid(row=29)
Label(self.frame, text="time window t4 ?").grid(row=30)
Entry(self.frame, textvariable=text7_4).grid(row=31)
Label(self.frame, text="itranslat (1 if you convert geodetic latitude to geocentric latitude) ?").grid(row=32)
Entry(self.frame, textvariable=text8).grid(row=33)
Button(self.frame, text="continue", command=writingFile).grid(row=34)
def OnFrameConfigure(self, event):
'''Reset the scroll region to encompass the inner frame'''
self.canvas.configure(scrollregion=self.canvas.bbox("all"))
class MtgProxyView(Frame):
"""The View, which takes care of the visual representation of the model.
Attributes:
root: the root panel for the visual represantion
cardModel: the cardModel class which deals with all the internal card data
home: the path of where images are located
safeHome: the path where PDfs are supposed to be saved
cnfData: the path to the config file
defaultImage: the path to the default image
listFrame: the frame in which the mode is portraied
canvas: tha canvas which allows scrolling and a grid
myscrollbar: the scrollbar which gives the user the abilty to scroll through the list of cards
buttonframe: the frame in which the action buttons are being placed
wipeWorkspace: the button which corresponds with the clear worksapce function
bSelectDir: the button which corresponds with the selectDir function
selectSaveDir: the button which corresponds with the selectSaveDir function
bMake: the button which corresponds with the makePdf function
addButton: the button which corresponds with the addNewCard function
"""
def __init__(self):
"""
This is the the constructor of the MtgProxyView
It takes care of all the setup and doesnt require anything from the main
"""
#basic setup
sizex = 765
sizey = 525
posx = 0
posy = 0
self.root = Tk()
self.root.title("PyProxies")
self.root.wm_geometry("%dx%d+%d+%d" % (sizex, sizey, posx, posy))
self.root.resizable(width=False, height=False)
#backend data setup
self.cardmodel = Cardmodel()
#constants
self.home = ""
self.safeHome = ""
self.cnfData = "upm.cnf"
self.defaultImage = "noCard.jpg"
self.loadConfig()
#list setup
self.listframe = Frame(self.root,
relief=GROOVE,
width=500,
height=500,
bd=1)
self.listframe.place(x=10, y=10)
self.canvas = Canvas(self.listframe)
self.frame = Frame(self.canvas)
self.myscrollbar = Scrollbar(self.listframe,
orient="vertical",
command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.myscrollbar.set)
#and it scrollbar
self.myscrollbar.pack(side="right", fill="y")
self.canvas.pack(side="left")
self.canvas.create_window((0, 0), window=self.frame, anchor='nw')
#button setup
self.buttonframe = Frame(self.root,
relief=GROOVE,
width=100,
height=500,
bd=1,
padx=15,
pady=10)
self.buttonframe.place(x=535, y=10)
self.wipeWorkspace = Button(self.buttonframe,
text="clear Workspace",
command=self.completeWipe,
width=20)
self.wipeWorkspace.pack(anchor="sw", pady=5)
self.bSelectDir = Button(self.buttonframe,
text="select a fitting Directory",
command=self.selectDir,
width=20)
self.bSelectDir.pack(anchor="sw", pady=5)
self.selectSaveDir = Button(self.buttonframe,
text="Select a save directory",
command=self.selectSafeDir,
width=20)
self.selectSaveDir.pack(anchor="sw", pady=5)
self.bMake = Button(self.buttonframe,
text="make PDF",
command=self.makePdf,
width=20)
self.bMake.pack(anchor="sw", pady=5)
self.addButton = Button(self.frame,
text="add a new Card",
command=self.addNewCard)
self.frame.bind("<Configure>", self.myfunction)
self.data()
self.root.mainloop()
def loadConfig(self):
"""
This is the functions which loads the configuration.
Only the place where Images can be added as sources and where PDFs can be saved,
are able to be set and saved.
"""
configFile = open(self.cnfData, "r+")
temp = configFile.read().split("\n")
try:
self.home = expanduser("~")
if os.path.exists(temp[0]):
self.home = temp[0]
self.safeHome = expanduser("~")
if os.path.exists(temp[1]):
self.safeHome = temp[1]
except IndexError:
print "Error"
self.home = expanduser("~")
self.safeHome = expanduser("~")
print "new homes"
print self.home
print self.safeHome
configFile.close()
def saveConfig(self):
"""
This Function takes care of writing the values of the home and the saveHome to the configuration file
"""
configFile = open(self.cnfData, "w")
configFile.write(self.home + "\n" + self.safeHome)
print "config saved"
configFile.close()
self.loadConfig()
def completeWipe(self):
"""
This function clears the workspace of all of its components and resets the Model.
"""
for i in range(self.cardmodel.getCardCount()):
#self.cardHowOften[i]=0
self.cardmodel.setCardHowOften(i, 0)
self.cardmodel.setImg(self.defaultImage, i)
#self.imgPaths[i] = self.defaultImage
self.cardmodel.resetCardCount()
for w in self.frame.winfo_children():
w.destroy()
self.data()
def selectSafeDir(self):
"""
This function sets the directory where exported PDFs are being stored.
Its does this by invoking the tkFileDialog which asks for user input and returns a valid path.
"""
path = tkFileDialog.askdirectory(
initialdir=self.safeHome, title="Select a better save directory.")
if isinstance(path, basestring):
self.safeHome = path
self.saveConfig()
def selectDir(self):
"""
This function provides the user with the functionality to set their starting directory for adding source images.
They can do this in order to save time and optimize their workflow.
Its does this by invoking the tkFileDialog which asks for user input and returns a valid path.
"""
path = tkFileDialog.askdirectory(
initialdir=self.home, title="Select a better working directory.")
if isinstance(path, basestring):
self.home = path
self.saveConfig()
def data(self):
"""
The data function takes care of going over the entiry model and representing it on the canvas object.
It is only supposed to be invoked when the workspace has been cleard beforehand.
"""
for i in range(self.cardmodel.getCardCount()):
#image label
pilFile = Image.open(self.cardmodel.getImg(i))
image1 = pilFile.resize((60, 80), Image.ANTIALIAS)
image2 = ImageTk.PhotoImage(image1)
imageLabel = Label(self.frame, image=image2)
imageLabel.image = image2
imageLabel.grid(row=i, column=0, padx=2, pady=2)
#other labels
Label(self.frame,
text="Card is being printed " +
str(self.cardmodel.getCardHowOftenAt(i)) + " times.").grid(
row=i, column=1)
Button(self.frame,
text="-",
command=lambda i=i: self.decrHowOften(i)).grid(row=i,
column=2)
Button(self.frame,
text="+",
command=lambda i=i: self.incrHowOften(i)).grid(row=i,
column=3)
Button(self.frame,
text="add Source",
command=lambda i=i: self.getImgPath(i)).grid(row=i,
column=4)
Button(self.frame, text="X",
command=lambda i=i: self.delete(i)).grid(row=i, column=5)
self.addButton = Button(self.frame,
text="add a new Card",
command=self.addNewCard)
self.addButton.grid(row=self.cardmodel.getCardCount(),
column=0,
columnspan=2,
padx=10,
pady=20,
sticky="W")
def updateOne(self, i):
"""
This Function is supposed to only update one row of the Canvas in,
which the model is displayed.
Args:
i: the index of the row which is supposed to be updated
"""
pilFile = Image.open(self.cardmodel.getImg(i))
image1 = pilFile.resize((60, 80), Image.ANTIALIAS)
image2 = ImageTk.PhotoImage(image1)
imageLabel = Label(self.frame, image=image2)
imageLabel.image = image2
imageLabel.grid(row=i, column=0, padx=2, pady=2)
# other labels
Label(self.frame,
text="Card is being printed " +
str(self.cardmodel.getCardHowOftenAt(i)) + " times.").grid(
row=i, column=1)
Button(self.frame, text="-",
command=lambda i=i: self.decrHowOften(i)).grid(row=i, column=2)
Button(self.frame, text="+",
command=lambda i=i: self.incrHowOften(i)).grid(row=i, column=3)
Button(self.frame,
text="add Source",
command=lambda i=i: self.getImgPath(i)).grid(row=i, column=4)
Button(self.frame, text="X",
command=lambda i=i: self.delete(i)).grid(row=i, column=5)
def delete(self, i):
"""
This function is supposed to delete one Card and update the model accordingly.
Args:
i: the indexing of the row, which is supposed to be updated
"""
self.cardmodel.deleteCard(i)
#complete reset
for w in self.frame.winfo_children():
w.destroy()
self.data()
def incrHowOften(self, i):
"""
This function takes care of increasing the counter of how often a card is supposed to be printed.
Args:
i: the row in which the the card is located
"""
self.cardmodel.incrCardHowOften(i)
self.updateOne(i)
def decrHowOften(self, i):
"""
This function takes care of decreasing the counter of how often a card is supposed to be printed.
Args:
i: the row in which the the card is located
"""
self.cardmodel.decrCardHowOften(i)
self.updateOne(i)
def addNewCard(self):
"""
This function adds a new card to the model and updates it with default values.
It then invokes the updateOne-function in order to update the view.
"""
self.cardmodel.addCard()
self.addButton.destroy()
self.addButton = Button(self.frame,
text="add a new Card",
command=self.addNewCard)
self.addButton.grid(row=self.cardmodel.getCardCount(),
column=0,
columnspan=2,
padx=10,
pady=20,
sticky="W")
self.updateOne(self.cardmodel.getCardCount() - 1)
def myfunction(self, event):
"""
A function which is called in the event of a configuration concerning the frame.
It sets the scrollregion of the scrollbar to be the canvas
"""
self.canvas.configure(scrollregion=self.canvas.bbox("all"),
width=500,
height=500)
def getImgPath(self, i):
"""
This function allows the user to change the image source of a card.
It does this by invoking the tkFileDialog in order to ask for a filename,
limited to JPGs and PNGs.
If the user input something it updates the model.
Args:
i: index of the row in which the card is located
"""
imgPath = tkFileDialog.askopenfilenames(initialdir=self.home,
title="Select Image",
filetypes=[
("JPG files", "*.jpg"),
("PNG files", "*.png"),
("JPEG files", "*.jpeg")
])
print imgPath
print str(imgPath) == "()"
if str(imgPath) != "()" and str(imgPath) != "":
print(imgPath[0])
self.cardmodel.setImg(imgPath[0], i)
self.updateOne(i)
else:
print "user didnt select anything"
def makePdf(self):
"""
This function gives the user the functionality to select a filename for the PDF they want to print.
Afterwards if a name has been entered the function gives the model to the proxymaker module,
which creates a PDF in the desired location.
"""
name = tkSimpleDialog.askstring(
'Input', 'Enter the desired name for the PDF, without suffix')
if name is not None:
proxymaker.writeData(self.cardmodel,
self.safeHome + "/" + name + ".pdf")
class Example(Frame):
'''
Constructor for creating a frame
'''
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
'''
Browse the filename to be added to to Openstack Swift
'''
def browsefile(self):
self.filename = askopenfilename()
self.nm = self.filename.split("/")
self.fnm = self.nm[len(self.nm)-1]
self.e2.configure(state="normal")
self.e2.update()
self.e2.delete(0, 'end')
self.e2.insert("end", self.fnm)
self.e2.configure(state="disabled")
self.e2.update()
'''
Add Data - To Openstack Swift
Check For De-Duplication of Data
- Display the Data When found duplicate data
Check For Already Added File - same file
- Display the content of already Added file
'''
def addData(self):
file_ext=self.fnm.split('.')
result = requests.get('http://localhost:8983/solr/techproducts/select?q='+ str(self.fnm)+'&wt=json&fl=id')
op = result.json()
flag = False
if op['response']['numFound'] == 0:
un_id = random.randint(1, 1000)
if file_ext[1] == 'txt':
listdocs = requests.get('http://localhost:8983/solr/techproducts/select?q=*.'+ file_ext[1] +'&wt=json')
listdict = listdocs.json()
f = open(self.fnm,"r")
lines = f.readlines()
alllines = ""
for j in range(0, len(lines)):
alllines += lines[j]
for i in range(0, len(listdict['response']['docs'])):
if alllines.strip() == (listdict['response']['docs'][i]['content'][0]).strip():
name = str(listdict['response']['docs'][i]['resourcename']).split("/")
self.e3.delete('1.0', END)
self.e3.insert(END,"Cannot Add Duplicate Data. There is already a file with same contents\n File name : "+ str(name[len(name)-1]) + "\n")
self.e3.insert(END,"Here are the contents\n")
self.e3.insert(END,str(listdict['response']['docs'][i]['content'][0]).strip())
flag = True
if file_ext[1] == 'pdf':
listdocs = requests.get('http://localhost:8983/solr/techproducts/select?q=*.'+ file_ext[1] +'&wt=json')
listdict = listdocs.json()
with open(self.fnm) as f:
doc = slate.PDF(f)
alllines = ""
for i in range(0, len(doc)):
alllines += doc[i]
remove = string.punctuation + string.whitespace
alllines = alllines.translate(None, remove)
for i in range(0, len(listdict['response']['docs'])):
alldocs = (listdict['response']['docs'][i]['content'][0]).encode("utf-8")
alldocs = alldocs.translate(None, remove)
res = (alllines == alldocs)
if alllines == alldocs:
name = str(listdict['response']['docs'][i]['resourcename']).split("/")
self.e3.delete('1.0', END)
self.e3.insert(END,"Cannot Add Duplicate Data. There is already a file with same contents\n File name : "+ str(name[len(name)-1]) + "\n")
self.e3.insert(END,"Here are the contents\n")
self.e3.insert(END,str(listdict['response']['docs'][i]['content'][0]).strip())
flag = True
if file_ext[1] == 'docx':
listdocs = requests.get('http://localhost:8983/solr/techproducts/select?q=*.'+ file_ext[1] +'&wt=json')
listdict = listdocs.json()
document = docx.Document(self.fnm)
alllines = ""
for para in document.paragraphs:
dl = para.text.encode("utf-8")
alllines += dl
remove = string.punctuation + string.whitespace
alllines = alllines.translate(None, remove)
for i in range(0, len(listdict['response']['docs'])):
alldocs = (listdict['response']['docs'][i]['content'][0]).encode("utf-8")
alldocs = alldocs.translate(None, remove)
res = (alllines == alldocs)
if alllines == alldocs:
name = str(listdict['response']['docs'][i]['resourcename']).split("/")
self.e3.delete('1.0', END)
self.e3.insert(END,"Cannot Add Duplicate Data. There is already a file with same contents\n File name : "+ str(name[len(name)-1]) + "\n")
self.e3.insert(END,"Here are the contents\n")
self.e3.insert(END,str(listdict['response']['docs'][i]['content'][0]).strip())
flag = True
if flag == False:
os.system('cp '+ str(self.fnm) + " /opt/solr/example/exampledocs/")
os.system("/opt/solr/bin/post -c techproducts /opt/solr/example/exampledocs/" + str(self.fnm) + " -params \"literal.id=" + str(un_id) + "\"")
self.e3.delete('1.0', END)
self.e3.insert(END,"Indexing Done for the Upload .....\n")
container = subprocess.check_output(["swift","list","-v","--os-username","admin","--os-password","ea12f4366a2a4253","--os-auth-url","http://localhost:5000/v2.0","--os-tenant-name","admin"])
container = container.split("\n")
os_name = os.environ['OS_USERNAME']
os_password = os.environ['OS_PASSWORD']
os_auth_url = os.environ['OS_AUTH_URL']
os_tenant_name = os.environ['OS_TENANT_NAME']
response = os.system("swift upload -c -v --os-username "+ str(os_name) + " --os-password "+ str(os_password) + " --os-auth-url " + str(os_auth_url) + " --os-tenant-name "+ str(os_tenant_name) + " "+ str(container[0]) + " "+ str(self.fnm))
if response == 0:
self.e3.insert(END,"File Uploaded Successfully to Openstack Swift\n")
if op['response']['numFound'] > 0:
answer = requests.get('http://localhost:8983/solr/techproducts/select?q='+ str(self.fnm)+'&wt=json&fl=content')
details = answer.json()
content_dict = details['response']['docs'][0]['content']
self.e3.delete('1.0', END)
self.e3.insert(END,"Cannot Add Data Again\n")
self.e3.insert(END,"Data Already Added to Openstack Swift:\nHere are the contents\n")
self.e3.insert(END,content_dict[0])
'''
Search The Openstack Swift Data with Search Query given by the user
'''
def searchData(self):
query = self.e1.get()
qresult = requests.get('http://localhost:8983/solr/techproducts/browse?q='+ str(query)+'&wt=json')
qop = qresult.json()
if qop['response']['numFound'] == 0:
self.e3.delete('1.0', END)
self.e3.insert(END,"Sorry !! No Details found for the search query")
if qop['response']['numFound'] > 0:
length = len(qop['response']['docs'])
self.e3.delete('1.0', END)
for i in range(0, length):
sname = str(qop['response']['docs'][i]['resourcename']).split("/")
self.e3.insert(END,"Filename : " + str(sname[len(sname)-1]) + "\n")
self.e3.insert(END,qop['response']['docs'][i]['content'][0])
self.e3.insert(END,"Search Result Found "+ str(length) + " \n")
'''
Clear The Text Area
'''
def clearText(self):
self.e1.delete(0, 'end')
self.e2.configure(state="normal")
self.e2.update()
self.e2.delete(0, 'end')
self.e2.configure(state="disabled")
self.e2.update()
self.e3.delete('1.0', END)
'''
GUI : Add Canvas
Add Buttons : Quit, Clear, Search, Browse, Add
Add Text Area : Search, Add, Output
'''
def initUI(self):
self.parent.title("Openstack Search")
self.config(bg = '#F0F0F0')
self.pack(fill = BOTH, expand = 1)
#create canvas
self.canvas1 = Canvas(self, relief = FLAT, background = "#D2D2D2",
width = 1000, height = 500)
self.canvas1.pack(side = TOP, anchor = NW, padx = 10, pady = 10)
self.e1 = Entry(self.canvas1)
self.e1.config(width=20)
self.e2 = Entry(self.canvas1)
self.e2.config(width=20)
self.e2.config(state="disabled")
self.e1_window = self.canvas1.create_window(210,70,window = self.e1)
self.e2_window = self.canvas1.create_window(210,120,window = self.e2)
self.e3 = Text(self.canvas1,height=18)
self.e3.grid(column=1,row=5, columnspan=5, rowspan=1, sticky='W')
scrb=Scrollbar(self.canvas1,orient=VERTICAL,command=self.e3.yview)
self.e3.configure(yscrollcommand=scrb.set)
self.e3_window = self.canvas1.create_window(450,350,window = self.e3)
self.button1 = Button(self, text = "Quit", command = self.quit, anchor = W)
self.button1.configure(width = 10, activebackground = "#33B5E5", relief = FLAT)
self.button1_window = self.canvas1.create_window(10, 10, anchor=NW, window=self.button1)
self.button2 = Button(self, text = "Search", anchor = W)
self.button2.configure(command=self.searchData)
self.button2.configure(width = 10, activebackground = "#33B5F5", relief = FLAT)
self.button2_window = self.canvas1.create_window(10, 60, anchor=NW, window=self.button2)
self.button3 = Button(self, text = "Browse", command = self.browsefile, anchor = W)
self.button3.configure(width = 10, activebackground = "#33B5D5", relief = FLAT)
self.button3_window = self.canvas1.create_window(10, 110, anchor=NW, window=self.button3)
self.button3 = Button(self, text = "Add", command = self.addData, anchor = W)
self.button3.configure(width = 10, activebackground = "#33B5D5", relief = FLAT)
self.button3_window = self.canvas1.create_window(10, 160, anchor=NW, window=self.button3)
self.button4 = Button(self, text = "Clear", command = self.clearText, anchor = W)
self.button4.configure(width = 10, activebackground = "#33B5D5", relief = FLAT)
self.button4_window = self.canvas1.create_window(200, 10, anchor=NW, window=self.button4)
import time
import os
from Tkinter import Canvas, Label, Frame, Button, Tk, Entry, Toplevel
from graphviz import Digraph
global master
master = Tk()
master.title('SLR Parser')
canvas = Canvas(master,
width=master.winfo_screenwidth(),
height=master.winfo_screenheight())
u1_entry = Entry(canvas)
canvas.create_window(220, 200, window=u1_entry, height=150, width=300)
u2_entry = Entry(canvas)
canvas.create_window(220, 430, window=u2_entry, height=100, width=300)
grammars = open("grammar2.txt")
G = {}
C = {}
I = {}
J = {}
inputstring = ""
start = ""
terminals = []
nonterminals = []
def on_show_frame(self):
self.canvas_wrappers = []
self.canvases = []
self.page_num = 0
if len(self.controller.sr_results) == 0:
self.controller.show_frame(SrNoFramesFoundScreen)
else:
pages = int(ceil(len(self.controller.sr_results) / 10.0))
for page in range(0, pages):
canvas_wrapper = Frame(self.content_wrapper,
borderwidth="1",
relief="solid")
canvas = Canvas(canvas_wrapper,
width=int(WINDOW_WIDTH * 7 / 8),
height=(WINDOW_HEIGHT * 2 / 3))
scroll_bar = Scrollbar(canvas_wrapper,
orient=VERTICAL,
command=canvas.yview)
results_list_frame = Frame(canvas)
canvas.configure(yscrollcommand=scroll_bar.set)
canvas.create_window(0, 0, window=results_list_frame)
canvas.bind_all("<Up>", self.on_up_key)
canvas.bind_all("<Down>", self.on_down_key)
canvas.bind_all("<Left>", self.on_left_key)
canvas.bind_all("<Right>", self.on_right_key)
canvas.grid(row=0, column=0, sticky="nsew")
scroll_bar.grid(row=0, column=1, sticky="ns")
canvas_wrapper.grid(row=2,
column=0,
columnspan=3,
sticky="nsew")
select_buttons_on_page = []
for row in range(0, RESULTS_PER_PAGE):
result_num = page * RESULTS_PER_PAGE + row
if result_num < len(self.controller.sr_results):
frame_num = self.controller.sr_results[result_num][
FRAME_NUM_LABEL]
result_entry = Frame(results_list_frame,
borderwidth="1",
relief="solid")
description = PLabel(
result_entry,
text="Frame #" + str(int(frame_num)) + ", Time: " +
str(datetime.timedelta(seconds=frame_num / 30)))
preview_wrapper = Frame(result_entry)
left_video_preview = Label(
preview_wrapper,
image=self.controller.sr_results[result_num][LEFT])
right_video_preview = Label(
preview_wrapper,
image=self.controller.sr_results[result_num]
[RIGHT])
select_button = SrSelectButton(
preview_wrapper,
self.controller,
self.controller.sr_results[result_num]
[SR_MAP_LABEL],
text="Select")
select_buttons_on_page.append(select_button)
description.pack()
left_video_preview.grid(row=row, column=0)
right_video_preview.grid(row=row, column=1)
select_button.grid(row=row, column=2)
preview_wrapper.pack()
result_entry.pack()
for i in range(0, len(select_buttons_on_page)):
select_buttons_on_page[i].configure(
command=select_buttons_on_page[i].use_sr_map)
self.master.update_idletasks()
canvas.config(scrollregion=canvas.bbox("all"))
canvas.yview_moveto(0)
self.canvas_wrappers.append(canvas_wrapper)
self.canvases.append(canvas)
self.prev_result_page = Button(
self.content_wrapper,
text="<",
command=lambda: self.prev_page_command())
self.page_info_label = PLabel(
self.content_wrapper,
text=get_page_info_label_message(self.page_num,
len(self.canvases),
RESULTS_PER_PAGE))
self.next_result_page = Button(
self.content_wrapper,
text=">",
command=lambda: self.next_page_command())
self.prev_result_page.grid(row=3, column=0)
self.page_info_label.grid(row=3, column=1)
self.next_result_page.grid(row=3, column=2)
self.canvas_wrappers[self.page_num].tkraise()
class ResultsFrame(Frame):
"Class which controls the results screen of the spelling aid"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
#Create UI elements
self.results_list = ResultsTable(self.parent, height=160, width=250)
buttonRetry = Button(self.parent, text="Retry", width=10,
command=self.restart)
buttonNewlist = Button(self.parent, text="New List", width=10,
command=self.new_selection)
buttonExit = Button(self.parent, text="Quit", width=10,
command=self.parent.destroy)
self.results_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
font = ("Helvetica", 20)
self.results_canvas.create_text(300, 15, text="Results", fill="#004183",
font=font)
self.results_canvas.create_window(310, 35, window=self.results_list,
anchor=NW)
self.results_canvas.create_window(150, 230, window=buttonRetry)
self.results_canvas.create_window(300, 230, window=buttonNewlist)
self.results_canvas.create_window(450, 230, window=buttonExit)
self.results_canvas.create_text(25, 55, font=font, text="List:",
anchor=W)
self.results_canvas.create_text(25, 85, font=font, text="Score:",
anchor=W)
self.results_canvas.create_text(25, 115, font=font, text="Time:",
anchor=W)
self.results_canvas.create_text(25, 145, font=font, text="Best Score:",
anchor=W)
self.results_canvas.create_text(25, 175, font=font, text="Best Time:",
anchor=W)
self.list_name = self.results_canvas.create_text(300, 55, font=font,
anchor=E)
self.score_number = self.results_canvas.create_text(300, 85, font=font,
anchor=E)
self.time_number = self.results_canvas.create_text(300, 115, font=font,
anchor=E)
self.best_score = self.results_canvas.create_text(300, 145, font=font,
anchor=E)
self.best_time = self.results_canvas.create_text(300, 175, font=font,
anchor=E)
self.results_canvas.pack()
def calculate(self, word_list, time_elapsed):
"""Calculate and display the users score and time, as well as personal
bests"""
score = 0
user_id = self.parent.user.uid
list_id = word_list.l_id
self.results_list.add_list(word_list.words)
for word in word_list.words:
if word.isCorrect:
score += 1
previous_records = self.parent.db.sql("""SELECT best_score, best_time
FROM user_list_map WHERE list_id = '%d'
AND user_id = '%d'"""
%(list_id, user_id))
try:
best_score = max(score, previous_records[0][0])
best_time = min(time_elapsed, previous_records[0][1])
self.parent.db.sql("""UPDATE user_list_map SET best_score='%d',
best_time='%d' WHERE list_id = '%d' AND
user_id = '%d'"""
%(best_score, best_time, list_id, user_id))
except IndexError:
#If the list has not been played before, create a record
best_score = score
best_time = time_elapsed
print "Creating"
self.parent.db.sql("""INSERT INTO user_list_map VALUES
('%d', '%d', '%d', '%d')"""
%(user_id, list_id, best_score, best_time))
self.results_canvas.itemconfig(self.list_name, text=word_list.name)
self.results_canvas.itemconfig(self.score_number, text=score)
self.results_canvas.itemconfig(self.time_number, text=time_elapsed)
self.results_canvas.itemconfig(self.best_score, text=best_score)
self.results_canvas.itemconfig(self.best_time, text=best_time)
def restart(self):
"""Clear the results page and restart the game with the current list"""
self.results_list.clear()
self.parent.start_game(self.parent.current_list)
def new_selection(self):
"""Clear the results page and return to the start screen"""
self.results_list.clear()
self.parent.new_list()
class Scrolling_Area(Frame, object):
def __init__(self, master, width=None, anchor=N, height=None, mousewheel_speed = 2, scroll_horizontally=True, xscrollbar=None, scroll_vertically=True, yscrollbar=None, background=None, inner_frame=Frame, **kw):
Frame.__init__(self, master, class_="Scrolling_Area", background=background)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self._width = width
self._height = height
self.canvas = Canvas(self, background=background, highlightthickness=0, width=width, height=height)
self.canvas.grid(row=0, column=0, sticky=N+E+W+S)
if scroll_vertically:
if yscrollbar is not None:
self.yscrollbar = yscrollbar
else:
self.yscrollbar = Scrollbar(self, orient=VERTICAL)
self.yscrollbar.grid(row=0, column=1,sticky=N+S)
self.canvas.configure(yscrollcommand=self.yscrollbar.set)
self.yscrollbar['command']=self.canvas.yview
else:
self.yscrollbar = None
if scroll_horizontally:
if xscrollbar is not None:
self.xscrollbar = xscrollbar
else:
self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
self.xscrollbar.grid(row=1, column=0, sticky=E+W)
self.canvas.configure(xscrollcommand=self.xscrollbar.set)
self.xscrollbar['command']=self.canvas.xview
else:
self.xscrollbar = None
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.innerframe = inner_frame(self.canvas, **kw)
self.innerframe.pack(anchor=anchor)
self.canvas.create_window(0, 0, window=self.innerframe, anchor='nw', tags="inner_frame")
self.canvas.bind('<Configure>', self._on_canvas_configure)
Mousewheel_Support(self).add_support_to(self.canvas, xscrollbar=self.xscrollbar, yscrollbar=self.yscrollbar)
@property
def width(self):
return self.canvas.winfo_width()
@width.setter
def width(self, width):
self.canvas.configure(width= width)
@property
def height(self):
return self.canvas.winfo_height()
@height.setter
def height(self, height):
self.canvas.configure(height = height)
def set_size(self, width, height):
self.canvas.configure(width=width, height = height)
def _on_canvas_configure(self, event):
width = max(self.innerframe.winfo_reqwidth(), event.width)
height = max(self.innerframe.winfo_reqheight(), event.height)
self.canvas.configure(scrollregion="0 0 %s %s" % (width, height))
self.canvas.itemconfigure("inner_frame", width=width, height=height)
def update_viewport(self):
self.update()
window_width = self.innerframe.winfo_reqwidth()
window_height = self.innerframe.winfo_reqheight()
if self._width is None:
canvas_width = window_width
else:
canvas_width = min(self._width, window_width)
if self._height is None:
canvas_height = window_height
else:
canvas_height = min(self._height, window_height)
self.canvas.configure(scrollregion="0 0 %s %s" % (window_width, window_height), width=canvas_width, height=canvas_height)
self.canvas.itemconfigure("inner_frame", width=window_width, height=window_height)
import Tkinter import Image from Tkinter import Tk, BOTH from ttk import Frame, Button, Style import cv2 import os import time import itertools from Tkinter import Tk, Frame, BOTH, Button, RIGHT, RAISED from Tkinter import BooleanVar, Checkbutton, PhotoImage, Canvas from Tkinter import Scale, StringVar, END, Listbox, Label, Menu from PIL import Image import ttk import thread import pylab root = Tk() cwgt = Canvas(root) cwgt.pack(expand=True, fill=BOTH) image1 = PhotoImage(file="1.png") # keep a link to the image to stop the image being garbage collected cwgt.img = image1 cwgt.create_image(0, 0, image=image1) b1 = Button(cwgt, text="Hello", bd=0) cwgt.create_window(20, 20, window=b1) root.mainloop()
width_text, height_text = draw.textsize(text) draw.text((text_x, text_y), text, fill="white") photoimage = ImageTk.PhotoImage(image) Label(root, image=photoimage).place(x=0,y=0) entry_pady = 7 Entry(root, background="white").place(x=text_x, y=text_y + height_text +entry_pady) ################################################### # Another example toplevel = Toplevel(root) toplevel.resizable(width=False, height=False) image_file = io.BytesIO(base64.b64decode(BASE64_BACKGROUND)) image = Image.open(image_file) photoimage2 = ImageTk.PhotoImage(image) canvas = Canvas(toplevel,width=width, height=height) canvas.create_image((0,0), image=photoimage2, anchor="nw") canvas.create_text((text_x, text_y), text=text, fill="white", anchor="nw") canvas.pack() entry = Entry(canvas, background="white") canvas.create_window((text_x, text_y + height_text +entry_pady), window=entry, anchor="nw") root.mainloop()
def start():
global canvas
canvas = Canvas(root, width=width, height=height)
canvas.pack()
x=50
y=15
entry_file1name = Entry(canvas, width=65, font=(14), bd=3, textvariable=file1, state=DISABLED)
canvas.create_window((x, y), window=entry_file1name, anchor="nw")
btn_Browse1 = Button(canvas, text="Browse DICOM File", width=20, background="white", command=browse_file(1))
btn_Browse1.bind('<Return>', browse_file(1))
canvas.create_window((x+620, y-5), window=btn_Browse1, anchor="nw")
y = y + 40
entry_file2name = Entry(canvas, width=65, font=(14), bd=3, textvariable=file2, state=DISABLED)
canvas.create_window((x, y), window=entry_file2name, anchor="nw")
btn_Browse2 = Button(canvas, text="Browse DICOM File", width=20, background="white", command=browse_file(2))
btn_Browse2.bind('<Return>', browse_file(2))
canvas.create_window((x + 620, y), window=btn_Browse2, anchor="nw")
y = y + 40
check1 = Checkbutton(canvas, text="PName", variable=pNameCheck)
canvas.create_window(x, y, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="Num Of Beams", variable=numBeamsCheck)
canvas.create_window(x+80, y, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="B Name", variable=bNameCheck)
canvas.create_window(x+200, y, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="Type", variable=typeCheck)
canvas.create_window(x+320, y, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="EN", variable=EnCheck)
canvas.create_window(x + 410, y, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="C Angle", variable=cAngleCheck)
canvas.create_window(x, y+30, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="G Angle", variable=gAngleCheck)
canvas.create_window(x+80, y + 30, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="B Meterset Unit", variable=bMetersetUnitCheck)
canvas.create_window(x+200, y+30, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="B Meterset", variable=bMetersetCheck)
canvas.create_window(x + 320, y+30, window=check1, anchor='w')
check1 = Checkbutton(canvas, text="Num CP", variable=numCPCheck)
canvas.create_window(x + 410, y+30, window=check1, anchor='w')
y = y + 50
frame = Frame(canvas)
canvas.create_window((x, y), window=frame, anchor="nw")
global text
text = Text(frame, font=("Helvetica", 12))
text.pack(side="left", fill="y")
scrollbar = Scrollbar(frame, orient="vertical")
scrollbar.config(command=text.yview)
scrollbar.pack(side="right", fill="y")
text.config(yscrollcommand=scrollbar.set)
y=y+440
global ERROR_LBL
ERROR_LBL = Label(canvas, fg='black', justify='left')
canvas.create_window((x, y), window=ERROR_LBL, anchor="nw")
y = y + 30
btn_Compare = Button(canvas, text="Compare", font=(14), foreground="white", background="#062569", width=13, command=compare)
btn_Compare.bind('<Return>', compare)
canvas.create_window((x, y), window=btn_Compare, anchor="nw")
btn_Exit = Button(canvas, text="Exit", font=(14), foreground="white", background="#062569", width=13,
command=quit)
btn_Exit.bind('<Return>', quit)
canvas.create_window((x+150, y), window=btn_Exit, anchor="nw")
root.protocol("WM_DELETE_WINDOW", quit)
root.resizable(0, 0)
root.mainloop()
class GameFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, width=600, height=250)
self.parent = parent
def init_gui(self):
correct = """R0lGODlhQABAAOeqAAAAAAABAAACAAADAAAEAAAFAAAFAQAGAQAHAQEHAQEIAQEJAQEKAQEKAgEL
AgEMAgENAgEPAgIPAgIQAgIRAwITAwIUAwIVBAMVBAIWAwIWBAIXBAMXBAMYAwIZBAMZBAMaBQMb
BAMdBQMeBQMfBQMgBQQgBQQiBgQkBgQlBgQmBwQnBwUnBgUoBwUqBwUrBwUsBwUsCAUtCAUuCAUv
CAYvCAUxCAYyCQYzCAY0CQY1CgY2CQY3CQc3CgY5Cgc5Cgc7Cgc+Cwg/CwdACwhACwhBCwhCCwhG
DAhHDAhIDQlLDQlMDglNDglPDglQDglRDglSDgpUDwpWDwtWDwpXDwpZDwtaEAtfEQtgEQthEQxk
EQxkEgxlEgxnEgxoEw1oEgxpEgxqEw1qEg1rEwxsEw1sEg1tEw1vEw1wFA1yFA5yFA1zFA50FA50
FQ51FA52FQ95Fg56FQ57Fg97FQ99Fg9+Fg9/Fg+AFhCAFg+BFhCCFhCEFxCGFxCHGBCIGBCKGBGK
GBCLGBGMGRGNGRGOGRGQGRGRGRGRGhGSGRGTGhKTGRKTGhGUGhKVGhKXGhKXGxKYGhKaGxKbGxKc
GxKdGxKdHBOdGxOdHBKeHBOeGxOeHBOfHBOgHBOhHBOiHBOiHROjHBOjHROkHRSkHROlHRSlHRSm
HRSnHRSoHRSrHv//////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////yH+EUNyZWF0ZWQgd2l0aCBH
SU1QACH5BAEKAP8ALAAAAABAAEAAAAj+AP8JHEiwoMGDCBMqPAhgocOHEB0CaBixosWFEyde3MhR
YEaKHUNC/CiyJMYHCTSaXGkQgAcVKVnKHAhgBZIIIGeanAiki4acOkVOlJInBNCgHQEIELOIxFGk
GwFASLNJxVOoFgFUiFOKx1WsEQFY0GOqiQCwIQF0ECSqi4KvaDGKWNRJjgW4cRMCOEGI06AWePMy
ROGnU6QggQUXBIBij6dPUBIrptk4lKkuAiRPBpCCT6hQdipoVgxgBB9PnAzBGC0YQAY7mzRJWsI6
L4AIazTpVkNg8kgFXDhpwqTorm+JA6aE0kRpk47acQEkMUVJU6cs0NEC8FGKEiVOfQb+ZMcKgMWk
TM0joRgPFQCIQMw1bXpy9rjC22+Ea+IUZwJ7pAZcIVx1jdjwX1AAKFHJJt5lgsWBOgGwAyScUHKJ
JoJIAKFMpRlSIXOj3LAhSwAkgMeHlIDixYgkauGdJpds4ggFLO5EhCOaWMKcKUMEEGFaJfzBoG6d
vAEBgipl9cAZoFRXXSQ41OgRAAHUJgATp1Sn2yZjJNBeARi8FZYMoGByoW6IrEbeD04Y9RAAFBwy
JHOYdCFlS1T8UQROCwVgxocwapIIB3cuBsAWppgxQ5KLGfGibpSI4kShLTnQRiqEWPHBUQCYAJ9u
zHHCxwGUtiQCH6RwYscRBOS0QBjKsYGqCSk1lMpQDoxs0okjaVjVEABCVBIfc6CwccBxADwxCaiF
VEHqBosAqhsnMdiaUABoDCsJIDq40YmZkIJCBgP2/VMiIAxWd4kkTsr6SA7W3ndBJMPJai8naSBQ
Lk0zxKalvZo00kO8DgXAxID2UmLJHARLtAAYsdorCQ0NS/TBHcMytwkdFb8JgyHDYuKJCx2/OcQm
mFhCSScM73tfFNRhMsoLJY+UwBeneAKHly7fZ0EdqOxQc0UAvFBGBT0/JEAD9SWN0XEBAQA7
"""
wrong = """R0lGODlhQABAAOexAAAAAAEAAAIAAAMAAAQAAAUAAAYAAAgAAAkAAAoAAAwAAA0AAA4AAA8AABAA
ABEAABIAABMAABQAABUAABYAABcAABgAABkAABoAABsAABwAAB0AAB4AAB8AACAAACEAACIAACMA
ACQAACUAACYAACgAACkAACoAACsAACwAAC0AAC4AADEAADMAADQAADUAADYAADgAADkAADoAADsA
ADwAAD0AAD4AAD8AAEEAAEIAAEQAAEUAAEkAAEoAAEsAAFQAAFUAAFgAAFkAAF0AAF8AAGEAAGIA
AGQAAGcAAGgAAGoAAGsAAG0AAG4AAG8AAHAAAHMAAHgAAHsAAHwAAIEAAIYAAIoAAI4AAJMAAJQA
AJUAAJYAAJcAAJgAAJkAAJoAAJsAAJwAAJ0AAJ4AAKAAAKEAAKQAAKcAAKgAAKkAAKoAAK0AAK4A
AK8AALAAALEAALMAALUAALcAALgAALkAALoAALsAAL4AAL8AAMAAAMEAAMQAAMUAAMYAAMgAAMkA
AMoAAMwAAM0AAM4AAM8AANAAANEAANIAANMAANQAANUAANYAANcAANgAANkAANoAANsAAN0AAN4A
AOAAAOEAAOIAAOMAAOQAAOYAAOgAAOkAAOoAAOwAAO0AAO4AAO8AAPAAAPEAAPIAAPMAAPQAAPUA
APYAAPcAAPgAAPkAAPoAAPsAAPwAAP0AAP4AAP8AAP//////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////yH+EUNyZWF0ZWQgd2l0aCBH
SU1QACH5BAEKAP8ALAAAAABAAEAAAAj+AP8JHEhwIAAABRMqXLjwIMOHCQFAgIAQosWGFjRUvNhQ
A5sxDTZyvAggwhpAK0SOFAigwxxXo7aEXGmxZBlSqwbFUMmx5Z1To0qN4oKAJ02DCsiQEmqKUA2j
DwFsoFOKFKlRpE55CQB1JQABZE5dtVqqEIyuES28STXW6ihWXxweNQhAzCqsVq+eMpQCrUEKamCN
wpt3VKsvBPwyBEDASyvChVcdKuEXQIU0giEXVtVFgWKFCbKo0lyY1SEVXQFcaJM5r+u8pbY4+ExQ
AZbXuK+uQjTDKAAMckaTdh00pueRCK6IEpqb+ClEOVSqliN0+OugpbgkrinASinmzYn+l0KEYyMA
Cm3EWseNVZUXuQ0BVFnVNvxrU4peIATQ4AzM9c0ZtlVqVAhmX4CpKBLCQR8UYkp9BxLHShdFKUTA
FDBFyB4ppugBwn4m8CGWhuydIpNKBkxhCoD2mXLHhwad8MeKJLKnBQMbFSAFKODVeJUpe4ggHQiH
0OjjVUJtcQBCAkTBI4u5jXLKIBz4VsEjQB05FipdHLTEKdUdKWUjE6QmQSMPQskeK1sQ4QqEGmJl
SiMSVKbBIOppOYoqj6lJXFaFbPAZACT0kaeYcEaI1SmBnEDbPwCgYKiWlOZ1iiAsPMoSCYMYWSmJ
QTGS0lwAaNBIlp8qWoolJGhaEAD+EjziaapRlpIJjHMZVEGRiaYqJyWU5foqCH8cSuuWjrTgalQn
iHisa6csYsOyEAFgAiCzVhqUJOUJG5UHiWSL6Ca9eVstBYw8mKonZ5lbUxOspJoKGvC5q1AASbDi
Z4CrgFGhvQkN0ESatI6CChgPUAvRAFB40uOxYkSg8EIBONGJuNpWZcYCE7+qxFKDPesWh2psZy4A
R7TS67F7viFAxwAg8UrIIrO3ShwJKCwAE6nQXDN7qLxBwbIDPBHKyj9bZUobGq0kwBOdPJz0dUvB
cQFtADARSpg+yrlvYRzaMVtNSLDlM6ikdJLu1yOfwse/DR0xM9tYlcLJCxIgQrD+mKgAMtO9SvSJ
6CmUTAsAB37s3TUqfmTA0wBOjKwlKpDsUBGheIyo5yl6tEoQw1Gz/eMkPIgEwAh5oKrlKXl4/s8B
DWN8IFaadPtqBn2gIrqcf6BwUAaCCIdoKDs1xMAfPW+uiQv7vaCIumiX8ol+USHg7NelYPKDeTgg
InWAWWFSbrUN1KG4fVhVIoR0OSCiOvioRKID1mpVxWJQlhDhmwyI3HXgKZEonVcywAboBegUmghC
alRwCH0FKHvzOwoAJuAG3R3QEz2oTAkM4T+qfWJ8EkwAHDronE9EsCYpKMT7sBIK6gkLAAFow2jE
wwkfPAoAMCBEVcZiCk0U72RWBEiD4jAxBFcBgAaEoBEqJmE7dwFgATcRSikuYQRqASAGg1DFKSAh
QIBBCgJh4NAmijAxAKxAEJiwnBcN4gAwdAIIHYNUB24Qx8U8QFn2guEaI/KZgAAAOw=="""
self.correct_img = PhotoImage(data=correct)
self.wrong_img = PhotoImage(data=wrong)
self.entry = Entry(self.parent, width=15,
font=('Helvetica', 20, 'normal'), justify=CENTER)
self.entry.bind("<Return>", lambda x:self.buttonSubmit.invoke())
self.buttonNext = Button(self.parent, width=10, text="Next Word",
command=self.next_word, state=DISABLED)
self.buttonSubmit = Button(self.parent, width=10, text="Submit",
command=self.submit_word)
buttonReplay = Button(self.parent, width=10, text="Repeat Word",
command=self.replay_word)
self.game_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.word_display = self.game_canvas.create_text((300, 105), text="?",
font=("Helvetica", 50, "bold"), fill="#004183")
self.progress_display = self.game_canvas.create_text((593, 5),
text="%d/%d"%(1, self.parent.list_length),
font=("Helvetica", 25, "bold"), anchor=NE)
self.timer_display = self.game_canvas.create_text(10, 5, anchor=NW,
font=("Helvetica", 25))
self.progress_bar = ProgressBar(self, width=300,
increments=len(self.parent.current_list.words))
self.game_canvas.create_window(500, 10, anchor=NE, window=self.progress_bar)
self.game_canvas.create_window(300, 180, window=self.entry)
self.game_canvas_image = self.game_canvas.create_image(500, 170)
self.game_canvas.create_window(150, 230, window=buttonReplay)
self.game_canvas.create_window(300, 230, window=self.buttonSubmit)
self.game_canvas.create_window(450, 230, window=self.buttonNext)
self.game_canvas.pack()
def start(self):
self.current_list_iter = iter(self.parent.current_list.words)
self.current_word = self.current_list_iter.next()
self.parent.festival.speech(self.current_word)
self.time_elapsed = 0
self.init_gui()
self.tick()
def next_word(self):
try:
self.current_word = self.current_list_iter.next()
index = self.parent.current_list.words.index(self.current_word) + 1
self.game_canvas.itemconfig(self.progress_display, text="%d/%d"
%(index, self.parent.list_length))
if index == self.parent.list_length:
self.buttonNext.configure(text="Finish")
self.game_canvas.itemconfig(self.word_display, text="?", fill="#004183")
self.game_canvas.itemconfig(self.game_canvas_image, state=HIDDEN)
self.buttonSubmit.configure(state=NORMAL)
self.buttonNext.configure(state=DISABLED)
self.parent.festival.speech(self.current_word)
except StopIteration:
self.list_complete()
def list_complete(self):
self.parent.after_cancel(self.timer)
self.parent.show_results(self.time_elapsed)
def replay_word(self):
self.parent.festival.speech(self.current_word)
def submit_word(self, event=None):
guess = self.entry.get()
self.entry.delete(0, END)
if guess == self.current_word.word:
self.correct(guess)
else:
self.incorrect(guess)
self.game_canvas.itemconfig(self.word_display, text='%s'%(self.current_word))
self.buttonNext.configure(state=NORMAL)
self.buttonSubmit.configure(state=DISABLED)
self.game_canvas.itemconfig(self.game_canvas_image, state=NORMAL)
def correct(self, guess):
self.current_word.setAnswer(guess, True)
self.game_canvas.itemconfig(self.game_canvas_image, image=self.correct_img)
self.game_canvas.itemconfig(self.word_display, fill="#139E1C")
self.progress_bar.increment(True)
def incorrect(self, guess):
self.current_word.setAnswer(guess, False)
self.game_canvas.itemconfig(self.game_canvas_image, image=self.wrong_img)
self.game_canvas.itemconfig(self.word_display, fill="#F30000")
self.progress_bar.increment(False)
def tick(self):
seconds = (self.time_elapsed)%60
minutes = self.time_elapsed/60
separator = ":" if seconds > 9 else ":0"
formatted_time = "%d%s%d"%(minutes, separator, seconds)
self.game_canvas.itemconfig(self.timer_display, text=formatted_time)
self.time_elapsed +=1
self.timer = self.parent.after(1000, self.tick)
Canvas and scrollbar"""
scrollbar = Scrollbar(window)
canvas = Canvas(window,
width=460,
height=700,
yscrollcommand=scrollbar.set,
scrollregion=(0, 0, 0, 890))
canvas.pack(side=LEFT)
scrollbar.pack(side=LEFT, fill=Y)
scrollbar.config(command=canvas.yview)
#Create invisible frames to organize layout
frame1 = Frame(window, width="200", padx=10) #where widgets will be
canvas.create_window(230, 440, window=frame1)
#This will make the frame stay static:
for i in range(1, 8):
frame1.grid_rowconfigure(i, minsize=50, weight=1)
for i in range(9, 14):
frame1.grid_rowconfigure(i, minsize=30, weight=1)
for i in [15, 16]:
frame1.grid_rowconfigure(i, minsize=60, weight=1)
for i in range(19, 22):
frame1.grid_rowconfigure(i, minsize=30, weight=1)
frame1.grid_columnconfigure(1, minsize=180, weight=1)
frameOUT = Frame(window, width="812", height="700", bg="thistle4") #For plots
frameOUT.pack(side=LEFT, fill=BOTH, expand=1)
#These will make the plots appear centered
frameOUT.grid_rowconfigure(0, minsize=5, weight=1)
class OfxConverter(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, background=u"white")
self.parent = parent
self.guiMap = []
self.debitValue = StringVar()
self.creditValue = StringVar()
self.row = 0
self.frame = Frame()
self.UNUSED = u"Unused"
self.initUI()
def writeLog(self,*msgs):
self.log[u'state'] = u'normal'
if self.log.index(u'end-1c')!=u'1.0':
self.log.insert(u'end', u'\n')
for msg in msgs:
self.log.insert(u'end', msg)
## self.log['state'] = 'disabled'
def help(self):
t = Toplevel()
t.wm_title(u"About")
t.transient()
photo = ImageTk.PhotoImage(file=u"chameleon.png")
## photo = PhotoImage(file="chameleon.gif")
w = Label(t, image=photo)
w.photo = photo
w.pack(fill=constants.BOTH,side=constants.LEFT,expand=True)
l = Label(t, text=u"OFX Converter\n\n"+
u"Convert files in csv format to the\nofx format " +
u"which is used by a lot\nof accounting programs " +
u"like gnucash\n\n Written in Python 3\nby Floris Groenendijk"
)
l.pack(side=constants.TOP, fill=u"both", expand=False, padx=20, pady=20)
def onComboboxChanged(self, event):
if event.widget.get() == u'credit/debit':
# check which checkbox in which column was changed
for i in xrange(len(self.comboBoxes)-1):
if self.comboBoxes[i] == event.widget:
break
values = []
# retrieve the values of the labels in that column
for j in xrange(len(self.labels)):
if self.labels[j][i][u'text'] not in values:
values.append(self.labels[j][i][u'text'])
self.creditCombo[u'values'] = values
self.creditCombo.current( 0 )
if len( values ) > 1:
self.debitCombo[u'values'] = values
self.debitCombo.current( 1 )
def onFrameConfigure(self, event):
# Reset the scroll region to encompass the inner frame
self.canvas.configure(scrollregion=self.canvas.bbox(u"all"))
def initUI(self):
self.parent.title(u"OFX Converter")
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = Menu(menubar)
fileMenu.add_command(label=u"Open", command=self.openFile, accelerator=u"Ctrl-o")
fileMenu.add_command(label=u"Exit", command=self.onExit, accelerator=u"Ctrl-e", underline=1 )
menubar.add_cascade(label=u"File", menu=fileMenu)
helpMenu = Menu(menubar)
helpMenu.add_command(label=u"About", command=self.help, accelerator=u"Ctrl-i")
menubar.add_cascade(label=u"Info", menu=helpMenu)
notebook = ttk.Notebook( self.parent )
tabFilesMain = Frame( notebook )
self.tabFiles = Frame( tabFilesMain )
self.tabFiles.pack(fill=constants.BOTH)
button = ttk.Button( tabFilesMain, command=self.parseFile, text=u"Process" )
button.pack(side=u"bottom", fill=constants.X, padx=5, pady=5)
tabLogging = Canvas( notebook )
tabLogging.grid_rowconfigure(0, weight=1)
tabLogging.grid_columnconfigure(0, weight=1)
# begin of custom csv frame
tabCustomCsv = Frame( notebook )
verticalScrollFrame = Frame( tabCustomCsv )
verticalScrollFrame.grid( row=0, column=0, rowspan=3, sticky=u"WNS" )
tabCustomCsv.grid_columnconfigure(0, weight=0)
tabCustomCsv.grid_columnconfigure(1, weight=1)
tabCustomCsv.grid_rowconfigure(2,weight=1)
self.comboFrame = Frame( tabCustomCsv )
self.comboFrame.grid( row=1, column=1, sticky=u"WE" )
canvasFrame = Frame( tabCustomCsv)
canvasFrame.grid( row=2, column=1, sticky=u"NEWS" )
horizontalScrollFrame = Frame( tabCustomCsv )
horizontalScrollFrame.grid( row=3, column=1, columnspan=1, sticky=u"WE" )
self.canvas = Canvas( canvasFrame, highlightthickness=0 )
scrollbar=Scrollbar( horizontalScrollFrame,orient=u"horizontal",command=self.canvas.xview)
self.canvas.configure(xscrollcommand=scrollbar.set)
self.canvas.pack(fill=constants.BOTH,expand=True)
scrollbar.pack(side=u"bottom", fill=constants.X)
scrollbar=Scrollbar( verticalScrollFrame,orient=u"vertical",command=self.canvas.yview)
self.canvas.configure(yscrollcommand=scrollbar.set)
scrollbar.pack(side=u"left", fill=constants.Y)
self.canvas.pack(fill=constants.BOTH,expand=1,anchor=u"nw")
# end of custom csv frame
# begin of config frame
configurationFrame = Frame( tabCustomCsv )
Label( configurationFrame, text=u"Values to determine whether the debit field concerns a debit or credit transaction and set the currency" ).pack(anchor=constants.W)
currencyLine = Frame( configurationFrame )
currencyLine.pack(fill=constants.X)
Label( currencyLine, text=u"currency", width=7, anchor=constants.W ).pack(side=constants.LEFT)
self.currencyCombo = ttk.Combobox( currencyLine,width=30,text=u"currency" )
self.currencyCombo.pack(side=constants.LEFT)
config = Config()
self.currencies = config.getCurrencies()
self.currencyCombo[u'values'] = list(sorted(self.currencies.keys()))
Label( configurationFrame, text=u"credit", width=7, anchor=constants.W ).pack(side=constants.LEFT)
self.creditCombo = ttk.Combobox(configurationFrame,width=10,text=u"credit")
self.creditCombo.pack(side=constants.LEFT)
Label( configurationFrame, text=u"debit", width=6, anchor=constants.W ).pack(side=constants.LEFT)
self.debitCombo = ttk.Combobox( configurationFrame,width=10,text=u"debit" )
self.debitCombo.pack(side=constants.LEFT)
Button( configurationFrame, text=u"save configuration", command=self.saveConfig ).pack(side=constants.RIGHT )
configurationFrame.grid( row=4, column=0, columnspan=2, sticky=u"WES")
# end of config frame
self.log = Text(tabLogging, wrap=u'word')
self.log.grid(row=0,column=0,sticky=u'news')
hScroll = Scrollbar(tabLogging, orient=constants.HORIZONTAL, command=self.log.xview)
hScroll.grid(row=1, column=0, sticky=u'we')
vScroll = Scrollbar(tabLogging, orient=constants.VERTICAL, command=self.log.yview)
vScroll.grid(row=0, column=1, sticky=u'ns')
self.log.configure(xscrollcommand=hScroll.set, yscrollcommand=vScroll.set)
notebook.add( tabFilesMain, text=u"Files to process" )
notebook.add( tabCustomCsv, text=u"Custom csv" )
notebook.add( tabLogging, text=u"Logging" )
notebook.pack(fill=constants.BOTH,expand=1,anchor=constants.N)
self.tabFiles.grid_columnconfigure( 0, weight=1 )
def addFile(self,filename,ibans):
if filename != u"" and len(ibans) > 0:
Label(self.tabFiles, text=filename,
borderwidth=3).grid(row=self.row,column=0,sticky=constants.W,padx=1)
ibanList = []
for iban in ibans:
ibanList.append( iban[:8] )
combo = ttk.Combobox(self.tabFiles,values=ibanList)
combo.current(0)
if len(ibanList) == 1:
combo.configure(state=constants.DISABLED)
combo.grid(row=self.row,column=1,sticky=constants.E,padx=1)
state = IntVar()
c = Checkbutton(self.tabFiles,variable=state)
c.grid(row=self.row,column=2)
self.row += 1
ttk.Separator(self.tabFiles).grid(row=self.row, sticky=u"ew", columnspan=3 )
self.row += 1
self.guiMap.append( [ filename, ibans, combo, c, state ] )
def addFileToCustomTab(self,filename):
if filename != u"":
if self.frame:
self.frame.pack_forget()
self.frame.destroy()
self.frame = Frame( self.canvas )
self.canvas.create_window((0,0),window=self.frame,anchor=u'nw')
self.frame.bind(u"<Configure>", self.onFrameConfigure)
file = csv.reader( open(filename) )
lines = 1
transaction = Transaction()
fields = transaction.fields
fields.insert(0,u"main account")
fields.insert(0,self.UNUSED)
self.comboBoxes = []
self.labels = collections.defaultdict(list)
for row in file:
column = 0
for field in row:
if lines == 1:
combo = ttk.Combobox(self.frame,values=transaction.fields,state=u"readonly")
combo.current(0)
combo.grid(row=0,column=column,sticky=constants.W)
self.comboBoxes.append( combo )
combo.bind(u'<<ComboboxSelected>>', self.onComboboxChanged)
nextColumn = column + 1
ttk.Separator(self.frame,orient=constants.VERTICAL).grid(row=0, column=nextColumn, sticky=u"ns")
label = Label(self.frame,text=field,borderwidth=3)
label.grid(row=lines,column=column,sticky=constants.W,padx=1)
self.labels[lines-1].append( label )
column = column + 1
ttk.Separator(self.frame,orient=constants.VERTICAL).grid(row=lines, column=column, sticky=u"ns")
column = column + 1
lines = lines + 1
if lines > 11:
break
def saveConfig(self):
fields = {}
memos = []
for i in xrange( len(self.comboBoxes) - 1 ):
key = self.comboBoxes[i].get()
if key == self.UNUSED:
continue
elif key == u'credit/debit':
fields[ key ] = u' '.join( [ unicode(i), self.creditCombo.get(), self.debitCombo.get() ] )
elif key == u'memo':
memos.append( unicode(i) )
elif key == u'main account':
fields[ key ] = self.labels[0][i][u'text']
else:
fields[ key ] = i
if len(memos) > 0:
fields[u'memo'] = u' '.join( memos )
config = Config()
(bankKey, bankValue) = config.addToConfig( fields )
self.writeLog( u'key', bankKey, u"with value", bankValue, u"added to config file" )
def openFile(self):
if sys.version_info >= (3,0):
filename = filedialog.askopenfilename(parent=self.parent,
filetypes=[(u'Csv files',u'.csv'),
(u'All Files',u'.*')],
title=u'Select the csv')
else:
filename = tkFileDialog.askopenfilename(parent=self.parent,
filetypes=[(u'Csv files',u'.csv'),
(u'All Files',u'.*')],
title=u'Select the csv')
if filename != u"":
self.writeLog( u'File added: ', filename )
bank = Bank()
ibans = bank.searchMainIban( filename )
# If mainIban contains more than one iban,
# let the user select which one is the main iban
# Otherwise we know the bank this csv belongs to
if len( ibans ) > 1:
self.writeLog( u'there\'s too many ibans, please select one from the list' )
elif len( ibans ) == 0:
self.writeLog( u'No ibans found, is the file correct?' )
## adding file to custom csv tab
else:
self.writeLog( u'Found iban: ', ibans[0][:8] )
ibanType = ibans[0][:8]
self.addFile(filename,ibans)
self.addFileToCustomTab( filename )
def parseFile(self):
for guiLine in self.guiMap:
( filename, ibans, combo, checkButton, state ) = guiLine
if state.get():
ibanType = combo.get()
config = Config()
fields = config.getCurrentBank( ibanType )
bankStatement = BankStatement()
bankStatement.account = ibans[0]
csvReader = CsvReader(fields)
csvReader.readFile( filename, bankStatement )
ofx = Ofx()
ofx.createXmlFile( filename, bankStatement )
checkButton.configure(state=constants.DISABLED)
def onExit(self):
quit()
class Scrolling_Area(Frame, object):
def __init__(self, master, width=None, anchor=N, height=None, mousewheel_speed = 2, scroll_horizontally=True, xscrollbar=None, scroll_vertically=True, yscrollbar=None, outer_background=None, inner_frame=Frame, **kw):
Frame.__init__(self, master, class_=self.__class__)
if outer_background:
self.configure(background=outer_background)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self._width = width
self._height = height
self.canvas = Canvas(self, background=outer_background, highlightthickness=0, width=width, height=height)
self.canvas.grid(row=0, column=0, sticky=N+E+W+S)
if scroll_vertically:
if yscrollbar is not None:
self.yscrollbar = yscrollbar
else:
self.yscrollbar = Scrollbar(self, orient=VERTICAL)
self.yscrollbar.grid(row=0, column=1,sticky=N+S)
self.canvas.configure(yscrollcommand=self.yscrollbar.set)
self.yscrollbar['command']=self.canvas.yview
else:
self.yscrollbar = None
if scroll_horizontally:
if xscrollbar is not None:
self.xscrollbar = xscrollbar
else:
self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
self.xscrollbar.grid(row=1, column=0, sticky=E+W)
self.canvas.configure(xscrollcommand=self.xscrollbar.set)
self.xscrollbar['command']=self.canvas.xview
else:
self.xscrollbar = None
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.innerframe = inner_frame(self.canvas, **kw)
self.innerframe.pack(anchor=anchor)
self.canvas.create_window(0, 0, window=self.innerframe, anchor='nw', tags="inner_frame")
self.canvas.bind('<Configure>', self._on_canvas_configure)
Mousewheel_Support(self).add_support_to(self.canvas, xscrollbar=self.xscrollbar, yscrollbar=self.yscrollbar)
@property
def width(self):
return self.canvas.winfo_width()
@width.setter
def width(self, width):
self.canvas.configure(width= width)
@property
def height(self):
return self.canvas.winfo_height()
@height.setter
def height(self, height):
self.canvas.configure(height = height)
def set_size(self, width, height):
self.canvas.configure(width=width, height = height)
def _on_canvas_configure(self, event):
width = max(self.innerframe.winfo_reqwidth(), event.width)
height = max(self.innerframe.winfo_reqheight(), event.height)
self.canvas.configure(scrollregion="0 0 %s %s" % (width, height))
self.canvas.itemconfigure("inner_frame", width=width, height=height)
def update_viewport(self):
self.update()
window_width = self.innerframe.winfo_reqwidth()
window_height = self.innerframe.winfo_reqheight()
if self._width is None:
canvas_width = window_width
else:
canvas_width = min(self._width, window_width)
if self._height is None:
canvas_height = window_height
else:
canvas_height = min(self._height, window_height)
self.canvas.configure(scrollregion="0 0 %s %s" % (window_width, window_height), width=canvas_width, height=canvas_height)
self.canvas.itemconfigure("inner_frame", width=window_width, height=window_height)
class Path:
def __init__(self, root):
self.canvas = Canvas(root, borderwidth=1, background="#ffffff")
self.frame = Frame(self.canvas, background="#ffffff")
self.vsb = Scrollbar(root, orient="vertical", command=self.canvas.yview)
self.canvas.configure(yscrollcommand=self.vsb.set)
self.vsb.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
self.canvas.create_window((4,4), window=self.frame, anchor="nw", tags="self.frame")
self.frame.bind("<Configure>", self.OnFrameConfigure)
self.data()
def data(self):
global textPath
textPath = StringVar()
global text0a
text0a = StringVar()
global text0b
text0b = StringVar()
global text2a
text2a = StringVar()
global text3
text3 = StringVar()
global alphaVar
alphaVar = IntVar()
global betaVar
betaVar = IntVar()
global allVar
allVar = IntVar()
global text6a
text6a = "0"
global filterVar
filterVar = IntVar()
global text6b
text6b = StringVar()
global t1x
t1x = ""
global t2x
t2x = ""
global t3x
t3x = ""
global t4x
t4x = ""
global text8_0
text8_0 = StringVar()
global text8_1
text8_1 = StringVar()
Label(self.frame,text="Path ? ").grid(row=0, column=0)
Entry(self.frame,textvariable=textPath).grid(row=1, column=0)
Button(self.frame, text="Valider et afficher", command = affiche_recap).grid(row=1, column=1)
Label(self.frame, text="Green function database information file\n (for a certain depth only for the instance) ?").grid(row=3)
Entry(self.frame, textvariable=text0a).grid(row=4)
Label(self.frame, text="Output directory (parentdir) ?").grid(row=5)
Entry(self.frame, textvariable=text0b).grid(row=6)
Label(self.frame, text="Phase name ?").grid(row=9)
Entry(self.frame, textvariable=text3).grid(row=10)
def afficheAlpha():
seismicPara["text"]="alpha"
betaVar.set(0)
allVar.set(0)
def afficheBeta():
seismicPara["text"]="beta"
alphaVar.set(0)
allVar.set(0)
def afficheAll():
seismicPara["text"]="all"
alphaVar.set(0)
betaVar.set(0)
seismicPara = Menubutton(self.frame, text="Seismic Parameter", relief=RAISED)
seismicPara.grid(row=0)
seismicPara.menu = Menu(seismicPara, tearoff = 0)
seismicPara["menu"] = seismicPara.menu
seismicPara.menu.add_checkbutton(label="alpha", variable = alphaVar, command = afficheAlpha)
seismicPara.menu.add_checkbutton(label="beta", variable = betaVar, command = afficheBeta)
seismicPara.menu.add_checkbutton(label="all", variable = allVar, command = afficheAll)
seismicPara.grid(row=11)
Label(self.frame, text="Filter name ?").grid(row=12)
Entry(self.frame, textvariable=text6b).grid(row=13)
Label(self.frame, text="time window t1 ?").grid(row=14)
Labelt1 = Label(self.frame, text="-->").grid(row=15)
Button(self.frame, text="time 1", command=self.time1).grid(row=15, column=1)
Label(self.frame, text="time window t2 ?").grid(row=16)
Labelt1 = Label(self.frame, text="-->").grid(row=17)
Button(self.frame, text="time 2", command=self.time2).grid(row=17, column=1)
'''
Label(self.frame, text="time window t3 ?").grid(row=18)
Labelt1 = Label(self.frame, text="-->").grid(row=19)
Button(self.frame, text="time 3", command=self.time3).grid(row=19, column=1)
Label(self.frame, text="time window t4 ?").grid(row=20)
Labelt1 = Label(self.frame, text="-->").grid(row=21)
Button(self.frame, text="time 4", command=self.time4).grid(row=21, column=1)
'''
def affiche0():
convertPara["text"]="No conversion"
text8_1.set(0)
def affiche1():
convertPara["text"]="Conversion"
text8_0.set(0)
convertPara = Menubutton(self.frame, text="Geodetic latitude to geocentric latitude conversion", relief=RAISED)
convertPara.grid(row=0)
convertPara.menu = Menu(convertPara, tearoff = 0)
convertPara["menu"] = convertPara.menu
convertPara.menu.add_checkbutton(label="No conversion", variable = text8_0, command = affiche0)
convertPara.menu.add_checkbutton(label="Conversion", variable = text8_1, command = affiche1)
convertPara.grid(row=22)
b = Checkbutton(self.frame, text = "apply filter", variable = filterVar)
b.grid(row=23, column = 0)
Button(self.frame, text="continue", command=self.quitter).grid(row=23, column=1)
def time1(self):
global t1x
global t1y
t1x, t1y = Pointage()
print type(t1x)
print t1y
def time2(self):
global t2x
global t2y
t2x, t2y = Pointage()
print t2x
print t2y
def time3(self):
t3x, t3y = Pointage()
print t3x
print t3y
def time4(self):
t4x, t4y = Pointage()
print t4x
print t4y
def quitter(self):
root.destroy()
def OnFrameConfigure(self, event):
'''Reset the scroll region to encompass the inner frame'''
self.canvas.configure(scrollregion=self.canvas.bbox("all"))
def draw_board(root):
"""
Create the graphical user interface.
"""
# provide the title that will be shown in the header
root.title("Bonbon Crumble")
# Indicate which variables of the program will be altered
# ! In order to manipulate variables that are part of the program
# ! but exist outside of the function, you need to indicate that you want
# ! to use and alter these variables by declaring them as "global"
global canvas, board, ovals, progress_label, points_label, points_field, \
max_label, max_field, swaps_left_label, swaps_left_field
# canvas will be the main board used for mastermind
# ! to create a canvas, the constructor is called
# ! (i.e. name of the class and required parameters)
canvas = Canvas(root, bg="white",
height=DIMENSION * (BONBON_SIZE + BONBON_SPACING) + 100,
width=DIMENSION * (BONBON_SIZE + BONBON_SPACING))
# Draw the empty circles representing the guesses
create_ovals(DIMENSION, DIMENSION)
# Fill circles with initial colors
init_board(DIMENSION)
canvas.create_line(0,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING),
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 10,
width=2)
# Draw the progress label
progress_label = Label(canvas, text=">> Select first bonbon.")
canvas.create_window(10, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 15,
anchor=NW, window=progress_label)
canvas.create_line(0,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 40,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING),
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 40,
width=1)
# Draw the swaps left label and field
swaps_left_label = Label(canvas, text="Swaps left:")
canvas.create_window(10, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=swaps_left_label)
swaps_left_field = Label(canvas, text=remaining_swaps, bg="white")
canvas.create_window(2 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=swaps_left_field)
# Draw the points label and field
points_label = Label(canvas, text="Score:", font=16)
canvas.create_window(3 * (BONBON_SIZE + BONBON_SPACING),
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=points_label)
points_field = Label(canvas, text="0", font=16)
canvas.create_window(4 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=points_field)
# Draw the max points label and field
max_label = Label(canvas, text="Max score:")
canvas.create_window(5 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=max_label)
max_field = Label(canvas, text="n/a", bg="white")
canvas.create_window(7 * (BONBON_SIZE + BONBON_SPACING) + 10,
bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 50,
anchor=NW, window=max_field)
canvas.itemconfig(max_field, fill="red")
# Draw the quit button
quit_button = Button(canvas, text="Quit", command=root.destroy)
quit_button.configure(width=5, relief=FLAT)
canvas.create_window(10, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 75,
anchor=NW, window=quit_button)
# Draw the max button
max_button = Button(canvas, text="Calculate maximum score", command=get_maximum_score)
max_button.configure(width=20, relief=FLAT)
canvas.create_window(100, bonbon_asked.nb_visible_rows(board) * (BONBON_SIZE + BONBON_SPACING) + 75,
anchor=NW, window=max_button)
# draw the canvas
canvas.pack()
class TrailUI:
def __init__(self, parent, trail=None):
self.parent = parent
self.trail = trail
self.alpha_reflection = trail.alpha_reflection
self.states = []
self.probabilitylabels = {}
## scrollbar
# create a canvas object and a vertical scrollbar for scrolling it
self.scrollframe = Frame(parent)
self.hsb = Scrollbar(self.scrollframe, orient=Tkinter.HORIZONTAL)
self.hsb.pack(fill=Tkinter.X, side=BOTTOM, expand=Tkinter.FALSE)
self.scrollcanvas = Canvas(self.scrollframe,
bd=0,
highlightthickness=0,
xscrollcommand=self.hsb.set)
self.scrollcanvas.pack(side=LEFT, fill=BOTH, expand=Tkinter.TRUE)
self.hsb.config(command=self.scrollcanvas.xview)
# reset the view
self.scrollcanvas.xview_moveto(0)
self.scrollcanvas.yview_moveto(0)
# put trailframe into scrollframe and assign configs
self.trailframe = interior = Frame(self.scrollcanvas)
self.interior_id = self.scrollcanvas.create_window(10,
0,
window=interior,
anchor=Tkinter.NW)
interior.bind('<Configure>', self._configure_interior)
self.scrollcanvas.bind('<Configure>', self._configure_canvas)
self.scrollframe.pack(fill=Tkinter.X, expand=1)
self.infoframe = Frame(parent)
self.infoframe.pack(fill=Tkinter.X, expand=1, side=BOTTOM)
self.canvas = Canvas(self.infoframe, width=1000, height=200)
self.canvas.pack()
self.b = Button(self.infoframe,
text='Disable Propagation',
command=self.__toggle_prop)
self.b.pack()
self.b2 = Button(self.infoframe,
text='Make active only',
command=self.__activeonly)
self.b2.pack()
self.parent.title("ClusterF**k")
self.enable_propagation = True
self.trail.updateColorList()
self.maxgridcol = -1
self.trail.initUI(self)
# Multi Cell Selection
self.multiselection_pressed = False
self.dynamicselection_pressed = False
self.selectedcells = []
self.parent.bind("<Control_L>", self.__selection_start)
self.parent.bind("<KeyRelease-Control_L>", self.__selection_end)
self.parent.bind("<Shift_L>", self.__dynamic_selection_start)
self.parent.bind("<KeyRelease-Shift_L>", self.__dynamic_selection_end)
self.parent.bind("<Escape>", lambda event: self._clear_selection())
self.parent.bind("<Return>", lambda event: self.open_cell_dialogue())
# track changes to the canvas and frame width and sync them,
# also updating the scrollbar
# taken from https://gist.github.com/EugeneBakin/76c8f9bcec5b390e45df
def _configure_interior(self, event):
# update the scrollbars to match the size of the inner frame
size = (self.trailframe.winfo_reqwidth(),
self.trailframe.winfo_reqheight())
self.scrollcanvas.config(scrollregion="0 0 %s %s" % size)
if self.trailframe.winfo_reqwidth() != self.scrollcanvas.winfo_width():
# update the canvas's width to fit the inner frame
self.scrollcanvas.config(width=self.trailframe.winfo_reqwidth())
def _configure_canvas(self, event):
if self.trailframe.winfo_reqwidth() != self.scrollcanvas.winfo_width():
# update the inner frame's width to fill the canvas
self.scrollcanvas.itemconfigure(
self.trailframe, width=self.scrollcanvas.winfo_width())
def __selection_start(self, event):
print "Selection start/continue"
self.multiselection_pressed = True
def __dynamic_selection_start(self, event):
print "Dynamic selection start"
self.dynamicselection_pressed = True
def __selection_end(self, event):
print "Selection end"
self.multiselection_pressed = False
def __dynamic_selection_end(self, event):
print "Dynamic selection end"
self.dynamicselection_pressed = False
def open_cell_dialogue(self):
if len(self.selectedcells) is 0:
return
# oldstate = self.__clickedcells[0]["oldstate"]
# oldstatestr = ",".join(["{:x}".format(x) for x in oldstate])
oldstatestr = ""
dialog = StatePopup(
self, oldstatestr,
self.selectedcells[0]["state_probs"]) # TODO add probs
self.trailframe.wait_window(dialog.top)
newstate = dialog.value
# set each cell of the selection to the new state
if newstate is not None:
for i, cell in enumerate(self.selectedcells):
cell["stateUI"].state.set(cell["row"], cell["col"],
set(newstate))
# self._clear_selection()
self.redraw_all()
self.redraw_selection()
def _clear_selection(self):
for cell in self.selectedcells:
cell["stateUI"].undraw_selection(cell)
self.selectedcells = []
def __toggle_prop(self):
self.enable_propagation = not self.enable_propagation
if self.enable_propagation:
self.b.config(text="Disable Propagation")
self.redraw_all()
else:
self.b.config(text="Enable Propagation")
def __activeonly(self):
self.trail.makeActiveOnly()
self.redraw_all()
def get_stateui_at(self, row, col):
# retrieve state from specific grid position
for state in self.states:
if state._row is row and state._col is col:
return state
return self.get_stateui_at(row, col - 1)
def redraw_selection(self):
for cell in self.selectedcells:
cell["stateUI"].draw_selection(cell)
def redraw_all(self):
if self.enable_propagation:
self.trail.propagate()
self.trail.getProbability(verbose=True)
self.redrawColorList()
self.redraw_states()
self.redraw_selection()
if self.enable_propagation:
self.redraw_probablities()
def redraw_states(self):
for state in self.states:
state.redraw_state()
if PRINT_PROPS is True:
for state in self.states:
state.redraw_propagation()
def redraw_probablities(self):
if self.alpha_reflection is True:
for i, prob in enumerate(self.trail.probabilities):
overallprob, sboxprob, mixcolprob = prob.getProbability()
if i < self.trail.rounds:
self.probabilitylabels["S" + str(i)].textvar.set(
"2^{0:.2f}".format(math.log(sboxprob, 2)))
self.probabilitylabels["M" + str(i + 1)].textvar.set(
"2^{0:.2f}".format(math.log(mixcolprob, 2)))
elif i >= self.trail.rounds + 1:
self.probabilitylabels["S" + str(i + 2)].textvar.set(
"2^{0:.2f}".format(math.log(sboxprob, 2)))
self.probabilitylabels["M" + str(i + 1)].textvar.set(
"2^{0:.2f}".format(math.log(mixcolprob, 2)))
else: # inner round
self.probabilitylabels["I"].textvar.set("2^{0:.2f}".format(
math.log(overallprob, 2)))
else:
for i, prob in enumerate(self.trail.probabilities):
overallprob, sboxprob, mixcolprob = prob.getProbability()
self.probabilitylabels["S" + str(i + 1)].textvar.set(
"2^{0:.2f}".format(math.log(sboxprob, 2)))
self.probabilitylabels["M" + str(i + 1)].textvar.set(
"2^{0:.2f}".format(math.log(mixcolprob, 2)))
def redrawColorList(self):
self.canvas.delete("colorlist")
self.trail.updateColorList()
for i, (state, color) in enumerate(self.trail.colorlist.items()):
statestr = ",".join(["{:x}".format(x) for x in state])
x = 15 + int(i / 5) * 250
y = 15 + (i % 5) * 40
self.canvas.create_rectangle(x,
y,
x + 25,
y + 25,
fill=color,
tags="colorlist")
textx = x + 40
texty = y + 12
self.canvas.create_text(textx,
texty,
text=statestr,
tags="colorlist",
fill="black",
anchor="w")
def cleanup(self):
self.infoframe.destroy()
self.trailframe.destroy()
class LoginFrame(Frame):
"""Class which controls the Login and Register screens of the spelling aid"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.db = self.parent.db
#Create login screen widgets
font = ("Helvetica", 20)
self.userEntry = Entry(self.parent, width=15, font=font)
self.passEntry = Entry(self.parent, width=15, show='*', font=font)
self.passEntry.bind('<Return>', self.login)
buttonSubmit = Button(self.parent, text="Login", command=self.login, width=10)
buttonRegSwitch = Button(self.parent, text="New User",
command=self.viewRegister, width=10)
#Create register screen widgets
self.userRegEntry = Entry(self.parent, width=15, font=font)
self.passRegEntry = Entry(self.parent, width=15, show='*',
font=font)
self.passRegEntry.bind('<Return>', self.register)
buttonRegister = Button(self.parent, text="Register",
command=self.register, width=10)
buttonBack = Button(self.parent, text="Back",
command=self.viewLogin, width=10)
#Create a canvas for each screen and populate
self.login_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.register_canvas = Canvas(self, width=600, height=250, bg="#FFFFFF")
self.login_canvas.create_text(300, 40, text="Login", font=font, fill="#004183")
self.login_canvas.create_text(170, 80, text="Username:"******"Password:"******"Register", font=font, fill="#004183")
self.register_canvas.create_text(170, 80, text="Username:"******"Password:"******"Check the user's input and allow access if it is correct"""
usernameGiven = self.userEntry.get()
passwordGiven = self.passEntry.get()
userDetails = self.db.sql("""SELECT * FROM
users WHERE username='******'"""
%(usernameGiven.lower().strip()))
#Check that the username exists
if len(userDetails)==1:
passHash = userDetails[0][2]
#Check that the password is correct
if (hashlib.sha1(passwordGiven).hexdigest() == passHash):
#Details are correct, unlock application
self.parent.login(User(userDetails[0]))
loginFailed = False
else:
loginFailed = True
else:
loginFailed = True
if loginFailed:
#If details are incorrect show an error message
tkMessageBox.showerror("Login Failed",
"Invalid username or password")
self.userEntry.delete(0, END)
self.passEntry.delete(0, END)
def register(self):
"""Register a new user with provided input"""
username = self.userRegEntry.get()
passwd = self.passRegEntry.get()
if username != '' and passwd != '':
username = username.lower().strip()
passHash = hashlib.sha1(passwd).hexdigest()
self.db.sql("""INSERT INTO users (username, passwd) VALUES
('%s', '%s')"""%(username, passHash))
self.viewLogin()
def viewRegister(self):
"""Switch to the register screen"""
self.login_canvas.pack_forget()
self.register_canvas.pack()
def viewLogin(self):
"""Switch to the login screen"""
self.register_canvas.pack_forget()
self.login_canvas.pack()
def displayFrame(self, data):
root = Tk()
root.title('Book Bank')
root.geometry("380x620")
yscrollbar = Scrollbar(root)
canvas = Canvas(root,
background="cadetblue4",
yscrollcommand=yscrollbar.set) # BG="#D2D2D2"
yscrollbar.config(command=canvas.yview)
yscrollbar.pack(side=RIGHT, fill=Y)
# Create the frame which will hold the widgets
canvas.pack(fill="both", expand=1)
# im = PhotoImage(file='/Users/RaMD/PycharmProjects/Exchange_Borrowing_Books/wall2.gif')
lf = LabelFrame(
canvas,
text=unicode("قائمة الكتب", "utf-8"),
bg='cadetblue4',
fg='gray99'
).grid(row=1, column=1, padx=80,
pady=50) # pack(expand=1, padx=20, pady=30, ipadx=20, ipady=18)
frame = Frame(lf)
im = Image.open('wall3.jpg')
img = ImageTk.PhotoImage(image=im)
# canvas.create_image(0, 0, anchor=NE, image=img)
Label(canvas, image=img).grid(row=0, column=0)
Label(root,
text=unicode("الكتب المتوفرة", "utf-8"),
bg='black',
fg="white",
width=40).place(x=0, y=0)
# method for book pic botton
def take(id, tableName):
root.destroy()
from Frame4_randa import BOOK_PROGRAM
BOOK_PROGRAM().show(id + 1, tableName)
def insert(tableName, tableIndex):
print('entered ')
root.destroy()
from insertFrame import database
database().show(tableName, tableIndex)
def back():
root.destroy()
from FrameSpecialty import Framespecialty
Framespecialty().frame1()
im = list(range(len(data)))
# this loop place book name image and price thaat gots from database
for i in range(len(data)):
#byteImgIO = io.BytesIO(data[i][1])
#byteImg = Image.open(byteImgIO)
#file_like = BytesIO(data[i][1])
#img1 = PIL.Image.open(file_like, mode='r').convert('RGB')
file_like = cStringIO.StringIO(data[i][1])
img1 = PIL.Image.open(file_like, mode='r').convert('RGB')
im1 = img1.resize((150, 150),
PIL.Image.ANTIALIAS) # to chage image size
im[i] = ImageTk.PhotoImage(im1)
Button(frame,
text=unicode(" اسم الكتاب: ", "utf-8") + str(data[i][0]) +
'\n' + unicode(" سعر الكتاب: ", "utf-8") + str(data[i][2]),
compound='top',
image=im[i],
command=lambda i=i: take(i, self.tableName)).pack()
# استعارة الكتاب
# seller button
Button(canvas,
text=unicode(" اضافة كتاب: ", "utf-8"),
command=lambda: insert(self.tableName, self.tableindex)).place(
x=230,
y=300) # .pack(side=BOTTOM,anchor=SE)#,padx=107,pady=5
Button(canvas,
text=unicode(" عودة إلى قائمة التخصصات: ", "utf-8"),
command=back).place(
x=195,
y=350) # .pack(side=BOTTOM,anchor=SW)#,padx=90,pady=5
root.update()
canvas.create_window(0, 0, window=frame, anchor=E)
canvas.config(scrollregion=canvas.bbox("all"))
root.mainloop()
