class DlgLogin(Dialog):
def body(self, master, cfg={}):
"place user dialog widgets"
self.config = cfg
self.config["OK button"] = False
self.site = StringVar()
self.site.set(cfg.get("site", ""))
self.login = StringVar()
self.login.set(cfg.get("user", ""))
self.password = StringVar()
self.password.set(str(cfg.get("password", "")))
site = Entry(master, width=15, textvariable=self.site)
site.grid(column=1, row=0, sticky="e")
Label(master, text=_("Site:")).grid(column=0, row=0, sticky="w")
loge = Entry(master, width=15, textvariable=self.login)
loge.grid(column=1, row=1, sticky="e")
Label(master, text=_("Username:"******"w")
pase = Entry(master, width=15, textvariable=self.password, show="*")
pase.grid(column=1, row=2, sticky="e")
Label(master, text=_("Password:"******"w")
self.to_remember = IntVar()
self.to_remember.set(cfg.get("remember_passwd", 1))
chk1 = Checkbutton(master, text="Remember",
variable=self.to_remember)
chk1.grid(column=0, row=3, sticky="w", columnspan=2)
self.resizable(width=0, height=0)
return loge
def apply(self):
"On ok button pressed"
self.config["remember_passwd"] = self.to_remember.get()
self.config["site"] = self.site.get()
self.config["user"] = self.login.get()
self.config["password"].set_password(self.password.get())
self.config["OK button"] = True
class NetworkPage(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.generalnavframe = ttk.Frame(self)
self.generalnavframe.grid(row=0, column=0, sticky="nsew")
self.generalpagebutt = tk.Button(self.generalnavframe, text="General", width=10, height=3, command=lambda: controller.show_frame(GeneralPage))
self.generalpagebutt.grid(row=0, column=0)
self.filesyspagebutt = tk.Button(self.generalnavframe, text="File System", width=10, height=3, command=lambda: controller.show_frame(FileSYSPage))
self.filesyspagebutt.grid(row=0, column=1)
self.serialpagebutt = tk.Button(self.generalnavframe, text="Serial", width=10, height=3, command=lambda: controller.show_frame(SerialPage))
self.serialpagebutt.grid(row=0, column=2)
self.networkpagebutt = tk.Button(self.generalnavframe, text="Network", width=10, height=3, bg='gray', command=lambda: controller.show_frame(NetworkPage))
self.networkpagebutt.grid(row=0, column=3)
self.generalcontrollsframe = ttk.Frame(self) # secondary frame with page controlls
self.generalcontrollsframe.grid(row=1, column=0, sticky="nsew")
self.var = IntVar()
self.var.set(2)
self.dhcp = ttk.Radiobutton(self.generalcontrollsframe, text="Dhcp", variable=self.var, value=2)
self.dhcp.grid(row=0, column=1)
self.static = ttk.Radiobutton(self.generalcontrollsframe, text="Static", variable=self.var, value=1)
self.static.grid(row=0, column=0)
self.ipaddress = ttk.Label(self.generalcontrollsframe, text="Ip Address")
self.ipaddress.grid(row=1, column=0)
self.ipaddrv4 = ttk.Entry(self.generalcontrollsframe, width=16)
self.ipaddrv4.grid(row=1, column=1)
self.subnetlbl = ttk.Label(self.generalcontrollsframe, text="Subnet")
self.subnetlbl.grid(row=2, column=0)
self.subnet = ttk.Entry(self.generalcontrollsframe, width=16)
self.subnet.grid(row=2, column=1)
self.gatewaylbl = ttk.Label(self.generalcontrollsframe, text="Gateway")
self.gatewaylbl.grid(row=3, column=0)
self.gateway = ttk.Entry(self.generalcontrollsframe, width=16)
self.gateway.grid(row=3, column=1)
self.dns1lbl = ttk.Label(self.generalcontrollsframe, text="Dns1")
self.dns1lbl.grid(row=4, column=0)
self.dns1 = ttk.Entry(self.generalcontrollsframe, width=16)
self.dns1.grid(row=4, column=1)
self.dns2lbl = ttk.Label(self.generalcontrollsframe, text="Dns2")
self.dns2lbl.grid(row=5, column=0)
self.dns2 = ttk.Entry(self.generalcontrollsframe, width=16)
self.dns2.grid(row=5, column=1)
self.setnetwork = ttk.Button(self.generalcontrollsframe, text="Set", width=16)
self.setnetwork.grid(row=7, column=0, columnspan=2)
class Checkbox(Checkbutton):
def __init__(self, master, text, default=None, **args):
self.var = IntVar()
Checkbutton.__init__(self, master, text=text, variable=self.var, **args)
if default is not None:
self.var.set(default)
def get(self):
return self.var.get()
class Calculator:
def __init__(self, master):
self.master = master
master.title("Calculator")
self.total = 0
self.entered_number = 0
self.total_label_text = IntVar()
self.total_label_text.set(self.total)
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Total:")
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master, validate="key", validatecommand=(vcmd, "%P"))
self.add_button = Button(master, text="+", command=lambda: self.update("add"))
self.subtract_button = Button(master, text="-", command=lambda: self.update("subtract"))
self.multiply_button = Button(master, text="*", command=lambda: self.update("multiply"))
# self.divide_button = Button(master, text="/", command=lambda: self.update("divide"))
self.reset_button = Button(master, text="Reset", command=lambda: self.update("reset"))
# LAYOUT
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=2, sticky=E)
self.entry.grid(row=1, column=0, columnspan=5, sticky=W + E)
self.add_button.grid(row=2, column=0)
self.subtract_button.grid(row=2, column=1)
self.multiply_button.grid(row=2, column=2)
# self.divide_button.grid(row=2, column=3)
self.reset_button.grid(row=2, column=4, sticky=W + E)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.entered_number = 0
return True
try:
self.entered_number = int(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "add":
self.total += self.entered_number
elif method == "subtract":
self.total -= self.entered_number
elif method == "multiply":
self.total *= self.entered_number
elif method == "divide":
self.total /= self.entered_number
else: # reset
self.total = 0
self.total_label_text.set(self.total)
self.entry.delete(0, END)
class FrameKSPObject(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
frame = Frame(self)
frame.pack()
self.string_var0 = StringVar()
self.string_var1 = StringVar()
self.int_var = IntVar()
self.entry0 = Entry(frame, textvariable=self.string_var0)
self.entry0.pack(side='left')
Entry(frame, textvariable=self.string_var1).pack(side='left')
frame = Frame(self)
frame.pack()
Button(frame, width=8, text='Accept', command=self.accept).pack(side='left')
Button(frame, width=8, text='Cancel', command=self.cancel).pack(side='left')
Button(frame, width=8, text='Delete', command=self.delete).pack(side='left')
def populate(self, kspobject):
self._kspobject = kspobject
self.string_var0.set(kspobject.name)
self.string_var1.set(kspobject.value)
self.int_var.set(kspobject.id_)
def accept(self):
name = self.string_var0.get()
value = self.string_var1.get()
id_ = self.int_var.get()
self.master.master.update_kspobject(name, value, id_)
self.master.destroy()
def cancel(self):
self.master.destroy()
def delete(self):
id_ = self.int_var.get()
self.master.master.delete_kspobject(id_)
self.master.destroy()
class DiceTab(Frame):
def __init__(self,master=None):
Frame.__init__(self,master)
#Sides of Dice
labelSides=Label(self,text="Sides")
labelSides.grid(row=0,column=0)
self.sides=StringVar()
self.sides.set(20)
spinboxSides=Spinbox(self,from_=1,to=20,increment=1,width=4)
spinboxSides.config(textvariable=self.sides, font="sans 24", justify="center")
spinboxSides.grid(row=0,column=1)
#Number of Dices
labelNumber=Label(self,text="Number")
labelNumber.grid(row=1,column=0)
self.number=StringVar()
self.number.set(1)
spinboxNumber=Spinbox(self,from_=1,to=30,increment=1,width=4)
spinboxNumber.config(textvariable=self.number, font="sans 24", justify="center")
spinboxNumber.grid(row=1,column=1)
#Modifier
labelModifier=Label(self,text="Modifier")
labelModifier.grid(row=2,column=0)
self.modifier=StringVar()
self.modifier.set(0)
spinboxModifier=Spinbox(self,from_=-5,to=5,increment=1,width=4)
spinboxModifier.config(textvariable=self.modifier, font="sans 24", justify="center")
spinboxModifier.grid(row=2,column=1)
#Hide Checkbox
labelHide=Label(self, text="Hide")
labelHide.grid(row=2, column=2)
self.hide=IntVar()
self.hide.set(0)
checkbuttonHide=Checkbutton(self,variable=self.hide)
checkbuttonHide.grid(row=2,column=3)
#Result display
self.result=StringVar()
self.result.set("")
labelResult1=Label(self,text="Result")
labelResult1.grid(row=1, column=4)
labelResult2=Label(self,text=self.result.get(),relief=SUNKEN,width=4)
labelResult2.grid(row=1,column=5)
#Button to roll
buttonRoll=Button(self,text="Roll!", command=self.roll)
buttonRoll.grid(row=2,column=5)
def roll(self):
self.throws=[]
numberOfDices=int(self.number.get())
sidesOfDice=int(self.sides.get())
modifierOfDice=int(self.modifier.get())
for i in range(numberOfDices):
self.throws.append(rd.randint(1,sidesOfDice))
self.result.set(str(sum(self.throws)+modifierOfDice))
labelResult2=Label(self,text=self.result.get(),relief=SUNKEN, width=4)
labelResult2.grid(row=1,column=5)
class ProgressCheckButton(Frame, Observable):
def __init__(self, parent, model, index, status_model):
Frame.__init__(self, parent)
Observable.__init__(self)
self.model = model
self.index = index
self.status_model = status_model
self.var = IntVar()
self.var.set(model.get_checked())
self.progress_var = IntVar()
self.progress_status = ProgressStatus.undefined
self.check_button = Checkbutton(self, text=model.get_label, variable=self.var, command=self._check_changed)
self.progress_bar = Progressbar(self, orient='horizontal', mode='indeterminate', variable=self.progress_var)
self.check_button.pack(side=LEFT, fill="both", expand=True)
self.model.add_listener(self._model_changed)
def _model_changed(self, new_status):
model_state = self.model.get_checked()
gui_state = self.var.get()
if model_state is not gui_state:
self.model.set_checked(gui_state)
def refresh_check(self):
if self.status_model.is_checked_force_reload():
self.check_button.select()
else:
self.check_button.deselect()
def is_checked(self):
return self.var.get()
def _progress_status_changed(self, new_status):
self._refresh_progress()
def _refresh_progress(self):
status = self.status_model.get_status()
if not status == self.progress_status:
if status == ProgressStatus.in_progress:
self.progress_bar.pack(side=RIGHT, fill="both", expand=True)
else:
self.progress_bar.pack_forget()
def _check_changed(self):
new_checked = self.var.get()
if new_checked is not self.model.get_checked():
self.model.set_checked(new_checked)
if new_checked is not self.status_model.is_checked():
self._notify(self.index, new_checked)
class ProgressListBoxItem(Frame, Observable):
def __init__(self, parent, model):
Frame.__init__(self, parent)
Observable.__init__(self)
self._model = model
# Create variables and initialise to zero
self._checked_var = IntVar()
self._progress_var = IntVar()
self._checked_var.set(0)
self._progress_var.set(0)
self._current_gui_checked_state = CheckStatus.undefined
self._current_gui_progress_state = ProgressStatus.undefined
self.check_button = Checkbutton(self, text=model.get_label(), variable=self._checked_var, command=self._user_check_changed)
self.progress_bar = Progressbar(self, orient='horizontal', mode='indeterminate', variable=self._progress_var)
self.check_button.pack(side=LEFT, fill="both", expand=True)
self._update()
self._model.add_listener(self._model_changed)
def _model_changed(self):
self.update()
def _update(self):
# Update check status
model_check_state = self._model.get_check_status()
if model_check_state is not self._current_gui_checked_state:
self._current_gui_checked_state = model_check_state
# if self.status_model.is_checked_force_reload():
if model_check_state:
self.check_button.select()
else:
self.check_button.deselect()
# Update progress status
model_progress_state = self._model.get_progress_status
if not model_progress_state == self._current_gui_progress_state:
self._current_gui_progress_state = model_progress_state
if model_progress_state == ProgressStatus.in_progress:
self.progress_bar.pack(side=RIGHT, fill="both", expand=True)
else:
self.progress_bar.pack_forget()
def _user_check_changed(self):
new_checked = self._checked_var.get()
if new_checked is not self._model.get_check_status():
self._model.manual_set_checked(new_checked)
class Options(Frame):
def __init__(self, master, ordinances=False, **kwargs):
super(Options, self).__init__(master, **kwargs)
self.ancestors = IntVar()
self.ancestors.set(4)
self.descendants = IntVar()
self.spouses = IntVar()
self.ordinances = IntVar()
self.contributors = IntVar()
self.start_indis = StartIndis(self)
self.fid = StringVar()
btn = Frame(self)
entry_fid = EntryWithMenu(btn, textvariable=self.fid, width=16)
entry_fid.bind('<Key>', self.enter)
label_ancestors = Label(self, text=_('Number of generations to ascend'))
entry_ancestors = EntryWithMenu(self, textvariable=self.ancestors, width=5)
label_descendants = Label(self, text=_('Number of generations to descend'))
entry_descendants = EntryWithMenu(self, textvariable=self.descendants, width=5)
btn_add_indi = Button(btn, text=_('Add a FamilySearch ID'), command=self.add_indi)
btn_spouses = Checkbutton(self, text='\t' + _('Add spouses and couples information'), variable=self.spouses)
btn_ordinances = Checkbutton(self, text='\t' + _('Add Temple information'), variable=self.ordinances)
btn_contributors = Checkbutton(self, text='\t' + _('Add list of contributors in notes'), variable=self.contributors)
self.start_indis.grid(row=0, column=0, columnspan=3)
entry_fid.grid(row=0, column=0, sticky='w')
btn_add_indi.grid(row=0, column=1, sticky='w')
btn.grid(row=1, column=0, columnspan=2, sticky='w')
entry_ancestors.grid(row=2, column=0, sticky='w')
label_ancestors.grid(row=2, column=1, sticky='w')
entry_descendants.grid(row=3, column=0, sticky='w')
label_descendants.grid(row=3, column=1, sticky='w')
btn_spouses.grid(row=4, column=0, columnspan=2, sticky='w')
if ordinances:
btn_ordinances.grid(row=5, column=0, columnspan=3, sticky='w')
btn_contributors.grid(row=6, column=0, columnspan=3, sticky='w')
entry_ancestors.focus_set()
def add_indi(self):
if self.start_indis.add_indi(self.fid.get()):
self.fid.set('')
def enter(self, evt):
if evt.keysym in {'Return', 'KP_Enter'}:
self.add_indi()
class VariableLabel:
def __init__(self,parent,col,row,genre):
"""
:param parent: fenetre root
:param col: colonne pour placer le label
:param row: ligne pour placer le label
:param genre: type de label (int ou str)
"""
self.val=StringVar()
self.val.set("RED")
if (genre=="integer"):
self.val=IntVar()
self.val.set(0)
label=Label(parent,textvariable=self.val,bg="bisque")
label.grid(column=col,row=row)
def getVar(self):
return(self.val)
def setVar(self,valeur):
"""
:param valeur: nouvelle valeur du Label
"""
self.val.set(valeur)
class Status_Bar(Frame):
"""
The status bar visualizes progress and status.
"""
task = None
def __init__(self, _master):
super(Status_Bar, self).__init__(_master, bd=1, relief=SUNKEN)
self.task = StringVar()
self.progress = IntVar()
self.init_widgets()
def update_task(self, _task, _progress):
""" This function is used as an endpoint for for the
bubbling notify_task call of the BPMFrame class.
:param _task: Text that defines the task
:param _progress: Text that describes the degree of progress
"""
if _progress < 0:
self.pb_progress.mode = 'indeterminate'
else:
self.pb_progress.mode = 'determinate'
self.task.set(_task)
self.progress.set(_progress)
self.update_idletasks()
def init_widgets(self):
"""
Initialize visual elements.
"""
self.l_task = ttk.Label(self, textvariable=self.task, width=70)
self.l_task.pack(side=LEFT, fill=X)
self.pb_progress = ttk.Progressbar(self, variable=self.progress, length=150)
self.pb_progress.pack(side=RIGHT)
def _create_frame_with_radio_btns(self, parent, name, text, row_index,
column_index, add_both=True):
''' Creates frame with one set of Radiobuttons.
Args:
parent (Tk object): parent of the frame.
name (str): name of the parameter that will a key in options
dictionary.
text (list of str): list with two parameter values that should
be displayed next to the first two Radiobuttons.
row_index (int): index of the row where the frame should
be placed using grid method.
column_index (int): index of the column where the frame
should be placed using grid method.
add_both (bool, optional): True if the third Radiobutton
with text "both" must be displayed, False otherwise,
defaults to True.
'''
assert len(text) == 2
v = IntVar()
self.options[name] = v
self.options[name].trace(
'w', (lambda *args: self.radio_btn_change(name)))
frame_with_radio_btns = Frame(parent)
first_option = Radiobutton(frame_with_radio_btns,
text=text[0], variable=v, value=1)
first_option.grid(row=0, column=0, sticky=W+N, padx=2)
v.set(1)
second_option = Radiobutton(frame_with_radio_btns,
text=text[1], variable=v, value=2)
second_option.grid(row=1, column=0, sticky=W+N, padx=2)
if add_both:
both = Radiobutton(frame_with_radio_btns, text='Both',
variable=v, value=3)
both.grid(row=3, column=0, sticky=W+N, padx=2)
frame_with_radio_btns.grid(row=row_index, column=column_index,
padx=1, pady=5, sticky=W+N)
class MainMenu():
def main(self):
'''Function to run on game start'''
self.mainMenu=Tk()
self.mainMenu.geometry('200x300+200+200')
self.mainMenu.title("Minesweeper")
playButton=Button(self.mainMenu,text='Play',command=lambda:self.startPlay(None))
self.height= IntVar()
self.width= IntVar()
self.minesAmount= IntVar()
self.height.set(10)
self.width.set(10)
self.minesAmount.set(10)
playButton.pack()
xSlider=Scale(self.mainMenu,orient='horizontal',length=150,width=15,label='Height',sliderlength=20,from_=1,to=15,tickinterval=0,variable=self.height).pack()
ySlider=Scale(self.mainMenu,orient='horizontal',length=150,width=15,label='Width',sliderlength=20,from_=1,to=15,tickinterval=0,variable=self.width).pack()
minesSlider=Scale(self.mainMenu,orient='horizontal',length=150,width=15,label='Mines',sliderlength=20,from_=0,to=15*15-1,tickinterval=0,variable=self.minesAmount).pack()
aboutButton=Button(self.mainMenu,text='About',command=self.about)
quitButton=Button(self.mainMenu,text='Quit',command=self.quitApp)
aboutButton.pack()
quitButton.pack()
def startPlay(self,event):
play=Play()
minesAmount=self.minesAmount.get()
height=self.height.get()
width=self.width.get()
if minesAmount>width*height-1:
messagebox.showerror(title='Error',message="Amount of mines can't be bigger than total size of the field. Plese try again.")
return
self.mainMenu.destroy()
play.StartGame(minesAmount,height,width)
def about(self):
messagebox.showinfo(title='About',message='Author:Marcel Salmič.')
def quitApp(self):
self.mainMenu.destroy()
class DrtGlueDemo(object):
def __init__(self, examples):
# Set up the main window.
self._top = Tk()
self._top.title("DRT Glue Demo")
# Set up key bindings.
self._init_bindings()
# Initialize the fonts.self._error = None
self._init_fonts(self._top)
self._examples = examples
self._readingCache = [None for example in examples]
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Set the data to None
self._curExample = -1
self._readings = []
self._drs = None
self._drsWidget = None
self._error = None
self._init_glue()
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_exampleListbox(self._top)
self._init_readingListbox(self._top)
self._init_canvas(self._top)
# Resize callback
self._canvas.bind("<Configure>", self._configure)
#########################################
## Initialization Helpers
#########################################
def _init_glue(self):
tagger = RegexpTagger(
[
("^(David|Mary|John)$", "NNP"),
("^(walks|sees|eats|chases|believes|gives|sleeps|chases|persuades|tries|seems|leaves)$", "VB"),
("^(go|order|vanish|find|approach)$", "VB"),
("^(a)$", "ex_quant"),
("^(every)$", "univ_quant"),
("^(sandwich|man|dog|pizza|unicorn|cat|senator)$", "NN"),
("^(big|gray|former)$", "JJ"),
("^(him|himself)$", "PRP"),
]
)
depparser = MaltParser(tagger=tagger)
self._glue = DrtGlue(depparser=depparser, remove_duplicates=False)
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = Font(font=Button()["font"])
root.option_add("*Font", self._sysfont)
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(root)
self._size.set(self._sysfont.cget("size"))
self._boldfont = Font(family="helvetica", weight="bold", size=self._size.get())
self._font = Font(family="helvetica", size=self._size.get())
if self._size.get() < 0:
big = self._size.get() - 2
else:
big = self._size.get() + 2
self._bigfont = Font(family="helvetica", weight="bold", size=big)
def _init_exampleListbox(self, parent):
self._exampleFrame = listframe = Frame(parent)
self._exampleFrame.pack(fill="both", side="left", padx=2)
self._exampleList_label = Label(self._exampleFrame, font=self._boldfont, text="Examples")
self._exampleList_label.pack()
self._exampleList = Listbox(
self._exampleFrame,
selectmode="single",
relief="groove",
background="white",
foreground="#909090",
font=self._font,
selectforeground="#004040",
selectbackground="#c0f0c0",
)
self._exampleList.pack(side="right", fill="both", expand=1)
for example in self._examples:
self._exampleList.insert("end", (" %s" % example))
self._exampleList.config(height=min(len(self._examples), 25), width=40)
# Add a scrollbar if there are more than 25 examples.
if len(self._examples) > 25:
listscroll = Scrollbar(self._exampleFrame, orient="vertical")
self._exampleList.config(yscrollcommand=listscroll.set)
listscroll.config(command=self._exampleList.yview)
listscroll.pack(side="left", fill="y")
# If they select a example, apply it.
self._exampleList.bind("<<ListboxSelect>>", self._exampleList_select)
def _init_readingListbox(self, parent):
self._readingFrame = listframe = Frame(parent)
self._readingFrame.pack(fill="both", side="left", padx=2)
self._readingList_label = Label(self._readingFrame, font=self._boldfont, text="Readings")
self._readingList_label.pack()
self._readingList = Listbox(
self._readingFrame,
selectmode="single",
relief="groove",
background="white",
foreground="#909090",
font=self._font,
selectforeground="#004040",
selectbackground="#c0f0c0",
)
self._readingList.pack(side="right", fill="both", expand=1)
# Add a scrollbar if there are more than 25 examples.
listscroll = Scrollbar(self._readingFrame, orient="vertical")
self._readingList.config(yscrollcommand=listscroll.set)
listscroll.config(command=self._readingList.yview)
listscroll.pack(side="right", fill="y")
self._populate_readingListbox()
def _populate_readingListbox(self):
# Populate the listbox with integers
self._readingList.delete(0, "end")
for i in range(len(self._readings)):
self._readingList.insert("end", (" %s" % (i + 1)))
self._readingList.config(height=min(len(self._readings), 25), width=5)
# If they select a example, apply it.
self._readingList.bind("<<ListboxSelect>>", self._readingList_select)
def _init_bindings(self):
# Key bindings are a good thing.
self._top.bind("<Control-q>", self.destroy)
self._top.bind("<Control-x>", self.destroy)
self._top.bind("<Escape>", self.destroy)
self._top.bind("n", self.next)
self._top.bind("<space>", self.next)
self._top.bind("p", self.prev)
self._top.bind("<BackSpace>", self.prev)
def _init_buttons(self, parent):
# Set up the frames.
self._buttonframe = buttonframe = Frame(parent)
buttonframe.pack(fill="none", side="bottom", padx=3, pady=2)
Button(buttonframe, text="Prev", background="#90c0d0", foreground="black", command=self.prev).pack(side="left")
Button(buttonframe, text="Next", background="#90c0d0", foreground="black", command=self.next).pack(side="left")
def _configure(self, event):
self._autostep = 0
(x1, y1, x2, y2) = self._cframe.scrollregion()
y2 = event.height - 6
self._canvas["scrollregion"] = "%d %d %d %d" % (x1, y1, x2, y2)
self._redraw()
def _init_canvas(self, parent):
self._cframe = CanvasFrame(
parent,
background="white",
# width=525, height=250,
closeenough=10,
border=2,
relief="sunken",
)
self._cframe.pack(expand=1, fill="both", side="top", pady=2)
canvas = self._canvas = self._cframe.canvas()
# Initially, there's no tree or text
self._tree = None
self._textwidgets = []
self._textline = None
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Exit", underline=1, command=self.destroy, accelerator="q")
menubar.add_cascade(label="File", underline=0, menu=filemenu)
actionmenu = Menu(menubar, tearoff=0)
actionmenu.add_command(label="Next", underline=0, command=self.next, accelerator="n, Space")
actionmenu.add_command(label="Previous", underline=0, command=self.prev, accelerator="p, Backspace")
menubar.add_cascade(label="Action", underline=0, menu=actionmenu)
optionmenu = Menu(menubar, tearoff=0)
optionmenu.add_checkbutton(
label="Remove Duplicates",
underline=0,
variable=self._glue.remove_duplicates,
command=self._toggle_remove_duplicates,
accelerator="r",
)
menubar.add_cascade(label="Options", underline=0, menu=optionmenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_radiobutton(label="Tiny", variable=self._size, underline=0, value=10, command=self.resize)
viewmenu.add_radiobutton(label="Small", variable=self._size, underline=0, value=12, command=self.resize)
viewmenu.add_radiobutton(label="Medium", variable=self._size, underline=0, value=14, command=self.resize)
viewmenu.add_radiobutton(label="Large", variable=self._size, underline=0, value=18, command=self.resize)
viewmenu.add_radiobutton(label="Huge", variable=self._size, underline=0, value=24, command=self.resize)
menubar.add_cascade(label="View", underline=0, menu=viewmenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="About", underline=0, command=self.about)
menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
parent.config(menu=menubar)
#########################################
## Main draw procedure
#########################################
def _redraw(self):
canvas = self._canvas
# Delete the old DRS, widgets, etc.
if self._drsWidget is not None:
self._drsWidget.clear()
if self._drs:
self._drsWidget = DrsWidget(self._canvas, self._drs)
self._drsWidget.draw()
if self._error:
self._drsWidget = DrsWidget(self._canvas, self._error)
self._drsWidget.draw()
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
self._autostep = 0
if self._top is None:
return
self._top.destroy()
self._top = None
def prev(self, *e):
selection = self._readingList.curselection()
readingListSize = self._readingList.size()
# there are readings
if readingListSize > 0:
# if one reading is currently selected
if len(selection) == 1:
index = int(selection[0])
# if it's on (or before) the first item
if index <= 0:
self._select_previous_example()
else:
self._readingList_store_selection(index - 1)
else:
# select its first reading
self._readingList_store_selection(readingListSize - 1)
else:
self._select_previous_example()
def _select_previous_example(self):
# if the current example is not the first example
if self._curExample > 0:
self._exampleList_store_selection(self._curExample - 1)
else:
# go to the last example
self._exampleList_store_selection(len(self._examples) - 1)
def next(self, *e):
selection = self._readingList.curselection()
readingListSize = self._readingList.size()
# if there are readings
if readingListSize > 0:
# if one reading is currently selected
if len(selection) == 1:
index = int(selection[0])
# if it's on (or past) the last item
if index >= (readingListSize - 1):
self._select_next_example()
else:
self._readingList_store_selection(index + 1)
else:
# select its first reading
self._readingList_store_selection(0)
else:
self._select_next_example()
def _select_next_example(self):
# if the current example is not the last example
if self._curExample < len(self._examples) - 1:
self._exampleList_store_selection(self._curExample + 1)
else:
# go to the first example
self._exampleList_store_selection(0)
def about(self, *e):
ABOUT = "NLTK Discourse Representation Theory (DRT) Glue Semantics Demo\n" + "Written by Daniel H. Garrette"
TITLE = "About: NLTK DRT Glue Demo"
try:
from tkMessageBox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
def postscript(self, *e):
self._autostep = 0
self._cframe.print_to_file()
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle():
return
self._top.mainloop(*args, **kwargs)
def resize(self, size=None):
if size is not None:
self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._boldfont.configure(size=-(abs(size)))
self._sysfont.configure(size=-(abs(size)))
self._bigfont.configure(size=-(abs(size + 2)))
self._redraw()
def _toggle_remove_duplicates(self):
self._glue.remove_duplicates = not self._glue.remove_duplicates
self._exampleList.selection_clear(0, "end")
self._readings = []
self._populate_readingListbox()
self._readingCache = [None for ex in self._examples]
self._curExample = -1
self._error = None
self._drs = None
self._redraw()
def _exampleList_select(self, event):
selection = self._exampleList.curselection()
if len(selection) != 1:
return
self._exampleList_store_selection(int(selection[0]))
def _exampleList_store_selection(self, index):
self._curExample = index
example = self._examples[index]
self._exampleList.selection_clear(0, "end")
if example:
cache = self._readingCache[index]
if cache:
if isinstance(cache, list):
self._readings = cache
self._error = None
else:
self._readings = []
self._error = cache
else:
try:
self._readings = self._glue.parse_to_meaning(example)
self._error = None
self._readingCache[index] = self._readings
except Exception as e:
self._readings = []
self._error = DrtVariableExpression(Variable("Error: " + str(e)))
self._readingCache[index] = self._error
# add a star to the end of the example
self._exampleList.delete(index)
self._exampleList.insert(index, (" %s *" % example))
self._exampleList.config(height=min(len(self._examples), 25), width=40)
self._populate_readingListbox()
self._exampleList.selection_set(index)
self._drs = None
self._redraw()
def _readingList_select(self, event):
selection = self._readingList.curselection()
if len(selection) != 1:
return
self._readingList_store_selection(int(selection[0]))
def _readingList_store_selection(self, index):
reading = self._readings[index]
self._readingList.selection_clear(0, "end")
if reading:
self._readingList.selection_set(index)
self._drs = reading.simplify().normalize().resolve_anaphora()
self._redraw()
class OperatePanel(Frame):
def __init__(self, parent, searchCallback, resetCallback):
super().__init__(parent)
self.icSelected = IntVar()
self.mwwSelected = IntVar()
self.urSelected = IntVar()
self.ifnSelected = IntVar()
self.searchCallback = searchCallback
self.resetCallback = resetCallback
self.searchBtn = Button(self,
text="Search",
command=self.onClickSearch,
padx=3)
self.resetBtn = Button(self,
text="Reset",
command=self.onClickReset,
padx=3)
self.icBtn = Checkbutton(self,
text="Ignore Case",
command=self.onSelectIgnoreCase,
variable=self.icSelected)
self.mwwBtn = Checkbutton(self,
text="Match Whole Word",
command=self.onSelectMatchWholeWord,
variable=self.mwwSelected)
self.urBtn = Checkbutton(self,
text="Use Regular",
command=self.onSelectUseRegular,
variable=self.urSelected)
self.ifnBtn = Checkbutton(self,
text="Ignore Folder Name",
variable=self.ifnSelected)
self.icBtn.grid(row=0, column=0, sticky="W")
self.mwwBtn.grid(row=0, column=1, sticky="W")
self.ifnBtn.grid(row=1, column=0, sticky="W")
self.urBtn.grid(row=1, column=1, sticky="W")
self.resetBtn.grid(row=2, column=0)
self.searchBtn.grid(row=2, column=1)
def getFlags(self):
flags = []
if self.icSelected.get() == 1:
flags.append("-ic")
if self.mwwSelected.get() == 1:
flags.append("-mww")
if self.urSelected.get() == 1:
flags.append("-r")
if self.ifnSelected.get() == 1:
flags.append("-ifn")
return flags
def onClickSearch(self):
if self.searchCallback is not None:
self.searchCallback()
def onClickReset(self):
self.urSelected.set(0)
self.icSelected.set(0)
self.mwwSelected.set(0)
self.ifnSelected.set(0)
if self.resetCallback is not None:
self.resetCallback()
def onSelectIgnoreCase(self):
self.urSelected.set(0)
def onSelectMatchWholeWord(self):
self.urSelected.set(0)
def onSelectUseRegular(self):
self.icSelected.set(0)
self.mwwSelected.set(0)
class MainApp():
def __init__(self):
self.File_name = None
self.Programe_Name = "CHE-Editor"
self.WDG = Tk()
self.WDG.title(self.Programe_Name)
self.WDG.iconbitmap("icons/icon_editor.ico")
self.WDG.geometry("860x620")
self.WDG.maxsize(width=1340, height=700)
self.WDG.minsize(width=860, height=620)
self.Main_UI()
def Main_UI(self):
self.MenuBar = Menu(self.WDG)
#1 #MenuBar
#File_menu
self.File_menu = Menu(self.MenuBar, tearoff=0, title="File")
self.MenuBar.add_cascade(label="File", menu=self.File_menu)
#Edit_menu
self.Edit_menu = Menu(self.MenuBar, tearoff=0, title="Edit")
self.MenuBar.add_cascade(label="Edit", menu=self.Edit_menu)
#View_menu
self.View_menu = Menu(self.MenuBar, tearoff=0, title="View")
self.MenuBar.add_cascade(label="View", menu=self.View_menu)
#Theme_menu in View
self.Theme_menu = Menu(self.View_menu, tearoff=0, title="Theme")
self.View_menu.add_cascade(label="Theme", menu=self.Theme_menu)
#Option_menu
self.Options_menu = Menu(self.MenuBar, tearoff=0, title="Options")
self.MenuBar.add_cascade(label="Options", menu=self.Options_menu)
#Help_menu
self.Help_menu = Menu(self.MenuBar, tearoff=0, title="Help")
self.MenuBar.add_cascade(label="Help", menu=self.Help_menu)
#2 #Icons Variables
#Edit_Menu Icons
Undo = PhotoImage(file="icons/Undo.gif")
Redo = PhotoImage(file="icons/redo.gif")
Paste = PhotoImage(file="icons/paste.gif")
Copy = PhotoImage(file="icons/copy.gif")
Cut = PhotoImage(file="icons/cut.gif")
#Help_Menu_Icons
Help = PhotoImage(file="icons/help.gif")
About = PhotoImage(file="icons/about.gif")
#File_Menu_Icons
New = PhotoImage(file="icons/new.gif")
Open = PhotoImage(file="icons/open.gif")
Save = PhotoImage(file="icons/save.gif")
Save_As = PhotoImage(file="icons/save_as.gif")
Exit = PhotoImage(file="icons/exit.gif")
#Appear menubar in app
self.WDG.config(menu=self.MenuBar)
#self.WDG.config(menu=self.IconBar)
#3 #Set commands in menus
#File_Menu
self.File_menu.add_command(label="New",
accelerator="Ctrl+N",
compound="left",
underline=0,
command=self.New)
self.File_menu.add_command(label="Open",
accelerator="Ctrl+O",
compound="left",
underline=0,
command=self.Open)
self.File_menu.add_command(label="Save",
accelerator="Ctrl+S",
compound="left",
underline=0,
command=self.Save)
self.File_menu.add_command(label="Save as",
accelerator="Shift+Ctrl+S",
compound="left",
underline=0,
command=self.Save_As)
self.File_menu.add_separator()
self.File_menu.add_command(label="Exit",
accelerator="F4",
compound="left",
underline=0,
command=self.Exit)
#Edit_Menu
self.Edit_menu.add_command(label="Undo",
accelerator="Ctrl+Z",
compound="left",
underline=0,
command=self.Undo)
self.Edit_menu.add_command(label="Redo",
accelerator='Ctrl+Y',
compound='left',
underline=0,
command=self.Redo)
self.Edit_menu.add_command(label="Select all",
accelerator='Ctrl+A',
compound='left',
underline=0,
command=self.Select)
self.Edit_menu.add_command(label="Cut",
accelerator='Ctrl+X',
compound='left',
underline=7,
command=self.Cut)
self.Edit_menu.add_command(label="Copy",
accelerator='Ctrl+C',
compound='left',
underline=0,
command=self.Copy)
self.Edit_menu.add_command(label="Paste",
accelerator='Ctrl+V',
compound='left',
underline=0,
command=self.Paste)
self.Edit_menu.add_command(label="Search",
accelerator='Ctrl+F',
compound='left',
underline=0,
command=self.Search)
#Help_Menu
self.Help_menu.add_command(label="Help",
accelerator="F1",
compound="left",
underline=0,
command=self.Help)
self.Help_menu.add_command(label="About",
compound="left",
underline=0,
command=self.About)
#View_Menu
self.Show_line_number = IntVar()
self.Show_line_number.set(1)
self.theme_name = StringVar()
self.View_menu.add_checkbutton(label="Show Line Number",
variable=self.Show_line_number)
self.Highlightline = BooleanVar()
self.View_menu.add_checkbutton(label='Highlight Current Line',
onvalue=1,
offvalue=0,
variable=self.Highlightline,
command=self.Toggle_highlight)
self.cursorcoord = BooleanVar()
self.View_menu.add_checkbutton(label='Show Cursor Location',
variable=self.cursorcoord,
command=self.Show_cursor_coord)
self.Theme_menu.add_radiobutton(label="Default",
variable=self.theme_name)
#4 #add Shortcut_Bar & Row_Number_Bar
#Shortcut_Bar
self.Shortcut_Bar = Frame(self.WDG, height=25)
self.Shortcut_Bar.pack(expand='no', fill='x')
Icons = ['New', 'Open', 'Save', 'Copy', 'Cut', 'Paste', 'Undo', 'Redo']
for i, icon in enumerate(Icons):
Tool_icon = PhotoImage(file='icons/{}.gif'.format(icon))
#c_var = 'self.{}'.format(icon)
cmd = eval('self.{}'.format(icon))
self.Tool_bar_btn = Button(self.Shortcut_Bar,
image=Tool_icon,
command=cmd)
self.Tool_bar_btn.image = Tool_icon
self.Tool_bar_btn.pack(side='left')
#Row_Number_Bar
self.Row_Number_Bar = Text(self.WDG,
width=3,
padx=3,
takefocus=0,
border=0,
background='khaki',
state='disabled',
wrap='none')
self.Row_Number_Bar.pack(side='left', fill='y')
#5 #add Content_Text
self.Content_Text = Text(self.WDG, wrap='word', undo=1)
self.Content_Text.pack(expand='yes', fill='both')
self.Content_Text.tag_configure('active_line', background='ivory2')
self.Scroll_Bar = Scrollbar(self.Content_Text)
self.Content_Text.configure(yscrollcommand=self.Scroll_Bar.set)
self.Scroll_Bar.config(command=self.Content_Text.yview)
self.Scroll_Bar.pack(side='right', fill='y')
#6 #add_Cursor_Coord_Bar
self.Cursor_Coord_Bar = Label(self.Content_Text,
text='Row: 1 | Column: 1')
self.Cursor_Coord_Bar.pack(fill=None,
expand='no',
side='right',
anchor='se')
#7 #Binding
self.Content_Text.bind("<Control-o>", self.Open)
self.Content_Text.bind("<Control-O>", self.Open)
self.Content_Text.bind("<Control-s>", self.Save)
self.Content_Text.bind("<Control-S>", self.Save)
self.Content_Text.bind("<Shift-Control-KeyPress-s>", self.Save_As)
self.Content_Text.bind("<Shift-Control-KeyPress-S>", self.Save_As)
self.Content_Text.bind("<Control-n>", self.New)
self.Content_Text.bind("<Control-N>", self.New)
self.Content_Text.bind("<Control-z>", self.Undo)
self.Content_Text.bind("<Control-Z>", self.Undo)
self.Content_Text.bind("<Control-y>", self.Redo)
self.Content_Text.bind("<Control-Y>", self.Redo)
self.Content_Text.bind("<Control-x>", self.Cut)
self.Content_Text.bind("<Control-X>", self.Cut)
self.Content_Text.bind("<Control-a>", self.Select)
self.Content_Text.bind("<Control-A>", self.Select)
self.Content_Text.bind("<Control-c>", self.Copy)
self.Content_Text.bind("<Control-C>", self.Copy)
self.Content_Text.bind("<Control-v>", self.Paste)
self.Content_Text.bind("<Control-V>", self.Paste)
self.Content_Text.bind("<Control-f>", self.Search)
self.Content_Text.bind("<Control-F>", self.Search)
self.Content_Text.bind("<Any-KeyPress>", self.Content_changed)
self.WDG.bind_all("<KeyPress-F1>", self.Help)
self.WDG.bind_all("<KeyPress-F4>", self.Exit)
#8 #Built In Finctions
#File_Menu_Functions
def New(self, event=None):
self.Content_Text.delete(1., 'end')
self.WDG.title('{} - {}'.format('Untitled', self.Programe_Name))
##
def Open(self, event=None):
self.Open_file_name = filedialog.askopenfilename(
defaultextension=".txt",
filetypes=[("All Files", "*.*"), ("Text Documents", "*.txt")])
if self.Open_file_name:
self.File_name = self.Open_file_name
self.WDG.title("{} - {}".format(os.path.basename(self.File_name),
self.Programe_Name))
self.Content_Text.delete(1.0, 'end')
with open(self.File_name) as _File:
self.Content_Text.insert(1.0, _File.read())
##
def Save(self, event=None):
if not self.File_name:
self.Save_As()
else:
self.Write_to_file(self.File_name)
return "break"
##
def Save_As(self, event=None):
self.Save_file_name = filedialog.asksaveasfilename(
defaultextension='.txt',
filetypes=[('All Files', '*.*'), ('Text Documents', '*.txt')])
if self.Save_file_name:
self.File_name = self.Save_file_name
self.Write_to_file(self.File_name)
self.WDG.title('{} - {}'.format(os.path.basename(self.File_name),
self.Programe_Name))
return "break"
##
def Write_to_file(self, filename):
try:
self.content = self.Content_Text.get(1.0, 'end')
with open(self.File_name, 'w') as the_file:
the_file.write(self.content)
except IOError as er:
print(er)
##
def Exit(self, event=None):
self.msg_exit = messagebox.askyesno('Exit Editor',
'Do you want to exit?')
if self.msg_exit:
self.WDG.destroy()
#Edit_Menu_Functions
##
def Select(self, event=None):
self.Content_Text.tag_add("sel", 1.0, "end")
print("Done1")
return "breake"
##
def Cut(self, event=None):
self.Content_Text.event_generate("<<Cut>>")
return "breake"
##
def Copy(self, event=None):
self.Content_Text.event_generate("<<Copy>>")
return "breake"
##
def Paste(self, event=None):
self.Content_Text.event_generate("<<Paste>>")
return "breake"
##
def Undo(self, event=None):
self.Content_Text.event_generate("<<Undo>>")
return "breake"
##
def Redo(self, event=None):
self.Content_Text.event_generate("<<Redo>>")
return "breake"
##
def Search(self, event=None):
self.Search_Window = Toplevel(self.WDG)
self.Search_Window.title("Search About...")
self.Search_Window.transient(self.WDG)
self.Search_Window.resizable(False, False)
self.S_lbl_1 = Label(self.Search_Window, text='Search About :')
self.S_lbl_1.grid(row=0, column=0, sticky='e')
self.S_ent_1 = Entry(self.Search_Window, width=28)
self.S_ent_1.grid(row=0, column=1, padx=2, pady=2, sticky='we')
self.S_ent_1.focus_set()
Ignore_case_value = IntVar()
self.S_chk_1 = Checkbutton(self.Search_Window,
text='Ignor Case',
variable=Ignore_case_value)
self.S_chk_1.grid(row=1, column=1, padx=2, pady=2, sticky='e')
self.S_btn_1 = Button(
self.Search_Window,
text='Find',
underline=0,
command=lambda: self.Search_results(self.S_ent_1.get(
), Ignore_case_value.get(), self.Content_Text, self.Search_Window,
self.S_ent_1))
self.S_btn_1.grid(row=0, column=2, padx=2, pady=2, sticky='e' + 'w')
self.S_btn_2 = Button(self.Search_Window,
text='Cancel',
underline=0,
command=self.Close_Search_Window)
self.S_btn_2.grid(row=1, column=2, padx=2, pady=2, sticky='e' + 'w')
##
def Search_results(self, Keyword, IfIgnoreCase, Content, Output, Input):
Content.tag_remove('match', '1.0', 'end')
matches_found = 0
if Keyword:
start_pos = '1.0'
while True:
start_pos = Content.search(Keyword,
start_pos,
nocase=IfIgnoreCase,
stopindex='end')
if not start_pos:
break
end_pos = "{} + {}c".format(start_pos, len(Keyword))
Content.tag_add('match', start_pos, end_pos)
matches_found += 1
start_pos = end_pos
Content.tag_config('match', foreground='red', background='yellow')
Input.focus_set()
Output.title("{} matches found".format(matches_found))
##
def Close_Search_Window(self):
self.Content_Text.tag_remove('match', '1.0', 'end')
self.Search_Window.destroy()
#self.Search_Window.protocol('WM_DELETE_WINDOW',self.Close_Search_Window)
return "break"
#View_Menu_Functions
##
def Content_changed(self, event=None):
self.Update_line_numbers()
self.Update_cursor_coord()
##
def Get_line_numbers(self, event=None):
self.Number = ""
if self.Show_line_number.get():
self.Row, self.Column = self.Content_Text.index('end').split('.')
for i in range(1, int(self.Row)):
self.Number += str(i) + "\n"
return self.Number
##
def Update_line_numbers(self):
self.Line_Number = self.Get_line_numbers()
self.Row_Number_Bar.config(state='normal')
self.Row_Number_Bar.delete(1.0, 'end')
self.Row_Number_Bar.insert(1.0, self.Line_Number)
self.Row_Number_Bar.config(state='disabled')
##
def Toggle_highlight(self, event=None):
if self.Highlightline.get():
self.Highlight_line()
else:
self.Undo_highlight()
##
def Highlight_line(self, interval=100):
self.Content_Text.tag_remove('active_line', 1.0, 'end')
self.Content_Text.tag_add('active_line', "insert linestart",
"insert lineend+1c")
self.Content_Text.after(interval, self.Toggle_highlight)
##
def Undo_highlight(self):
self.Content_Text.tag_remove('active_line', 1.0, 'end')
##
def Show_cursor_coord(self):
self.cursor_coord_checked = self.cursorcoord.get()
if self.cursor_coord_checked:
self.Cursor_Coord_Bar.pack(expand='no',
fill=None,
side='right',
anchor='se')
else:
self.Cursor_Coord_Bar.pack_forget()
##
def Update_cursor_coord(self):
self.Row_2, self.Column_2 = self.Content_Text.index('insert').split(
'.')
self.row_num, self.col_num = str(int(
self.Row_2)), str(int(self.Column_2) + 1)
self.Coord = "Row: {} | Column: {}".format(self.row_num, self.col_num)
self.Cursor_Coord_Bar.config(text=self.Coord)
#Help_Menu_Functions
##
def About(self, event=None):
messagebox.showinfo(
'About', '{} {}'.format(self.Programe_Name,
'\nDeveloped by \n TaReK'))
##
def Help(self, event=None):
messagebox.showinfo('Help',
'Text Editor building in python',
icon='question')
def guiMain(args=None):
mainWindow = Tk()
mainWindow.wm_title("OoT Randomizer %s" % ESVersion)
set_icon(mainWindow)
notebook = ttk.Notebook(mainWindow)
randomizerWindow = ttk.Frame(notebook)
adjustWindow = ttk.Frame(notebook)
customWindow = ttk.Frame(notebook)
notebook.add(randomizerWindow, text='Randomize')
notebook.pack()
# Shared Controls
farBottomFrame = Frame(mainWindow)
def open_output():
open_file(output_path(''))
openOutputButton = Button(farBottomFrame, text='Open Output Directory', command=open_output)
if os.path.exists(local_path('README.html')):
def open_readme():
open_file(local_path('README.html'))
openReadmeButton = Button(farBottomFrame, text='Open Documentation', command=open_readme)
openReadmeButton.pack(side=LEFT)
farBottomFrame.pack(side=BOTTOM, fill=X, padx=5, pady=5)
# randomizer controls
topFrame = Frame(randomizerWindow)
rightHalfFrame = Frame(topFrame)
checkBoxFrame = Frame(rightHalfFrame)
createSpoilerVar = IntVar()
createSpoilerCheckbutton = Checkbutton(checkBoxFrame, text="Create Spoiler Log", variable=createSpoilerVar)
suppressRomVar = IntVar()
suppressRomCheckbutton = Checkbutton(checkBoxFrame, text="Do not create patched Rom", variable=suppressRomVar)
compressRomVar = IntVar()
compressRomCheckbutton = Checkbutton(checkBoxFrame, text="Compress patched Rom", variable=compressRomVar)
openForestVar = IntVar()
openForestCheckbutton = Checkbutton(checkBoxFrame, text="Open Forest", variable=openForestVar)
openDoorVar = IntVar()
openDoorCheckbutton = Checkbutton(checkBoxFrame, text="Open Door of Time", variable=openDoorVar)
dungeonItemsVar = IntVar()
dungeonItemsCheckbutton = Checkbutton(checkBoxFrame, text="Place Dungeon Items (Compasses/Maps)", onvalue=0, offvalue=1, variable=dungeonItemsVar)
beatableOnlyVar = IntVar()
beatableOnlyCheckbutton = Checkbutton(checkBoxFrame, text="Only ensure seed is beatable, not all items must be reachable", variable=beatableOnlyVar)
hintsVar = IntVar()
hintsCheckbutton = Checkbutton(checkBoxFrame, text="Gossip Stone Hints with Stone of Agony", variable=hintsVar)
createSpoilerCheckbutton.pack(expand=True, anchor=W)
suppressRomCheckbutton.pack(expand=True, anchor=W)
compressRomCheckbutton.pack(expand=True, anchor=W)
openForestCheckbutton.pack(expand=True, anchor=W)
openDoorCheckbutton.pack(expand=True, anchor=W)
dungeonItemsCheckbutton.pack(expand=True, anchor=W)
beatableOnlyCheckbutton.pack(expand=True, anchor=W)
hintsCheckbutton.pack(expand=True, anchor=W)
fileDialogFrame = Frame(rightHalfFrame)
romDialogFrame = Frame(fileDialogFrame)
baseRomLabel = Label(romDialogFrame, text='Base Rom')
romVar = StringVar()
romEntry = Entry(romDialogFrame, textvariable=romVar)
def RomSelect():
rom = filedialog.askopenfilename(filetypes=[("Rom Files", (".z64", ".n64")), ("All Files", "*")])
romVar.set(rom)
romSelectButton = Button(romDialogFrame, text='Select Rom', command=RomSelect)
baseRomLabel.pack(side=LEFT)
romEntry.pack(side=LEFT)
romSelectButton.pack(side=LEFT)
romDialogFrame.pack()
checkBoxFrame.pack()
fileDialogFrame.pack()
drowDownFrame = Frame(topFrame)
bridgeFrame = Frame(drowDownFrame)
bridgeVar = StringVar()
bridgeVar.set('medallions')
bridgeOptionMenu = OptionMenu(bridgeFrame, bridgeVar, 'medallions', 'vanilla', 'dungeons', 'open')
bridgeOptionMenu.pack(side=RIGHT)
bridgeLabel = Label(bridgeFrame, text='Rainbow Bridge Requirement')
bridgeLabel.pack(side=LEFT)
bridgeFrame.pack(expand=True, anchor=E)
bottomFrame = Frame(randomizerWindow)
seedLabel = Label(bottomFrame, text='Seed #')
seedVar = StringVar()
seedEntry = Entry(bottomFrame, textvariable=seedVar)
countLabel = Label(bottomFrame, text='Count')
countVar = StringVar()
countSpinbox = Spinbox(bottomFrame, from_=1, to=100, textvariable=countVar)
def generateRom():
guiargs = Namespace
guiargs.seed = int(seedVar.get()) if seedVar.get() else None
guiargs.count = int(countVar.get()) if countVar.get() != '1' else None
guiargs.bridge = bridgeVar.get()
guiargs.create_spoiler = bool(createSpoilerVar.get())
guiargs.suppress_rom = bool(suppressRomVar.get())
guiargs.compress_rom = bool(compressRomVar.get())
guiargs.open_forest = bool(openForestVar.get())
guiargs.open_door_of_time = bool(openDoorVar.get())
guiargs.nodungeonitems = bool(dungeonItemsVar.get())
guiargs.beatableonly = bool(beatableOnlyVar.get())
guiargs.hints = bool(hintsVar.get())
guiargs.rom = romVar.get()
try:
if guiargs.count is not None:
seed = guiargs.seed
for _ in range(guiargs.count):
main(seed=seed, args=guiargs)
seed = random.randint(0, 999999999)
else:
main(seed=guiargs.seed, args=guiargs)
except Exception as e:
messagebox.showerror(title="Error while creating seed", message=str(e))
else:
messagebox.showinfo(title="Success", message="Rom patched successfully")
generateButton = Button(bottomFrame, text='Generate Patched Rom', command=generateRom)
seedLabel.pack(side=LEFT)
seedEntry.pack(side=LEFT)
countLabel.pack(side=LEFT, padx=(5, 0))
countSpinbox.pack(side=LEFT)
generateButton.pack(side=LEFT, padx=(5, 0))
openOutputButton.pack(side=RIGHT)
drowDownFrame.pack(side=LEFT)
rightHalfFrame.pack(side=RIGHT)
topFrame.pack(side=TOP)
bottomFrame.pack(side=BOTTOM)
if args is not None:
# load values from commandline args
createSpoilerVar.set(int(args.create_spoiler))
suppressRomVar.set(int(args.suppress_rom))
compressRomVar.set(int(args.compress_rom))
if args.nodungeonitems:
dungeonItemsVar.set(int(not args.nodungeonitems))
openForestVar.set(int(args.open_forest))
openDoorVar.set(int(args.open_door_of_time))
beatableOnlyVar.set(int(args.beatableonly))
hintsVar.set(int(args.hints))
if args.count:
countVar.set(str(args.count))
if args.seed:
seedVar.set(str(args.seed))
bridgeVar.set(args.bridge)
romVar.set(args.rom)
mainWindow.mainloop()
class CollectorGUI:
def __init__(self, master):
self.master = master
self.master.title('Mouse Movement Collection')
self.master.bind('<Motion>', self.track_movement)
self.master.bind('<Button-1>', self.track_click)
self.FRAME_WIDTH = 1000
self.FRAME_HEIGHT = 500
master.geometry('{}x{}'.format(self.FRAME_WIDTH,
self.FRAME_HEIGHT)) # width x height
self.start_button = Button(master,
text='Start Collection',
command=self.spawn_random_button)
self.start_button.pack()
self.collected = IntVar(value=0)
self.collected_total = IntVar(value=0)
self.num_to_collect = 50
self.counter = Label(master, textvariable=self.collected)
self.counter.place(x=10, y=10)
self.counter_total = Label(master, textvariable=self.collected_total)
self.counter_total.place(x=10, y=30)
self.current_button = {}
# self.button_log = {}
date = str(datetime.now().date())
data_dir = 'data\\'
# make the directory if the folder does not exist
if not os.path.exists(data_dir):
os.mkdir(data_dir)
filename = data_dir + 'button_log_{}.csv'.format(date)
print('Output will be written to {}'.format(filename))
self.button_log_file = open(filename, 'a+')
self.last_updated = time()
self.START_TIME = None
if self.START_TIME is None:
self.START_TIME = time()
#print(self.START_TIME)
# clears the GUI of existing buttons
def clear_buttons(self):
buttons = self.master.pack_slaves()
for b in buttons:
b.destroy()
buttons = self.master.place_slaves()
for b in buttons:
if isinstance(b, Button):
b.destroy()
return
# creates a new button of random size in a random location on the window
def spawn_random_button(self):
self.collected.set(value=(self.collected.get() +
1)) # increment counter
# CLOSE WINDOW AFTER N BUTTONS PRESSED
if self.collected.get() > self.num_to_collect:
self.clear_buttons()
sleep(.5)
self.restart()
return
self.collected_total.set(value=(self.collected_total.get() +
1)) # increment counter
self.last_updated = time()
self.clear_buttons() # clear previous button
n = self.collected.get()
new_button = Button(self.master,
text='CLICK ME',
command=self.spawn_random_button,
bg='red')
# randomize button dimensions and location
w = random.randint(15, 100)
h = random.randint(15, 100)
x = random.randint(w, self.FRAME_WIDTH - w)
y = random.randint(w, self.FRAME_HEIGHT - h)
# log button
this_button = {"x": x, "y": y, "width": w, "height": h}
self.current_button = this_button
# self.button_log[n] = this_button
# sleep(.1) # short break before next button appears
new_button.place(x=x, y=y, height=h, width=w)
# when an iteration is complete, spawn a button to restart the collection process
def restart(self):
w = 20
h = 80
x = random.randint(w, self.FRAME_WIDTH - w)
y = random.randint(w, self.FRAME_HEIGHT - h)
self.start_button = Button(self.master,
text='Start Collection',
command=self.spawn_random_button,
bg='blue')
self.start_button.place(x=x, y=y)
self.collected.set(0)
# collects information on movement events (position and time)
def track_movement(self, event):
x = event.x_root - self.master.winfo_rootx()
y = event.y_root - self.master.winfo_rooty()
# print('({}, {})'.format(x, y), 'button:', self.current_button)
t = time() - self.last_updated
if self.collected.get() > 0:
self.log_action('MOVE', x, y, t, self.current_button)
# collects information on click events (position and time)
def track_click(self, event):
x = event.x_root - self.master.winfo_rootx()
y = event.y_root - self.master.winfo_rooty()
t = time() - self.last_updated
if self.collected.get() > 0:
self.log_action('CLICK', x, y, t, self.current_button)
# writes collected event information to the CSV specified in the initialization of the GUI
def log_action(self, action, x, y, t, b):
self.button_log_file.write(
'{}, {}, {}, {}, {}, {}, {}, {}, {}\n'.format(
self.collected.get(), action, x, y, t, b['x'], b['y'],
b['width'], b['height']))
class MLNQueryGUI(object):
def __init__(self, master, gconf, directory=None):
self.master = master
self.initialized = False
self.master.bind('<Return>', self.infer)
self.master.bind('<Escape>', lambda a: self.master.quit())
self.master.protocol('WM_DELETE_WINDOW', self.quit)
self.dir = os.path.abspath(
ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
self.frame = Frame(master)
self.frame.pack(fill=BOTH, expand=1)
self.frame.columnconfigure(1, weight=1)
row = 0
# pracmln project options
Label(self.frame, text='PRACMLN Project: ').grid(row=row,
column=0,
sticky='ES')
project_container = Frame(self.frame)
project_container.grid(row=row, column=1, sticky="NEWS")
# new proj file
self.btn_newproj = Button(project_container,
text='New Project...',
command=self.new_project)
self.btn_newproj.grid(row=0, column=1, sticky="WS")
# open proj file
self.btn_openproj = Button(project_container,
text='Open Project...',
command=self.ask_load_project)
self.btn_openproj.grid(row=0, column=2, sticky="WS")
# save proj file
self.btn_updateproj = Button(project_container,
text='Save Project...',
command=self.noask_save_project)
self.btn_updateproj.grid(row=0, column=3, sticky="WS")
# save proj file as...
self.btn_saveproj = Button(project_container,
text='Save Project as...',
command=self.ask_save_project)
self.btn_saveproj.grid(row=0, column=4, sticky="WS")
# grammar selection
row += 1
Label(self.frame, text='Grammar: ').grid(row=row, column=0, sticky='E')
grammars = ['StandardGrammar', 'PRACGrammar']
self.selected_grammar = StringVar()
self.selected_grammar.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_grammar) + tuple(grammars))
l.grid(row=row, column=1, sticky='NWE')
# logic selection
row += 1
Label(self.frame, text='Logic: ').grid(row=row, column=0, sticky='E')
logics = ['FirstOrderLogic', 'FuzzyLogic']
self.selected_logic = StringVar()
self.selected_logic.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_logic) + tuple(logics))
l.grid(row=row, column=1, sticky='NWE')
# mln section
row += 1
Label(self.frame, text="MLN: ").grid(row=row, column=0, sticky='NE')
self.mln_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={
'extension': '.mln',
'ftypes': [('MLN files', '.mln')]
},
defaultname='*unknown{}',
importhook=self.import_mln,
deletehook=self.delete_mln,
projecthook=self.save_proj,
filecontenthook=self.mlnfilecontent,
fileslisthook=self.mlnfiles,
updatehook=self.update_mln,
onchangehook=self.project_setdirty)
self.mln_container.editor.bind("<FocusIn>", self._got_focus)
self.mln_container.grid(row=row, column=1, sticky="NEWS")
self.mln_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
row += 1
self.use_emln = IntVar()
self.use_emln.set(0)
self.cb_use_emln = Checkbutton(self.frame,
text="use model extension",
variable=self.use_emln,
command=self.onchange_use_emln)
self.cb_use_emln.grid(row=row, column=1, sticky="W")
# mln extension section
row += 1
self.emlncontainerrow = row
self.emln_label = Label(self.frame, text="EMLN: ")
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky='NE')
self.emln_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={
'extension':
'.emln',
'ftypes':
[('MLN extension files', '.emln')
]
},
defaultname='*unknown{}',
importhook=self.import_emln,
deletehook=self.delete_emln,
projecthook=self.save_proj,
filecontenthook=self.emlnfilecontent,
fileslisthook=self.emlnfiles,
updatehook=self.update_emln,
onchangehook=self.project_setdirty)
self.emln_container.grid(row=self.emlncontainerrow,
column=1,
sticky="NEWS")
self.emln_container.editor.bind("<FocusIn>", self._got_focus)
self.emln_container.columnconfigure(1, weight=2)
self.onchange_use_emln(dirty=False)
self.frame.rowconfigure(row, weight=1)
# db section
row += 1
Label(self.frame, text="Evidence: ").grid(row=row,
column=0,
sticky='NE')
self.db_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={
'extension': '.db',
'ftypes':
[('Database files', '.db')]
},
defaultname='*unknown{}',
importhook=self.import_db,
deletehook=self.delete_db,
projecthook=self.save_proj,
filecontenthook=self.dbfilecontent,
fileslisthook=self.dbfiles,
updatehook=self.update_db,
onchangehook=self.project_setdirty)
self.db_container.grid(row=row, column=1, sticky="NEWS")
self.db_container.editor.bind("<FocusIn>", self._got_focus)
self.db_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
# inference method selection
row += 1
self.list_methods_row = row
Label(self.frame, text="Method: ").grid(row=row, column=0, sticky=E)
self.selected_method = StringVar()
self.selected_method.trace('w', self.select_method)
methodnames = sorted(InferenceMethods.names())
self.list_methods = OptionMenu(*(self.frame, self.selected_method) +
tuple(methodnames))
self.list_methods.grid(row=self.list_methods_row,
column=1,
sticky="NWE")
# options
row += 1
option_container = Frame(self.frame)
option_container.grid(row=row, column=1, sticky="NEWS")
# Multiprocessing
self.multicore = IntVar()
self.cb_multicore = Checkbutton(option_container,
text="Use all CPUs",
variable=self.multicore,
command=self.settings_setdirty)
self.cb_multicore.grid(row=0, column=2, sticky=W)
# profiling
self.profile = IntVar()
self.cb_profile = Checkbutton(option_container,
text='Use Profiler',
variable=self.profile,
command=self.settings_setdirty)
self.cb_profile.grid(row=0, column=3, sticky=W)
# verbose
self.verbose = IntVar()
self.cb_verbose = Checkbutton(option_container,
text='verbose',
variable=self.verbose,
command=self.settings_setdirty)
self.cb_verbose.grid(row=0, column=4, sticky=W)
# options
self.ignore_unknown_preds = IntVar()
self.cb_ignore_unknown_preds = Checkbutton(
option_container,
text='ignore unkown predicates',
variable=self.ignore_unknown_preds,
command=self.settings_setdirty)
self.cb_ignore_unknown_preds.grid(row=0, column=5, sticky="W")
# queries
row += 1
Label(self.frame, text="Queries: ").grid(row=row, column=0, sticky=E)
self.query = StringVar()
self.query.trace('w', self.settings_setdirty)
Entry(self.frame, textvariable=self.query).grid(row=row,
column=1,
sticky="NEW")
# additional parameters
row += 1
Label(self.frame, text="Add. params: ").grid(row=row,
column=0,
sticky="NE")
self.params = StringVar()
self.params.trace('w', self.settings_setdirty)
self.entry_params = Entry(self.frame, textvariable=self.params)
self.entry_params.grid(row=row, column=1, sticky="NEW")
# closed-world predicates
row += 1
Label(self.frame, text="CW preds: ").grid(row=row,
column=0,
sticky="E")
cw_container = Frame(self.frame)
cw_container.grid(row=row, column=1, sticky='NEWS')
cw_container.columnconfigure(0, weight=1)
self.cwPreds = StringVar()
self.cwPreds.trace('w', self.settings_setdirty)
self.entry_cw = Entry(cw_container, textvariable=self.cwPreds)
self.entry_cw.grid(row=0, column=0, sticky="NEWS")
self.closed_world = IntVar()
self.cb_closed_world = Checkbutton(cw_container,
text="CW Assumption",
variable=self.closed_world,
command=self.onchange_cw)
self.cb_closed_world.grid(row=0, column=1, sticky='W')
# output filename
row += 1
output_cont = Frame(self.frame)
output_cont.grid(row=row, column=1, sticky='NEWS')
output_cont.columnconfigure(0, weight=1)
# - filename
Label(self.frame, text="Output: ").grid(row=row, column=0, sticky="NE")
self.output_filename = StringVar()
self.entry_output_filename = Entry(output_cont,
textvariable=self.output_filename)
self.entry_output_filename.grid(row=0, column=0, sticky="NEW")
# - save option
self.save = IntVar()
self.cb_save = Checkbutton(output_cont,
text="save",
variable=self.save)
self.cb_save.grid(row=0, column=1, sticky=W)
# start button
row += 1
start_button = Button(self.frame,
text=">> Start Inference <<",
command=self.infer)
start_button.grid(row=row, column=1, sticky="NEW")
self.settings_dirty = IntVar()
self.project_dirty = IntVar()
self.gconf = gconf
self.project = None
self.project_dir = os.path.abspath(
ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
if gconf['prev_query_project':self.project_dir] is not None:
self.load_project(
os.path.join(self.project_dir,
gconf['prev_query_project':self.project_dir]))
else:
self.new_project()
self.config = self.project.queryconf
self.project.addlistener(self.project_setdirty)
self.mln_container.dirty = False
self.emln_container.dirty = False
self.db_container.dirty = False
self.project_setdirty(dirty=False)
self.master.geometry(gconf['window_loc_query'])
self.initialized = True
def _got_focus(self, *_):
if self.master.focus_get() == self.mln_container.editor:
if not self.project.mlns and not self.mln_container.file_buffer:
self.mln_container.new_file()
elif self.master.focus_get() == self.db_container.editor:
if not self.project.dbs and not self.db_container.file_buffer:
self.db_container.new_file()
elif self.master.focus_get() == self.emln_container.editor:
if not self.project.emlns and not self.emln_container.file_buffer:
self.emln_container.new_file()
def quit(self):
if self.settings_dirty.get() or self.project_dirty.get():
savechanges = messagebox.askyesnocancel(
"Save changes",
"You have unsaved project changes. Do you want to save them before quitting?"
)
if savechanges is None:
return
elif savechanges:
self.noask_save_project()
self.master.destroy()
else:
# write gui settings and destroy
self.write_gconfig()
self.master.destroy()
####################### PROJECT FUNCTIONS #################################
def new_project(self):
self.project = MLNProject()
self.project.addlistener(self.project_setdirty)
self.project.name = DEFAULTNAME.format('.pracmln')
self.reset_gui()
self.set_config(self.project.queryconf)
self.mln_container.update_file_choices()
self.emln_container.update_file_choices()
self.db_container.update_file_choices()
self.project_setdirty(dirty=True)
def project_setdirty(self, dirty=False, *args):
self.project_dirty.set(dirty or self.mln_container.dirty
or self.db_container.dirty
or self.emln_container.dirty)
self.changewindowtitle()
def settings_setdirty(self, *args):
self.settings_dirty.set(1)
self.changewindowtitle()
def changewindowtitle(self):
title = (WINDOWTITLEEDITED if
(self.settings_dirty.get() or self.project_dirty.get()) else
WINDOWTITLE).format(self.project_dir, self.project.name)
self.master.title(title)
def ask_load_project(self):
filename = askopenfilename(initialdir=self.dir,
filetypes=[('PRACMLN project files',
'.pracmln')],
defaultextension=".pracmln")
if filename and os.path.exists(filename):
self.load_project(filename)
else:
logger.info('No file selected.')
return
def load_project(self, filename):
if filename and os.path.exists(filename):
projdir, _ = ntpath.split(filename)
self.dir = os.path.abspath(projdir)
self.project_dir = os.path.abspath(projdir)
self.project = MLNProject.open(filename)
self.project.addlistener(self.project_setdirty)
self.reset_gui()
self.set_config(self.project.queryconf.config)
self.mln_container.update_file_choices()
self.db_container.update_file_choices()
if len(self.project.mlns) > 0:
self.mln_container.selected_file.set(
self.project.queryconf['mln']
or list(self.project.mlns.keys())[0])
self.mln_container.dirty = False
if len(self.project.emlns) > 0:
self.emln_container.selected_file.set(
self.project.queryconf['emln']
or list(self.project.emlns.keys())[0])
self.emln_container.dirty = False
if len(self.project.dbs) > 0:
self.db_container.selected_file.set(
self.project.queryconf['db']
or list(self.project.dbs.keys())[0])
self.db_container.dirty = False
self.write_gconfig(savegeometry=False)
self.settings_dirty.set(0)
self.project_setdirty(dirty=False)
self.changewindowtitle()
else:
logger.error(
'File {} does not exist. Creating new project...'.format(
filename))
self.new_project()
def noask_save_project(self):
if self.project.name and not self.project.name == DEFAULTNAME.format(
'.pracmln'):
self.save_project(os.path.join(self.project_dir,
self.project.name))
else:
self.ask_save_project()
def ask_save_project(self):
fullfilename = asksaveasfilename(initialdir=self.project_dir,
confirmoverwrite=True,
filetypes=[('PRACMLN project files',
'.pracmln')],
defaultextension=".pracmln")
self.save_project(fullfilename)
def save_project(self, fullfilename):
if fullfilename:
fpath, fname = ntpath.split(fullfilename)
fname = fname.split('.')[0]
self.project.name = fname
self.dir = os.path.abspath(fpath)
self.project_dir = os.path.abspath(fpath)
self.mln_container.save_all_files()
self.emln_container.save_all_files()
self.db_container.save_all_files()
self.update_config()
self.project.save(dirpath=self.project_dir)
self.write_gconfig()
self.load_project(fullfilename)
self.settings_dirty.set(0)
def save_proj(self):
self.project.save(dirpath=self.project_dir)
self.write_gconfig()
self.project_setdirty(dirty=False)
####################### MLN FUNCTIONS #####################################
def import_mln(self, name, content):
self.project.add_mln(name, content)
def delete_mln(self, fname):
if fname in self.project.mlns:
self.project.rm_mln(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.mlns:
self.project.rm_mln(fnamestr)
def update_mln(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.mln_container.selected_file.get()
if new is None:
new = self.mln_container.selected_file.get().strip('*')
if content is None:
content = self.mln_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno(
"Save changes",
"A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.mlns[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.mlns[old] = content
else:
if new in self.project.mlns:
if askoverwrite:
savechanges = messagebox.askyesno(
"Save changes",
"A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.mlns[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.mlns[new] = content
return 1
def mlnfiles(self):
return list(self.project.mlns.keys())
def mlnfilecontent(self, filename):
return self.project.mlns.get(filename, '').strip()
# /MLN FUNCTIONS #####################################
####################### EMLN FUNCTIONS #####################################
def import_emln(self, name, content):
self.project.add_emln(name, content)
def delete_emln(self, fname):
if fname in self.project.emlns:
self.project.rm_emln(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.emlns:
self.project.rm_emln(fnamestr)
def update_emln(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.emln_container.selected_file.get()
if new is None:
new = self.emln_container.selected_file.get().strip('*')
if content is None:
content = self.emln_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno(
"Save changes",
"A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.emlns[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.emlns[old] = content
else:
if new in self.project.emlns:
if askoverwrite:
savechanges = messagebox.askyesno(
"Save changes",
"A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.emlns[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.emlns[new] = content
return 1
def emlnfiles(self):
return list(self.project.emlns.keys())
def emlnfilecontent(self, filename):
return self.project.emlns.get(filename, '').strip()
# /EMLN FUNCTIONS #####################################
# DB FUNCTIONS #####################################
def import_db(self, name, content):
self.project.add_db(name, content)
def delete_db(self, fname):
if fname in self.project.dbs:
self.project.rm_db(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.dbs:
self.project.rm_db(fnamestr)
def update_db(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.db_container.selected_file.get()
if new is None:
new = self.db_container.selected_file.get().strip('*')
if content is None:
content = self.db_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno(
"Save changes",
"A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.dbs[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.dbs[old] = content
else:
if new in self.project.dbs:
if askoverwrite:
savechanges = messagebox.askyesno(
"Save changes",
"A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.dbs[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.dbs[new] = content
return 1
def dbfiles(self):
return list(self.project.dbs.keys())
def dbfilecontent(self, filename):
return self.project.dbs.get(filename, '').strip()
# /DB FUNCTIONS #####################################
# GENERAL FUNCTIONS #################################
def select_method(self, *args):
self.set_outputfilename()
self.settings_setdirty()
def onchange_use_emln(self, dirty=True, *args):
if not self.use_emln.get():
self.emln_label.grid_forget()
self.emln_container.grid_forget()
else:
self.emln_label.grid(row=self.emlncontainerrow,
column=0,
sticky="NE")
self.emln_container.grid(row=self.emlncontainerrow,
column=1,
sticky="NWES")
if dirty:
self.settings_setdirty()
def onchange_cw(self, *args):
if self.closed_world.get():
self.entry_cw.configure(state=DISABLED)
else:
self.entry_cw.configure(state=NORMAL)
self.settings_setdirty()
def reset_gui(self):
self.set_config({})
self.db_container.clear()
self.emln_container.clear()
self.mln_container.clear()
def set_config(self, newconf):
self.config = newconf
self.selected_grammar.set(ifnone(newconf.get('grammar'),
'PRACGrammar'))
self.selected_logic.set(ifnone(newconf.get('logic'),
'FirstOrderLogic'))
self.mln_container.selected_file.set(ifnone(newconf.get('mln'), ''))
if self.use_emln.get():
self.emln_container.selected_file.set(
ifnone(newconf.get('mln'), ''))
self.db_container.selected_file.set(ifnone(newconf.get('db'), ""))
self.selected_method.set(
ifnone(newconf.get("method"),
InferenceMethods.name('MCSAT'),
transform=InferenceMethods.name))
self.multicore.set(ifnone(newconf.get('multicore'), 0))
self.profile.set(ifnone(newconf.get('profile'), 0))
self.params.set(ifnone(newconf.get('params'), ''))
self.use_emln.set(ifnone(newconf.get('use_emln'), 0))
self.verbose.set(ifnone(newconf.get('verbose'), 1))
self.ignore_unknown_preds.set(
ifnone(newconf.get('ignore_unknown_preds'), 0))
self.output_filename.set(ifnone(newconf.get('output_filename'), ''))
self.cwPreds.set(ifnone(newconf.get('cw_preds'), ''))
self.closed_world.set(ifnone(newconf.get('cw'), 0))
self.save.set(ifnone(newconf.get('save'), 0))
self.query.set(ifnone(newconf.get('queries'), ''))
self.onchange_cw()
def set_outputfilename(self):
if not hasattr(self, "output_filename") or not hasattr(
self, "db_filename") or not hasattr(self, "mln_filename"):
return
mln = self.mln_container.selected_file.get()
db = self.db_container.selected_file.get()
if "" in (mln, db):
return
if self.selected_method.get():
method = InferenceMethods.clazz(self.selected_method.get())
methodid = InferenceMethods.id(method)
filename = config.query_output_filename(mln, methodid, db)
self.output_filename.set(filename)
def update_config(self):
self.config = PRACMLNConfig()
self.config["use_emln"] = self.use_emln.get()
self.config['mln'] = self.mln_container.selected_file.get().strip(
).lstrip('*')
self.config['emln'] = self.emln_container.selected_file.get().strip(
).lstrip('*')
self.config["db"] = self.db_container.selected_file.get().strip(
).lstrip('*')
self.config["method"] = InferenceMethods.id(
self.selected_method.get().strip())
self.config["params"] = self.params.get().strip()
self.config["queries"] = self.query.get()
self.config["output_filename"] = self.output_filename.get().strip()
self.config["cw"] = self.closed_world.get()
self.config["cw_preds"] = self.cwPreds.get()
self.config['profile'] = self.profile.get()
self.config['logic'] = self.selected_logic.get()
self.config['grammar'] = self.selected_grammar.get()
self.config['multicore'] = self.multicore.get()
self.config['save'] = self.save.get()
self.config['ignore_unknown_preds'] = self.ignore_unknown_preds.get()
self.config['verbose'] = self.verbose.get()
self.config['window_loc'] = self.master.winfo_geometry()
self.config['dir'] = self.dir
self.project.queryconf = PRACMLNConfig()
self.project.queryconf.update(self.config.config.copy())
def write_gconfig(self, savegeometry=True):
self.gconf['prev_query_path'] = self.dir
self.gconf['prev_query_project':self.dir] = self.project.name
# save geometry
if savegeometry:
self.gconf['window_loc_query'] = self.master.geometry()
self.gconf.dump()
def infer(self, savegeometry=True, options={}, *args):
mln_content = self.mln_container.editor.get("1.0", END).strip()
db_content = self.db_container.editor.get("1.0", END).strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print((headline('PRACMLN QUERY TOOL')))
print()
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(
mln_content,
searchpaths=[self.dir],
projectpath=os.path.join(self.dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('emlnarg') is not None:
emln_content = mlnpath(options.get('emlnarg')).content
else:
emln_content = self.emln_container.editor.get("1.0",
END).strip()
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj,
dbfiles=[options.get('dbarg')],
ignore_unknown_preds=self.config.get(
'ignore_unknown_preds', True))
else:
out(self.config.get('ignore_unknown_preds', True))
dbobj = parse_db(mlnobj,
db_content,
ignore_unknown_preds=self.config.get(
'ignore_unknown_preds', True))
if options.get('queryarg') is not None:
self.config["queries"] = options.get('queryarg')
infer = MLNQuery(config=self.config,
mln=mlnobj,
db=dbobj,
emln=emln_content)
result = infer.run()
# write to file if run from commandline, otherwise save result to project results
if options.get('outputfile') is not None:
output = io.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')),
'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(
os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = io.StringIO()
result.write(output)
fname = self.output_filename.get()
self.project.add_result(fname, output.getvalue())
self.project.save(dirpath=self.dir)
logger.info(
'saved result to file results/{} in project {}'.format(
fname, self.project.name))
else:
logger.debug(
'No output file given - results have not been saved.')
except:
traceback.print_exc()
# restore main window
sys.stdout.flush()
self.master.deiconify()
class waitWindowProgressBar(Toplevel):
def __init__(self, parent=None):
"""
Initialises the calculate wait window. Waits for other processes to finish, then packs everything.
messages, setup_dataset and stop are the functions that change the layout of the frame.
"""
super().__init__(parent)
self.title("Setting up.......")
#self.attributes("-topmost", True)
self.pb_val = IntVar(self)
self.pb_val.set(0)
self.pb = Progressbar(self, length=400, variable=self.pb_val)
self.pb.pack(pady=20, padx=20)
self.pb.configure(maximum=10)
self.labeltext = StringVar()
self.labeltext.set("Waiting for other process.....")
self.waiting_label = Label(self, textvariable=self.labeltext)
self.waiting_label.configure(anchor="center")
self.waiting_label.pack(pady=20, padx=20, fill='both', expand=True)
self.stopbutton = Button(self,
text="Stop!",
compound="bottom",
command=self.stop)
self.stopbutton.pack(side="left", fill="x", expand=True)
self.stopflag = 0
self.update()
def stop(self):
"""
Sets the stopflag to 1, thus stopping the calculation.
"""
self.stopflag = 1
def setup_dataset(self, dataset):
"""
Sets up the calculation wait window for the different stages of calculation.
"""
self.dataset = dataset
self.title("Calculating Dataset %s" % os.path.basename(dataset.path))
self.waiting_label.pack(pady=20, padx=20)
self.update()
def errormessage(self, dataset):
messagebox.showwarning(
"Invalid parameters",
"Dataset %s was skipped in the computation because of invalid parameters. Please configure Cut-off frequency and / or Filter type."
% os.path.basename(dataset.path))
def return_function(self):
"""
Returns two functions for further use in the model.
"""
@ri.rternalize
def messages(i, r, each):
"""
Messages function given to the R environment.
Gives feedback on the state of the Monte-Carlo simulation.
"""
self.pb.step()
count = np.asarray((i, r))
if (count[0] == -1):
self.title("Computation for Dataset %s" %
os.path.basename(self.dataset.path))
self.pb.pack(pady=20, padx=20)
self.pb_val.set(0)
self.stopbutton["state"] = "normal"
if self.dataset.metadata[
"Method"] == "HILDE-Homogeneous" or self.dataset.metadata[
"Method"] == "HILDE-Heterogeneous":
self.pb.configure(maximum=int(
self.dataset.metadata["Repetitions_Hilde"]))
else:
self.pb.configure(
maximum=int(self.dataset.metadata["Repetitions"]))
self.labeltext.set(
"Currently computing quantile for Dataset:\n%s \n Press Stop! button to stop computation for current dataset."
% os.path.basename(self.dataset.path))
if (count[0] == -2):
self.pb.pack_forget()
self.labeltext.set(
"Calculating fit for Dataset:\n%s\nThis computation cannot be interrupted and may take a few minutes."
% os.path.basename(self.dataset.path))
self.stopbutton["state"] = "disabled"
self.waiting_label.pack(pady=20, padx=20)
self.update()
return self.stopflag
return messages, self.setup_dataset, self.errormessage
class MLNQueryGUI(object):
def __init__(self, master, gconf, directory=None):
self.master = master
self.initialized = False
self.master.bind('<Return>', self.infer)
self.master.bind('<Escape>', lambda a: self.master.quit())
self.master.protocol('WM_DELETE_WINDOW', self.quit)
self.dir = os.path.abspath(ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
self.frame = Frame(master)
self.frame.pack(fill=BOTH, expand=1)
self.frame.columnconfigure(1, weight=1)
row = 0
# pracmln project options
Label(self.frame, text='PRACMLN Project: ').grid(row=row, column=0,
sticky='ES')
project_container = Frame(self.frame)
project_container.grid(row=row, column=1, sticky="NEWS")
# new proj file
self.btn_newproj = Button(project_container, text='New Project...', command=self.new_project)
self.btn_newproj.grid(row=0, column=1, sticky="WS")
# open proj file
self.btn_openproj = Button(project_container, text='Open Project...', command=self.ask_load_project)
self.btn_openproj.grid(row=0, column=2, sticky="WS")
# save proj file
self.btn_updateproj = Button(project_container, text='Save Project...', command=self.noask_save_project)
self.btn_updateproj.grid(row=0, column=3, sticky="WS")
# save proj file as...
self.btn_saveproj = Button(project_container, text='Save Project as...', command=self.ask_save_project)
self.btn_saveproj.grid(row=0, column=4, sticky="WS")
# grammar selection
row += 1
Label(self.frame, text='Grammar: ').grid(row=row, column=0, sticky='E')
grammars = ['StandardGrammar', 'PRACGrammar']
self.selected_grammar = StringVar()
self.selected_grammar.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_grammar) + tuple(grammars))
l.grid(row=row, column=1, sticky='NWE')
# logic selection
row += 1
Label(self.frame, text='Logic: ').grid(row=row, column=0, sticky='E')
logics = ['FirstOrderLogic', 'FuzzyLogic']
self.selected_logic = StringVar()
self.selected_logic.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_logic) + tuple(logics))
l.grid(row=row, column=1, sticky='NWE')
# mln section
row += 1
Label(self.frame, text="MLN: ").grid(row=row, column=0, sticky='NE')
self.mln_container = FileEditBar(self.frame, directory=self.dir,
filesettings={'extension': '.mln', 'ftypes': [('MLN files', '.mln')]},
defaultname='*unknown{}',
importhook=self.import_mln,
deletehook=self.delete_mln,
projecthook=self.save_proj,
filecontenthook=self.mlnfilecontent,
fileslisthook=self.mlnfiles,
updatehook=self.update_mln,
onchangehook=self.project_setdirty)
self.mln_container.editor.bind("<FocusIn>", self._got_focus)
self.mln_container.grid(row=row, column=1, sticky="NEWS")
self.mln_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
row += 1
self.use_emln = IntVar()
self.use_emln.set(0)
self.cb_use_emln = Checkbutton(self.frame, text="use model extension",
variable=self.use_emln,
command=self.onchange_use_emln)
self.cb_use_emln.grid(row=row, column=1, sticky="W")
# mln extension section
row += 1
self.emlncontainerrow = row
self.emln_label = Label(self.frame, text="EMLN: ")
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky='NE')
self.emln_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={'extension': '.emln', 'ftypes': [('MLN extension files','.emln')]},
defaultname='*unknown{}',
importhook=self.import_emln,
deletehook=self.delete_emln,
projecthook=self.save_proj,
filecontenthook=self.emlnfilecontent,
fileslisthook=self.emlnfiles,
updatehook=self.update_emln,
onchangehook=self.project_setdirty)
self.emln_container.grid(row=self.emlncontainerrow, column=1, sticky="NEWS")
self.emln_container.editor.bind("<FocusIn>", self._got_focus)
self.emln_container.columnconfigure(1, weight=2)
self.onchange_use_emln(dirty=False)
self.frame.rowconfigure(row, weight=1)
# db section
row += 1
Label(self.frame, text="Evidence: ").grid(row=row, column=0, sticky='NE')
self.db_container = FileEditBar(self.frame, directory=self.dir,
filesettings={'extension': '.db', 'ftypes': [('Database files', '.db')]},
defaultname='*unknown{}',
importhook=self.import_db,
deletehook=self.delete_db,
projecthook=self.save_proj,
filecontenthook=self.dbfilecontent,
fileslisthook=self.dbfiles,
updatehook=self.update_db,
onchangehook=self.project_setdirty)
self.db_container.grid(row=row, column=1, sticky="NEWS")
self.db_container.editor.bind("<FocusIn>", self._got_focus)
self.db_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
# inference method selection
row += 1
self.list_methods_row = row
Label(self.frame, text="Method: ").grid(row=row, column=0, sticky=E)
self.selected_method = StringVar()
self.selected_method.trace('w', self.select_method)
methodnames = sorted(InferenceMethods.names())
self.list_methods = OptionMenu(*(self.frame, self.selected_method) + tuple(methodnames))
self.list_methods.grid(row=self.list_methods_row, column=1, sticky="NWE")
# options
row += 1
option_container = Frame(self.frame)
option_container.grid(row=row, column=1, sticky="NEWS")
# Multiprocessing
self.multicore = IntVar()
self.cb_multicore = Checkbutton(option_container, text="Use all CPUs",
variable=self.multicore,
command=self.settings_setdirty)
self.cb_multicore.grid(row=0, column=2, sticky=W)
# profiling
self.profile = IntVar()
self.cb_profile = Checkbutton(option_container, text='Use Profiler',
variable=self.profile,
command=self.settings_setdirty)
self.cb_profile.grid(row=0, column=3, sticky=W)
# verbose
self.verbose = IntVar()
self.cb_verbose = Checkbutton(option_container, text='verbose',
variable=self.verbose,
command=self.settings_setdirty)
self.cb_verbose.grid(row=0, column=4, sticky=W)
# options
self.ignore_unknown_preds = IntVar()
self.cb_ignore_unknown_preds = Checkbutton(option_container,
text='ignore unkown predicates',
variable=self.ignore_unknown_preds,
command=self.settings_setdirty)
self.cb_ignore_unknown_preds.grid(row=0, column=5, sticky="W")
# queries
row += 1
Label(self.frame, text="Queries: ").grid(row=row, column=0, sticky=E)
self.query = StringVar()
self.query.trace('w', self.settings_setdirty)
Entry(self.frame, textvariable=self.query).grid(row=row, column=1, sticky="NEW")
# additional parameters
row += 1
Label(self.frame, text="Add. params: ").grid(row=row, column=0, sticky="NE")
self.params = StringVar()
self.params.trace('w', self.settings_setdirty)
self.entry_params = Entry(self.frame, textvariable=self.params)
self.entry_params.grid(row=row, column=1, sticky="NEW")
# closed-world predicates
row += 1
Label(self.frame, text="CW preds: ").grid(row=row, column=0, sticky="E")
cw_container = Frame(self.frame)
cw_container.grid(row=row, column=1, sticky='NEWS')
cw_container.columnconfigure(0, weight=1)
self.cwPreds = StringVar()
self.cwPreds.trace('w', self.settings_setdirty)
self.entry_cw = Entry(cw_container, textvariable=self.cwPreds)
self.entry_cw.grid(row=0, column=0, sticky="NEWS")
self.closed_world = IntVar()
self.cb_closed_world = Checkbutton(cw_container, text="CW Assumption",
variable=self.closed_world,
command=self.onchange_cw)
self.cb_closed_world.grid(row=0, column=1, sticky='W')
# output filename
row += 1
output_cont = Frame(self.frame)
output_cont.grid(row=row, column=1, sticky='NEWS')
output_cont.columnconfigure(0, weight=1)
# - filename
Label(self.frame, text="Output: ").grid(row=row, column=0, sticky="NE")
self.output_filename = StringVar()
self.entry_output_filename = Entry(output_cont, textvariable=self.output_filename)
self.entry_output_filename.grid(row=0, column=0, sticky="NEW")
# - save option
self.save = IntVar()
self.cb_save = Checkbutton(output_cont, text="save", variable=self.save)
self.cb_save.grid(row=0, column=1, sticky=W)
# start button
row += 1
start_button = Button(self.frame, text=">> Start Inference <<", command=self.infer)
start_button.grid(row=row, column=1, sticky="NEW")
self.settings_dirty = IntVar()
self.project_dirty = IntVar()
self.gconf = gconf
self.project = None
self.project_dir = os.path.abspath(ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
if gconf['prev_query_project': self.project_dir] is not None:
self.load_project(os.path.join(self.project_dir, gconf['prev_query_project':self.project_dir]))
else:
self.new_project()
self.config = self.project.queryconf
self.project.addlistener(self.project_setdirty)
self.mln_container.dirty = False
self.emln_container.dirty = False
self.db_container.dirty = False
self.project_setdirty(dirty=False)
self.master.geometry(gconf['window_loc_query'])
self.initialized = True
def _got_focus(self, *_):
if self.master.focus_get() == self.mln_container.editor:
if not self.project.mlns and not self.mln_container.file_buffer:
self.mln_container.new_file()
elif self.master.focus_get() == self.db_container.editor:
if not self.project.dbs and not self.db_container.file_buffer:
self.db_container.new_file()
elif self.master.focus_get() == self.emln_container.editor:
if not self.project.emlns and not self.emln_container.file_buffer:
self.emln_container.new_file()
def quit(self):
if self.settings_dirty.get() or self.project_dirty.get():
savechanges = messagebox.askyesnocancel("Save changes", "You have unsaved project changes. Do you want to save them before quitting?")
if savechanges is None:
return
elif savechanges:
self.noask_save_project()
self.master.destroy()
else:
# write gui settings and destroy
self.write_gconfig()
self.master.destroy()
####################### PROJECT FUNCTIONS #################################
def new_project(self):
self.project = MLNProject()
self.project.addlistener(self.project_setdirty)
self.project.name = DEFAULTNAME.format('.pracmln')
self.reset_gui()
self.set_config(self.project.queryconf)
self.mln_container.update_file_choices()
self.emln_container.update_file_choices()
self.db_container.update_file_choices()
self.project_setdirty(dirty=True)
def project_setdirty(self, dirty=False, *args):
self.project_dirty.set(dirty or self.mln_container.dirty or self.db_container.dirty or
self.emln_container.dirty)
self.changewindowtitle()
def settings_setdirty(self, *args):
self.settings_dirty.set(1)
self.changewindowtitle()
def changewindowtitle(self):
title = (WINDOWTITLEEDITED if (self.settings_dirty.get() or self.project_dirty.get()) else WINDOWTITLE).format(self.project_dir, self.project.name)
self.master.title(title)
def ask_load_project(self):
filename = askopenfilename(initialdir=self.dir, filetypes=[('PRACMLN project files', '.pracmln')], defaultextension=".pracmln")
if filename and os.path.exists(filename):
self.load_project(filename)
else:
logger.info('No file selected.')
return
def load_project(self, filename):
if filename and os.path.exists(filename):
projdir, _ = ntpath.split(filename)
self.dir = os.path.abspath(projdir)
self.project_dir = os.path.abspath(projdir)
self.project = MLNProject.open(filename)
self.project.addlistener(self.project_setdirty)
self.reset_gui()
self.set_config(self.project.queryconf.config)
self.mln_container.update_file_choices()
self.db_container.update_file_choices()
if len(self.project.mlns) > 0:
self.mln_container.selected_file.set(self.project.queryconf['mln'] or list(self.project.mlns.keys())[0])
self.mln_container.dirty = False
if len(self.project.emlns) > 0:
self.emln_container.selected_file.set(self.project.queryconf['emln'] or list(self.project.emlns.keys())[0])
self.emln_container.dirty = False
if len(self.project.dbs) > 0:
self.db_container.selected_file.set(self.project.queryconf['db'] or list(self.project.dbs.keys())[0])
self.db_container.dirty = False
self.write_gconfig(savegeometry=False)
self.settings_dirty.set(0)
self.project_setdirty(dirty=False)
self.changewindowtitle()
else:
logger.error('File {} does not exist. Creating new project...'.format(filename))
self.new_project()
def noask_save_project(self):
if self.project.name and not self.project.name == DEFAULTNAME.format('.pracmln'):
self.save_project(os.path.join(self.project_dir, self.project.name))
else:
self.ask_save_project()
def ask_save_project(self):
fullfilename = asksaveasfilename(initialdir=self.project_dir,
confirmoverwrite=True,
filetypes=[('PRACMLN project files','.pracmln')],
defaultextension=".pracmln")
self.save_project(fullfilename)
def save_project(self, fullfilename):
if fullfilename:
fpath, fname = ntpath.split(fullfilename)
fname = fname.split('.')[0]
self.project.name = fname
self.dir = os.path.abspath(fpath)
self.project_dir = os.path.abspath(fpath)
self.mln_container.save_all_files()
self.emln_container.save_all_files()
self.db_container.save_all_files()
self.update_config()
self.project.save(dirpath=self.project_dir)
self.write_gconfig()
self.load_project(fullfilename)
self.settings_dirty.set(0)
def save_proj(self):
self.project.save(dirpath=self.project_dir)
self.write_gconfig()
self.project_setdirty(dirty=False)
####################### MLN FUNCTIONS #####################################
def import_mln(self, name, content):
self.project.add_mln(name, content)
def delete_mln(self, fname):
if fname in self.project.mlns:
self.project.rm_mln(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.mlns:
self.project.rm_mln(fnamestr)
def update_mln(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.mln_container.selected_file.get()
if new is None:
new = self.mln_container.selected_file.get().strip('*')
if content is None:
content = self.mln_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.mlns[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.mlns[old] = content
else:
if new in self.project.mlns:
if askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.mlns[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.mlns[new] = content
return 1
def mlnfiles(self):
return list(self.project.mlns.keys())
def mlnfilecontent(self, filename):
return self.project.mlns.get(filename, '').strip()
# /MLN FUNCTIONS #####################################
####################### EMLN FUNCTIONS #####################################
def import_emln(self, name, content):
self.project.add_emln(name, content)
def delete_emln(self, fname):
if fname in self.project.emlns:
self.project.rm_emln(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.emlns:
self.project.rm_emln(fnamestr)
def update_emln(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.emln_container.selected_file.get()
if new is None:
new = self.emln_container.selected_file.get().strip('*')
if content is None:
content = self.emln_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.emlns[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.emlns[old] = content
else:
if new in self.project.emlns:
if askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.emlns[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.emlns[new] = content
return 1
def emlnfiles(self):
return list(self.project.emlns.keys())
def emlnfilecontent(self, filename):
return self.project.emlns.get(filename, '').strip()
# /EMLN FUNCTIONS #####################################
# DB FUNCTIONS #####################################
def import_db(self, name, content):
self.project.add_db(name, content)
def delete_db(self, fname):
if fname in self.project.dbs:
self.project.rm_db(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.dbs:
self.project.rm_db(fnamestr)
def update_db(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.db_container.selected_file.get()
if new is None:
new = self.db_container.selected_file.get().strip('*')
if content is None:
content = self.db_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.dbs[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.dbs[old] = content
else:
if new in self.project.dbs:
if askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.dbs[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.dbs[new] = content
return 1
def dbfiles(self):
return list(self.project.dbs.keys())
def dbfilecontent(self, filename):
return self.project.dbs.get(filename, '').strip()
# /DB FUNCTIONS #####################################
# GENERAL FUNCTIONS #################################
def select_method(self, *args):
self.set_outputfilename()
self.settings_setdirty()
def onchange_use_emln(self, dirty=True, *args):
if not self.use_emln.get():
self.emln_label.grid_forget()
self.emln_container.grid_forget()
else:
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky="NE")
self.emln_container.grid(row=self.emlncontainerrow, column=1, sticky="NWES")
if dirty:
self.settings_setdirty()
def onchange_cw(self, *args):
if self.closed_world.get():
self.entry_cw.configure(state=DISABLED)
else:
self.entry_cw.configure(state=NORMAL)
self.settings_setdirty()
def reset_gui(self):
self.set_config({})
self.db_container.clear()
self.emln_container.clear()
self.mln_container.clear()
def set_config(self, newconf):
self.config = newconf
self.selected_grammar.set(ifnone(newconf.get('grammar'), 'PRACGrammar'))
self.selected_logic.set(ifnone(newconf.get('logic'), 'FirstOrderLogic'))
self.mln_container.selected_file.set(ifnone(newconf.get('mln'), ''))
if self.use_emln.get():
self.emln_container.selected_file.set(ifnone(newconf.get('mln'), ''))
self.db_container.selected_file.set(ifnone(newconf.get('db'), ""))
self.selected_method.set(ifnone(newconf.get("method"), InferenceMethods.name('MCSAT'), transform=InferenceMethods.name))
self.multicore.set(ifnone(newconf.get('multicore'), 0))
self.profile.set(ifnone(newconf.get('profile'), 0))
self.params.set(ifnone(newconf.get('params'), ''))
self.use_emln.set(ifnone(newconf.get('use_emln'), 0))
self.verbose.set(ifnone(newconf.get('verbose'), 1))
self.ignore_unknown_preds.set(ifnone(newconf.get('ignore_unknown_preds'), 0))
self.output_filename.set(ifnone(newconf.get('output_filename'), ''))
self.cwPreds.set(ifnone(newconf.get('cw_preds'), ''))
self.closed_world.set(ifnone(newconf.get('cw'), 0))
self.save.set(ifnone(newconf.get('save'), 0))
self.query.set(ifnone(newconf.get('queries'), ''))
self.onchange_cw()
def set_outputfilename(self):
if not hasattr(self, "output_filename") or not hasattr(self, "db_filename") or not hasattr(self, "mln_filename"):
return
mln = self.mln_container.selected_file.get()
db = self.db_container.selected_file.get()
if "" in (mln, db):
return
if self.selected_method.get():
method = InferenceMethods.clazz(self.selected_method.get())
methodid = InferenceMethods.id(method)
filename = config.query_output_filename(mln, methodid, db)
self.output_filename.set(filename)
def update_config(self):
self.config = PRACMLNConfig()
self.config["use_emln"] = self.use_emln.get()
self.config['mln'] = self.mln_container.selected_file.get().strip().lstrip('*')
self.config['emln'] = self.emln_container.selected_file.get().strip().lstrip('*')
self.config["db"] = self.db_container.selected_file.get().strip().lstrip('*')
self.config["method"] = InferenceMethods.id(self.selected_method.get().strip())
self.config["params"] = self.params.get().strip()
self.config["queries"] = self.query.get()
self.config["output_filename"] = self.output_filename.get().strip()
self.config["cw"] = self.closed_world.get()
self.config["cw_preds"] = self.cwPreds.get()
self.config['profile'] = self.profile.get()
self.config['logic'] = self.selected_logic.get()
self.config['grammar'] = self.selected_grammar.get()
self.config['multicore'] = self.multicore.get()
self.config['save'] = self.save.get()
self.config['ignore_unknown_preds'] = self.ignore_unknown_preds.get()
self.config['verbose'] = self.verbose.get()
self.config['window_loc'] = self.master.winfo_geometry()
self.config['dir'] = self.dir
self.project.queryconf = PRACMLNConfig()
self.project.queryconf.update(self.config.config.copy())
def write_gconfig(self, savegeometry=True):
self.gconf['prev_query_path'] = self.dir
self.gconf['prev_query_project': self.dir] = self.project.name
# save geometry
if savegeometry:
self.gconf['window_loc_query'] = self.master.geometry()
self.gconf.dump()
def infer(self, savegeometry=True, options={}, *args):
mln_content = self.mln_container.editor.get("1.0", END).strip()
db_content = self.db_container.editor.get("1.0", END).strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print((headline('PRACMLN QUERY TOOL')))
print()
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(mln_content, searchpaths=[self.dir],
projectpath=os.path.join(self.dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('emlnarg') is not None:
emln_content = mlnpath(options.get('emlnarg')).content
else:
emln_content = self.emln_container.editor.get("1.0", END).strip()
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj, dbfiles=[options.get('dbarg')], ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
else:
out(self.config.get('ignore_unknown_preds', True))
dbobj = parse_db(mlnobj, db_content, ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
if options.get('queryarg') is not None:
self.config["queries"] = options.get('queryarg')
infer = MLNQuery(config=self.config, mln=mlnobj, db=dbobj, emln=emln_content)
result = infer.run()
# write to file if run from commandline, otherwise save result to project results
if options.get('outputfile') is not None:
output = io.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')), 'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = io.StringIO()
result.write(output)
fname = self.output_filename.get()
self.project.add_result(fname, output.getvalue())
self.project.save(dirpath=self.dir)
logger.info('saved result to file results/{} in project {}'.format(fname, self.project.name))
else:
logger.debug('No output file given - results have not been saved.')
except:
traceback.print_exc()
# restore main window
sys.stdout.flush()
self.master.deiconify()
class IntegerEntry(StringEntry):
"""Integer class for entry
super
Parameters
----------
parent : str
parent handle
lf_text : str
text on LabelFrame
l_limit : int
lower limit
u_limit : int
upper limit
def_inp : str
default text
colour : str
frame colour
mod : str
enable or disable state switch
Returns
-------
integer
"""
def __init__(self,
parent,
lf_text,
l_limit,
u_limit,
def_inp="",
colour='brown',
mod=False):
'''
#self.parent = parent
#self.lf_text = lf_text
#self.mod = mod
#self.colour = colour
'''
super().__init__(parent, lf_text, def_inp, colour, mod) # added
# StringEntry.__init__(self,fr,lf_text,def_inp,colour,mod)
self.l_limit = l_limit
self.u_limit = u_limit
self.out_var = IntVar()
self.out_var.set(def_inp)
self.construct(colour)
self.limits()
self.make_entry()
def limits(self):
"""limit logic
Parameters
----------
None
Returns
-------
None
"""
self.ulab = Label(self,
text=str(self.u_limit) + " upper limit",
style='brown.TLabel') # self.lf1
self.ulab.grid(row=0, column=1, padx=10)
self.llab = Label(self,
text=str(self.l_limit) + " lower limit",
style='brown.TLabel') # self.lf1
self.llab.grid(row=1, column=1, padx=10)
def end_input(self, evt):
"""limit on integer, float
Parameters
----------
evt : str
bind handle
Returns
-------
None
"""
self.ulab['style'] = 'brown.TLabel'
self.llab['style'] = 'brown.TLabel'
if self.l_limit < self.out_var.get() < self.u_limit:
self.messlbl['text'] = "That's OK"
elif self.l_limit >= self.out_var.get():
self.messlbl['text'] = "Input below or at lower limit"
self.llab['style'] = 'lowr.TLabel'
else:
self.messlbl['text'] = "Input above or at upper limit"
self.ulab['style'] = 'upr.TLabel'
def is_okay(self, text, inp, ind):
""" validation function
Parameters
----------
text : str
text if allowed
inp : str
current input
Returns
-------
boolean
"""
if text in ("", "-"):
return True
try:
int(text)
except ValueError:
return False
return True
class sideWindow(AppShell):
#################################################################
# sideWindow(AppShell)
# This class will open a side window wich contains a scene graph and
# a world setting page.
#################################################################
appversion = '1.0'
appname = 'Navigation Window'
frameWidth = 325
frameHeight = 580
frameIniPosX = 0
frameIniPosY = 110
padx = 0
pady = 0
lightEnable = 0
ParticleEnable = 0
basedriveEnable = 0
collision = 0
backface = 0
texture = 1
wireframe = 0
enableBaseUseDrive = 0
def __init__(self, worldColor,lightEnable,ParticleEnable, basedriveEnable,collision,
backface, texture, wireframe, grid, widgetVis, enableAutoCamera, parent = None, nodePath = render, **kw):
self.worldColor = worldColor
self.lightEnable = lightEnable
self.ParticleEnable = ParticleEnable
self.basedriveEnable = basedriveEnable
self.collision = collision
self.backface = backface
self.texture = texture
self.wireframe = wireframe
self.grid = grid
self.enableAutoCamera = enableAutoCamera
self.widgetVis = widgetVis
# Define the megawidget options.
optiondefs = (
('title', self.appname, None),
)
self.defineoptions(kw, optiondefs)
if parent == None:
self.parent = Toplevel()
else:
self.parent = parent
AppShell.__init__(self, self.parent)
self.parent.geometry('%dx%d+%d+%d' % (self.frameWidth, self.frameHeight,self.frameIniPosX,self.frameIniPosY))
self.parent.resizable(False,False) ## Disable the ability to resize for this Window.
def appInit(self):
print('----SideWindow is Initialized!!')
def createInterface(self):
# The interior of the toplevel panel
interior = self.interior()
mainFrame = Frame(interior)
## Creat NoteBook
self.notebookFrame = Pmw.NoteBook(mainFrame)
self.notebookFrame.pack(fill=tkinter.BOTH,expand=1)
sgePage = self.notebookFrame.add('Tree Graph')
envPage = self.notebookFrame.add('World Setting')
self.notebookFrame['raisecommand'] = self.updateInfo
## Tree Grapgh Page
self.SGE = seSceneGraphExplorer.seSceneGraphExplorer(
sgePage, nodePath = render,
scrolledCanvas_hull_width = 270,
scrolledCanvas_hull_height = 570)
self.SGE.pack(fill = tkinter.BOTH, expand = 0)
## World Setting Page
envPage = Frame(envPage)
pageFrame = Frame(envPage)
self.LightingVar = IntVar()
self.LightingVar.set(self.lightEnable)
self.LightingButton = Checkbutton(
pageFrame,
text = 'Enable Lighting',
variable = self.LightingVar,
command = self.toggleLights)
self.LightingButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.CollisionVar = IntVar()
self.CollisionVar.set(self.collision)
self.CollisionButton = Checkbutton(
pageFrame,
text = 'Show Collision Object',
variable = self.CollisionVar,
command = self.showCollision)
self.CollisionButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.ParticleVar = IntVar()
self.ParticleVar.set(self.ParticleEnable)
self.ParticleButton = Checkbutton(
pageFrame,
text = 'Show Particle Dummy',
variable = self.ParticleVar,
command = self.enableParticle)
self.ParticleButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.baseUseDriveVar = IntVar()
self.baseUseDriveVar.set(self.basedriveEnable)
self.baseUseDriveButton = Checkbutton(
pageFrame,
text = 'Enable base.usedrive',
variable = self.baseUseDriveVar,
command = self.enablebaseUseDrive)
self.baseUseDriveButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.backfaceVar = IntVar()
self.backfaceVar.set(self.backface)
self.backfaceButton = Checkbutton(
pageFrame,
text = 'Enable BackFace',
variable = self.backfaceVar,
command = self.toggleBackface)
self.backfaceButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.textureVar = IntVar()
self.textureVar.set(self.texture)
self.textureButton = Checkbutton(
pageFrame,
text = 'Enable Texture',
variable = self.textureVar,
command = self.toggleTexture)
self.textureButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.wireframeVar = IntVar()
self.wireframeVar.set(self.wireframe)
self.wireframeButton = Checkbutton(
pageFrame,
text = 'Enable Wireframe',
variable = self.wireframeVar,
command = self.toggleWireframe)
self.wireframeButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.gridVar = IntVar()
self.gridVar.set(self.grid)
self.gridButton = Checkbutton(
pageFrame,
text = 'Enable Grid',
variable = self.gridVar,
command = self.toggleGrid)
self.gridButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.widgetVisVar = IntVar()
self.widgetVisVar.set(self.widgetVis)
self.widgetVisButton = Checkbutton(
pageFrame,
text = 'Enable WidgetVisible',
variable = self.widgetVisVar,
command = self.togglewidgetVis)
self.widgetVisButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.enableAutoCameraVar = IntVar()
self.enableAutoCameraVar.set(self.enableAutoCamera)
self.enableAutoCameraButton = Checkbutton(
pageFrame,
text = 'Enable Auto Camera Movement for Loading Objects',
variable = self.enableAutoCameraVar,
command = self.toggleAutoCamera)
self.enableAutoCameraButton.pack(side=tkinter.LEFT, expand=False)
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
pageFrame = Frame(envPage)
self.backgroundColor = ColorEntry(
pageFrame, text = 'BG Color', value=self.worldColor)
self.backgroundColor['command'] = self.setBackgroundColorVec
self.backgroundColor['resetValue'] = [0,0,0,0]
self.backgroundColor.pack(side=tkinter.LEFT, expand=False)
self.bind(self.backgroundColor, 'Set background color')
pageFrame.pack(side=tkinter.TOP, fill=tkinter.X, expand=True)
envPage.pack(expand=False)
## Set all stuff done
self.notebookFrame.setnaturalsize()
mainFrame.pack(fill = 'both', expand = 1)
def createMenuBar(self):
# We don't need menu bar here.
self.menuBar.destroy()
def onDestroy(self, event):
#################################################################
# onDestroy(self, event)
# This function will be called when user closed the side window.
# Here we will send out a message with whole data set we will need
# for the next time user open the side window.
#################################################################
messenger.send('SW_close',[self.worldColor,
self.lightEnable,
self.ParticleEnable,
self.basedriveEnable,
self.collision,
self.backface,
self.texture,
self.wireframe,
self.grid,
self.widgetVis,
self.enableAutoCamera])
'''
If you have open any thing, please rewrite here!
'''
pass
###############################
def updateInfo(self, page = 'Tree Graph'):
#################################################################
# updateInfo(self, page = 'Tree Graph')
# This function will be called when each time user change the main
# page of the window.
# What it dose is to call right function to restore the data for current selected page.
#################################################################
if page=='Tree Graph':
self.updateTreeGraph()
elif page == 'World Setting':
self.updateWorldSetting()
def updateTreeGraph(self):
#################################################################
# updateTreeGraph(self)
# When scene graoh page has been opend, call sceneGraphExplorer to
# updata the tree.
#################################################################
self.SGE.update()
pass
def updateWorldSetting(self):
#################################################################
# updateWorldSetting(self)
# When world setting page has been selected, this function will
# reset those check box in the page to reflect the current world setting.
#################################################################
self.LightingVar.set(self.lightEnable)
self.CollisionVar.set(self.collision)
self.ParticleVar.set(self.ParticleEnable)
self.baseUseDriveVar.set(self.basedriveEnable)
self.backgroundColor.set(value = self.worldColor)
pass
def toggleLights(self):
#################################################################
# toggleLights(self)
# send out a message to let sceneEditor know we need to toggle the light.
# Then, sceneEditor will pass the message to dataHolder to disable/enable
# the lights. (lightManager is inside the dataHolder)
#################################################################
self.lightEnable = (self.lightEnable+1)%2
messenger.send('SW_lightToggle')
pass
def showCollision(self):
#################################################################
# showCollision(self)
# This function will send out a message to sceneEditor to toggle
# the visibility of collision objects.
#################################################################
self.collision = (self.collision+1)%2
messenger.send('SW_collisionToggle', [self.collision])
pass
def enableParticle(self):
#################################################################
# enableParticle(self)
# This function will send out a message to sceneEditor to toggle
# the visibility of particle objects.
#################################################################
self.ParticleEnable = (self.ParticleEnable+1)%2
messenger.send('SW_particleToggle', [self.ParticleEnable])
pass
def enablebaseUseDrive(self):
#################################################################
# enablebaseUseDrive(self)
# This function will toggle the usage of base.useDrive.
# Well, it may not usefull at all.
#
# We won't send out any message in this time to notice
# the sceneEditor this event happend.
# In the other hand, we will restore it back when
# the side window has been closed.
#
#################################################################
if self.enableBaseUseDrive==0:
print('Enabled')
base.useDrive()
self.enableBaseUseDrive = 1
else:
print('disabled')
#base.useTrackball()
base.disableMouse()
self.enableBaseUseDrive = 0
self.basedriveEnable = (self.basedriveEnable+1)%2
pass
def toggleBackface(self):
#################################################################
# toggleBackface(self)
# This function will toggle the back face setting. so it will
# render the polygon with two sides.
#################################################################
base.toggleBackface()
self.backface = (self.backface+1)%2
return
def toggleBackfaceFromMainW(self):
#################################################################
# toggleBackfaceFromMainW(self)
# This function is called by sceneEditor when user used hot key
# to toggle the back face setting in the main panda window.
# In here we will only reset the flag and reset the state of
# check box
#################################################################
self.backface = (self.backface+1)%2
self.backfaceButton.toggle()
return
def toggleTexture(self):
#################################################################
# toggleTexture(self)
# This function will toggle the txture using option for the whole scene.
#################################################################
base.toggleTexture()
self.texture = (self.texture+1)%2
return
def toggleTextureFromMainW(self):
#################################################################
# toggleTextureFromMainW(self)
# This function is called by sceneEditor when user used hot key
# to toggle the texture usage from the main panda window.
# In here we will only reset the flag and reset the state of
# check box
#################################################################
self.texture = (self.texture+1)%2
self.textureButton.toggle()
return
def toggleWireframe(self):
#################################################################
# toggleWireframe(self)
# This function will toggle the wire frame mode.
#################################################################
base.toggleWireframe()
self.wireframe = (self.wireframe+1)%2
return
def toggleWireframeFromMainW(self):
#################################################################
# toggleWireframeFromMainW(self)
# This function is called by sceneEditor when user used hot key
# to toggle the wire frame mode in the main panda window.
# In here we will only reset the flag and reset the state of
# check box
#################################################################
self.wireframe = (self.wireframe+1)%2
self.wireframeButton.toggle()
return
def toggleGrid(self):
#################################################################
# toggleGrid(self)
# This function will toggle the usage of the grid.
#################################################################
self.grid = (self.grid+1)%2
if self.grid==1:
SEditor.grid.enable()
else:
SEditor.grid.disable()
def togglewidgetVis(self):
#################################################################
# togglewidgetVis(self)
# This function will toggle the visibility of the widget of the grid.
#################################################################
self.widgetVis = (self.widgetVis+1)%2
SEditor.toggleWidgetVis()
if SEditor.widget.fActive:
messenger.send('shift-f')
return
def toggleWidgetVisFromMainW(self):
#################################################################
# toggleWidgetVisFromMainW(self)
# This function is called by sceneEditor when user used hot key
# to toggle the visibility of widgets ('v') from the main panda window.
# In here we will only reset the flag and reset the state of
# check box
#################################################################
self.widgetVis = (self.widgetVis+1)%2
self.widgetVisButton.toggle()
return
def setBackgroundColorVec(self,color):
#################################################################
# setBackgroundColorVec(self,color)
# Call back function
# This will be called from the colorEntry on the world setting page.
# The "color" here is a list containing three integer data, R, G and B.
#################################################################
base.setBackgroundColor(color[0]/255.0,
color[1]/255.0,
color[2]/255.0)
self.worldColor = [color[0],color[1],color[2],0]
def toggleAutoCamera(self):
#################################################################
# toggleAutoCamera(self)
# This function will toggle the usage of the auto-camera movement
# when user loaded model or actor into the scene.
#################################################################
self.enableAutoCamera = (self.enableAutoCamera+1)%2
SEditor.toggleAutoCamera()
return
def selectPage(self,page='Tree Graph'):
#################################################################
#################################################################
self.notebookFrame.selectpage(page)
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
self.createWidgets()
def generate(self):
n = int(self.menu_gen.get())
seed = self.inp_seed.get()
self.output = Generator.convert(seed, n)
if len(self.output) > 0:
self.generated = True
self.butt_draw.config( state= 'normal')
self.chek_fullscrn.config(state= 'normal')
self.clearOutput(self.output)
def draw(self, n, step=False):
p1, p2 = Draw.move(n)
self.curr_canvas.create_line(p1[0], p1[1], p2[0], p2[1], fill= self.color, width= self.thick)
if step:
self.curr_canvas.update_idletasks()
def do(self, action, step, rainbow):
if len(action) > 1:
p = action[1]
else:
p = 1.0
self.timebuff += step
cmd = action[0].lower()
if cmd == "draw":
if rainbow:
self.incColor()
if self.incThickYN:
self.incThick(self.reverseThick, False)
elif self.incThickYN:
self.incThick(self.reverseThick, True)
if self.timebuff > 1.0:
truncate = int(self.timebuff)
self.after(truncate, self.draw(float(p), True))
self.timebuff -= truncate
else:
self.draw(float(p))
elif cmd == "turn":
Draw.turn(float(p))
elif cmd == "skip":
Draw.skip(float(p))
elif cmd == "back":
Draw.back(float(p))
elif cmd == "color":
if not rainbow:
self.color = Color.getHexString(p)
elif cmd == "thick":
self.thick = int(p)
else:
print("Unknown command " + cmd)
def drawAll(self, newWindow= True):
if self.generated == True:
self.butt_print.config(state= 'disabled')
self.timebuff = 0.0
self.color = Color.white()
self.thick = 2
l = float(self.slid_linesize.get())
a = float(self.slid_angle.get())
Draw.init(self.startingPoint, l, a)
if self.fullScreen.get() == 1:
if newWindow:
self.curr_canvas = dc.BigCanvas(self).canvas
self.canvas.delete("all")
else:
self.curr_canvas = self.canvas
self.curr_canvas.delete("all")
self.curr_canvas.config(bg= Color.getHexString(self.bgColor.get()))
rainbow = self.rainbowCheck.get() == 1
if rainbow or self.incThickYN:
self.incStep = 1.0/float(self.getDrawCount(self.output))
self.percent = 0.0
for c in self.output:
if c == '[':
Draw.push()
elif c == ']':
Draw.pop()
else:
for r in Rule.getDrawings():
if c == r[0]:
if len(r) > 2:
params = (r[1], r[2])
else:
params = (r[1],)
s = float(self.slid_timer.get())
self.do(params, s, rainbow)
break
self.butt_print.config(state= 'normal')
def incColor(self):
self.color = Color.getValueByPercent(self.percent)
self.percent += self.incStep
def incThick(self, reverse, incYN):
maxthick = 5
minthick = 1
diff = maxthick - minthick
if reverse:
result = maxthick - int(diff * self.percent)
else:
result = minthick + int(diff * self.percent)
self.thick = result
if incYN:
self.percent += self.incStep
def getDrawCount(self, s):
draw_commands = []
for r in Rule.getDrawings():
if r[1].lower() == "draw":
draw_commands.append(r[0])
draw_count = 0;
for c in s:
for d in draw_commands:
if c == d:
draw_count += 1
break
return draw_count
def clearOutput(self, replacement=None):
self.text_output.config(state= 'normal')
self.text_output.delete(1.0, END)
if replacement:
self.text_output.insert(END, replacement)
self.text_output.config(state= 'disabled')
def formatRules(self, rules):
ret = []
for r in rules:
entry = r[0] + " | " + r[1]
if len(r) > 2:
entry += " " + r[2]
ret.append(entry)
return ret
def getRuleFromFormatted(self, s):
if s:
rule = s.split('|')
rule[0] = rule[0].strip()
rule[1] = rule[1].strip()
prod = rule[1].split(" ")
if len(prod) == 1:
return (rule[0], prod[0])
else:
return (rule[0], prod[0], prod[1])
def RefreshLists(self):
self.list_prod.delete(0, END)
self.list_draw.delete(0, END)
l = self.formatRules(Rule.getProductions())
for p in l:
self.list_prod.insert(END, p)
l = self.formatRules(Rule.getDrawings())
for d in l:
self.list_draw.insert(END, d)
def AddProductionRule(self, edit=None):
rule = dp.AddProductionRuleDialog(self, edit).result
if rule:
if edit:
Rule.removeProd(edit[0])
Rule.AddProduction(rule)
self.RefreshLists()
def AddDrawingRule(self, edit=None):
rule = dd.AddDrawingRuleDialog(self, edit).result
if rule:
if edit:
Rule.removeDraw(edit[0])
Rule.AddDrawing(rule)
self.RefreshLists()
def EditProductionRule(self):
s = self.list_prod.curselection()
if s:
idx = s[0]
rule = (idx,) + self.getRuleFromFormatted(self.list_prod.get(idx))
if rule:
self.AddProductionRule(rule)
def EditDrawingRule(self):
s = self.list_draw.curselection()
if s:
idx = s[0]
rule = (idx,) + self.getRuleFromFormatted(self.list_draw.get(idx))
if rule:
self.AddDrawingRule(rule)
def DeleteProductionRule(self):
s = self.list_prod.curselection()
if s:
Rule.removeProd(s[0])
self.RefreshLists()
def DeleteDrawingRule(self):
s = self.list_draw.curselection()
if s:
Rule.removeDraw(s[0])
self.RefreshLists()
def packOutput(self):
ret = ""
ret += self.packAxiom()
ret += self.packProdRules()
ret += self.packDrawRules()
return ret
def packAxiom(self):
return "@" + str(self.inp_seed.get()).strip()
def packRules(self, rules):
ret = "@"
for r in rules:
ret += "$" + str(r[0]) + "|" + str(r[1])
if len(r) > 2:
ret += ":" + str(r[2])
return ret
def packProdRules(self):
return self.packRules(Rule.getProductions())
def packDrawRules(self):
return self.packRules(Rule.getDrawings())
def parseProdRules(self, raw):
rules = raw.split('$')
for rule in rules:
if rule is not "":
r = rule.split('|')
Rule.AddProduction((r[0], r[1]))
def parseDrawRules(self, raw):
rules = raw.split('$')
for rule in rules:
if rule is not "":
r = rule.split('|')
p = r[1].split(':')
if len(p) == 1:
tup = (r[0], p[0])
else:
tup = (r[0], p[0], p[1])
Rule.AddDrawing(tup)
def parseSaveFile(self, s):
Rule.wipe()
settings = s.split('@')
self.inp_seed.set(str(settings[1]))
self.parseProdRules(settings[2])
self.parseDrawRules(settings[3])
self.RefreshLists()
def save(self):
try:
filename = filedialog.asksaveasfilename(**self.file_options['txt'])
if filename:
f = open(filename, 'w')
f.write(self.packOutput())
f.close()
except Exception as e:
print("File IO error in save\n", e)
def load(self):
try:
filename = filedialog.askopenfilename(**self.file_options['txt'])
if filename:
f = open(filename, 'r')
self.parseSaveFile(f.read())
f.close()
self.slid_linesize.set(1.0)
self.slid_timer.set(0.0)
self.menu_gen.set(1)
self.clearOutput()
except Exception as e:
print("File IO error in load\n" + e)
def help(self):
help.HelpDialog(self)
def saveImage(self):
filename = filedialog.asksaveasfilename(**self.file_options['ps'])
self.curr_canvas.postscript(file=filename, colormode='color')
def click(self, event):
self.startingPoint = (event.x, event.y)
def clickAndRedraw(self, event):
self.click(event)
self.drawAll(False)
def fileOptions(self):
self.file_options = {}
txt_options = {}
ps_options = {}
txt_options['defaultextension'] = '.txt'
txt_options['filetypes'] = [('Plaintext', '.txt')]
txt_options['initialdir'] = 'Patterns'
ps_options['defaultextension'] = '.ps'
ps_options['filetypes'] = [('Postscript Image', '.ps')]
ps_options['initialdir'] = 'Images'
self.file_options['txt'] = txt_options
self.file_options['ps'] = ps_options
def makeMenuBar(self):
self.menubar = Menu(self);
self.menubar.add_command(label="Save", command= self.save)
self.menubar.add_command(label="Load", command= self.load)
self.menubar.add_command(label="Help", command= self.help)
root.config(menu= self.menubar)
def makeInputFrame(self):
self.inp_seed = String()
self.bgColor = String()
self.gen_value = Int()
self.rainbowCheck = Int()
self.fram_input = Frame(self, bd= 2, relief= self.style, width= input_frame_width, height= input_frame_height)
self.fram_seed = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_prod = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_draw = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_drawParams = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_gen = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_output = Frame(self.fram_input, bd= 1, relief= self.style)
self.menu_gen = DropDown(self.fram_gen, textvariable= self.gen_value, state= 'readonly')
self.entr_seed = Input(self.fram_seed, textvariable= self.inp_seed)
self.text_output = Output(self.fram_output, width= 35, height= 10)
self.scrl_output = Scrollbar(self.fram_output)
self.list_prod = List(self.fram_prod, selectmode= BROWSE, font= "Courier 8", height= 5)
self.list_draw = List(self.fram_draw, selectmode= BROWSE, font= "Courier 8", height= 5)
self.slid_linesize = Slider(self.fram_drawParams, from_= 0.1, to= 10.0, orient= HORIZONTAL, resolution= 0.1, length= 180)
self.slid_timer = Slider(self.fram_drawParams, from_= 0, to= 2, orient= HORIZONTAL, resolution= 0.02, length= 180)
self.slid_angle = Slider(self.fram_drawParams, from_= 0, to= 359, orient= HORIZONTAL, length= 180)
self.entr_bgcolor = Input (self.fram_drawParams, textvariable= self.bgColor)
self.butt_prodAdd = Button(self.fram_prod, text= "Add", width=8, command= self.AddProductionRule)
self.butt_prodEdit = Button(self.fram_prod, text= "Edit", width=8, command= self.EditProductionRule)
self.butt_prodDelete = Button(self.fram_prod, text= "Delete", width=8, command= self.DeleteProductionRule)
self.butt_drawAdd = Button(self.fram_draw, text= "Add", width=8, command= self.AddDrawingRule)
self.butt_drawEdit = Button(self.fram_draw, text= "Edit", width=8, command= self.EditDrawingRule)
self.butt_drawDelete = Button(self.fram_draw, text= "Delete", width=8, command= self.DeleteDrawingRule)
self.chek_incColor = CheckBox(self.fram_draw, text= "Rainbow", variable= self.rainbowCheck)
Label(self.fram_seed, text= "Axiom:", width=8).grid (row=0, column=0)
Label(self.fram_prod, text= "Production\nRules:", width=8).grid (row=0, column=0)
Label(self.fram_draw, text= "Drawing\nRules:", width=8).grid (row=0, column=0)
Label(self.fram_drawParams, text= "Line Size:").grid (row=0, column=0)
Label(self.fram_drawParams, text= "Delay (ms):").grid (row=1, column=0)
Label(self.fram_drawParams, text= "Starting Angle:").grid (row=2, column=0)
Label(self.fram_drawParams, text= "Background Color:").grid (row=3, column=0)
Label(self.fram_output, text= "Output:").grid (row=0, column=0)
Label(self.fram_gen, text= "Generations:").grid (row=0, column=0)
self.gen_value.set(1)
self.menu_gen['values'] = tuple(range(1, 13))
self.slid_linesize.set(1.0)
self.bgColor.set( Color.default() )
self.text_output.config(state='disabled', yscrollcommand= self.scrl_output.set)
self.scrl_output.config(command=self.text_output.yview)
self.fram_input.grid (row=0, column=0)
self.fram_seed.grid (row=1, column=0, sticky= 'ew')
self.fram_prod.grid (row=2, column=0, sticky= 'ew')
self.fram_draw.grid (row=3, column=0, sticky= 'ew')
self.fram_drawParams.grid (row=4, column=0, sticky= 'ew')
self.fram_gen.grid (row=5, column=0, sticky= 'ew')
self.fram_output.grid (row=6, column=0, sticky= 'ew')
self.entr_seed.grid (row=0, column=1, sticky= 'ew')
self.list_prod.grid (row=0, column=1, sticky= 'ew')
self.butt_prodAdd.grid (row=1, column=0, sticky= 'ew')
self.butt_prodEdit.grid (row=1, column=1, sticky= 'ew')
self.butt_prodDelete.grid (row=1, column=2, sticky= 'ew')
self.list_draw.grid (row=0, column=1)
self.butt_drawAdd.grid (row=1, column=0, sticky= 'ew')
self.butt_drawEdit.grid (row=1, column=1, sticky= 'ew')
self.butt_drawDelete.grid (row=1, column=2, sticky= 'ew')
self.chek_incColor.grid (row=0, column=2)
self.slid_linesize.grid (row=0, column=1, sticky= 'ew')
self.slid_timer.grid (row=1, column=1, sticky= 'ew')
self.slid_angle.grid (row=2, column=1, sticky= 'ew')
self.entr_bgcolor.grid (row=3, column=1, sticky= 'ew')
self.menu_gen.grid (row=0, column=1, sticky= 'ew')
self.text_output.grid (row=1, column=0)
self.scrl_output.grid (row=1, column=1, sticky= 'ns')
def makeCanvasFrame(self):
self.fram_canvas = Frame(self, bd=10, relief=self.style)
self.canvas = Canvas(self.fram_canvas, width= canvas_width, height= canvas_height)
self.fram_canvas.grid(row=0, column=1, sticky='nesw')
self.canvas.grid(sticky='nesw')
self.canvas.bind("<Button-1>", self.click)
self.curr_canvas = self.canvas
def makeIgnitionFrame(self):
self.fullScreen = Int()
self.fram_ignition = Frame(self, bd=4, relief=self.style, width= ignition_frame_width, height= ignition_frame_height)
self.butt_generate = Button(self.fram_ignition, text= " -- GENERATE -- ", width=111, command= self.generate)
self.butt_draw = Button(self.fram_ignition, text= " -- DRAW -- ", width=100, command= self.drawAll, state= 'disabled')
self.butt_print = Button(self.fram_ignition, text= "Save Image", command= self.saveImage, state= 'disabled')
self.chek_fullscrn = CheckBox(self.fram_ignition, text= "Fullscreen", variable= self.fullScreen, state= 'disabled')
self.fram_ignition.grid(row=1, column=0, columnspan=2)
self.butt_generate.grid(row=0, column=0, columnspan=2)
self.butt_draw.grid( row=1, column=0)
self.butt_print.grid( row=0, column=2, rowspan= 2, sticky='ns')
self.chek_fullscrn.grid(row=1, column=1)
def createWidgets(self):
self.incThickYN = False
self.reverseThick = False
self.style = RIDGE
self.startingPoint = (20, 20)
self.generated = False
self.fileOptions()
self.makeMenuBar()
self.makeInputFrame()
self.makeCanvasFrame()
self.makeIgnitionFrame()
class Gui(Frame):
def __init__(self, control, *args, **kwargs):
Frame.__init__(self, *args, **kwargs)
self.config(padx=2)
self.queue = Queue()
self.control = control
self.disabledWhileRunning = []
self.formulae = list(map(lambda t: StringVar(self, t), ["x/22.5+4", "50-x*50/180"]))
self.executionTime = DoubleVar(self, "360")
self.programSpeed = IntVar(self, "292")
self.maxTravel = IntVar(self, "-200000")
self.loadSettings()
self.createWidgets()
self.thread = None
def compileFormulae(self):
rv = []
for f in self.formulae:
body = "def formula5480750923(x):\n return " + f.get()
l = {}
try:
exec(body, {}, l)
except:
rv.append(None)
continue
compiled = l["formula5480750923"]
compiled(0)
rv.append(compiled)
return rv
def plotFormulae(self):
try:
compiled = self.compileFormulae()
except:
return
for g in self.graphs:
g.points = []
self.canvas.x.end = self.executionTime.get()
self.canvas.clear()
for x in range(self.canvas.x.start, int(self.canvas.x.end)):
point = []
for c in range(len(compiled)):
v = None
if compiled[c]:
v = compiled[c](x)
assert isinstance(v, float)
point.append(v)
self.__addPoint__(x, point)
self.canvas.update()
def __start__(self):
self.canvas.x.end = self.executionTime.get()
pumps = self.compileFormulae()
self.setValues()
self.control.mover.setSpeed(abs(int(self.programSpeed.get())))
start_time = float(self.current_time.get())
def calcPumpValues(time):
values = list(map(lambda x: x(time), pumps))
self.__addPoint__(time, values)
self.current_time.set(time)
return values
def thFunc():
try:
for g in self.graphs:
g.points = []
self.control.executeProgram(start_time, calcPumpValues)
finally:
self.invoke(self.__enableControls__)
self.__disableControls__()
self.canvas.clear()
self.thread = Thread(target=thFunc, name="Control")
self.thread.start()
def __enableControls__(self):
for e in self.disabledWhileRunning:
e.config(state=NORMAL)
def __disableControls__(self):
for e in self.disabledWhileRunning:
e.config(state="disabled")
def __addPoint__(self, x, values):
for v in values:
assert isinstance(v, float)
def c():
for i in range(len(self.canvas.graphs)):
self.canvas.graphs[i].addPoint(x, values[i])
self.invoke(c)
def invoke(self, callable):
self.after_idle(callable)
def __stop__(self):
self.control.stop()
def __quit__(self):
def quitting():
self.__stop__()
if self.thread and self.thread.is_alive():
print("Thread is active")
return False
self.quit()
return True
run_repeating(self, quitting)
def __move__(self, steps):
speed = int(self.speed.get())
if speed < 0:
speed *= -1
self.speed.set(speed)
self.control.mover.setSpeed(speed)
self.control.mover.go(steps)
def __up__(self):
steps = int(self.steps.get())
self.__move__(steps)
def __down__(self):
steps = int(self.steps.get())
self.__move__(-steps)
def showValues(self):
self.maxTravel.set(self.control.mover.maxTravel)
self.executionTime.set(self.control.fullTime)
self.programSpeed.set(self.control.mover.getSpeed())
def setValues(self):
self.control.mover.maxTravel = int(self.maxTravel.get())
self.control.fullTime = float(self.executionTime.get())
self.control.mover.setSpeed(abs(int(self.programSpeed.get())))
def loadSettings(self):
config = Config()
try:
config.read()
except KeyError:
pass
config.configureControl(self.control)
for i in range(len(self.formulae)):
self.formulae[i].set(config.formulae[i])
self.showValues()
def saveSettings(self):
self.setValues()
config = Config()
config.getFromControl(self.control)
for i in range(len(self.formulae)):
config.formulae[i] = self.formulae[i].get()
config.write()
def createWidgets(self):
panel = Frame(self, name="mainMenu")
panel.grid(sticky=W)
Button(panel, name="quit", text="Выход", command=self.__quit__).grid(row=0, column=0)
Button(panel, name="reconnect", text="Пересоединение", command=self.control.reconnect).grid(row=0, column=1)
b = Button(panel, text="Загрузить", command=self.loadSettings)
b.grid(row=0, column=2)
self.disabledWhileRunning.append(b)
b = Button(panel, text="Сохранить", command=self.saveSettings)
b.grid(row=0, column=3)
self.disabledWhileRunning.append(b)
panel = LabelFrame(self, text="Прямое управление стаканом", name="motor")
panel.grid(sticky=W)
b = Button(panel, text="Вверх", command=self.__up__, name="up")
b.grid(row=0, column=0)
self.disabledWhileRunning.append(b)
b = Button(panel, text="Вниз", command=self.__down__, name="down")
b.grid(row=1, column=0)
self.disabledWhileRunning.append(b)
Label(panel, text="Шаг:").grid(sticky=E, row=0, column=1)
self.steps = IntVar(self, "10000")
Entry(panel, textvariable=self.steps, width=6).grid(sticky=W, row=0, column=2)
Label(panel, text="Скорость:").grid(sticky=E, row=1, column=1)
self.speed = IntVar(self, "2000")
Entry(panel, textvariable=self.speed, width=6).grid(sticky=W, row=1, column=2)
self.position = IntVar(self, "1000")
def readPosition():
try:
self.position.set(self.control.mover.getPosition())
except (ConnectionResetError, Timeout):
pass
run_repeating(self, readPosition, 10000)
b = Button(panel, text="Прочитать положение", command=readPosition)
b.grid(row=0, column=3, columnspan=2)
self.disabledWhileRunning.append(b)
Label(panel, text="Положение:").grid(sticky=E, row=1, column=3)
Entry(panel, textvariable=self.position, width=8, state="disabled").grid(sticky=W, row=1, column=4)
panel = LabelFrame(self, text="Программа", name="program")
program = panel
panel.grid(sticky=W + E)
panel.columnconfigure(1, weight=1)
row = 0
for f in self.formulae:
columns, rows = self.grid_size()
Label(panel, text="Насос %d:" % (row + 1)).grid(row=row, column=0, sticky=E)
e = Entry(panel, textvariable=f)
e.grid(sticky=E + W, row=row, column=1)
self.disabledWhileRunning.append(e)
f.trace("w", lambda *x: self.after_idle(self.plotFormulae))
row += 1
panel = Frame(program, name="mover")
panel.grid(columnspan=2, sticky=W)
Label(panel, text="Максимальное смещение:").grid(sticky=E)
Entry(panel, textvariable=self.maxTravel).grid(sticky=W, row=0, column=1)
Label(panel, text="Скорость:").grid(sticky=E)
Entry(panel, textvariable=self.programSpeed).grid(sticky=W, row=1, column=1)
Label(panel, text="Время выполнения (в секундах):").grid(sticky=E)
e = Entry(panel, textvariable=self.executionTime)
e.grid(sticky=W, row=2, column=1)
self.current_time = DoubleVar(self, "0")
Label(panel, text="Текущее время:").grid(sticky=E)
e = Entry(panel, textvariable=self.current_time)
e.grid(sticky=W, row=3, column=1)
self.disabledWhileRunning.append(e)
self.executionTime.trace("w", lambda *x: self.plotFormulae())
panel = Frame(program, name="bottom")
panel.grid(columnspan=2, sticky=W)
row = 0
startButton = Button(panel, name="start", text="Старт", command=self.__start__)
startButton.grid(row=row, column=0)
self.disabledWhileRunning.append(startButton)
Button(panel, text="Стоп", command=self.__stop__).grid(row=row, column=1)
self.canvas = GraphCanvas(self)
self.graphs = (Graph(self.canvas), Graph(self.canvas))
self.canvas.x.end = 100
self.canvas.y.end = 24
self.plotFormulae()
self.canvas.grid(sticky=E + W + S + N)
columns, rows = self.grid_size()
self.columnconfigure(columns - 1, weight=1)
self.rowconfigure(rows - 1, weight=1)
class OptimizeGroup(Group):
def __init__(self, *args, **kwargs):
self._app = kwargs.pop('wavesyn_root')
self.__topwin = kwargs.pop('topwin')
super().__init__(*args, **kwargs)
parameter_frame = Frame(self)
parameter_frame.pack(side='left', expand='yes', fill='y')
self.__num = LabeledEntry(parameter_frame)
set_attributes(self.__num,
label_text = 'num',
entry_text = '1',
label_width = 5,
entry_width = 8,
checker_function = self._app.gui.value_checker.check_int
)
self.__num.entry.bind('<Return>', lambda event: self._on_solve_click())
self.__num.pack(side='top')
self.__pci = LabeledEntry(parameter_frame)
set_attributes(self.__pci,
label_text = 'PCI',
entry_text = '100',
label_width = 5,
entry_width = 8,
checker_function = self._app.gui.value_checker.check_int
)
self.__pci.pack(side='top')
self.__parallel_checker_variable = IntVar()
self.__parallel_checker = Checkbutton(parameter_frame, text="Parallel", variable=self.__parallel_checker_variable, command=self._on_parallel_checker_click)
self.__parallel_checker.pack()
progfrm = Frame(self)
progfrm.pack(side='left', expand='yes', fill='y')
self.__genbtn = Button(progfrm, text='Generate', command=self._on_solve_click)
self.__genbtn.pack(side='top')
Button(progfrm, text='Stop', command=self._on_stop_button_click).pack(side='top')
self.__progressbar_variable = IntVar()
self.__finishedwav = IntVar()
self.__progressbar = Progressbar(progfrm, orient='horizontal', variable=self.__progressbar_variable, maximum=100)
self.__progressbar.pack(side='left')
self.__progressbar.config(length=55)
self.__finishedwavbar = Progressbar(progfrm, orient='horizontal', variable=self.__finishedwav)
self.__finishedwavbar.pack(side='left')
self.__finishedwavbar.config(length=30)
self.name = 'Generate'
self.getparams = None
self.__stopflag = False
def _on_solve_click(self):
params = self.__topwin.parameter_group.get_parameters()
repeat_times = self.__num.get_int()
if self.__parallel_checker_variable.get():
run = self.__topwin.current_algorithm.process_run
else:
run = self.__topwin.current_algorithm.thread_run
with code_printer():
run(on_finished=['store', 'plot'], progress_indicator='progress_dialog', repeat_times=repeat_times, **params)
def _on_stop_button_click(self):
self.__stopflag = True
def _on_parallel_checker_click(self):
topwin = self.__topwin
if topwin.current_algorithm.need_cuda:
self.__parallel_checker_variable.set(0)
topwin.root_node.gui.dialogs.report(f'''{topwin.node_path}:
Current algorithm "{topwin.current_algorithm.meta.name}" need CUDA worker, which does not support multi-cpu parallel.
''')
def _cancel_parallel(self):
self.__parallel_checker_variable.set(0)
class IpdSubOptionsForm(VerticalScrolledFrame):
# Initialize the GUI
def __init__(self, root):
VerticalScrolledFrame.__init__(self, root)
#Frame.__init__(self, root)
#super(500, 500)
root.title("Choose IPD-IMGT/HLA Submission Options")
self.parent = root
#button_opt = {'fill': Tkconstants.BOTH, 'padx': 35, 'pady': 5}
# This window should not be resizeable. I guess.
self.parent.resizable(width=False, height=False)
#self.parent.resizable(width=True, height=True)
# To define the exit behavior. Save and exit.
self.parent.protocol('WM_DELETE_WINDOW', self.saveOptions)
# Define the return behavior. Same as "close window" etc
root.bind('<Return>', self.returnFunction)
self.instructionsFrame = Frame(self.interior)
self.instructionText = StringVar()
self.instructionText.set('\nThese options are required for an IPD allele submission.\n'
+ 'Login Credentials will not be stored, but they will be sent to IPD via\n'
+ 'secure https connection.\n')
Label(self.instructionsFrame, width=85, height=6, textvariable=self.instructionText).pack()
self.instructionsFrame.pack()
#Standard Inputs widths for the form elements
formInputWidth = 35
labelInputWidth = 35
# Make a frame to contain the input variables
# self.interior is defined in the ScrolledWindow class
self.submissionDetailsInputFrame = Frame(self.interior)
self.usernameInstrText = StringVar()
self.usernameInstrText.set('IPD Username:'******'IPD Password:'******'Cell/Sample ID:')
self.sampleIDinstrLabel = Label(self.submissionDetailsInputFrame, width=labelInputWidth, height=1, textvariable=self.sampleIDInstrText).grid(row=2, column=0)
self.inputSampleID = StringVar()
self.inputSampleIDEntry = Entry(self.submissionDetailsInputFrame, width=formInputWidth, textvariable=self.inputSampleID).grid(row=2, column=1)
self.geneInstrStringVar = StringVar()
self.geneInstrStringVar.set('Gene:')
self.geneInstrLabel = Label(self.submissionDetailsInputFrame, width=labelInputWidth, height=1, textvariable=self.geneInstrStringVar).grid(row=3, column=0)
self.inputGene = StringVar()
self.inputGeneEntry = Entry(self.submissionDetailsInputFrame, width=formInputWidth, textvariable=self.inputGene).grid(row=3, column=1)
self.chooseClassIntVar = IntVar()
self.chooseClassIntVar.set(1)
Radiobutton(self.submissionDetailsInputFrame, text="HLA Class I ", variable=self.chooseClassIntVar, value=1).grid(row=4, column=0)
Radiobutton(self.submissionDetailsInputFrame, text="HLA Class II", variable=self.chooseClassIntVar, value=2).grid(row=4, column=1)
self.alleleInstrText = StringVar()
self.alleleInstrText.set('Allele Local Name:')
self.alleleInstrLabel = Label(self.submissionDetailsInputFrame, width=labelInputWidth, height=1, textvariable=self.alleleInstrText).grid(row=5, column=0)
self.inputAllele = StringVar()
self.inputAlleleEntry = Entry(self.submissionDetailsInputFrame, width=formInputWidth, textvariable=self.inputAllele).grid(row=5, column=1)
# New form stuff
# Gotta add this to the load/save config nonsense below.
# TODO: Can I just load an ENA accession? I think that is possible. Easier than filling it in here
# TODO: When ENA Sequence Accession # Is provided, I can probably lookup an annotated sequence.
# Should I put a button next to this field
# Button: "Lookup This ENA Sequence Accession #"
# If it is found, then i already know the sequence with exon boundaries.
# TODO: Do I need to specify if it is ENA / Genbank / The other one? Probably not.
# I can require an ENA code and disregard Genbank.
# Radio Buttons?
# ENA / Genbank Accession #
# No, this tool is for ENA submission. But this is a question for James Robinson.
# Should i choose between which intermediate databse they use?
self.enaAccInstrText = StringVar()
self.enaAccInstrText.set('ENA Sequence Accession #:')
self.enaAccInstrLabel = Label(self.submissionDetailsInputFrame, width=labelInputWidth, height=1, textvariable=self.enaAccInstrText).grid(row=6, column=0)
self.inputEnaAcc = StringVar()
self.inputEnaAccEntry = Entry(self.submissionDetailsInputFrame, width=formInputWidth, textvariable=self.inputEnaAcc).grid(row=6, column=1)
# Release Date
self.releaseDateInstrText = StringVar()
self.releaseDateInstrText.set('IPD Release Date:')
self.releaseDateInstrLabel = Label(self.submissionDetailsInputFrame, width=labelInputWidth, height=1, textvariable=self.releaseDateInstrText).grid(row=7, column=0)
self.inputReleaseDate = StringVar()
self.inputReleaseDateEntry = Entry(self.submissionDetailsInputFrame, width=formInputWidth, textvariable=self.inputReleaseDate).grid(row=7, column=1)
# Reference Details
# Is this allele in a published paper or not?
# 0=unpublished, 1=published
self.publishedReferenceIntVar = IntVar()
self.publishedReferenceIntVar.set(0)
self.submissionDetailsInputFrame.pack()
self.unpublishedReferenceFrame = Frame(self.interior)
self.referenceInstrText = StringVar()
self.referenceInstrText.set('\nPlease provide some information about a\npublished paper relevant to this sequence.\n')
self.referenceInstrLabel = Label(self.unpublishedReferenceFrame, width=70, height=4, textvariable=self.referenceInstrText).pack()#.grid(row=2, column=0)
Radiobutton(self.unpublishedReferenceFrame, text="No Published Reference.", variable=self.publishedReferenceIntVar, value=0).pack()
self.unpublishedReferenceFrame.pack()
self.publishedReferenceFrame = Frame(self.interior)
# Radio Button: Published
Radiobutton(self.unpublishedReferenceFrame, text="Use This Reference:", variable=self.publishedReferenceIntVar, value=1).pack()
# Reference Title
self.referenceTitleInstrText = StringVar()
self.referenceTitleInstrText.set('Reference Title:')
self.referenceTitleInstrLabel = Label(self.publishedReferenceFrame, width=labelInputWidth, height=1, textvariable=self.referenceTitleInstrText).grid(row=1, column=0)
self.inputReferenceTitle = StringVar()
self.inputReferenceTitleEntry = Entry(self.publishedReferenceFrame, width=formInputWidth, textvariable=self.inputReferenceTitle).grid(row=1, column=1)
# Authors
self.referenceAuthorsInstrText = StringVar()
self.referenceAuthorsInstrText.set('Reference Authors:')
self.referenceAuthorsInstrLabel = Label(self.publishedReferenceFrame, width=labelInputWidth, height=1, textvariable=self.referenceAuthorsInstrText).grid(row=2, column=0)
self.inputReferenceAuthors = StringVar()
self.inputReferenceAuthorsEntry = Entry(self.publishedReferenceFrame, width=formInputWidth, textvariable=self.inputReferenceAuthors).grid(row=2, column=1)
# Journal
self.referenceJournalInstrText = StringVar()
self.referenceJournalInstrText.set('Reference Journal:')
self.referenceJournalInstrLabel = Label(self.publishedReferenceFrame, width=labelInputWidth, height=1, textvariable=self.referenceJournalInstrText).grid(row=3, column=0)
self.inputReferenceJournal = StringVar()
self.inputReferenceJournalEntry = Entry(self.publishedReferenceFrame, width=formInputWidth, textvariable=self.inputReferenceJournal).grid(row=3, column=1)
self.publishedReferenceFrame.pack()
# Make a frame to contain the input variables.
# I had to make 2 of them to organize my gui, maybe I can name this better.
self.submissionDetailsInputFrame2 = Frame(self.interior)
# /alignment -> defined by IPD sequence alignment service
# In this case, it is the closest known allele.
self.closestAlleleInstrText = StringVar()
self.closestAlleleInstrText.set('Closest Known HLA Allele:')
self.closestAlleleInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.closestAlleleInstrText).grid(row=1, column=0)
self.inputClosestAllele = StringVar()
self.inputClosestAlleleEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputClosestAllele).grid(row=1, column=1)
# Written Description
# Looks like this is a description of how the sequence differes from closest knnown allele
self.closestAlleleWrittenDescriptionInstrText = StringVar()
self.closestAlleleWrittenDescriptionInstrText.set('Differences from Closest Allele:')
self.closestAlleleWrittenDescriptionInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.closestAlleleWrittenDescriptionInstrText).grid(row=2, column=0)
self.inputClosestAlleleWrittenDescription = StringVar()
self.inputClosestAlleleWrittenDescriptionEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputClosestAlleleWrittenDescription).grid(row=2, column=1)
# DONOR INFORMATION
# Cell ID (cellnum)
# Wait, is this the same as the sample ID? Should I move the sample ID field down here?
# No. I am disregarding this sample ID.
# Ethnic Origin - Text
self.ethnicOriginInstrText = StringVar()
self.ethnicOriginInstrText.set('Ethnic Origin:')
self.ethnicOriginInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.ethnicOriginInstrText).grid(row=3, column=0)
self.inputEthnicOrigin = StringVar()
self.inputEthnicOriginEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputEthnicOrigin).grid(row=3, column=1)
# Sex - Text
self.sexInstrText = StringVar()
self.sexInstrText.set('Sex:')
self.sexInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.sexInstrText).grid(row=4, column=0)
self.inputSex = StringVar()
self.inputSexEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputSex).grid(row=4, column=1)
# TODO Make a boolean
# Consanguineous (T/F)
self.consanguineousInstrText = StringVar()
self.consanguineousInstrText.set('Sample is Consanguineous:')
self.consanguineousInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.consanguineousInstrText).grid(row=5, column=0)
self.inputConsanguineous = StringVar()
self.inputConsanguineousEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputConsanguineous).grid(row=5, column=1)
# TODO Make a boolean
# Homozygous (T/F)
# TODO: Accepted values are 'Yes', 'No', 'Unknown'
# Make dropdown for this, or radio buttons.
self.homozygousInstrText = StringVar()
self.homozygousInstrText.set('Sample is Homozygous:')
self.homozygousInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.homozygousInstrText).grid(row=6, column=0)
self.inputHomozygous = StringVar()
self.inputHomozygousEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputHomozygous).grid(row=6, column=1)
# Lab of Origin (text)
self.labOriginInstrText = StringVar()
self.labOriginInstrText.set('Lab of Origin:')
self.labOriginInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.labOriginInstrText).grid(row=7, column=0)
self.inputLabOrigin = StringVar()
self.inputLabOriginEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputLabOrigin).grid(row=7, column=1)
# Lab Contact
self.labContactInstrText = StringVar()
self.labContactInstrText.set('Lab Contact:')
self.labContactInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.labContactInstrText).grid(row=8, column=0)
self.inputLabContact = StringVar()
self.inputLabContactEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputLabContact).grid(row=8, column=1)
# Cell Availability
# Material Available (T/F)
self.materialAvailableInstrText = StringVar()
self.materialAvailableInstrText.set('Material Availability:')
self.materialAvailableInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.materialAvailableInstrText).grid(row=9, column=0)
self.inputMaterialAvailable = StringVar()
self.inputMaterialAvailableEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputMaterialAvailable).grid(row=9, column=1)
# Cell Bank (Text)
self.cellBankInstrText = StringVar()
self.cellBankInstrText.set('Cell Bank:')
self.cellBankInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.cellBankInstrText).grid(row=10, column=0)
self.inputCellBank = StringVar()
self.inputCellBankEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputCellBank).grid(row=10, column=1)
# Cell Workshop Details
# I think Cell Workshop Details is just a header. there isn't new information here, just a header.
# TODO: Compare this with the IPD Submission website, im not missing something?
self.submissionDetailsInputFrame2.pack()
# numbering these input frames are not informative. Oh well. This frame has HLA Allele calls on it.
self.submissionDetailsInputFrame3 = Frame(self.interior)
# Alternative HLA DNA Typing
# Dropdown Box with another Entry Field?
# I need:
# Label
self.sourceHLAInstrText = StringVar()
self.sourceHLAInstrText.set('Source HLA Types (Sequenced):')
self.sourceHLAInstrLabel = Label(self.submissionDetailsInputFrame3, width=labelInputWidth, height=1, textvariable=self.sourceHLAInstrText).grid(row=1, column=0)
# Combo Box, with source_hla dictionary keys. Sorted.
# Text input, with the gene specified.
# "Clear" button. clear out all allele calls.
# Configuration should be assigned whenever text changes.
# I Think i need a new panel for this. Yeah.
# Source Serology Typing
# Maybe the same as DNA typing?
# Ignore for now.
# Sequencing Methods
# Primers
# This is probably a Dropdown with Entry field also.
# TODO: Comments. Where does this stuff go? This is details about the lab of origin. I haven't tried specifying this one yet, ask James how to do it.
# Comments
self.submissionDetailsInputFrame3.pack()
# Make a frame for the save options button.
self.saveOptionsFrame = Frame(self.interior)
Button(self.saveOptionsFrame, text='Save Options', command=self.saveOptions).grid(row=0, column=0)
self.saveOptionsFrame.pack()
self.loadOptions()
# I needed a function for the return keypress to latch onto.
# It is just a wrapper for the saveOptions method.
def returnFunction(self, event):
self.saveOptions()
# submissionOptions is a dictionary, passed by the parent.
def loadOptions(self):
if getConfigurationValue('ipd_username') is not None:
self.inputUsername.set(getConfigurationValue('ipd_username'))
if getConfigurationValue('ipd_password') is not None:
self.inputPassword.set(getConfigurationValue('ipd_password'))
if getConfigurationValue('sample_id') is not None:
self.inputSampleID.set(getConfigurationValue('sample_id'))
if getConfigurationValue('gene') is not None:
self.inputGene.set(getConfigurationValue('gene'))
if getConfigurationValue('class') is not None:
if (str(getConfigurationValue('class')) == '1'):
self.chooseClassIntVar.set(1)
elif (str(getConfigurationValue('class')) == '2'):
self.chooseClassIntVar.set(2)
else:
raise Exception('Error loading IPD submission options. Invalid class:' + str(getConfigurationValue('class')))
if getConfigurationValue('allele_name') is not None:
self.inputAllele.set(getConfigurationValue('allele_name'))
if getConfigurationValue('ena_sequence_accession') is not None:
self.inputEnaAcc.set(getConfigurationValue('ena_sequence_accession'))
if getConfigurationValue('ena_release_date') is not None:
self.inputReleaseDate.set(getConfigurationValue('ena_release_date'))
# 0=unpublished, 1=published
#print('1Setting is_published value to:' + getConfigurationValue('is_published'))
if (getConfigurationValue('is_published') is None or getConfigurationValue('is_published') == 'None'):
self.publishedReferenceIntVar.set(0)
#print('2Setting is_published value to:' + getConfigurationValue('is_published'))
else:
self.publishedReferenceIntVar.set(getConfigurationValue('is_published'))
if getConfigurationValue('reference_title') is not None:
self.inputReferenceTitle.set(getConfigurationValue('reference_title'))
if getConfigurationValue('reference_authors') is not None:
self.inputReferenceAuthors.set(getConfigurationValue('reference_authors'))
if getConfigurationValue('reference_journal') is not None:
self.inputReferenceJournal.set(getConfigurationValue('reference_journal'))
if getConfigurationValue('reference_journal') is not None:
self.inputReferenceJournal.set(getConfigurationValue('reference_journal'))
if getConfigurationValue('closest_known_allele') is not None:
self.inputClosestAllele.set(getConfigurationValue('closest_known_allele'))
if getConfigurationValue('closest_allele_written_description') is not None:
self.inputClosestAlleleWrittenDescription.set(getConfigurationValue('closest_allele_written_description'))
if getConfigurationValue('ethnic_origin') is not None:
self.inputEthnicOrigin.set(getConfigurationValue('ethnic_origin'))
if getConfigurationValue('sex') is not None:
self.inputSex.set(getConfigurationValue('sex'))
if getConfigurationValue('consanguineous') is not None:
self.inputConsanguineous.set(getConfigurationValue('consanguineous'))
if getConfigurationValue('homozygous') is not None:
self.inputHomozygous.set(getConfigurationValue('homozygous'))
if getConfigurationValue('lab_of_origin') is not None:
self.inputLabOrigin.set(getConfigurationValue('lab_of_origin'))
if getConfigurationValue('lab_contact') is not None:
self.inputLabContact.set(getConfigurationValue('lab_contact'))
if getConfigurationValue('material_availability') is not None:
self.inputMaterialAvailable.set(getConfigurationValue('material_availability'))
if getConfigurationValue('cell_bank') is not None:
self.inputCellBank.set(getConfigurationValue('cell_bank'))
# TODO:
# Load options for HLA allele calls.
# Clear the combo-box, and fill it with the keys of my hla allele call dictionary.
def saveOptions(self):
# Close the window
# TODO: If i force the user to fill in all the options, this form is really obnoxious.
# Instead they should be allowed to close it and I will still warn them.
# I can re-think this plan if people are trying to submit bad data.
#if (self.checkOptions()):
#Don't force user to fill in all the options:
self.checkOptions()
if(True):
logging.info ('Saving Options....')
assignConfigurationValue('ipd_username', self.inputUsername.get())
# I store this password so I can use it in the submission
# I don't ever want to save the password. Make sure it isn't being saved in the config, in AlleleSubCommon.py
assignConfigurationValue('ipd_password', self.inputPassword.get())
assignConfigurationValue('sample_id', self.inputSampleID.get())
assignConfigurationValue('gene', self.inputGene.get())
assignConfigurationValue('class', str(self.chooseClassIntVar.get()))
assignConfigurationValue('allele_name', self.inputAllele.get())
assignConfigurationValue('ena_sequence_accession', self.inputEnaAcc.get())
assignConfigurationValue('ena_release_date', self.inputReleaseDate.get())
assignConfigurationValue('is_published', str(self.publishedReferenceIntVar.get()))
#print('Saving is_published configuration as :' + str(self.publishedReferenceIntVar.get()))
assignConfigurationValue('reference_title',self.inputReferenceTitle.get())
assignConfigurationValue('reference_authors',self.inputReferenceAuthors.get())
assignConfigurationValue('reference_journal',self.inputReferenceJournal.get())
assignConfigurationValue('closest_known_allele', self.inputClosestAllele.get())
assignConfigurationValue('closest_allele_written_description', self.inputClosestAlleleWrittenDescription.get())
assignConfigurationValue('ethnic_origin', self.inputEthnicOrigin.get())
assignConfigurationValue('sex', self.inputSex.get())
# TODO: Accepted values are 'Yes', 'No', 'Unknown'
# Make dropdown for these
assignConfigurationValue('consanguineous', self.inputConsanguineous.get())
assignConfigurationValue('homozygous', self.inputHomozygous.get())
assignConfigurationValue('lab_of_origin', self.inputLabOrigin.get())
assignConfigurationValue('lab_contact', self.inputLabContact.get())
assignConfigurationValue('material_availability', self.inputMaterialAvailable.get())
assignConfigurationValue('cell_bank', self.inputCellBank.get())
# I have saved hla calls in a dictionary. They should have been saved individually.
self.parent.destroy()
else:
#logging.info('Not ready to save, you are missing options.')
pass
def checkOptions(self):
# TODO this method
logging.info ('Checking options.')
# Don't check the IPD Username
# Don't check the IPD Password
if (not self.inputSampleID.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Sample ID. Please try again.')
return False
if (not self.inputGene.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Gene. Please try again.')
return False
if (not self.inputAllele.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an Allele Name. Please try again.')
return False
if (not self.inputEnaAcc.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an ENA Accession Number. Please try again.')
return False
if (not self.inputReleaseDate.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an IPD Submission Release Date. Please try again.')
return False
# This is NOne if nothing is selected.
if (self.publishedReferenceIntVar.get() == 0):
# unpublished, nothing to check
pass
else:
if ((not self.inputReferenceTitle.get())
or (not self.inputReferenceAuthors.get())
or (not self.inputReferenceJournal.get())
):
messagebox.showwarning('Missing Form Value',
'You are must supply information about the published Reference. Please try again.')
return False
if (not self.inputClosestAllele.get()):
messagebox.showwarning('Missing Form Value',
'You are missing the closest known reference allele to this sequence. Please provide this information.')
return False
if (not self.inputEthnicOrigin.get()):
messagebox.showwarning('Missing Form Value',
'Please provide a description of an ethnic origin for this sample.')
return False
if (not self.inputSex.get()):
messagebox.showwarning('Missing Form Value',
'Please identify the sex for this sample.')
return False
# TODO: Accepted values are 'Yes', 'No', 'Unknown' I think
if (not self.inputConsanguineous.get()):
messagebox.showwarning('Missing Form Value',
'Please indicate if the sample is consanguineous or not.')
return False
if (not self.inputHomozygous.get()):
messagebox.showwarning('Missing Form Value',
'Please indicate if the sample is homozygous or not.')
return False
if (not self.inputLabOrigin.get()):
messagebox.showwarning('Missing Form Value',
'Please provide the name of the submitting laboratory.')
return False
if (not self.inputLabContact.get()):
messagebox.showwarning('Missing Form Value',
'Please provide the name of the laboratory contact.')
return False
if (not self.inputMaterialAvailable.get()):
messagebox.showwarning('Missing Form Value',
'Please indicate if the cell material is available.')
return False
if (not self.inputCellBank.get()):
messagebox.showwarning('Missing Form Value',
'Please provide the name of the cell bank where the sample can be found.')
return False
# TODO Validate the HLA ALlele calls. I won't do IMGT/HLA validation, I will leave that validation up to IMGT/HLA
# Validate A, B, DRB1. The rest, I don't care.
# All options look good, right?
return True
def closeWindow(self):
#writeConfigurationFile()
self.parent.destroy()
class SaleTerminal:
def __init__(self, master):
self.master = master
master.title("Point of Sale")
# Initializing the counter so that the user can see their sum for their items purchased
self.total = 0
self.entered_number = 0
# Creating the box and total area for an active sum update
self.total_label_text = IntVar()
self.total_label_text.set(self.total)
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Total:")
# Testing the method of inputting how much your item should cost, but will take this out if not working by PRoject Demo
vcmd = master.register(self.validate)
self.entry = Entry(master, validate="key", validatecommand=(vcmd, '%P'))
# Here I create the vast majority of the buttons, I set them to look for their respective functions "Bx" and
# execute when the left click on the mouse is performed on the specific button
self.B1 = Button(master, text="Coca-Cola", command=lambda: self.update("B1"))
self.B2 = Button(master, text="Lays", command=lambda: self.update("B2"))
self.B3 = Button(master, text="MJ Thriller", command=lambda: self.update("B3"))
self.B4 = Button(master, text="Time Mag", command=lambda: self.update("B4"))
self.B5 = Button(master, text="USB", command=lambda: self.update("B5"))
self.B6 = Button(master, text="Star Wars", command=lambda: self.update("B6"))
self.B7 = Button(master, text="Total", command=lambda: self.update("B7"))
self.B8 = Button(master, text="Print", command=lambda: self.update("B8"))
self.subtract_button = Button(master, text="Save $10", command=lambda: self.update("subtract10"))
self.reset_button = Button(master, text="Reset", command=lambda: self.update("reset"))
# Here I set the layout for the buttons, I can specify where on the main window I would like everything.
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=2, sticky=E)
self.entry.grid(row=1, column=0, columnspan=3, sticky=W+E)
self.B1.grid(row=2, column=0)
self.B2.grid(row=2, column=1)
self.B3.grid(row=3, column=0)
self.B4.grid(row=3, column=1)
self.B5.grid(row=3, column=2)
self.B6.grid(row=2, column=2)
self.B7.grid(row=1, column=3)
self.B8.grid(row=3, column=4)
self.subtract_button.grid(row=3, column=3)
self.reset_button.grid(row=2, column=3, sticky=W+E)
# For the input of value for specific items in the box provided
def validate(self, new_text):
if not new_text: # the field is being cleared
self.entered_number = 0
return True
# These functions help define what a button does when pressed
def update(self, method):
# Create or Append a text file wit hthe given name
f = open("Receipt.txt", "a")
# If B1 is pressed, then add the price of B1 to the total and print this string to the text file
#This process is duplicated for each button given their unique message and price
if method == "B1":
#self.total += self.entered_number
self.total += 2.76
print("Coca-Cola (12 Pack) $2.76", file=f)
elif method == "B2":
self.total += 2.99
print("Lays Classic $2.99", file=f)
elif method == "B3":
self.total += 7.00
print("Michael J.- Thriller $7.00 ", file=f)
elif method == "B4":
self.total += 3.50
print("Time Magazine $3.50", file=f)
elif method == "B5":
self.total += 19.99
print("USB 3.0 Cruzer $19.99", file=f)
elif method == "B6":
self.total += 9.98
print("Star Wars: V $9.98", file=f)
elif method == "subtract10":
self.total -= 10
SubTot = self.total
print("Discount -$10.00",file=f)
elif method == "B7":
roundedTotal = round(self.total, 2)
print("\n------------------------------------ \n Your total today is: $", roundedTotal, file=f)
print("\n\n Payment: Android Pay \n Technology: Bluetooth and NFC \n APPROVED", file=f)
print("\n \n \n Thank you very much.\n" " Please come back again.", file=f)
call(["./rpi", "args", "to", "rpi"])
# Here we call a program called "Hello World" to execute. This program is the GCC make of the C file
# essentialy, the IDE will create this build when you compile
elif method == "B8":
call(["sudo", "./helloworld", "args", "to", "helloworld"])
elif method == "reset":
# Here I reset the counter
self.total = 0
print(" KWIK-E Mart \n ******************** \n * 123 Evergreen Tr. * \n * S4S 0A2 *\n * (306) 591-0909 *\n ******************** \n Welcome to KWIK-E Mart\n \n \n \n------------------------------------ \n ", file=open("Receipt.txt", "w"))
else: # reset
self.total = 0
roundedTot = round(self.total,2)
self.total_label_text.set(roundedTot)
self.entry.delete(0, END)
def createwindow():
global componentlist
global intrinsiclist
global intrinsicvaluelist
global extrinsiclist
global extrinsicvaluelist
global affordanceformulalist
clearall_button = Button(framer.Objframe, text="clear", command = lambda: clearlists(componentlist, intrinsiclist, intrinsicvaluelist,
extrinsiclist, extrinsicvaluelist, affordanceformulalist))
clearall_button.config(image = framer.cancelbtnpic, borderwidth = 0, bg = "#fa7878", activebackground= "#fa7878", compound = CENTER, foreground = "white", activeforeground = "#fa7878", font=(None, 13))
clearall_button.place ( x = 560, y = 590 )
tooltip.CreateToolTip(clearall_button, text = 'Tooltip:\n\n'
'Klick this button to discard your modifications\n'
'and clear all checkboxes, option menus and text fields')
exec_button = Button(framer.Objframe, text="save", command = lambda: getvals(pred_entry, optionVar, optionVarHead, headgroup_entry,
optionVarConc, concavitygroup_entry, rotvalx, rotvaly,
rotvalz, reflvalxy, reflvalxz, reflvalyz, optionVarScale,
optionVarMovable))
exec_button.config(image = framer.smallbtnpic, borderwidth = 0, bg = "#a3ff8f", activebackground= "#a3ff8f", compound = CENTER, foreground = "white", activeforeground = "#a3ff8f", font=(None, 13))
exec_button.place ( x = 560, y = 636 )
tooltip.CreateToolTip(exec_button, text = 'Tooltip:\n\n'
'Klick this button to save your modifications\n'
'to a VoxML conform XML document')
debug_textfield = tk.Text(framer.Objframe, height=4, width=48)
debug_textfield.configure(relief = RIDGE, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
debug_textfield.place ( x = 100, y = 590 )
group_label = Label(framer.Objframe, text = "Group:", foreground = "white", background = "#404040", font=(None, 14))
group_label.place (x = 360, y = 50)
tooltip.CreateToolTip(group_label, text = 'Tooltip:\n\n'
'Use Integers to refer to groups of parts,\n'
'habitats or affordance formulas')
args_label = Label(framer.Objframe, text = "Arguments:", foreground = "white", background = "#404040", font=(None, 14))
args_label.place (x = 440, y = 50)
tooltip.CreateToolTip(args_label, text = 'Tooltip:\n\n'
'Insert functions arguments in entry fields\n'
'below')
lex_label = Label(framer.Objframe, text = "<Lex>", foreground = "white", background = "#404040", font=(None, 14))
lex_label.place (x = 50, y = 50)
pred_label = Label(framer.Objframe, text = "Predicate:", foreground = "white", background = "#404040", font=(None, 12))
pred_label.place (x = 100, y = 80)
pred_entry = Entry(framer.Objframe)
pred_entry.configure(relief = RIDGE, width = 17, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
pred_entry.place (x = 190, y = 80)
typesub_label = Label(framer.Objframe, text = "Type:", foreground = "white", background = "#404040", font=(None, 12))
typesub_label.place (x = 100, y = 110)
optionVar = StringVar()
optionVar.set("physobj")
option = OptionMenu(framer.Objframe, optionVar, "physobj", "physobj", "physobj*artifact")
option.place(x = 190, y = 110)
option.config( width = 145, height = 14, image = framer.menutickpic, anchor = "w", bd = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
type_label = Label(framer.Objframe, text = "<Type>", foreground = "white", background = "#404040", font=(None, 14))
type_label.place (x = 50, y = 140)
head_label = Label(framer.Objframe, text = "Head:", foreground = "white", background = "#404040", font=(None, 12))
head_label.place (x = 100, y = 170)
headgroup_entry = Entry(framer.Objframe, width = 4)
headgroup_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
headgroup_entry.place (x = 370, y = 170)
tooltip.CreateToolTip(headgroup_entry, text = 'Tooltip:\n\n'
'*OPTIONAL*')
optionVarHead = StringVar()
optionVarHead.set("ellipsoid")
optionmenuhead = OptionMenu(framer.Objframe, optionVarHead, "ellipsoid", "ellipsoid", "bipyramid", "cylindroid", "cupola", "frustum",
"hemiellipsoid", "parallelepiped", "prismatoid", "pyramid", "rectangular_prism", "sheet",
"toroid", "wedge")
optionmenuhead.place(x = 190, y = 170)
optionmenuhead.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 11))
component_label = Label(framer.Objframe, text = "Component:", foreground = "white", background = "#404040", font=(None, 12))
component_label.place (x = 100, y = 200)
component_entry = Entry(framer.Objframe)
component_entry.configure(relief = RIDGE, width = 17, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
component_entry.place (x = 190, y = 200)
componentgroup_entry = Entry(framer.Objframe, width = 4)
componentgroup_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
componentgroup_entry.place (x = 370, y = 200)
tooltip.CreateToolTip(componentgroup_entry, text = 'Tooltip:\n\n'
'*OPTIONAL*')
duplicatevar = IntVar()
duplicatevar.set(0)
dupecheckbutton = Checkbutton(framer.Objframe, text="", variable=duplicatevar)
dupecheckbutton.var = duplicatevar
dupecheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", font=(None, 12))
dupecheckbutton.place ( x = 470, y = 200 )
tooltip.CreateToolTip(dupecheckbutton, text = 'Tooltip:\n\n'
'Check this box if the Object has multiple instances\n'
'or copies of that same part\n\n *OPTIONAL*')
add_component_button = Button(framer.Objframe, text="add", command = lambda: addcomponent(component_entry, componentgroup_entry, duplicatevar,
debug_textfield, componentlist_textfield,optionVarComponentlist, OptionMenuComponentlist))
add_component_button.config(image = framer.smallbtnpic, borderwidth = 0, bg = "#a3ff8f", activebackground= "#a3ff8f", compound = CENTER, foreground = "white", activeforeground = "#a3ff8f", font=(None, 13))
add_component_button.place ( x = 560, y = 198 )
tooltip.CreateToolTip(add_component_button, text = 'Tooltip:\n\n'
'Klick this button to add a component\n'
'to the componentlist of the current object')
concavity_label = Label(framer.Objframe, text = "Concavity:", foreground = "white", background = "#404040", font=(None, 12))
concavity_label.place (x = 100, y = 230)
optionVarConc = StringVar()
optionVarConc.set("Flat")
optionmenuconc = OptionMenu(framer.Objframe, optionVarConc, "Flat", "Flat", "Concave", "Convex")
optionmenuconc.place(x = 190, y = 230)
optionmenuconc.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
concavitygroup_entry = Entry(framer.Objframe, width = 4)
concavitygroup_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
concavitygroup_entry.place (x = 370, y = 230)
tooltip.CreateToolTip(concavitygroup_entry, text = 'Tooltip:\n\n'
'*OPTIONAL*')
rotatsym_label = Label(framer.Objframe, text = "Rotatsym:", foreground = "white", background = "#404040", font=(None, 12))
rotatsym_label.place (x = 100, y = 260)
rotvalx = IntVar()
rotvalx.set(0)
rotvaly = IntVar()
rotvaly.set(0)
rotvalz = IntVar()
rotvalz.set(0)
rotxcheckbutton = Checkbutton(framer.Objframe, text="X", variable=rotvalx)
rotxcheckbutton.var = rotvalx
rotxcheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", activeforeground = "#404040", font=(None, 12))
rotxcheckbutton.place ( x = 190, y = 260 )
rotxcheckbuttonlabel = Label(framer.Objframe, text="X")
rotxcheckbuttonlabel.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "white", font=(None, 12))
rotxcheckbuttonlabel.place ( x = 210, y = 262 )
rotycheckbutton = Checkbutton(framer.Objframe, text="Y", variable=rotvaly)
rotycheckbutton.var = rotvaly
rotycheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", activeforeground = "#404040", font=(None, 12))
rotycheckbutton.place ( x = 230, y = 260 )
rotycheckbuttonlabel = Label(framer.Objframe, text="Y")
rotycheckbuttonlabel.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "white", font=(None, 12))
rotycheckbuttonlabel.place ( x = 250, y = 262 )
rotzcheckbutton = Checkbutton(framer.Objframe, text="Z", variable=rotvalz)
rotzcheckbutton.var = rotvalz
rotzcheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", activeforeground = "#404040", font=(None, 12))
rotzcheckbutton.place ( x = 270, y = 260 )
rotzcheckbuttonlabel = Label(framer.Objframe, text="Z")
rotzcheckbuttonlabel.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "white", font=(None, 12))
rotzcheckbuttonlabel.place ( x = 290, y = 262 )
reflsym_label = Label(framer.Objframe, text = "Reflsym:", foreground = "white", background = "#404040", font=(None, 12))
reflsym_label.place (x = 100, y = 290)
reflvalxy = IntVar()
reflvalxy.set(0)
reflvalxz = IntVar()
reflvalxz.set(0)
reflvalyz = IntVar()
reflvalyz.set(0)
reflxycheckbutton = Checkbutton(framer.Objframe, text="XY", variable=reflvalxy)
reflxycheckbutton.var = reflvalxy
reflxycheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", activeforeground = "#404040", font=(None, 12))
reflxycheckbutton.place ( x = 190, y = 290 )
reflxycheckbuttonlabel = Label(framer.Objframe, text="XY")
reflxycheckbuttonlabel.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "white", font=(None, 12))
reflxycheckbuttonlabel.place ( x = 210, y = 292 )
reflxzcheckbutton = Checkbutton(framer.Objframe, text="XZ", variable=reflvalxz)
reflxzcheckbutton.var = reflvalxz
reflxzcheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", activeforeground = "#404040", font=(None, 12))
reflxzcheckbutton.place ( x = 240, y = 290 )
reflxzcheckbuttonlabel = Label(framer.Objframe, text="XZ")
reflxzcheckbuttonlabel.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "white", font=(None, 12))
reflxzcheckbuttonlabel.place ( x = 260, y = 292 )
reflyzcheckbutton = Checkbutton(framer.Objframe, text="YZ", variable=reflvalyz)
reflyzcheckbutton.var = reflvalyz
reflyzcheckbutton.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "#404040", activeforeground = "#404040", font=(None, 12))
reflyzcheckbutton.place ( x = 290, y = 290 )
reflyzcheckbuttonlabel = Label(framer.Objframe, text="YZ")
reflyzcheckbuttonlabel.config(borderwidth = 0, background = "#404040", activebackground= "#404040", foreground = "white", font=(None, 12))
reflyzcheckbuttonlabel.place ( x = 310, y = 292 )
habitat_label = Label(framer.Objframe, text = "<Habitat>", foreground = "white", background = "#404040", font=(None, 14))
habitat_label.place (x = 50, y = 320)
intrinsic_label = Label(framer.Objframe, text = "Intrinsic:", foreground = "white", background = "#404040", font=(None, 12))
intrinsic_label.place (x = 100, y = 350)
optionVarIntr = StringVar()
optionVarIntr.set("UP")
optionmenuint = OptionMenu(framer.Objframe, optionVarIntr, "UP", "UP", "TOP", "NEAR", "FRONT")
optionmenuint.place(x = 190, y = 350)
optionmenuint.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
intrinsicgroup_entry = Entry(framer.Objframe, width = 4)
intrinsicgroup_entry.place (x = 370, y = 350)
intrinsicgroup_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
tooltip.CreateToolTip(intrinsicgroup_entry, text = 'Tooltip:\n\n'
'*OPTIONAL*')
intrinsicarg1_entry = Entry(framer.Objframe, width = 4)
intrinsicarg1_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
intrinsicarg1_entry.place (x = 440, y = 350)
intrinsicarg2_entry = Entry(framer.Objframe, width = 4)
intrinsicarg2_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
intrinsicarg2_entry.place (x = 485, y = 350)
add_intrinsic_button = Button(framer.Objframe, text="add", command = lambda: addhabitat(optionVarIntr, intrinsicgroup_entry, intrinsicarg1_entry,
intrinsicarg2_entry, intrinsiclist, intrinsicvaluelist,
"intr", debug_textfield, optionVarIntrinsiclist, OptionMenuIntrinsiclist, componentlist_textfield))
add_intrinsic_button.config(image = framer.smallbtnpic, borderwidth = 0, bg = "#a3ff8f", activebackground= "#a3ff8f", compound = CENTER, foreground = "white", activeforeground = "#a3ff8f", font=(None, 13))
add_intrinsic_button.place ( x = 560, y = 348 )
tooltip.CreateToolTip(add_intrinsic_button, text = 'Tooltip:\n\n'
'Klick this button to add an intrinsic habitat\n'
'to the list of intrinsic habitats of the current object')
extrinsic_label = Label(framer.Objframe, text = "Extrinsic:", foreground = "white", background = "#404040", font=(None, 12))
extrinsic_label.place (x = 100, y = 380)
optionVarExtr = StringVar()
optionVarExtr.set("UP")
optionmenuext = OptionMenu(framer.Objframe, optionVarExtr, "UP", "UP", "TOP", "NEAR", "FRONT")
optionmenuext.place(x = 190, y = 380)
optionmenuext.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
extrinsicgroup_entry = Entry(framer.Objframe, width = 4)
extrinsicgroup_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
extrinsicgroup_entry.place (x = 370, y = 380)
tooltip.CreateToolTip(extrinsicgroup_entry, text = 'Tooltip:\n\n'
'*OPTIONAL*')
extrinsicarg1_entry = Entry(framer.Objframe, width = 4)
extrinsicarg1_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
extrinsicarg1_entry.place (x = 440, y = 380)
extrinsicarg2_entry = Entry(framer.Objframe, width = 4)
extrinsicarg2_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
extrinsicarg2_entry.place (x = 485, y = 380)
add_extrinsic_button = Button(framer.Objframe, text="add", command = lambda: addhabitat(optionVarExtr, extrinsicgroup_entry, extrinsicarg1_entry,
extrinsicarg2_entry, extrinsiclist, extrinsicvaluelist,
"extr", debug_textfield, optionVarExtrinsiclist, OptionMenuExtrinsiclist, componentlist_textfield))
add_extrinsic_button.config(image = framer.smallbtnpic, borderwidth = 0, bg = "#a3ff8f", activebackground= "#a3ff8f", compound = CENTER, foreground = "white", activeforeground = "#a3ff8f", font=(None, 13))
add_extrinsic_button.place ( x = 560, y = 378 )
tooltip.CreateToolTip(add_extrinsic_button, text = 'Tooltip:\n\n'
'Klick this button to add an extrinsic habitat\n'
'to the list of extrinsic habitats of the current object')
affordance_label = Label(framer.Objframe, text = "<Affordances>", foreground = "white", background = "#404040", font=(None, 14))
affordance_label.place (x = 50, y = 410)
affordanceformula_label = Label(framer.Objframe, text = "Formula:", foreground = "white", background = "#404040", font=(None, 12))
affordanceformula_label.place (x = 100, y = 440)
optionVarAfford = StringVar()
optionVarAfford.set("grasp")
optionmenuafford = OptionMenu(framer.Objframe, optionVarAfford, "grasp", "grasp", "lift", "roll", "slide", "put_on", "put_in")
optionmenuafford.place(x = 190, y = 440)
optionmenuafford.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
affordanceformulagroup_entry = Entry(framer.Objframe, width = 4)
affordanceformulagroup_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
affordanceformulagroup_entry.place (x = 370, y = 440)
affordarg1_entry = Entry(framer.Objframe, width = 4)
affordarg1_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
affordarg1_entry.place (x = 440, y = 440)
affordarg2_entry = Entry(framer.Objframe, width = 4)
affordarg2_entry.configure(relief = RIDGE, width = 3, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
affordarg2_entry.place (x = 485, y = 440)
add_affordanceformula_button = Button(framer.Objframe, text="add", command = lambda: addformula(optionVarAfford, affordanceformulagroup_entry,
affordarg1_entry, affordarg2_entry, debug_textfield,
optionVarAffordancelist, OptionMenuAffordancelist, componentlist_textfield))
add_affordanceformula_button.config(image = framer.smallbtnpic, borderwidth = 0, bg = "#a3ff8f", activebackground= "#a3ff8f", compound = CENTER, foreground = "white", activeforeground = "#a3ff8f", font=(None, 13))
add_affordanceformula_button.place ( x = 560, y = 438 )
tooltip.CreateToolTip(add_affordanceformula_button, text = 'Tooltip:\n\n'
'Klick this button to add an affordance formula\n'
'to the list of affordance formulas of the current object')
embodiement_label = Label(framer.Objframe, text="<Embodiement>", foreground = "white", background = "#404040", font=(None, 14))
embodiement_label.place (x = 50, y = 470)
scale_label = Label(framer.Objframe, text = "Scale:", foreground = "white", background = "#404040", font=(None, 12))
scale_label.place (x = 100, y = 500)
optionVarScale = StringVar()
optionVarScale.set("agent")
OptionMenuScale = OptionMenu(framer.Objframe, optionVarScale, "< agent", "< agent", "agent", "> agent")
OptionMenuScale.place(x = 190, y = 500)
OptionMenuScale.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
movable_label = Label(framer.Objframe, text = "Movable:", foreground = "white", background = "#404040", font=(None, 12))
movable_label.place (x = 100, y = 530)
optionVarMovable = StringVar()
optionVarMovable.set("True")
OptionMenuMovable = OptionMenu(framer.Objframe, optionVarMovable, "True", "True", "False")
OptionMenuMovable.place(x = 190, y = 530)
OptionMenuMovable.config(width=145, height = 14, image = framer.menutickpic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#a3ff8f", font=(None, 12))
componentlist_label = Label(framer.Objframe, text = "File Preview:", foreground = "white", background = "#404040", font=(None, 14))
componentlist_label.place (x = 670, y = 50)
componentlist_textfield = tk.Text(framer.Objframe, height=10, width=40)
componentlist_textfield.configure(relief = RIDGE, bd = 2, foreground = "white", insertbackground = "white", background = "#505050", font=(None, 12))
componentlist_textfield.place ( x = 670, y = 80 )
optionVarComponentlist = StringVar()
optionVarComponentlist.set("Select Component")
OptionMenuComponentlist = OptionMenu(framer.Objframe, optionVarComponentlist, "Select Component")
OptionMenuComponentlist.place(x = 670, y = 300)
OptionMenuComponentlist.config(width=250, height = 16, image = framer.cancelmenupic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#fa7878", font=(None, 12))
OptionMenuComponentlist['menu'].entryconfig(1, background = "#404040" ,activebackground = "#404040", foreground = "white", activeforeground = "#fa7878")
removecompo_button = Button(framer.Objframe, text="remove", command = lambda: removefromlist(componentlist, componentlist_textfield, OptionMenuComponentlist, optionVarComponentlist, debug_textfield))
removecompo_button.config(image = framer.cancelbtnpic, borderwidth = 0, bg = "#fa7878", activebackground= "#fa7878", compound = CENTER, foreground = "white", activeforeground = "#fa7878", font=(None, 13))
removecompo_button.place ( x = 960, y = 300 )
optionVarIntrinsiclist = StringVar()
optionVarIntrinsiclist.set("Select Intrinsic Habitat")
OptionMenuIntrinsiclist = OptionMenu(framer.Objframe, optionVarIntrinsiclist, "Select Intrinsic Habitat")
OptionMenuIntrinsiclist.place(x = 670, y = 348)
OptionMenuIntrinsiclist.config(width=250, height = 16, image = framer.cancelmenupic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#fa7878", font=(None, 12))
removeintr_button = Button(framer.Objframe, text="remove", command = lambda: removefromlist(intrinsiclist, componentlist_textfield, OptionMenuIntrinsiclist, optionVarIntrinsiclist, debug_textfield))
removeintr_button.config(image = framer.cancelbtnpic, borderwidth = 0, bg = "#fa7878", activebackground= "#fa7878", compound = CENTER, foreground = "white", activeforeground = "#fa7878", font=(None, 13))
removeintr_button.place ( x = 960, y = 348 )
optionVarExtrinsiclist = StringVar()
optionVarExtrinsiclist.set("Select Extrinsic Habitat")
OptionMenuExtrinsiclist = OptionMenu(framer.Objframe, optionVarExtrinsiclist, "Select Extrinsic Habitat")
OptionMenuExtrinsiclist.place(x = 670, y = 380)
OptionMenuExtrinsiclist.config(width=250, height = 16, image = framer.cancelmenupic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#fa7878", font=(None, 12))
removeextr_button = Button(framer.Objframe, text="remove", command = lambda: removefromlist(extrinsiclist, componentlist_textfield, OptionMenuExtrinsiclist, optionVarExtrinsiclist, debug_textfield))
removeextr_button.config(image = framer.cancelbtnpic, borderwidth = 0, bg = "#fa7878", activebackground= "#fa7878", compound = CENTER, foreground = "white", activeforeground = "#fa7878", font=(None, 13))
removeextr_button.place ( x = 960, y = 380 )
optionVarAffordancelist = StringVar()
optionVarAffordancelist.set("Select Affordance Formula")
OptionMenuAffordancelist = OptionMenu(framer.Objframe, optionVarAffordancelist, "Select Affordance Formula")
OptionMenuAffordancelist.place(x = 670, y = 440)
OptionMenuAffordancelist.config(width=250, height = 16, image = framer.cancelmenupic, anchor = "w", borderwidth = 0, indicatoron=0, compound = LEFT, bg = "#404040", activebackground= "#404040", foreground = "white", activeforeground = "#fa7878", font=(None, 12))
removeAffordance_button = Button(framer.Objframe, text="remove", command = lambda: removefromlist(affordanceformulalist, componentlist_textfield, OptionMenuAffordancelist, optionVarAffordancelist, debug_textfield))
removeAffordance_button.config(image = framer.cancelbtnpic, borderwidth = 0, bg = "#fa7878", activebackground= "#fa7878", compound = CENTER, foreground = "white", activeforeground = "#fa7878", font=(None, 13))
removeAffordance_button.place ( x = 960, y = 440 )
drdwnlistgrn = [option, optionmenuhead, optionmenuconc, optionmenuint, optionmenuext, optionmenuafford, OptionMenuScale, OptionMenuMovable]
drdwnlistred = [OptionMenuComponentlist, OptionMenuIntrinsiclist, OptionMenuExtrinsiclist, OptionMenuAffordancelist]
for drdwn in drdwnlistgrn:
i = 0
while i < drdwn['menu'].index('end') + 1:
drdwn['menu'].entryconfig(i, background = "#404040" ,activebackground = "#505050", foreground = "white", activeforeground = "#a3ff8f")
i += 1
for drdwn in drdwnlistred:
i = 0
while i < drdwn['menu'].index('end') + 1:
drdwn['menu'].entryconfig(i, background = "#404040" ,activebackground = "#505050", foreground = "white", activeforeground = "#fa7878")
i += 1
drdwn['menu'].add_command(label = " ", command=tk._setit(optionVarComponentlist, "Select Component"))
drdwn['menu'].entryconfig(1, background = "#404040" ,activebackground = "#404040", foreground = "white", activeforeground = "#fa7878")
class Start_Frame(Frame):
"""
Fenêtre initiale. Demande à l'utilisateur d'entrer les dimensions de la
grille à créer. Permet également d'ouvrir une grille préexistante.
"""
TITLE = "Dosun Fuwari Solver"
HELPTEXT = "Enter the dimensions of the grid you want to create: (maximum 20x20)"
def __init__(self, master=None):
"""
Initialisation automatique à la création de la fenêtre d'initialisation
"""
super().__init__(master, padding=(20, 20, 20, 20))
# assigner les variables d'instance
self.master = master
# variables Tk qui contiendront les valeurs entrées dans les deux champs de
# texte
self.x = IntVar()
self.y = IntVar()
# Les initialiser à des valeurs cohérentes
self.x.set(2)
self.y.set(2)
# Dessiner la fenêtre
self.create_widgets()
def create_widgets(self):
"""
Affiche le formulaire de démarrage.
"""
# Titre
Label(
self,
text=self.TITLE,
font=("Helvetica", 16),
anchor=N,
padding=(0, 0, 0, 10),
).grid(row=0, column=0, columnspan=4, sticky=W + E + N)
# Texte d'indication
Label(
self,
text=self.HELPTEXT,
wraplength=300,
font=("Helvetica", 12),
anchor=N,
justify=LEFT,
padding=(0, 0, 0, 10),
).grid(row=1, column=0, columnspan=3, sticky=W + E)
# Commande de validation des entrées
# Source: https://stackoverflow.com/a/31048136
# Empêche la création de grilles de dimensions ridicules
vcmd = (self.register(self.validate), "%d", "%P", "%S")
# Formulaire d'entrée de la largeur de la grille
Label(self, text="Width:").grid(row=2, column=0)
x_entry = Entry(self,
textvariable=self.x,
validate="key",
validatecommand=vcmd)
x_entry.grid(row=2, column=1, sticky=W + E)
# Formulaire d'entrée de la hauteur de la grille
Label(self, text="Height:").grid(row=3, column=0)
y_entry = Entry(self,
textvariable=self.y,
validate="key",
validatecommand=vcmd)
y_entry.grid(row=3, column=1, sticky=W + E)
# Bouton Start
sub_btn = Button(
self,
text="Start!",
command=lambda: self.start_editor(int(x_entry.get()),
int(y_entry.get())),
)
# Associer la même action à la touche entrée qu'au bouton start
self.master.bind(
"<Return>",
lambda e: self.start_editor(int(x_entry.get()), int(y_entry.get()),
e),
)
# Pareil avec le bouton entrée du pavé numérique
self.master.bind(
"<KP_Enter>",
lambda e: self.start_editor(int(x_entry.get()), int(y_entry.get()),
e),
)
sub_btn.grid(row=2, column=3, rowspan=2)
def validate(self, action, value_if_allowed, text):
"""
Renvoie True ssi la valeur fournie dans text est convertissable en
entier et a une valeur autorisée ( > 0 et <= 20)
Source: https://stackoverflow.com/a/31048136
"""
# Ne vérifier l'entrée que si on insère un caractère
if action == "1":
# N'autoriser que des chiffres
if text in "0123456789":
try:
# Vérifier que la valeur saisie est un entier et est entre
# les bornes choisies
return 0 < int(value_if_allowed) <= 20
except ValueError:
# La valeur n'était pas un entier: enpêcher la saisie
return False
else:
# La valeur n'était pas un chiffre
return False
else:
# Sinon on s'en fout (on n'empêche pas de supprimer, sélectionner
# comme on veut)
return True
def start_editor(self, x, y, event=None):
"""
Détruit la fenêtre initiale et ouvre une fenêtre d'édition avec une
grille de la taille choisie par l'utilisateur
"""
self.destroy()
self.master.change(Editor_Frame, [x, y, {"blacks": [], "zones": []}])
def open_grid(self):
"""
Ouvre une grille préexistante dans une fenêtre d'édition
"""
filename = askopenfilename(
initialdir=".",
filetypes=(("JSON File", "*.json"), ("All Files", "*.*")),
title="Choose a file.",
)
if filename:
grid = fio.read_grid(filename)
self.destroy()
self.master.change(Editor_Frame,
[grid["width"], grid["height"], grid])
def create_menu(self, root):
"""
Dessine le "menu" - la barre d'options en haut de la fenêtre.
"""
menubar = Menu(root)
fileMenu = Menu(menubar, tearoff=0)
fileMenu.add_command(label="Open grid", command=self.open_grid)
fileMenu.add_command(label="Quit", command=quit)
menubar.add_cascade(label="File", menu=fileMenu)
return menubar
class GameLogic: # pylint: disable=too-many-instance-attributes
# all instance-attributes are needed to run the show
""" Luokka toteuttaa pelin toiminnallisuuden ja logiikan, käyttäen apunaan eri olioita.
Attributes:
first_wheel = yksittäinen pelilinja, Wheel-olio
second_wheel = yksittäinen pelilinja, Wheel-olio
third_wheel = yksittäinen pelilinja, Wheel-olio
credits = pelivarat, Credit-olio
bet = pelipanos
bet_list = lista eri pelipanoksista
payoff = voittojen laskemiseen käytettävä Payoff-olio
last_win_amount = viimeisin voiton suuruus
list_of_wheels = kaikki voittolinjat sisältävä lista
can_be_locked = käytetään pelilinjoen lukituksen ohitukseen
"""
def __init__(self):
""""Konstruktori joka luo pelilogiikan olion.
"""
self.first_wheel = Wheel()
self.second_wheel = Wheel()
self.third_wheel = Wheel()
self.credits = Credit()
self.bet = IntVar()
self.bet_list = [1, 2, 5, 10]
self.payoff = Payoff()
self.last_win_amount = IntVar()
self.last_win_amount.set(0)
self.list_of_wheels = (self.first_wheel, self.second_wheel,
self.third_wheel)
self.can_be_locked = True
def start(self):
"""Alustaa pelipanoksen oikeaksi
"""
self.raise_bet()
def play(self):
"""Tarkistaa riittävätkö pelivarat pelaamiseen, olivatko aiemmalla kieroksella
pelilinjat lukittu ja arpoo pelilinjoille uudet arvot"""
if self.check_credits():
if not self.can_be_locked:
self.unlock_all_and_spin()
else:
if self.check_locked_wheels():
self.use_credit_and_spin()
return True
return False
def check_credits(self):
"""Tarkistaa riittävät pelivarat pelin pelaamiseen"""
if self.credits.value.get() == 0:
return False
if self.credits.value.get() < self.bet.get():
return False
return True
def check_locked_wheels(self):
"""Tarkistaa olivatko osa pelilinjoista lukittu edellisellä kieroksella. """
locked_wheels = 0
for wheel in self.list_of_wheels:
if wheel.is_locked:
locked_wheels += 1
self.can_be_locked = False
if locked_wheels > len(self.list_of_wheels) - 1:
self.can_be_locked = True
return False
return True
def unlock_all_and_spin(self):
"""Käytetään pelilinjojen lukituksen vapauttamiseen, jos esim. edellisellä kierroksella
osa linjoista on ollut lukittuna. Jokaisen pelikierroksen jälkeen joka sisältää lukitun
pelilinja, tulee olla vähintaa yksi kierros jossa kaikki pelilinjat arvotaan uudestaan """
self.first_wheel.set_unlocked()
self.second_wheel.set_unlocked()
self.third_wheel.set_unlocked()
self.use_credit_and_spin()
self.can_be_locked = True
def use_credit_and_spin(self):
"""Toiminnallisuus joka kuluttaa pelivaroja panoksen verran,
arpoo uudet arvot pelilinjoilla ja tarkistaa tuliko voittoa"""
self.credits.use_credit(self.bet.get())
self.spin_all_wheels()
self.check_for_payoff()
def check_for_payoff(self):
"""Tarkistaa tuliko kierroksella voittoa"""
if self.payoff.check_for_win(self.first_wheel.value,
self.second_wheel.value,
self.third_wheel.value):
payoff_amount = self.payoff.payoff_amount(self.first_wheel.value,
self.bet.get())
self.credits.add_payoff(payoff_amount)
self.last_win_amount.set(payoff_amount)
self.can_be_locked = False
def raise_bet(self):
"""Korottaa pelipanoksen"""
next_bet = self.bet_list.pop(0)
self.bet.set(next_bet)
self.bet_list.append(next_bet)
def spin_all_wheels(self):
"""Arpoo uudet arvot pelilinjoille jotka eivät ole lukittu"""
self.first_wheel.spin()
self.second_wheel.spin()
self.third_wheel.spin()
class MyFirstGUI:
def __init__(self, master):
self.master = master
master.title("GUI do Sensor")
# Variaveis do Sensor
#threadSensor = Thread(target = novoSensor(),)
#threadSensor.start()
# REMOVER SENSOR E ADICIONAR CONTROLLER P/ MVC PENDENTE FALTA FAZER
self.sensor = novoSensor(cpf_sensor, ip_servidor, tcp_porta)
# Label principal
self.label = Label(master, text="Configurações do Sensor:")
self.label.grid(row=0, column=1, columnspan=1)
# Label BPM:
self.bpm_label = Label(master, text="BPM:")
self.bpm_label.grid(row=1, column=0, sticky=W)
# Valor BPM e Label_Valor_BPM
self.valor_bpm_label_num = IntVar()
self.valor_bpm_label_num.set(self.sensor.bpm)
self.valor_bpm_label = Label(master,
textvariable=self.valor_bpm_label_num)
self.valor_bpm_label.grid(row=1, column=1)
# Botão Incrementar BPM
self.incrementar_bpm_button = Button(master,
text="/\\",
command=self.incrementarBPM)
self.incrementar_bpm_button.grid(row=1, column=2)
self.decrementar_bpm_button = Button(master,
text="\\/",
command=self.decrementarBPM)
self.decrementar_bpm_button.grid(row=1, column=3)
# # # # MOVIMENTO # # # #
# Label movimento
self.movimento_label = Label(master, text="Movimentando:")
self.movimento_label.grid(row=2, column=0, sticky=W)
# Valor Movimento e Label_Valor_Movimento
if (True == self.sensor.movimento):
self.valor_movimento_label = Label(master, text="SIM!")
else:
self.valor_movimento_label = Label(master, text="NÃO!")
self.valor_movimento_label.grid(row=2, column=1)
# Botão Movimentar
self.movimentar_button = Button(master,
text="ANDA!",
command=self.movimentar)
self.movimentar_button.grid(row=2, column=2)
self.parar_button = Button(master, text="PARA!", command=self.parar)
self.parar_button.grid(row=2, column=3)
# # # # PRESSAO # # # #
# Label Pressao
self.pressao_label = Label(master, text="Pressão:")
self.pressao_label.grid(row=3, column=0, sticky=W)
# Valor Pressao e Label_Valor_Pressao
self.valor_pressao_label = Label(master, text=str(self.sensor.pressao))
self.valor_pressao_label.grid(row=3, column=1)
# Botão Incrementar Pressao
self.pressao_baixa_button = Button(master,
text="BAIXA",
command=self.pressao_baixa)
self.pressao_baixa_button.grid(row=3, column=2)
# Botão Decrementar Pressao
self.pressao_normal_button = Button(master,
text="NORMAL",
command=self.pressao_normal)
self.pressao_normal_button.grid(row=3, column=3)
# Botão Pressao Alta
self.pressao_alta_button = Button(master,
text="ALTA",
command=self.pressao_alta)
self.pressao_alta_button.grid(row=3, column=4)
# # # # COORDENADAS # # # #
# Label POSX
self.posicaox_label = Label(master, text="X:")
self.posicaox_label.grid(row=4, column=0, sticky=W)
# Valor posicaoX
self.valor_posicaox_label_num = IntVar()
self.valor_posicaox_label_num.set(self.sensor.x)
self.valor_posicaox_label = Label(
master, textvariable=self.valor_posicaox_label_num)
self.valor_posicaox_label.grid(row=4, column=1)
# Botão Incrementar X
self.incrementar_posicaox_button = Button(
master, text="/\\", command=self.incrementar_posicaox)
self.incrementar_posicaox_button.grid(row=4, column=2)
# Botão Decrementar X
self.decrementar_posicaox_button = Button(
master, text="\\/", command=self.decrementar_posicaox)
self.decrementar_posicaox_button.grid(row=4, column=3)
# Label POSY
self.posicaoy_label = Label(master, text="Y:")
self.posicaoy_label.grid(row=5, column=0, sticky=W)
# Valor posicaoY
self.valor_posicaoy_label_num = IntVar()
self.valor_posicaoy_label_num.set(self.sensor.y)
self.valor_posicaoy_label = Label(
master, textvariable=self.valor_posicaoy_label_num)
self.valor_posicaoy_label.grid(row=5, column=1)
# Botão Incrementar X
self.incrementar_posicaoy_button = Button(
master, text="/\\", command=self.incrementar_posicaoy)
self.incrementar_posicaoy_button.grid(row=5, column=2)
# Botão Decrementar X
self.decrementar_posicaoy_button = Button(
master, text="\\/", command=self.decrementar_posicaoy)
self.decrementar_posicaoy_button.grid(row=5, column=3)
# # # # FECHAR # # # #
# Botão fechar
self.close_button = Button(master, text="Close", command=master.quit)
self.close_button.grid(row=6, column=1, columnspan=1)
# Atualiza dados da interface
# FALTA FAZER
# # # Funções da classe # # #
# def atualizarValores(self):
# FALTA FAZER
def incrementarBPM(self):
self.sensor.bpm += 1
self.valor_bpm_label_num.set(self.sensor.bpm)
self.valor_bpm_label = Label(self.master,
textvariable=self.valor_bpm_label_num)
def decrementarBPM(self):
self.sensor.bpm -= 1
self.valor_bpm_label_num.set(self.sensor.bpm)
self.valor_bpm_label = Label(self.master,
textvariable=self.valor_bpm_label_num)
def pressao_baixa(self):
self.sensor.pressao = 1
self.valor_pressao_label = Label(self.master,
text=str(self.sensor.pressao))
self.valor_pressao_label.grid(row=3, column=1)
def pressao_normal(self):
self.sensor.pressao = 0
self.valor_pressao_label = Label(self.master,
text=str(self.sensor.pressao))
self.valor_pressao_label.grid(row=3, column=1)
def pressao_alta(self):
self.sensor.pressao = 2
self.valor_pressao_label = Label(self.master,
text=str(self.sensor.pressao))
self.valor_pressao_label.grid(row=3, column=1)
def movimentar(self):
self.sensor.movimento = True
self.valor_movimento_label = Label(self.master, text="SIM!")
self.valor_movimento_label.grid(row=2, column=1)
def parar(self):
self.sensor.movimento = False
self.valor_movimento_label = Label(self.master, text="NÃO!")
self.valor_movimento_label.grid(row=2, column=1)
def incrementar_posicaox(self):
self.sensor.x += 1
self.valor_posicaox_label_num.set(self.sensor.x)
self.valor_posicaox_label = Label(
self.master, textvariable=self.valor_posicaox_label_num)
def decrementar_posicaox(self):
self.sensor.x -= 1
self.valor_posicaox_label_num.set(self.sensor.x)
self.valor_posicaox_label = Label(
self.master, textvariable=self.valor_posicaox_label_num)
def incrementar_posicaoy(self):
self.sensor.y += 1
self.valor_posicaoy_label_num.set(self.sensor.y)
self.valor_posicaoy_label = Label(
self.master, textvariable=self.valor_posicaoy_label_num)
def decrementar_posicaoy(self):
self.sensor.y -= 1
self.valor_posicaoy_label_num.set(self.sensor.y)
self.valor_posicaoy_label = Label(
self.master, textvariable=self.valor_posicaoy_label_num)
class RandomExcursionTestItem:
def __init__(self, master, title, x_coor, y_coor, data, variant=False):
self.__chb_var = IntVar()
self.__state = StringVar()
self.__count = StringVar()
self.__xObs = StringVar()
self.__p_value = StringVar()
self.__result = StringVar()
self.__results = []
self.__variant = variant
checkbox = Checkbutton(master, text=title, variable=self.__chb_var)
checkbox.place(x=x_coor, y=y_coor)
state_label = LabelTag(master,
'State', (x_coor + 60), (y_coor + 30),
width=100,
font_size=12,
border=2,
relief='groove')
if variant:
self.__state.set('-1.0')
else:
self.__state.set('+1')
state_option = OptionMenu(master, self.__state, *data)
state_option.place(x=(x_coor + 60),
y=(y_coor + 60),
height=25,
width=100)
if not variant:
xObs_label = LabelTag(master,
'CHI-SQUARED', (x_coor + 165), (y_coor + 30),
width=350,
font_size=12,
border=2,
relief='groove')
xObs_Entry = Entry(master, textvariable=self.__xObs)
xObs_Entry.place(x=(x_coor + 165),
y=(y_coor + 60),
width=350,
height=25)
else:
count_label = LabelTag(master,
'Count', (x_coor + 165), (y_coor + 30),
width=350,
font_size=12,
border=2,
relief='groove')
count_Entry = Entry(master, textvariable=self.__count)
count_Entry.place(x=(x_coor + 165),
y=(y_coor + 60),
width=350,
height=25)
pass
p_value_label = LabelTag(master,
'P-Value', (x_coor + 520), (y_coor + 30),
width=350,
font_size=12,
border=2,
relief='groove')
p_value_Entry = Entry(master, textvariable=self.__p_value)
p_value_Entry.place(x=(x_coor + 520),
y=(y_coor + 60),
width=350,
height=25)
conclusion_label = LabelTag(master,
'Conclusion', (x_coor + 875),
(y_coor + 30),
width=150,
font_size=12,
border=2,
relief='groove')
conclusion_Entry = Entry(master, textvariable=self.__result)
conclusion_Entry.place(x=(x_coor + 875),
y=(y_coor + 60),
width=150,
height=25)
update_button = Button(master, text='Update', command=self.update)
update_button.config(font=("Calibri", 10))
update_button.place(x=(x_coor + 1030),
y=(y_coor + 60),
width=180,
height=25)
def get_check_box_value(self):
return self.__chb_var.get()
def set_check_box_value(self, value):
self.__chb_var.set(value)
def set_results(self, results):
self.__results = results
self.update()
def update(self):
match = False
for result in self.__results:
if result[0] == self.__state.get():
if self.__variant:
self.__count.set(result[2])
else:
self.__xObs.set(result[2])
self.__p_value.set(result[3])
self.__result.set(self.get_result_string(result[4]))
match = True
if not match:
if self.__variant:
self.__count.set('')
else:
self.__xObs.set('')
self.__p_value.set('')
self.__result.set('')
def get_result_string(self, result):
if result == True:
return 'Random'
else:
return 'Non-Random'
def reset(self):
self.__chb_var.set('0')
if self.__variant:
self.__state.set('-1.0')
self.__count.set('')
else:
self.__state.set('+1')
self.__xObs.set('')
self.__p_value.set('')
self.__result.set('')
class EnaSubOptionsForm(VerticalScrolledFrame):
# Initialize the GUI
def __init__(self, root):
#Frame.__init__(self, root)
VerticalScrolledFrame.__init__(self, root)
root.title("Choose EMBL-ENA Submission Options")
self.parent = root
# Assign the icon of this sub-window.
assignIcon(self.parent)
#button_opt = {'fill': Tkconstants.BOTH, 'padx': 35, 'pady': 5}
# To define the exit behavior. Save and exit.
self.parent.protocol('WM_DELETE_WINDOW', self.saveOptions)
# Define the return behavior. Same as "close window" etc
root.bind('<Return>', self.returnFunction)
# This window should not be resizeable. I guess.
self.parent.resizable(width=False, height=False)
#Standard Inputs widths for the form elements
formInputWidth = 30
labelInputWidth = 30
self.instructionsFrame = Frame(self.interior)
self.instructionText = StringVar()
self.instructionText.set('\nProvide this required sequence metadata, please.\n'
+ 'The Allele Local Name is provided by the submitting laboratory.\n'
+ 'You may name it similar to the closest known allele,\n'
+ 'if you wish.')
Label(self.instructionsFrame, width=85, height=6, textvariable=self.instructionText).pack()
self.instructionsFrame.pack()
self.submissionDetailsInputFrame2 = Frame(self.interior)
self.sampleIDInstrText = StringVar()
self.sampleIDInstrText.set('Sample ID:')
self.sampleIDinstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.sampleIDInstrText).grid(row=0, column=0)
self.inputSampleID = StringVar()
self.inputSampleIDEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputSampleID).grid(row=0, column=1)
self.geneInstrStringVar = StringVar()
self.geneInstrStringVar.set('Gene:')
self.geneInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.geneInstrStringVar).grid(row=1, column=0)
self.inputGene = StringVar()
self.inputGeneEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputGene).grid(row=1, column=1)
self.chooseClassIntVar = IntVar()
self.chooseClassIntVar.set(1)
Radiobutton(self.submissionDetailsInputFrame2, text="HLA Class I ", variable=self.chooseClassIntVar, value=1).grid(row=2, column=0)
Radiobutton(self.submissionDetailsInputFrame2, text="HLA Class II", variable=self.chooseClassIntVar, value=2).grid(row=2, column=1)
self.alleleInstrText = StringVar()
self.alleleInstrText.set('Allele Local Name:')
self.alleleInstrLabel = Label(self.submissionDetailsInputFrame2, width=labelInputWidth, height=1, textvariable=self.alleleInstrText).grid(row=3, column=0)
self.inputAllele = StringVar()
self.inputAlleleEntry = Entry(self.submissionDetailsInputFrame2, width=formInputWidth, textvariable=self.inputAllele).grid(row=3, column=1)
self.submissionDetailsInputFrame2.pack()
# Make a frame to contain the Test/Production radio buttons.
self.testProductionFrame = Frame(self.interior)
self.testProductionInstrText = StringVar()
self.testProductionInstrText.set('\nBy default, you submit to the EMBL-ENA test servers,\n'
+ 'where submissions are regularly deleted.\n'
+ 'change this option if you want to submit to the live environment.\n'
+ 'Login Credentials will not be stored, but they will be sent\n'
+ 'to EMBL-ENA via REST during allele submission.\n'
)
self.alleleInstrLabel = Label(self.testProductionFrame, width=70, height=7, textvariable=self.testProductionInstrText).pack()#.grid(row=2, column=0)
# 1 = Test. 0 = Production/live server
self.chooseTestServersIntVar = IntVar()
# a short check in case the config value has not been implemented yet.
if(getConfigurationValue('test_submission') is not None):
self.chooseTestServersIntVar.set(int(getConfigurationValue('test_submission')))
else:
self.chooseTestServersIntVar.set(1)
Radiobutton(self.testProductionFrame, text="Submit to EMBL-ENA TEST / DEMO environment.", variable=self.chooseTestServersIntVar, value=1).pack()
Radiobutton(self.testProductionFrame, text="Submit to EMBL-ENA LIVE / PROD environment.", variable=self.chooseTestServersIntVar, value=0).pack()
self.testProductionFrame.pack()
# Make a frame to contain the input variables
self.submissionDetailsInputFrame = Frame(self.interior)
self.usernameInstrText = StringVar()
self.usernameInstrText.set('EMBL-ENA Username:'******'EMBL-ENA Password:'******'\nEMBL-ENA will store the sequence in an "Analysis" object.\n'
+ 'You must specify an analysis Alias, Title, and\n'
+ 'Description for every submitted sequence.\n'
+ 'The Alias must be unique.\n'
)
self.analysisMetadataLabel = Label(self.analysisOptionsInputFrame, width=70, height=5, textvariable=self.analysisMetadataInstrText).pack()#.grid(row=2, column=0)
self.analysisOptionsInputFrame.pack()
# Frame to specify Analysis Information
self.newAnalysisFrame = Frame(self.interior)
self.analysisAliasInstrText = StringVar()
self.analysisAliasInstrText.set('Analysis Alias:')
self.analysisAliasInstrLabel = Label(self.newAnalysisFrame, width=labelInputWidth, height=1, textvariable=self.analysisAliasInstrText).grid(row=0, column=0)
self.inputAnalysisAlias = StringVar()
self.inputStudyIdEntry = Entry(self.newAnalysisFrame, width=formInputWidth, textvariable=self.inputAnalysisAlias).grid(row=0, column=1)
self.analysisTitleInstrText = StringVar()
self.analysisTitleInstrText.set('Analysis Title:')
self.analysisTitleInstrLabel = Label(self.newAnalysisFrame, width=labelInputWidth, height=1, textvariable=self.analysisTitleInstrText).grid(row=1, column=0)
self.inputAnalysisTitle = StringVar()
self.inputAnalysisTitleEntry = Entry(self.newAnalysisFrame, width=formInputWidth, textvariable=self.inputAnalysisTitle).grid(row=1, column=1)
self.analysisDescriptionInstrText = StringVar()
self.analysisDescriptionInstrText.set('Analysis Description:')
self.analysisDescriptionInstrLabel = Label(self.newAnalysisFrame, width=labelInputWidth, height=1, textvariable=self.analysisDescriptionInstrText).grid(row=2, column=0)
self.inputAnalysisDescription = StringVar()
self.inputAnalysisDescriptionEntry = Entry(self.newAnalysisFrame, width=formInputWidth, textvariable=self.inputAnalysisDescription).grid(row=2, column=1)
self.newAnalysisFrame.pack()
# A Frame for specifing the details of the Study / Project
self.projectDetailsFrame = Frame(self.interior)
self.alleleInstrText = StringVar()
self.alleleInstrText.set('\nEMBL-ENA requires that submissions are assigned to a Study/Project.\n'
+ 'You must either:\n\n'
+ '1.) Provide an existing EMBL-ENA study/project accession #.\n'
+ 'This was provided in a previous submission, or you can see a list of\n'
+ 'your projects by logging into EMBL-ENA Webin. (ex. \'PRJEB01234\')\n'
+ '\n'
+ '2.) Specify metadata for a new study at EMBL-ENA.\n'
+ 'Provide an Identifier, Title, and short Abstract for the new Study,\n'
+ 'and I will create it automatically.\n'
+ 'Study Identifier must be Unique.'
)
self.alleleInstrLabel = Label(self.projectDetailsFrame, width=70, height=12, textvariable=self.alleleInstrText).pack()#.grid(row=2, column=0)
self.chooseProjectIntVar = IntVar()
self.chooseProjectIntVar.set(2)
# A frame for the "new study" radio button
self.existingProjectFrame = Frame(self.projectDetailsFrame)
Radiobutton(self.existingProjectFrame, text="Use this study accession:", variable=self.chooseProjectIntVar, value=1).grid(row=0,column=0)
self.inputStudyAccession = StringVar()
self.inputStudyIdEntry = Entry(self.existingProjectFrame, width=formInputWidth, textvariable=self.inputStudyAccession).grid(row=0, column=1)
self.existingProjectFrame.pack()
# Filler Label
Label(self.projectDetailsFrame, width=labelInputWidth, height=1, text=' ').pack()
# This radio button is on the project details frame, but not
# on one of it's sub-frames (existingProjectFrame or newProjectFrame)
# That's so i can pack it, and not use a grid
Radiobutton(self.projectDetailsFrame, text="Create a new study with this information:", variable=self.chooseProjectIntVar, value=2).pack()
self.newProjectFrame = Frame(self.projectDetailsFrame)
self.studyIdInstrText = StringVar()
self.studyIdInstrText.set('Short Study Identifier:')
self.studyIdInstrLabel = Label(self.newProjectFrame, width=labelInputWidth, height=1, textvariable=self.studyIdInstrText).grid(row=0, column=0)
self.inputStudyId = StringVar()
self.inputStudyIdEntry = Entry(self.newProjectFrame, width=formInputWidth, textvariable=self.inputStudyId).grid(row=0, column=1)
self.studyShortTitleInstrText = StringVar()
self.studyShortTitleInstrText.set('Descriptive Study Title:')
self.studyShortTitleInstrLabel = Label(self.newProjectFrame, width=labelInputWidth, height=1, textvariable=self.studyShortTitleInstrText).grid(row=1, column=0)
self.inputStudyShortTitle = StringVar()
self.inputStudyShortTitleEntry = Entry(self.newProjectFrame, width=formInputWidth, textvariable=self.inputStudyShortTitle).grid(row=1, column=1)
self.studyAbstractInstrText = StringVar()
self.studyAbstractInstrText.set('Study Description / Abstract:')
self.studyAbstractInstrLabel = Label(self.newProjectFrame, width=labelInputWidth, height=1, textvariable=self.studyAbstractInstrText).grid(row=2, column=0)
self.inputStudyAbstract = StringVar()
self.inputStudyAbstractEntry = Entry(self.newProjectFrame, width=formInputWidth, textvariable=self.inputStudyAbstract).grid(row=2, column=1)
self.newProjectFrame.pack()
self.projectDetailsFrame.pack()
# Make a frame for the save options button.
self.saveOptionsFrame = Frame(self.interior)
Button(self.saveOptionsFrame, text='Save Options', command=self.saveOptions).grid(row=0, column=0)
self.saveOptionsFrame.pack()
# TODO: Should there be a cancel button, to close this window without saving?
self.loadOptions()
# I needed a function for the return keypress to latch onto.
# It is just a wrapper for the saveOptions method.
def returnFunction(self, event):
self.saveOptions()
# submissionOptions is a dictionary, passed by the parent.
def loadOptions(self):
if getConfigurationValue('ena_username') is not None:
self.inputUsername.set(getConfigurationValue('ena_username'))
if getConfigurationValue('ena_password') is not None:
self.inputPassword.set(getConfigurationValue('ena_password'))
if getConfigurationValue('sample_id') is not None:
self.inputSampleID.set(getConfigurationValue('sample_id'))
if getConfigurationValue('gene') is not None:
self.inputGene.set(getConfigurationValue('gene'))
if getConfigurationValue('class') is not None:
if (str(getConfigurationValue('class')) == '1'):
self.chooseClassIntVar.set(1)
elif (str(getConfigurationValue('class')) == '2'):
self.chooseClassIntVar.set(2)
else:
raise Exception('Error loading EMBL-ENA submission options. Invalid class:' + str(getConfigurationValue('class')))
if getConfigurationValue('allele_name') is not None:
self.inputAllele.set(getConfigurationValue('allele_name'))
if getConfigurationValue('choose_project') is not None:
if (str(getConfigurationValue('choose_project')) == '1'):
self.chooseProjectIntVar.set(1)
elif (str(getConfigurationValue('choose_project')) == '2'):
self.chooseProjectIntVar.set(2)
else:
raise Exception('Error loading EMBL-ENA submission options. Invalid Project choice:' + str(getConfigurationValue('choose_project')))
if getConfigurationValue('study_accession') is not None:
self.inputStudyAccession.set(getConfigurationValue('study_accession'))
if getConfigurationValue('study_identifier') is not None:
self.inputStudyId.set(getConfigurationValue('study_identifier'))
if getConfigurationValue('study_short_title') is not None:
self.inputStudyShortTitle.set(getConfigurationValue('study_short_title'))
if getConfigurationValue('study_abstract') is not None:
self.inputStudyAbstract.set(getConfigurationValue('study_abstract'))
if getConfigurationValue('test_submission') is not None:
# 1 = Test. 0 = Production/live server
self.chooseTestServersIntVar.set(int(getConfigurationValue('test_submission')))
if getConfigurationValue('analysis_alias') is not None:
self.inputAnalysisAlias.set(getConfigurationValue('analysis_alias'))
if getConfigurationValue('analysis_title') is not None:
self.inputAnalysisTitle.set(getConfigurationValue('analysis_title'))
if getConfigurationValue('analysis_description') is not None:
self.inputAnalysisDescription.set(getConfigurationValue('analysis_description'))
def saveOptions(self):
# Close the window
if (self.checkOptions()):
logging.info ('Saving Options....')
assignConfigurationValue('ena_username', self.inputUsername.get())
# I store this password so I can use it in the submission
# I don't ever want to save the password. Make sure it isn't being saved in the config, in AlleleSubCommon.py
assignConfigurationValue('ena_password', self.inputPassword.get())
assignConfigurationValue('sample_id', self.inputSampleID.get())
assignConfigurationValue('gene', self.inputGene.get())
assignConfigurationValue('class', str(self.chooseClassIntVar.get()))
assignConfigurationValue('allele_name', self.inputAllele.get())
assignConfigurationValue('choose_project', str(self.chooseProjectIntVar.get()))
assignConfigurationValue('study_accession', self.inputStudyAccession.get())
assignConfigurationValue('study_identifier', self.inputStudyId.get())
assignConfigurationValue('study_short_title', self.inputStudyShortTitle.get())
assignConfigurationValue('study_abstract', self.inputStudyAbstract.get())
assignConfigurationValue('test_submission', str(self.chooseTestServersIntVar.get()))
assignConfigurationValue('analysis_alias', str(self.inputAnalysisAlias.get()))
assignConfigurationValue('analysis_title', str(self.inputAnalysisTitle.get()))
assignConfigurationValue('analysis_description', str(self.inputAnalysisDescription.get()))
self.parent.destroy()
else:
#logging.info('Not ready to save, you are missing options.')
pass
def checkOptions(self):
# TODO: THis is really annoying. I should allow them to close this screen without providing all the information
# Im sure a user will complain about this.
#logging.info ('Checking options.')
# Don't check the ena Username
# Don't check the ena Password
# TODO: I should be more strict with this enforcement. I got rid of the False returns because it was too darn annoying.
if (not self.inputSampleID.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Sample ID. Please try again.')
#return False
return True
if (not self.inputGene.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Gene. Please try again.')
#return False
return True
# Don't check the class boolean
if (not self.inputAllele.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an Allele Name. Please try again.')
#return False
return True
if (str(self.chooseProjectIntVar.get()) == '1'):
# Use Existing Project
if (not self.inputStudyAccession.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Study Accession number. Please try again.')
#return False
return True
elif(str(self.chooseProjectIntVar.get()) == '2'):
# Use New Project
if (not self.inputStudyId.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Study Name. Please try again.')
#return False
return True
if (not self.inputStudyShortTitle.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Study Description. Please try again.')
#return False
return True
if (not self.inputStudyAbstract.get()):
messagebox.showwarning('Missing Form Value',
'You are missing a Study Accession number. Please try again.')
#return False
return True
else:
raise Exception ('Unknown value of self.chooseProjectIntVar. I expect 1 or 2. Observed:' + str(self.chooseProjectIntVar))
if (not self.inputAnalysisAlias.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an Analysis Alias. Please try again.')
#return False
return True
if (not self.inputAnalysisTitle.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an Analysis Title. Please try again.')
#return False
return True
if (not self.inputAnalysisDescription.get()):
messagebox.showwarning('Missing Form Value',
'You are missing an Analysis Description. Please try again.')
#return False
return True
# All options look good, right?
return True
def closeWindow(self):
self.parent.destroy()
class App(Frame):
"""The main application."""
def __init__(self, master=None, path="", flags=DEFAULT_FLAGS):
"""Initialize the frame."""
# get the "path" keyword argument, unique to MyPanel2
tc0_text = DEFAULT_FILE_TEXT
if path:
# expand to full pathname for current directory
if not os.path.dirname(path):
path = os.path.abspath(os.path.join(os.getcwd(), path))
tc0_text = path
# if no flags were passed, use the defaults
if flags == (False, ) * 8:
flags = DEFAULT_FLAGS
Frame.__init__(self, master, relief=RAISED)
self.pack(fill=BOTH)
self._create_widgets()
self._create_menubar()
self._initialize(tc0_text, flags)
def about_me(self):
"""Handle About..."""
print("about_me")
def log(self, _s):
"""Log this string _s to the frame and the console."""
print("%s" % _s)
self._e2.insert(END, "\n- " + _s)
self._e2.see(END)
########################################################################
def do_et(self, pathname, et_flag, html_flag):
"""Run the ET function."""
# self.log("do_et: %s %s %s" % (pathname, et_flag, html_flag))
self.log("Processing ET and/or HTML")
et_options = Options()
et_options.html = html_flag
body = et.do_body2(pathname, index=MIN_INDEX, options=et_options)
if et_flag:
output_filename = "%s.csv" % pathname
outfile = open(output_filename, "w")
print(body, file=outfile)
outfile.close()
print("et output is in %s" % output_filename)
########################################################################
def do_gpx2kml(self, pathname):
"""Create a KML file from the path data."""
self.log("Processing gpx2hkml")
input_filename = pathname
output_filename = None
gpx2kml.create_kml_file(input_filename, output_filename)
########################################################################
def do_mr(self, pathname):
"""Process the pathname file using mr.py."""
self.log(f"Processing mr: {pathname}")
mr_options = Options()
mr.process_arg(pathname, mr_options)
########################################################################
def do_rooter(self, pathname):
"""Create a Rooter HTML File."""
self.log("Creating Rooter file")
rooter.do_rooter(pathname) # , options=ro_options)
########################################################################
def do_rtept(self, pathname):
"""Create a Streets & Trips Route GPX File.
Arguments:
pathname {[type]} -- [description]
"""
try:
self.log("do_rtept")
output_filename = make_rtept.do_make_rtept(pathname)
self.log("%s created" % output_filename)
except Exception as _e:
print(_e)
self.log(traceback.format_exc())
########################################################################
def do_gs(self, pathname):
"""Create a Cachly gpx File.
Arguments:
pathname {str} -- pathname
"""
self.log("Creating Cachly file")
try:
make_gs.process_arg(pathname)
except Exception as _e:
print(_e)
self.log(traceback.format_exc())
########################################################################
def do_html_maps(self, pathname):
"""Create a HTML Maps File.
Arguments:
pathname {str} -- pathname
"""
self.log("Creating HTML Maps file")
try:
make_html_maps.process_arg(pathname)
except Exception as _e:
print(_e)
self.log(traceback.format_exc())
########################################################################
def _create_widgets(self):
self._s1 = StringVar()
self._s2 = StringVar()
self._v1 = IntVar()
self._v2 = IntVar()
self._v3 = IntVar()
self._v4 = IntVar()
self._v5 = IntVar()
self._v6 = IntVar()
self._v7 = IntVar()
self._v8 = IntVar()
self.lf1 = LabelFrame(self, text="Filename:")
self.lf1.pack(fill=BOTH)
self.lf2 = LabelFrame(self,
text="Processing choices: pick at least one")
# self.lf2.config(label="Processing choices: pick at least one")
self.lf2.pack(fill=BOTH)
self.lf3 = LabelFrame(self, text="Logging")
# self.lf3.config(label="Logging")
self.lf3.pack(fill=BOTH)
self._b1 = Button(self,
text="Run",
command=self.b1_callback,
default=ACTIVE)
self._b1.pack(side="bottom")
self._e1 = Entry(self.lf1, textvariable=self._s1)
self._e1.pack(fill=BOTH)
self._e1.bind("<Button-1>", self.e1_callback)
self._e2 = Text(self.lf3, height=10, width=72, wrap=NONE)
self._e2.pack(fill=BOTH)
self._c1 = Checkbutton(self.lf2,
text="ET - generate Excel .csv output",
variable=self._v1)
self._c1.pack(anchor=W)
self._c2 = Checkbutton(self.lf2,
text="HTML - include HTML output from et.py",
variable=self._v2)
self._c2.pack(anchor=W)
self._c3 = Checkbutton(self.lf2,
text="KML - output for Google Earth",
variable=self._v3)
self._c3.pack(anchor=W)
self._c4 = Checkbutton(self.lf2,
text="MR - generate a .gpx route file",
variable=self._v4)
self._c4.pack(anchor=W)
self._c5 = Checkbutton(self.lf2,
text="ROOTER - generate a Rooter file",
variable=self._v5)
self._c5.pack(anchor=W)
self._c6 = Checkbutton(
self.lf2,
text="RTEPT - generate a Streets and Trips GPX _rtept file",
variable=self._v6)
self._c6.pack(anchor=W)
self._c7 = Checkbutton(self.lf2,
text="Cachly - generate a Cachly file",
variable=self._v7)
self._c7.pack(anchor=W)
self._c8 = Checkbutton(self.lf2,
text="HTML Maps - generate a HTML Maps file",
variable=self._v8)
self._c8.pack(anchor=W)
def _create_menubar(self):
self.menubar = Menu(self)
self.filemenu = Menu(self.menubar, tearoff=0)
self.filemenu.add_command(label="Quit", command=self.quit)
self.helpmenu = Menu(self.menubar, tearoff=0)
self.helpmenu.add_command(label="About Me", command=self.about_me)
self.menubar.add_cascade(label="File", menu=self.filemenu)
self.menubar.add_cascade(label="Help", menu=self.helpmenu)
# self.master.config(menu=self.menubar)
def _initialize(self, tc0_text, flags):
self._s1.set(tc0_text)
self._s2.set("Logging")
self._v1.set(flags[0])
self._v2.set(flags[1])
self._v3.set(flags[2])
self._v4.set(flags[3])
self._v5.set(flags[4])
self._v6.set(flags[5])
self._v7.set(flags[6])
self._v8.set(flags[7])
def b1_callback(self):
"""Handle the callback operation of the _b1 button."""
print(
'"%s"' % self._e1.get(),
self._v1.get(),
self._v2.get(),
self._v3.get(),
self._v4.get(),
self._v5.get(),
self._v6.get(),
self._v7.get(),
self._v8.get(),
)
if self._s1.get() == DEFAULT_FILE_TEXT:
self.e1_callback(None)
return
else:
print("Process %s" % self._s1.get())
_d = {
"pathname": self._s1.get(),
"et_flag": self._v1.get(),
"html_flag": self._v2.get(),
"kml_flag": self._v3.get(),
"mr_flag": self._v4.get(),
"ro_flag": self._v5.get(),
"rtept_flag": self._v6.get(),
"gs_flag": self._v7.get(),
"hm_flag": self._v8.get(),
}
self.process_parameters(**_d)
self.after_idle(self._shutdown)
def _shutdown(self):
"""Shutdown after three seconds."""
self.after(3000, self.quit())
def e1_callback(self, _event):
"""Handle the callback function for _e1."""
# print("e1_callback", "%s" % event)
filename = tkFileDialog.askopenfilename(filetypes=(("gpx files",
"*.gpx"),
("all files",
"*.*")))
if filename:
self._s1.set(filename)
def process_parameters(self,
pathname="",
et_flag=True,
html_flag=False,
kml_flag=True,
mr_flag=True,
ro_flag=True,
rtept_flag=True,
gs_flag=True,
hm_flag=False):
"""Perform the processing specified by pathname and flags."""
# print(
# "et_flag:", et_flag, "\n",
# "html_flag:", html_flag, "\n",
# "kml_flag:", kml_flag, "\n",
# "mr_flag:", mr_flag, "\n",
# "ro_flag:", ro_flag, "\n",
# "rtept_flag:", rtept_flag, "\n",
# "gs_flag:", gs_flag, "\n",
# "hm_flag:", hm_flag, "\n",
# )
self.log("Reading from %s" % pathname)
if not (et_flag or html_flag or kml_flag or mr_flag or ro_flag
or rtept_flag or gs_flag or hm_flag):
self.log("ERROR: Nothing to do: no flags set")
return
# perform the processing
if et_flag or html_flag:
self.do_et(pathname, et_flag=et_flag, html_flag=html_flag)
if kml_flag:
self.do_gpx2kml(pathname)
if mr_flag:
self.do_mr(pathname)
if ro_flag:
self.do_rooter(pathname)
if rtept_flag:
self.log("rtept_flag: %s" % pathname)
self.do_rtept(pathname)
if gs_flag:
self.do_gs(pathname)
if hm_flag:
self.do_html_maps(pathname)
self.log("Done!")
myDirDesc.set('Directory:')
lblDirDesc = tk.Label(frame, textvariable=myDirDesc)
lblDirDesc.grid(column=0, row=3, pady=myPady)
lblDir = tk.Label(frame, textvariable=myDir)
lblDir.grid(column=0, row=4, pady=myPady)
global btnDir
btnDir = tk.Button(frame, text="Select Dir", command=selectDir)
btnDir.grid(column=0, row=5, pady=myPady)
# radioButtons
var = IntVar()
var.set(1) # Set option 1 as default
global rb2Stems
rb2Stems = tk.Radiobutton(root,
text="Vocals/accompaniment (2 stems)",
variable=var,
value=1)
rb2Stems.place(relwidth=0.5, relheight=0.1, relx=0.25, rely=0.55)
global rb4Stems
rb4Stems = tk.Radiobutton(root,
text="Vocals/drums/bass/other (4 stems)",
variable=var,
value=2)
rb4Stems.place(relwidth=0.5, relheight=0.1, relx=0.25, rely=0.65)
city_info.pack(pady=(3, 0))
whether_lab.pack(pady=(0, 2))
temp_label.pack(pady=(0, 2))
feelslike_lab.pack(pady=(0, 2))
tempmin_lab.pack(pady=(0, 2))
tempmax_lab.pack(pady=(0, 1))
humidity_lab.pack()
iconlab.pack(pady=8)
# input frame
city_entry = tkinter.Entry(input_frame, width=20, font=large_font)
submit_button = tkinter.Button(
input_frame, text='Submit', font=large_font, bg=input_color, command=search)
search_method = IntVar()
search_method.set(1)
search_city = tkinter.Radiobutton(input_frame, text='Search By City Name',
variable=search_method, value=1, font=small_font, bg=input_color)
search_zip = tkinter.Radiobutton(input_frame, text='Search By Zip Code',
variable=search_method, value=2, font=small_font, bg=input_color)
city_entry.grid(row=0, column=0, padx=10, pady=(10, 0))
submit_button.grid(row=0, column=1, padx=10,
pady=(10, 0), sticky='e', ipadx=15)
search_city.grid(row=1, column=0, pady=2, sticky='w')
search_zip.grid(row=1, column=0, pady=2, padx=5, sticky='e', columnspan=2)
# run the windows main loop
root.mainloop()
class TilesetCreator(Frame):
"""
Converts smaller individual tiles into one tileset image
Will not keep aspect ratio so ensure that images are the correct aspect ratio before running
"""
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.open_dir = StringVar()
self.tile_width = IntVar()
self.tile_height = IntVar()
self.output_dir = StringVar()
self.init_ui()
def init_ui(self):
"""
Initializes all the widgets and UI elements
:return: None
"""
# Configure the frame
self.parent.title("Tileset Creator")
self.parent.config(padx=4, pady=4)
self.parent.resizable(0, 0)
# Create the main widgets
# Tile Width
Label(self.parent, text="Tile Width: ").grid(row=0,
column=0,
columnspan=2)
Entry(self.parent, width=3,
textvariable=self.tile_width).grid(row=1, column=0, columnspan=2)
self.tile_width.set(32)
# Tile Height
Label(self.parent, text="Tile Height: ").grid(row=2,
column=0,
columnspan=2)
Entry(self.parent, width=3,
textvariable=self.tile_height).grid(row=3,
column=0,
columnspan=2)
self.tile_height.set(32)
# Image Directory
Label(self.parent, text="Image Directory: ").grid(row=4,
column=0,
columnspan=2)
Entry(self.parent, width=32, textvariable=self.open_dir).grid(row=5,
column=0)
Button(self.parent, text="...",
command=self.choose_in_dir).grid(row=5, column=1)
# Output Directory
Label(self.parent, text="Output Directory: ").grid(row=6,
column=0,
columnspan=2)
Entry(self.parent, width=32,
textvariable=self.output_dir).grid(row=7, column=0)
Button(self.parent, text="...",
command=self.choose_out_dir).grid(row=7, column=1)
# Action button
Button(self.parent, text="Create Tileset",
command=self.create_tileset).grid(row=8, column=0, columnspan=2)
def choose_in_dir(self):
"""
Opens the Tkinter choose dir dialog and then sets the dir entry to the directory chosen
:return: None
"""
directory = filedialog.askdirectory()
self.open_dir.set(directory)
def choose_out_dir(self):
"""
Opens the Tkinter choose dir dialog and then sets the output dir entry to the directory chosen
:return: None
"""
directory = filedialog.askdirectory()
self.output_dir.set(directory)
def create_tileset(self):
"""
Create the tileset image by opening each of the tile images, resizing them to the appropriate size and then
placing them in a larger image
:return: None
"""
# Ensure the directory isn't empty
if self.open_dir.get() is None or self.open_dir.get() == "":
showerror("Error", "Invalid directory selected")
return
file_count = 0
for file in os.listdir(self.open_dir.get()):
if file.endswith(".png") or file.endswith(".jpg"):
file_count += 1
# Ensure there are actual files
if file_count <= 0:
showerror("Error", "Could not find any .png or .jpg files")
return
# Amount of tiles across and down (total tiles = tiles * tiles)
tiles = int(ceil(sqrt(file_count)))
# Create the parent image for the tileset (where the tiles will be pasted)
image_width = tiles * self.tile_width.get()
image_height = tiles * self.tile_height.get()
tileset = Image.new("RGBA", (image_width, image_height), "white")
# Loop through all the images and paste them into the appropriate positions in the tileset
row = 0
column = 0
for file in os.listdir(self.open_dir.get()):
# Only worried about images ending with common formats (jpg and png)
if file.endswith(".png") or file.endswith(".jpg"):
# Open the image and scale down using LANCZOS (best scaling, poor performance)
tile = Image.open(self.open_dir.get() + "/" + file)
tile = tile.resize(
(self.tile_width.get(), self.tile_height.get()),
Image.LANCZOS)
# Paste the tile into the tileset
y_pos = int(column * self.tile_width.get())
x_pos = int(row * self.tile_height.get())
tileset.paste(tile, (y_pos, x_pos))
# Handle coordinate changes
column += 1
if column > tiles:
column = 0
row += 1
# Save the output to the same directory this script was run
outfile = self.output_dir.get() + "/tileset.png"
tileset.save(outfile, "png")
messagebox.showinfo("Complete", "Tileset saved to " + outfile)
def main(task_field,task_tree,progress):
print('here')
Head_data_file=open(repositroy_url+'/Head_data_file.txt','r')
state=''
state_name=''
task_field.config(state='normal')
task_field.replace(1.0,END,'Clearing neo4j nodes...')
task_field.config(state='disabled')
task_tree.config(state='normal')
task_tree.replace(1.0,END,'Working...')
task_tree.config(state='disabled')
graph.cypher.execute("MATCH(n) OPTIONAL MATCH(n)-[r]->() DELETE n,r")
global file_exit_flag
task_field.config(state='normal')
task_field.replace(1.0,END,'Graph database creation in progress...')
task_field.config(state='disabled')
progress_count=IntVar()
progress.config(mode='determinate',maximum=file_download_count,value=0,variable=progress_count)
graph.cypher.execute('MERGE(c:Country{country_name:"India",label_name:"Country"})')
country_name=graph.find_one("Country",'country_name',"India")
while file_exit_flag and not kill_flag:
Head_data_read=Head_data_file.readline()
if(Head_data_read!=''):
#print(Head_data_read)
#print(Head_data_read)
if(Head_data_read=='STATE\n') and not kill_flag:
Head_data_read=Head_data_file.readline()
state_name=Head_data_read.replace('\n','')
task_tree.config(state='normal')
task_tree.replace(1.0,END,'Updating database for state-'+state_name+'\n')
task_tree.config(state='disabled')
print('State-'+state_name)
#state=Node("State",state_name=state_name,label_name="State")
#graph.create(state,Relationship(country_name,"CONTAIN",0))
graph.cypher.execute('MERGE(s:State{state_name:"'+state_name+'",label_name:"State"})')
state=graph.find_one("State","state_name",state_name)
graph.create(Relationship(country_name,"CONTAIN",state))
else:
if(Head_data_read=='FILE NAME START HERE\n') and not kill_flag:
while(Head_data_read!='FILE NAME END HERE\n'):
Head_data_read=Head_data_file.readline()
if(Head_data_read!='FILE NAME END HERE\n'):
region=Head_data_read.replace('\n','')
task_tree.config(state='normal')
task_tree.insert(END,'Updating region-'+region+'\n')
print('Region-'+region)
region_file_name=Head_data_file.readline()
#print(region)#region_file_name.split('.csv')[0])
data_parser(region,region_file_name.split('.csv')[0],state,state_name,progress_count)
global count
count+=1
progress_count.set(count)
#print('done')
#Head_data_read=Head_data_file.readline()
else:
file_exit_flag=False
#data_parser(repositroy_url)
task_field.config(state='normal')
task_tree.config(state='normal')
task_field.replace(1.0,END,'Database creation is complete!')
task_tree.replace(1.0,END,'Database updated!')
task_field.config(state='disabled')
task_field.config(state='disabled')
#if __name__=='__main__':main()
class TreeView(object):
def __init__(self, *trees):
from math import sqrt, ceil
self._trees = trees
self._top = Tk()
self._top.title('NLTK')
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Control-q>', self.destroy)
cf = self._cframe = CanvasFrame(self._top)
self._top.bind('<Control-p>', self._cframe.print_to_file)
# Size is variable.
self._size = IntVar(self._top)
self._size.set(12)
bold = ('helvetica', -self._size.get(), 'bold')
helv = ('helvetica', -self._size.get())
# Lay the trees out in a square.
self._width = int(ceil(sqrt(len(trees))))
self._widgets = []
for i in range(len(trees)):
widget = TreeWidget(cf.canvas(), trees[i], node_font=bold,
leaf_color='#008040', node_color='#004080',
roof_color='#004040', roof_fill='white',
line_color='#004040', draggable=1,
leaf_font=helv)
widget.bind_click_trees(widget.toggle_collapsed)
self._widgets.append(widget)
cf.add_widget(widget, 0, 0)
self._layout()
self._cframe.pack(expand=1, fill='both')
self._init_menubar()
def _layout(self):
i = x = y = ymax = 0
width = self._width
for i in range(len(self._widgets)):
widget = self._widgets[i]
(oldx, oldy) = widget.bbox()[:2]
if i % width == 0:
y = ymax
x = 0
widget.move(x-oldx, y-oldy)
x = widget.bbox()[2] + 10
ymax = max(ymax, widget.bbox()[3] + 10)
def _init_menubar(self):
menubar = Menu(self._top)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Print to Postscript', underline=0,
command=self._cframe.print_to_file,
accelerator='Ctrl-p')
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-x')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
zoommenu = Menu(menubar, tearoff=0)
zoommenu.add_radiobutton(label='Tiny', variable=self._size,
underline=0, value=10, command=self.resize)
zoommenu.add_radiobutton(label='Small', variable=self._size,
underline=0, value=12, command=self.resize)
zoommenu.add_radiobutton(label='Medium', variable=self._size,
underline=0, value=14, command=self.resize)
zoommenu.add_radiobutton(label='Large', variable=self._size,
underline=0, value=28, command=self.resize)
zoommenu.add_radiobutton(label='Huge', variable=self._size,
underline=0, value=50, command=self.resize)
menubar.add_cascade(label='Zoom', underline=0, menu=zoommenu)
self._top.config(menu=menubar)
def resize(self, *e):
bold = ('helvetica', -self._size.get(), 'bold')
helv = ('helvetica', -self._size.get())
xspace = self._size.get()
yspace = self._size.get()
for widget in self._widgets:
widget['node_font'] = bold
widget['leaf_font'] = helv
widget['xspace'] = xspace
widget['yspace'] = yspace
if self._size.get() < 20: widget['line_width'] = 1
elif self._size.get() < 30: widget['line_width'] = 2
else: widget['line_width'] = 3
self._layout()
def destroy(self, *e):
if self._top is None: return
self._top.destroy()
self._top = None
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self._top.mainloop(*args, **kwargs)
class RecursiveDescentApp(object):
"""
A graphical tool for exploring the recursive descent parser. The tool
displays the parser's tree and the remaining text, and allows the
user to control the parser's operation. In particular, the user
can expand subtrees on the frontier, match tokens on the frontier
against the text, and backtrack. A "step" button simply steps
through the parsing process, performing the operations that
``RecursiveDescentParser`` would use.
"""
def __init__(self, grammar, sent, trace=0):
self._sent = sent
self._parser = SteppingRecursiveDescentParser(grammar, trace)
# Set up the main window.
self._top = Tk()
self._top.title('Recursive Descent Parser Application')
# Set up key bindings.
self._init_bindings()
# Initialize the fonts.
self._init_fonts(self._top)
# Animations. animating_lock is a lock to prevent the demo
# from performing new operations while it's animating.
self._animation_frames = IntVar(self._top)
self._animation_frames.set(5)
self._animating_lock = 0
self._autostep = 0
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_feedback(self._top)
self._init_grammar(self._top)
self._init_canvas(self._top)
# Initialize the parser.
self._parser.initialize(self._sent)
# Resize callback
self._canvas.bind('<Configure>', self._configure)
#########################################
## Initialization Helpers
#########################################
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = tkinter.font.Font(font=Button()["font"])
root.option_add("*Font", self._sysfont)
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(root)
self._size.set(self._sysfont.cget('size'))
self._boldfont = tkinter.font.Font(family='helvetica', weight='bold',
size=self._size.get())
self._font = tkinter.font.Font(family='helvetica',
size=self._size.get())
if self._size.get() < 0: big = self._size.get()-2
else: big = self._size.get()+2
self._bigfont = tkinter.font.Font(family='helvetica', weight='bold',
size=big)
def _init_grammar(self, parent):
# Grammar view.
self._prodframe = listframe = Frame(parent)
self._prodframe.pack(fill='both', side='left', padx=2)
self._prodlist_label = Label(self._prodframe, font=self._boldfont,
text='Available Expansions')
self._prodlist_label.pack()
self._prodlist = Listbox(self._prodframe, selectmode='single',
relief='groove', background='white',
foreground='#909090', font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._prodlist.pack(side='right', fill='both', expand=1)
self._productions = list(self._parser.grammar().productions())
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
self._prodlist.config(height=min(len(self._productions), 25))
# Add a scrollbar if there are more than 25 productions.
if len(self._productions) > 25:
listscroll = Scrollbar(self._prodframe,
orient='vertical')
self._prodlist.config(yscrollcommand = listscroll.set)
listscroll.config(command=self._prodlist.yview)
listscroll.pack(side='left', fill='y')
# If they select a production, apply it.
self._prodlist.bind('<<ListboxSelect>>', self._prodlist_select)
def _init_bindings(self):
# Key bindings are a good thing.
self._top.bind('<Control-q>', self.destroy)
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Escape>', self.destroy)
self._top.bind('e', self.expand)
#self._top.bind('<Alt-e>', self.expand)
#self._top.bind('<Control-e>', self.expand)
self._top.bind('m', self.match)
self._top.bind('<Alt-m>', self.match)
self._top.bind('<Control-m>', self.match)
self._top.bind('b', self.backtrack)
self._top.bind('<Alt-b>', self.backtrack)
self._top.bind('<Control-b>', self.backtrack)
self._top.bind('<Control-z>', self.backtrack)
self._top.bind('<BackSpace>', self.backtrack)
self._top.bind('a', self.autostep)
#self._top.bind('<Control-a>', self.autostep)
self._top.bind('<Control-space>', self.autostep)
self._top.bind('<Control-c>', self.cancel_autostep)
self._top.bind('<space>', self.step)
self._top.bind('<Delete>', self.reset)
self._top.bind('<Control-p>', self.postscript)
#self._top.bind('<h>', self.help)
#self._top.bind('<Alt-h>', self.help)
self._top.bind('<Control-h>', self.help)
self._top.bind('<F1>', self.help)
#self._top.bind('<g>', self.toggle_grammar)
#self._top.bind('<Alt-g>', self.toggle_grammar)
#self._top.bind('<Control-g>', self.toggle_grammar)
self._top.bind('<Control-g>', self.edit_grammar)
self._top.bind('<Control-t>', self.edit_sentence)
def _init_buttons(self, parent):
# Set up the frames.
self._buttonframe = buttonframe = Frame(parent)
buttonframe.pack(fill='none', side='bottom', padx=3, pady=2)
Button(buttonframe, text='Step',
background='#90c0d0', foreground='black',
command=self.step,).pack(side='left')
Button(buttonframe, text='Autostep',
background='#90c0d0', foreground='black',
command=self.autostep,).pack(side='left')
Button(buttonframe, text='Expand', underline=0,
background='#90f090', foreground='black',
command=self.expand).pack(side='left')
Button(buttonframe, text='Match', underline=0,
background='#90f090', foreground='black',
command=self.match).pack(side='left')
Button(buttonframe, text='Backtrack', underline=0,
background='#f0a0a0', foreground='black',
command=self.backtrack).pack(side='left')
# Replace autostep...
# self._autostep_button = Button(buttonframe, text='Autostep',
# underline=0, command=self.autostep)
# self._autostep_button.pack(side='left')
def _configure(self, event):
self._autostep = 0
(x1, y1, x2, y2) = self._cframe.scrollregion()
y2 = event.height - 6
self._canvas['scrollregion'] = '%d %d %d %d' % (x1,y1,x2,y2)
self._redraw()
def _init_feedback(self, parent):
self._feedbackframe = feedbackframe = Frame(parent)
feedbackframe.pack(fill='x', side='bottom', padx=3, pady=3)
self._lastoper_label = Label(feedbackframe, text='Last Operation:',
font=self._font)
self._lastoper_label.pack(side='left')
lastoperframe = Frame(feedbackframe, relief='sunken', border=1)
lastoperframe.pack(fill='x', side='right', expand=1, padx=5)
self._lastoper1 = Label(lastoperframe, foreground='#007070',
background='#f0f0f0', font=self._font)
self._lastoper2 = Label(lastoperframe, anchor='w', width=30,
foreground='#004040', background='#f0f0f0',
font=self._font)
self._lastoper1.pack(side='left')
self._lastoper2.pack(side='left', fill='x', expand=1)
def _init_canvas(self, parent):
self._cframe = CanvasFrame(parent, background='white',
#width=525, height=250,
closeenough=10,
border=2, relief='sunken')
self._cframe.pack(expand=1, fill='both', side='top', pady=2)
canvas = self._canvas = self._cframe.canvas()
# Initially, there's no tree or text
self._tree = None
self._textwidgets = []
self._textline = None
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Reset Parser', underline=0,
command=self.reset, accelerator='Del')
filemenu.add_command(label='Print to Postscript', underline=0,
command=self.postscript, accelerator='Ctrl-p')
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-x')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label='Edit Grammar', underline=5,
command=self.edit_grammar,
accelerator='Ctrl-g')
editmenu.add_command(label='Edit Text', underline=5,
command=self.edit_sentence,
accelerator='Ctrl-t')
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
rulemenu = Menu(menubar, tearoff=0)
rulemenu.add_command(label='Step', underline=1,
command=self.step, accelerator='Space')
rulemenu.add_separator()
rulemenu.add_command(label='Match', underline=0,
command=self.match, accelerator='Ctrl-m')
rulemenu.add_command(label='Expand', underline=0,
command=self.expand, accelerator='Ctrl-e')
rulemenu.add_separator()
rulemenu.add_command(label='Backtrack', underline=0,
command=self.backtrack, accelerator='Ctrl-b')
menubar.add_cascade(label='Apply', underline=0, menu=rulemenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_checkbutton(label="Show Grammar", underline=0,
variable=self._show_grammar,
command=self._toggle_grammar)
viewmenu.add_separator()
viewmenu.add_radiobutton(label='Tiny', variable=self._size,
underline=0, value=10, command=self.resize)
viewmenu.add_radiobutton(label='Small', variable=self._size,
underline=0, value=12, command=self.resize)
viewmenu.add_radiobutton(label='Medium', variable=self._size,
underline=0, value=14, command=self.resize)
viewmenu.add_radiobutton(label='Large', variable=self._size,
underline=0, value=18, command=self.resize)
viewmenu.add_radiobutton(label='Huge', variable=self._size,
underline=0, value=24, command=self.resize)
menubar.add_cascade(label='View', underline=0, menu=viewmenu)
animatemenu = Menu(menubar, tearoff=0)
animatemenu.add_radiobutton(label="No Animation", underline=0,
variable=self._animation_frames,
value=0)
animatemenu.add_radiobutton(label="Slow Animation", underline=0,
variable=self._animation_frames,
value=10, accelerator='-')
animatemenu.add_radiobutton(label="Normal Animation", underline=0,
variable=self._animation_frames,
value=5, accelerator='=')
animatemenu.add_radiobutton(label="Fast Animation", underline=0,
variable=self._animation_frames,
value=2, accelerator='+')
menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0,
command=self.about)
helpmenu.add_command(label='Instructions', underline=0,
command=self.help, accelerator='F1')
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
#########################################
## Helper
#########################################
def _get(self, widget, treeloc):
for i in treeloc: widget = widget.subtrees()[i]
if isinstance(widget, TreeSegmentWidget):
widget = widget.label()
return widget
#########################################
## Main draw procedure
#########################################
def _redraw(self):
canvas = self._canvas
# Delete the old tree, widgets, etc.
if self._tree is not None:
self._cframe.destroy_widget(self._tree)
for twidget in self._textwidgets:
self._cframe.destroy_widget(twidget)
if self._textline is not None:
self._canvas.delete(self._textline)
# Draw the tree.
helv = ('helvetica', -self._size.get())
bold = ('helvetica', -self._size.get(), 'bold')
attribs = {'tree_color': '#000000', 'tree_width': 2,
'node_font': bold, 'leaf_font': helv,}
tree = self._parser.tree()
self._tree = tree_to_treesegment(canvas, tree, **attribs)
self._cframe.add_widget(self._tree, 30, 5)
# Draw the text.
helv = ('helvetica', -self._size.get())
bottom = y = self._cframe.scrollregion()[3]
self._textwidgets = [TextWidget(canvas, word, font=self._font)
for word in self._sent]
for twidget in self._textwidgets:
self._cframe.add_widget(twidget, 0, 0)
twidget.move(0, bottom-twidget.bbox()[3]-5)
y = min(y, twidget.bbox()[1])
# Draw a line over the text, to separate it from the tree.
self._textline = canvas.create_line(-5000, y-5, 5000, y-5, dash='.')
# Highlight appropriate nodes.
self._highlight_nodes()
self._highlight_prodlist()
# Make sure the text lines up.
self._position_text()
def _redraw_quick(self):
# This should be more-or-less sufficient after an animation.
self._highlight_nodes()
self._highlight_prodlist()
self._position_text()
def _highlight_nodes(self):
# Highlight the list of nodes to be checked.
bold = ('helvetica', -self._size.get(), 'bold')
for treeloc in self._parser.frontier()[:1]:
self._get(self._tree, treeloc)['color'] = '#20a050'
self._get(self._tree, treeloc)['font'] = bold
for treeloc in self._parser.frontier()[1:]:
self._get(self._tree, treeloc)['color'] = '#008080'
def _highlight_prodlist(self):
# Highlight the productions that can be expanded.
# Boy, too bad tkinter doesn't implement Listbox.itemconfig;
# that would be pretty useful here.
self._prodlist.delete(0, 'end')
expandable = self._parser.expandable_productions()
untried = self._parser.untried_expandable_productions()
productions = self._productions
for index in range(len(productions)):
if productions[index] in expandable:
if productions[index] in untried:
self._prodlist.insert(index, ' %s' % productions[index])
else:
self._prodlist.insert(index, ' %s (TRIED)' %
productions[index])
self._prodlist.selection_set(index)
else:
self._prodlist.insert(index, ' %s' % productions[index])
def _position_text(self):
# Line up the text widgets that are matched against the tree
numwords = len(self._sent)
num_matched = numwords - len(self._parser.remaining_text())
leaves = self._tree_leaves()[:num_matched]
xmax = self._tree.bbox()[0]
for i in range(0, len(leaves)):
widget = self._textwidgets[i]
leaf = leaves[i]
widget['color'] = '#006040'
leaf['color'] = '#006040'
widget.move(leaf.bbox()[0] - widget.bbox()[0], 0)
xmax = widget.bbox()[2] + 10
# Line up the text widgets that are not matched against the tree.
for i in range(len(leaves), numwords):
widget = self._textwidgets[i]
widget['color'] = '#a0a0a0'
widget.move(xmax - widget.bbox()[0], 0)
xmax = widget.bbox()[2] + 10
# If we have a complete parse, make everything green :)
if self._parser.currently_complete():
for twidget in self._textwidgets:
twidget['color'] = '#00a000'
# Move the matched leaves down to the text.
for i in range(0, len(leaves)):
widget = self._textwidgets[i]
leaf = leaves[i]
dy = widget.bbox()[1] - leaf.bbox()[3] - 10.0
dy = max(dy, leaf.parent().label().bbox()[3] - leaf.bbox()[3] + 10)
leaf.move(0, dy)
def _tree_leaves(self, tree=None):
if tree is None: tree = self._tree
if isinstance(tree, TreeSegmentWidget):
leaves = []
for child in tree.subtrees(): leaves += self._tree_leaves(child)
return leaves
else:
return [tree]
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
self._autostep = 0
if self._top is None: return
self._top.destroy()
self._top = None
def reset(self, *e):
self._autostep = 0
self._parser.initialize(self._sent)
self._lastoper1['text'] = 'Reset Application'
self._lastoper2['text'] = ''
self._redraw()
def autostep(self, *e):
if self._animation_frames.get() == 0:
self._animation_frames.set(2)
if self._autostep:
self._autostep = 0
else:
self._autostep = 1
self._step()
def cancel_autostep(self, *e):
#self._autostep_button['text'] = 'Autostep'
self._autostep = 0
# Make sure to stop auto-stepping if we get any user input.
def step(self, *e): self._autostep = 0; self._step()
def match(self, *e): self._autostep = 0; self._match()
def expand(self, *e): self._autostep = 0; self._expand()
def backtrack(self, *e): self._autostep = 0; self._backtrack()
def _step(self):
if self._animating_lock: return
# Try expanding, matching, and backtracking (in that order)
if self._expand(): pass
elif self._parser.untried_match() and self._match(): pass
elif self._backtrack(): pass
else:
self._lastoper1['text'] = 'Finished'
self._lastoper2['text'] = ''
self._autostep = 0
# Check if we just completed a parse.
if self._parser.currently_complete():
self._autostep = 0
self._lastoper2['text'] += ' [COMPLETE PARSE]'
def _expand(self, *e):
if self._animating_lock: return
old_frontier = self._parser.frontier()
rv = self._parser.expand()
if rv is not None:
self._lastoper1['text'] = 'Expand:'
self._lastoper2['text'] = rv
self._prodlist.selection_clear(0, 'end')
index = self._productions.index(rv)
self._prodlist.selection_set(index)
self._animate_expand(old_frontier[0])
return 1
else:
self._lastoper1['text'] = 'Expand:'
self._lastoper2['text'] = '(all expansions tried)'
return 0
def _match(self, *e):
if self._animating_lock: return
old_frontier = self._parser.frontier()
rv = self._parser.match()
if rv is not None:
self._lastoper1['text'] = 'Match:'
self._lastoper2['text'] = rv
self._animate_match(old_frontier[0])
return 1
else:
self._lastoper1['text'] = 'Match:'
self._lastoper2['text'] = '(failed)'
return 0
def _backtrack(self, *e):
if self._animating_lock: return
if self._parser.backtrack():
elt = self._parser.tree()
for i in self._parser.frontier()[0]:
elt = elt[i]
self._lastoper1['text'] = 'Backtrack'
self._lastoper2['text'] = ''
if isinstance(elt, Tree):
self._animate_backtrack(self._parser.frontier()[0])
else:
self._animate_match_backtrack(self._parser.frontier()[0])
return 1
else:
self._autostep = 0
self._lastoper1['text'] = 'Finished'
self._lastoper2['text'] = ''
return 0
def about(self, *e):
ABOUT = ("NLTK Recursive Descent Parser Application\n"+
"Written by Edward Loper")
TITLE = 'About: Recursive Descent Parser Application'
try:
from tkinter.messagebox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
def help(self, *e):
self._autostep = 0
# The default font's not very legible; try using 'fixed' instead.
try:
ShowText(self._top, 'Help: Recursive Descent Parser Application',
(__doc__ or '').strip(), width=75, font='fixed')
except:
ShowText(self._top, 'Help: Recursive Descent Parser Application',
(__doc__ or '').strip(), width=75)
def postscript(self, *e):
self._autostep = 0
self._cframe.print_to_file()
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self._top.mainloop(*args, **kwargs)
def resize(self, size=None):
if size is not None: self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._boldfont.configure(size=-(abs(size)))
self._sysfont.configure(size=-(abs(size)))
self._bigfont.configure(size=-(abs(size+2)))
self._redraw()
#########################################
## Expand Production Selection
#########################################
def _toggle_grammar(self, *e):
if self._show_grammar.get():
self._prodframe.pack(fill='both', side='left', padx=2,
after=self._feedbackframe)
self._lastoper1['text'] = 'Show Grammar'
else:
self._prodframe.pack_forget()
self._lastoper1['text'] = 'Hide Grammar'
self._lastoper2['text'] = ''
# def toggle_grammar(self, *e):
# self._show_grammar = not self._show_grammar
# if self._show_grammar:
# self._prodframe.pack(fill='both', expand='y', side='left',
# after=self._feedbackframe)
# self._lastoper1['text'] = 'Show Grammar'
# else:
# self._prodframe.pack_forget()
# self._lastoper1['text'] = 'Hide Grammar'
# self._lastoper2['text'] = ''
def _prodlist_select(self, event):
selection = self._prodlist.curselection()
if len(selection) != 1: return
index = int(selection[0])
old_frontier = self._parser.frontier()
production = self._parser.expand(self._productions[index])
if production:
self._lastoper1['text'] = 'Expand:'
self._lastoper2['text'] = production
self._prodlist.selection_clear(0, 'end')
self._prodlist.selection_set(index)
self._animate_expand(old_frontier[0])
else:
# Reset the production selections.
self._prodlist.selection_clear(0, 'end')
for prod in self._parser.expandable_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
#########################################
## Animation
#########################################
def _animate_expand(self, treeloc):
oldwidget = self._get(self._tree, treeloc)
oldtree = oldwidget.parent()
top = not isinstance(oldtree.parent(), TreeSegmentWidget)
tree = self._parser.tree()
for i in treeloc:
tree = tree[i]
widget = tree_to_treesegment(self._canvas, tree,
node_font=self._boldfont,
leaf_color='white',
tree_width=2, tree_color='white',
node_color='white',
leaf_font=self._font)
widget.label()['color'] = '#20a050'
(oldx, oldy) = oldtree.label().bbox()[:2]
(newx, newy) = widget.label().bbox()[:2]
widget.move(oldx-newx, oldy-newy)
if top:
self._cframe.add_widget(widget, 0, 5)
widget.move(30-widget.label().bbox()[0], 0)
self._tree = widget
else:
oldtree.parent().replace_child(oldtree, widget)
# Move the children over so they don't overlap.
# Line the children up in a strange way.
if widget.subtrees():
dx = (oldx + widget.label().width()/2 -
widget.subtrees()[0].bbox()[0]/2 -
widget.subtrees()[0].bbox()[2]/2)
for subtree in widget.subtrees(): subtree.move(dx, 0)
self._makeroom(widget)
if top:
self._cframe.destroy_widget(oldtree)
else:
oldtree.destroy()
colors = ['gray%d' % (10*int(10*x/self._animation_frames.get()))
for x in range(self._animation_frames.get(),0,-1)]
# Move the text string down, if necessary.
dy = widget.bbox()[3] + 30 - self._canvas.coords(self._textline)[1]
if dy > 0:
for twidget in self._textwidgets: twidget.move(0, dy)
self._canvas.move(self._textline, 0, dy)
self._animate_expand_frame(widget, colors)
def _makeroom(self, treeseg):
"""
Make sure that no sibling tree bbox's overlap.
"""
parent = treeseg.parent()
if not isinstance(parent, TreeSegmentWidget): return
index = parent.subtrees().index(treeseg)
# Handle siblings to the right
rsiblings = parent.subtrees()[index+1:]
if rsiblings:
dx = treeseg.bbox()[2] - rsiblings[0].bbox()[0] + 10
for sibling in rsiblings: sibling.move(dx, 0)
# Handle siblings to the left
if index > 0:
lsibling = parent.subtrees()[index-1]
dx = max(0, lsibling.bbox()[2] - treeseg.bbox()[0] + 10)
treeseg.move(dx, 0)
# Keep working up the tree.
self._makeroom(parent)
def _animate_expand_frame(self, widget, colors):
if len(colors) > 0:
self._animating_lock = 1
widget['color'] = colors[0]
for subtree in widget.subtrees():
if isinstance(subtree, TreeSegmentWidget):
subtree.label()['color'] = colors[0]
else:
subtree['color'] = colors[0]
self._top.after(50, self._animate_expand_frame,
widget, colors[1:])
else:
widget['color'] = 'black'
for subtree in widget.subtrees():
if isinstance(subtree, TreeSegmentWidget):
subtree.label()['color'] = 'black'
else:
subtree['color'] = 'black'
self._redraw_quick()
widget.label()['color'] = 'black'
self._animating_lock = 0
if self._autostep: self._step()
def _animate_backtrack(self, treeloc):
# Flash red first, if we're animating.
if self._animation_frames.get() == 0: colors = []
else: colors = ['#a00000', '#000000', '#a00000']
colors += ['gray%d' % (10*int(10*x/(self._animation_frames.get())))
for x in range(1, self._animation_frames.get()+1)]
widgets = [self._get(self._tree, treeloc).parent()]
for subtree in widgets[0].subtrees():
if isinstance(subtree, TreeSegmentWidget):
widgets.append(subtree.label())
else:
widgets.append(subtree)
self._animate_backtrack_frame(widgets, colors)
def _animate_backtrack_frame(self, widgets, colors):
if len(colors) > 0:
self._animating_lock = 1
for widget in widgets: widget['color'] = colors[0]
self._top.after(50, self._animate_backtrack_frame,
widgets, colors[1:])
else:
for widget in widgets[0].subtrees():
widgets[0].remove_child(widget)
widget.destroy()
self._redraw_quick()
self._animating_lock = 0
if self._autostep: self._step()
def _animate_match_backtrack(self, treeloc):
widget = self._get(self._tree, treeloc)
node = widget.parent().label()
dy = (1.0 * (node.bbox()[3] - widget.bbox()[1] + 14) /
max(1, self._animation_frames.get()))
self._animate_match_backtrack_frame(self._animation_frames.get(),
widget, dy)
def _animate_match(self, treeloc):
widget = self._get(self._tree, treeloc)
dy = ((self._textwidgets[0].bbox()[1] - widget.bbox()[3] - 10.0) /
max(1, self._animation_frames.get()))
self._animate_match_frame(self._animation_frames.get(), widget, dy)
def _animate_match_frame(self, frame, widget, dy):
if frame > 0:
self._animating_lock = 1
widget.move(0, dy)
self._top.after(10, self._animate_match_frame,
frame-1, widget, dy)
else:
widget['color'] = '#006040'
self._redraw_quick()
self._animating_lock = 0
if self._autostep: self._step()
def _animate_match_backtrack_frame(self, frame, widget, dy):
if frame > 0:
self._animating_lock = 1
widget.move(0, dy)
self._top.after(10, self._animate_match_backtrack_frame,
frame-1, widget, dy)
else:
widget.parent().remove_child(widget)
widget.destroy()
self._animating_lock = 0
if self._autostep: self._step()
def edit_grammar(self, *e):
CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
def set_grammar(self, grammar):
self._parser.set_grammar(grammar)
self._productions = list(grammar.productions())
self._prodlist.delete(0, 'end')
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
def edit_sentence(self, *e):
sentence = " ".join(self._sent)
title = 'Edit Text'
instr = 'Enter a new sentence to parse.'
EntryDialog(self._top, sentence, instr, self.set_sentence, title)
def set_sentence(self, sentence):
self._sent = sentence.split() #[XX] use tagged?
self.reset()
class App:
def __init__(self, master):
self.initDone = False
self.initGuiData()
self.master = master
self.master.title("Hot wire cutter (version 0.1.f)")
self.nb = ttk.Notebook(self.master)
self.nb.enable_traversal()
self.queueTkSendMsg = queue.Queue()
self._thread_cmd = threading.Thread(target=self.execCmd,
args=(self.queueTkSendMsg, "rien"))
self._thread_cmd.setDaemon(
True
) #added by mstrens in order to kill automatically the thread when program close
self._thread_cmd.start()
self.queueTkGetMsg = queue.Queue()
self.tGrbl = Grbl(
self.nb, self, self.queueTkGetMsg
) #create an instance of Gerbil in order to communicate with GRBL
# queue is used to get message back from interface
self.tProfil = Profil(self.nb,
self) #add a tab for selecting the profile
self.tTransform = Transform(self.nb,
self) #add a tab to modify the profile
self.tBloc = Bloc(self.nb,
self) #add a tab to design the wing and the bloc
self.tMargin = Margin(self.nb,
self) #add a tab to design the vertical margin
self.tMaterial = Material(self.nb,
self) #add a tab to specify the material
self.tGuillotine = Guillotine(
self.nb, self, self.queueTkSendMsg) #add a tab to make guillotine
self.tCut = Cut(self.nb, self) #add a tab to cut
self.tTable = Table(self.nb,
self) #add a tab to define the Table (size)
self.nb.pack()
atexit.register(self.tGrbl.disconnectToGrbl)
self.initDone = True
self.running = True
self.periodicCall()
self.validateAllOn = True
self.validateAll(0) #validate all
#self.tBloc.toTableRight.set(self.tTable.dY.get() - self.tTable.lG.get() - self.tTable.lD.get() - self.tBloc.toTableLeft.get() - self.tBloc.lX.get() )
#print (self.tBloc.toTableRight.get())
def execCmd(self, queue, rien):
"""
thread in order to execute task outside the main tkhtread (when they can take to much time e.g.)
get Cmd via a queue queueTkSendMsg
used e.g. when a button is clicked in Thinker
not sure it is really requested for this application
"""
while True:
msg = queue.get()
if msg == "Connect":
self.tGrbl.connectToGrbl()
self.tGuillotine.updateBtnState()
elif msg == "Disconnect":
self.tGrbl.disconnectToGrbl()
self.tGuillotine.updateBtnState()
def processIncoming(self):
"""Handle all messages currently in the queue, if any."""
while self.queueTkGetMsg.qsize():
try:
msg = self.queueTkGetMsg.get(0) + "\n"
# Check contents of message and do whatever is needed. As a
# simple test, print it (in real life, you would
# suitably update the GUI's display in a richer fashion).
#print("getting a message in queue",msg)
self.tGuillotine.msgBox.insert(END, msg)
except queue.Empty:
# just on general principles, although we don't
# expect this branch to be taken in this case
pass
def periodicCall(self):
"""
Check every 200 ms if there is something new in the queue.
execute it when tkinter is sleeping
"""
self.processIncoming()
if not self.running:
# This is the brutal stop of the system. You may want to do
# some cleanup before actually shutting it down.
#import sys
#sys.exit(1)
pass
self.master.after(200, self.periodicCall)
#def calback(self, a , b, c):
# print("do something")
def initGuiData(self):
#not saved with config
self.validateAllOn = False
self.warningMsg = StringVar(value="")
self.cutMsg = StringVar(value="")
self.limMinX = DoubleVar(
value='0.0') # min value to plot on X axis (not saved in .ini)
self.limMinY = DoubleVar(
value='0.0') # min value to plot on Y axis (not saved in .ini)
self.zoom = StringVar(value="1X")
#self.zoom.trace('w', self.calback)
self.configUploadFileName = None
self.tableUploadFileName = None
self.tableSaveFileName = None
self.materialUploadFileName = None
self.materialSaveFileName = None
self.connected = StringVar(value="OFF")
self.grblStatus = StringVar(value="Not connected")
self.grblXG = DoubleVar(value="0") #grbl horizontal left pos
self.grblYG = DoubleVar(value="0") #grbl vertical left pos
self.grblXD = DoubleVar(value="0") #grbl horizontal right pos
self.grblYD = DoubleVar(value="0") #grbl vertical right pos
self.grblF = DoubleVar(value="0") #grbl feed rate
self.grblS = DoubleVar(value="0") #grbl heating
self.gMoveAxis = StringVar(
value="Both") # grbl axis to move (left,right)
self.gMoveDist = DoubleVar(value="10") #grbl mistance to move
# Transformed profil based on original (filled by validateTransform) ; is an numpy array and not a usual List
#take care of Chord, but not of position of block and margins...
self.tRootX = np.array([])
self.tRootY = np.array([])
self.tRootS = []
self.tTipX = np.array([])
self.tTipY = np.array([])
self.tTipS = []
# Position profil (in a numpy array) based on "t" profile and position of block and margins...
self.pRootX = np.array([])
self.pRootY = np.array([])
self.pRootS = []
self.pTipX = np.array([])
self.pTipY = np.array([])
self.pTipS = []
#guillotine
self.gVSpeedNoCut = DoubleVar(value='5')
self.gHSpeedNoCut = DoubleVar(value='5')
self.gCuttingSpeed = DoubleVar(value='5')
self.gApplyCalculatedHeating = IntVar(value='1')
self.gHeating = DoubleVar(value='50')
self.gType = StringVar(value="Vertical")
self.gCuttingWhile = StringVar(value="Both")
#self.gHeatWhileArming = IntVar(value='1')
self.gVDist = DoubleVar(value='10')
self.gHDist = DoubleVar(value='10')
#saved in config
#profil
self.oRootX = [
] # original profil : usual python List ; saved in the files
self.oRootY = []
self.oRootS = [] # synchro points
self.oTipX = []
self.oTipY = []
self.oTipS = []
self.nameRoot = StringVar(value="")
self.nameTip = StringVar(value="")
#transform
self.cRoot = DoubleVar(value='200.0') #chord
self.cTip = DoubleVar(value='150.0') #chord
self.incidenceRoot = DoubleVar(value='0.0')
self.thicknessRoot = DoubleVar(value='100.0')
self.vInvertRoot = IntVar(value='0')
self.incidenceTip = DoubleVar(value='0.0')
self.thicknessTip = DoubleVar(value='100.0')
self.vInvertTip = IntVar(value='0')
self.covering = DoubleVar(value='0.0')
self.keepChord = IntVar(value='0')
self.smooth = IntVar(value='0')
self.nbrPoints = IntVar(value='50')
self.repartition = DoubleVar(value='2.0')
self.reducePoints = IntVar(value='0')
#bloc
self.blocLX = DoubleVar(value='600.0') #Length = envergure
self.blocHZ = DoubleVar(value='50.0') #height of the bloc
self.fLeading = DoubleVar(value='10.0') #fleche
self.fTrailing = DoubleVar(
value='-30'
) #self.cRoot.get() - self.cTip.get() - self.fLeading.get()) #calculated
self.mLeading = DoubleVar(value='5.0')
self.mTrailingRoot = DoubleVar(value='10.0')
self.mTrailingTip = DoubleVar(value='10.0')
self.leftRightWing = StringVar(value='Left')
self.blocPosition = StringVar(value='Left') #Left or Right position
self.blocToTableLeft = DoubleVar(
value='100.0') #calculated but depend on bloc position
self.blocToTableRight = DoubleVar(
value='10.0') #calculated but depend on bloc position
self.blocToTableTrailingRoot = IntVar(value='50')
self.blocToTableTrailingTip = IntVar(value='50') #calculated
self.blocToTableLeadingRoot = IntVar(value='50') #calculated
self.blocToTableLeadingTip = IntVar(value='50') #calculated
#margin
self.hTrailingRoot = DoubleVar(value='10.0')
self.hTrailingTip = DoubleVar(value='10.0') #calculated
self.hLeadingRoot = DoubleVar(value='10.0') #calculated
self.hLeadingTip = DoubleVar(value='10.0') #calculated
self.hMaxRoot = DoubleVar(value='10.0') #calculated
self.hMaxTip = DoubleVar(value='10.0') #calculated
self.hMinRoot = DoubleVar(value='10.0') #calculated
self.hMinTip = DoubleVar(value='10.0') #calculated
self.hOffset = DoubleVar(value='10.0') #heigh of the base of the bloc
self.alignProfil = StringVar(value="Trailing")
self.hProfil = DoubleVar(
value='20.0') #heigh of the profile in the bloc
self.angleInRoot = DoubleVar(value='0.0')
self.angleInTip = DoubleVar(value='0.0')
self.angleOutRoot = DoubleVar(value='0.0')
self.angleOutTip = DoubleVar(value='0.0')
"""
self.hMaxRootNorm = 0
self.hMinRootNorm = 0
self.hLeadingRootNorm = 0
self.hMaxTipNorm = 0
self.hMinTipNorm = 0
self.hLeadingTipNorm = 0
"""
#Material
self.mSpeedHigh = DoubleVar(value='10.0') #speed max
self.mSpeedHalf = DoubleVar(value='5.0') #speed min
self.mSpeedLow = DoubleVar(value='1.0') #speed min
self.mRadSpHigh = DoubleVar(value='0.9') #Radiance at high max
self.mRadSpHalf = DoubleVar(value='1.5') #Radiance at half speed
self.mHeatSpHigh = IntVar(value='90') #Heat at High speed
self.mHeatSpLow = IntVar(value='40') #Heat at low speed
self.mName = StringVar(value="No material name")
#table
self.tableYY = DoubleVar(value='1000.0') # distance between 2 axis
self.tableYG = DoubleVar(
value='20.0') #distance between left Y axis and left table edge
self.tableYD = DoubleVar(value='20.0') # same on the rigth side
self.cMaxY = DoubleVar(value='500.0') # max course in Y
self.cMaxZ = DoubleVar(value='200.0') # max course in Z (height)
self.vMaxY = DoubleVar(value='10.0') # max speed in Y
self.vMaxZ = DoubleVar(value='5.0') # max speed in Z (height)
self.tHeatingMax = DoubleVar(value='100.0') # max heating
self.tName = StringVar(value="No table name")
#self.tComPort = StringVar(value="Select a Com port")
self.tComPort = StringVar(value="COM6")
self.tBaudrate = StringVar(value="115200")
self.tPreHeat = DoubleVar(value='5.0') # delay between Heat and move
self.tPostHeat = DoubleVar(value='5.0') # delay between Move and Heat
#cut
self.vCut = DoubleVar(
value='2.0'
) # max speed for cutting (on root or tip depending the longest)
self.gCodeStart1 = StringVar(value="")
self.gCodeStart2 = StringVar(value="")
self.gCodeStart3 = StringVar(value="")
self.gCodeStart4 = StringVar(value="")
self.gCodeEnd1 = StringVar(value="")
self.gCodeEnd2 = StringVar(value="")
self.gCodeEnd3 = StringVar(value="")
self.gCodeEnd4 = StringVar(value="")
self.gCodeLetters = StringVar(value="XYZA")
#self.validatePart()
def uploadConfig(self):
#global configUploadFileName
#configUploadFileName = filedialog.askopenfilename(initialdir="C:/Data/",
self.configUploadFileName = filedialog.askopenfilename(\
filetypes =(("Ini files", "*.ini"),("All files","*.*")),
title = "Choose a file."
)
if len(self.configUploadFileName) > 0:
self.validateAllOn = False
#config.read('config.ini')
config = configparser.ConfigParser()
config.add_section("Profil")
config.add_section("Transform")
config.add_section("Bloc")
config.add_section("Material")
config.add_section("Table")
config.add_section("Cut")
config.add_section("Guillotine")
config.read(self.configUploadFileName)
self.oRootX = stringToListOfFloat(config.get("Profil", "RootX"))
self.oRootY = stringToListOfFloat(config.get("Profil", "RootY"))
self.oRootS = stringToListOfFloat(config.get("Profil", "RootS"))
self.oTipX = stringToListOfFloat(config.get("Profil", "TipX"))
self.oTipY = stringToListOfFloat(config.get("Profil", "TipY"))
self.oTipS = stringToListOfFloat(config.get("Profil", "TipS"))
self.nameRoot.set(value=config.get("Profil", "nameRoot"))
self.nameTip.set(value=config.get("Profil", "nameTip"))
self.cRoot.set(value=config.getfloat("Transform", "cRoot"))
self.cTip.set(value=config.getfloat("Transform", "cTip"))
self.incidenceRoot.set(
value=config.getfloat("Transform", "incidenceRoot"))
self.thicknessRoot.set(
value=config.getfloat("Transform", "thicknessRoot"))
self.vInvertRoot.set(
value=config.getint("Transform", "vInvertRoot"))
self.incidenceTip.set(
value=config.getfloat("Transform", "incidenceTip"))
self.thicknessTip.set(
value=config.getfloat("Transform", "thicknessTip"))
self.vInvertTip.set(value=config.getint("Transform", "vInvertTip"))
self.covering.set(value=config.getfloat("Transform", "covering"))
self.keepChord.set(value=config.getint("Transform", "keepChord"))
self.smooth.set(value=config.getint("Transform", "smooth"))
self.nbrPoints.set(value=config.getint("Transform", "nbrPoints"))
self.repartition.set(
value=config.getfloat("Transform", "repartition"))
self.reducePoints.set(
value=config.getint("Transform", "reducePoints"))
self.blocLX.set(value=config.getfloat("Bloc", "blocLX"))
self.blocHZ.set(value=config.getfloat("Bloc", "blocHZ"))
self.fLeading.set(value=config.getfloat("Bloc", "fLeading"))
self.mLeading.set(value=config.getfloat("Bloc", "mLeading"))
self.mTrailingRoot.set(
value=config.getfloat("Bloc", "mTrailingRoot"))
self.mTrailingTip.set(
value=config.getfloat("Bloc", "mTrailingTip"))
self.leftRightWing.set(value=config.get("Bloc", "leftRightWing"))
self.blocPosition.set(value=config.get("Bloc", "blocPosition"))
self.blocToTableLeft.set(
value=config.getfloat("Bloc", "blocToTableLeft"))
self.blocToTableRight.set(
value=config.getfloat("Bloc", "blocToTableRight"))
self.blocToTableTrailingRoot.set(
value=config.getint("Bloc", "blocToTableTrailingRoot"))
self.blocToTableTrailingTip.set(
value=config.getint("Bloc", "blocToTableTrailingTip"))
self.blocToTableLeadingRoot.set(
value=config.getint("Bloc", "blocToTableLeadingRoot"))
self.blocToTableLeadingTip.set(
value=config.getint("Bloc", "blocToTableLeadingTip"))
self.hTrailingRoot.set(
value=config.getfloat("Bloc", "hTrailingRoot"))
self.hTrailingTip.set(
value=config.getfloat("Bloc", "hTrailingTip"))
self.hLeadingRoot.set(
value=config.getfloat("Bloc", "hLeadingRoot"))
self.hLeadingTip.set(value=config.getfloat("Bloc", "hLeadingTip"))
self.hMaxRoot.set(value=config.getfloat("Bloc", "hMaxRoot"))
self.hMaxTip.set(value=config.getfloat("Bloc", "hMaxTip"))
self.hMinRoot.set(value=config.getfloat("Bloc", "hMinRoot"))
self.hMinTip.set(value=config.getfloat("Bloc", "hMinTip"))
self.hOffset.set(value=config.getfloat("Bloc", "hOffset"))
self.alignProfil.set(value=config.get("Bloc", "alignProfil"))
self.hProfil.set(value=config.get("Bloc", "hProfil"))
try:
self.angleInRoot.set(
value=config.getfloat("Bloc", "angleInRoot"))
self.angleInTip.set(
value=config.getfloat("Bloc", "angleInTip"))
self.angleOutRoot.set(
value=config.getfloat("Bloc", "angleOutRoot"))
self.angleOutTip.set(
value=config.getfloat("Bloc", "angleOutTip"))
except:
pass
"""
self.hMaxRootNorm = config.get("Bloc", "hMaxRootNorm")
self.hMinRootNorm = config.get("Bloc", "hMinRootNorm")
self.hLeadingRootNorm = config.get("Bloc", "hLeadingRootNorm")
self.hMaxTipNorm = config.get("Bloc", "hMaxTipNorm")
self.hMinTipNorm = config.get("Bloc", "hMinTipNorm")
self.hLeadingTipNorm = config.get("Bloc", "hLeadingTipNorm")
"""
self.mSpeedHigh.set(
value=config.getfloat("Material", "mSpeedHigh"))
self.mSpeedHalf.set(
value=config.getfloat("Material", "mSpeedHalf"))
self.mSpeedLow.set(value=config.getfloat("Material", "mSpeedLow"))
self.mRadSpHigh.set(
value=config.getfloat("Material", "mRadSpHigh"))
self.mRadSpHalf.set(
value=config.getfloat("Material", "mRadSpHalf"))
self.mHeatSpHigh.set(
value=config.getfloat("Material", "mHeatSpHigh"))
self.mHeatSpLow.set(
value=config.getfloat("Material", "mHeatSpLow"))
self.mName.set(value=config.get("Material", "mName"))
self.tableYY.set(value=config.getfloat("Table", "tableYY"))
self.tableYG.set(value=config.getfloat("Table", "tableYG"))
self.tableYD.set(value=config.getfloat("Table", "tableYD"))
self.cMaxY.set(value=config.getfloat("Table", "cMaxY"))
self.cMaxZ.set(value=config.getfloat("Table", "cMaxZ"))
self.vMaxY.set(value=config.getfloat("Table", "vMaxY"))
self.vMaxZ.set(value=config.getfloat("Table", "vMaxZ"))
self.tHeatingMax.set(value=config.getfloat("Table", "tHeatingMax"))
self.tName.set(value=config.get("Table", "tName"))
self.tComPort.set(value=config.get("Table", "tComPort"))
self.tBaudrate.set(value=config.get("Table", "tBaudrate"))
self.tPreHeat.set(value=config.getfloat("Table", "tPreHeat"))
self.tPostHeat.set(value=config.getfloat("Table", "tPostHeat"))
self.vCut.set(value=config.getfloat("Cut", "vCut"))
self.gCodeStart1.set(value=config.get("Cut", "gCodeStart1"))
self.gCodeStart2.set(value=config.get("Cut", "gCodeStart2"))
self.gCodeStart3.set(value=config.get("Cut", "gCodeStart3"))
self.gCodeStart4.set(value=config.get("Cut", "gCodeStart4"))
self.gCodeEnd1.set(value=config.get("Cut", "gCodeEnd1"))
self.gCodeEnd2.set(value=config.get("Cut", "gCodeEnd2"))
self.gCodeEnd3.set(value=config.get("Cut", "gCodeEnd3"))
self.gCodeEnd4.set(value=config.get("Cut", "gCodeEnd4"))
self.gCodeLetters.set(value=config.get("Cut", "gCodeLetters"))
self.gVSpeedNoCut.set(
value=config.getfloat("Guillotine", "gVSpeedNoCut"))
self.gHSpeedNoCut.set(
value=config.getfloat("Guillotine", "gHSpeedNoCut"))
self.gCuttingSpeed.set(
value=config.getfloat("Guillotine", "gCuttingSpeed"))
self.gApplyCalculatedHeating.set(
value=config.getint("Guillotine", "gApplyCalculatedHeating"))
self.gHeating.set(value=config.getfloat("Guillotine", "gHeating"))
self.gType.set(value=config.get("Guillotine", "gType"))
self.gCuttingWhile.set(
value=config.get("Guillotine", "gCuttingWhile"))
self.gVDist.set(value=config.getfloat("Guillotine", "gVDist"))
self.gHDist.set(value=config.getfloat("Guillotine", "gHDist"))
"""
x ,y , self.hMaxRootNorm, self.hMinRootNorm , self.hLeadingRootNorm = self.normaliseProfil(
self.oRootX, self.oRootY, self.cRoot.get(), 0, 0)
x ,y , self.hMaxTipNorm, self.hMinTipNorm , self.hLeadingTipNorm = self.normaliseProfil(
self.oTipX, self.oTipY, self.cTip.get(), 0, 0)
"""
self.validateAllOn = True
self.validateAll(0)
self.tProfil.updatePlotRoot()
self.tProfil.updatePlotTip()
def uploadTable(self):
self.tableUploadFileName = filedialog.askopenfilename(\
filetypes =(("Table files", "*.tab"),("All files","*.*")),
title = "Choose a file to upload a table."
)
if len(self.tableUploadFileName) > 0:
#config.read('config.ini')
config = configparser.ConfigParser()
config.add_section("Table")
config.add_section("Cut")
config.read(self.tableUploadFileName)
self.tableYY.set(value=config.getfloat("Table", "tableYY"))
self.tableYG.set(value=config.getfloat("Table", "tableYG"))
self.tableYD.set(value=config.getfloat("Table", "tableYD"))
self.cMaxY.set(value=config.getfloat("Table", "cMaxY"))
self.cMaxZ.set(value=config.getfloat("Table", "cMaxZ"))
self.vMaxY.set(value=config.getfloat("Table", "vMaxY"))
self.vMaxZ.set(value=config.getfloat("Table", "vMaxZ"))
self.tHeatingMax.set(value=config.getfloat("Table", "tHeatingMax"))
self.tName.set(value=config.get("Table", "tName"))
self.tComPort.set(value=config.get("Table", "tComPort"))
self.tBaudrate.set(value=config.get("Table", "tBaudrate"))
self.tPreHeat.set(value=config.getfloat("Table", "tPreHeat"))
self.tPostHeat.set(value=config.getfloat("Table", "tPostHeat"))
self.vCut.set(value=config.getfloat("Cut", "vCut"))
self.gCodeStart1.set(value=config.get("Cut", "gCodeStart1"))
self.gCodeStart2.set(value=config.get("Cut", "gCodeStart2"))
self.gCodeStart3.set(value=config.get("Cut", "gCodeStart3"))
self.gCodeStart4.set(value=config.get("Cut", "gCodeStart4"))
self.gCodeEnd1.set(value=config.get("Cut", "gCodeEnd1"))
self.gCodeEnd2.set(value=config.get("Cut", "gCodeEnd2"))
self.gCodeEnd3.set(value=config.get("Cut", "gCodeEnd3"))
self.gCodeEnd4.set(value=config.get("Cut", "gCodeEnd4"))
self.gCodeLetters.set(value=config.get("Cut", "gCodeLetters"))
self.validateAll(
20) # recalculate and redraw bloc, margin and after
def uploadMaterial(self):
self.materialUploadFileName = filedialog.askopenfilename(\
filetypes =(("Material", "*.mat"),("All files","*.*")),
title = "Choose a file to upload a material"
)
if len(self.materialUploadFileName) > 0:
#config.read('config.ini')
config = configparser.ConfigParser()
config.add_section("Material")
config.read(self.materialUploadFileName)
self.mSpeedHigh.set(
value=config.getfloat("Material", "mSpeedHigh"))
self.mSpeedHalf.set(
value=config.getfloat("Material", "mSpeedHalf"))
self.mSpeedLow.set(value=config.getfloat("Material", "mSpeedLow"))
self.mRadSpHigh.set(
value=config.getfloat("Material", "mRadSpHigh"))
self.mRadSpHalf.set(
value=config.getfloat("Material", "mRadSpHalf"))
self.mHeatSpHigh.set(
value=config.getfloat("Material", "mHeatSpHigh"))
self.mHeatSpLow.set(
value=config.getfloat("Material", "mHeatSpLow"))
self.mName.set(value=config.get("Material", "mName"))
self.validateAll(30) # recalculate and redraw cutting
def saveConfig(self):
config = configparser.ConfigParser()
config.add_section("Profil")
config.add_section("Transform")
config.add_section("Bloc")
config.add_section("Material")
config.add_section("Table")
config.add_section("Cut")
config.add_section("Guillotine")
#save all paramaters
config.set(
"Profil", "RootX",
str('[{:s}]'.format(', '.join(
['{}'.format(x) for x in self.oRootX]))))
config.set(
"Profil", "RootY",
str('[{:s}]'.format(', '.join(
['{}'.format(x) for x in self.oRootY]))))
config.set(
"Profil", "RootS",
str('[{:s}]'.format(', '.join(
['{}'.format(x) for x in self.oRootS]))))
config.set(
"Profil", "TipX",
str('[{:s}]'.format(', '.join(['{}'.format(x)
for x in self.oTipX]))))
config.set(
"Profil", "TipY",
str('[{:s}]'.format(', '.join(['{}'.format(x)
for x in self.oTipY]))))
config.set(
"Profil", "TipS",
str('[{:s}]'.format(', '.join(['{}'.format(x)
for x in self.oTipS]))))
config.set("Profil", "nameRoot", self.nameRoot.get())
config.set("Profil", "nameTip", self.nameTip.get())
config.set("Transform", "cRoot", str(self.cRoot.get()))
config.set("Transform", "cTip", str(self.cTip.get()))
config.set("Transform", "incidenceRoot", str(self.incidenceRoot.get()))
config.set("Transform", "thicknessRoot", str(self.thicknessRoot.get()))
config.set("Transform", "vInvertRoot", str(self.vInvertRoot.get()))
config.set("Transform", "incidenceTip", str(self.incidenceTip.get()))
config.set("Transform", "thicknessTip", str(self.thicknessTip.get()))
config.set("Transform", "vInvertTip", str(self.vInvertTip.get()))
config.set("Transform", "covering", str(self.covering.get()))
config.set("Transform", "keepChord", str(self.keepChord.get()))
config.set("Transform", "smooth", str(self.smooth.get()))
config.set("Transform", "nbrPoints", str(self.nbrPoints.get()))
config.set("Transform", "repartition", str(self.repartition.get()))
config.set("Transform", "reducePoints", str(self.reducePoints.get()))
config.set("Bloc", "blocLX", str(self.blocLX.get()))
config.set("Bloc", "blocHZ", str(self.blocHZ.get()))
config.set("Bloc", "fLeading", str(self.fLeading.get()))
config.set("Bloc", "fTrailing", str(self.fTrailing.get()))
config.set("Bloc", "mLeading", str(self.mLeading.get()))
config.set("Bloc", "mTrailingRoot", str(self.mTrailingRoot.get()))
config.set("Bloc", "mTrailingTip", str(self.mTrailingTip.get()))
config.set("Bloc", "leftRightWing", self.leftRightWing.get())
config.set("Bloc", "blocPosition", self.blocPosition.get())
config.set("Bloc", "blocToTableLeft", str(self.blocToTableLeft.get()))
config.set("Bloc", "blocToTableRight",
str(self.blocToTableRight.get()))
config.set("Bloc", "blocToTableTrailingRoot",
str(self.blocToTableTrailingRoot.get()))
config.set("Bloc", "blocToTableTrailingTip",
str(self.blocToTableTrailingTip.get()))
config.set("Bloc", "blocToTableLeadingRoot",
str(self.blocToTableLeadingRoot.get()))
config.set("Bloc", "blocToTableLeadingTip",
str(self.blocToTableLeadingTip.get()))
config.set("Bloc", "hTrailingRoot", str(self.hTrailingRoot.get()))
config.set("Bloc", "hTrailingTip", str(self.hTrailingTip.get()))
config.set("Bloc", "hLeadingRoot", str(self.hLeadingRoot.get()))
config.set("Bloc", "hLeadingTip", str(self.hLeadingTip.get()))
config.set("Bloc", "hMaxRoot", str(self.hMaxRoot.get()))
config.set("Bloc", "hMaxTip", str(self.hMaxTip.get()))
config.set("Bloc", "hMinRoot", str(self.hMinRoot.get()))
config.set("Bloc", "hMinTip", str(self.hMinTip.get()))
config.set("Bloc", "hOffset", str(self.hOffset.get()))
config.set("Bloc", "alignProfil", self.alignProfil.get())
config.set("Bloc", "hProfil", str(self.hProfil.get()))
config.set("Bloc", "angleInRoot", str(self.angleInRoot.get()))
config.set("Bloc", "angleInTip", str(self.angleInTip.get()))
config.set("Bloc", "angleOutRoot", str(self.angleOutRoot.get()))
config.set("Bloc", "angleOutTip", str(self.angleOutTip.get()))
config.set("Material", "mSpeedHigh", str(self.mSpeedHigh.get()))
config.set("Material", "mSpeedHalf", str(self.mSpeedHalf.get()))
config.set("Material", "mSpeedLow", str(self.mSpeedLow.get()))
config.set("Material", "mRadSpHigh", str(self.mRadSpHigh.get()))
config.set("Material", "mRadSpHalf", str(self.mRadSpHalf.get()))
config.set("Material", "mHeatSpHigh", str(self.mHeatSpHigh.get()))
config.set("Material", "mHeatSpLow", str(self.mHeatSpLow.get()))
config.set("Material", "mName", self.mName.get())
config.set("Table", "tableYY", str(self.tableYY.get()))
config.set("Table", "tableYG", str(self.tableYG.get()))
config.set("Table", "tableYD", str(self.tableYD.get()))
config.set("Table", "cMaxY", str(self.cMaxY.get()))
config.set("Table", "cMaxZ", str(self.cMaxZ.get()))
config.set("Table", "vMaxY", str(self.vMaxY.get()))
config.set("Table", "vMaxZ", str(self.vMaxZ.get()))
config.set("Table", "tHeatingMax", str(self.tHeatingMax.get()))
config.set("Table", "tName", self.tName.get())
config.set("Table", "tComPort", self.tComPort.get())
config.set("Table", "tBaudrate", self.tBaudrate.get())
config.set("Table", "tPreHeat", str(self.tPreHeat.get()))
config.set("Table", "tPostHeat", str(self.tPostHeat.get()))
config.set("Cut", "vCut", str(self.vCut.get()))
config.set("Cut", "gCodeStart1", self.gCodeStart1.get())
config.set("Cut", "gCodeStart2", self.gCodeStart2.get())
config.set("Cut", "gCodeStart3", self.gCodeStart3.get())
config.set("Cut", "gCodeStart4", self.gCodeStart4.get())
config.set("Cut", "gCodeEnd1", self.gCodeEnd1.get())
config.set("Cut", "gCodeEnd2", self.gCodeEnd2.get())
config.set("Cut", "gCodeEnd3", self.gCodeEnd3.get())
config.set("Cut", "gCodeEnd4", self.gCodeEnd4.get())
config.set("Cut", "gCodeLetters", self.gCodeLetters.get())
config.set("Guillotine", "gVSpeedNoCut", str(self.gVSpeedNoCut.get()))
config.set("Guillotine", "gHSpeedNoCut", str(self.gHSpeedNoCut.get()))
config.set("Guillotine", "gCuttingSpeed",
str(self.gCuttingSpeed.get()))
config.set("Guillotine", "gApplyCalculatedHeating",
str(self.gApplyCalculatedHeating.get()))
config.set("Guillotine", "gHeating", str(self.gHeating.get()))
config.set("Guillotine", "gType", self.gType.get())
config.set("Guillotine", "gCuttingWhile", self.gCuttingWhile.get())
config.set("Guillotine", "gVDist", str(self.gVDist.get()))
config.set("Guillotine", "gHDist", str(self.gHDist.get()))
configSaveFileName = filedialog.asksaveasfilename(title="Save as...", defaultextension="*.ini",\
filetypes=[("Ini files","*.ini"),("All files", "*")], initialfile=self.configUploadFileName)
if len(configSaveFileName) > 0:
config.write(open(configSaveFileName, 'w'))
def saveTable(self):
config = configparser.ConfigParser()
config.add_section("Table")
config.add_section("Cut")
config.set("Table", "tableYY", str(self.tableYY.get()))
config.set("Table", "tableYG", str(self.tableYG.get()))
config.set("Table", "tableYD", str(self.tableYD.get()))
config.set("Table", "cMaxY", str(self.cMaxY.get()))
config.set("Table", "cMaxZ", str(self.cMaxZ.get()))
config.set("Table", "vMaxY", str(self.vMaxY.get()))
config.set("Table", "vMaxZ", str(self.vMaxZ.get()))
config.set("Table", "tHeatingMax", str(self.tHeatingMax.get()))
config.set("Table", "tName", self.tName.get())
config.set("Table", "tComPort", self.tComPort.get())
config.set("Table", "tBaudrate", self.tBaudrate.get())
config.set("Table", "tPreHeat", str(self.tPreHeat.get()))
config.set("Table", "tPostHeat", str(self.tPostHeat.get()))
config.set("Cut", "vCut", str(self.vCut.get()))
config.set("Cut", "gCodeStart1", self.gCodeStart1.get())
config.set("Cut", "gCodeStart2", self.gCodeStart2.get())
config.set("Cut", "gCodeStart3", self.gCodeStart3.get())
config.set("Cut", "gCodeStart4", self.gCodeStart4.get())
config.set("Cut", "gCodeEnd1", self.gCodeEnd1.get())
config.set("Cut", "gCodeEnd2", self.gCodeEnd2.get())
config.set("Cut", "gCodeEnd3", self.gCodeEnd3.get())
config.set("Cut", "gCodeEnd4", self.gCodeEnd4.get())
config.set("Cut", "gCodeLetters", self.gCodeLetters.get())
if self.tableSaveFileName == None:
self.tableSaveFileName = self.tableUploadFileName
self.tableSaveFileName = filedialog.asksaveasfilename(title="Save table as...", defaultextension="*.tab",\
filetypes=[("Table files","*.tab"),("All files", "*")], initialfile=self.tableSaveFileName)
if len(self.tableSaveFileName) > 0:
config.write(open(self.tableSaveFileName, 'w'))
def saveMaterial(self):
config = configparser.ConfigParser()
config.add_section("Material")
config.set("Material", "mSpeedHigh", str(self.mSpeedHigh.get()))
config.set("Material", "mSpeedHalf", str(self.mSpeedHalf.get()))
config.set("Material", "mSpeedLow", str(self.mSpeedLow.get()))
config.set("Material", "mRadSpHigh", str(self.mRadSpHigh.get()))
config.set("Material", "mRadSpHalf", str(self.mRadSpHalf.get()))
config.set("Material", "mHeatSpHigh", str(self.mHeatSpHigh.get()))
config.set("Material", "mHeatSpLow", str(self.mHeatSpLow.get()))
config.set("Material", "mName", self.mName.get())
if self.materialSaveFileName == None:
self.materialSaveFileName = self.materialUploadFileName
self.materialSaveFileName = filedialog.asksaveasfilename(title="Save material as...", defaultextension="*.material",\
filetypes=[("Material files","*.material"),("All files", "*")], initialfile=self.materialSaveFileName)
if len(self.materialSaveFileName) > 0:
config.write(open(self.materialSaveFileName, 'w'))
def validatePart(self):
self.fTrailing.set(-(self.cRoot.get() - self.cTip.get() -
self.fLeading.get()))
if self.blocPosition.get() == "Left":
self.tBloc.blocToTableRightBox[
'validate'] = 'none' # disable validate, otherwise we call validate inside validate
self.blocToTableRight.set(self.tableYY.get() - self.tableYG.get() -
self.tableYD.get() -
self.blocToTableLeft.get() -
self.blocLX.get())
self.tBloc.blocToTableRightBox[
'validate'] = 'focusout' #enable after the update
else:
self.tBloc.blocToTableRightBox[
'validate'] = 'none' # disable validate, otherwise we call validate inside validate
self.blocToTableLeft.set(self.tableYY.get() - self.tableYG.get() -
self.tableYD.get() -
self.blocToTableRight.get() -
self.blocLX.get())
self.tBloc.blocToTableRightBox['validate'] = 'focusout'
self.blocToTableTrailingTip.set(self.blocToTableTrailingRoot.get() -
self.fTrailing.get())
self.blocToTableLeadingRoot.set(self.blocToTableTrailingRoot.get() +
self.cRoot.get() +
self.mTrailingRoot.get() +
self.mLeading.get())
self.blocToTableLeadingTip.set(self.blocToTableTrailingTip.get() +
self.cTip.get() +
self.mTrailingTip.get() +
self.mLeading.get())
#self.mSpeedHalf.set(self.mSpeedHigh.get() / 2) #half speed = high speed /2
def validateAll(self, level):
# level is used to avoid to recalculate some data when not needed
# 0 = calculate all (original profil change)
# 10 = calculate Transform and after (Transform profil: chord, incidence...)
# 20 = calculate Bloc/margin and after (change table or bloc position)
# 30 = calculate cutting (change speed, material)
if self.initDone and self.validateAllOn: #avoid validate during the set up of tkinter widgets and when validateAll is disabled
#try:
if level == 0:
self.tProfil.updatePlotRoot()
self.tProfil.updatePlotTip()
if level <= 10:
#create tRoot and tTipX based on oRoot and oTip and chords but not based on bloc and margin
# draw the view in Transform (= tRoot and tTip)
if (len(self.oRootX) > 0) and (len(self.oTipX) > 0):
#create tRoot and tTipX based on oRoot and oTip and chords but not based on bloc and margin
self.tTransform.validateTransform()
self.tTransform.updatePlotRoot()
self.tTransform.updatePlotTip()
if level <= 20:
pass
#create pRoot and pTipX based on tRoot and tTip and based on Table, bloc and margin
self.validatePart()
#print("validatePart is done")
self.calculatePositions()
#print("calculatepositions is done")
# draw the bloc ()
self.tBloc.updatePlotBloc()
#print("updatePlotBloc is done")
#draw the margins
self.tMargin.updatePlotMargin()
#print("updatePlotMargin is done")
#update heating for guillotine
self.tGuillotine.updateGuillotineHeating()
#print("updateGuillotineHeating is done")
if level <= 30: # calculate Cut based on Material
self.mSpeedHalf.set(self.mSpeedHigh.get() /
2) #half speed = high speed /2
if (len(self.pRootX) > 0) and (len(self.pTipX) > 0):
pass
#print("begin calculateRedraw")
self.tCut.calculateRedraw()
#print("end calculateRedraw")
warningMsg = ""
if (len(self.oRootX) <= 1) and (len(self.oTipX) <= 1):
warningMsg = "Root and Tip profiles missing"
elif len(self.oRootX) <= 1:
warningMsg = "Root profile missing"
elif len(self.oTipX) <= 1:
warningMsg = "Tip profile missing"
elif (self.tRootS.count(4) + self.tRootS.count(10)) != (
self.tTipS.count(4) + self.tTipS.count(10)):
warningMsg = "Transformed root and tip profiles must have the same number of synchro points"
self.warningMsg.set(warningMsg)
#next 2 lines are normally as comment
#except:
return True
def calculatePositions(self):
#create bRoot and bTipX based on tRoot and tTip and based on bloc and margin
#calculate Root and Tip offset to apply
if (len(self.tRootX) > 0) and (len(
self.tTipX) > 0): # and (len(self.tRootX) == len(self.tTipX)):
#calculate relative height of max, min leading
hMaxRootNorm, hMinRootNorm, hLeadingRootNorm = self.calculateRelativeHeigths(
self.tRootX, self.tRootY)
hMaxTipNorm, hMinTipNorm, hLeadingTipNorm = self.calculateRelativeHeigths(
self.tTipX, self.tTipY)
#Apply vertical aligment
if self.alignProfil.get() == "Trailing":
self.hTrailingRoot.set(self.hProfil.get())
self.hTrailingTip.set(self.hProfil.get())
elif self.alignProfil.get() == "Leading":
self.hTrailingRoot.set(self.hProfil.get() - hLeadingRootNorm)
self.hTrailingTip.set(self.hProfil.get() - hLeadingTipNorm)
elif self.alignProfil.get() == "Extrados":
self.hTrailingRoot.set(self.hProfil.get() - hMaxRootNorm)
self.hTrailingTip.set(self.hProfil.get() - hMaxTipNorm)
elif self.alignProfil.get() == "Intrados":
self.hTrailingRoot.set(self.hProfil.get() - hMinRootNorm)
self.hTrailingTip.set(self.hProfil.get() - hMinTipNorm)
self.hLeadingRoot.set(self.hTrailingRoot.get() + hLeadingRootNorm)
self.hLeadingTip.set(self.hTrailingTip.get() + hLeadingTipNorm)
self.hMaxRoot.set(self.blocHZ.get() - self.hTrailingRoot.get() -
hMaxRootNorm)
self.hMaxTip.set(self.blocHZ.get() - self.hTrailingTip.get() -
hMaxTipNorm)
self.hMinRoot.set(self.hTrailingRoot.get() + hMinRootNorm)
self.hMinTip.set(self.hTrailingTip.get() + hMinTipNorm)
#apply offsets
self.pRootX = self.tRootX + self.blocToTableTrailingRoot.get(
) + self.mTrailingRoot.get()
self.pTipX = self.tTipX + self.blocToTableTrailingTip.get(
) + self.mTrailingTip.get()
self.pRootY = self.tRootY + self.hOffset.get(
) + self.hTrailingRoot.get()
self.pTipY = self.tTipY + self.hOffset.get(
) + self.hTrailingRoot.get()
self.pRootS = list(self.tRootS) #create list of synchro
self.pTipS = list(self.tTipS) #create list of synchro
"""
def validateFloat(self, reason, val , name , old, min , max):
if reason == "focusout":
try :
v = float(val)
if v >= float(min) and v <= float(max):
return True
return True
except :
return False
elif reason == "focusout":
if float(val) > float(max):
print("focus out max exceeded")
return False
return self.validateAll()
return True
"""
def normaliseArrayProfil(self, aX, aY, chord):
#normalise the profil with chord
if len(aX) > 0:
minX = np.min(aX)
maxX = np.max(aX)
ratio = chord / (maxX - minX)
aXn = aX * ratio
aXn = aXn - aXn[0]
aXn = -1.0 * aXn # multiply by -1 to reverse the order
aYn = aY * ratio
aYn = aYn - aYn[0]
return aXn, aYn
"""
def normaliseProfil (self , pX , pY , coord , oY, oZ):
#normalise the profil with coord and offset of origin
if len(pX) > 0:
aX = np.array(pX)
aY = np.array(pY)
minX = np.min(aX)
idxMin = np.where(aX == minX) #return an array with indexes
maxX = np.max(aX)
minY = np.min(aY)
maxY = np.max(aY)
ratio= coord / ( maxX - minX )
aX = aX * ratio
aX = aX - aX[0]
aX = -1 * aX # multiply by -1 to reverse the order
aX = aX + oY
aY = aY * ratio
aY = aY - aY[0]
aY = aY + oZ
maxh = (maxY / ( maxX - minX ) ) - pY[0]
minh = (minY / ( maxX - minX ) ) - pY[0]
if len(idxMin) > 0 and len(idxMin[0]) > 0:
r = idxMin[0][0]
leadingh = (pY[r] / ( maxX - minX ) ) - pY[0]
else:
leadingh = 0
#print("normalised aX=", aX , "aY=", aY)
return aX.tolist() , aY.tolist() ,maxh ,minh, leadingh
"""
def calculateRelativeHeigths(self, pX, pY):
maxX = np.max(pX)
idxMax = np.where(pX == maxX) #return an array with indexes
minY = np.min(pY)
maxY = np.max(pY)
maxh = maxY - pY[0]
minh = minY - pY[0]
if len(idxMax) > 0 and len(idxMax[0]) > 0:
r = idxMax[0][0]
leadingh = pY[r] - pY[0]
else:
leadingh = 0
return maxh, minh, leadingh
class CharacterSheetTab(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.player = StringVar()
self.character = StringVar()
self.dm = StringVar()
self.str = StringVar()
self.int = StringVar()
self.wis = StringVar()
self.dex = StringVar()
self.con = StringVar()
self.cha = StringVar()
self.JPpoison = StringVar()
self.JPwands = StringVar()
self.JPparalysis = StringVar()
self.JPbreath = StringVar()
self.JPspell = StringVar()
self.class_ = StringVar()
self.race = StringVar()
self.align = StringVar()
self.AC = StringVar()
self.HP = StringVar()
self.maxHP = StringVar()
self.XP_to_add = StringVar()
self.XPbonus = StringVar()
self.XPtotal = IntVar()
self.level = StringVar()
self.init_once()
(
self.baseXP,
self.mainCarRace,
self.mainCarClass) = self.classDifferenciation()
self.remainingXP = StringVar()
self.remainingXP.set(self.getRemainingXP())
self.bonusXP = StringVar()
self.bonusXP.set(self.getBonusXP())
self.freeze = IntVar()
self.freeze.set(1)
Label(self, text="Player Name:").grid(row=0, column=0, columnspan=2)
Label(self, text="Character Name :").grid(
row=0, column=4, columnspan=2)
Label(self, text="DM Name:").grid(row=0, column=8, columnspan=2)
Label(self, text="STR:").grid(row=1, column=0)
Label(self, text="INT:").grid(row=2, column=0)
Label(self, text="WIS:").grid(row=3, column=0)
Label(self, text="DEX:").grid(row=4, column=0)
Label(self, text="CON:").grid(row=5, column=0)
Label(self, text="CHA:").grid(row=6, column=0)
Label(self, text="Poison/Deathray:").grid(row=1, column=2)
Label(self, text="Wands:").grid(row=2, column=2)
Label(self, text="Paralysis:").grid(row=3, column=2)
Label(self, text="Dragon Breath:").grid(row=4, column=2)
Label(self, text="Spells:").grid(row=5, column=2)
Label(self, text="Armor Class").grid(row=1, column=4, columnspan=1)
Label(self, text="Health Points").grid(row=1, column=5, columnspan=3)
Label(self, text=" / ").grid(row=2, column=6)
Label(self, text="Class :").grid(row=3, column=4)
Label(self, text="Race :").grid(row=4, column=4)
Label(self, text="XP to add :").grid(row=7, column=0)
Label(self, text="Remaining :").grid(row=8, column=0)
Label(self, text="Bonus :").grid(row=7, column=2)
Label(self, text="Alignment :").grid(row=3, column=6)
Label(self, text="Level :").grid(row=9, column=0, columnspan=2)
self.remainingLabel = Label(
self,
textvariable=self.remainingXP,
relief=SUNKEN,
width=5)
self.remainingLabel.grid(row=8, column=1)
self.bonusLabel = Label(
self,
textvariable=self.bonusXP,
relief=SUNKEN,
width=5)
self.bonusLabel.grid(row=7, column=3)
self.levelLabel = Label(
self,
textvariable=self.level,
relief=SUNKEN,
width=5)
self.levelLabel.grid(row=9, column=2, columnspan=2)
Eplayer = Entry(self, textvariable=self.player)
Eplayer.grid(row=0, column=2, columnspan=2)
Eplayer.bind(sequence='<KeyRelease>', func=self.refresh)
Echaracter = Entry(self, textvariable=self.character)
Echaracter.grid(row=0, column=6, columnspan=2)
Echaracter.bind(sequence='<KeyRelease>', func=self.refresh)
EDM = Entry(self, textvariable=self.dm)
EDM.grid(row=0, column=10, columnspan=2)
EDM.bind(sequence='<KeyRelease>', func=self.refresh)
Estr = Entry(self, textvariable=self.str)
Estr.grid(row=1, column=1)
Estr.bind(sequence='<KeyRelease>', func=self.refresh)
Eint = Entry(self, textvariable=self.int)
Eint.grid(row=2, column=1)
Eint.bind(sequence='<KeyRelease>', func=self.refresh)
Ewis = Entry(self, textvariable=self.wis)
Ewis.grid(row=3, column=1)
Ewis.bind(sequence='<KeyRelease>', func=self.refresh)
Edex = Entry(self, textvariable=self.dex)
Edex.grid(row=4, column=1)
Edex.bind(sequence='<KeyRelease>', func=self.refresh)
Econ = Entry(self, textvariable=self.con)
Econ.grid(row=5, column=1)
Econ.bind(sequence='<KeyRelease>', func=self.refresh)
Echa = Entry(self, textvariable=self.cha)
Echa.grid(row=6, column=1)
Echa.bind(sequence='<KeyRelease>', func=self.refresh)
Entry(self, textvariable=self.JPpoison).grid(row=1, column=3)
Entry(self, textvariable=self.JPwands).grid(row=2, column=3)
Entry(self, textvariable=self.JPparalysis).grid(row=3, column=3)
Entry(self, textvariable=self.JPbreath).grid(row=4, column=3)
Entry(self, textvariable=self.JPspell).grid(row=5, column=3)
Entry(self, textvariable=self.AC).grid(row=2, column=4)
Entry(self, textvariable=self.HP).grid(row=2, column=5)
Entry(self, textvariable=self.maxHP).grid(row=2, column=7)
EXP = Entry(self, textvariable=self.XP_to_add)
EXP.grid(row=7, column=1)
EXP.bind(sequence='<KeyPress-Return>', func=self.addXP)
OptionMenu(
self, self.class_,
"Class",
"Warrior",
"Wizard",
"Thief",
"Cleric").grid(row=3, column=5)
OptionMenu(
self, self.align,
"Alignment",
"Lawful Good",
"Lawful Neutral",
"Lawful Evil",
"Neutral Good",
"Neutral Neutral",
"Neutral Evil",
"Chaotic Good",
"Chaotic Neutral",
"Chaotic Evil").grid(row=3, column=7)
OptionMenu(
self, self.race,
"Race",
"Human",
"Elf",
"Dwarf",
"Halfelin").grid(row=4, column=5)
Button(
self,
text="Add XP",
command=self.refresh,
width=6).grid(row=10, column=3)
def refresh(self, event):
(
self.baseXP,
self.mainCarRace,
self.mainCarClass) = self.classDifferenciation()
self.remainingXP.set(self.getRemainingXP())
self.bonusXP.set(self.getBonusXP())
self.update_idletasks()
def addXP(self, event):
(
self.baseXP,
self.mainCarRace,
self.mainCarClass) = self.classDifferenciation()
self.remainingXP.set(self.getRemainingXP())
self.bonusXP.set(self.getBonusXP())
self.addXPToTotal()
self.update_idletasks()
def save(self):
file_ = filedialog.asksaveasfile(
parent=self,
mode="w",
title="Save your Character Sheet",
defaultextension=".dndcs",
filetypes=[
("Character Sheets", ".dndcs"),
("All Files", ".*")])
string = ""
list_vars = [
self.player, self.character, self.dm, self.str, self.int,
self.wis, self.dex, self.con, self.cha, self.JPpoison,
self.JPwands, self.JPparalysis, self.JPbreath, self.JPspell,
self.class_, self.race, self.align, self.AC, self.HP,
self.maxHP, self.XPtotal, self.level]
for i in range(len(list_vars)):
string += str(list_vars[i].get())+"\n"
string = string[:-2]
file_.write(string)
file_.close()
def load(self):
self.reset()
file_ = filedialog.askopenfile(
parent=self, mode="r", title="Open a Character Sheet",
defaultextension=".dndcs",
filetypes=[
("Character Sheets", ".dndcs"),
("All Files", ".*")]
)
list_vars = [
self.player, self.character, self.dm, self.str, self.int,
self.wis, self.dex, self.con, self.cha, self.JPpoison,
self.JPwands, self.JPparalysis, self.JPbreath, self.JPspell,
self.class_, self.race, self.align, self.AC, self.HP,
self.maxHP, self.XPtotal, self.level]
i = 0
for line in file_:
line.strip()
list_vars[i].set(line)
i += 1
file_.close()
self.refresh(1)
def reset(self):
self.player.set("")
self.character.set("")
self.dm.set("")
self.str.set("")
self.int.set("")
self.wis.set("")
self.dex.set("")
self.con.set("")
self.cha.set("")
self.JPpoison.set("")
self.JPwands.set("")
self.JPparalysis.set("")
self.JPbreath.set("")
self.JPspell.set("")
self.class_.set("Class")
self.race.set("Race")
self.align.set("Alignment")
self.AC.set("")
self.HP.set("")
self.maxHP.set("")
self.XP_to_add.set("")
self.XPbonus.set("")
self.XPtotal.set(0)
self.level.set("1")
def classDifferenciation(self):
XPToReturn = 0
mainCarClass = 0
mainCarRace = 0
if self.class_.get() == "Warrior":
XPToReturn += 2000
mainCarClass = int(self.str.get())
elif self.class_.get() == "Wizard":
XPToReturn += 2500
mainCarClass = int(self.int.get())
elif self.class_.get() == "Cleric":
XPToReturn += 1500
mainCarClass = int(self.wis.get())
elif self.class_.get() == "Thief":
XPToReturn += 1200
mainCarClass = int(self.dex.get())
else:
XPToReturn += 0
if self.race.get() == "Human":
XPToReturn += 0
mainCarRace = int(self.cha.get())
elif self.race.get() == "Elf":
XPToReturn += 1500
mainCarRace = int(self.str.get())
elif self.race.get() == "Dwarf":
XPToReturn += 500
mainCarRace = int(self.con.get())
elif self.race.get() == "Halfelin":
XPToReturn += 800
mainCarRace = int(self.dex.str.get())
return XPToReturn, mainCarClass, mainCarRace
def getRemainingXP(self):
remainingXP = int(self.baseXP) * int(self.level.get()) - \
int(self.XPtotal.get())
return str(remainingXP)
def getBonusXP(self):
bonusPercentage = 0
if 16 <= self.mainCarClass <= 18:
bonusPercentage += 5
elif 13 <= self.mainCarClass <= 15:
bonusPercentage += 0
elif 9 <= self.mainCarClass <= 12:
bonusPercentage -= 5
elif 3 <= self.mainCarClass <= 8:
bonusPercentage -= 10
else:
bonusPercentage = 0
if 16 <= self.mainCarRace <= 18:
bonusPercentage += 5
elif 13 <= self.mainCarRace <= 15:
bonusPercentage += 0
elif 9 <= self.mainCarRace <= 12:
bonusPercentage -= 5
elif 3 <= self.mainCarRace <= 8:
bonusPercentage -= 10
else:
bonusPercentage = 0
self.bonus = bonusPercentage
return str(bonusPercentage) + "%"
def addXPToTotal(self):
(
self.baseXP,
self.mainCarRace,
self.mainCarClass) = self.classDifferenciation()
self.remainingXP.set(self.getRemainingXP())
self.bonusXP.set(self.getBonusXP())
remaining = int(self.getRemainingXP())
bonus = int(self.getBonusXP().strip("%"))
if self.XP_to_add.get() != '':
XP_to_add = int(self.XP_to_add.get())
else:
XP_to_add = 0
self.XP_to_add.set("")
total = self.XPtotal.get()
total += XP_to_add*(1+bonus/100)
self.XPtotal.set(total)
if total >= remaining:
self.level.set(str(int(self.level.get())+1))
def rollCharacteristics(self):
if self.freeze.get() == 0:
chars = [
self.str, self.int, self.wis,
self.dex, self.con, self.cha]
for char in chars:
char.set(str(
rd.randint(1, 6) + rd.randint(1, 6) + rd.randint(1, 6)))
pass
@method_once
def init_once(self):
self.level.set("1")
self.baseXP = 0
self.mainCarRace = 0
self.mainCarClass = 0
self.bonus = 0
self.XP_to_add.set("0")
)
edit_menu.add_separator()
edit_menu.add_command(label="Find",
underline=0,
accelerator="Ctrl+F",
command=find_text)
edit_menu.add_separator()
edit_menu.add_command(label="Select All",
underline=7,
accelerator="Ctrl+A",
command=select_all)
menu_bar.add_cascade(label="Edit", menu=edit_menu)
view_menu = Menu(menu_bar, tearoff=0)
show_line_number = IntVar()
show_line_number.set(1)
view_menu.add_checkbutton(label="Show Line Number",
variable=show_line_number,
command=update_line_numbers)
show_cursor_info = IntVar()
show_cursor_info.set(1)
view_menu.add_checkbutton(
label="Show Cursor Location at Bottom",
variable=show_cursor_info,
command=show_cursor_info_bar,
)
to_highlight_line = BooleanVar()
view_menu.add_checkbutton(
label="Highlight Current Line",
onvalue=1,
offvalue=0,
class PasswordGenerator():
def __init__(self):
root = Tk()
root.title('密码生成器')
root.update()
self.root = root
self.ps_length = IntVar(value=8)
self.ps_level = IntVar(value=3)
self.password = StringVar()
self.load_view()
root.mainloop()
def load_view(self):
f1 = Frame(self.root)
f1.pack(padx=10, pady=5)
Label(f1, text="密码长度：").grid(row=0, column=0)
f1r = Frame(f1)
f1r.grid(row=0, column=1)
Entry(f1r,
textvariable=self.ps_length,
width=5,
validate="key",
validatecommand=(self.test, '%P')).grid(row=0, column=1)
Button(f1r, text="+", command=self.calcPlus).grid(row=0, column=2)
Button(f1r, text="-", command=self.calcSubt).grid(row=0, column=3)
Label(f1, text="密码强度：").grid(row=1, column=0)
f1rb = Frame(f1)
f1rb.grid(row=1, column=1)
Radiobutton(f1rb, text="简单", variable=self.ps_level,
value=1).grid(row=1, column=1)
Radiobutton(f1rb, text="一般", variable=self.ps_level,
value=3).grid(row=1, column=2)
Radiobutton(f1rb, text="复杂", variable=self.ps_level,
value=4).grid(row=1, column=3)
Entry(self.root, textvariable=self.password, state="readonly").pack()
submit = Button(self.root, text="生成密码并复制到剪切板", command=self.getPw)
submit.pack()
def cutLength(self):
res = []
for i in range(self.ps_level.get(), 1, -1):
res.append(
random.randint(1,
self.ps_length.get() - sum(res) - i + 1))
res.append(self.ps_length.get() - sum(res))
random.shuffle(res)
return res
def makePassword(self, dists, arr):
res = []
for i in range(len(arr)):
for j in range(arr[i]):
res += random.choice(dists[i])
random.shuffle(res)
return ''.join(res)
def getPassword(self):
arr = self.cutLength()
str1 = '01'
str2 = '23456789'
str3 = 'abcdefghijkmnpqrstuvwxyz'
str4 = 'ABCDEFGHJKMNPQRSTUVWXYZ'
str5 = '_@!,.:;-=+/?'
dists = {
1: [str1 + str2],
3: [str2, str3, str4],
4: [str2, str3, str4, str5]
}
return self.makePassword(dists[self.ps_level.get()], arr)
def test(self, res):
if res.isdigit():
return int(res) > 4
else:
return False
def calcPlus(self):
self.ps_length.set(self.ps_length.get() + 1)
def calcSubt(self):
lengVal = self.ps_length.get()
if lengVal > 4:
self.ps_length.set(lengVal - 1)
def getPw(self):
res = self.getPassword()
clipboard.copy(res)
self.password.set(res)
class ErlangCT:
def __init__(self, f_path):
self.root = Tk()
self.root.title("P2: Erlang-C Calculator")
# excel file path
self.f_path = f_path
# member variables
self.num_servers = 0 # result: number of servers
self.ew = 0.0 # result: expected waiting time
self.en = 0.0 # result: expected number packets in system
self.ens = 0.0 # result: expected number of busy servers
self.alpha = 0.0 # input: max waiting time
self.l = 0.0 # input: lambda
self.u = 0.0 # input: mu
# text fields and validation for each variable
self.alpha_entry = Entry(self.root)
self.l_entry = Entry(self.root)
self.u_entry = Entry(self.root)
# text field labels
self.alpha_label = Label(self.root,
text="Waiting Time Should Not Exceed: ")
self.l_label = Label(self.root, text="Desired Arrival Rate (lambda): ")
self.u_label = Label(self.root, text="Desired Service Rate (mu): ")
# calcualte button
self.calculate_button = Button(
self.root,
text="Calculate",
command=lambda: self.update("calculate"))
self.main_menu_button = Button(
self.root,
text="Main Menu",
command=lambda: self.update("main-menu"))
# initialize result text field
self.num_servers_result = IntVar()
self.num_servers_result.set(self.num_servers)
self.ew_result = DoubleVar()
self.ew_result.set(self.ew)
self.en_result = DoubleVar()
self.en_result.set(self.en)
self.ens_result = DoubleVar()
self.ens_result.set(self.en)
# result text field labels
self.num_servers_text_label = Label(self.root,
text="Number of Servers Required:")
self.num_servers_result_label = Label(
self.root, textvariable=self.num_servers_result)
self.es_text_label = Label(self.root, text="Expected Waiting Time:")
self.ew_result_label = Label(self.root, textvariable=self.ew_result)
self.en_text_label = Label(self.root,
text="Expected Number Packets in System:")
self.en_result_label = Label(self.root, textvariable=self.en_result)
self.ens_text_label = Label(self.root,
text="Expected Number of Busy Servers:")
self.ens_result_label = Label(self.root, textvariable=self.ens_result)
# Calculator Layout
self.alpha_label.grid(row=1, column=0, columnspan=3, sticky=W)
self.alpha_entry.grid(row=1, column=4, columnspan=1, sticky=E)
self.l_label.grid(row=2, column=0, columnspan=3, sticky=W)
self.l_entry.grid(row=2, column=4, columnspan=1, sticky=E)
self.u_label.grid(row=3, column=0, columnspan=3, sticky=W)
self.u_entry.grid(row=3, column=4, columnspan=1, sticky=E)
self.calculate_button.grid(row=4, column=0)
self.num_servers_text_label.grid(row=5, column=0, sticky=W)
self.num_servers_result_label.grid(row=5,
column=3,
columnspan=2,
sticky=E)
self.es_text_label.grid(row=6, column=0, sticky=W)
self.ew_result_label.grid(row=6, column=3, columnspan=2, sticky=E)
self.en_text_label.grid(row=7, column=0, sticky=W)
self.en_result_label.grid(row=7, column=3, columnspan=2, sticky=E)
self.ens_text_label.grid(row=8, column=0, sticky=W)
self.ens_result_label.grid(row=8, column=3, columnspan=2, sticky=E)
self.main_menu_button.grid(row=9, column=0)
def update(self, method):
if method == "calculate":
self.alpha = float(self.alpha_entry.get())
self.l = float(self.l_entry.get())
self.u = float(self.u_entry.get())
result = erlang_c_time(self.l, self.u, self.alpha)
self.num_servers = result['c']
self.ew = result['ew']
self.en = result['en']
self.ens = result['ens']
self.num_servers_result.set(self.num_servers)
self.ew_result.set(self.ew)
self.en_result.set(self.en)
self.ens_result.set(self.ens)
self.write_to_excel()
elif method == "main-menu":
self.root.destroy()
from main_menu import MainMenu
m_menu = MainMenu(self.f_path)
m_menu.root.mainloop()
else: # reset
self.num_servers = 0
def write_to_excel(self):
wb = load_workbook(self.f_path)
ws = wb["Part 2"]
data = [["Inputs", "Values", "Results", "Values"],
[
"Max P(wait)", "", "Number of Servers",
str(self.num_servers)
], ["Max E(w)",
str(self.alpha), "E(S)",
str(self.ew)],
["Arrival Rate",
str(self.l), "E(N)",
str(self.en)], ["Service Rate",
str(self.u), "", ""]]
i = 1
for v in data:
j = 1
for e in v:
c = ws.cell(row=i, column=j)
c.value = e
j += 1
i += 1
wb.save(self.f_path)
class ShiftReduceApp(object):
"""
A graphical tool for exploring the shift-reduce parser. The tool
displays the parser's stack and the remaining text, and allows the
user to control the parser's operation. In particular, the user
can shift tokens onto the stack, and can perform reductions on the
top elements of the stack. A "step" button simply steps through
the parsing process, performing the operations that
``nltk.parse.ShiftReduceParser`` would use.
"""
def __init__(self, grammar, sent, trace=0):
self._sent = sent
self._parser = SteppingShiftReduceParser(grammar, trace)
# Set up the main window.
self._top = Tk()
self._top.title('Shift Reduce Parser Application')
# Animations. animating_lock is a lock to prevent the demo
# from performing new operations while it's animating.
self._animating_lock = 0
self._animate = IntVar(self._top)
self._animate.set(10) # = medium
# The user can hide the grammar.
self._show_grammar = IntVar(self._top)
self._show_grammar.set(1)
# Initialize fonts.
self._init_fonts(self._top)
# Set up key bindings.
self._init_bindings()
# Create the basic frames.
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_feedback(self._top)
self._init_grammar(self._top)
self._init_canvas(self._top)
# A popup menu for reducing.
self._reduce_menu = Menu(self._canvas, tearoff=0)
# Reset the demo, and set the feedback frame to empty.
self.reset()
self._lastoper1['text'] = ''
#########################################
## Initialization Helpers
#########################################
def _init_fonts(self, root):
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
self._sysfont = tkinter.font.Font(font=Button()["font"])
root.option_add("*Font", self._sysfont)
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(root)
self._size.set(self._sysfont.cget('size'))
self._boldfont = tkinter.font.Font(family='helvetica', weight='bold',
size=self._size.get())
self._font = tkinter.font.Font(family='helvetica',
size=self._size.get())
def _init_grammar(self, parent):
# Grammar view.
self._prodframe = listframe = Frame(parent)
self._prodframe.pack(fill='both', side='left', padx=2)
self._prodlist_label = Label(self._prodframe,
font=self._boldfont,
text='Available Reductions')
self._prodlist_label.pack()
self._prodlist = Listbox(self._prodframe, selectmode='single',
relief='groove', background='white',
foreground='#909090',
font=self._font,
selectforeground='#004040',
selectbackground='#c0f0c0')
self._prodlist.pack(side='right', fill='both', expand=1)
self._productions = list(self._parser.grammar().productions())
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
self._prodlist.config(height=min(len(self._productions), 25))
# Add a scrollbar if there are more than 25 productions.
if 1:#len(self._productions) > 25:
listscroll = Scrollbar(self._prodframe,
orient='vertical')
self._prodlist.config(yscrollcommand = listscroll.set)
listscroll.config(command=self._prodlist.yview)
listscroll.pack(side='left', fill='y')
# If they select a production, apply it.
self._prodlist.bind('<<ListboxSelect>>', self._prodlist_select)
# When they hover over a production, highlight it.
self._hover = -1
self._prodlist.bind('<Motion>', self._highlight_hover)
self._prodlist.bind('<Leave>', self._clear_hover)
def _init_bindings(self):
# Quit
self._top.bind('<Control-q>', self.destroy)
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Alt-q>', self.destroy)
self._top.bind('<Alt-x>', self.destroy)
# Ops (step, shift, reduce, undo)
self._top.bind('<space>', self.step)
self._top.bind('<s>', self.shift)
self._top.bind('<Alt-s>', self.shift)
self._top.bind('<Control-s>', self.shift)
self._top.bind('<r>', self.reduce)
self._top.bind('<Alt-r>', self.reduce)
self._top.bind('<Control-r>', self.reduce)
self._top.bind('<Delete>', self.reset)
self._top.bind('<u>', self.undo)
self._top.bind('<Alt-u>', self.undo)
self._top.bind('<Control-u>', self.undo)
self._top.bind('<Control-z>', self.undo)
self._top.bind('<BackSpace>', self.undo)
# Misc
self._top.bind('<Control-p>', self.postscript)
self._top.bind('<Control-h>', self.help)
self._top.bind('<F1>', self.help)
self._top.bind('<Control-g>', self.edit_grammar)
self._top.bind('<Control-t>', self.edit_sentence)
# Animation speed control
self._top.bind('-', lambda e,a=self._animate:a.set(20))
self._top.bind('=', lambda e,a=self._animate:a.set(10))
self._top.bind('+', lambda e,a=self._animate:a.set(4))
def _init_buttons(self, parent):
# Set up the frames.
self._buttonframe = buttonframe = Frame(parent)
buttonframe.pack(fill='none', side='bottom')
Button(buttonframe, text='Step',
background='#90c0d0', foreground='black',
command=self.step,).pack(side='left')
Button(buttonframe, text='Shift', underline=0,
background='#90f090', foreground='black',
command=self.shift).pack(side='left')
Button(buttonframe, text='Reduce', underline=0,
background='#90f090', foreground='black',
command=self.reduce).pack(side='left')
Button(buttonframe, text='Undo', underline=0,
background='#f0a0a0', foreground='black',
command=self.undo).pack(side='left')
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Reset Parser', underline=0,
command=self.reset, accelerator='Del')
filemenu.add_command(label='Print to Postscript', underline=0,
command=self.postscript, accelerator='Ctrl-p')
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-x')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
editmenu = Menu(menubar, tearoff=0)
editmenu.add_command(label='Edit Grammar', underline=5,
command=self.edit_grammar,
accelerator='Ctrl-g')
editmenu.add_command(label='Edit Text', underline=5,
command=self.edit_sentence,
accelerator='Ctrl-t')
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
rulemenu = Menu(menubar, tearoff=0)
rulemenu.add_command(label='Step', underline=1,
command=self.step, accelerator='Space')
rulemenu.add_separator()
rulemenu.add_command(label='Shift', underline=0,
command=self.shift, accelerator='Ctrl-s')
rulemenu.add_command(label='Reduce', underline=0,
command=self.reduce, accelerator='Ctrl-r')
rulemenu.add_separator()
rulemenu.add_command(label='Undo', underline=0,
command=self.undo, accelerator='Ctrl-u')
menubar.add_cascade(label='Apply', underline=0, menu=rulemenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_checkbutton(label="Show Grammar", underline=0,
variable=self._show_grammar,
command=self._toggle_grammar)
viewmenu.add_separator()
viewmenu.add_radiobutton(label='Tiny', variable=self._size,
underline=0, value=10, command=self.resize)
viewmenu.add_radiobutton(label='Small', variable=self._size,
underline=0, value=12, command=self.resize)
viewmenu.add_radiobutton(label='Medium', variable=self._size,
underline=0, value=14, command=self.resize)
viewmenu.add_radiobutton(label='Large', variable=self._size,
underline=0, value=18, command=self.resize)
viewmenu.add_radiobutton(label='Huge', variable=self._size,
underline=0, value=24, command=self.resize)
menubar.add_cascade(label='View', underline=0, menu=viewmenu)
animatemenu = Menu(menubar, tearoff=0)
animatemenu.add_radiobutton(label="No Animation", underline=0,
variable=self._animate, value=0)
animatemenu.add_radiobutton(label="Slow Animation", underline=0,
variable=self._animate, value=20,
accelerator='-')
animatemenu.add_radiobutton(label="Normal Animation", underline=0,
variable=self._animate, value=10,
accelerator='=')
animatemenu.add_radiobutton(label="Fast Animation", underline=0,
variable=self._animate, value=4,
accelerator='+')
menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0,
command=self.about)
helpmenu.add_command(label='Instructions', underline=0,
command=self.help, accelerator='F1')
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
def _init_feedback(self, parent):
self._feedbackframe = feedbackframe = Frame(parent)
feedbackframe.pack(fill='x', side='bottom', padx=3, pady=3)
self._lastoper_label = Label(feedbackframe, text='Last Operation:',
font=self._font)
self._lastoper_label.pack(side='left')
lastoperframe = Frame(feedbackframe, relief='sunken', border=1)
lastoperframe.pack(fill='x', side='right', expand=1, padx=5)
self._lastoper1 = Label(lastoperframe, foreground='#007070',
background='#f0f0f0', font=self._font)
self._lastoper2 = Label(lastoperframe, anchor='w', width=30,
foreground='#004040', background='#f0f0f0',
font=self._font)
self._lastoper1.pack(side='left')
self._lastoper2.pack(side='left', fill='x', expand=1)
def _init_canvas(self, parent):
self._cframe = CanvasFrame(parent, background='white',
width=525, closeenough=10,
border=2, relief='sunken')
self._cframe.pack(expand=1, fill='both', side='top', pady=2)
canvas = self._canvas = self._cframe.canvas()
self._stackwidgets = []
self._rtextwidgets = []
self._titlebar = canvas.create_rectangle(0,0,0,0, fill='#c0f0f0',
outline='black')
self._exprline = canvas.create_line(0,0,0,0, dash='.')
self._stacktop = canvas.create_line(0,0,0,0, fill='#408080')
size = self._size.get()+4
self._stacklabel = TextWidget(canvas, 'Stack', color='#004040',
font=self._boldfont)
self._rtextlabel = TextWidget(canvas, 'Remaining Text',
color='#004040', font=self._boldfont)
self._cframe.add_widget(self._stacklabel)
self._cframe.add_widget(self._rtextlabel)
#########################################
## Main draw procedure
#########################################
def _redraw(self):
scrollregion = self._canvas['scrollregion'].split()
(cx1, cy1, cx2, cy2) = [int(c) for c in scrollregion]
# Delete the old stack & rtext widgets.
for stackwidget in self._stackwidgets:
self._cframe.destroy_widget(stackwidget)
self._stackwidgets = []
for rtextwidget in self._rtextwidgets:
self._cframe.destroy_widget(rtextwidget)
self._rtextwidgets = []
# Position the titlebar & exprline
(x1, y1, x2, y2) = self._stacklabel.bbox()
y = y2-y1+10
self._canvas.coords(self._titlebar, -5000, 0, 5000, y-4)
self._canvas.coords(self._exprline, 0, y*2-10, 5000, y*2-10)
# Position the titlebar labels..
(x1, y1, x2, y2) = self._stacklabel.bbox()
self._stacklabel.move(5-x1, 3-y1)
(x1, y1, x2, y2) = self._rtextlabel.bbox()
self._rtextlabel.move(cx2-x2-5, 3-y1)
# Draw the stack.
stackx = 5
for tok in self._parser.stack():
if isinstance(tok, Tree):
attribs = {'tree_color': '#4080a0', 'tree_width': 2,
'node_font': self._boldfont,
'node_color': '#006060',
'leaf_color': '#006060', 'leaf_font':self._font}
widget = tree_to_treesegment(self._canvas, tok,
**attribs)
widget.label()['color'] = '#000000'
else:
widget = TextWidget(self._canvas, tok,
color='#000000', font=self._font)
widget.bind_click(self._popup_reduce)
self._stackwidgets.append(widget)
self._cframe.add_widget(widget, stackx, y)
stackx = widget.bbox()[2] + 10
# Draw the remaining text.
rtextwidth = 0
for tok in self._parser.remaining_text():
widget = TextWidget(self._canvas, tok,
color='#000000', font=self._font)
self._rtextwidgets.append(widget)
self._cframe.add_widget(widget, rtextwidth, y)
rtextwidth = widget.bbox()[2] + 4
# Allow enough room to shift the next token (for animations)
if len(self._rtextwidgets) > 0:
stackx += self._rtextwidgets[0].width()
# Move the remaining text to the correct location (keep it
# right-justified, when possible); and move the remaining text
# label, if necessary.
stackx = max(stackx, self._stacklabel.width()+25)
rlabelwidth = self._rtextlabel.width()+10
if stackx >= cx2-max(rtextwidth, rlabelwidth):
cx2 = stackx + max(rtextwidth, rlabelwidth)
for rtextwidget in self._rtextwidgets:
rtextwidget.move(4+cx2-rtextwidth, 0)
self._rtextlabel.move(cx2-self._rtextlabel.bbox()[2]-5, 0)
midx = (stackx + cx2-max(rtextwidth, rlabelwidth))/2
self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
(x1, y1, x2, y2) = self._stacklabel.bbox()
# Set up binding to allow them to shift a token by dragging it.
if len(self._rtextwidgets) > 0:
def drag_shift(widget, midx=midx, self=self):
if widget.bbox()[0] < midx: self.shift()
else: self._redraw()
self._rtextwidgets[0].bind_drag(drag_shift)
self._rtextwidgets[0].bind_click(self.shift)
# Draw the stack top.
self._highlight_productions()
def _draw_stack_top(self, widget):
# hack..
midx = widget.bbox()[2]+50
self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
def _highlight_productions(self):
# Highlight the productions that can be reduced.
self._prodlist.selection_clear(0, 'end')
for prod in self._parser.reducible_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
#########################################
## Button Callbacks
#########################################
def destroy(self, *e):
if self._top is None: return
self._top.destroy()
self._top = None
def reset(self, *e):
self._parser.initialize(self._sent)
self._lastoper1['text'] = 'Reset App'
self._lastoper2['text'] = ''
self._redraw()
def step(self, *e):
if self.reduce(): return True
elif self.shift(): return True
else:
if list(self._parser.parses()):
self._lastoper1['text'] = 'Finished:'
self._lastoper2['text'] = 'Success'
else:
self._lastoper1['text'] = 'Finished:'
self._lastoper2['text'] = 'Failure'
def shift(self, *e):
if self._animating_lock: return
if self._parser.shift():
tok = self._parser.stack()[-1]
self._lastoper1['text'] = 'Shift:'
self._lastoper2['text'] = '%r' % tok
if self._animate.get():
self._animate_shift()
else:
self._redraw()
return True
return False
def reduce(self, *e):
if self._animating_lock: return
production = self._parser.reduce()
if production:
self._lastoper1['text'] = 'Reduce:'
self._lastoper2['text'] = '%s' % production
if self._animate.get():
self._animate_reduce()
else:
self._redraw()
return production
def undo(self, *e):
if self._animating_lock: return
if self._parser.undo():
self._redraw()
def postscript(self, *e):
self._cframe.print_to_file()
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self._top.mainloop(*args, **kwargs)
#########################################
## Menubar callbacks
#########################################
def resize(self, size=None):
if size is not None: self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._boldfont.configure(size=-(abs(size)))
self._sysfont.configure(size=-(abs(size)))
#self._stacklabel['font'] = ('helvetica', -size-4, 'bold')
#self._rtextlabel['font'] = ('helvetica', -size-4, 'bold')
#self._lastoper_label['font'] = ('helvetica', -size)
#self._lastoper1['font'] = ('helvetica', -size)
#self._lastoper2['font'] = ('helvetica', -size)
#self._prodlist['font'] = ('helvetica', -size)
#self._prodlist_label['font'] = ('helvetica', -size-2, 'bold')
self._redraw()
def help(self, *e):
# The default font's not very legible; try using 'fixed' instead.
try:
ShowText(self._top, 'Help: Shift-Reduce Parser Application',
(__doc__ or '').strip(), width=75, font='fixed')
except:
ShowText(self._top, 'Help: Shift-Reduce Parser Application',
(__doc__ or '').strip(), width=75)
def about(self, *e):
ABOUT = ("NLTK Shift-Reduce Parser Application\n"+
"Written by Edward Loper")
TITLE = 'About: Shift-Reduce Parser Application'
try:
from tkinter.messagebox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self._top, TITLE, ABOUT)
def edit_grammar(self, *e):
CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
def set_grammar(self, grammar):
self._parser.set_grammar(grammar)
self._productions = list(grammar.productions())
self._prodlist.delete(0, 'end')
for production in self._productions:
self._prodlist.insert('end', (' %s' % production))
def edit_sentence(self, *e):
sentence = " ".join(self._sent)
title = 'Edit Text'
instr = 'Enter a new sentence to parse.'
EntryDialog(self._top, sentence, instr, self.set_sentence, title)
def set_sentence(self, sent):
self._sent = sent.split() #[XX] use tagged?
self.reset()
#########################################
## Reduce Production Selection
#########################################
def _toggle_grammar(self, *e):
if self._show_grammar.get():
self._prodframe.pack(fill='both', side='left', padx=2,
after=self._feedbackframe)
self._lastoper1['text'] = 'Show Grammar'
else:
self._prodframe.pack_forget()
self._lastoper1['text'] = 'Hide Grammar'
self._lastoper2['text'] = ''
def _prodlist_select(self, event):
selection = self._prodlist.curselection()
if len(selection) != 1: return
index = int(selection[0])
production = self._parser.reduce(self._productions[index])
if production:
self._lastoper1['text'] = 'Reduce:'
self._lastoper2['text'] = '%s' % production
if self._animate.get():
self._animate_reduce()
else:
self._redraw()
else:
# Reset the production selections.
self._prodlist.selection_clear(0, 'end')
for prod in self._parser.reducible_productions():
index = self._productions.index(prod)
self._prodlist.selection_set(index)
def _popup_reduce(self, widget):
# Remove old commands.
productions = self._parser.reducible_productions()
if len(productions) == 0: return
self._reduce_menu.delete(0, 'end')
for production in productions:
self._reduce_menu.add_command(label=str(production),
command=self.reduce)
self._reduce_menu.post(self._canvas.winfo_pointerx(),
self._canvas.winfo_pointery())
#########################################
## Animations
#########################################
def _animate_shift(self):
# What widget are we shifting?
widget = self._rtextwidgets[0]
# Where are we shifting from & to?
right = widget.bbox()[0]
if len(self._stackwidgets) == 0: left = 5
else: left = self._stackwidgets[-1].bbox()[2]+10
# Start animating.
dt = self._animate.get()
dx = (left-right)*1.0/dt
self._animate_shift_frame(dt, widget, dx)
def _animate_shift_frame(self, frame, widget, dx):
if frame > 0:
self._animating_lock = 1
widget.move(dx, 0)
self._top.after(10, self._animate_shift_frame,
frame-1, widget, dx)
else:
# but: stacktop??
# Shift the widget to the stack.
del self._rtextwidgets[0]
self._stackwidgets.append(widget)
self._animating_lock = 0
# Display the available productions.
self._draw_stack_top(widget)
self._highlight_productions()
def _animate_reduce(self):
# What widgets are we shifting?
numwidgets = len(self._parser.stack()[-1]) # number of children
widgets = self._stackwidgets[-numwidgets:]
# How far are we moving?
if isinstance(widgets[0], TreeSegmentWidget):
ydist = 15 + widgets[0].label().height()
else:
ydist = 15 + widgets[0].height()
# Start animating.
dt = self._animate.get()
dy = ydist*2.0/dt
self._animate_reduce_frame(dt/2, widgets, dy)
def _animate_reduce_frame(self, frame, widgets, dy):
if frame > 0:
self._animating_lock = 1
for widget in widgets: widget.move(0, dy)
self._top.after(10, self._animate_reduce_frame,
frame-1, widgets, dy)
else:
del self._stackwidgets[-len(widgets):]
for widget in widgets:
self._cframe.remove_widget(widget)
tok = self._parser.stack()[-1]
if not isinstance(tok, Tree): raise ValueError()
label = TextWidget(self._canvas, str(tok.label()), color='#006060',
font=self._boldfont)
widget = TreeSegmentWidget(self._canvas, label, widgets,
width=2)
(x1, y1, x2, y2) = self._stacklabel.bbox()
y = y2-y1+10
if not self._stackwidgets: x = 5
else: x = self._stackwidgets[-1].bbox()[2] + 10
self._cframe.add_widget(widget, x, y)
self._stackwidgets.append(widget)
# Display the available productions.
self._draw_stack_top(widget)
self._highlight_productions()
# # Delete the old widgets..
# del self._stackwidgets[-len(widgets):]
# for widget in widgets:
# self._cframe.destroy_widget(widget)
#
# # Make a new one.
# tok = self._parser.stack()[-1]
# if isinstance(tok, Tree):
# attribs = {'tree_color': '#4080a0', 'tree_width': 2,
# 'node_font': bold, 'node_color': '#006060',
# 'leaf_color': '#006060', 'leaf_font':self._font}
# widget = tree_to_treesegment(self._canvas, tok.type(),
# **attribs)
# widget.node()['color'] = '#000000'
# else:
# widget = TextWidget(self._canvas, tok.type(),
# color='#000000', font=self._font)
# widget.bind_click(self._popup_reduce)
# (x1, y1, x2, y2) = self._stacklabel.bbox()
# y = y2-y1+10
# if not self._stackwidgets: x = 5
# else: x = self._stackwidgets[-1].bbox()[2] + 10
# self._cframe.add_widget(widget, x, y)
# self._stackwidgets.append(widget)
#self._redraw()
self._animating_lock = 0
#########################################
## Hovering.
#########################################
def _highlight_hover(self, event):
# What production are we hovering over?
index = self._prodlist.nearest(event.y)
if self._hover == index: return
# Clear any previous hover highlighting.
self._clear_hover()
# If the production corresponds to an available reduction,
# highlight the stack.
selection = [int(s) for s in self._prodlist.curselection()]
if index in selection:
rhslen = len(self._productions[index].rhs())
for stackwidget in self._stackwidgets[-rhslen:]:
if isinstance(stackwidget, TreeSegmentWidget):
stackwidget.label()['color'] = '#00a000'
else:
stackwidget['color'] = '#00a000'
# Remember what production we're hovering over.
self._hover = index
def _clear_hover(self, *event):
# Clear any previous hover highlighting.
if self._hover == -1: return
self._hover = -1
for stackwidget in self._stackwidgets:
if isinstance(stackwidget, TreeSegmentWidget):
stackwidget.label()['color'] = 'black'
else:
stackwidget['color'] = 'black'
class Calculator:
def __init__(self, master):
self.master = master
master.title("Calculator")
self.total = 0
self.entered_number = 0
self.total_label_text = IntVar()
self.total_label_text.set(self.total)
self.total_label = Label(master, textvariable=self.total_label_text)
self.label = Label(master, text="Total:")
vcmd = master.register(self.validate) # we have to wrap the command
self.entry = Entry(master,
validate="key",
validatecommand=(vcmd, '%P'))
self.add_button = Button(master,
text="+",
command=lambda: self.update("add"))
self.subtract_button = Button(master,
text="-",
command=lambda: self.update("subtract"))
self.reset_button = Button(master,
text="Reset",
command=lambda: self.update("reset"))
# LAYOUT
self.label.grid(row=0, column=0, sticky=W)
self.total_label.grid(row=0, column=1, columnspan=2, sticky=E)
self.entry.grid(row=1, column=0, columnspan=3, sticky=W + E)
self.add_button.grid(row=2, column=0)
self.subtract_button.grid(row=2, column=1)
self.reset_button.grid(row=2, column=2, sticky=W + E)
def validate(self, new_text):
if not new_text: # the field is being cleared
self.entered_number = 0
return True
try:
self.entered_number = int(new_text)
return True
except ValueError:
return False
def update(self, method):
if method == "add":
self.total += self.entered_number
elif method == "subtract":
self.total -= self.entered_number
else: # reset
self.total = 0
self.total_label_text.set(self.total)
self.entry.delete(0, END)
class CadastroVeiculo:
def __init__(self, master):
self.app_main = tkinter.Toplevel(master)
# self.app_main = tkinter.Tk()
self.app_main.title("Cadastro de Veículo")
self.centralizar_tela()
self.atualizando_cadastro = False
self.veiculo_atual = None
self.combobox_tipo_veiculo = None
self.combobox_peso_balanca = None
self.tipo_veiculo = StringVar()
self.tolerancia_balanca = StringVar()
self.quantidade_lacres = IntVar()
self.lote = StringVar()
self.placa_1 = StringVar()
self.placa_2 = StringVar()
self.placa_3 = StringVar()
self.placa_4 = StringVar()
Label(self.app_main, text="Tipo Veículo: ",
font=(None, 8, 'normal')).grid(sticky=W, column=0, row=0, padx=5)
self.combobox_tipo_veiculo = Combobox(self.app_main,
textvariable=self.tipo_veiculo,
width=40,
state="readonly")
self.combobox_tipo_veiculo.grid(sticky="we",
column=0,
row=1,
padx=5,
columnspan=2)
self.combobox_tipo_veiculo['values'] = [
t for t in TipoVeiculoService.listar_tipos_veiculos()
]
Label(self.app_main, text="Peso Balança: ",
font=(None, 8, 'normal')).grid(sticky=W, column=0, row=2, padx=5)
self.combobox_peso_balanca = Combobox(
self.app_main,
textvariable=self.tolerancia_balanca,
width=40,
state="readonly")
self.combobox_peso_balanca.grid(sticky="we",
column=0,
row=3,
padx=5,
columnspan=2)
self.combobox_peso_balanca['values'] = [
t for t in PesoBalancaService.listar_pesos_balanca()
]
Label(self.app_main, text="Qtd. Lacres:",
font=(None, 8, 'normal')).grid(sticky=W, column=0, row=4, padx=5)
entry_numero_lacres = tkinter.Entry(
self.app_main, textvariable=self.quantidade_lacres)
entry_numero_lacres.grid(sticky="we",
column=0,
row=5,
padx=(5, 10),
columnspan=2)
entry_numero_lacres.config(validate="key",
validatecommand=(self.app_main.register(
NumberUtils.eh_inteiro), '%P'))
Label(self.app_main, text="Cavalo: ",
font=(None, 8, 'normal')).grid(sticky=W, column=0, row=6, padx=5)
entry_placa_1 = Entry(self.app_main, textvariable=self.placa_1)
entry_placa_1.grid(sticky="we", column=0, row=7, padx=5)
entry_placa_1.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.placa_1))
Label(self.app_main,
text="Município Cavalo: ",
font=(None, 8, 'normal')).grid(sticky=W, column=1, row=6, padx=5)
self.entry_municipio_placa_1 = AutocompleteEntry(self.app_main,
width=20)
self.entry_municipio_placa_1.grid(sticky="we",
column=1,
row=7,
padx=(5, 10))
self.entry_municipio_placa_1.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.entry_municipio_placa_1.var))
Label(self.app_main, text="Placa 2: ",
font=(None, 8, 'normal')).grid(sticky=W, column=0, row=8, padx=5)
entry_placa_2 = Entry(self.app_main, textvariable=self.placa_2)
entry_placa_2.grid(sticky="we", column=0, row=9, padx=5)
entry_placa_2.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.placa_2))
Label(self.app_main,
text="Município Placa 2: ",
font=(None, 8, 'normal')).grid(sticky=W, column=1, row=8, padx=5)
self.entry_municipio_placa_2 = AutocompleteEntry(self.app_main,
width=20)
self.entry_municipio_placa_2.grid(sticky="we",
column=1,
row=9,
padx=(5, 10))
self.entry_municipio_placa_2.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.entry_municipio_placa_2.var))
Label(self.app_main, text="Placa 3: ",
font=(None, 8, 'normal')).grid(sticky=W,
column=0,
row=10,
padx=5)
entry_placa_3 = Entry(self.app_main, textvariable=self.placa_3)
entry_placa_3.grid(sticky="we", column=0, row=11, padx=5)
entry_placa_3.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.placa_3))
Label(self.app_main,
text="Município Placa 3: ",
font=(None, 8, 'normal')).grid(sticky=W,
column=1,
row=10,
padx=5)
self.entry_municipio_placa_3 = AutocompleteEntry(self.app_main,
width=20)
self.entry_municipio_placa_3.grid(sticky="we",
column=1,
row=11,
padx=(5, 10))
self.entry_municipio_placa_3.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.entry_municipio_placa_3.var))
Label(self.app_main, text="Placa 4: ",
font=(None, 8, 'normal')).grid(sticky=W,
column=0,
row=12,
padx=5)
entry_placa_4 = Entry(self.app_main, textvariable=self.placa_4)
entry_placa_4.grid(sticky="we", column=0, row=13, padx=5)
entry_placa_4.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.placa_4))
Label(self.app_main,
text="Município Placa 4: ",
font=(None, 8, 'normal')).grid(sticky=W,
column=1,
row=12,
padx=5)
self.entry_municipio_placa_4 = AutocompleteEntry(self.app_main,
width=20)
self.entry_municipio_placa_4.grid(sticky="we",
column=1,
row=13,
padx=(5, 10))
self.entry_municipio_placa_4.bind(
"<KeyRelease>",
lambda ev: CadastroVeiculo.converter_para_maiusculo(
ev, self.entry_municipio_placa_4.var))
Button(self.app_main, text='Salvar', command=self.salvar_ou_atualizar) \
.grid(sticky='we', column=0, row=14, padx=5, pady=5)
self.botao_deletar = Button(self.app_main,
text='Excluir',
command=self.deletar,
state=DISABLED)
self.botao_deletar.grid(sticky='we',
column=1,
row=14,
padx=10,
pady=10)
def centralizar_tela(self):
window_width = self.app_main.winfo_reqwidth()
window_height = self.app_main.winfo_reqheight()
position_right = int(self.app_main.winfo_screenwidth() / 2.3 -
window_width / 2)
position_down = int(self.app_main.winfo_screenheight() / 3 -
window_height / 2)
self.app_main.geometry("+{}+{}".format(position_right, position_down))
@staticmethod
def converter_para_maiusculo(event, var):
var.set(var.get().upper())
def salvar_ou_atualizar(self):
try:
self.verificar_campos_obrigatorios()
if self.veiculo_atual is None or self.veiculo_atual.id is None:
self.salvar()
else:
self.atualizar()
except RuntimeError as e:
messagebox.showerror("Erro", e)
def salvar(self):
try:
self.veiculo_atual = Veiculo()
self.atualizar_dados_veiculo(self.veiculo_atual)
VeiculoService.salvar_ou_atualizar(self.veiculo_atual)
messagebox.showinfo("Sucesso", "Veículo salvo com sucesso!")
self.app_main.destroy()
except peewee.IntegrityError:
traceback.print_exc(file=sys.stdout)
messagebox.showerror(
"Cadastro duplicado!",
"Já existe um veículo cadastrado com esses dados!")
except Exception as e:
messagebox.showerror("Erro", e)
def atualizar(self):
try:
self.atualizar_dados_veiculo(self.veiculo_atual)
VeiculoService.salvar_ou_atualizar(self.veiculo_atual)
messagebox.showinfo("Sucesso", "Veículo atualizado com sucesso!")
self.app_main.destroy()
except Exception as e:
messagebox.showerror("Erro", e)
def deletar(self):
deletar = messagebox.askokcancel("Confirmar",
"Excluir registro pernamentemente ?")
if deletar:
try:
VeiculoService.deletar_veiculo(self.veiculo_atual)
messagebox.showinfo("Sucesso", "Veículo deletado com sucesso!")
except Exception as e:
messagebox.showerror("Erro",
"Erro deletar veículo!\n{}".format(e))
def atualizar_dados_veiculo(self, veiculo):
self.botao_deletar['state'] = 'normal'
descricao_tipo_veiculo = self.tipo_veiculo.get().split(' - ')[1]
tipo_veiculo = TipoVeiculoService.pesquisar_tipo_veiculo_pela_descricao(
descricao_tipo_veiculo)
descricao_peso_balanca = self.tolerancia_balanca.get().split(' - ')[1]
peso_balanca = PesoBalancaService.pesquisar_pesos_balanca_pela_descricao(
descricao_peso_balanca)
quantidade_lacres = self.quantidade_lacres.get()
placa1 = self.placa_1.get().strip()
placa2 = self.placa_2.get().strip()
placa3 = self.placa_3.get().strip()
placa4 = self.placa_4.get().strip()
c1 = CadastroVeiculo.extrair_codigo_municipio(
self.entry_municipio_placa_1.get())
c2 = CadastroVeiculo.extrair_codigo_municipio(
self.entry_municipio_placa_2.get())
c3 = CadastroVeiculo.extrair_codigo_municipio(
self.entry_municipio_placa_3.get())
c4 = CadastroVeiculo.extrair_codigo_municipio(
self.entry_municipio_placa_4.get())
municipio_placa1 = MunicipioService.pesquisar_municipio_pelo_codigo(c1)
municipio_placa2 = MunicipioService.pesquisar_municipio_pelo_codigo(c2)
municipio_placa3 = MunicipioService.pesquisar_municipio_pelo_codigo(c3)
municipio_placa4 = MunicipioService.pesquisar_municipio_pelo_codigo(c4)
veiculo.tipo_veiculo = tipo_veiculo
veiculo.peso_balanca = peso_balanca
veiculo.quantidade_lacres = quantidade_lacres
veiculo.placa1 = placa1
veiculo.placa2 = placa2
veiculo.placa3 = placa3
veiculo.placa4 = placa4
veiculo.municipio_placa1 = municipio_placa1
veiculo.municipio_placa2 = municipio_placa2
veiculo.municipio_placa3 = municipio_placa3
veiculo.municipio_placa4 = municipio_placa4
@staticmethod
def extrair_codigo_municipio(municipio):
return "".join(re.findall("\\d*", municipio))
def verificar_campos_obrigatorios(self):
if not self.tipo_veiculo.get():
raise RuntimeError("Campo obrigatório",
"O campo 'Tipo Veículo' é obrigatório!")
if not self.tolerancia_balanca.get():
RuntimeError("Campo obrigatório",
"O campo 'Tolerância Balança' é obrigatório!")
if not self.placa_1.get():
RuntimeError("Campo obrigatório",
"A placa do cavalo é obrigatório!")
CadastroVeiculo.validar_formato_placa(self.placa_1.get().strip())
CadastroVeiculo.validar_formato_municipio(
self.entry_municipio_placa_1.get().strip())
if self.placa_2.get().strip():
CadastroVeiculo.validar_formato_placa(self.placa_2.get().strip())
CadastroVeiculo.validar_formato_municipio(
self.entry_municipio_placa_2.get().strip())
if self.placa_3.get().strip():
CadastroVeiculo.validar_formato_placa(self.placa_3.get().strip())
CadastroVeiculo.validar_formato_municipio(
self.entry_municipio_placa_3.get().strip())
if self.placa_4.get().strip():
CadastroVeiculo.validar_formato_placa(self.placa_4.get().strip())
CadastroVeiculo.validar_formato_municipio(
self.entry_municipio_placa_4.get().strip())
@staticmethod
def validar_formato_placa(placa):
formato_correto = bool(
re.match("^[A-Z]{3}[0-9][0-9A-Z][0-9]{2}$", placa))
print('formato: {} - {}'.format(formato_correto, placa))
if not formato_correto:
raise RuntimeError(
"Placa '{}' está em um formato inválido!".format(placa))
@staticmethod
def validar_formato_municipio(municipio):
formato_correto = bool(re.match("^[A-Z]{2}\\s[0-9]{7}$", municipio))
print('formato: {} - {}'.format(formato_correto, municipio))
if not formato_correto:
raise RuntimeError(
"Município '{}' está em um formato inválido!".format(
municipio))
def setar_campos_para_edicao(self, veiculo):
self.botao_deletar['state'] = 'normal'
self.veiculo_atual = veiculo
CadastroVeiculo.selecionar_item_combobox(self.combobox_tipo_veiculo,
veiculo.tipo_veiculo)
CadastroVeiculo.selecionar_item_combobox(self.combobox_peso_balanca,
veiculo.peso_balanca)
self.quantidade_lacres.set(veiculo.quantidade_lacres)
self.placa_1.set(veiculo.placa1)
self.placa_2.set(veiculo.placa2 if veiculo.placa2 else '')
self.placa_3.set(veiculo.placa3 if veiculo.placa3 else '')
self.placa_4.set(veiculo.placa4 if veiculo.placa4 else '')
self.entry_municipio_placa_1.var.set('{} {}'.format(
veiculo.municipio_placa1.uf, veiculo.municipio_placa1.codigo))
if veiculo.placa2:
self.entry_municipio_placa_2.var.set('{} {}'.format(
veiculo.municipio_placa2.uf, veiculo.municipio_placa2.codigo))
if veiculo.placa3:
self.entry_municipio_placa_3.var.set('{} {}'.format(
veiculo.municipio_placa3.uf, veiculo.municipio_placa3.codigo))
if veiculo.placa4:
self.entry_municipio_placa_4.var.set('{} {}'.format(
veiculo.municipio_placa4.uf, veiculo.municipio_placa4.codigo))
@staticmethod
def selecionar_item_combobox(combobox, selecao):
cont = 0
for v in combobox['values']:
if v == str(selecao):
combobox.current(cont)
cont += 1
class TestItem:
def __init__(self, master, title, x_coor, y_coor, serial=False):
self.__chb_var = IntVar()
self.__p_value = StringVar()
self.__result = StringVar()
self.__p_value_02 = StringVar()
self.__result_02 = StringVar()
checkbox = Checkbutton(master, text=title, variable=self.__chb_var)
checkbox.place(x=x_coor, y=y_coor)
p_value_entry = Entry(master, textvariable=self.__p_value)
p_value_entry.config(state=DISABLED)
p_value_entry.place(x=365, y=y_coor, width=500, height=25)
result_entry = Entry(master, textvariable=self.__result)
result_entry.config(state=DISABLED)
result_entry.place(x=870, y=y_coor, width=350, height=25)
if serial:
p_value_entry_02 = Entry(master, textvariable=self.__p_value_02)
p_value_entry_02.config(state=DISABLED)
p_value_entry_02.place(x=365, y=y_coor + 30, width=500, height=25)
result_entry_02 = Entry(master, textvariable=self.__result_02)
result_entry_02.config(state=DISABLED)
result_entry_02.place(x=870, y=y_coor + 30, width=350, height=25)
def get_check_box_value(self):
return self.__chb_var.get()
def set_check_box_value(self, value):
self.__chb_var.set(value)
def set_p_value(self, value):
self.__p_value.set(value)
def set_result_value(self, value):
self.__result.set(value)
def set_p_value_02(self, value):
self.__p_value_02.set(value)
def set_result_value_02(self, value):
self.__result_02.set(value)
def set_values(self, values):
self.__p_value.set(values[0])
self.__result.set(self.__get_result_string(values[1]))
def set_p_2_values(self, values):
self.__p_value_02(values[0])
self.__result_02(self.__get_result_string(values[1]))
def reset(self):
self.set_check_box_value(0)
self.set_p_value('')
self.set_result_value('')
self.set_p_value_02('')
self.set_result_value_02('')
def __get_result_string(self, result):
if result == True:
return 'Random'
else:
return 'Non-Random'
class CFGDemo:
def __init__(self, grammar, text):
self._grammar = grammar
self._text = text
# Set up the main window.
self._top = Tk()
self._top.title("Context Free Grammar Demo")
# Base font size
self._size = IntVar(self._top)
self._size.set(12) # = medium
# Set up the key bindings
self._init_bindings(self._top)
# Create the basic frames
frame1 = Frame(self._top)
frame1.pack(side="left", fill="y", expand=0)
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_grammar(frame1)
self._init_treelet(frame1)
self._init_workspace(self._top)
# //////////////////////////////////////////////////
# Initialization
# //////////////////////////////////////////////////
def _init_bindings(self, top):
top.bind("<Control-q>", self.destroy)
def _init_menubar(self, parent):
pass
def _init_buttons(self, parent):
pass
def _init_grammar(self, parent):
self._prodlist = ProductionList(parent, self._grammar, width=20)
self._prodlist.pack(side="top", fill="both", expand=1)
self._prodlist.focus()
self._prodlist.add_callback("select", self._selectprod_cb)
self._prodlist.add_callback("move", self._selectprod_cb)
def _init_treelet(self, parent):
self._treelet_canvas = Canvas(parent, background="white")
self._treelet_canvas.pack(side="bottom", fill="x")
self._treelet = None
def _init_workspace(self, parent):
self._workspace = CanvasFrame(parent, background="white")
self._workspace.pack(side="right", fill="both", expand=1)
self._tree = None
self.reset_workspace()
# //////////////////////////////////////////////////
# Workspace
# //////////////////////////////////////////////////
def reset_workspace(self):
c = self._workspace.canvas()
fontsize = int(self._size.get())
node_font = ("helvetica", -(fontsize + 4), "bold")
leaf_font = ("helvetica", -(fontsize + 2))
# Remove the old tree
if self._tree is not None:
self._workspace.remove_widget(self._tree)
# The root of the tree.
start = self._grammar.start().symbol()
rootnode = TextWidget(c, start, font=node_font, draggable=1)
# The leaves of the tree.
leaves = []
for word in self._text:
leaves.append(TextWidget(c, word, font=leaf_font, draggable=1))
# Put it all together into one tree
self._tree = TreeSegmentWidget(c, rootnode, leaves, color="white")
# Add it to the workspace.
self._workspace.add_widget(self._tree)
# Move the leaves to the bottom of the workspace.
for leaf in leaves:
leaf.move(0, 100)
# self._nodes = {start:1}
# self._leaves = dict([(l,1) for l in leaves])
def workspace_markprod(self, production):
pass
def _markproduction(self, prod, tree=None):
if tree is None:
tree = self._tree
for i in range(len(tree.subtrees()) - len(prod.rhs())):
if tree["color", i] == "white":
self._markproduction # FIXME: Is this necessary at all?
for j, node in enumerate(prod.rhs()):
widget = tree.subtrees()[i + j]
if (isinstance(node, Nonterminal)
and isinstance(widget, TreeSegmentWidget)
and node.symbol == widget.label().text()):
pass # matching nonterminal
elif (isinstance(node, str) and isinstance(widget, TextWidget)
and node == widget.text()):
pass # matching nonterminal
else:
break
else:
# Everything matched!
print("MATCH AT", i)
# //////////////////////////////////////////////////
# Grammar
# //////////////////////////////////////////////////
def _selectprod_cb(self, production):
canvas = self._treelet_canvas
self._prodlist.highlight(production)
if self._treelet is not None:
self._treelet.destroy()
# Convert the production to a tree.
rhs = production.rhs()
for (i, elt) in enumerate(rhs):
if isinstance(elt, Nonterminal):
elt = Tree(elt)
tree = Tree(production.lhs().symbol(), *rhs)
# Draw the tree in the treelet area.
fontsize = int(self._size.get())
node_font = ("helvetica", -(fontsize + 4), "bold")
leaf_font = ("helvetica", -(fontsize + 2))
self._treelet = tree_to_treesegment(canvas,
tree,
node_font=node_font,
leaf_font=leaf_font)
self._treelet["draggable"] = 1
# Center the treelet.
(x1, y1, x2, y2) = self._treelet.bbox()
w, h = int(canvas["width"]), int(canvas["height"])
self._treelet.move((w - x1 - x2) / 2, (h - y1 - y2) / 2)
# Mark the places where we can add it to the workspace.
self._markproduction(production)
def destroy(self, *args):
self._top.destroy()
def mainloop(self, *args, **kwargs):
self._top.mainloop(*args, **kwargs)
class UBX_MSGRATE_Frame(Frame):
"""
UBX Message Rate configuration command panel.
"""
def __init__(self, app, container, *args, **kwargs):
"""
Constructor.
:param object app: reference to main tkinter application
:param frame container: container frame
"""
self.__app = app # Reference to main application class
self.__master = self.__app.get_master() # Reference to root class (Tk)
self.__container = container
Frame.__init__(self, self.__container.container, *args, **kwargs)
self._img_send = ImageTk.PhotoImage(Image.open(ICON_SEND))
self._img_pending = ImageTk.PhotoImage(Image.open(ICON_PENDING))
self._img_confirmed = ImageTk.PhotoImage(Image.open(ICON_CONFIRMED))
self._img_warn = ImageTk.PhotoImage(Image.open(ICON_WARNING))
self._ddc_rate = IntVar()
self._uart1_rate = IntVar()
self._usb_rate = IntVar()
self._spi_rate = IntVar()
self._cfg_msg_command = None
self._body()
self._do_layout()
self._attach_events()
self._reset()
def _body(self):
"""
Set up frame and widgets.
"""
MAX_RATE = 0xFF
self._lbl_cfg_msg = Label(self, text=LBLCFGMSG, anchor="w")
self._lbx_cfg_msg = Listbox(
self,
border=2,
relief="sunken",
bg=ENTCOL,
height=7,
justify=LEFT,
exportselection=False,
)
self._scr_cfg_msg = Scrollbar(self, orient=VERTICAL)
self._lbx_cfg_msg.config(yscrollcommand=self._scr_cfg_msg.set)
self._scr_cfg_msg.config(command=self._lbx_cfg_msg.yview)
self._lbl_ddc = Label(self, text="I2C")
self._spn_ddc = Spinbox(
self,
width=3,
from_=0,
to=MAX_RATE,
textvariable=self._ddc_rate,
state=READONLY,
readonlybackground=ENTCOL,
)
self._lbl_uart1 = Label(self, text="UART1")
self._spn_uart1 = Spinbox(
self,
width=3,
from_=0,
to=MAX_RATE,
textvariable=self._uart1_rate,
state=READONLY,
readonlybackground=ENTCOL,
)
self._lbl_usb = Label(self, text="USB")
self._spn_usb = Spinbox(
self,
width=3,
from_=0,
to=MAX_RATE,
textvariable=self._usb_rate,
state=READONLY,
readonlybackground=ENTCOL,
)
self._lbl_spi = Label(self, text="SPI")
self._spn_spi = Spinbox(
self,
width=3,
from_=0,
to=MAX_RATE,
textvariable=self._spi_rate,
state=READONLY,
readonlybackground=ENTCOL,
)
self._lbl_send_command = Label(self)
self._btn_send_command = Button(
self,
image=self._img_send,
width=50,
fg="green",
command=self._on_send_cfg_msg,
font=self.__app.font_md,
)
def _do_layout(self):
"""
Layout widgets.
"""
self._lbl_cfg_msg.grid(column=0, row=0, columnspan=6, padx=3, sticky=(W, E))
self._lbx_cfg_msg.grid(
column=0, row=1, columnspan=2, rowspan=8, padx=3, pady=3, sticky=(W, E)
)
self._scr_cfg_msg.grid(column=1, row=1, rowspan=8, sticky=(N, S, E))
self._lbl_ddc.grid(column=2, row=1, rowspan=2, padx=0, pady=1, sticky=(E))
self._spn_ddc.grid(column=3, row=1, rowspan=2, padx=0, pady=0, sticky=(W))
self._lbl_uart1.grid(column=2, row=3, rowspan=2, padx=0, pady=1, sticky=(E))
self._spn_uart1.grid(column=3, row=3, rowspan=2, padx=0, pady=0, sticky=(W))
self._lbl_usb.grid(column=2, row=5, rowspan=2, padx=0, pady=1, sticky=(E))
self._spn_usb.grid(column=3, row=5, rowspan=2, padx=0, pady=0, sticky=(W))
self._lbl_spi.grid(column=2, row=7, rowspan=2, padx=0, pady=1, sticky=(E))
self._spn_spi.grid(column=3, row=7, rowspan=2, padx=0, pady=0, sticky=(W))
self._btn_send_command.grid(
column=4, row=1, rowspan=8, ipadx=3, ipady=3, sticky=(E)
)
self._lbl_send_command.grid(
column=5, row=1, rowspan=8, ipadx=3, ipady=3, sticky=(E)
)
(cols, rows) = self.grid_size()
for i in range(cols):
self.grid_columnconfigure(i, weight=1)
for i in range(rows):
self.grid_rowconfigure(i, weight=1)
self.option_add("*Font", self.__app.font_sm)
def _attach_events(self):
"""
Bind listbox selection events.
"""
self._lbx_cfg_msg.bind("<<ListboxSelect>>", self._on_select_cfg_msg)
def _reset(self):
"""
Reset settings to defaults.
"""
idx = 0
for _, val in UBX_CONFIG_MESSAGES.items():
self._lbx_cfg_msg.insert(idx, val)
idx += 1
def update_status(self, cfgtype, **kwargs):
"""
Update pending confirmation status.
"""
if cfgtype == "CFG-MSG":
self.__container.set_status("CFG-MSG GET message received", "green")
self._ddc_rate.set(kwargs.get("ddcrate", 0))
self._uart1_rate.set(kwargs.get("uart1rate", 0))
self._usb_rate.set(kwargs.get("usbrate", 0))
self._spi_rate.set(kwargs.get("spirate", 0))
self._lbl_send_command.config(image=self._img_confirmed)
elif cfgtype == "ACK-NAK":
self.__container.set_status("CFG-MSG POLL message rejected", "red")
self._lbl_send_command.config(image=self._img_warn)
def _on_select_cfg_msg(self, *args, **kwargs): # pylint: disable=unused-argument
"""
CFG-MSG command has been selected.
"""
idx = self._lbx_cfg_msg.curselection()
self._cfg_msg_command = self._lbx_cfg_msg.get(idx)
# poll selected message configuration to get current message rates
msg = key_from_val(UBX_CONFIG_MESSAGES, self._cfg_msg_command)
self._do_poll_msg(msg)
def _on_send_cfg_msg(self, *args, **kwargs): # pylint: disable=unused-argument
"""
CFG-MSG command send button has been clicked.
"""
msg = key_from_val(UBX_CONFIG_MESSAGES, self._cfg_msg_command)
msgClass = int.from_bytes(msg[0:1], "little", signed=False)
msgID = int.from_bytes(msg[1:2], "little", signed=False)
rateDDC = int(self._ddc_rate.get())
rateUART1 = int(self._uart1_rate.get())
rateUSB = int(self._usb_rate.get())
rateSPI = int(self._spi_rate.get())
data = UBXMessage(
"CFG",
"CFG-MSG",
SET,
msgClass=msgClass,
msgID=msgID,
rateDDC=rateDDC,
rateUART1=rateUART1,
rateUSB=rateUSB,
rateSPI=rateSPI,
)
self.__app.serial_handler.serial_write(data.serialize())
self._lbl_send_command.config(image=self._img_pending)
self.__container.set_status("CFG-MSG SET message sent", "green")
self.__container.set_pending(UBX_CFGMSG, ("ACK-ACK", "ACK-NAK"))
self._do_poll_msg(msg)
def _do_poll_msg(self, msg):
"""
Poll message rate.
"""
data = UBXMessage("CFG", "CFG-MSG", POLL, payload=msg) # poll for a response
self.__app.serial_handler.serial_write(data.serialize())
self._lbl_send_command.config(image=self._img_pending)
self.__container.set_status("CFG-MSG POLL message sent", "blue")
self.__container.set_pending(UBX_CFGMSG, ("CFG-MSG", "ACK-NAK"))
class window(Tk):
"""Creates a window to display current progress in the game and return values given to the game object in order to progress
the game.
Creates a keyboard with extra buttons to show game stats, close the window, and start a new game
Finds the current stage of the game and displays the appropriate PNG file in the window"""
# Step 4.1: Create init function, bringing data from Game object
def __init__(self, game_obj: 'expects game class object'):
assert (type(game_obj)) == game
Tk.__init__(self)
self.title('Hangman')
self.geometry("1000x600+250+100")
self.head = Label(text='Hello World!')
self.game = game_obj
self.word_label = Label(self,
text=" " + self.game.partial_word + ' ',
font=('Concolas 24 bold'))
self.try_label = Label(self, text="Guesses left:")
self.wins_label = Label(self, text="Wins:")
self.losses_label = Label(self, text="Losses:")
self.labeltext = IntVar()
self.labeltext.set(self.game.Misses())
self.missNum = Label(self, textvariable=self.labeltext)
self.wintext = IntVar()
self.wintext.set(self.game.totalwin)
self.winNum = Label(self, textvariable=self.wintext)
self.losstext = IntVar()
self.losstext.set(self.game.totalloss)
self.lossNum = Label(self, textvariable=self.losstext)
self.keyboard_function()
self.hangman_stage(0)
self.package_update(0)
# Step 4.2: Create Hint keyboard function
def hint_function(self):
"""Function for the a button that returns the next letter while counting the hint as a missed guess"""
self.game.miss += 1
self.labeltext.set(self.game.miss)
for c in self.game.word.upper():
if c in self.game.partial_word:
pass
else:
x = c
self.keyboard_return(x)
break
self.package_update(1)
print(self.game.miss)
# Step 4.3: Create new game keyboard function
def new_game_button(self):
"""Function for the new game button to reset the game values and spawn a new word"""
self.game.new_game()
self.package_update(
0
) #Run both to set up initial conditions and reset all the previously triggered conditions
self.package_update(1)
# Step 4.4: Create keyboard function
def keyboard_function(self):
"""Function spawns all of the buttons for the GUI keyboard"""
self.close_button = Button(self,
text="Close",
command=self.quit,
activebackground='red',
activeforeground='light blue',
font=("Helvetica 18"),
width=4)
self.close_button.grid(row=4, column=12)
self.new_button = Button(self,
text="New Game",
command=lambda n=0: self.new_game_button(),
activebackground='red',
activeforeground='light blue',
font=("Helvetica 18"))
self.new_button.grid(row=4, column=3, columnspan=2)
self.miss_button = Button(self,
text="Hint",
command=self.hint_function,
font=("Helvetica 18"),
width=4)
self.miss_button.grid(column=3, row=3)
keyboard = [
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', 'A', 'S', 'D',
'F', 'G', 'H', 'J', 'K', 'L', 'Z', 'X', 'C', 'V', 'B', 'N', 'M'
]
n = 0
for i in keyboard:
Button(self,
text=i,
command=lambda d=i: self.keyboard_return(d),
font=("Helvetica 18"),
width=4).grid(row=2 + n // 10, column=3 + n % 10)
n += 1
if n == 10:
n += 1
elif n == 20:
n += 2
# Step 4.3: Create keyboard return function which gets called every time a button is activated
def keyboard_return(self, x: str):
"""Function takes button presses and progresses the game"""
assert (type(x)) == str
if self.game.miss < 6:
self.game.partial_word, self.game.miss = self.game.word_checker(
self.game.word, self.game.partial_word, x, self.game.miss)
self.package_update(
1
) # 2 Times because it doesnt work otherwise, probably due to timing
self.package_update(1)
print(self.game)
# Step 4.4: Create image function to render hangman picture and update it
def hangman_stage(self,
stage: int) -> 'Mutates imgLabel with Photoimage object':
"""function takes an integer between 0 and 6 and displays the corresponding stage in the GUI"""
assert (type(stage)) == int
photos = [
PhotoImage(file='hangman-0.png'),
PhotoImage(file='hangman-1.png'),
PhotoImage(file='hangman-2.png'),
PhotoImage(file='hangman-3.png'),
PhotoImage(file='hangman-4.png'),
PhotoImage(file='hangman-5.png'),
PhotoImage(file='hangman-6.png')
]
self.imgLabel = Label(image=photos[stage])
self.imgLabel.image = photos[
stage] # Python's garbage collector won't keep the images unless I create an object specific variable to hold it
self.imgLabel.images = photos
self.imgLabel.grid(row=0, column=0, columnspan=3, padx=10, pady=40)
# Step 4.5: Create a packing function to place all objects on the grid and update grid
def package_update(self, update: int):
"""function places all objects on a grid to display
the param update takes two arguments
0 - initial placement
1 - update placement
function places certain items on the grid every time it is ran
items that only need to be placed once are only executed if update = 0
otherwise items that only need to be placed during certain stages
or items that change throughout the game are placed if update = 1"""
self.word_label = Label(self,
text=" " + self.game.partial_word + " ",
font=('Concolas 24 bold'))
self.word_label.grid(row=0, column=3, columnspan=6, padx=10)
self.labeltext.set(self.game.Misses())
self.wintext.set(self.game.totalwin)
self.losstext.set(self.game.totalloss)
self.missNum.grid(column=1, row=2)
self.winNum.grid(column=1, row=3)
self.lossNum.grid(column=1, row=4)
if update == 0:
self.loss_label = Label(self,
text=' ',
font=('Concolas 24 bold'))
self.loss_label.grid(row=1, column=3, columnspan=6, padx=10)
self.head.grid(column=0, row=1)
self.try_label.grid(column=0, row=2)
self.losses_label.grid(column=0, row=4)
self.wins_label.grid(column=0, row=3)
else:
if self.game.miss < 6:
self.hangman_stage(self.game.miss)
self.loss_label = Label(self,
text=' ',
font=('Concolas 24 bold'))
self.loss_label.grid(row=1, column=3, columnspan=6, padx=10)
else:
self.hangman_stage(6)
self.loss_label = Label(self,
text='Y O U L O S T',
font=('Concolas 24 bold'))
self.loss_label.grid(row=1, column=3, columnspan=6, padx=10)
return
class TreeView(object):
def __init__(self, *trees):
from math import sqrt, ceil
self._trees = trees
self._top = Tk()
self._top.title('NLTK')
self._top.bind('<Control-x>', self.destroy)
self._top.bind('<Control-q>', self.destroy)
cf = self._cframe = CanvasFrame(self._top)
self._top.bind('<Control-p>', self._cframe.print_to_file)
# Size is variable.
self._size = IntVar(self._top)
self._size.set(12)
bold = ('helvetica', -self._size.get(), 'bold')
helv = ('helvetica', -self._size.get())
# Lay the trees out in a square.
self._width = int(ceil(sqrt(len(trees))))
self._widgets = []
for i in range(len(trees)):
widget = TreeWidget(cf.canvas(),
trees[i],
node_font=bold,
leaf_color='#008040',
node_color='#004080',
roof_color='#004040',
roof_fill='white',
line_color='#004040',
draggable=1,
leaf_font=helv)
widget.bind_click_trees(widget.toggle_collapsed)
self._widgets.append(widget)
cf.add_widget(widget, 0, 0)
self._layout()
self._cframe.pack(expand=1, fill='both')
self._init_menubar()
def _layout(self):
i = x = y = ymax = 0
width = self._width
for i in range(len(self._widgets)):
widget = self._widgets[i]
(oldx, oldy) = widget.bbox()[:2]
if i % width == 0:
y = ymax
x = 0
widget.move(x - oldx, y - oldy)
x = widget.bbox()[2] + 10
ymax = max(ymax, widget.bbox()[3] + 10)
def _init_menubar(self):
menubar = Menu(self._top)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Print to Postscript',
underline=0,
command=self._cframe.print_to_file,
accelerator='Ctrl-p')
filemenu.add_command(label='Exit',
underline=1,
command=self.destroy,
accelerator='Ctrl-x')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
zoommenu = Menu(menubar, tearoff=0)
zoommenu.add_radiobutton(label='Tiny',
variable=self._size,
underline=0,
value=10,
command=self.resize)
zoommenu.add_radiobutton(label='Small',
variable=self._size,
underline=0,
value=12,
command=self.resize)
zoommenu.add_radiobutton(label='Medium',
variable=self._size,
underline=0,
value=14,
command=self.resize)
zoommenu.add_radiobutton(label='Large',
variable=self._size,
underline=0,
value=28,
command=self.resize)
zoommenu.add_radiobutton(label='Huge',
variable=self._size,
underline=0,
value=50,
command=self.resize)
menubar.add_cascade(label='Zoom', underline=0, menu=zoommenu)
self._top.config(menu=menubar)
def resize(self, *e):
bold = ('helvetica', -self._size.get(), 'bold')
helv = ('helvetica', -self._size.get())
xspace = self._size.get()
yspace = self._size.get()
for widget in self._widgets:
widget['node_font'] = bold
widget['leaf_font'] = helv
widget['xspace'] = xspace
widget['yspace'] = yspace
if self._size.get() < 20: widget['line_width'] = 1
elif self._size.get() < 30: widget['line_width'] = 2
else: widget['line_width'] = 3
self._layout()
def destroy(self, *e):
if self._top is None: return
self._top.destroy()
self._top = None
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self._top.mainloop(*args, **kwargs)
class Root(Tk):
def __init__(self):
super(Root, self).__init__()
self.title('Biolocalizacion')
self.minsize(500, 200)
ico = os.path.join(PROJECT_DIR, 'resources/favicon.ico')
# self.wm_iconbitmap(ico)
self.labelFrameWaiting = ttk.LabelFrame(self, text='')
self.labelFrameWaiting.grid(column=0, row=1, padx=30, pady=10)
self.createLabel()
def createLabel(self):
self.labelFrameOptionMenu = ttk.LabelFrame(self,
text='Tipo de secuencia')
self.labelFrameOptionMenu.grid(column=0, row=0, padx=20, pady=20)
self.optionMenu()
self.labelFrameOpenFile = ttk.LabelFrame(
self, text='Abrir archivo a geolocalizar')
self.labelFrameOpenFile.grid(column=1, row=0, padx=20, pady=20)
self.label = ttk.Label(self.labelFrameOpenFile, text='')
self.label.grid(column=1, row=2)
self.button()
self.labelFrameBootstrap = ttk.LabelFrame(self, text='Bootstrap')
self.labelFrameBootstrap.grid(column=2, row=0, padx=20, pady=20)
self.input()
def optionMenu(self):
self.typeSequence = StringVar(self.labelFrameOptionMenu)
self.typeSequence.set(next(iter(SEQUENCE_TYPE.keys())))
w = OptionMenu(self.labelFrameOptionMenu, self.typeSequence,
*SEQUENCE_TYPE.keys())
w.pack()
def button(self):
self.button = ttk.Button(self.labelFrameOpenFile,
text='Ingrese archivo',
command=self.fileDialog)
self.button.grid(column=1, row=1, padx=30, pady=10)
def fileDialog(self):
if platform.system() == 'Windows': # Windows
self.fileName = filedialog.askopenfilename(
initialdir='/',
title='Seleccionar archivo',
filetype=(('fasta', '*.fasta'), ('All Files', '*.*')))
else: # linux variants
self.fileName = filedialog.askopenfilename(
initialdir='/',
title='Seleccionar archivo',
filetypes=(('fasta', '*.fasta'), ('All Files', '*.*')))
try:
self.check_fasta()
self.button.configure(text=os.path.basename(self.fileName))
self.waitingLabel()
geolocation.run(self.fileName,
alphabet=SEQUENCE_TYPE.get(
self.typeSequence.get()),
bootstrap=self.bootstrap.get(),
aligned=self.aligned,
quantitySequences=self.quantitySequences)
self.waitingLabel.config(text='Procesado con exito')
self.update()
filepath = 'egfr-family.phy.log'
# Windows
# threading.Thread(target=lambda: os.system('egfr-family.phy.log')).start()
# Linux
# threading.Thread(target=lambda: subprocess.run(["xdg-open", 'egfr-family.phy.log'], check=True)).start()
if platform.system() == 'Darwin': # macOS
threading.Thread(
target=lambda: subprocess.run(['open', filepath])).start()
elif platform.system() == 'Windows': # Windows
threading.Thread(target=lambda: os.startfile(filepath)).start()
else: # linux variants
threading.Thread(target=lambda: subprocess.run(
["xdg-open", filepath], check=True)).start()
threading.Thread(target=lambda: plt.show()).run()
self._update()
except FileNotFoundError:
pass
except TypeSequenceException:
pass
except Exception:
pass
def check_fasta(self):
self.aligned = False
self.is_fasta()
self.is_content_valid_fasta()
def is_fasta(self):
with open(self.fileName, "r") as handle:
fasta = SeqIO.parse(handle, "fasta")
if not any(
fasta
): # False when `fasta` is empty, i.e. wasn't a FASTA file
msg = 'El formato del archivo debe ser fasta'
self.label.configure(text=msg)
raise Exception(msg)
def is_content_valid_fasta(self):
with open(self.fileName, "r") as handle:
lines = iter(handle.read().splitlines(True))
nextLine = next(lines, None)
seqs = []
seq = []
if nextLine.startswith('>'):
nextLine = next(lines, None)
while nextLine is not None:
if not nextLine.startswith('>'):
seq.append(nextLine)
nextLine = next(lines, None)
else:
seq = "".join(seq)
seq = seq.replace("\n", "")
seq = seq.replace("\r", "")
seqs.append(seq)
seq = []
nextLine = next(lines, None)
seq = "".join(seq)
seq = seq.replace("\n", "")
seq = seq.replace("\r", "")
seqs.append(seq)
self.quantitySequences = len(seqs)
if self.quantitySequences < SEQUENCES_MIN:
msg = 'Un mínimo de 5 secuencias es requerido'
self.label.configure(text=msg)
raise Exception(msg)
msg = ''
if self.is_aligned(seqs):
self.aligned = True
msg = msg + ' Secuencias alineadas, se salteara ese paso'
self.label.configure(text=msg)
if len(
set(
list(
map(lambda sequence: len(list(set(sequence))),
seqs)))) == 1:
for sequence in seqs:
seqDistinct = list(set(sequence))
seqDistinct.sort()
if seqDistinct == [
'A', 'C', 'G', 'T'
] or seqDistinct == ['A', 'C', 'G', 'U']:
if self.typeSequence.get().lower() != "nucleotido":
msg = 'Ha especificado tipo de secuencia: ' + self.typeSequence.get(
) + ' y son posibles secuencias de nucleotidos'
if not messagebox.askyesno(
message=msg + ", ¿Desea continuar?",
title="Advertencia"):
raise TypeSequenceException(msg)
else:
break
else:
if self.typeSequence.get().lower() != 'proteina':
msg = 'Ha especificado tipo de secuencia: ' + self.typeSequence.get(
) + ' y son posibles secuencias de proteinas'
if not messagebox.askyesno(
message=msg + ", ¿Desea continuar?",
title="Advertencia"):
raise TypeSequenceException(msg)
else:
break
else:
msg = 'El formato del contenido debe comenzar con > para cada header por secuencia'
self.label.configure(text=msg)
raise Exception(msg)
def is_aligned(self, seqs):
return len(set(list(map(
lambda sequence: len(sequence), seqs)))) == 1 and next(
filter(lambda sequence: '-' in sequence, seqs),
None) is not None
def waitingLabel(self):
self.waitingLabel = ttk.Label(self.labelFrameWaiting, text='')
self.infoWaitingLabel = ttk.Label(self.labelFrameWaiting, text='')
self.button.state(["disabled"])
msg = ''
if self.aligned:
msg = 'Secuencias alineadas, se salteara ese paso.'
self.infoWaitingLabel.grid(column=0, row=0)
self.infoWaitingLabel.config(text=msg)
self.waitingLabel.grid(column=1, row=0)
self.waitingLabel.config(text="Procesando...")
self.update()
def input(self):
# vcmd = (self.register(self.onValidate), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
# self.bootstrap = IntVar(self, value="1000")
# self.entry = Entry(self.labelFrameBootstrap, validate="key", validatecommand=vcmd, textvariable=self.bootstrap)
# self.bootstrap = max(self.bootstrap.get(), 1000)
# self.entry.grid(column=1, row=1, padx=30, pady=10)
# self.entry.pack()
self.bootstrap = IntVar(self.labelFrameBootstrap)
self.bootstrap.set(next(iter(BOOTSTRAP_QUANTITY)))
w = OptionMenu(self.labelFrameBootstrap, self.bootstrap,
*BOOTSTRAP_QUANTITY)
w.pack()
def onValidate(self, action, index, value_if_allowed, prior_value, text,
validation_type, trigger_type, widget_name):
if value_if_allowed:
try:
int(value_if_allowed)
return True
except ValueError:
return False
else:
return False
def _update(self):
python_script.main_refresh(self, python_script)
class App(Tk):
def showMessage(self, messagetype, messageString):
if messagetype==MSG_ERROR:
messagebox.showerror("Error", messageString)
elif messagetype==MSG_WARN:
messagebox.showwarning("Warning",messageString)
elif messagetype==MSG_INFO:
messagebox.showinfo("Information",messageString)
def sendMessage(self, messageType,messageText):
self.api.sendMessage(messageType,messageText)
def getGrid(self):
if self.gpsl==None:
print('GPS Listener not running. Update settings and try again.')
# js8callAPIsupport.js8CallUDPAPICalls.showMessage(MSG_ERROR, getStatus()))
self.showMessage('ERROR', 'GPS Listener not running. Update settings and try again.')
return
if self.showoutput==1:
print('Getting Grid from GPS')
gpsText = self.gpsl.getMaidenhead()
if self.showoutput==1:
print(gpsText)
if gpsText==None:
gpsText = "No Fix"
ngr = self.gpsl.get_ngr()
if gpsText!=None:
if gpsText=='None':
gpsText="No Fix"
#print("Got Grid "+gpsText)
if ngr!=None:
None
#print("Got NGR "+ngr)
latlon=''
if self.gpsl.getStatus().startswith('Error'):
self.gpsText=self.gpsl.getStatus()
lat=None
lon=None
latlon=self.gpsl.getStatus()
else:
lat=self.gpsl.getCurrentLat()
lon=self.gpsl.getCurrentLon()
if lat!=None:
latf = f"{lat:.5f}"
lonf = f"{lon:.5f}"
latlon=str(latf)+', '+str(lonf)
self.var1.set(gpsText)
self.latlonvar.set(latlon)
return gpsText
# if gpsText!= "No Fix" and gpsText!='JJ00aa00':
# self.setJS8CallGridButton.configure(state='normal')
# self.sendJS8CallALLCALLButton.configure(state='normal')
# self.latlonButton.configure(state='normal')
#self.ngrStr.set(ngr)
# else:
# self.setJS8CallGridButton.configure(state='disabled')
# self.sendJS8CallALLCALLButton.configure(state='disabled')
# self.latlonButton.configure(state='normal')
# self.ngrStr.set('No Fix')
# self.var1.set('No Fix')
# self.latlonvar.set('No Fix')
#if gpsText=='JJ00aa00':
#self.ngrStr.set('No Fix')
def show_frame(self, context):
frame = self.frames[context]
frame.tkraise()
def nav_buttons(self, frame, controller):
# gps_page=Button(frame, text="GPS", command=lambda:controller.show_frame(GPSPage), bg="white", font=NAV_BUTTON_FONT, width=NAV_BUTTON_WIDTH)
# gps_page.grid(row=2, column=0)
# aprs_page=Button(frame, text="APRS Message", command=lambda:controller.show_frame(MessagePage), bg="white", font=NAV_BUTTON_FONT, width=NAV_BUTTON_WIDTH)
# aprs_page.grid(row=2, column=1)
# settings_page=Button(frame, text="Settings", command=lambda:controller.show_frame(SettingsPage), bg="white", font=NAV_BUTTON_FONT, width=NAV_BUTTON_WIDTH)
# settings_page.grid(row=2, column=2)
rh=0.1
rw=0.28
rx=0.01
# ry=0.02
gps_page=Button(frame, text="GPS", command=lambda:controller.show_frame(GPSPage), bg="white")
gps_page.grid(row=2, column=0, sticky=W+E+N+S, padx=5, pady=5)
aprs_page=Button(frame, text="APRS Message", command=lambda:controller.show_frame(MessagePage), bg="white")
aprs_page.grid(row=2, column=1, sticky=W+E+N+S, padx=5, pady=5)
settings_page=Button(frame, text="Settings", command=lambda:controller.show_frame(SettingsPage), bg="white")
settings_page.grid(row=2, column=2, sticky=W+E+N+S, padx=5, pady=5)
def sendGridToALLCALL(self,gridText):
self.api.sendGridToALLCALL(gridText, self.gpsl.getStatus())
def sendGridToJS8Call(self, gridText):
self.api.sendGridToJS8Call(gridText, self.gpsl.getStatus())
def __exit__(self, exc_type, exc_val, exc_tb):
print("Main Window is closing, call any function you'd like here!")
def __enter__(self):
# make a database connection and return it
print('Starting')
def ask_quit(self):
if self.gpsl!=None:
print('Shutting down GPS Listener')
self.gpsl.setReadGPS(False)
self.gpsl.join()
print('Exiting. Thanks for using JS8CallUtils By M0IAX')
self.destroy()
def update_timer(self):
if self.autoGridToJS8Call.get()==0:
self.initTimer()
self.timerStr.set("Timer Not Active")
if self.autoGridToJS8Call.get()==1:
if self.timer<=0:
self.initTimer()
self.timer=self.timer-1
t="Timer: " + str(self.timer)
self.timerStr.set(t)
if self.timer<=0:
print('Got to Zero')
gridstr = self.getGrid()
print('grd ', gridstr)
combotext=self.autocombo.get()
print("combo text ", combotext)
if gridstr!=None and gridstr!='' and gridstr!="No Fix":
if combotext=="Auto update JS8Call Grid":
self.sendGridToJS8Call(gridstr)
if combotext=="Auto TX Grid to APRSIS":
self.sendGridToALLCALL(gridstr)
if combotext=="Auto TX Grid to APRSIS and Update JS8Call Grid":
self.sendGridToJS8Call(gridstr)
self.sendGridToALLCALL(gridstr)
else:
print('No grid. enabld gps and wait for fix')
self.initTimer()
self.after(1000, self.update_timer)
#def update_status_timer(self):
# self.mainWindow.after(10000, self.update_status_timer)
def initTimer(self):
self.timer=self.MAX_TIMER
def autocomboChange(self, event):
return ''
def comboChange(self, event):
mode = self.combo.get()
if mode=="APRS":
self.callLbl.config(text='Enter Callsign (including SSID)')
elif mode=="Email":
self.callLbl.config(text='Enter Email Address to send to')
elif mode=="SMS":
self.callLbl.config(text='Enter cell phone number')
def cb(self):
None
#if self.autoGridToJS8Call.get()==0:
# self.autoGridToJS8Call.set(1)
#else:
# self.autoGridToJS8Call.set(0)
# self.timerStr.set("Timer Not Active")
def refreshSettings(self):
self.settingValues = settings.Settings()
self.showoutput = int(self.settingValues.getDebugSettingValue('showoutput'))
self.timeinmins = int(self.settingValues.getAppSettingValue('autotimeperiod'))
self.autoatstart = int(self.settingValues.getAppSettingValue('autoonatstart'))
self.autooption = int(self.settingValues.getAppSettingValue('autoselectedoption'))
self.autocombo.current(self.autooption) #set the selected item
self.MAX_TIMER=self.timeinmins*60
self.serverPortVar = StringVar()
self.serverVar = IntVar()
self.serverPortVar.set(int(self.settingValues.getNetworkSettingValue('serverport')))
self.serverVar.set(self.settingValues.getNetworkSettingValue('serverip'))
self.gpsOption = self.settingValues.getGPSHardwareSettingValue('option')
self.gpsComPortVar = StringVar()
self.gpsComPortSpeedVar = StringVar()
self.gpsComPortVar.set(self.settingValues.getGPSHardwareSettingValue('gpscomport'))
self.gpsComPortSpeedVar.set(self.settingValues.getGPSHardwareSettingValue('gpsportspeed'))
self.maidPreceision.set(self.settingValues.getAppSettingValue('precision'))
self.autoTimeVar.set(self.settingValues.getAppSettingValue('autotimeperiod'))
self.autoGridToJS8Call.set(self.settingValues.getAppSettingValue('autoonatstart'))
self.autoGridCheck.configure(text="Enable Auto update every "+str(self.timeinmins)+" mins.")
if self.gpsOption=='None':
self.autoGridCheck.configure(state='disabled')
self.autoGridToJS8Call.set(0)
else:
self.autoGridCheck.configure(state='normal')
if self.gpsl!=None:
self.gpsl.setPrecision(int(self.settingValues.getAppSettingValue('precision')))
self.gpsl.setShowDebug(self.showoutput)
if self.gpsOptionBeforeRefresh!=self.gpsOption:
if self.gpsl!=None:
print('Shutting down GPS Listener')
#self.gpsl.destroy()
self.gpsl.setReadGPS(False)
self.gpsl.join()
self.gpsl=None
if self.gpsOption!='None':
print('Starting GPS Listener')
if self.gpsOption=='GPSD':
self.gpsl = gpsdGPSListener.GpsListener( self.settingValues.getAppSettingValue('precision'),
self.showoutput
)
else:
print('Running serial gps again')
self.gpsl = serialGPSlistener.GPSListener(self.settingValues.getGPSHardwareSettingValue('gpscomport'),
self.settingValues.getGPSHardwareSettingValue('gpsportspeed'),
self.settingValues.getAppSettingValue('precision'),
self.showoutput
)
self.gpsl.start()
else:
print('Setting thread to None')
self.gpsl=None
self.gpsOptionBeforeRefresh=self.gpsOption
def __init__(self, *args, **kwargs):
Tk.__init__(self, *args, **kwargs)
self.seq=1
self.settingValues = settings.Settings()
self.showoutput = int(self.settingValues.getDebugSettingValue('showoutput'))
self.timeinmins = int(self.settingValues.getAppSettingValue('autotimeperiod'))
self.autoatstart = int(self.settingValues.getAppSettingValue('autoonatstart'))
self.autooption = int(self.settingValues.getAppSettingValue('autoselectedoption'))
#self.autocombo.set(self.autooption)
self.MAX_TIMER=self.timeinmins*60
self.serverPortVar = StringVar()
self.serverVar = IntVar()
self.serverPortVar.set(int(self.settingValues.getNetworkSettingValue('serverport')))
self.serverVar.set(self.settingValues.getNetworkSettingValue('serverip'))
self.api = js8callAPIsupport.js8CallUDPAPICalls(self.settingValues.getNetworkSettingValue('serverip'),
int(self.settingValues.getNetworkSettingValue('serverport')))
self.gpsOption = self.settingValues.getGPSHardwareSettingValue('option')
self.gpsComPortVar = StringVar()
self.gpsComPortSpeedVar = StringVar()
self.gpsComPortSpeedVar = self.settingValues.getGPSHardwareSettingValue('gpsportspeed')
self.gpsComPortVar = self.settingValues.getGPSHardwareSettingValue('gpscomport')
self.gpsOptionBeforeRefresh = self.gpsOption
self.gpsl=None
if self.gpsOption!="None":
if self.gpsOption=='GPSD':
self.gpsl = gpsdGPSListener.GpsListener( self.settingValues.getAppSettingValue('precision'),
self.showoutput
)
else:
self.gpsl = serialGPSlistener.GPSListener(self.settingValues.getGPSHardwareSettingValue('gpscomport'),
self.settingValues.getGPSHardwareSettingValue('gpsportspeed'),
self.settingValues.getAppSettingValue('precision'),
self.showoutput
)
self.gpsl.start()
self.geometry(str(WIDTH)+"x"+str(HEIGHT))
self.title("JS8Call Utilities by M0IAX")
self.gpsComPortVar = StringVar()
self.gpsComPortSpeedVar = StringVar()
self.maidPreceision = StringVar()
self.autoTimeVar = StringVar()
self.autoGridToJS8Call = IntVar()
self.var1 = StringVar()
self.var2 = StringVar()
self.latlonvar = StringVar()
#set default values
self.gpsComPortVar.set(self.settingValues.getGPSHardwareSettingValue('gpscomport'))
self.gpsComPortSpeedVar.set(self.settingValues.getGPSHardwareSettingValue('gpsportspeed'))
self.maidPreceision.set(self.settingValues.getAppSettingValue('precision'))
self.autoTimeVar.set(self.settingValues.getAppSettingValue('autotimeperiod'))
self.autoGridToJS8Call.set(self.settingValues.getAppSettingValue('autoonatstart'))
#Main window frame
container = Frame(self)
container.pack(side="top", fill="both", expand=True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
self.frames = {}
for F in (GPSPage, MessagePage, SettingsPage):
frame = F(container, self)
self.frames[F] = frame
frame.grid(row=0, column=0, sticky='nsew')
self.show_frame(GPSPage)
bottomFrame=Frame(self)
bottomFrame.pack()
self.autocombo = Combobox(bottomFrame, state='readonly',width=45)
self.autocombo.state='disabled'
self.autocombo.bind('<<ComboboxSelected>>', self.autocomboChange)
self.autocombo['values']= ("Auto update JS8Call Grid", "Auto TX Grid to APRSIS", "Auto TX Grid to APRSIS and Update JS8Call Grid")
self.autocombo.current(self.autooption) #set the selected item
#self.autocombo.place(relx=0.05,rely=0.63, relwidth=0.9,relheight=0.1)
self.autocombo.grid(row=0, column=0,sticky=W+E+N+S)
self.autoGridToJS8Call = IntVar(value=self.autoatstart)
self.autoGridCheck = Checkbutton(bottomFrame, text="Enable Auto update every "+str(self.timeinmins)+" mins.", variable=self.autoGridToJS8Call, command=self.cb)
#self.autoGridCheck.place(relx=0.05,rely=0.71, relwidth=0.9,relheight=0.1)
self.autoGridCheck.grid(row=1, column=0, sticky=W+E+N+S, padx=5, pady=5)
if self.gpsOption=='None':
self.autoGridCheck.configure(state='disabled')
self.autoGridToJS8Call.set(0)
else:
self.autoGridCheck.configure(state='normal')
self.timer=60 #Set timer to 60 for the first tx GPS should have a lock in that time
self.timerStr = StringVar()
self.timerStr.set("Timer Not Active")
self.timerlabel = Label(bottomFrame, textvariable=self.timerStr )
#self.timerlabel.place(relx=0.05,rely=0.81, relwidth=0.9,relheight=0.1)
self.timerlabel.grid(row=2, column=0,sticky=W+E+N+S)
buttonFrame=Frame(self)
buttonFrame.pack()
self.nav_buttons(buttonFrame, self)
self.update_timer()
class Config:
"""Read/write and store all data from config files."""
def __init__(self, cmdLineParams, master=None):
self.cmdLineParams = cmdLineParams
self.master = master
self.ai_path = '' # Path to FG_ROOT/AI directory.
self.apt_path = '' # Path to FG_ROOT/Airports/apt.dat.gz file.
self.metar_path = '' # Path to FG_ROOT/Airports/metar.dat.gz file.
self.aircraft_dirs = [] # List of aircraft directories.
# Dictionary whose keys are aircraft names. For each aircraft name 'n',
# self.aircraftDict[n] is the list, in self.aircraft_dirs priority
# order, of all Aircraft instances with that name.
self.aircraftDict = {}
self.aircraftList = [] # Sorted list of Aircraft instances.
self.scenario_list = [] # List of selected scenarios.
# List of all aircraft carriers found in AI scenario folder.
# Each entry format is:
# ["ship name", "parking position"... , "scenario name"]
self.carrier_list = []
self.settings = [] # List of basic settings read from config file.
self.text = '' # String to be shown in command line options window.
# 'self.aircraftId' is the central variable telling which particular
# aircraft is selected in FFGo's interface. It is a tuple of the form
# (aircraftName, aircraftDir).
self.aircraftId = misc.Observable()
self.aircraft = StringVar()
self.aircraftDir = StringVar()
# Whenever 'self.aircraftId' is set, 'self.aircraft' and
# 'self.aircraftDir' are automatically updated to reflect the new value
# (and their observers called, even if the values didn't change).
self.aircraftId.trace("w", self.updateAircraftNameAndDirFromAircraftId)
# Note: the FFGo config file stores the values of 'self.aircraft' and
# 'self.aircraftDir' separately (this makes the compatibility
# path easy with versions that don't know about aircraftDir).
self.airport = StringVar() # ICAO code of the selected airport
self.alreadyProposedChanges = StringVar()
self.apt_data_source = IntVar()
self.auto_update_apt = IntVar()
self.carrier = StringVar() # when non-empty, we are in “carrier mode”
self.FG_aircraft = StringVar()
self.FG_bin = StringVar()
self.FG_root = StringVar()
self.FG_scenery = StringVar()
self.FG_working_dir = StringVar()
self.MagneticField_bin = StringVar()
self.MagneticField_bin.trace('w', self.updateMagFieldProvider)
self.filteredAptList = IntVar()
self.language = StringVar()
self.park = StringVar()
self.rwy = StringVar()
self.scenario = StringVar()
self.mainWindowGeometry = StringVar()
self.saveWindowPosition = IntVar()
self.baseFontSize = StringVar()
self.TkDefaultFontSize = IntVar()
# tkinter.BooleanVar feels kind of messy. Sometimes, it prints out as
# 'True', other times as '1'... IntVar seems more predictable.
self.showFGCommand = IntVar()
self.showFGCommandInSeparateWindow = IntVar()
self.FGCommandGeometry = StringVar()
self.showFGOutput = IntVar()
self.showFGOutputInSeparateWindow = IntVar()
self.FGOutputGeometry = StringVar()
self.autoscrollFGOutput = IntVar()
# Option to translate --parkpos into --lat, --lon and --heading (useful
# when --parkpos is broken in FlightGear)
self.fakeParkposOption = IntVar()
self.airportStatsManager = None # will be initialized later
self.aircraftStatsManager = None # ditto
self.airportStatsShowPeriod = IntVar()
self.airportStatsExpiryPeriod = IntVar()
self.aircraftStatsShowPeriod = IntVar()
self.aircraftStatsExpiryPeriod = IntVar()
self.keywords = {'--aircraft=': self.aircraft,
'--airport=': self.airport,
'--fg-root=': self.FG_root,
'--fg-scenery=': self.FG_scenery,
'--carrier=': self.carrier,
'--parkpos=': self.park,
'--runway=': self.rwy,
'AIRCRAFT_DIR=': self.aircraftDir,
'AI_SCENARIOS=': self.scenario,
'ALREADY_PROPOSED_CHANGES=':
self.alreadyProposedChanges,
'APT_DATA_SOURCE=': self.apt_data_source,
'AUTO_UPDATE_APT=': self.auto_update_apt,
'FG_BIN=': self.FG_bin,
'FG_AIRCRAFT=': self.FG_aircraft,
'FG_WORKING_DIR=': self.FG_working_dir,
'MAGNETICFIELD_BIN=': self.MagneticField_bin,
'FILTER_APT_LIST=': self.filteredAptList,
'LANG=': self.language,
'WINDOW_GEOMETRY=': self.mainWindowGeometry,
'SAVE_WINDOW_POSITION=': self.saveWindowPosition,
'BASE_FONT_SIZE=': self.baseFontSize,
'SHOW_FG_COMMAND=': self.showFGCommand,
'SHOW_FG_COMMAND_IN_SEPARATE_WINDOW=':
self.showFGCommandInSeparateWindow,
'FG_COMMAND_GEOMETRY=': self.FGCommandGeometry,
'SHOW_FG_OUTPUT=': self.showFGOutput,
'SHOW_FG_OUTPUT_IN_SEPARATE_WINDOW=':
self.showFGOutputInSeparateWindow,
'FG_OUTPUT_GEOMETRY=': self.FGOutputGeometry,
'AUTOSCROLL_FG_OUTPUT=': self.autoscrollFGOutput,
'FAKE_PARKPOS_OPTION=': self.fakeParkposOption,
'AIRPORT_STATS_SHOW_PERIOD=':
self.airportStatsShowPeriod,
'AIRPORT_STATS_EXPIRY_PERIOD=':
self.airportStatsExpiryPeriod,
'AIRCRAFT_STATS_SHOW_PERIOD=':
self.aircraftStatsShowPeriod,
'AIRCRAFT_STATS_EXPIRY_PERIOD=':
self.aircraftStatsExpiryPeriod}
# In order to avoid using a lot of memory, detailed airport data is
# only loaded on demand. Since this is quite slow, keep a cache of the
# last retrieved data.
self.aptDatCache = collections.deque(maxlen=50)
self._earlyTranslationsSetup()
self._createUserDirectories()
self._maybeMigrateFromFGoConfig()
# Not having the FlightGear version at this point is not important
# enough to justify pestering the user about it. :-)
# Defer logging of the detected FG version to fit nicely with
# the other startup messages.
self.update(ignoreFGVersionError=True, logFGVersion=False)
self.setTkDefaultFontSize()
self.setupFonts(init=True)
def setTkDefaultFontSize(self):
"""Save unaltered TkDefaultFont size."""
size = tkinter.font.nametofont("TkDefaultFont").actual()["size"]
self.TkDefaultFontSize.set(size)
def setupFonts(self, init=False):
"""Setup the default fonts.
When called with init=True, custom fonts are created and
stored as attributes of self. Otherwise, they are simply
configured.
"""
# According to <http://www.tcl.tk/man/tcl8.4/TkCmd/font.htm>, font
# sizes are interpreted this way:
# - for positive values, the unit is points;
# - for negative values, the unit is pixels;
# - 0 is a special value for "a platform-dependent default size".
#
# Apparently, Tkinter doesn't accept floats for the 'size' parameter of
# <font>.configure(), even when positive (tested with Python 2.7.3).
baseSize = int(float(self.baseFontSize.get()))
# Get the actual size when baseSize == 0, otherwise scaling won't work
# since 0*factor == 0, regardless of the (finite) factor.
if baseSize == 0:
baseSize = self.TkDefaultFontSize.get()
def scale(factor):
return int(round(baseSize * factor))
def configFontSize(style, factor):
font = tkinter.font.nametofont("Tk%sFont" % style)
font.configure(size=scale(factor))
# Configure built-in fonts
for style in ("Default", "Text", "Fixed", "Caption", "Tooltip"):
# The 'if init:' here is a workaround for a weird problem: when
# saving the settings from the Preferences dialog, even if the very
# same font size is set here as the one that was used at program
# initialization, the main window layout gets broken, with the
# airport chooser Treeview taking more and more horizontal space
# every time the settings are saved. Avoiding to reconfigure the
# fonts in such "reinit" conditions works around the problem...
if init:
configFontSize(style, 1)
for style, factor in (("Menu", 20 / 18.), ("Heading", 20 / 18.),
("SmallCaption", 16 / 18.), ("Icon", 14 / 18.)):
if init: # Second part of the workaround mentioned above
configFontSize(style, factor)
# Create or configure custom fonts, depending on 'init'
aboutTitleFontSize = scale(42 / 18.)
if init:
self.aboutTitleFont = tkinter.font.Font(
family="Helvetica", weight="bold", size=aboutTitleFontSize)
else:
self.aboutTitleFont.configure(size=aboutTitleFontSize)
# Final part of the workaround mentioned above. Normally, the code
# should always be executed, regardless of the value of 'init'.
if init:
# For the ttk.Treeview widget
treeviewHeadingFontSize = scale(1.)
# Redundant test, right. Hopefully, one day, we'll be able to get
# rid of the workaround and this test won't be redundant anymore.
if init:
self.treeviewHeadingFont = tkinter.font.Font(
weight="normal", size=treeviewHeadingFontSize)
else:
self.treeviewHeadingFont.configure(size=treeviewHeadingFontSize)
style = ttk.Style()
style.configure("Treeview.Heading", font=self.treeviewHeadingFont)
def makeInstalledAptList(self):
logger.notice(_("Building the list of installed airports "
"(this may take some time)..."))
# writelines() used below doesn't automatically add line terminators
airports = [ icao + '\n' for icao in self._findInstalledApt() ]
logger.info("Opening '{}' for writing".format(INSTALLED_APT))
with open(INSTALLED_APT, "w", encoding="utf-8") as fout:
fout.writelines(airports)
def readMetarDat(self):
"""Fetch METAR station list from metar.dat.gz file"""
logger.info("Opening '{}' for reading".format(self.metar_path))
res = []
with gzip.open(self.metar_path, mode='rt', encoding='utf-8') as fin:
for line in fin:
if not line.startswith('#'):
res.append(line.strip())
return res
def rebuildApt(self):
"""Rebuild apt file."""
self._makeAptDigest()
def _computeAircraftDirList(self):
FG_AIRCRAFT_env = os.getenv("FG_AIRCRAFT", "")
if FG_AIRCRAFT_env:
FG_AIRCRAFT_envList = FG_AIRCRAFT_env.split(os.pathsep)
else:
FG_AIRCRAFT_envList = []
# FG_ROOT/Aircraft
defaultAircraftDir = os.path.join(self.FG_root.get(),
DEFAULT_AIRCRAFT_DIR)
aircraft_dirs = (self.FG_aircraft.get().split(os.pathsep)
+ FG_AIRCRAFT_envList + [defaultAircraftDir])
return aircraft_dirs
def logDetectedFlightGearVersion(self, logLevel=LogLevel.notice,
prefix=True):
if self.FG_version is not None:
FG_version = str(self.FG_version)
else:
FG_version = pgettext("FlightGear version", "none")
# Uses the same string as in App.about()
message = _("Detected FlightGear version: {ver}").format(
ver=FG_version)
logger.log(logLevel, prefix, message)
def getFlightGearVersion(self, ignoreFGVersionError=False, log=False):
# This import requires the translation system [_() function] to be in
# place.
from .fgdata import fgversion
self.FG_version = None # in case an exception is raised below
FG_bin = self.FG_bin.get()
FG_root = self.FG_root.get()
exc = None
if FG_bin and FG_root:
try:
self.FG_version = fgversion.getFlightGearVersion(
FG_bin, FG_root, self.FG_working_dir.get())
except fgversion.error as e:
exc = e # may need to be raised later
if log:
self.logDetectedFlightGearVersion()
if exc is not None and not ignoreFGVersionError:
raise exc
# This is a callback for FFGo's misc.Observable class.
def updateAircraftNameAndDirFromAircraftId(self, aircraftId):
aircraftName, aircraftDir = aircraftId
self.aircraft.set(aircraftName)
self.aircraftDir.set(aircraftDir)
def aircraftWithNameAndDir(self, name, dir_):
"""Get the Aircraft instance for a given name and directory."""
try:
aircrafts = self.aircraftDict[name]
except KeyError:
raise NoSuchAircraft(name, dir_)
for aircraft in aircrafts:
# The idea is that the directory 'dir_' passed here should have
# been discovered earlier by a filesystem exploration, therefore
# there must be one Aircraft instance that has an exact match for
# both 'name' and 'dir_' (no need to use 'os.path.samefile()',
# which would be slower, could raise errors...).
if aircraft.dir == dir_:
return aircraft
else:
raise NoSuchAircraft(name, dir_)
def aircraftWithId(self, aircraftId):
"""Get the Aircraft instance for a given aircraft ID."""
return self.aircraftWithNameAndDir(*self.aircraftId.get())
def getCurrentAircraft(self):
"""Get the Aircraft instance for the currently-selected aircraft."""
return self.aircraftWithId(self.aircraftId.get())
def _findAircraft(self, acName, acDir):
"""Return an aircraft ID for 'acName' and 'acDir' if possible.
If no aircraft is found with the given name and directory, fall
back to:
- an identically-named aircraft in a different directory
(taking the first in FG_AIRCRAFT precedence order);
- if this isn't possible either, fall back to the default
aircraft. The returned aircraft ID will have an empty
directory component if even the default aircraft isn't
available in this case.
Log an appropriate warning or notice when a fallback strategy is
used.
"""
if acName in self.aircraftDict:
for ac in self.aircraftDict[acName]:
if ac.dir == acDir:
aircraft = ac
break
else:
aircraft = self.aircraftDict[acName][0]
logger.notice(
_("Could not find aircraft '{aircraft}' under '{dir}', "
"taking it from '{fallback}' instead").format(
aircraft=acName, dir=acDir, fallback=aircraft.dir))
else:
try:
defaultAircrafts = self.aircraftDict[DEFAULT_AIRCRAFT]
except KeyError:
aircraft = None
logger.warning(
_("Could not find the default aircraft: {aircraft}")
.format(aircraft=DEFAULT_AIRCRAFT))
else:
aircraft = defaultAircrafts[0]
logger.notice(
_("Could not find aircraft '{aircraft}', using "
"'{fallback}' from '{dir}' instead").format(
aircraft=acName, fallback=aircraft.name,
dir=aircraft.dir))
if aircraft is None:
return (DEFAULT_AIRCRAFT, '')
else:
return (aircraft.name, aircraft.dir)
def sanityChecks(self):
status, *rest = self.decodeParkingSetting(self.park.get())
if status == "invalid":
logger.warning(
_("Invalid syntax for the parking setting ({setting!r}), "
"resetting it.").format(setting=self.park.get()))
self.park.set('')
if self.rwy.get() and self.park.get():
# Impossible to at the same time set a non-default runway and a
# parking position. The latter wins. :-)
self.rwy.set('')
def update(self, path=None, ignoreFGVersionError=False, logFGVersion=True):
"""Read config file and update variables.
path is a path to different than default config file
"""
if self.aircraftStatsManager is None: # application init
# Requires the translation system to be in place
from . import stats_manager
self.aircraftStatsManager = \
stats_manager.AircraftStatsManager(self)
else:
# Save the in-memory statistics (from Aircraft instances) to
# persistent storage. This expires old stats, according to
# self.aircraftStatsExpiryPeriod.
self.aircraftStatsManager.save()
del self.settings
del self.text
del self.aircraft_dirs
del self.apt_path
del self.ai_path
del self.metar_path
del self.aircraftDict
del self.aircraftList
del self.scenario_list
del self.carrier_list
# The variable will be set again right after reading the config
# file, therefore there is no need to run the callbacks now
# (such as updating the aircraft image).
self.aircraftId.set((DEFAULT_AIRCRAFT, ''), runCallbacks=False)
self.airport.set(DEFAULT_AIRPORT)
self.alreadyProposedChanges.set('')
self.apt_data_source.set(1)
self.auto_update_apt.set(1)
self.carrier.set('')
self.FG_aircraft.set('')
self.FG_bin.set('')
self.FG_root.set('')
self.FG_scenery.set('')
self.FG_working_dir.set('')
self.MagneticField_bin.set('')
self.language.set('')
self.baseFontSize.set(DEFAULT_BASE_FONT_SIZE)
self.mainWindowGeometry.set('')
self.saveWindowPosition.set('1')
self.showFGCommand.set('1')
self.showFGCommandInSeparateWindow.set('0')
self.FGCommandGeometry.set('')
self.showFGOutput.set('1')
self.showFGOutputInSeparateWindow.set('0')
self.FGOutputGeometry.set('')
self.autoscrollFGOutput.set('1')
self.park.set('')
self.fakeParkposOption.set('0')
self.rwy.set('')
self.scenario.set('')
self.filteredAptList.set(0)
self.airportStatsShowPeriod.set('365') # approx. one year
self.airportStatsExpiryPeriod.set('3652') # approx. ten years
self.aircraftStatsShowPeriod.set('365')
self.aircraftStatsExpiryPeriod.set('3652')
self.settings, self.text = self._read(path)
for line in self.settings:
cut = line.find('=') + 1
if cut:
name = line[:cut]
value = line[cut:]
if value:
if name in self.keywords:
var = self.keywords[name]
var.set(value)
# Useful to know when the airport has been changed
self.previousAirport = self.airport.get()
self._setLanguage(self.language.get())
setupTranslationHelper(self)
self.aircraft_dirs = self._computeAircraftDirList()
self.apt_path = os.path.join(self.FG_root.get(), APT_DAT)
self.ai_path = os.path.join(self.FG_root.get(), AI_DIR)
self.metar_path = os.path.join(self.FG_root.get(), METAR_DAT)
self.aircraftDict, self.aircraftList = self._readAircraft()
# Load the saved statistics into the new in-memory Aircraft instances
# (the set of aircrafts may have just changed, hence the need to save
# the stats before the in-memory aircraft list is updated, and reload
# them afterwards).
self.aircraftStatsManager.load()
# Choose a suitable aircraft, even if the one defined by
# 'self.aircraft' and 'self.aircraftDir' isn't available.
self.aircraftId.set(self._findAircraft(self.aircraft.get(),
self.aircraftDir.get()))
self.scenario_list, self.carrier_list = self._readScenarios()
self.sanityChecks()
self.getFlightGearVersion(ignoreFGVersionError=ignoreFGVersionError,
log=logFGVersion)
def write(self, text=None, path=None):
"""Write the configuration to a file.
text -- content of text window processed by CondConfigParser
(pass None to use the value of Config.text)
path -- path to the file the config will be written to
(the default config file is used if this argument is
empty or None)
"""
if not path:
path = CONFIG
if text is None:
text = self.text
options = []
keys = list(self.keywords.keys())
keys.sort()
for k in keys:
v = self.keywords[k]
if k in ('--carrier=', '--airport=', '--parkpos=', '--runway='):
if v.get():
options.append(k + v.get())
else:
options.append(k + str(v.get()))
s = '\n'.join(options)
logger.info("Opening config file for writing: '{}'".format(path))
with open(path, mode='w', encoding='utf-8') as config_out:
config_out.write(s + '\n' + CUT_LINE + '\n')
# Make sure the config file has exactly one newline at the end
while text.endswith('\n\n'):
text = text[:-1]
if not text.endswith('\n'):
text += '\n'
config_out.write(text)
def _findInstalledApt(self):
"""Walk thru all scenery and find installed airports.
Take geographic coordinates from directories names and compare them
with airports coordinates in apt file.
The result is a sorted list of ICAO codes for matching airports.
"""
coord_dict = {}
sceneries = self.FG_scenery.get().split(os.pathsep)
for scenery in sceneries:
path = os.path.join(scenery, 'Terrain')
if os.path.exists(path):
for dir in os.listdir(path):
p = os.path.join(path, dir)
for coords in os.listdir(p):
d = os.path.join(p, coords)
if not os.path.isdir(d):
continue
logger.debug("Exploring Terrain directory '{}' -> '{}'"
.format(p, coords))
converted = self._stringToCoordinates(coords)
if converted is not None:
coord_dict[converted] = None
else:
logger.notice(
_("Ignoring directory '{}' (unexpected name)")
.format(d))
coords = coord_dict.keys()
res = []
for icao in self.sortedIcao():
airport = self.airports[icao]
for c in coords:
if (c[0][0] < airport.lat < c[0][1] and
c[1][0] < airport.lon < c[1][1]):
res.append(icao)
return res
def _calculateRange(self, coordinates):
c = coordinates
if c.startswith('s') or c.startswith('w'):
c = int(c[1:]) * (-1)
return c, c + 1
else:
c = int(c[1:])
return c, c + 1
def _createUserDirectories(self):
"""Create config, log and stats directories if they don't exist."""
for d in USER_DATA_DIR, LOG_DIR, STATS_DIR:
os.makedirs(d, exist_ok=True)
def _maybeMigrateFromFGoConfig_dialogs(self, parent):
message = _("Initialize {prg}'s configuration from your existing " \
"FGo! configuration?").format(prg=PROGNAME)
detail = (_("""\
You have no {cfgfile} file but you do have a {fgo_cfgfile} file,
which normally belongs to FGo!. Except in rare circumstances
(such as using braces or backslashes, or opening brackets at the
beginning of a config line), a configuration file from
FGo! 1.5.5 or earlier should be usable as is by {prg}.""")
.replace('\n', ' ') + "\n\n" + _("""\
If {fgo_cfgfile} was written by FGo! 1.5.5 or earlier, you
should probably say “Yes” here in order to initialize {prg}'s
configuration based on your FGo! config file (precisely:
copy {fgo_cfgfile} to {cfgfile}).""")
.replace('\n', ' ') + "\n\n" + _("""\
If {fgo_cfgfile} was written by a version of FGo! that is greater
than 1.5.5, it is advised to say “No” here.""")
.replace('\n', ' ')
).format(prg=PROGNAME, cfgfile=CONFIG, fgo_cfgfile=FGO_CONFIG)
if askyesno(PROGNAME, message, detail=detail, parent=parent):
choice = "migrate from FGo!"
else:
message = _("Create a default {prg} configuration?").format(
prg=PROGNAME)
detail = _("""\
Choose “Yes” to create a basic {prg} configuration now. If you
choose “No”, {prg} will exit and you'll have to create {cfgfile}
yourself, or restart {prg} to see the same questions again.""") \
.replace('\n', ' ').format(prg=PROGNAME, cfgfile=CONFIG)
if askyesno(PROGNAME, message, detail=detail, parent=parent):
choice = "create default cfg"
message = _("Creating a default {prg} configuration.").format(
prg=PROGNAME)
detail = (_("""\
It is suggested that you go to the Settings menu and choose
Preferences to review your newly-created configuration.""")
.replace('\n', ' ') + "\n\n" + _("""\
You can also reuse most, if not all FlightGear options you
had in FGo!'s main text box (the “options window”). Just copy
them to the corresponding {prg} text box.""")
.replace('\n', ' ') + "\n\n" + _("""\
Note: you may run both FGo! and {prg} simultaneously, as their
configurations are kept separate.""")
.replace('\n', ' ')
).format(prg=PROGNAME)
showinfo(PROGNAME, message, detail=detail, parent=parent)
else:
choice = "abort"
return choice
def _maybeMigrateFromFGoConfig(self):
if os.path.isfile(FGO_CONFIG) and not os.path.isfile(CONFIG):
baseSize = tkinter.font.nametofont("TkDefaultFont").actual()["size"]
def configFontSize(val, absolute=False):
for style in ("Default", "Text", "Fixed", "Caption", "Tooltip"):
font = tkinter.font.nametofont("Tk{}Font".format(style))
if absolute:
font.configure(size=val)
else:
font.configure(size=int(round(baseSize * val)))
# Make sure most people can read the following dialogs (the
# standard Tk size may be rather small): 140% increase
configFontSize(1.4, absolute=False)
choice = None # user choice in the to-be-displayed dialogs
# It seems we need an otherwise useless Toplevel window in order to
# center the Tk standard dialogs...
t = tkinter.Toplevel()
try:
# Transparent if the OS supports it
t.attributes('-alpha', '0.0')
# Center the Toplevel. To be effective, this would probably
# need a visit to the Tk event loop, however it is enough to
# have the child dialogs centered, which is what matters here.
self.master.eval('tk::PlaceWindow {} center'.format(
t.winfo_pathname(t.winfo_id())))
choice = self._maybeMigrateFromFGoConfig_dialogs(t)
finally:
t.destroy()
# Restore font size for later self.setupFonts() call
configFontSize(baseSize, absolute=True)
if choice in (None, "abort"):
raise AbortConfig
elif choice == "migrate from FGo!":
# shutil.copy() and shutil.copy2() attempt to preserve the file's
# permission mode, which is undesirable here → manual copy.
with open(FGO_CONFIG, "r", encoding='utf-8') as fgoConfig, \
open(CONFIG, "w", encoding='utf-8') as config:
config.write(fgoConfig.read())
else:
assert choice == "create default cfg", repr(choice)
def _makeAptDigest(self, head=None):
"""Build apt database from apt.dat.gz"""
if self.FG_root.get():
_ProcessApt(self.master, self, self.apt_path, head)
def _read(self, path=None):
"""Read the specified or a default configuration file.
- If 'path' is None and CONFIG exists, load CONFIG;
- if 'path' is None and CONFIG does not exist, load the
configuration from the presets and default, localized
config_ll resource;
- otherwise, load configuration from the specified file.
"""
try:
# ExitStack not strictly necessary here, but allows clean and
# convenient handling of the various files or resources the
# configuration may be loaded from.
with contextlib.ExitStack() as stack:
res = self._read0(stack, path)
except OSError as e:
message = _('Error loading configuration')
showerror(_('{prg}').format(prg=PROGNAME), message, detail=str(e))
res = ([''], '')
return res
_presetsBlankLineOrCommentCre = re.compile(r"^[ \t]*(#|$)")
def _read0(self, stack, path):
# Data before the CUT_LINE in the config file, destined to
# self.settings
settings = []
# Data after the CUT_LINE in the config file, destined to
# self.text and to be parsed by CondConfigParser
condConfLines = []
if path is not None or (path is None and os.path.exists(CONFIG)):
if path is None:
path = CONFIG
logger.info("Opening config file '{}' for reading".format(path))
configStream = stack.enter_context(open(path, "r",
encoding="utf-8"))
beforeCutLine = True
else: # Use default config if no regular config exists.
# Load presets if exists.
if resourceExists(PRESETS):
with textResourceStream(PRESETS) as presets:
for line in presets:
line = line.strip()
if not self._presetsBlankLineOrCommentCre.match(line):
settings.append(line)
# Find the currently used language according to the environment.
try:
lang_code = gettext.translation(
MESSAGES, LOCALE_DIR).info()['language']
except OSError:
lang_code = 'en'
if not resourceExists(DEFAULT_CONFIG_STEM + lang_code):
lang_code = 'en'
resPath = DEFAULT_CONFIG_STEM + lang_code
configStream = stack.enter_context(textResourceStream(resPath))
# There is no "cut line" in the template config files.
beforeCutLine = False
for line in configStream:
if beforeCutLine:
line = line.strip()
if line != CUT_LINE:
if beforeCutLine:
# Comments wouldn't be preserved on saving, therefore don't
# try to handle them before the "cut line".
if line:
settings.append(line)
else:
condConfLines.append(line)
else:
beforeCutLine = False
return (settings, ''.join(condConfLines))
def _readAircraft(self):
"""
Walk through Aircraft directories and return the available aircrafts.
Return a tuple (aircraftDict, aircraftList) listing all
aircrafts found via self.aircraft_dirs.
aircraftDict is a dictionary whose keys are the names (derived
from the -set.xml files) of all aircrafts. For each aircraft
name 'n', aircraftDict[n] is the list, in self.aircraft_dirs
priority order, of all Aircraft instances with that name.
aircraftList is the sorted list of all Aircraft instances,
suitable for quick building of the aircraft list in the GUI.
"""
aircraftDict = {}
for dir_ in self.aircraft_dirs:
if os.path.isdir(dir_):
for d in os.listdir(dir_):
self._readAircraftData(dir_, d, aircraftDict)
aircraftList = []
# First sort by lowercased aircraft name
sortFunc = lambda s: (s.lower(), s)
for acName in sorted(aircraftDict.keys(), key=sortFunc):
# Then sort by position in self.aircraft_dirs
aircraftList.extend(aircraftDict[acName])
return (aircraftDict, aircraftList)
def _readAircraftData(self, dir_, d, aircraftDict):
path = os.path.join(dir_, d)
if os.path.isdir(path):
for f in os.listdir(path):
self._appendAircraft(f, aircraftDict, path)
def _appendAircraft(self, f, aircraftDict, path):
if f.endswith('-set.xml'):
# Dirty and ugly hack to prevent carrier-set.xml in
# seahawk directory to be attached to the aircraft
# list.
if (not path.startswith('seahawk') and
f != 'carrier-set.xml'):
name = f[:-8]
if name not in aircraftDict:
aircraftDict[name] = []
aircraft = Aircraft(name, path)
aircraftDict[name].append(aircraft)
def sortedIcao(self):
return sorted(self.airports.keys())
def _readApt(self):
"""Read the apt digest file (create a new one if none exists).
Return a list of AirportStub instances.
"""
from .fgdata import apt_dat
if not os.path.exists(APT):
# Create a new file if self.FG_root is non-empty
self._makeAptDigest()
if not os.path.isfile(APT): # may happen if self.FG_root was empty
self.aptDatSize, self.airports = 0, {}
return []
for attempt in itertools.count(start=1):
try:
self.aptDatSize, self.airports = apt_dat.AptDatDigest.read(APT)
except apt_dat.UnableToParseAptDigest:
if attempt < 2:
self._makeAptDigest()
else:
raise
else:
break
if self.filteredAptList.get():
installedApt = self._readInstalledAptSet()
res = [ self.airports[icao] for icao in self.sortedIcao()
if icao in installedApt ]
else:
res = [ self.airports[icao] for icao in self.sortedIcao() ]
return res
def _readInstalledAptSet(self):
"""Read the set of locally installed airports from INSTALLED_APT.
Create a new INSTALLED_APT file if none exists yet.
Return a frozenset(), which offers very fast membership test
compared to a list.
"""
if not os.path.exists(INSTALLED_APT):
self.makeInstalledAptList()
logger.info("Opening installed apt file '{}' for reading".format(
INSTALLED_APT))
with open(INSTALLED_APT, "r", encoding="utf-8") as f:
# Strip the newline char ending every line
res = frozenset([ line[:-1] for line in f ])
return res
def _readScenarios(self):
"""Walk through AI scenarios and read carrier data.
Return two lists:
scenarios: [scenario name, ...]
carrier data: [[name, parkking pos, ..., scenario name], ...]
Return two empty lists if no scenario is found.
"""
carriers = []
scenarios = []
if os.path.isdir(self.ai_path):
for f in os.listdir(self.ai_path):
path = os.path.join(self.ai_path, f)
if os.path.isfile(path) and f.lower().endswith('.xml'):
scenario_name = f[:-4]
scenarios.append(scenario_name)
# Appends to 'carriers'
self._append_carrier_data(carriers, path, scenario_name)
return sorted(scenarios), sorted(carriers)
def _append_carrier_data(self, carriers, xmlFilePath, scenario_name):
logger.info("Reading scenario data from '{}'".format(xmlFilePath))
root = self._get_root(xmlFilePath)
scenario = root.find('scenario')
if scenario is not None:
for e in scenario.iterfind('entry'):
typeElt = e.find('type')
if typeElt is not None and typeElt.text == 'carrier':
data = self._get_carrier_data(e, scenario_name)
carriers.append(data)
def _get_root(self, xmlFilePath):
tree = ElementTree.parse(xmlFilePath)
return tree.getroot()
def _get_carrier_data(self, e, scenario_name):
nameElt = e.find('name')
if nameElt is not None:
data = [nameElt.text]
else:
data = ['unnamed']
for child in e.iterfind('parking-pos'):
parkingNameElt = child.find('name')
if parkingNameElt is not None:
data.append(parkingNameElt.text)
data.append(scenario_name)
return data
# The '1' is the version number of this custom format for the contents of
# Config.park, in case we need to change it.
aptDatParkConfStart_cre = re.compile(r"::apt\.dat::1::(?P<nameLen>\d+),")
aptDatParkConfEnd_cre = re.compile(
r"""lat=(?P<lat>{floatRegexp}),
lon=(?P<lon>{floatRegexp}),
heading=(?P<heading>{floatRegexp})$""".format(
floatRegexp=r"-?\d+(\.\d*)?"),
re.VERBOSE)
def decodeParkingSetting(self, parkConf):
status = "invalid" # will be overridden if correct in the end
parkName = None
options = []
if not parkConf:
status = "none" # no parking position
else:
mo = self.aptDatParkConfStart_cre.match(parkConf)
if mo:
# Length of the following parking name (after the comma)
nameLen = int(mo.group("nameLen"))
i = mo.end("nameLen") + 1 + nameLen
if len(parkConf) > i and parkConf[i] == ";":
mo2 = self.aptDatParkConfEnd_cre.match(parkConf[i+1:])
if mo2:
parkName = parkConf[mo.end("nameLen")+1:i]
options = ["--lat=" + mo2.group("lat"),
"--lon=" + mo2.group("lon"),
"--heading=" + mo2.group("heading")]
status = "apt.dat"
else: # plain parking name
parkName = parkConf
options = ["--parkpos=" + parkName]
status = "groundnet"
return (status, parkName, options)
def _earlyTranslationsSetup(self):
"""Setup translations before the config file has been read.
The language is determined from the environment (LANGUAGE,
LC_ALL, LC_MESSAGES, and LANG—cf. gettext.translation() and
gettext.find()).
"""
try:
langCode = gettext.translation(
MESSAGES, LOCALE_DIR).info()['language']
except OSError:
langCode = 'en'
self._setLanguage(langCode)
def _setLanguage(self, lang):
# Initialize provided language...
try:
L = gettext.translation(MESSAGES, LOCALE_DIR, languages=[lang])
L.install()
# ...or fallback to system default.
except Exception:
gettext.install(MESSAGES, LOCALE_DIR)
# Regexp for directory names such as w040n20
_geoDirCre = re.compile(r"[we]\d{3}[ns]\d{2}$")
def _stringToCoordinates(self, coordinates):
"""Convert geo coordinates to decimal format."""
if not self._geoDirCre.match(coordinates):
return None
lat = coordinates[4:]
lon = coordinates[:4]
lat_range = self._calculateRange(lat)
lon_range = self._calculateRange(lon)
return lat_range, lon_range
def _autoUpdateApt(self):
if not self.auto_update_apt.get() or not os.path.exists(self.apt_path):
return
old_timestamp = self._readAptTimestamp()
self._updateApt(old_timestamp)
def _readAptTimestamp(self):
if not os.path.exists(APT_TIMESTAMP):
self._writeAptTimestamp('')
logger.info("Opening apt timestamp file '{}' for reading".format(
APT_TIMESTAMP))
with open(APT_TIMESTAMP, "r", encoding="utf-8") as timestamp:
old_modtime = timestamp.read()
return old_modtime
def _writeAptTimestamp(self, s=None):
if s is None:
s = self._getAptModTime()
logger.info("Opening apt timestamp file '{}' for writing".format(
APT_TIMESTAMP))
with open(APT_TIMESTAMP, "w", encoding="utf-8") as timestamp:
timestamp.write(s)
def _getAptModTime(self):
return str(os.path.getmtime(self.apt_path))
def _updateApt(self, old_timestamp):
if old_timestamp != self._getAptModTime():
self._makeAptDigest(head=_('Modification of apt.dat.gz detected.'))
# The new apt.dat may invalidate the current parking
status, *rest = self.decodeParkingSetting(self.park.get())
if status == "apt.dat":
# This was a parking position obtained from apt.dat; it may be
# invalid with the new file, reset.
self.park.set('')
# This is also outdated with respect to the new apt.dat.
self.aptDatCache.clear()
# Accept any arguments to allow safe use as a Tkinter variable observer
def updateMagFieldProvider(self, *args):
from .geo.magfield import EarthMagneticField, MagVarUnavailable
try:
self.earthMagneticField = EarthMagneticField(self)
except MagVarUnavailable as e:
self.earthMagneticField = None
self.earthMagneticFieldLastProblem = e.message
from .fgdata import airport as airport_mod
from .fgdata import parking as parking_mod
from .gui import airport_finder as airport_finder_mod
from .gui import gps_tool as gps_tool_mod
for module in (airport_mod, parking_mod, airport_finder_mod,
gps_tool_mod):
module.setupEarthMagneticFieldProvider(self.earthMagneticField)
class CFGDemo(object):
def __init__(self, grammar, text):
self._grammar = grammar
self._text = text
# Set up the main window.
self._top = Tk()
self._top.title('Context Free Grammar Demo')
# Base font size
self._size = IntVar(self._top)
self._size.set(12) # = medium
# Set up the key bindings
self._init_bindings(self._top)
# Create the basic frames
frame1 = Frame(self._top)
frame1.pack(side='left', fill='y', expand=0)
self._init_menubar(self._top)
self._init_buttons(self._top)
self._init_grammar(frame1)
self._init_treelet(frame1)
self._init_workspace(self._top)
#//////////////////////////////////////////////////
# Initialization
#//////////////////////////////////////////////////
def _init_bindings(self, top):
top.bind('<Control-q>', self.destroy)
def _init_menubar(self, parent): pass
def _init_buttons(self, parent): pass
def _init_grammar(self, parent):
self._prodlist = ProductionList(parent, self._grammar, width=20)
self._prodlist.pack(side='top', fill='both', expand=1)
self._prodlist.focus()
self._prodlist.add_callback('select', self._selectprod_cb)
self._prodlist.add_callback('move', self._selectprod_cb)
def _init_treelet(self, parent):
self._treelet_canvas = Canvas(parent, background='white')
self._treelet_canvas.pack(side='bottom', fill='x')
self._treelet = None
def _init_workspace(self, parent):
self._workspace = CanvasFrame(parent, background='white')
self._workspace.pack(side='right', fill='both', expand=1)
self._tree = None
self.reset_workspace()
#//////////////////////////////////////////////////
# Workspace
#//////////////////////////////////////////////////
def reset_workspace(self):
c = self._workspace.canvas()
fontsize = int(self._size.get())
node_font = ('helvetica', -(fontsize+4), 'bold')
leaf_font = ('helvetica', -(fontsize+2))
# Remove the old tree
if self._tree is not None:
self._workspace.remove_widget(self._tree)
# The root of the tree.
start = self._grammar.start().symbol()
rootnode = TextWidget(c, start, font=node_font, draggable=1)
# The leaves of the tree.
leaves = []
for word in self._text:
leaves.append(TextWidget(c, word, font=leaf_font, draggable=1))
# Put it all together into one tree
self._tree = TreeSegmentWidget(c, rootnode, leaves,
color='white')
# Add it to the workspace.
self._workspace.add_widget(self._tree)
# Move the leaves to the bottom of the workspace.
for leaf in leaves: leaf.move(0,100)
#self._nodes = {start:1}
#self._leaves = dict([(l,1) for l in leaves])
def workspace_markprod(self, production):
pass
def _markproduction(self, prod, tree=None):
if tree is None: tree = self._tree
for i in range(len(tree.subtrees())-len(prod.rhs())):
if tree['color', i] == 'white':
self._markproduction
for j, node in enumerate(prod.rhs()):
widget = tree.subtrees()[i+j]
if (isinstance(node, Nonterminal) and
isinstance(widget, TreeSegmentWidget) and
node.symbol == widget.label().text()):
pass # matching nonterminal
elif (isinstance(node, compat.string_types) and
isinstance(widget, TextWidget) and
node == widget.text()):
pass # matching nonterminal
else: break
else:
# Everything matched!
print('MATCH AT', i)
#//////////////////////////////////////////////////
# Grammar
#//////////////////////////////////////////////////
def _selectprod_cb(self, production):
canvas = self._treelet_canvas
self._prodlist.highlight(production)
if self._treelet is not None: self._treelet.destroy()
# Convert the production to a tree.
rhs = production.rhs()
for (i, elt) in enumerate(rhs):
if isinstance(elt, Nonterminal): elt = Tree(elt)
tree = Tree(production.lhs().symbol(), *rhs)
# Draw the tree in the treelet area.
fontsize = int(self._size.get())
node_font = ('helvetica', -(fontsize+4), 'bold')
leaf_font = ('helvetica', -(fontsize+2))
self._treelet = tree_to_treesegment(canvas, tree,
node_font=node_font,
leaf_font=leaf_font)
self._treelet['draggable'] = 1
# Center the treelet.
(x1, y1, x2, y2) = self._treelet.bbox()
w, h = int(canvas['width']), int(canvas['height'])
self._treelet.move((w-x1-x2)/2, (h-y1-y2)/2)
# Mark the places where we can add it to the workspace.
self._markproduction(production)
def destroy(self, *args):
self._top.destroy()
def mainloop(self, *args, **kwargs):
self._top.mainloop(*args, **kwargs)
class PypeTkPad(object):
def __init__(self, master, queue, pypeOutput):
self.queue = queue
self.pypeOutput = pypeOutput
self.master = master
self.master.title('PypePad')
self.master.geometry("%dx%d%+d%+d" % (700, 500, 0, 0))
self.master.minsize(300, 100)
self.output_file_name = None
self.BuildMainFrame()
self.UpdateOutput()
def NewCommand(self):
self.ClearAllCommand()
def OpenCommand(self):
import tkinter.filedialog
from tkinter import END
openfile = tkinter.filedialog.askopenfile()
if not openfile:
return
for line in openfile.readlines():
self.text_input.insert(END,line)
def SaveCommand(self):
import tkinter.filedialog
from tkinter import END
saveasfile = tkinter.filedialog.asksaveasfile()
if not saveasfile:
return
alltext = self.text_input.get("1.0",END)
saveasfile.write(alltext)
def QuitCommand(self):
self.master.quit()
def ClearInputCommand(self):
from tkinter import END
self.text_input.delete("1.0",END)
def ClearOutputCommand(self):
from tkinter import NORMAL, END, DISABLED
self.text_output["state"] = NORMAL
self.text_output.delete("1.0",END)
self.text_output["state"] = DISABLED
self.text_output.see(END)
self.text_output.update()
def ClearAllCommand(self):
self.ClearInputCommand()
self.ClearOutputCommand()
def OutputFileCommand(self):
import tkinter.filedialog
outputfilename = tkinter.filedialog.asksaveasfilename()
if sys.platform == 'win32' and len(outputfilename.split()) > 1:
outputfilename = '"%s"' % outputfilename
self.output_file_name = outputfilename
def AboutCommand(self):
self.OutputText('\n')
self.OutputText('* PypePad, Copyright (c) Luca Antiga, David Steinman. *\n')
self.OutputText('\n')
def UpdateOutput(self):
if self.pypeOutput:
text = self.pypeOutput.pop(0)
self.output_stream.write(text)
self.master.after(10,self.UpdateOutput)
def RunPype(self,arguments):
if not arguments:
return
if self.output_to_file.get() is not 'n' and self.output_file_name:
self.output_stream.output_to_file = True
self.output_stream.output_file = open(self.output_file_name,self.output_to_file.get())
else:
self.output_stream.output_to_file = False
self.queue.append(arguments)
def GetWordUnderCursor(self):
from tkinter import CURRENT
splitindex = self.text_input.index(CURRENT).split('.')
line = self.text_input.get(splitindex[0]+".0",splitindex[0]+".end")
wordstart = line.rfind(' ',0,int(splitindex[1])-1)+1
wordend = line.find(' ',int(splitindex[1]))
if wordend == -1:
wordend = len(line)
word = line[wordstart:wordend]
return word
def GetWordIndex(self):
startindex = self.text_input.index("insert-1c wordstart")
endindex = self.text_input.index("insert-1c wordend")
if self.text_input.get(startindex+'-1c') == '-' and self.text_input.get(startindex+'-2c') == '-':
startindex = self.text_input.index("insert-1c wordstart -2c")
elif self.text_input.get(startindex+'-1c') == '-' and self.text_input.get(startindex+'-2c') == ' ':
startindex = self.text_input.index("insert-1c wordstart -1c")
self.wordIndex[0] = startindex
self.wordIndex[1] = endindex
word = self.text_input.get(self.wordIndex[0],self.wordIndex[1])
return word
def GetLogicalLine(self,physicallineid):
indexes, lines = self.GetLogicalLines()
return lines[indexes[physicallineid]]
def GetLogicalLineRange(self,physicallinefirstid,physicallinelastid):
indexes, lines = self.GetLogicalLines()
return lines[indexes[physicallinefirstid]:indexes[physicallinelastid]+1]
def GetAllLogicalLines(self):
return self.GetLogicalLines()[1]
def GetLogicalLines(self):
from tkinter import END
# Python 2 hack to remove the u'...' prefix from unicode literal strings. does not change py3 behavior
physicallines = [str(line) for line in self.text_input.get("1.0",END).split('\n')]
lines = []
indexes = [0] * len(physicallines)
lineid = 0
previousline = ""
join = 0
for line in physicallines:
if line.startswith('#'):
if join:
indexes[lineid] = indexes[lineid-1]
elif join:
if line.endswith('\\'):
lines[-1] = lines[-1] + " " + line[:-1]
join = 1
else:
lines[-1] = lines[-1] + " " + line
join = 0
indexes[lineid] = indexes[lineid-1]
else:
if line.endswith('\\'):
join = 1
lines.append(line[:-1])
else:
lines.append(line)
join = 0
if lineid > 0:
indexes[lineid] = indexes[lineid-1]+1
lineid += 1
return indexes, lines
def GetLineUnderCursor(self):
from tkinter import INSERT
currentlineid = int(self.text_input.index(INSERT).split('.')[0]) - 1
return self.GetLogicalLine(currentlineid)
def RunAllCommand(self):
lines = self.GetAllLogicalLines()
for line in lines:
if line and line.strip():
self.RunPype(line)
def RunLineCommand(self):
line = self.GetLineUnderCursor()
if line and line.strip():
self.RunPype(line)
def RunSelectionCommand(self):
from tkinter import TclError, SEL_FIRST, SEL_LAST
try:
firstlineid = int(self.text_input.index(SEL_FIRST).split('.')[0]) - 1
lastlineid = int(self.text_input.index(SEL_LAST).split('.')[0]) - 1
lines = self.GetLogicalLineRange(firstlineid,lastlineid)
for line in lines:
self.RunPype(line)
except TclError:
pass
def GetSuggestionsList(self,word):
list = []
try:
from vmtk import vmtkscripts
from vmtk import pypes
except ImportError:
return None
if word.startswith('--'):
list = ['--pipe','--help']
elif word.startswith('-'):
optionlist = []
scriptindex = self.text_input.search('vmtk',self.wordIndex[0],backwards=1)
moduleName = self.text_input.get( scriptindex,scriptindex+' wordend' )
try:
module = importlib.import_module('vmtk.'+moduleName)
# Find the principle class to instantiate the requested action defined inside the requested writerModule script.
# Returns a single member list (containing the principle class name) which satisfies the following criteria:
# 1) is a class defined within the script
# 2) the class is a subclass of pypes.pypescript
scriptObjectClasses = [x for x in dir(module) if isclass(getattr(module, x)) and issubclass(getattr(module, x), pypes.pypeScript)]
scriptObjectClassName = scriptObjectClasses[0]
scriptObject = getattr(module, scriptObjectClassName)
scriptObject = scriptObject()
members = scriptObject.InputMembers + scriptObject.OutputMembers
for member in members:
optionlist.append('-'+member.OptionName)
list = [option for option in optionlist if option.count(word)]
except:
return list
else:
list = [scriptname for scriptname in vmtkscripts.__all__ if scriptname.count(word)]
for index, item in enumerate(list):
# check if scriptname contains starting prefix 'vmtk.' and remove it before returning list to the user.
if 'vmtk.' == item[0:5]:
splitList = item.split('.')
list[index] = splitList[1]
else:
continue
return list
def FillSuggestionsList(self,word):
from tkinter import END
self.suggestionslist.delete(0,END)
suggestions = self.GetSuggestionsList(word)
for suggestion in suggestions:
self.suggestionslist.insert(END,suggestion)
def ReplaceTextCommand(self,word):
self.text_input.delete(self.wordIndex[0],self.wordIndex[1])
self.text_input.insert(self.wordIndex[0],word)
self.text_input.focus_set()
def ShowHelpCommand(self):
word = self.GetWordUnderCursor()
self.OutputText(word)
if word:
self.RunPype(word+' --help')
else:
self.OutputText('Enter your vmtk Pype above and Run.\n')
def AutoCompleteCommand(self):
word = self.GetWordIndex()
self.suggestionswindow.withdraw()
if word:
self.FillSuggestionsList(word)
self.suggestionswindow.geometry("%dx%d%+d%+d" % (400, 150, self.text_output.winfo_rootx(),self.text_output.winfo_rooty()))
self.suggestionswindow.deiconify()
self.suggestionswindow.lift()
def InsertScriptName(self,scriptname):
from tkinter import INSERT
self.text_input.insert(INSERT,scriptname+' ')
def InsertFileName(self):
from tkinter import INSERT
import tkinter.filedialog
openfilename = tkinter.filedialog.askopenfilename()
if not openfilename:
return
if len(openfilename.split()) > 1:
openfilename = '"%s"' % openfilename
self.text_input.insert(INSERT,openfilename+' ')
def KeyPressHandler(self,event):
if event.keysym == "Tab" :
self.AutoCompleteCommand()
self.suggestionslist.focus_set()
self.suggestionslist.selection_set(0)
return "break"
else:
self.text_input.focus_set()
def TopKeyPressHandler(self,event):
from tkinter import ACTIVE, INSERT
if event.keysym in ['Down','Up'] :
self.suggestionslist.focus_set()
elif event.keysym == "Return":
word = self.suggestionslist.get(ACTIVE)
self.ReplaceTextCommand(word)
self.suggestionswindow.withdraw()
self.text_input.focus_set()
elif len(event.keysym) == 1 :
self.suggestionswindow.withdraw()
self.text_input.insert(INSERT,event.keysym)
self.text_input.focus_set()
else :
self.suggestionswindow.withdraw()
self.text_input.focus_set()
def NewHandler(self,event):
self.NewCommand()
def OpenHandler(self,event):
self.OpenCommand()
def SaveHandler(self,event):
self.SaveCommand()
def InsertFileNameHandler(self,event):
self.InsertFileName()
return "break"
def QuitHandler(self,event):
self.QuitCommand()
def ShowHelpHandler(self,event):
self.ShowHelpCommand()
def RunKeyboardHandler(self,event):
from tkinter import SEL_FIRST, TclError
try:
self.text_input.index(SEL_FIRST)
self.RunSelectionCommand()
except TclError:
self.RunLineCommand()
return "break"
def RunAllHandler(self,event):
self.RunAllCommand()
def PopupHandler(self,event):
try:
self.popupmenu.tk_popup(event.x_root, event.y_root, 0)
finally:
self.popupmenu.grab_release()
def OutputText(self,text):
from tkinter import NORMAL, END, DISABLED
self.text_output["state"] = NORMAL
self.text_output.insert(END,text)
self.text_output["state"] = DISABLED
def BuildScriptMenu(self,parentmenu,modulename):
from tkinter import Menu
menu = Menu(parentmenu,bd=1,activeborderwidth=0)
try:
module = importlib.import_module('vmtk.'+modulename)
except ImportError:
return None
scriptnames = [scriptname for scriptname in getattr(module, '__all__')]
for index, scriptname in enumerate(scriptnames):
# check if scriptname contains starting prefix 'vmtk.' and remove it before returning list to the user.
if 'vmtk.' == scriptname[0:5]:
splitList = scriptname.split('.')
scriptnames[index] = splitList[1]
else:
continue
menulength = 20
for i in range(len(scriptnames)//menulength+1):
subscriptnames = scriptnames[i*menulength:(i+1)*menulength]
if not subscriptnames:
break
submenu = Menu(menu,bd=1,activeborderwidth=0)
menu.add_cascade(label=subscriptnames[0]+"...",menu=submenu)
for scriptname in subscriptnames:
callback = CallbackShim(self.InsertScriptName,scriptname)
submenu.add_command(label=scriptname,command=callback)
return menu
def BuildMainFrame(self):
from tkinter import Menu, IntVar, StringVar, Toplevel, Listbox, Frame, PanedWindow, Text, Scrollbar, Entry
from tkinter import X, N, S, W, E, VERTICAL, TOP, END, DISABLED, RAISED
menu = Menu(self.master,activeborderwidth=0,bd=0)
self.master.config(menu=menu)
filemenu = Menu(menu,tearoff=0,bd=1,activeborderwidth=0)
menu.add_cascade(label="File", underline=0, menu=filemenu)
filemenu.add_command(label="New", accelerator='Ctrl+N',command=self.NewCommand)
filemenu.add_command(label="Open...",accelerator='Ctrl+O', command=self.OpenCommand)
filemenu.add_command(label="Save as...",accelerator='Ctrl+S', command=self.SaveCommand)
filemenu.add_separator()
filemenu.add_command(label="Quit",accelerator='Ctrl+Q', command=self.QuitCommand)
self.log_on = IntVar()
self.log_on.set(1)
self.output_to_file = StringVar()
self.output_to_file.set('n')
scriptmenu = Menu(menu,tearoff=0,bd=1,activeborderwidth=0)
modulenames = ['vmtkscripts']
for modulename in modulenames:
scriptsubmenu = self.BuildScriptMenu(menu,modulename)
if scriptsubmenu:
scriptmenu.add_cascade(label=modulename,menu=scriptsubmenu)
editmenu = Menu(menu,tearoff=0,bd=1,activeborderwidth=0)
menu.add_cascade(label="Edit",underline=0, menu=editmenu)
editmenu.add_cascade(label="Insert script",menu=scriptmenu)
editmenu.add_command(label="Insert file name", accelerator='Ctrl+F',command=self.InsertFileName)
editmenu.add_separator()
editmenu.add_command(label="Clear input", command=self.ClearInputCommand)
editmenu.add_command(label="Clear output", command=self.ClearOutputCommand)
editmenu.add_command(label="Clear all", command=self.ClearAllCommand)
editmenu.add_separator()
editmenu.add_checkbutton(label="Log", variable=self.log_on)
editmenu.add_separator()
editmenu.add_radiobutton(label="No output to file", variable=self.output_to_file,value='n')
editmenu.add_radiobutton(label="Write output to file", variable=self.output_to_file,value='w')
editmenu.add_radiobutton(label="Append output to file", variable=self.output_to_file,value='a')
editmenu.add_command(label="Output file...", command=self.OutputFileCommand)
runmenu = Menu(menu,tearoff=0,bd=1,activeborderwidth=0)
menu.add_cascade(label="Run", underline=0, menu=runmenu)
runmenu.add_command(label="Run all", command=self.RunAllCommand)
runmenu.add_command(label="Run current line", command=self.RunLineCommand)
runmenu.add_command(label="Run selection", command=self.RunSelectionCommand)
helpmenu = Menu(menu,tearoff=0,bd=1,activeborderwidth=0)
menu.add_cascade(label="Help", underline=0, menu=helpmenu)
helpmenu.add_command(label="Help", underline=0, accelerator='F1',command=self.ShowHelpCommand)
helpmenu.add_command(label="About", underline=0, command=self.AboutCommand)
self.master.bind("<Control-KeyPress-q>", self.QuitHandler)
self.master.bind("<Control-KeyPress-n>", self.NewHandler)
self.master.bind("<Control-KeyPress-o>", self.OpenHandler)
self.master.bind("<Control-KeyPress-s>", self.SaveHandler)
self.master.bind("<Control-KeyPress-f>", self.InsertFileNameHandler)
self.master.bind("<KeyPress-F1>", self.ShowHelpHandler)
self.master.bind("<KeyPress>", self.KeyPressHandler)
self.wordIndex = ['1.0','1.0']
self.suggestionswindow = Toplevel(bg='#ffffff',bd=0,height=50,width=600,highlightthickness=0,takefocus=True)
self.suggestionswindow.overrideredirect(1)
self.suggestionslist = Listbox(self.suggestionswindow,bg='#ffffff',bd=1,fg='#336699',activestyle='none',highlightthickness=0,height=9)
self.suggestionslist.insert(END,"foo")
self.suggestionslist.pack(side=TOP,fill=X)
self.suggestionswindow.bind("<KeyPress>", self.TopKeyPressHandler)
self.suggestionswindow.withdraw()
self.master.rowconfigure(0,weight=1)
self.master.columnconfigure(0,weight=1)
content = Frame(self.master,bd=0,padx=2,pady=2)
content.grid(row=0,column=0,sticky=N+S+W+E)
content.rowconfigure(0,weight=1,minsize=50)
content.rowconfigure(1,weight=0)
content.columnconfigure(0,weight=1)
panes = PanedWindow(content,orient=VERTICAL,bd=1,sashwidth=8,sashpad=0,sashrelief=RAISED,showhandle=True)
panes.grid(row=0,column=0,sticky=N+S+W+E)
frame1 = Frame(panes,bd=0)
frame1.grid(row=0,column=0,sticky=N+S+W+E)
frame1.columnconfigure(0,weight=1)
frame1.columnconfigure(1,weight=0)
frame1.rowconfigure(0,weight=1)
panes.add(frame1,height=300,minsize=20)
frame2 = Frame(panes,bd=0)
frame2.grid(row=1,column=0,sticky=N+S+W+E)
frame2.columnconfigure(0,weight=1)
frame2.columnconfigure(1,weight=0)
frame2.rowconfigure(0,weight=1)
panes.add(frame2,minsize=20)
self.text_input = Text(frame1, bg='#ffffff',bd=1,highlightthickness=0)
self.text_input.bind("<KeyPress>", self.KeyPressHandler)
self.text_input.bind("<Button-3>", self.PopupHandler)
self.text_input.bind("<Control-Return>", self.RunKeyboardHandler)
self.input_scrollbar = Scrollbar(frame1,orient=VERTICAL,command=self.text_input.yview)
self.text_input["yscrollcommand"] = self.input_scrollbar.set
self.text_output = Text(frame2,state=DISABLED,bd=1,bg='#ffffff',highlightthickness=0)
self.output_scrollbar = Scrollbar(frame2,orient=VERTICAL,command=self.text_output.yview)
self.text_output["yscrollcommand"] = self.output_scrollbar.set
self.text_entry = Entry(content,bd=1,bg='#ffffff',state=DISABLED,highlightthickness=0)
self.text_input.focus_set()
self.text_input.grid(row=0,column=0,sticky=N+S+W+E)
self.input_scrollbar.grid(row=0,column=1,sticky=N+S+W+E)
self.text_output.grid(row=0,column=0,sticky=N+S+W+E)
self.output_scrollbar.grid(row=0,column=1,sticky=N+S+W+E)
self.text_entry.grid(row=1,column=0,sticky=N+S+W+E)
self.popupmenu = Menu(self.text_input, tearoff=1, bd=0)
self.popupmenu.add_command(label="Context help", command=self.ShowHelpCommand)
self.popupmenu.add_cascade(label="Insert script",menu=scriptmenu)
self.popupmenu.add_command(label="Insert file name...", command=self.InsertFileName)
self.popupmenu.add_separator()
self.popupmenu.add_command(label="Run all", command=self.RunAllCommand)
self.popupmenu.add_command(label="Run current line", command=self.RunLineCommand)
self.popupmenu.add_command(label="Run selection", command=self.RunSelectionCommand)
self.output_stream = TkPadOutputStream(self.text_output)
self.input_stream = TkPadInputStream(self.text_entry,self.output_stream)
