def build_widgets(self, master, row):
self.var = IntVar(master)
self.init_var()
chbut = Checkbutton(master, text = self.label,
command = self.var_changed,
variable = self.var)
chbut.grid(row = row, column =1, columnspan = 3, sticky = 'w')
class MeasureFrame(LabelFrame):
def __init__(self, master, tracker, text="Measuring", *args, **kwargs):
LabelFrame.__init__(self, master, text=text, *args, **kwargs)
self.tracker = tracker
self.config_frame = NamedEntryFrame(self, (OBS_INTERVAL,
NUM_SAMPLES,
NUM_OBSS),
parsers={OBS_INTERVAL: float,
NUM_SAMPLES: int,
NUM_OBSS: int})
self.config_frame.grid()
self.save_frame = LabelFrame(self, text="Saving")
self.dest_selector = FileSelectionFrame(self.save_frame,
ask_mode="save")
self.dest_selector.grid(row=0, column=0, columnspan=2)
self.save_button = Button(self.save_frame, text="Save",
command=bg_caller(self.save))
self.save_button.grid(row=1, column=0)
self.appending_var = BooleanVar()
self.append_checkbutton = Checkbutton(self.save_frame, text="Append",
variable=self.appending_var)
self.append_checkbutton.grid(row=1, column=1)
self.save_frame.grid()
def measure(self, only_accurate=True):
try:
interval = self.config_frame.get(OBS_INTERVAL)
samples = self.config_frame.get(NUM_SAMPLES)
num_obss = self.config_frame.get(NUM_OBSS)
except ValueError:
logger.error("Could not parse input fields.")
data = self.tracker.measure(observation_interval=interval,
samples_per_observation=samples,
number_of_observations=num_obss)
if only_accurate:
accurate_data = [point for point in data
if point.status == point.DATA_ACCURATE]
num_invalid = len(data) - len(accurate_data)
if num_invalid > 0:
logger.warning("Hiding {} inaccurate data points."
.format(num_invalid))
return accurate_data
else:
return data
def save(self, only_accurate=True):
dest = self.dest_selector.path_var.get()
if not dest:
logger.error("Must select a destination file.")
return
data = self.measure(only_accurate=only_accurate)
w = csv.writer(open(dest, 'a' if self.appending_var.get() else 'w'))
for point in data:
w.writerow((point.time, point.position.r,
point.position.theta, point.position.phi))
logger.info("Saved measurements into {!r}".format(dest))
class PasswordDialog(Dialog):
def __init__(self, title, prompt, parent):
self.prompt = prompt
Dialog.__init__(self, parent, title)
def body(self, master):
from Tkinter import Label
from Tkinter import Entry
from Tkinter import Checkbutton
from Tkinter import IntVar
from Tkinter import W
self.checkVar = IntVar()
Label(master, text=self.prompt).grid(row=0, sticky=W)
self.e1 = Entry(master)
self.e1.grid(row=0, column=1)
self.cb = Checkbutton(master, text="Save to keychain", variable=self.checkVar)
self.cb.pack()
self.cb.grid(row=1, columnspan=2, sticky=W)
self.configure(show='*')
def apply(self):
self.result = (self.e1.get(), self.checkVar.get() == 1)
def MakeCB(self, cb_ptr, text, evt_type, arg, csp=1, stky=W):
cb_ptr = Checkbutton(self, text=text)
cb_ptr.bind(evt_type, lambda event, arg=arg: self.toggle_cb(event, arg))
if self.orig[arg]:
cb_ptr.select()
cb_ptr.grid(row=self.row, column=self.col, columnspan=csp, sticky=W)
self.row += 1
def redraw(self):
# Even though there are never more than three widgets per row,
# we have four columns, to allow the taskname label and the
# input widget to stretch.
self.grid_columnconfigure(2, weight=1)
row = 0
# Add a new row of widgets for each task.
for rec in sorted(self.table.query(), key=lambda rec: rec.get('created')):
# Extract the fields we need.
completed = rec.get('completed')
taskname = rec.get('taskname')
# Create a button with an 'X' in it, to delete the task.
close_btn = Button(self, text='X',
command=lambda rec=rec: self.delete_rec(rec))
close_btn.grid(row=row, column=0)
# Create a checkbox, to mark it completed (or not).
var = BooleanVar(self, value=completed)
completed_btn = Checkbutton(self, variable=var,
command=lambda rec=rec, var=var:
self.toggle_rec(rec, var))
completed_btn.grid(row=row, column=1)
# Create a label showing the task name.
taskname_lbl = Label(self, text=taskname, anchor=W)
taskname_lbl.grid(row=row, column=2, columnspan=2, sticky=W)
row += 1 # Bump row index.
# Add a final row with the input and button to add new tasks.
self.input = Entry(self)
self.input.bind('<Return>', self.add_rec)
self.input.grid(row=row, column=0, columnspan=3, sticky=W+E)
add_btn = Button(self, text='Add Task', command=self.add_rec)
add_btn.grid(row=row, column=3)
# Add save button. (Auto-save is left as an exercise.)
save_btn = Button(self, text='Save local snapshot', command=self.save)
save_btn.grid(row=row+1, column=0, columnspan=3, sticky=W)
def CreateCheckList(self, frame, labels, values=None, colors=None):
all_widgetes = [w for w in frame.winfo_children() if w.winfo_class() == 'Checkbutton']
for w in all_widgetes:
w.destroy()
all_widgetes = [w for w in frame.winfo_children() if w.winfo_class() == 'Label']
for w in all_widgetes[1:]:
w.destroy()
var = []
if values is not None:
add_text = ["%5.1f" % (values[i]) +'%' for i in range(len(values))]
for i in range(len(labels)):
var.append(BooleanVar())
fgc = "black"
if colors is not None:
mycolor = '#%02x%02x%02x' % (colors[i,0], colors[i,1], colors[i,2])
if (colors[i,0]+colors[i,1]+colors[i,2])/3/255<=0.5:
fgc = "#FFFFFF"
else:
mycolor = frame.cget('bg')
cb = Checkbutton(frame, text=labels[i], state=DISABLED, variable=var[i], bg=mycolor, disabledforeground=fgc, anchor=W)
# cb.pack(anchor=W, fill=X, padx=2)
cb.grid(row=i+2,column=0,sticky=W+E)
if values is not None:
cb = Label(frame, text=add_text[i], bg=mycolor, fg=fgc, anchor=E)
cb.grid(row=i+2,column=1,sticky=W+E+N+S)
frame.grid_rowconfigure(i+2, weight=0)
return var
class PasswordDialog(Dialog):
def __init__(self, title, prompt, parent):
self.prompt = prompt
Dialog.__init__(self, parent, title)
def body(self, master):
from Tkinter import Label
from Tkinter import Entry
from Tkinter import Checkbutton
from Tkinter import IntVar
from Tkinter import W
self.checkVar = IntVar()
Label(master, text=self.prompt).grid(row=0, sticky=W)
self.e1 = Entry(master)
self.e1.grid(row=0, column=1)
self.cb = Checkbutton(master, text="Save to keychain", variable=self.checkVar)
self.cb.pack()
self.cb.grid(row=1, columnspan=2, sticky=W)
self.e1.configure(show='*')
def apply(self):
self.result = (self.e1.get(), self.checkVar.get() == 1)
def __init__(self, master, mech):
self.mech = mech
frame = Frame(master)
frame.grid()
rct_label = Label(frame, text='Select Reactants')
rct_label.grid(column=1, row=1)
and_or = Label(frame, text='AND/OR')
and_or.grid(column=3, row=1)
prod_label = Label(frame, text='Select Products')
prod_label.grid(column=4, row=1)
what_to_do = Label(frame, text='Execute')
what_to_do.grid(column=6, row=1)
reactants_scrollbar = Scrollbar(frame, orient=VERTICAL)
self.reactants = Listbox(frame,
selectmode=EXTENDED,
exportselection=0,
yscrollcommand=reactants_scrollbar.set)
self.reactants.grid(column=1, row=2)
reactants_scrollbar.config(command=self.reactants.yview)
reactants_scrollbar.grid(column=2, row=2, sticky=N + S)
self.logical_and = IntVar()
self.logical_and.set(1)
c = Checkbutton(frame, text="AND", variable=self.logical_and)
c.grid(column=3, row=2)
products_scrollbar = Scrollbar(frame, orient=VERTICAL)
self.products = Listbox(frame, selectmode=EXTENDED, exportselection=0)
self.products.grid(column=4, row=2)
products_scrollbar.config(command=self.products.yview)
products_scrollbar.grid(column=5, row=2, sticky=N + S)
self.method_list = Listbox(frame,
selectmode=EXTENDED,
exportselection=0)
self.method_list.grid(column=6, row=2)
#self.methods = [k for k in dir(self.mech) if k[:1] != '_' and isinstance(getattr(self.mech, k), MethodType)]
self.methods = [
'plot_rxns', 'find_rxns', 'print_rxns', 'print_irrs',
'print_net_rxn', 'plot_proc'
]
method_labels = [
'Plot Reactions', 'Show Rxn Ids', 'Print Rxns', 'Print IRRs',
'Print Net Rxn', 'Process Plot'
]
for method in method_labels:
self.method_list.insert(END, method)
species_keys = self.mech.species_dict.keys()
species_keys.sort()
self.species_objects = [
self.mech.species_dict[spc] for spc in species_keys
]
for spc in species_keys:
self.reactants.insert(END, spc)
self.products.insert(END, spc)
self.execute_button = Button(frame, text="go", command=self.execute)
self.execute_button.grid(column=6, row=4)
def interface_visu(self, root):
"""!Création de l'interface de visualisation
permet de choisir d'afficher les matrices MAC ou les modes avec gmsh
gère la compatibilité des choix de l'utilisateur (les calculs de MAC
ne sont pas tous possibles)
"""
mdo = self.objects
f = Frame(root, relief='sunken', borderwidth=1)
Label(f, text=" ").grid(
row=0, column=1, columnspan=3, sticky='w' + 'e')
Label(f, text=" ").grid(
row=2, column=1, columnspan=3, sticky='w' + 'e')
f.columnconfigure(0, weight=3)
f.columnconfigure(1, weight=3)
f1 = Frame(f)
f1.grid(row=1, column=0, sticky='ew')
f1.columnconfigure(1, weight=4)
f1.columnconfigure(2, weight=4)
bir1 = Checkbutton(f1, variable=self.is_resu1, command=self.cb_changed)
bir1.grid(row=0, column=0, sticky='e', padx=20)
bir2 = Checkbutton(f1, variable=self.is_resu2, command=self.cb_changed)
bir2.grid(row=1, column=0, sticky='e', padx=20)
Label(f1, text=u"Résultat 1").grid(row=0, column=1, sticky='w')
self.var_resu1 = StringVar()
self.menu_resu1 = MyMenu(f1, options=mdo.get_resultats_name(),
var=self.var_resu1, cmd=self.visu1_changed)
self.menu_resu1.grid(row=0, column=2, sticky='ew', padx=20)
Label(f1, text=u"Résultat 2").grid(row=1, column=1, sticky='w')
self.var_resu2 = StringVar()
self.menu_resu2 = MyMenu(f1, options=mdo.get_resultats_name(),
var=self.var_resu2, cmd=self.visu2_changed)
self.menu_resu2.grid(row=1, column=2, sticky='ew', padx=20)
f2 = Frame(f)
f2.grid(row=1, column=1)
self.mac_button = Button(
f2, text=" MAC ", command=self.view_macs, state='disabled')
self.mac_button.grid(row=1, column=2, sticky='ew')
self.phi_button = Button(
f2, text=u"Déformées", command=self.view_modes, state='disabled')
self.phi_button.grid(row=2, column=2, sticky='ew')
self.frf_button = Button(f2, text=" FRF ", command=self.view_frf)
self.frf_button.grid(row=3, column=2, sticky='ew')
self.frf_button = Button(
f1, text=" Observation ", command=self.view_obs_1)
self.frf_button.grid(row=0, column=3, sticky='ew')
self.frf_button = Button(
f1, text=" Observation ", command=self.view_obs_2)
self.frf_button.grid(row=1, column=3, sticky='ew')
return f
class GpioSimulator():
def __init__(self, frontend):
self.frontend = frontend
self.playing_led = None
thread = Thread(target=self.initial_simulator)
thread.start()
def initial_simulator(self):
root = Tk()
root.title("GPIO Simulator")
previous = Button(root, text="Previous", command=self.previous)
main = Button(root, text="Main button", command=self.main)
next = Button(root, text="Next", command=self.next)
vol_up = Button(root, text="Vol +", command=self.vol_up)
vol_up_long = Button(root, text="Vol + long", command=self.vol_up_long)
vol_down = Button(root, text="Vol -", command=self.vol_down)
vol_down_long = Button(root,
text="Vol - long",
command=self.vol_down_long)
main_long = Button(root, text="Main long", command=self.main_long)
self.playing_led = Checkbutton(text="playing_led", state=DISABLED)
vol_up.grid(row=0, column=1)
vol_up_long.grid(row=0, column=2)
previous.grid(row=1, column=0)
main.grid(row=1, column=1)
main_long.grid(row=1, column=2)
next.grid(row=1, column=3)
vol_down.grid(row=2, column=1)
vol_down_long.grid(row=2, column=2)
self.playing_led.grid(row=3, column=1)
root.mainloop()
def previous(self):
self.frontend.input({'key': 'previous', 'long': False})
def main(self):
self.frontend.input({'key': 'main', 'long': False})
def main_long(self):
self.frontend.input({'key': 'main', 'long': True})
def next(self):
self.frontend.input({'key': 'next', 'long': False})
def vol_up(self):
self.frontend.input({'key': 'volume_up', 'long': False})
def vol_down(self):
self.frontend.input({'key': 'volume_down', 'long': False})
def vol_down_long(self):
self.frontend.input({'key': 'volume_down', 'long': True})
def vol_up_long(self):
self.frontend.input({'key': 'volume_up', 'long': True})
class GpioSimulator():
def __init__(self, frontend):
self.frontend = frontend
self.playing_led = None
thread = Thread(target=self.initial_simulator)
thread.start()
def initial_simulator(self):
root = Tk()
root.title("GPIO Simulator")
previous = Button(root, text="Previous", command=self.previous)
main = Button(root, text="Main button", command=self.main)
next = Button(root, text="Next", command=self.next)
vol_up = Button(root, text="Vol +", command=self.vol_up)
vol_up_long = Button(root, text="Vol + long", command=self.vol_up_long)
vol_down = Button(root, text="Vol -", command=self.vol_down)
vol_down_long = Button(root, text="Vol - long",
command=self.vol_down_long)
main_long = Button(root, text="Main long", command=self.main_long)
self.playing_led = Checkbutton(text="playing_led", state=DISABLED)
vol_up.grid(row=0, column=1)
vol_up_long.grid(row=0, column=2)
previous.grid(row=1, column=0)
main.grid(row=1, column=1)
main_long.grid(row=1, column=2)
next.grid(row=1, column=3)
vol_down.grid(row=2, column=1)
vol_down_long.grid(row=2, column=2)
self.playing_led.grid(row=3, column=1)
root.mainloop()
def previous(self):
self.frontend.input({'key': 'previous', 'long': False})
def main(self):
self.frontend.input({'key': 'main', 'long': False})
def main_long(self):
self.frontend.input({'key': 'main', 'long': True})
def next(self):
self.frontend.input({'key': 'next', 'long': False})
def vol_up(self):
self.frontend.input({'key': 'volume_up', 'long': False})
def vol_down(self):
self.frontend.input({'key': 'volume_down', 'long': False})
def vol_down_long(self):
self.frontend.input({'key': 'volume_down', 'long': True})
def vol_up_long(self):
self.frontend.input({'key': 'volume_up', 'long': True})
def dimscheduler(self):
mischeader = headersmall(self.frame, text="Dimension Scheduler")
f = Frame(self.frame)
f.config(bg=Styles.colours["grey"])
smallentryframetext(f, 0, 0, self.params["dims"], 7, "Set Size:")
checkdimschel = Checkbutton(self.frame, text="Enable", variable=self.params["dimscheudler"], bg=Styles.colours["grey"])
mischeader.grid(row=18, column=0, sticky=W, columnspan=2)
checkdimschel.grid(row=19, column=0, sticky=W, columnspan=1, padx=15)
f.grid(row=19, column=1, sticky=W + E, columnspan=1)
class AuthDialog(Popup):
message = _('Enter username and password\nfor "%(method)s" at "%(realm)s"')
def __init__(self, parent, deferred, method, realm, addnl=None):
self.deferred = deferred
self.method = method
self.realm = realm
self._saveOK = False
Popup.__init__(self, parent, addnl)
def _saveBoolean(self, *value):
self._saveOK = not self._saveOK
def getResult(self):
return (self.uentry.get(), self.pentry.get(), self._saveOK)
def body(self):
print "auth body"
from Tkinter import NW, E, W, Frame, Label, Button, Entry, Checkbutton
defargs = { 'padx':5, 'pady':5, 'sticky':W }
self.top = Frame(self)
self.top.grid(row=1,column=1,sticky=NW)
msg = self.message % { 'realm':self.realm, 'method':self.method }
self.label = Label(self.top, text=msg, justify='center')
self.label.grid(row=1, column=1, columnspan=4, **defargs)
self.ulabel = Label(self.top, text=_('User Name')+':', justify='left')
self.ulabel.grid(row=2, column=1, columnspan=2, **defargs)
self.uentry = Entry(self.top)
self.uentry.grid(row=2, column=3, columnspan=2, **defargs)
self.uentry.focus_set()
self.plabel = Label(self.top, text=_('Password')+':', justify='left')
self.plabel.grid(row=3, column=1, columnspan=2, **defargs)
self.pentry = Entry(self.top, show="*")
self.pentry.grid(row=3, column=3, columnspan=2, **defargs)
self._saveOk = False
self.saveCheck = Checkbutton(self.top, command=self._saveBoolean)
self.saveCheck.grid(row=4, column=1, columnspan=1, **defargs)
self.savelabel = Label(self.top,
text=_('Save this username and password'))
self.savelabel.grid(row=4, column=2, columnspan=3, **defargs)
defargs['sticky'] = W
self.cancelb = Button(self.top, text=_('Cancel'), command=self.cancel)
self.cancelb.grid(row=5, column=3, columnspan=1, **defargs)
self.okb = Button(self.top, text=_('OK'), command=self.selected)
self.okb.grid(row=5, column=4, columnspan=1, **defargs)
def cs_checkbox(root, r, c, label, boolval, box_conf={}, grid_conf={}):
entrybl = BooleanVar()
entrybl.set(boolval)
checkbox = Checkbutton(master=root,
text=label,
onvalue=True,
offvalue=False,
variable=entrybl,
**box_conf)
checkbox.grid(row=r, column=c, **grid_conf)
return entrybl
def addCheckButton(self, item):
self.entryBox.delete(0, END)
self.label1.grid_forget()
self.todoList.append(item)
n = len(self.buttonList)
lx = Checkbutton(self.listFrame, text=self.todoList[n], variable=self.todoList[n], command=lambda ni=n: self.removeCheckButton(ni))
lx.grid(row=n, column=0, sticky='NW')
self.buttonList.append(lx)
#print self.buttonList
self.saveData(self.todoList)
def _setup_features(self, size):
""" Method which does the initial setup of features checkboxes. """
self._buttons = {}
for index in range(len(self._feature_labels)):
label = self._feature_labels[index][0]
value = self._feature_labels[index][1]
checkbox = Checkbutton(self._root_window,
text=label,
onvalue=value,
offvalue='')
checkbox.grid(row=2, column=index)
self._root_window.bind(value.lower(), self._on_feature_toggled)
self._buttons[value] = checkbox
class IssueDialog(tkSimpleDialog.Dialog):
def body(self, top):
self.title("Issue Number")
Label(top, text="Enter issue number: ").grid(row=0, sticky=W)
Label(top, text="Chapter number to start with: ").grid(row=1, sticky=W)
Label(top, text="Enter password for " + user + ": ").grid(row=2, sticky=W)
self.e1 = Entry(top)
self.e1.insert(0, "000")
self.e1.grid(row=0, column=1)
self.e3 = Entry(top)
self.e3.insert(0, "2")
self.e3.grid(row=1, column=1)
self.e2 = Entry(top, show="*")
self.e2.grid(row=2, column=1)
self.var = IntVar()
self.b = Checkbutton(top, text="Debug?", variable= self.var, onvalue = 1, offvalue = 0)
self.b.grid(row=3, columnspan=2, sticky=W)
#def callConvert():
#essa_clipboardDateConvert.convert()
#self.convertButton = Button(top, text="Convert clipboard date", command=callConvert)
#self.convertButton.grid(row=4, columnspan=2, sticky=W)
def apply(self):
global issue
issue = self.e1.get()
global chapNum
chapNum = int(self.e3.get())
global password
password = self.e2.get()
global debug
debug = self.var.get()
def openfile():
name = askopenfilename()
nam = name.split("/")
g = nam[-1].split(".")
grup = g[0]
print(nam, g)
print(grup)
fitxer = open(name, mode="r")
for linia in fitxer:
coordinates = linia.split("\t")
N, X, Y, Z, C = coordinates
N = coordinates[0]
X = coordinates[1]
Y = coordinates[2]
Z = coordinates[3]
C = [coordinates[4]]
if len(coordinates) > 5:
i = 5
for c in range(len(coordinates) - 5):
C.append(coordinates[i])
codis.add(c)
i = i + 1
codis.add(C[0])
i = 0
r = 2
c = 1
if askyesno("codis...", "Vols unir per codis?"):
codis_linia.clear()
tria = tk.Toplevel()
ok = tk.Button(tria, text="ok", width=25, command=tria.destroy)
ok.grid(column=0, row=0, columnspan=5)
for item in codis:
codis_linia[str(item)] = IntVar()
chb = Checkbutton(tria, text=str(item), variable=codis_linia[item], onvalue=True, offvalue=False, height=5)
if c > 5:
c = 1
r = r + 1
chb.grid(column=c, row=r)
c = c + 1
label2 = tk.Label(tria, text="Quins codis son linies")
label2.grid(row=1, columnspan=5)
def __init__(self, master, mech):
self.mech = mech
frame = Frame(master)
frame.grid()
rct_label = Label(frame, text = 'Select Reactants')
rct_label.grid(column = 1, row = 1)
and_or = Label(frame, text = 'AND/OR')
and_or.grid(column = 3, row = 1)
prod_label = Label(frame, text = 'Select Products')
prod_label.grid(column = 4, row = 1)
what_to_do = Label(frame, text = 'Execute')
what_to_do.grid(column = 6, row = 1)
reactants_scrollbar = Scrollbar(frame, orient = VERTICAL)
self.reactants = Listbox(frame, selectmode = EXTENDED, exportselection = 0, yscrollcommand = reactants_scrollbar.set)
self.reactants.grid(column = 1, row = 2)
reactants_scrollbar.config(command = self.reactants.yview)
reactants_scrollbar.grid(column = 2, row = 2, sticky = N + S)
self.logical_and = IntVar()
self.logical_and.set(1)
c = Checkbutton(frame, text = "AND", variable = self.logical_and)
c.grid(column = 3, row = 2)
products_scrollbar = Scrollbar(frame, orient = VERTICAL)
self.products = Listbox(frame, selectmode = EXTENDED, exportselection = 0)
self.products.grid(column = 4, row = 2)
products_scrollbar.config(command = self.products.yview)
products_scrollbar.grid(column = 5, row = 2, sticky = N + S)
self.method_list = Listbox(frame, selectmode = EXTENDED, exportselection = 0)
self.method_list.grid(column = 6, row = 2)
#self.methods = [k for k in dir(self.mech) if k[:1] != '_' and isinstance(getattr(self.mech, k), MethodType)]
self.methods = ['plot_rxns', 'find_rxns', 'print_rxns', 'print_irrs', 'print_net_rxn', 'plot_proc']
method_labels= ['Plot Reactions', 'Show Rxn Ids', 'Print Rxns', 'Print IRRs', 'Print Net Rxn', 'Process Plot']
for method in method_labels:
self.method_list.insert(END, method)
species_keys = self.mech.species_dict.keys()
species_keys.sort()
self.species_objects = [self.mech.species_dict[spc] for spc in species_keys]
for spc in species_keys:
self.reactants.insert(END, spc)
self.products.insert(END, spc)
self.execute_button = Button(frame, text = "go", command = self.execute)
self.execute_button.grid(column = 6, row = 4)
class MainGui:
def __init__(self, master):
self.master = master
master.title("YAOMC")
self.file_button = Button(master,
text="Select scores",
command=self.pick_file)
self.folder_button = Button(master,
text="Select Output folder",
command=self.pick_folder)
self.gen_button = Button(master,
text="Generate",
command=lines.separate_lines)
self.exit_button = Button(master, text="Exit", command=master.quit)
self.folder_text = StringVar()
self.file_text = StringVar()
self.folder_text.set("none." if outputfolder == '' else outputfolder)
self.file_text.set("none." if inputfile == '' else inputfile)
param.outdir = "none." if outputfolder == '' else outputfolder
param.infile = "none." if inputfile == '' else inputfile
self.folder_label = Label(master, textvariable=self.folder_text)
self.file_label = Label(master, textvariable=self.file_text)
self.build_check = Checkbutton(master, text="build")
self.midi_check = Checkbutton(master, text="midi")
self.build_check.select()
self.midi_check.select()
self.file_label.grid(row=1, column=2, sticky=W)
self.folder_label.grid(row=2, column=2, sticky=W)
self.file_button.grid(row=1, column=1, sticky=W)
self.folder_button.grid(row=2, column=1, sticky=W)
self.gen_button.grid(row=3, column=1)
self.exit_button.grid(row=3, column=2)
self.build_check.grid(row=4, column=1)
self.midi_check.grid(row=4, column=2)
def pick_file(self):
param.infile = tkFileDialog.askopenfilename(
initialdir=".",
title="Select scores",
filetypes=(("png files", "*.png"), ("all files", "*.*")))
self.file_text.set(param.infile)
def pick_folder(self):
param.outdir = tkFileDialog.askdirectory(initialdir=".")
self.folder_text.set(param.outdir)
class MyFirstGUI:
def __init__(self, master):
self.master = master
master.title("Celsius <-> Farenheit")
self.var = tk.IntVar()
self.label = Label(master, anchor=CENTER, text="Temperature Conversion")
self.label.grid(columnspan=3, rowspan=2, sticky=W)
#self.labelInput = Label(master, text="Enter temperature", borderwidth=2, relief="solid")
#self.labelInput.grid(row=2, column=1)
self.textEntry = Entry(master, text="enter temperature")
self.textEntry.grid(row=2, column=1)
self.calculate_button = Button(master, text="Convert", command=self.calc)
self.calculate_button.grid(row=2, column=2)
#self.labelInput.pack(side=LEFT)
self.converstion_type = Checkbutton(master, text="Farenheit", variable=var)
self.converstion_type.grid(row=3, column=1)
#self.labelInput.pack(side=RIGHT)
self.output = Label(master, text="...")
self.output.grid(row=3, column=3)
self.outputInput = Label(master, text="Converted Temperature", borderwidth=2, relief="solid")
#self.outputInput.grid(row=1, column=2)
#self.outputInput.pack(side=RIGHT)
def calc(self):
entry = self.textEntry.get()
if(entry != "" and var.get()==False):
#convert celsius to celsius
val = 5*(int(entry)-32)/9
self.output.config(text=str(val))
elif(entry != "" and var.get()==True):
#convert celsius to farenheit
val = 9*(int(entry)/5) + 32
self.output.config(text=str(val))
def create_top_frame(self):
"""
Initialize the upper frame of the window in charge of buttons, in order:
creates a top_frame, sets a 'Search' label and binds an entry box beside
it, which calls ``refine_search`` upon a user releasing a key after pressing.
Then binds the *delete* button to ``data_from_db``
"""
logger.info('Creating top frame')
self.top_frame = Frame(self.container)
self.top_frame.pack(side=TOP, fill=X, expand=False)
label = Label(self.top_frame, text='Search ')
self.e = Entry(self.top_frame)
create_tool_tip(self.e, 'Search in Name, Attributes, Notes')
self.e.bind('<KeyRelease>', self.refine_search)
label.grid(row=0, column=0, padx=5, pady=10)
self.e.grid(row=0, column=1, padx=5, pady=10)
check_button = Checkbutton(self.top_frame,
text='Filter for this file',
variable=self.filter_file,
command=self.filter_by_current_file)
check_button.grid(row=0, column=2, padx=5, pady=10)
advanced_filter = Button(self.top_frame,
text='Advanced',
command=self.advanced_prompt)
advanced_filter.grid(row=0, column=3, padx=5, pady=10)
reset = Button(self.top_frame, text='Reset', command=self.reset)
reset.grid(row=0, column=4, padx=5, pady=10)
spacer = Label(self.top_frame, width=30)
spacer.grid(row=0, column=5)
self.top_frame.columnconfigure(5, weight=1)
delete_button = Button(self.top_frame,
text='Delete',
command=self.delete_from_db,
width=10)
delete_button.grid(row=0, column=6, padx=15)
def addFile(self,filename,ibans):
if filename != u"" and len(ibans) > 0:
Label(self.tabFiles, text=filename,
borderwidth=3).grid(row=self.row,column=0,sticky=constants.W,padx=1)
ibanList = []
for iban in ibans:
ibanList.append( iban[:8] )
combo = ttk.Combobox(self.tabFiles,values=ibanList)
combo.current(0)
if len(ibanList) == 1:
combo.configure(state=constants.DISABLED)
combo.grid(row=self.row,column=1,sticky=constants.E,padx=1)
state = IntVar()
c = Checkbutton(self.tabFiles,variable=state)
c.grid(row=self.row,column=2)
self.row += 1
ttk.Separator(self.tabFiles).grid(row=self.row, sticky=u"ew", columnspan=3 )
self.row += 1
self.guiMap.append( [ filename, ibans, combo, c, state ] )
class MethodCheckButton(Frame):
def __init__(self, master):
Frame.__init__(self, master, width = 15)
self.initComplete = False
self.getVar = IntVar()
self.postVar = IntVar()
self.getCheckButton = Checkbutton(self, \
text = "GET", width = 6, variable = self.getVar, \
command = self.__singleSelectCommandGet, onvalue = 1, offvalue = 0)
self.postCheckButton = Checkbutton(self, \
text = "POST", width = 6, variable = self.postVar, \
command = self.__singleSelectCommandPost, onvalue = 1, offvalue = 0)
self.label = Label(self, text = "Use Method:", padx = 3)
self.__boxComponents()
self.initComplete = True
def __boxComponents(self):
self.label.grid(row = 0, column = 0)
self.getCheckButton.grid(row = 0, column = 1)
self.postCheckButton.grid(row = 0, column = 2)
def __singleSelectCommandGet(self):
if self.initComplete == False:
return
self.postCheckButton.deselect()
def __singleSelectCommandPost(self):
if self.initComplete == False:
return
self.getCheckButton.deselect()
def getCurrentMethod(self):
if self.getVar.get() == 1:
return "get"
if self.postVar.get() == 1:
return "post"
return None
class MethodCheckButton(Frame):
def __init__(self, master):
Frame.__init__(self, master, width=15)
self.initComplete = False
self.getVar = IntVar()
self.postVar = IntVar()
self.getCheckButton = Checkbutton(self, \
text = "GET", width = 6, variable = self.getVar, \
command = self.__singleSelectCommandGet, onvalue = 1, offvalue = 0)
self.postCheckButton = Checkbutton(self, \
text = "POST", width = 6, variable = self.postVar, \
command = self.__singleSelectCommandPost, onvalue = 1, offvalue = 0)
self.label = Label(self, text="Use Method:", padx=3)
self.__boxComponents()
self.initComplete = True
def __boxComponents(self):
self.label.grid(row=0, column=0)
self.getCheckButton.grid(row=0, column=1)
self.postCheckButton.grid(row=0, column=2)
def __singleSelectCommandGet(self):
if self.initComplete == False:
return
self.postCheckButton.deselect()
def __singleSelectCommandPost(self):
if self.initComplete == False:
return
self.getCheckButton.deselect()
def getCurrentMethod(self):
if self.getVar.get() == 1:
return "get"
if self.postVar.get() == 1:
return "post"
return None
def redraw(self):
# Even though there are never more than three widgets per row,
# we have four columns, to allow the taskname label and the
# input widget to stretch.
self.grid_columnconfigure(2, weight=1)
row = 0
# Add a new row of widgets for each task.
for rec in sorted(self.table.query(),
key=lambda rec: rec.get('created')):
# Extract the fields we need.
completed = rec.get('completed')
taskname = rec.get('taskname')
# Create a button with an 'X' in it, to delete the task.
close_btn = Button(self,
text='X',
command=lambda rec=rec: self.delete_rec(rec))
close_btn.grid(row=row, column=0)
# Create a checkbox, to mark it completed (or not).
var = BooleanVar(self, value=completed)
completed_btn = Checkbutton(
self,
variable=var,
command=lambda rec=rec, var=var: self.toggle_rec(rec, var))
completed_btn.grid(row=row, column=1)
# Create a label showing the task name.
taskname_lbl = Label(self, text=taskname, anchor=W)
taskname_lbl.grid(row=row, column=2, columnspan=2, sticky=W)
row += 1 # Bump row index.
# Add a final row with the input and button to add new tasks.
self.input = Entry(self)
self.input.bind('<Return>', self.add_rec)
self.input.grid(row=row, column=0, columnspan=3, sticky=W + E)
add_btn = Button(self, text='Add Task', command=self.add_rec)
add_btn.grid(row=row, column=3)
# Add save button. (Auto-save is left as an exercise.)
save_btn = Button(self, text='Save local snapshot', command=self.save)
save_btn.grid(row=row + 1, column=0, columnspan=3, sticky=W)
def policy(self):
policyheader = headersmall(self.frame, text="Policies:")
cei = Checkbutton(self.frame, text="Expected Improvement", variable=self.params["policies"][0], bg=Styles.colours["grey"])
cpi = Checkbutton(self.frame, text="Probability Improvement", variable=self.params["policies"][1], bg=Styles.colours["grey"])
cucb = Checkbutton(self.frame, text="Upper Confidence Bound", variable=self.params["policies"][2], bg=Styles.colours["grey"])
ctho = Checkbutton(self.frame, text="Thompson", variable=self.params["policies"][3], bg=Styles.colours["grey"])
self.isreadyR(cei)
self.isreadyR(cpi)
self.isreadyR(cucb)
self.isreadyR(ctho)
policyheader.grid(row=1, column=0, sticky=W, columnspan=1)
cei.grid(row=2, column=0, pady=0, sticky=W, padx=10, columnspan=1)
cpi.grid(row=3, column=0, pady=0, sticky=W, padx=10, columnspan=1)
cucb.grid(row=4, column=0, pady=0, sticky=W, padx=10, columnspan=1)
ctho.grid(row=5, column=0, pady=0, sticky=W, padx=10, columnspan=1)
def __init__(self, master):
column0_padx = 24
row_pady = 36
#Label 1
lbl_testcase_exec = Label(master, text="Test case execution",
wraplength=100, anchor='w', justify='left')
lbl_results_cmp = Label(master, text="Results comparison",
wraplength=100, justify='left')
lbl_tolerance = Label(master, text="Tolerance (5%)", wraplength=100)
testcase_exec = Checkbutton(master)
results_cmp = Checkbutton(master)
tolerance = Entry(master, width=4)
lbl_analysis = Label(master, text="Analysis Library")
analysis_lib = Entry(master, width=30)
lbl_testcase_exec.grid(row=0, column=2, padx=20, pady=12, sticky='w')
lbl_results_cmp.grid(row=0, column=3, pady=12, sticky='w')
lbl_tolerance.grid(row=0, column=4, padx=20, pady=12, sticky='wn')
lbl_analysis.grid(row=1, column=0, sticky='w', padx=column0_padx)
analysis_lib.grid(row=1, column=1, sticky='w')
testcase_exec.grid(row=1, column=2, padx=20, sticky='w')
results_cmp.grid(row=1, column=3, sticky='w')
tolerance.grid(row=1, column=4, padx=20, sticky='w')
#Label 2
lbl_ref_analysis = Label(
master, text="Reference Analysis Libary Version",
wraplength=150, justify='left', pady=row_pady)
ref_analysis_lib = Entry(master, width=30)
lbl_ref_analysis.grid(row=2, column=0, sticky='w', padx=column0_padx)
ref_analysis_lib.grid(row=2, column=1, sticky='w')
# version
lbl_version = Label(master, text="Version under Test")
version = Label(master, text="vA.B.C.D")
lbl_version.grid(row=3, column=0, sticky='w', padx=column0_padx)
version.grid(row=3, column=1, sticky='w')
# test all
lbl_testall = Label(master, text="Test All")
testall = Checkbutton(master)
lbl_testall.grid(row=4, column=0, pady=row_pady, padx=column0_padx,
sticky='w')
testall.grid(row=4, column=1, sticky='w')
# buttons
bottom_frame = Frame(master)
bottom_frame.grid(row=5, column=1, columnspan=3, sticky='w')
btn_start = Button(bottom_frame, text = "Go", width=7)
btn_start.pack(side='left')
btn_commit = Button(bottom_frame, text="Commit", width=7)
btn_commit.pack(side='left', padx=80)
btn_exit = Button(bottom_frame, text="Exit", width=7)
btn_exit.pack(side='left')
def solver(self):
solverheader = headersmall(self.frame, text="Solvers:")
direct = Radiobutton(self.frame, text="Direct", variable=self.params["solver"], value="direct",
bg=Styles.colours["grey"])
lbfgs = Radiobutton(self.frame, text="LBFGS", variable=self.params["solver"], value="lbfgs",
bg=Styles.colours["grey"])
message = Message(self.frame, text="Enable normalization if you use lbfgs", width=200)
try:
import nlopt
except:
self.params["solver"].set("lbfgs")
self.params["normalize"].set(1)
direct.config(state=DISABLED)
message.config(text="You do not have nlopt library installed to use the Direct Solver",
bg=Styles.colours["lightRed"])
normalize = Checkbutton(self.frame, text="Normalize Input", variable=self.params["normalize"],
bg=Styles.colours["grey"])
solverheader.grid(row=1, column=0, sticky=W, columnspan=2)
direct.grid(row=2, column=0, pady=0, sticky=W, padx=10)
lbfgs.grid(row=3, column=0, pady=0, sticky=W, padx=10)
message.grid(row=2, column=1, rowspan=1)
normalize.grid(row=3, column=1)
def kernels(self):
kernelsheader = headersmall(self.frame, text="Kernels:")
cse = Checkbutton(self.frame, text="Squared Exponential", variable=self.params["kernels"][0], bg=Styles.colours["grey"])
cm5 = Checkbutton(self.frame, text="Matern 5", variable=self.params["kernels"][1], bg=Styles.colours["grey"])
cm3 = Checkbutton(self.frame, text="Matern 3", variable=self.params["kernels"][2], bg=Styles.colours["grey"])
cm1 = Checkbutton(self.frame, text="Matern 1", variable=self.params["kernels"][3], bg=Styles.colours["grey"])
self.isreadyR(cse)
self.isreadyR(cm5)
self.isreadyR(cm3)
self.isreadyR(cm1)
kernelsheader.grid(row=1, column=1, sticky=W, columnspan=2)
cse.grid(row=2, column=1, pady=0, sticky=W, padx=10, columnspan=1)
cm5.grid(row=3, column=1, pady=0, sticky=W, padx=10, columnspan=1)
cm3.grid(row=4, column=1, pady=0, sticky=W, padx=10, columnspan=1)
cm1.grid(row=5, column=1, pady=0, sticky=W, padx=10, columnspan=1)
Label(self.frame, text="", font=("Arial", 6)).grid(row=6, column=0, sticky=W, columnspan=2)
def __init__(self, title, txt, dicoprofils):
LabelFrame.__init__(self, text=title)
self.listing_profils(dicoprofils)
# Dropdowm list of available profiles
self.ddprofils = Combobox(self,
values = dicoprofils.keys(),
width = 35,
height = len(dicoprofils.keys())*20)
self.ddprofils.current(1) # set the dropdown list to first element
# export options
caz_doc = Checkbutton(self, text = u'HTML / Word (.doc/.docx)',
variable = self.master.opt_doc)
caz_xls = Checkbutton(self, text = u'Excel 2003 (.xls)',
variable = self.master.opt_xls)
caz_xml = Checkbutton(self, text = u'XML (ISO 19139)',
variable = self.master.opt_xml)
# Basic buttons
self.action = StringVar()
self.action.set(txt.get('gui_choprofil'))
self.val = Button(self, textvariable = self.action,
relief= 'raised',
command = self.bell)
can = Button(self, text = 'Cancel (quit)',
relief= 'groove',
command = self.master.destroy)
# Widgets placement
self.ddprofils.bind('<<ComboboxSelected>>', self.alter_val)
self.ddprofils.grid(row = 1, column = 0, columnspan = 3, sticky = N+S+W+E, padx = 2, pady = 5)
caz_doc.grid(row = 2, column = 0, sticky = N+S+W, padx = 2, pady = 1)
caz_xls.grid(row = 3, column = 0, sticky = N+S+W, padx = 2, pady = 1)
caz_xml.grid(row = 4, column = 0, sticky = N+S+W, padx = 2, pady = 1)
self.val.grid(row = 5, column = 0, columnspan = 2,
sticky = N+S+W+E, padx = 2, pady = 5)
can.grid(row = 5, column = 2, sticky = N+S+W+E, padx = 2, pady = 5)
scrollx = Scrollbar(root, orient="horizontal", command=scrollframe.xview)
scrollx.grid(row=1, column=0, sticky="nwse")
scrolly = Scrollbar(root, orient="vertical", command=scrollframe.yview)
scrolly.grid(row=0, column=1, sticky="nwse")
scrollframe["xscrollcommand"] = scrollx.set
scrollframe["yscrollcommand"] = scrolly.set
scrollframe.grid(row=0, column=0, sticky="nwse")
checkvar = BooleanVar(root, value=scrollframe["stretch"])
def set_stretch():
scrollframe["stretch"] = True if checkvar.get() else False
scrollframe.update_scrollregion()
stretch = Checkbutton(root,
anchor="w",
onvalue=True,
offvalue=False,
variable=checkvar,
text="Stick contained frame to container",
command=set_stretch)
stretch.grid(sticky="nwse", padx=2, pady=2)
root.title("Scrolled Frame")
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)
root.mainloop()
check_binchoice() # -- layout the widgets -- head_label.grid(row=0,column=0, padx=5,pady=5, columnspan=2) filename_button.grid(row=1,column=0, padx=5,pady=5, sticky='nsew') filename_entry.grid(row=1, column=1, padx=5,pady=5) nA_label.grid(row=2,column=0, padx=5,pady=5) nA_entry.grid(row=2, column=1, padx=5,pady=5) nB_label.grid(row=3,column=0, padx=5,pady=5) nB_entry.grid(row=3, column=1, padx=5,pady=5) fitType_label.grid(row=4,column=0, padx=5,pady=5) fitType_frame.grid(row=4,column=1, padx=5,pady=5) niter_label.grid(row=5,column=0, padx=5,pady=5) niter_entry.grid(row=5,column=1, padx=5,pady=5) nobinning_label.grid(row=6,column=0) nobinning_check.grid(row=6,column=1) p_label.grid(row=7,column=0, padx=5,pady=5) p_entry.grid(row=7,column=1, padx=5,pady=5) fbL_label.grid(row=8,column=0, padx=5,pady=5) fbL_entry.grid(row=8,column=1, padx=5,pady=5) fbH_label.grid(row=9,column=0, padx=5,pady=5) fbH_entry.grid(row=9,column=1, padx=5,pady=5) binchoice_label.grid(row=10,column=0, padx=5,pady=5) binchoice_frame.grid(row=10,column=1, padx=5,pady=5) fQ_label.grid(row=11,column=0, padx=5,pady=5) fQ_entry.grid(row=11,column=1, padx=5,pady=5) outID_label.grid(row=12,column=0, padx=5,pady=5) outID_entry.grid(row=12,column=1, padx=5,pady=5) submit_button.grid(row=14,column=0, padx=5,pady=5, columnspan=2, sticky='nsew') progress_label.grid(row=15,column=0, padx=5,pady=5, columnspan=2) reset_button.grid(row=17,column=0, padx=5,pady=5, sticky='nsew')
def __init__(self, ncffile, options):
try:
from Tkinter import Checkbutton, Frame, Label, Scrollbar
from Tkinter import Listbox, Button, IntVar, Tk, VERTICAL
from Tkinter import EXTENDED, END, N, S, SINGLE, Entry
from Tkinter import StringVar, Text, DISABLED, LEFT
except Exception:
try:
from tkinter import Checkbutton, Frame, Label, Scrollbar
from tkinter import Listbox, Button, IntVar, Tk, VERTICAL
from tkinter import EXTENDED, END, N, S, SINGLE, Entry
from tkinter import StringVar, Text, DISABLED, LEFT
except Exception:
warn('tkinter unavailable')
master = self.root = Tk()
self.ncffile = ncffile
self.options = options
self.plotted_variables = set()
frame = Frame(master)
frame.grid(row=0)
codeframe = Frame(master)
codeframe.grid(row=1)
metaframe = Frame(master)
metaframe.grid(row=2)
goframe = Frame(frame)
goframe.grid(column=3, row=1)
var_label = Label(frame, text='Select Variable')
var_label.grid(column=0, row=0)
var_scrollbar = Scrollbar(frame, orient=VERTICAL)
var_scrollbar.grid(column=1, row=1, sticky=N + S)
self.var = Listbox(frame, selectmode=EXTENDED,
exportselection=0,
yscrollcommand=var_scrollbar.set)
self.var.grid(column=0, row=1)
var_scrollbar.config(command=self.var.yview)
what_to_do = Label(frame, text='Execute')
what_to_do.grid(column=2, row=0)
self.method_list = Listbox(frame, selectmode=SINGLE, exportselection=0)
self.method_list.grid(column=2, row=1)
self.pre_txt = StringVar()
pre_label = Label(codeframe, text='Before any figures, execute code')
self.pre_txt.set(_pre_code)
pre_label.grid(row=2, sticky='W')
self.pre = Entry(codeframe, width=120, textvariable=self.pre_txt)
self.pre.grid(row=3, sticky='E')
self.before_txt = StringVar()
self.before_txt.set(_before_code)
before_label = Label(
codeframe, text='Before each figure, execute code')
before_label.grid(row=4, sticky='W')
self.before = Entry(codeframe, width=120, textvariable=self.before_txt)
self.before.grid(row=5, sticky='E')
self.after_txt = StringVar()
self.after_txt.set(_after_code)
after_label = Label(codeframe, text='After each figure, execute code')
after_label.grid(row=6, sticky='W')
self.after = Entry(codeframe, width=120, textvariable=self.after_txt)
self.after.grid(row=7, sticky='E')
self.post_txt = StringVar()
self.post_txt.set(_post_code)
post_label = Label(codeframe, text='After all figures, execute code')
post_label.grid(row=8, sticky='W')
self.post = Entry(codeframe, width=120, textvariable=self.post_txt)
self.post.grid(row=9, sticky='E')
options_label = Label(goframe, text='Options:')
options_label.grid(column=0, row=1, sticky='W')
self.logscale = IntVar()
self.logscale.set(0)
c = Checkbutton(goframe, text="log-scale?", variable=self.logscale)
c.grid(column=0, row=2, sticky='W')
self.coastlines = IntVar()
self.coastlines.set(_coastlines_opt)
coastlines = Checkbutton(
goframe, text="coastlines?", variable=self.coastlines,
justify=LEFT)
coastlines.grid(column=0, row=3, sticky='W')
self.countries = IntVar()
self.countries.set(_countries_opt)
countries = Checkbutton(
goframe, text="countries?", variable=self.countries, justify=LEFT)
countries.grid(column=0, row=4, sticky='W')
self.states = IntVar()
self.states.set(_states_opt)
states = Checkbutton(goframe, text="states?",
variable=self.states, justify=LEFT)
states.grid(column=0, row=5, sticky='W')
self.counties = IntVar()
self.counties.set(_counties_opt)
counties = Checkbutton(goframe, text="counties?",
variable=self.counties, justify=LEFT)
counties.grid(column=0, row=6, sticky='W')
self.execute_button = Button(
goframe, text="Make Figure", command=self.execute)
self.execute_button.grid(row=0, column=0, sticky='W')
self.methods = ['mapplot', 'presslat', 'presslon', 'time-lat',
'profile', 'timeseries', 'pressx', 'tileplot', 'plot']
method_labels = ['lat-lon', 'press-lat', 'press-lon', 'time-lat',
'Vertical Profile', 'Time Series', 'press-? (2-D)',
'Tile Plot (2-D)', 'Plot (1-D)']
for method in method_labels:
self.method_list.insert(END, method)
var_keys = [k for k, v in self.ncffile.variables.items()
if k not in _coordkeys]
var_keys.sort()
self.vars = []
for spc in var_keys:
self.var.insert(END, spc)
self.vars.append(spc)
meta_label = Label(metaframe, text='Common Data Language Header:')
meta_label.grid(column=0, row=0, sticky='W')
meta_scrollbar = Scrollbar(metaframe, orient=VERTICAL)
meta_scrollbar.grid(column=1, row=1, sticky=N + S)
self.meta = Text(metaframe, height=10, width=118, bg='white',
relief='flat', yscrollcommand=meta_scrollbar.set)
self.meta.grid(column=0, row=1, sticky='W')
from PseudoNetCDF.pncdump import pncdump
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
pdump = StringIO("")
pncdump(self.ncffile, header=True, outfile=pdump, )
pdump.seek(0, 0)
self.meta.insert(END, pdump.read())
self.meta.config(state=DISABLED)
help = Button(goframe, text='Help', command=self.help)
help.grid(column=0, row=7)
quit = Button(goframe, text='Quit', command=self.quit)
quit.grid(column=0, row=8)
master.mainloop()
def init_gui(self):
'''
Initialize a simple gui.
'''
top = Frame(self.master)
top.grid(**self.paddingArgs)
frame = Frame(top)
frame.grid(column = 0, row = 0, columnspan = 2)
text = Label(frame, text = 'OCCI service URL:')
text.grid(column = 0, row = 0, **self.paddingArgs)
self.url.set('http://localhost:8888')
entry = Entry(frame, width = 25, textvariable = self.url)
entry.grid(column = 1, row = 0, **self.paddingArgs)
go = Button(frame, text = 'Go', command = self.run_tests)
go.grid(column = 2, row = 0, **self.paddingArgs)
reset = Button(frame, text = 'Reset', command = self.reset)
reset.grid(column = 3, row = 0, **self.paddingArgs)
login_frame = LabelFrame(top, borderwidth = 2, relief = 'groove', text = 'Session information')
login_frame.grid(column = 0, row = 1, sticky = W + E + N + S,
padx = 2, pady = 2)
self.login.set(1)
login_switch = Checkbutton(login_frame, text = 'Login required?',
variable = self.login)
login_switch.grid(column = 0, row = 0, columnspan = 2, **self.paddingArgs)
self.user.set('foo')
self.password.set('bar')
user_text = Label(login_frame, text = 'Username:'******'Password:'******'groove', text = 'Service information')
info_frame.grid(column = 1, row = 1, sticky = W + E + N + S, **self.paddingArgs)
self.info_text = Label(info_frame, text = 'Please press "GO"')
self.info_text.pack(side = 'top')
test_frame = LabelFrame(top, borderwidth = 2, relief = 'groove', text = 'Tests')
test_frame.grid(column = 0, row = 2, columnspan = 2, **self.paddingArgs)
label = Label(test_frame, text = 'Checking for correct version information:')
label.grid(column = 0, row = 0, sticky = W, **self.paddingArgs)
self.version_test_label = Label(test_frame, text = '...')
self.version_test_label.grid(column = 1, row = 0, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Checking completeness of infrastructure model:')
label.grid(column = 0, row = 1, sticky = W, **self.paddingArgs)
self.infra_model_test_label = Label(test_frame, text = '...')
self.infra_model_test_label.grid(column = 1, row = 1, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Checking correct handling of Content-type/Accept headers:')
label.grid(column = 0, row = 2, sticky = W, **self.paddingArgs)
self.accept_header_test_label = Label(test_frame, text = '...')
self.accept_header_test_label.grid(column = 1, row = 2, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Testing instantiation of compute/storage/network kinds:')
label.grid(column = 0, row = 3, sticky = W, **self.paddingArgs)
self.creational_test_label = Label(test_frame, text = '...')
self.creational_test_label.grid(column = 1, row = 3, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Testing correct handling of user-defined mixins (tagging/grouping):')
label.grid(column = 0, row = 4, sticky = W, **self.paddingArgs)
self.mixin_test_label = Label(test_frame, text = '...')
self.mixin_test_label.grid(column = 1, row = 4, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Testing links between compute/storage compute/network:')
label.grid(column = 0, row = 5, sticky = W, **self.paddingArgs)
self.link_test_label = Label(test_frame, text = '...')
self.link_test_label.grid(column = 1, row = 5, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Triggering actions on compute/network/storage kinds:')
label.grid(column = 0, row = 6, sticky = W, **self.paddingArgs)
self.action_test_label = Label(test_frame, text = '...')
self.action_test_label.grid(column = 1, row = 6, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Testing filter mechanisms using Categories:')
label.grid(column = 0, row = 7, sticky = W, **self.paddingArgs)
self.filter_test_label = Label(test_frame, text = '...')
self.filter_test_label.grid(column = 1, row = 7, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Testing correct behaviour on location and "normal" paths:')
label.grid(column = 0, row = 8, sticky = W, **self.paddingArgs)
self.location_path_label = Label(test_frame, text = '...')
self.location_path_label.grid(column = 1, row = 8, sticky = W, **self.paddingArgs)
label = Label(test_frame, text = 'Simple syntax checks:')
label.grid(column = 0, row = 9, sticky = W, **self.paddingArgs)
self.syntax_test_label = Label(test_frame, text = '...')
self.syntax_test_label.grid(column = 1, row = 9, sticky = W, **self.paddingArgs)
label = Label(top, text = 'NOTE: Passing all tests only indicates that the service\nyou are testing is OCCI compliant - IT DOES NOT GUARANTE IT!')
label.grid(column = 0, row = 4, columnspan = 2, **self.paddingArgs)
quit_button = Button(top, text = 'Quit', command = self.quit)
quit_button.grid(column = 1, row = 5, sticky = E, **self.paddingArgs)
class ToolBar(Frame):
def __init__(self, root, printer, settings, logger, *arg):
self.app = root
self.printer = printer
self.settings = settings
self.logger = logger
self.app.printing = False
self.app.connected = False
self.app.paused = False
Frame.__init__(self, root, *arg)
topBar = Frame(self)
topBar.grid(row=1, column=1, columnspan=3, sticky=W)
speedBar = Frame(self)
speedBar.grid(row=1, column=5, sticky=E)
bottomBar = Frame(self)
bottomBar.grid(row=2, column=1, columnspan=6, sticky=W+E)
self.bPort = Button(topBar, text="Port", width=BWIDTH, command=self.doPort)
self.bPort.pack(side=LEFT, padx=2, pady=2)
ports = self.scanSerial()
self.spPort = Spinbox(topBar, values=ports, state="readonly")
self.spPort.pack(side=LEFT, padx=2, pady=2)
l = Label(topBar, text=" @ ")
l.pack(side=LEFT, padx=2, pady=2)
self.spBaud = Spinbox(topBar, values=baudChoices)
self.spBaud.pack(side=LEFT, padx=2, pady=2)
self.spBaud.delete(0, END)
self.spBaud.insert(0, 115200)
self.spBaud.config(state="readonly")
self.bConnectMode = CM_CONNECT
self.bConnect = Button(topBar, text=connectText[CM_CONNECT], width=BWIDTH, command=self.doConnect)
self.bConnect.pack(side=LEFT, padx=2, pady=2)
if len(ports) == 0:
self.bConnect.config(state=DISABLED)
else:
self.bConnect.config(state=NORMAL)
self.bReset = Button(topBar, text="Reset", width=BWIDTH, command=self.doReset, state=DISABLED)
self.bReset.pack(side=LEFT, padx=2, pady=2)
l = Label(speedBar, text="Speed:", justify=RIGHT)
l.grid(row=1, column=1, sticky=E)
self._speedJob = None
self.currentSpeed = self.app.FeedMultiply
self.scSpeed = Scale(speedBar, from_=MINSPEED, to=MAXSPEED, orient=HORIZONTAL, command=self.updateSpeedCommand)
self.scSpeed.grid(row=1, column=2)
self.scSpeed.set(self.currentSpeed);
l = Label(speedBar, text="Fan:", width=10, anchor=E, justify=RIGHT)
l.grid(row=1, column=3, sticky=E)
self._fanJob = None
self.currentFanSpeed = self.app.FanSpeed
self.scFan = Scale(speedBar, from_=0, to=255, orient=HORIZONTAL, command=self.updateFanSpeedCommand)
self.scFan.grid(row=1, column=4)
self.scFan.set(self.currentFanSpeed);
if self.settings.speedcommand is not None:
self.cbvAssertFan = IntVar()
if self.settings.forcefanspeed:
self.cbvAssertFan.set(1)
else:
self.cbvAssertFan.set(0)
self.cbAssertFan = Checkbutton(speedBar, text="Force", variable=self.cbvAssertFan,
command=self.clickAssertFan)
self.cbAssertFan.grid(row=1, column=5)
self.bSliceMode = SM_SLICE
self.bSlice = Button(bottomBar, text=sliceText[SM_SLICE], width=BWIDTH*2, command=self.doSlice)
self.bSlice.pack(side=LEFT, padx=2, pady=2)
self.bLoad = Button(bottomBar, text="Load GCode", width=BWIDTH, command=self.doLoad)
self.bLoad.pack(side=LEFT, padx=2, pady=2)
self.setSliceText()
self.bSD = Button(bottomBar, text="SD", width=BWIDTH, command=self.doSD, state=DISABLED)
self.bSD.pack(side=LEFT, padx=2, pady=2)
self.bPrintMode = PR_PRINT
self.bPrint = Button(bottomBar, text=printText[PR_PRINT], width=BWIDTH, command=self.doPrint, state=DISABLED)
self.bPrint.pack(side=LEFT, padx=2, pady=2)
self.bPauseMode = PM_PAUSE
self.bPause = Button(bottomBar, text=pauseText[PM_PAUSE], width=BWIDTH, command=self.doPause, state=DISABLED)
self.bPause.pack(side=LEFT, padx=2, pady=2)
self.bAbandon = Button(bottomBar, text="Abandon SD Print", width=BWIDTH+8, command=self.doAbandon, state=DISABLED)
self.bAbandon.pack(side=LEFT, padx=2, pady=2)
self.cbvLiftOnPause = IntVar()
if self.settings.liftonpause:
self.cbvLiftOnPause.set(1)
else:
self.cbvLiftOnPause.set(0)
self.cbLiftOnPause = Checkbutton(bottomBar, text="Lift Head/Retract on Pause", variable=self.cbvLiftOnPause,
command=self.clickLiftOnPause)
self.cbLiftOnPause.pack(side=LEFT, padx=2)
self.cbvResumeAtPause = IntVar()
if self.settings.resumeatpausepoint:
self.cbvResumeAtPause.set(1)
else:
self.cbvResumeAtPause.set(0)
self.cbResumeAtPause = Checkbutton(bottomBar, text="Resume print at pause point", variable=self.cbvResumeAtPause,
command=self.clickResumeAtPause)
self.cbResumeAtPause.pack(side=LEFT, padx=2)
def clickAssertFan(self):
if self.cbvAssertFan.get() == 1:
self.settings.forcefanspeed = True
self.settings.setModified()
else:
self.settings.forcefanspeed = False
self.settings.setModified()
def clickLiftOnPause(self):
if self.cbvLiftOnPause.get() == 1:
self.settings.liftonpause = True
self.settings.setModified()
else:
self.settings.liftonpause = False
self.settings.setModified()
def clickResumeAtPause(self):
if self.cbvResumeAtPause.get() == 1:
self.settings.resumeatpausepoint = True
self.settings.setModified()
else:
self.settings.resumeatpausepoint = False
self.settings.setModified()
def setSliceText(self):
if self.settings.slicer == SLIC3R:
sl = "slic3r:%s" % self.app.slic3r.getProfile()
else:
sl = "skeinforge:%s" % self.app.skeinforge.getProfile()
sliceText[SM_SLICE] = "Slice (%s)" % sl
if self.bSliceMode == SM_SLICE:
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
lt = len(sliceText[SM_SLICE])+2
if lt < BWIDTH:
lt = BWIDTH
self.bSlice.config(text=sliceText[SM_SLICE], width=lt)
def updateSpeedCommand(self, *arg):
if self._speedJob:
self.app.master.after_cancel(self._speedJob)
self._speedJob = self.app.master.after(500, self.updateSpeed)
def updateSpeed(self, *arg):
v = self.scSpeed.get()
self.setSpeed(v)
def setSpeed(self, v):
if v < MINSPEED or v > MAXSPEED:
self.logger.logMsg("Attempt to change speed outside of allowable range (%d-%d)" % (MINSPEED, MAXSPEED))
elif int(v) != self.currentSpeed:
if self.app.connected:
self.currentSpeed = int(v)
self.logger.logMsg("changing speed percentage to %d%%" % self.currentSpeed)
cmd = "M220 S%d" % self.currentSpeed
self.printer.send_now(cmd)
else:
self.logger.logMsg("Printer is off-line")
self.scSpeed.set(self.currentSpeed)
def updateFanSpeedCommand(self, *arg):
if self._fanJob:
self.app.master.after_cancel(self._fanJob)
self._fanJob = self.app.master.after(500, self.updateFanSpeed)
def updateFanSpeed(self, *arg):
v = self.scFan.get()
self.setFanSpeed(v)
self.app.FanSpeed = v
def forceFanSpeed(self, v):
self.currentFanSpeed = -1
self.setFanSpeed(v)
def setFanSpeed(self, v):
if int(v) != self.currentFanSpeed:
if self.app.connected:
self.currentFanSpeed = int(v)
cmd = "M106 S%d" % self.currentFanSpeed
self.printer.send_now(cmd)
else:
self.logger.logMsg("Printer is off-line")
self.scFan.set(self.currentFanSpeed)
def syncSpeeds(self):
self.currentSpeed = self.app.FeedMultiply
self.scSpeed.set(self.currentSpeed)
self.currentFanSpeed = self.app.FanSpeed
self.scFan.set(self.currentFanSpeed)
def initializeToolbar(self):
self.bReset.config(state=DISABLED)
self.bSliceMode = SM_SLICE
self.bSlice.config(text=sliceText[SM_SLICE])
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
if not self.app.sdprinting and not self.app.sdpaused:
self.bPrintMode = PR_PRINT
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPauseMode = PM_PAUSE
self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED)
def setSDPrint(self):
self.bPause.config(text=pauseText[PM_PAUSE], state=NORMAL)
self.bPauseMode = PM_PAUSE
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPrintMode = PR_PRINT
self.bAbandon.config(state=NORMAL)
def clearSDPrint(self):
self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED)
self.bPauseMode = PM_PAUSE
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPrintMode = PR_PRINT
self.bAbandon.config(state=DISABLED)
self.checkAllowPrint()
def setCancelMode(self):
self.bSliceMode = SM_CANCEL
self.bSlice.config(text=sliceText[SM_CANCEL], width=BWIDTH)
self.bLoad.config(state=DISABLED)
self.app.allowLoadGCodeMenu(False)
self.app.allowSliceMenu(False)
def setLoading(self, flag):
if flag:
self.bLoad.config(state=DISABLED)
self.bSlice.config(state=DISABLED)
self.app.allowLoadGCodeMenu(False)
self.app.allowSliceMenu(False)
else:
self.bLoad.config(state=NORMAL)
self.bSlice.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
self.app.allowSliceMenu(True)
def clearCancelMode(self):
self.bSliceMode = SM_SLICE
lt = len(sliceText[SM_SLICE])+2
if lt < BWIDTH:
lt = BWIDTH
self.bSlice.config(text=sliceText[SM_SLICE], width=lt)
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
self.app.allowSliceMenu(True)
def doConnect(self):
if self.bConnectMode == CM_CONNECT:
port = self.spPort.get()
baud = int(self.spBaud.get())
self.printer.onlinecb = self.onlinecb
try:
self.printer.connect(port, baud)
except SerialException:
self.logger.logMsg("Unable to open printer port %s" % port)
else:
if self.app.printing:
self.logger.logMsg("Please wait until printing has finished or is paused")
else:
self.printer.disconnect()
self.printer.onlinecb = None
self.app.printerConnected(False)
# self.app.connected = False
self.bConnectMode = CM_CONNECT
self.bConnect.config(text=connectText[CM_CONNECT])
self.bReset.config(state=DISABLED)
self.bSD.config(state=DISABLED)
if self.app.paused:
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPrintMode = PR_PRINT
self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED)
self.bPauseMode = PM_PAUSE
self.app.printing = False
self.app.paused = False
def doReset(self):
if tkMessageBox.askyesno("Reset?", "Are you sure you want to reset the printer?", parent=self.app):
self.printer.reset()
self.printer.printing = 0
self.app.printing = False
self.bSlice.config(state=NORMAL)
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
self.app.allowSliceMenu(True)
self.bPrintMode = PR_PRINT
self.bPrint.config(text=printText[PR_PRINT], state=NORMAL)
if self.app.paused:
self.printer.paused = 0
self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED)
self.bPauseMode = PM_PAUSE
self.app.paused = False
def onlinecb(self):
self.logger.logMsg("Printer is on-line")
self.app.printerConnected(True)
# self.app.connected = True
self.bConnectMode = CM_DISCONNECT
self.bConnect.config(text=connectText[CM_DISCONNECT])
self.bReset.config(state=NORMAL)
self.bSD.config(state=NORMAL)
self.checkAllowPrint()
def checkAllowPrint(self):
if self.app.connected and len(self.app.gcode) != 0 and not self.app.printing and not self.app.sdprinting:
self.bPrint.config(text=printText[PR_PRINT], state=NORMAL)
self.bPrintMode = PR_PRINT
def printComplete(self):
self.app.endTime = time.time()
self.app.elapsedTime = self.app.endTime - self.app.startTime
self.logger.logMsg("Printing completed at %s" % time.strftime('%H:%M:%S', time.localtime()))
self.logger.logMsg("Total elapsed time: %s" % formatElapsed(self.app.elapsedTime))
self.bPrintMode = PR_PRINT
self.bPrint.config(text=printText[PR_PRINT], state=NORMAL)
self.bPauseMode = PM_PAUSE
self.bPause.config(text=pauseText[PM_PAUSE], state=DISABLED)
self.app.printing = False
self.bSlice.config(state=NORMAL)
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
self.app.allowSliceMenu(True)
self.app.paused = False
self.app.gc.updatePrintProgress(0)
self.app.closeAllReports()
if self.settings.endprintmacro is not None:
self.app.doMacro(name=self.settings.endprintmacro, silent=True)
def doPause(self):
if self.bPauseMode == PM_PAUSE:
if self.app.printing:
self.app.paused = True
self.printer.pause()
elif self.app.sdprinting:
self.app.sdpaused = True
self.printer.send_now("M25")
self.app.sdprinting = False
self.bPause.config(text=pauseText[PM_RESUME])
self.bPauseMode = PM_RESUME
self.bPrint.config(text=printText[PR_RESTART], state=NORMAL)
self.bPrintMode = PR_RESTART
else:
if self.app.sdpaused:
self.printer.send_now("M24")
self.app.sdpaused = False
self.app.sdprinting = True
self.bPause.config(text=pauseText[PM_PAUSE])
self.bPauseMode = PM_PAUSE
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPrintMode = PR_PRINT
else:
self.hitPrint = False
if self.settings.resumeatpausepoint:
self.printer.send_now("G1 X%s Y%s F%s" % (self.app.pausePoint[XAxis], self.app.pausePoint[YAxis], self.settings.xyfeed))
self.printer.send_now("G1 Z%s F%s" % (self.app.pausePoint[ZAxis], self.settings.zfeed))
self.printer.send_now("G92 E%s" % self.app.pausePoint[EAxis])
self.printer.send_now("G1 F%s" % self.settings.xyfeed)
self.printer.startcb = self.startcb
self.printer.resume()
def doAbandon(self):
self.printer.send_now("M25")
self.app.sdpaused = False
self.app.sdprinting = False
self.clearSDPrint()
def doSlice(self):
if self.bSliceMode == SM_SLICE:
self.bLoad.config(state=DISABLED)
self.app.allowLoadGCodeMenu(False)
self.app.openSTLFile()
else:
self.app.slicerCancel = True
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
def doLoad(self):
self.app.openGCodeFile()
def doPrint(self):
if self.app.sdpaused:
self.printer.send_now("M26 S0")
self.printer.send_now("M24")
self.app.sdpaused = False
self.app.sdprinting = True
self.bPause.config(text=pauseText[PM_PAUSE])
self.bPauseMode = PM_PAUSE
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPrintMode = PR_PRINT
else:
if len(self.app.gcode) == 0:
self.logger.logMsg("Nothing to print")
else:
#if not self.app.paused:
self.app.gc.updatePrintProgress(0, restart=True)
self.bPauseMode = PM_PAUSE
self.bPause.config(text=pauseText[PM_PAUSE], state=NORMAL)
self.hitPrint = True
self.printer.startcb = self.startcb
self.printer.startprint(self.app.gcode)
def startcb(self):
self.printer.startcb = None
if not self.app.paused:
self.app.startTime = time.time()
self.logger.logMsg("Printing Started at %s" % time.strftime('%H:%M:%S', time.localtime(self.app.startTime)))
self.app.printing = True
self.bSlice.config(state=DISABLED)
self.bLoad.config(state=DISABLED)
self.app.allowLoadGCodeMenu(False)
self.app.allowSliceMenu(False)
self.bPrint.config(text=printText[PR_RESTART], state=DISABLED)
self.bPrintMode = PR_RESTART
self.printer.endcb = self.endcb
else:
if self.hitPrint:
self.app.startTime = time.time()
self.logger.logMsg("Printing restarted at %s" % time.strftime('%H:%M:%S', time.localtime()))
else:
self.logger.logMsg("Printing resumed at %s" % time.strftime('%H:%M:%S', time.localtime()))
self.bPause.config(text=pauseText[PM_PAUSE])
self.bPauseMode = PM_PAUSE
self.app.printing = True
self.bSlice.config(state=DISABLED)
self.bLoad.config(state=DISABLED)
self.app.allowLoadGCodeMenu(False)
self.app.allowSliceMenu(False)
self.app.paused = False
self.bPrint.config(state=DISABLED)
self.printer.endcb = self.endcb
def endcb(self):
self.printer.endcb = None
if not self.app.paused:
self.printComplete()
if self.app.sduploading:
self.app.sduploading = False
self.printer.send_now("M29")
else:
self.app.event_generate(MWM_REQUESTPOSITIONREPORT)
# record the current printer position and how many intervals were willing to wait fo the response
self.maxWait114 = MAXWAIT114;
self.waitPos = self.printer.queueindex
self.check114Response()
def check114Response(self) :
# tick off 1 interval, and make sure we haven't either received the report or we've waited max intervals
self.maxWait114 -= 1
if self.app.m114count == 0 or self.maxWait114 <= 0:
# one way or the other we're done waiting here
if self.maxWait114 <= 0:
self.app.m114count = 0
self.logger.logMsg("Location report not received - proceeding")
self.app.pausePoint[XAxis] = self.app.location[XAxis]
self.app.pausePoint[YAxis] = self.app.location[YAxis]
self.app.pausePoint[ZAxis] = self.app.location[ZAxis]
self.app.pausePoint[EAxis] = self.app.location[EAxis]
self.logger.logMsg("Pause location: X:%f Y:%f Z:%f E:%f" %
(self.app.pausePoint[XAxis], self.app.pausePoint[YAxis], self.app.pausePoint[ZAxis], self.app.pausePoint[EAxis]))
if self.settings.liftonpause:
self.printer.send_now("G1 E%s F%s" % (self.app.pausePoint[EAxis]-2, self.settings.efeed))
self.printer.send_now("G1 Z%s F%s" % (self.app.pausePoint[ZAxis]+10, self.settings.zfeed))
self.bPause.config(text=pauseText[PM_RESUME])
self.bPauseMode = PM_RESUME
self.app.printing = False
self.bSlice.config(state=NORMAL)
self.bLoad.config(state=NORMAL)
self.app.allowLoadGCodeMenu(True)
self.app.allowSliceMenu(True)
if self.app.sduploading:
self.bPrint.config(text=printText[PR_PRINT], state=DISABLED)
self.bPrintMode = PR_PRINT
else:
self.bPrint.config(text=printText[PR_RESTART], state=NORMAL)
self.bPrintMode = PR_RESTART
else:
# we still are waiting for the report, but reset everything if the printer is still moving
if self.waitPos != self.printer.queueindex:
self.waitPos = self.printer.queueindex
self.maxWait114 = MAXWAIT114
self.app.master.after(500, self.check114Response)
def doPort(self):
l = self.scanSerial()
self.spPort.config(values=l)
if len(l) == 0:
self.bConnect.config(state=DISABLED)
else:
self.bConnect.config(state=NORMAL)
def scanSerial(self):
"""scan for available ports. return a list of device names."""
baselist=[]
if os.name=="nt":
try:
key=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,"HARDWARE\\DEVICEMAP\\SERIALCOMM")
i=0
while(1):
baselist+=[_winreg.EnumValue(key,i)[1]]
i+=1
except:
pass
return baselist+glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*') +glob.glob("/dev/tty.*")+glob.glob("/dev/cu.*")+glob.glob("/dev/rfcomm*")
def doSD(self):
self.app.doSD()
def CreateWidgets(self):
frameMain = Frame(self,borderwidth=2,relief=SUNKEN)
frameMain.pack(side=TOP,expand=TRUE,fill=BOTH)
frameButtons=Frame(self)
frameButtons.pack(side=BOTTOM,fill=X)
self.buttonOK = Button(frameButtons,text='OK',
width=8,command=self.OK)
self.buttonOK.grid(row=0,column=0,padx=5,pady=5)
self.buttonCancel = Button(frameButtons,text='Cancel',
width=8,command=self.Cancel)
self.buttonCancel.grid(row=0,column=1,padx=5,pady=5)
self.frameKeySeqBasic = Frame(frameMain)
self.frameKeySeqAdvanced = Frame(frameMain)
self.frameControlsBasic = Frame(frameMain)
self.frameHelpAdvanced = Frame(frameMain)
self.frameKeySeqAdvanced.grid(row=0,column=0,sticky=NSEW,padx=5,pady=5)
self.frameKeySeqBasic.grid(row=0,column=0,sticky=NSEW,padx=5,pady=5)
self.frameKeySeqBasic.lift()
self.frameHelpAdvanced.grid(row=1,column=0,sticky=NSEW,padx=5)
self.frameControlsBasic.grid(row=1,column=0,sticky=NSEW,padx=5)
self.frameControlsBasic.lift()
self.buttonLevel = Button(frameMain,command=self.ToggleLevel,
text='Advanced Key Binding Entry >>')
self.buttonLevel.grid(row=2,column=0,stick=EW,padx=5,pady=5)
labelTitleBasic = Label(self.frameKeySeqBasic,
text="New keys for '"+self.action+"' :")
labelTitleBasic.pack(anchor=W)
labelKeysBasic = Label(self.frameKeySeqBasic,justify=LEFT,
textvariable=self.keyString,relief=GROOVE,borderwidth=2)
labelKeysBasic.pack(ipadx=5,ipady=5,fill=X)
self.modifier_checkbuttons = {}
column = 0
for modifier, variable in zip(self.modifiers, self.modifier_vars):
label = self.modifier_label.get(modifier, modifier)
check=Checkbutton(self.frameControlsBasic,
command=self.BuildKeyString,
text=label,variable=variable,onvalue=modifier,offvalue='')
check.grid(row=0,column=column,padx=2,sticky=W)
self.modifier_checkbuttons[modifier] = check
column += 1
labelFnAdvice=Label(self.frameControlsBasic,justify=LEFT,
text=\
"Select the desired modifier keys\n"+
"above, and the final key from the\n"+
"list on the right.\n\n" +
"Use upper case Symbols when using\n" +
"the Shift modifier. (Letters will be\n" +
"converted automatically.)")
labelFnAdvice.grid(row=1,column=0,columnspan=4,padx=2,sticky=W)
self.listKeysFinal=Listbox(self.frameControlsBasic,width=15,height=10,
selectmode=SINGLE)
self.listKeysFinal.bind('<ButtonRelease-1>',self.FinalKeySelected)
self.listKeysFinal.grid(row=0,column=4,rowspan=4,sticky=NS)
scrollKeysFinal=Scrollbar(self.frameControlsBasic,orient=VERTICAL,
command=self.listKeysFinal.yview)
self.listKeysFinal.config(yscrollcommand=scrollKeysFinal.set)
scrollKeysFinal.grid(row=0,column=5,rowspan=4,sticky=NS)
self.buttonClear=Button(self.frameControlsBasic,
text='Clear Keys',command=self.ClearKeySeq)
self.buttonClear.grid(row=2,column=0,columnspan=4)
labelTitleAdvanced = Label(self.frameKeySeqAdvanced,justify=LEFT,
text="Enter new binding(s) for '"+self.action+"' :\n"+
"(These bindings will not be checked for validity!)")
labelTitleAdvanced.pack(anchor=W)
self.entryKeysAdvanced=Entry(self.frameKeySeqAdvanced,
textvariable=self.keyString)
self.entryKeysAdvanced.pack(fill=X)
labelHelpAdvanced=Label(self.frameHelpAdvanced,justify=LEFT,
text="Key bindings are specified using Tkinter keysyms as\n"+
"in these samples: <Control-f>, <Shift-F2>, <F12>,\n"
"<Control-space>, <Meta-less>, <Control-Alt-Shift-X>.\n"
"Upper case is used when the Shift modifier is present!\n\n" +
"'Emacs style' multi-keystroke bindings are specified as\n" +
"follows: <Control-x><Control-y>, where the first key\n" +
"is the 'do-nothing' keybinding.\n\n" +
"Multiple separate bindings for one action should be\n"+
"separated by a space, eg., <Alt-v> <Meta-v>." )
labelHelpAdvanced.grid(row=0,column=0,sticky=NSEW)
class GUI:
def _run(self):
self.saveBtn.config(state=DISABLED)
self.progressTxt.config(state=NORMAL)
self.progressTxt.delete('1.0', END)
self.progressTxt.update()
self.progressTxt.config(state=DISABLED)
inputId = self.txEntry.get()
item = map(int, self.dbLbox.curselection())
db = self.dbids[item[0]]
self.runBtn.config(state=DISABLED)
self.inputId, self.inputName, self.hprobes = main(inputId,
db,
debug=self.debug,
txt=self.progressTxt)
self.runBtn.config(state=NORMAL)
if self.hprobes is not None:
self.saveBtn.config(state=NORMAL)
def _quitGUI(self):
#rpath = self.progressTxt.get('8.0','end-1c')
#if rpath.startswith('Your results'):
# tkMessageBox.showinfo("Quit", self.progressTxt.get('8.0','end-1c'))
self.master.destroy()
def _save(self):
hps = filter_probes(self.hprobes, self.spec.get(), self.mingc.get(),
self.multiexon.get(), self.mintm.get(),
self.maxtm.get(), self.mindimer.get(),
self.minfold.get(), self.maxduplex.get())
result_csv = write_probesCSV(self.inputId, self.inputName, hps,
self.progressTxt)
result_fna = write_probesFNA(self.inputId, self.inputName, hps,
self.progressTxt)
tkMessageBox.showinfo('Result file',
'Details on ' + str(len(hps)) + \
' hybridization probe(s) were exported to ' + \
result_csv + "\n\n" + \
'Sequences of '+ str(len(hps)) + \
' hybridization probe(s) were exported to ' + \
result_fna)
def __init__(self, master, dbnames, dbids, debug, version):
self.dbids = dbids
self.debug = debug
self.master = master
master.title('Plish Probe Designer')
self.logoImg = PhotoImage(file=get_script_path() +
'/img/plishLogo.gif')
self.logoLbl = Label(master, image=self.logoImg)
self.logoLbl.grid(row=0, columnspan=3)
self.logoLbl.img = self.logoImg
self.dbLbl = Label(master, text='Database')
self.dbLbl.grid(row=1, sticky=W + N)
self.dbLbox = Listbox(master, width=63, height=4)
self.dbLbox.configure(exportselection=False)
for i in range(len(dbnames)):
self.dbLbox.insert(i, dbnames[i])
self.dbLbox.select_set(0)
self.dbLbox.grid(row=1, column=1, columnspan=2, sticky=N)
self.txLbl = Label(master, text='Transcript ID')
self.txLbl.grid(row=2, sticky=W + N)
self.txEntry = Entry(master, width=39)
self.txEntry.grid(row=2, column=1, sticky=W + N)
self.runBtn = Button(master, text='Run', command=self._run, width=15)
self.runBtn.grid(row=2, column=2)
self.progressLbl = Label(master, text='Progress')
self.progressLbl.grid(row=4, sticky=W + N)
self.progressTxt = Text(bg="#263238",
fg="#ffffff",
state=DISABLED,
width=51,
height=16)
self.progressTxt.grid(row=4, column=1)
self.saveBtn = Button(master,
text='Save',
command=self._save,
state=DISABLED,
width=15)
self.saveBtn.grid(row=5, column=2, sticky=N)
self.quitBtn = Button(master,
text='Quit',
command=self._quitGUI,
width=15)
self.quitBtn.grid(row=6, column=2, sticky=N)
self.aboutLF = LabelFrame(master, text='About', width=300)
self.aboutLF.grid(row=5,
column=0,
rowspan=2,
columnspan=2,
sticky=N + W)
self.versionLbl = Label(self.aboutLF, text='PLISH Probe Designer, Version ' + version + '\n' + \
'(c) Heller lab, Stanford University School of Medicine\n' + \
' Daniel C. Ellwanger <*****@*****.**> ',
justify=LEFT)
self.versionLbl.grid(row=0, column=0, sticky=N)
# Filter
self.filterLF = LabelFrame(master, text='Filter')
self.filterLF.grid(row=4, column=2, rowspan=2, sticky=N + W)
self.mingc = DoubleVar()
self.mingc.set(_defaultGC)
self.mingcLbl = Label(self.filterLF, text='Min. GC')
self.mingcLbl.grid(row=0, column=0, sticky=N + W)
self.mingcEntry = Entry(self.filterLF, width=5, text=self.mingc)
self.mingcEntry.grid(row=0, column=1, sticky=N + W)
self.mingcLbl2 = Label(self.filterLF, text='%')
self.mingcLbl2.grid(row=0, column=2, sticky=N + W)
self.spec = StringVar(master)
self.spec.set("isoform")
self.specLbl = Label(self.filterLF, text='Specificity')
self.specLbl.grid(row=1, column=0, sticky=N + W)
self.specOm = OptionMenu(self.filterLF, self.spec, "isoform", "gene",
"none")
self.specOm.grid(row=1, column=1, sticky=N + W, columnspan=2)
self.mintm = DoubleVar()
self.mintm.set(_defaultMinTm)
self.mintmLbl = Label(self.filterLF, text='Min. Tm')
self.mintmLbl.grid(row=2, column=0, sticky=N + W)
self.mintmEntry = Entry(self.filterLF, width=5, text=self.mintm)
self.mintmEntry.grid(row=2, column=1, sticky=N + W)
self.mintmLbl2 = Label(self.filterLF, text=u'\N{DEGREE SIGN}' + 'C')
self.mintmLbl2.grid(row=2, column=2, sticky=N + W)
self.maxtm = DoubleVar()
self.maxtm.set(_defaultMaxTm)
self.maxtmLbl = Label(self.filterLF, text='Max. Tm')
self.maxtmLbl.grid(row=3, column=0, sticky=N + W)
self.maxtmEntry = Entry(self.filterLF, width=5, text=self.maxtm)
self.maxtmEntry.grid(row=3, column=1, sticky=N + W)
self.maxtmLbl2 = Label(self.filterLF, text=u'\N{DEGREE SIGN}' + 'C')
self.maxtmLbl2.grid(row=3, column=2, sticky=N + W)
self.minfold = DoubleVar()
self.minfold.set(_defaultMinFold)
self.minfoldLbl = Label(self.filterLF, text='Min. Fold')
self.minfoldLbl.grid(row=4, column=0, sticky=N + W)
self.minfoldEntry = Entry(self.filterLF, width=5, text=self.minfold)
self.minfoldEntry.grid(row=4, column=1, sticky=N + W)
self.minfoldLbl2 = Label(self.filterLF, text='kcal/mol')
self.minfoldLbl2.grid(row=4, column=2, sticky=N + W)
self.mindimer = DoubleVar()
self.mindimer.set(_defaultMinDimer)
self.mindimerLbl = Label(self.filterLF, text='Min. Dimer')
self.mindimerLbl.grid(row=5, column=0, sticky=N + W)
self.mindimerEntry = Entry(self.filterLF, width=5, text=self.mindimer)
self.mindimerEntry.grid(row=5, column=1, sticky=N + W)
self.mindimerLbl2 = Label(self.filterLF, text='kcal/mol')
self.mindimerLbl2.grid(row=5, column=2, sticky=N + W)
self.maxduplex = DoubleVar()
self.maxduplex.set(_defaultMaxDuplex)
self.maxduplexLbl = Label(self.filterLF, text='Max. Duplex')
self.maxduplexLbl.grid(row=6, column=0, sticky=N + W)
self.maxduplexEntry = Entry(self.filterLF,
width=5,
text=self.maxduplex)
self.maxduplexEntry.grid(row=6, column=1, sticky=N + W)
self.maxduplexLbl2 = Label(self.filterLF, text='kcal/mol')
self.maxduplexLbl2.grid(row=6, column=2, sticky=N + W)
self.multiexon = BooleanVar()
self.multiexon.set(_defaultMultiExon)
self.multiexonCb = Checkbutton(self.filterLF,
text='Multi-exon',
variable=self.multiexon,
onvalue=True,
offvalue=False)
self.multiexonCb.grid(row=7, column=0, sticky=N + W)
def initUI(self):
self.parent.title("FIND SPE VALUE")
self.pack(fill=BOTH, expand=True)
self.columnconfigure(0, weight=1)
#self.rowconfigure(0, weight=1)
# weight attibute is used to make them growable
self.graph_cb = BooleanVar()
self.bins = IntVar()
self.path = StringVar()
self.n_files = IntVar()
self.start_s = IntVar()
self.end_s = IntVar()
self.guess = IntVar()
search = Image.open("next_logo.jpg")
search_temp = search.resize((160, 200), Image.ANTIALIAS)
search_aux = ImageTk.PhotoImage(search_temp)
label1 = Label(self, image=search_aux)
label1.image = search_aux
label1.grid(row=0, column=0,
columnspan=10, rowspan=10, sticky=E+W+S+N)
#Number of Files and Bins. Spin Box
self.n_files.set("2000")
sb1 = Spinbox(self, from_=1, to=10000,
width=6, textvariable=self.n_files)
sb1.grid(row=1,column=4, sticky=W)
sb1_label = Label(self, text="Files")
sb1_label.grid(row=1,column=3, padx=5, sticky=E)
self.bins.set("50")
sb2 = Spinbox(self, from_=10, to=200,
width=6, textvariable=self.bins)
sb2.grid(row=1,column=6, sticky=W)
sb2_label = Label(self, text="Hist. Bins")
sb2_label.grid(row=1,column=5, padx=5, sticky=E)
# INTEGRATION LIMITS
Integration_label = Label(self, text="INTEGRATION",
font = "Verdana 12 bold")
Integration_label.grid(row=3,column=4,
padx=5,
columnspan = 2)
self.start_s.set("1732")
sb3 = Spinbox(self, from_=1, to=10000,
width=6, textvariable=self.start_s)
sb3.grid(row=4,column=4, sticky=W)
sb3_label = Label(self, text="StartPoint")
sb3_label.grid(row=4,column=3, padx=5, sticky=E)
self.end_s.set("1752")
sb4 = Spinbox(self, from_=1, to=10000,
width=6, textvariable=self.end_s)
sb4.grid(row=4,column=6, sticky=W)
sb4_label = Label(self, text="EndPoint")
sb4_label.grid(row=4,column=5, padx=5, sticky=E)
sb4_label = Label(self, text="")
sb4_label.grid(row=4,column=7, padx=5, sticky=E)
# FITTING PARAMETERS
Integration_label = Label(self, text="FITTING",
font = "Verdana 12 bold")
Integration_label.grid(row=6,column=4,
padx=5,
columnspan = 2)
self.guess.set("-20")
sb5 = Spinbox(self, from_=-50, to=-1,
width=6, textvariable=self.guess)
sb5.grid(row=7,column=4, sticky=W)
sb5_label = Label(self, text="SPE guess")
sb5_label.grid(row=7,column=5, padx=5, sticky=W)
#Check buttons
cb1 = Checkbutton(self, text="MultiGraph Output", variable=self.graph_cb )
cb1.select()
cb1.grid(row=7,column=6, sticky=W)
#Text Box
#self.path.set("F:/DATOS_DAC/spe_1230/2046/pmt_0_trace_evt_")
self.path.set("spe_1230_2046.h5.z")
e1 = Entry(self, textvariable=self.path, width=45)
e1.grid(row=10,column=3, sticky=W, columnspan=10, padx=10, pady=5)
e1_label = Label(self, text="DataSet path (including name file)")
e1_label.grid(row=9,column=3,sticky=W, columnspan=10, padx=10)
# Main buttons
obtn = Button(self, text="GO!!", command=self.SPE_f)
obtn.grid(row=14, column=5, sticky=E, pady=5)
cbtn = Button(self, text="Quit", command=self.quit)
cbtn.grid(row=14, column=6, sticky=E, pady=5)
hbtn = Button(self, text="Help")
hbtn.grid(row=14, column=0, sticky=W, pady=5)
class Debugger:
vstack = vsource = vlocals = vglobals = None
def __init__(self, pyshell, idb=None):
if idb is None:
idb = Idb(self)
self.pyshell = pyshell
self.idb = idb
self.frame = None
self.make_gui()
self.interacting = 0
self.nesting_level = 0
def run(self, *args):
# Deal with the scenario where we've already got a program running
# in the debugger and we want to start another. If that is the case,
# our second 'run' was invoked from an event dispatched not from
# the main event loop, but from the nested event loop in 'interaction'
# below. So our stack looks something like this:
# outer main event loop
# run()
# <running program with traces>
# callback to debugger's interaction()
# nested event loop
# run() for second command
#
# This kind of nesting of event loops causes all kinds of problems
# (see e.g. issue #24455) especially when dealing with running as a
# subprocess, where there's all kinds of extra stuff happening in
# there - insert a traceback.print_stack() to check it out.
#
# By this point, we've already called restart_subprocess() in
# ScriptBinding. However, we also need to unwind the stack back to
# that outer event loop. To accomplish this, we:
# - return immediately from the nested run()
# - abort_loop ensures the nested event loop will terminate
# - the debugger's interaction routine completes normally
# - the restart_subprocess() will have taken care of stopping
# the running program, which will also let the outer run complete
#
# That leaves us back at the outer main event loop, at which point our
# after event can fire, and we'll come back to this routine with a
# clean stack.
if self.nesting_level > 0:
self.abort_loop()
self.root.after(100, lambda: self.run(*args))
return
try:
self.interacting = 1
return self.idb.run(*args)
finally:
self.interacting = 0
def close(self, event=None):
try:
self.quit()
except Exception:
pass
if self.interacting:
self.top.bell()
return
if self.stackviewer:
self.stackviewer.close()
self.stackviewer = None
# Clean up pyshell if user clicked debugger control close widget.
# (Causes a harmless extra cycle through close_debugger() if user
# toggled debugger from pyshell Debug menu)
self.pyshell.close_debugger()
# Now close the debugger control window....
self.top.destroy()
def make_gui(self):
pyshell = self.pyshell
self.flist = pyshell.flist
self.root = root = pyshell.root
self.top = top = ListedToplevel(root)
self.top.wm_title("Debug Control")
self.top.wm_iconname("Debug")
top.wm_protocol("WM_DELETE_WINDOW", self.close)
self.top.bind("<Escape>", self.close)
#
self.bframe = bframe = Frame(top)
self.bframe.pack(anchor="w")
self.buttons = bl = []
#
self.bcont = b = Button(bframe, text="Go", command=self.cont)
bl.append(b)
self.bstep = b = Button(bframe, text="Step", command=self.step)
bl.append(b)
self.bnext = b = Button(bframe, text="Over", command=self.next)
bl.append(b)
self.bret = b = Button(bframe, text="Out", command=self.ret)
bl.append(b)
self.bret = b = Button(bframe, text="Quit", command=self.quit)
bl.append(b)
#
for b in bl:
b.configure(state="disabled")
b.pack(side="left")
#
self.cframe = cframe = Frame(bframe)
self.cframe.pack(side="left")
#
if not self.vstack:
self.__class__.vstack = BooleanVar(top)
self.vstack.set(1)
self.bstack = Checkbutton(cframe,
text="Stack",
command=self.show_stack,
variable=self.vstack)
self.bstack.grid(row=0, column=0)
if not self.vsource:
self.__class__.vsource = BooleanVar(top)
self.bsource = Checkbutton(cframe,
text="Source",
command=self.show_source,
variable=self.vsource)
self.bsource.grid(row=0, column=1)
if not self.vlocals:
self.__class__.vlocals = BooleanVar(top)
self.vlocals.set(1)
self.blocals = Checkbutton(cframe,
text="Locals",
command=self.show_locals,
variable=self.vlocals)
self.blocals.grid(row=1, column=0)
if not self.vglobals:
self.__class__.vglobals = BooleanVar(top)
self.bglobals = Checkbutton(cframe,
text="Globals",
command=self.show_globals,
variable=self.vglobals)
self.bglobals.grid(row=1, column=1)
#
self.status = Label(top, anchor="w")
self.status.pack(anchor="w")
self.error = Label(top, anchor="w")
self.error.pack(anchor="w", fill="x")
self.errorbg = self.error.cget("background")
#
self.fstack = Frame(top, height=1)
self.fstack.pack(expand=1, fill="both")
self.flocals = Frame(top)
self.flocals.pack(expand=1, fill="both")
self.fglobals = Frame(top, height=1)
self.fglobals.pack(expand=1, fill="both")
#
if self.vstack.get():
self.show_stack()
if self.vlocals.get():
self.show_locals()
if self.vglobals.get():
self.show_globals()
def interaction(self, message, frame, info=None):
self.frame = frame
self.status.configure(text=message)
#
if info:
type, value, tb = info
try:
m1 = type.__name__
except AttributeError:
m1 = "%s" % str(type)
if value is not None:
try:
m1 = "%s: %s" % (m1, str(value))
except:
pass
bg = "yellow"
else:
m1 = ""
tb = None
bg = self.errorbg
self.error.configure(text=m1, background=bg)
#
sv = self.stackviewer
if sv:
stack, i = self.idb.get_stack(self.frame, tb)
sv.load_stack(stack, i)
#
self.show_variables(1)
#
if self.vsource.get():
self.sync_source_line()
#
for b in self.buttons:
b.configure(state="normal")
#
self.top.wakeup()
# Nested main loop: Tkinter's main loop is not reentrant, so use
# Tcl's vwait facility, which reenters the event loop until an
# event handler sets the variable we're waiting on
self.nesting_level += 1
self.root.tk.call('vwait', '::idledebugwait')
self.nesting_level -= 1
#
for b in self.buttons:
b.configure(state="disabled")
self.status.configure(text="")
self.error.configure(text="", background=self.errorbg)
self.frame = None
def sync_source_line(self):
frame = self.frame
if not frame:
return
filename, lineno = self.__frame2fileline(frame)
if filename[:1] + filename[-1:] != "<>" and os.path.exists(filename):
self.flist.gotofileline(filename, lineno)
def __frame2fileline(self, frame):
code = frame.f_code
filename = code.co_filename
lineno = frame.f_lineno
return filename, lineno
def cont(self):
self.idb.set_continue()
self.abort_loop()
def step(self):
self.idb.set_step()
self.abort_loop()
def next(self):
self.idb.set_next(self.frame)
self.abort_loop()
def ret(self):
self.idb.set_return(self.frame)
self.abort_loop()
def quit(self):
self.idb.set_quit()
self.abort_loop()
def abort_loop(self):
self.root.tk.call('set', '::idledebugwait', '1')
stackviewer = None
def show_stack(self):
if not self.stackviewer and self.vstack.get():
self.stackviewer = sv = StackViewer(self.fstack, self.flist, self)
if self.frame:
stack, i = self.idb.get_stack(self.frame, None)
sv.load_stack(stack, i)
else:
sv = self.stackviewer
if sv and not self.vstack.get():
self.stackviewer = None
sv.close()
self.fstack['height'] = 1
def show_source(self):
if self.vsource.get():
self.sync_source_line()
def show_frame(self, stackitem):
self.frame = stackitem[0] # lineno is stackitem[1]
self.show_variables()
localsviewer = None
globalsviewer = None
def show_locals(self):
lv = self.localsviewer
if self.vlocals.get():
if not lv:
self.localsviewer = NamespaceViewer(self.flocals, "Locals")
else:
if lv:
self.localsviewer = None
lv.close()
self.flocals['height'] = 1
self.show_variables()
def show_globals(self):
gv = self.globalsviewer
if self.vglobals.get():
if not gv:
self.globalsviewer = NamespaceViewer(self.fglobals, "Globals")
else:
if gv:
self.globalsviewer = None
gv.close()
self.fglobals['height'] = 1
self.show_variables()
def show_variables(self, force=0):
lv = self.localsviewer
gv = self.globalsviewer
frame = self.frame
if not frame:
ldict = gdict = None
else:
ldict = frame.f_locals
gdict = frame.f_globals
if lv and gv and ldict is gdict:
ldict = None
if lv:
lv.load_dict(ldict, force, self.pyshell.interp.rpcclt)
if gv:
gv.load_dict(gdict, force, self.pyshell.interp.rpcclt)
def set_breakpoint_here(self, filename, lineno):
self.idb.set_break(filename, lineno)
def clear_breakpoint_here(self, filename, lineno):
self.idb.clear_break(filename, lineno)
def clear_file_breaks(self, filename):
self.idb.clear_all_file_breaks(filename)
def load_breakpoints(self):
"Load PyShellEditorWindow breakpoints into subprocess debugger"
pyshell_edit_windows = self.pyshell.flist.inversedict.keys()
for editwin in pyshell_edit_windows:
filename = editwin.io.filename
try:
for lineno in editwin.breakpoints:
self.set_breakpoint_here(filename, lineno)
except AttributeError:
continue
class IniGenGui(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.inigen = IniGen()
self.initUIGlobals()
def initUIGlobals(self):
"""
This is the first part of the window to be rendered. After these have been
set by the user and 'Emit Globals' has been clicked, the given algorithm
can then specify how to generate the second part of the window. All fields
are disabled for user input after globals have been emitted.
Information in Global Parameters:
Algorithm
- name of the algorithm to use
File Name
- name of the output file to be generated
Min Time
- Minimum Time for distillers to run
Max Time
- Maximum Time for distillers to run
Set Enabled:
- checkbox to specify if the distiller should be enabled True or False
"""
self.parent.title("Ini Generator")
Style().configure("TButton", padding=(0, 5, 0, 5), font='serif 10')
# initialize row counter. This is incremented after each element added to grid
row = 0
# initialize column counter. This is incremented after a column has been filled
self.column = 0
# Globals: entries for info common to all runs
label_globals = Label(self, text="Globals")
label_globals.grid(row=row, column=self.column)
row += 1
label_alg = Label(self, text="Algorithm")
label_alg.grid(row=row, column=self.column, sticky=E + W)
row += 1
self.cbox_alg = Combobox(self,
values=algorithms.keys(),
state='readonly')
self.cbox_alg.current(0)
self.cbox_alg.grid(row=row, column=self.column, sticky=E + W + S + N)
row += 1
label_filename = Label(self, text="Output File Name")
label_filename.grid(row=row, column=self.column, sticky=E + W)
row += 1
self.entry_filename = Entry(self)
self.entry_filename.grid(row=row, column=self.column, sticky=W + E)
row += 1
label_mintime = Label(self, text="Min Time")
label_mintime.grid(row=row, column=self.column, sticky=E + W)
row += 1
self.entry_mintime = Entry(self)
self.entry_mintime.grid(row=row, column=self.column, sticky=W + E)
row += 1
label_maxtime = Label(self, text="Max Time")
label_maxtime.grid(row=row, column=self.column, sticky=W + E)
row += 1
self.entry_maxtime = Entry(self)
self.entry_maxtime.grid(row=row, column=self.column, sticky=W + E)
row += 1
self.enabled = IntVar()
self.check_enabled = Checkbutton(self,
text="set enabled",
variable=self.enabled)
self.check_enabled.grid(row=row, column=self.column, sticky=W + E)
row += 1
# Control: buttons used to emmiting text and generating file
self.button_emit_globals = Button(self,
text="Emit Globals",
command=self.emit_globals)
self.button_emit_globals.grid(row=row,
column=self.column,
sticky=W + E)
row += 1
button_addrun = Button(self, text="Add Run", command=self.emit_run)
button_addrun.grid(row=row, column=self.column, sticky=W + E)
row += 1
button_generate = Button(self,
text="Generate File",
command=self.generate_file)
button_generate.grid(row=row, column=self.column, sticky=W + E)
row += 1
self.column += 1
self.pack()
def initUIRuns(self):
"""
Second part of gui to be rendered. This contains all the fields needed to emit
a single run within a distiller file. Multiple runs can be added by clicking
'Add Run' multiple times.
Information in Run Parameters:
Run Name
- header name for run
Dependencies
- description and uuid fields for each dependency in the algorithm
Params
- parameter fields for each parameter in the algorithm
"""
self.entry_run_name = None
self.entries_dep_description = []
self.entries_dep_uuid = []
self.entries_param = []
row = 0
label_runs = Label(self, text="Runs")
label_runs.grid(row=row, column=self.column)
row += 1
label_run_name = Label(self, text="Run Name")
label_run_name.grid(row=row, column=self.column, sticky=W + E)
row += 1
self.entry_run_name = Entry(self)
self.entry_run_name.grid(row=row, column=self.column, sticky=W + E)
row += 1
algorithm = self.cbox_alg.get()
settings = algorithms[algorithm]
for dep in settings['deps']:
if row >= 21:
self.column += 1
row = 1
label_dep_description = Label(self,
text="{0} (description)".format(dep))
label_dep_description.grid(row=row,
column=self.column,
sticky=W + E)
row += 1
entry_dep_description = Entry(self)
entry_dep_description.grid(row=row,
column=self.column,
sticky=W + E)
row += 1
label_dep_uuid = Label(self, text="{0} (uuid)".format(dep))
label_dep_uuid.grid(row=row, column=self.column, sticky=W + E)
row += 1
entry_dep_uuid = Entry(self)
entry_dep_uuid.grid(row=row, column=self.column, sticky=W + E)
row += 1
self.entries_dep_description.append(entry_dep_description)
self.entries_dep_uuid.append(entry_dep_uuid)
for param in settings['params']:
if row >= 21:
self.column += 1
row = 1
label_param = Label(self, text=param)
label_param.grid(row=row, column=self.column, sticky=W + E)
row += 1
entry_param = Entry(self)
entry_param.grid(row=row, column=self.column, sticky=W + E)
row += 1
self.entries_param.append(entry_param)
row = 0
self.column += 1
self.text_file = Text(self)
self.text_file.grid(row=row,
column=self.column,
rowspan=31,
sticky=W + E + N + S,
padx=5,
pady=5)
self.column += 1
scrollbar = Scrollbar(self, command=self.text_file.yview)
self.text_file.config(yscrollcommand=scrollbar.set)
scrollbar.grid(row=row, column=self.column, rowspan=31, sticky=N + S)
self.pack()
def emit_globals(self):
self.algorithm = algorithms[self.cbox_alg.get()]
path = self.algorithm['path']
if self.enabled.get():
enabled = 'True'
else:
enabled = 'False'
lines = self.inigen.emit_global(path, enabled)
self.mintime = self.entry_mintime.get()
self.maxtime = self.entry_maxtime.get()
self.cbox_alg.configure(state='disabled')
self.entry_filename.configure(state='disabled')
self.entry_mintime.configure(state='disabled')
self.entry_maxtime.configure(state='disabled')
self.check_enabled.configure(state='disabled')
self.button_emit_globals.configure(state='disabled')
self.initUIRuns()
self.update_text(lines)
def emit_run(self):
label = self.entry_run_name.get()
chunking = 'parallel' #hardcoded for now
mintime = self.mintime
maxtime = self.maxtime
lines = self.inigen.emit_run_header(label, chunking, mintime, maxtime)
self.update_text(lines)
deps = []
for i in range(len(self.entries_dep_description)):
deps.append([
self.entries_dep_description[i].get(),
self.algorithm['deps'][i], self.entries_dep_uuid[i].get()
])
params = []
for i in range(len(self.entries_param)):
params.append(
[self.algorithm['params'][i], self.entries_param[i].get()])
outputs = self.algorithm['outputs']
lines = self.inigen.emit_run_body(deps, params, outputs)
self.update_text(lines)
def generate_file(self):
self.inigen.generate_file(self.entry_filename.get())
self.quit()
def update_text(self, lines):
self.text_file.configure(state='normal')
string = "\n".join(lines)
self.text_file.insert(END, string)
self.text_file.configure(state='disabled')
def __init__(self, ncffile, options):
master = self.root = Tk()
self.ncffile = ncffile
self.options = options
self.plotted_variables = set()
frame = Frame(master)
frame.grid(row = 0)
codeframe = Frame(master)
codeframe.grid(row = 1)
metaframe = Frame(master)
metaframe.grid(row = 2)
goframe = Frame(frame)
goframe.grid(column = 3, row = 1)
var_label = Label(frame, text = 'Select Variable')
var_label.grid(column = 0, row = 0)
var_scrollbar = Scrollbar(frame, orient = VERTICAL)
var_scrollbar.grid(column = 1, row = 1, sticky = N + S)
self.var = Listbox(frame, selectmode = EXTENDED, exportselection = 0, yscrollcommand = var_scrollbar.set)
self.var.grid(column = 0, row = 1)
var_scrollbar.config(command = self.var.yview)
what_to_do = Label(frame, text = 'Execute')
what_to_do.grid(column = 2, row = 0)
self.method_list = Listbox(frame, selectmode = SINGLE, exportselection = 0)
self.method_list.grid(column = 2, row = 1)
self.pre_txt = StringVar()
pre_label = Label(codeframe, text = 'Before any figures, execute code')
self.pre_txt.set(_pre_code)
pre_label.grid(row = 2, sticky = 'W')
self.pre = Entry(codeframe, width = 120, textvariable = self.pre_txt)
self.pre.grid(row =3, sticky = 'E')
self.before_txt = StringVar()
self.before_txt.set(_before_code)
before_label = Label(codeframe, text = 'Before each figure, execute code')
before_label.grid(row = 4, sticky = 'W')
self.before = Entry(codeframe, width = 120, textvariable = self.before_txt)
self.before.grid(row =5, sticky = 'E')
self.after_txt = StringVar()
self.after_txt.set(_after_code)
after_label = Label(codeframe, text = 'After each figure, execute code')
after_label.grid(row = 6, sticky = 'W')
self.after = Entry(codeframe, width = 120, textvariable = self.after_txt)
self.after.grid(row =7, sticky = 'E')
self.post_txt = StringVar()
self.post_txt.set(_post_code)
post_label = Label(codeframe, text = 'After all figures, execute code')
post_label.grid(row = 8, sticky = 'W')
self.post = Entry(codeframe, width = 120, textvariable = self.post_txt)
self.post.grid(row = 9, sticky = 'E')
options_label = Label(goframe, text = 'Options:')
options_label.grid(column = 0, row = 1, sticky = 'W')
self.logscale = IntVar()
self.logscale.set(0)
c = Checkbutton(goframe, text = "log-scale?", variable = self.logscale)
c.grid(column = 0, row = 2, sticky = 'W')
self.coastlines = IntVar()
self.coastlines.set(_coastlines_opt)
coastlines = Checkbutton(goframe, text = "coastlines?", variable = self.coastlines, justify = LEFT)
coastlines.grid(column = 0, row = 3, sticky = 'W')
self.countries = IntVar()
self.countries.set(_countries_opt)
countries = Checkbutton(goframe, text = "countries?", variable = self.countries, justify = LEFT)
countries.grid(column = 0, row = 4, sticky = 'W')
self.states = IntVar()
self.states.set(_states_opt)
states = Checkbutton(goframe, text = "states?", variable = self.states, justify = LEFT)
states.grid(column = 0, row = 5, sticky = 'W')
self.counties = IntVar()
self.counties.set(_counties_opt)
counties = Checkbutton(goframe, text = "counties?", variable = self.counties, justify = LEFT)
counties.grid(column = 0, row = 6, sticky = 'W')
self.execute_button = Button(goframe, text = "Make Figure", command = self.execute)
self.execute_button.grid(row = 0, column = 0, sticky = 'W')
self.methods = ['mapplot', 'presslat', 'presslon', 'time-lat', 'profile', 'timeseries', 'pressx', 'tileplot', 'plot']
method_labels= ['lat-lon', 'press-lat', 'press-lon', 'time-lat', 'Vertical Profile', 'Time Series', 'press-? (2-D)', 'Tile Plot (2-D)', 'Plot (1-D)']
for method in method_labels:
self.method_list.insert(END, method)
var_keys = [k for k, v in self.ncffile.variables.items() if k not in ('time', 'latitude', 'longitude', 'latitude_bounds', 'longitude_bounds', 'time_bounds', 'tau0', 'tau1', 'TFLAG')]
var_keys.sort()
self.vars = []
for spc in var_keys:
self.var.insert(END, spc)
self.vars.append(spc)
meta_label = Label(metaframe, text = 'Common Data Language Header:')
meta_label.grid(column = 0, row = 0, sticky = 'W')
meta_scrollbar = Scrollbar(metaframe, orient = VERTICAL)
meta_scrollbar.grid(column = 1, row = 1, sticky = N + S)
self.meta = Text(metaframe, height=10, width=118, bg='white', relief='flat', yscrollcommand = meta_scrollbar.set)
self.meta.grid(column = 0, row = 1, sticky = 'W')
from PseudoNetCDF.pncdump import pncdump
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
pdump = StringIO("")
try:
name = ', '.join(options.ifile)
except:
name = 'ifile'
pncdump(self.ncffile, header = True, outfile = pdump, )
pdump.seek(0, 0)
self.meta.insert(END, pdump.read())
self.meta.config(state=DISABLED)
help = Button(goframe, text = 'Help', command = self.help)
help.grid(column = 0, row = 7)
quit = Button(goframe, text = 'Quit', command = self.quit)
quit.grid(column = 0, row = 8)
master.mainloop()
class readInputDates:
def __init__(self, master):
self.master = master
master.title("Enter Date Range:")
self.label_month = Label(master, text="Month")
self.label_date = Label(master, text="Date")
self.label_year = Label(master, text="Year")
self.label_startDate = Label(master, text="Start Date:")
self.label_endDate = Label(master, text="End Date:")
self.label_stock = Label(master, text="Stock:")
self.label_slowMA = Label(master, text="Slow MA:")
self.label_fastMA = Label(master, text="Fast MA:")
self.entry_stock = Entry(master)
vcmd = master.register(self.validate)
self.entry_d1 = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'd1'),
text=1)
self.entry_d2 = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'd2'))
self.entry_m1 = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'm1'))
self.entry_m2 = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'm2'))
self.entry_y1 = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'y1'))
self.entry_y2 = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'y2'))
self.entry_slowMA = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'slowMA'))
self.entry_fastMA = Entry(master,
validate="key",
validatecommand=(vcmd, '%P', 'fastMA'))
self.plot_button = Button(master,
text="Plot",
command=lambda: self.plot())
self.MansfieldVar = IntVar()
#enable Mansfield as default
self.MansfieldVar.set(1)
self.mansfieldCheckBox = Checkbutton(master, text="Mansfield RSI", variable = self.MansfieldVar, onvalue = 1,\
offvalue=0)
self.niftyOverlayVar = IntVar()
self.niftyOverlayVar.set(1)
self.niftyOverlayCheckBox = Checkbutton(master, text="Nifty Overlay", variable = self.niftyOverlayVar, onvalue = 1,\
offvalue=0)
# Layout
self.label_stock.grid(row=1, column=1)
self.entry_stock.grid(row=1, column=2)
self.label_month.grid(row=2, column=2)
self.label_date.grid(row=2, column=3)
self.label_year.grid(row=2, column=4)
self.label_endDate.grid(row=4, column=1)
self.label_startDate.grid(row=3, column=1)
self.plot_button.grid(row=1, column=4)
self.entry_m1.grid(row=3, column=2)
self.entry_m2.grid(row=4, column=2)
self.entry_d1.grid(row=3, column=3)
self.entry_d2.grid(row=4, column=3)
self.entry_y1.grid(row=3, column=4)
self.entry_y2.grid(row=4, column=4)
self.label_slowMA.grid(row=5, column=1)
self.entry_slowMA.grid(row=5, column=2)
self.label_fastMA.grid(row=5, column=3)
self.entry_fastMA.grid(row=5, column=4)
self.mansfieldCheckBox.grid(row=6, column=4)
self.niftyOverlayCheckBox.grid(row=6, column=3)
# set some default values
self.entry_stock.insert(0, 'ASHOKLEY.NS')
self.entry_d1.insert(0, 20)
self.entry_m1.insert(0, 5)
self.entry_y1.insert(0, 2016)
self.entry_d2.insert(0, 19)
self.entry_m2.insert(0, 6)
self.entry_y2.insert(0, 2017)
self.entry_slowMA.insert(0, 30)
self.entry_fastMA.insert(0, 150)
def validate(self, new_text, entry):
if not new_text: # the field is being cleared
if entry == 'd1':
self.entry_d1 = 0
elif entry == 'd2':
self.entry_d2 = 0
elif entry == 'm1':
self.entry_m1 = 0
elif entry == 'm2':
self.entry_m2 = 0
elif entry == 'y1':
self.entry_y1 = 0
elif entry == 'y2':
self.entry_y2 = 0
elif entry == 'slowMA':
self.entry_slowMA = 0
elif entry == 'fastMA':
self.entry_fastMA = 0
return True
try:
if entry == 'd1':
self.entry_d1 = int(new_text)
elif entry == 'd2':
self.entry_d2 = int(new_text)
elif entry == 'm1':
self.entry_m1 = int(new_text)
#substrace month -1. thats how they formated in yahoo api data
self.entry_m1 -= 1
elif entry == 'm2':
self.entry_m2 = int(new_text)
#substrace month -1. thats how they formated in yahoo api data
self.entry_m2 -= 1
elif entry == 'y1':
self.entry_y1 = int(new_text)
elif entry == 'y2':
self.entry_y2 = int(new_text)
elif entry == 'slowMA':
self.entry_slowMA = int(new_text)
elif entry == 'fastMA':
self.entry_fastMA = int(new_text)
return True
except ValueError:
return False
def plot(self):
global MA1, MA2, TypeMansfield, NiftyOverlay
MA1 = self.entry_slowMA
MA2 = self.entry_fastMA
EPSDataDict = {
'2016-01-04': 47,
'2015-10-01': 32,
'2015-07-01': 27,
'2015-04-01': 26
}
#stock = '%5ENSEI'
is_index = 0
stock = self.entry_stock.get()
if stock == 'NIFTY':
is_index = 1
print 'is_index ', is_index
if is_index == 1:
dataDict = pickle.load(open("data/FIIDATA.txt", "r"))
print self.entry_d1, self.entry_d2, self.entry_m1, self.entry_m2, self.entry_y1, self.entry_y2
d1 = str(self.entry_d1)
m1 = str(self.entry_m1)
y1 = str(self.entry_y1)
d2 = str(self.entry_d2)
m2 = str(self.entry_m2)
y2 = str(self.entry_y2)
TypeMansfield = self.MansfieldVar.get()
NiftyOverlay = self.niftyOverlayVar.get()
if is_index == 0:
fetchYahooData(stock, m1, d1, y1, m2, d2, y2)
#fetch Nifty data in both cases
fetchYahooData('%5ENSEI', m1, d1, y1, m2, d2, y2)
if is_index == 1:
graphData('nsei', False, dataDict)
else:
graphData(stock, True, EPSDataDict)
b2_lep.grid_forget()
b3_lep.grid_forget()
b4_lep.grid_forget()
lepptyes.grid_forget()
st_lepptcb.set(0)
chooseleppt()
lyes = Checkbutton(frame1,
text="Choose number of charged leptons",
bg="LightCyan2",
variable=st_lepcb,
onvalue=1,
offvalue=0,
command=chooseNlep)
lyes.grid(row=0, column=0, sticky=W) #Define and show checkbox
#Question mark to be next to "choose lep" option
qlep = Canvas(frame1, width=16, height=16)
qlep.place(relx=0.61, rely=0.001, anchor=N)
qlep.create_image(8, 8, image=questionmark)
infolep = Message(frame1,
text="""The number of charged leptons in the event""",
bg="White",
aspect=300) #Information message
def on_enterlep(event):
"""shows an explanation if cursor placed over question mark"""
infolep.place(relx=0.625, rely=0.0155, anchor=NW)
def data(self):
global textPath
textPath = StringVar()
global text0a
text0a = StringVar()
global text0b
text0b = StringVar()
global text2a
text2a = StringVar()
global text3
text3 = StringVar()
global alphaVar
alphaVar = IntVar()
global betaVar
betaVar = IntVar()
global allVar
allVar = IntVar()
global text6a
text6a = "0"
global filterVar
filterVar = IntVar()
global text6b
text6b = StringVar()
global t1x
t1x = ""
global t2x
t2x = ""
global t3x
t3x = ""
global t4x
t4x = ""
global text8_0
text8_0 = StringVar()
global text8_1
text8_1 = StringVar()
Label(self.frame,text="Path ? ").grid(row=0, column=0)
Entry(self.frame,textvariable=textPath).grid(row=1, column=0)
Button(self.frame, text="Valider et afficher", command = affiche_recap).grid(row=1, column=1)
Label(self.frame, text="Green function database information file\n (for a certain depth only for the instance) ?").grid(row=3)
Entry(self.frame, textvariable=text0a).grid(row=4)
Label(self.frame, text="Output directory (parentdir) ?").grid(row=5)
Entry(self.frame, textvariable=text0b).grid(row=6)
Label(self.frame, text="Phase name ?").grid(row=9)
Entry(self.frame, textvariable=text3).grid(row=10)
def afficheAlpha():
seismicPara["text"]="alpha"
betaVar.set(0)
allVar.set(0)
def afficheBeta():
seismicPara["text"]="beta"
alphaVar.set(0)
allVar.set(0)
def afficheAll():
seismicPara["text"]="all"
alphaVar.set(0)
betaVar.set(0)
seismicPara = Menubutton(self.frame, text="Seismic Parameter", relief=RAISED)
seismicPara.grid(row=0)
seismicPara.menu = Menu(seismicPara, tearoff = 0)
seismicPara["menu"] = seismicPara.menu
seismicPara.menu.add_checkbutton(label="alpha", variable = alphaVar, command = afficheAlpha)
seismicPara.menu.add_checkbutton(label="beta", variable = betaVar, command = afficheBeta)
seismicPara.menu.add_checkbutton(label="all", variable = allVar, command = afficheAll)
seismicPara.grid(row=11)
Label(self.frame, text="Filter name ?").grid(row=12)
Entry(self.frame, textvariable=text6b).grid(row=13)
Label(self.frame, text="time window t1 ?").grid(row=14)
Labelt1 = Label(self.frame, text="-->").grid(row=15)
Button(self.frame, text="time 1", command=self.time1).grid(row=15, column=1)
Label(self.frame, text="time window t2 ?").grid(row=16)
Labelt1 = Label(self.frame, text="-->").grid(row=17)
Button(self.frame, text="time 2", command=self.time2).grid(row=17, column=1)
'''
Label(self.frame, text="time window t3 ?").grid(row=18)
Labelt1 = Label(self.frame, text="-->").grid(row=19)
Button(self.frame, text="time 3", command=self.time3).grid(row=19, column=1)
Label(self.frame, text="time window t4 ?").grid(row=20)
Labelt1 = Label(self.frame, text="-->").grid(row=21)
Button(self.frame, text="time 4", command=self.time4).grid(row=21, column=1)
'''
def affiche0():
convertPara["text"]="No conversion"
text8_1.set(0)
def affiche1():
convertPara["text"]="Conversion"
text8_0.set(0)
convertPara = Menubutton(self.frame, text="Geodetic latitude to geocentric latitude conversion", relief=RAISED)
convertPara.grid(row=0)
convertPara.menu = Menu(convertPara, tearoff = 0)
convertPara["menu"] = convertPara.menu
convertPara.menu.add_checkbutton(label="No conversion", variable = text8_0, command = affiche0)
convertPara.menu.add_checkbutton(label="Conversion", variable = text8_1, command = affiche1)
convertPara.grid(row=22)
b = Checkbutton(self.frame, text = "apply filter", variable = filterVar)
b.grid(row=23, column = 0)
Button(self.frame, text="continue", command=self.quitter).grid(row=23, column=1)
class ParametersDialog(Toplevel):
# Constructor
def __init__(self, parent, title = None):
Toplevel.__init__(self, parent)
self.transient(parent)
if title:
self.title(title)
self._parent = parent
self._result = None
# Entry fields in the dialog
self._height_entry, self._width_entry = None, None
self._duration_entry, self._time_step_entry = None, None
self._env_file_entry, self._landmarks_entry = None, None
# Callbacks
self._random_landmarks_cb = None
# Set "use random landmarks" to true, so that a user doesn't have to come up with a data file
self._random_landmarks = IntVar()
self._random_landmarks.set(1)
self._do_random = True
body = Frame(self)
self.initial_focus = self.body(body)
body.pack(padx=5, pady=5)
self.buttonbox()
self.grab_set()
if not self.initial_focus:
self.initial_focus = self
self.protocol("WM_DELETE_WINDOW", self.cancel)
# Center the dialog on the screen
sw = self._parent.winfo_screenwidth()
sh = self._parent.winfo_screenheight()
w, h = sw * 0.5, sh * 0.2 # very large or small screen users might adjust this
x, y = int((sw - w) / 2), int((sh - h) / 2)
self.geometry("%dx%d+%d+%d" % (w, h, x ,y))
self.initial_focus.focus_set()
self.wait_window(self)
def result(self): return self._result
# The body of the dialog (not including the standard buttons like 'OK' and 'Cancel')
def body(self, master):
Label(
master,
text="Height of window:").grid(row=0, column=0, padx=10)
Label(
master,
text="Width of window:").grid(row=1, column=0, padx=10, pady=10)
Label(
master,
text="Duration (sec):").grid(row=0, column=2, padx=10)
Label(
master,
text="Time step (sec):").grid(row=1, column=2, padx=10, pady=10)
Label(
master,
text="Path to env file:").grid(row=2, column=0, padx=10)
Label(
master,
text="No. landmarks:").grid(row=2, column=2, padx=10)
# Default width and height should be relative to the screen size
w = int(self.winfo_screenwidth() * 0.3)
h = int(self.winfo_screenheight() * 0.2)
self._height_entry = Entry(master)
self._height_entry.grid(row=0, column=1)
self._height_entry.insert(END, str(h))
self._width_entry = Entry(master)
self._width_entry.grid(row=1, column=1)
self._width_entry.insert(END, str(w))
# Default duration is 2000 seconds, default time step is 1 second
self._duration_entry = Entry(master)
self._duration_entry.grid(row=0, column=3)
self._duration_entry.insert(END, str(2000))
self._time_step_entry = Entry(master)
self._time_step_entry.grid(row=1, column=3)
self._time_step_entry.insert(END, str(1))
# We default to random landmarks, so leave this entry field blank
self._env_file_entry = Entry(master, state='disabled')
self._env_file_entry.grid(row=2, column=1)
# Default to 10 landmarks
self._landmarks_entry = Entry(master)
self._landmarks_entry.grid(row=2, column=3)
self._landmarks_entry.insert(END, 10)
self._random_landmarks_cb = Checkbutton(
master,
text="Random Landmarks",
variable=self._random_landmarks,
command=lambda e1=self._env_file_entry,
e2=self._landmarks_entry,
e3=self._height_entry,
e4=self._width_entry,
v=self._random_landmarks:
self.random_landmarks_cb(
e1, e2, e3, e4, v))
self._random_landmarks_cb.grid(row=3, column=3, pady=10)
return self._height_entry # initial focus
# Standard button box
def buttonbox(self):
box = Frame(self)
w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
w.pack(side=LEFT, padx=5, pady=5)
w = Button(box, text="Cancel", width=10, command=self.cancel)
w.pack(side=LEFT, padx=5, pady=5)
# Bind the <Return> key to the ok action, and the <Escape> key to the cancel action
self.bind("<Return>", self.ok)
self.bind("<Escape>", self.cancel)
box.pack()
# Standard OK button and semantics
def ok(self, event=None):
if not self.validate():
self.initial_focus.focus_set() # put focus back
return
self.withdraw()
self.update_idletasks()
self.cancel()
# Standard Cancel button and semantics
def cancel(self, event=None):
self._parent.focus_set() # put focus back on parent window
self.destroy()
# Validate the input
def validate(self):
try:
h = int(self._height_entry.get())
w = int(self._width_entry.get())
dur = int(self._duration_entry.get())
dt = int(self._time_step_entry.get())
landmarks_count = int(self._landmarks_entry.get())
environ_file = None
if not self._do_random:
environ_file = self._env_file_entry.get()
self._result = (h, w, dur, dt, landmarks_count, environ_file, self._do_random)
return 1
except ValueError:
pass # TODO
return 0
# Checkbutton command
def random_landmarks_cb(self, env_entry, landmarks_entry, height_entry, width_entry, var):
if self._random_landmarks.get() == 1:
self._do_random = True
env_entry.configure(state='disabled')
height_entry.configure(state='normal')
width_entry.configure(state='normal')
landmarks_entry.configure(state='normal')
else:
self._do_random = False
env_entry.configure(state='normal')
height_entry.configure(state='disabled')
width_entry.configure(state='disabled')
landmarks_entry.configure(state='disabled')
class InterfaceExpansion(Frame):
def __init__(self, root, modifstruct, param_visu, mess):
"""!Creation de l'interface pour le calcul de condensation de la mesure
"""
Frame.__init__(self, root, relief='sunken', borderwidth=1)
self.root = root
self.modif_struct = modifstruct
self.param_visu = param_visu
self.mess = mess
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(2, weight=1)
self.rowconfigure(1, weight=1)
self.term = []
objects = self.root.objects
# Déclaration des variables Tk
self.var_resu_exp = StringVar()
self.condens_meth = StringVar()
self.var_modl_sup = StringVar()
self.var_grno_capt = StringVar()
self.var_grno_intf = StringVar()
self.var_raid_name = StringVar()
self.var_modlx = StringVar()
self.sumail_name = StringVar()
self.param_mode_iter_simult_lmme = None
self.param_dlg = None
# -----------------------------------------------------------------
# Titre
#
Label(self, text="Choix de la base d'expansion", font=self.root.font2
).grid(row=0, column=0, columnspan=3, sticky="ew")
# -----------------------------------------------------------------
# Definition du modele support
f = Frame(self)
f.grid(row=1, column=0, sticky='nsew', padx=60)
f.columnconfigure(0, weight=3)
# menu de selection des modes identifies
Label(f, text="Modes experimentaux").grid(row=0, column=0, sticky='w')
self.menu_resu_exp = MyMenu(f, objects.get_mode_meca_name(),
self.var_resu_exp, self.refresh_list_exp)
self.menu_resu_exp.grid(row=0, column=1, sticky='ew')
# menu de selection du modele support
Label(f, text="Modele support").grid(row=1, column=0, sticky='w')
self.menu_modl_sup = MyMenu(f, objects.get_model_name(),
self.var_modl_sup, self.modele_support_changed)
self.menu_modl_sup.grid(row=1, column=1, sticky='ew')
# menu de selection de la matrice de raideur assemblee du modele
# support
Label(f, text="Matrice raideur (support)",
justify='left').grid(row=2, column=0, sticky='w')
self.menu_raid_name = MyMenu(f, objects.get_matr_name(),
self.var_raid_name,
self.mat_raideur_changed)
self.menu_raid_name.grid(row=2, column=1, sticky='ew')
Label(f, text="Methode (base expansion)").grid(
row=3, column=0, sticky='w')
self.dic_condens_meth = {
"ES": "Expansion statique",
"LMME": "Expansion statique projetee",
}
self.menu_condens_meth = MyMenu(f, self.dic_condens_meth.keys(),
self.condens_meth,
self.condens_changed)
self.menu_condens_meth.grid(row=3, column=1, sticky='ew')
self.condens_meth.set("ES")
# menu selection du modele modification
Label(f, text="Modele modification").grid(row=4, column=0, sticky='w')
self.menu_modlx = MyMenu(f, objects.get_model_name(),
self.var_modlx, self.modele_modif_changed)
self.menu_modlx.grid(row=4, column=1, sticky='ew')
# menu de selection du groupe de noeuds capteur
self.capteur = SelectionNoeuds(f, "Noeuds et DDL capteur",
bg='#90a090', command=self.capteur_changed)
self.capteur.grid(row=5, column=0, columnspan=2, pady=3, sticky='ew')
# menu de selection du groupe de noeuds interface
self.iface = SelectionNoeuds(f, "Noeuds et DDL interface",
bg='#9090a0', command=self.iface_changed)
self.iface.grid(row=6, column=0, columnspan=2, pady=3, sticky='ew')
Label(f, text="Nom de la super maille : ").grid(
row=7, column=0, sticky='w')
Entry(f, textvariable=self.sumail_name).grid(row=7, column=1)
self.sumail_name.set("SUMAIL")
Button(f, text="Valider", command=self.anything_changed).grid(row=8,
column=1,
sticky='e')
# -----------------------------------------------------------------
# menu de selection des modes identifies experimentalement
f = Frame(self)
f.grid(row=1, column=1, sticky='nsew')
f.rowconfigure(0, weight=1)
self.liste_exp = ModeFreqList(f, "Modes du modele experimental")
self.liste_exp.grid(row=0, column=0, columnspan=2, sticky='nsew')
Button(f, text="Voir", command=self.view_model_exp).grid(row=1,
column=0,
columnspan=2)
# -----------------------------------------------------------------
# menu de selection de la methode pour
# le calcul de la base d'expansion
f = Frame(self)
f.grid(row=1, column=2, sticky='nsew')
f.rowconfigure(0, weight=1)
self.liste_sup = ModeFreqList(f, "Base d'expansion")
self.liste_sup.grid(row=0, column=0, sticky='snew')
Button(f, text="Voir", command=self.view_expansion).grid(
row=1, column=0)
self.reglage_lmme_visible = IntVar()
self.button_reglage_lmme = Checkbutton(f, text="Reglages LMME",
variable=self.reglage_lmme_visible,
command=self.show_param_dialog,
state='disabled', indicatoron=0)
self.reglage_lmme_visible.set(0)
self.button_reglage_lmme.grid(row=1, column=1)
self.configure_param_lmme_dialog()
def setup(self, mdo):
""" Actualisation des concepts dans les listes lorsqu'on a change de tab"""
self.menu_resu_exp.update(
mdo.get_mode_meca_name(), self.var_resu_exp, self.refresh_list_exp)
self.menu_modl_sup.update(
mdo.get_model_name(), self.var_modl_sup, self.modele_support_changed)
self.menu_modlx.update(
mdo.get_model_name(), self.var_modlx, self.modele_modif_changed)
def configure_param_lmme_dialog(self):
w = Toplevel()
w.protocol('WM_DELETE_WINDOW', self.hide_param_dialog)
self.param_dlg = w
w.withdraw() # cache la fenetre
w.rowconfigure(0, weight=1)
w.columnconfigure(0, weight=1)
prm = ParamModeLMME(
w, "Paramètres du calcul modal pour la méthode LMME",
relief='sunken', borderwidth=2)
prm.grid(row=0, column=0)
self.param_mode_iter_simult_lmme = prm
Button(w, text="Appliquer", command=self.anything_changed).grid(
row=1, column=0)
Button(w, text="OK", command=self.hide_param_dialog).grid(
row=2, column=0)
def show_param_dialog(self):
state = self.reglage_lmme_visible.get()
if state:
self.param_dlg.deiconify()
else:
self.param_dlg.withdraw()
def hide_param_dialog(self):
self.anything_changed()
self.reglage_lmme_visible.set(0)
self.param_dlg.withdraw()
def modele_support_changed(self):
"""Selectionne les matrices de raideur compatibles avec le modèle
support sélectionné
"""
obj_dict = CONTEXT.get_current_step().get_contexte_courant()
modsup = self.var_modl_sup.get()
# choix des matrices de raideur assemblees de ce modele support
mat_asse = self.root.objects.matrices.items()
mat_rigi = []
for name, obj in mat_asse:
LIME = obj.sdj.LIME.get()
if not LIME:
continue
for k in LIME:
obj = obj_dict[k.strip()]
refe = obj.sdj.RERR.get()
modl = refe[0].strip() # Modele
typ = refe[1].strip() # Type matrice (Masse ou raideur)
if typ == "RIGI_MECA" and modl == modsup:
mat_rigi.append(name)
self.menu_raid_name.update(
mat_rigi, self.var_raid_name, self.mat_raideur_changed)
old_rigi = self.var_raid_name.get()
if old_rigi not in mat_rigi:
self.var_raid_name.set(mat_rigi[0])
# choix des groupno capteur
self.capteur.set_modele(obj_dict[modsup], obj_dict)
self.iface.set_modele(obj_dict[modsup], obj_dict)
def refresh_list_exp(self):
resu_exp = self.var_resu_exp.get()
resu = self.root.objects.get_mode_meca(resu_exp)
self.liste_exp.set_resu(resu)
def anything_changed(self):
# if self.valid():
self.refresh_list_sup()
def condens_changed(self):
meth = self.condens_meth.get()
if meth == "ES":
self.button_reglage_lmme['state'] = 'disabled'
else:
self.button_reglage_lmme['state'] = 'normal'
self.anything_changed()
def group_no_capteur_changed(self):
"""modif : on ne fait les calculs qu'une fois qu'on a appuye sur "Valider" """
pass
# self.anything_changed()
def group_no_iface_changed(self):
"""modif : on ne fait les calculs qu'une fois qu'on a appuye sur "Valider" """
pass
# self.anything_changed()
def mat_raideur_changed(self):
self.anything_changed()
def modele_modif_changed(self):
self.anything_changed()
def iface_changed(self):
"""modif : on ne fait les calculs qu'une fois qu'on a appuye sur "Valider" """
pass
# self.anything_changed()
def capteur_changed(self):
"""modif : on ne fait les calculs qu'une fois qu'on a appuye sur "Valider" """
pass
# self.anything_changed())
def _can_set_modif_struct_para(self):
"""Renvoit True si tous les paramêtres pour calculer les modes
de la structure modifiée ont pu être obtenu."""
disp_mess = self.root.mess.disp_mess
retour = True
# resultat experimentaux
resu_exp_name = self.var_resu_exp.get()
try:
self.modif_struct.find_experimental_result_from(resu_exp_name)
except KeyError:
disp_mess("Il faut donner les donnees experimentales")
retour = False
# modele support
modlsup = self.var_modl_sup.get()
try:
self.modif_struct.find_support_modele_from(modlsup)
except KeyError:
disp_mess("Il faut donner un modele support")
retour = False
objects = self.modif_struct.objects
matr_rig = objects.get_matr(self.var_raid_name.get())
if matr_rig == None:
disp_mess((u"Il faut selectionner une matrice raideur "
u"parmi celles proposées!"))
retour = False
else:
self.modif_struct.set_stiffness_matrix(matr_rig)
self.modif_struct.set_method_name(self.condens_meth.get())
self.modif_struct.set_sumail_name(self.sumail_name.get())
grno_capt = self.capteur.get_selected()
if not grno_capt:
disp_mess(("Il faut selectionner un GROUP_NO capteur "
"parmi ceux proposes!"))
retour = False
else:
self.modif_struct.set_sensor_groups(grno_capt)
grno_iface = self.iface.get_selected()
self.modif_struct.set_interface_groups(grno_iface)
try:
self.modif_struct.find_maillage_modif_from(self.var_modlx.get())
except KeyError:
disp_mess("Il faut donner le modele associe a la modification")
retour = False
if retour == False:
disp_mess("calcul impossible !!")
return False
return True
def refresh_list_sup(self):
"""!Rafraichit la liste des vecteurs de base d'expansion
depend: var_raid_name, var_grno_capt
"""
if not self._can_set_modif_struct_para():
return
self.modif_struct.get_modele_support()
self.modif_struct.find_maillage_modif_from(self.var_modlx.get())
self.modif_struct.find_maillage_support_from(self.var_modl_sup.get())
self.modif_struct.find_modele_modif_from(self.var_modlx.get())
# Getting the frequency from the interface for the LMME method
calc_freq = None
if self.modif_struct.method_name == "LMME":
calc_freq = self.param_mode_iter_simult_lmme.get_calc_freq()
x_bsmo = self.modif_struct.calc_base_proj(calc_freq)
self.liste_sup.set_resu(x_bsmo)
# on sauve le nom du modele sup utilisé
# pour calculer la base d'expansion (pour affichage par GMSH)
# self.base_expansion_modl = modlsup
# self.base_expansion = self.modif_struct.base_expansion
self.root.expansion_completed()
def view_expansion(self):
"""!Visualisation de la base d'expansion par GMSH ou Salome
"""
if not self.modif_struct.base_expansion:
return
be = self.modif_struct.base_expansion.obj
# print be.dump(present=True,size=150)
# modl = self.root.objects.get_model(self.modif_struct.support_modele.nom)
# base_mod = Resultat(self.root.objects, be.nom,
# be, self.root.mess)
# Ordres a afficher
if self.modif_struct.method_name == "LMME":
modes_expansion = self.liste_sup.get_selection()
else:
modes_expansion = []
for num in self.liste_sup.get_selection():
node, comp = self.modif_struct.calc_base_es().get_modes_data()[
'NOEUD_CMP'][num - 1].split()
modes_expansion.append(node)
modes_expansion.append(comp)
# if not (isinstance(be,tuple) or isinstance(be,list)):
# be = tuple(be)
term = self.param_visu.visu_resu(resultat=be,
nume_mode=modes_expansion)
self.term.append(term)
def view_model_exp(self):
"""!Visualisation des modes identifies par GMSH ou Salome.
"""
resu_exp = self.var_resu_exp.get()
resu = self.root.objects.get_mode_meca(resu_exp)
# Modes a afficher
modes_ide = self.liste_exp.get_selection()
term = self.param_visu.visu_resu(resultat=resu.obj,
nume_mode=modes_ide)
self.term.append(term)
class GeneratorDialog:
# The UI to configure the settings by the user
def __init__(self, root, ctrl):
self.__root = root
self.__ctrl = ctrl
self.__pluginDir = os.path.dirname(
os.path.abspath(inspect.stack()[0][1]))
self.__ico = PhotoImage(file=self.__pluginDir +
'/pic/ScribusGenerator_logo.gif')
root.tk.call('wm', 'iconphoto', root._w, '-default', self.__ico)
def show(self):
self.__root.title(CONST.APP_NAME)
mainFrame = Frame(self.__root)
top = mainFrame.winfo_toplevel()
top.rowconfigure(0, weight=1)
top.columnconfigure(0, weight=1)
mainFrame.rowconfigure(0, weight=1)
mainFrame.columnconfigure(0, weight=1)
mainFrame.grid(sticky='ew')
# Three Sections: Input-Settings, Output-Settings and Buttons
inputFrame = LabelFrame(mainFrame, text='Input Settings')
inputFrame.columnconfigure(2, weight=1)
inputFrame.grid(column=0, row=0, padx=5, pady=5, sticky='ew')
outputFrame = LabelFrame(mainFrame, text='Output Settings')
outputFrame.columnconfigure(2, weight=1)
outputFrame.grid(column=0, row=1, padx=5, pady=5, sticky='ew')
buttonFrame = Frame(mainFrame)
buttonFrame.columnconfigure(3, weight=1)
buttonFrame.grid(column=0, row=2, padx=5, pady=5, sticky='ew')
# Input-Settings
scribusSourceFileLabel = Label(inputFrame,
text='Scribus File:',
width=15,
anchor='w')
scribusSourceFileLabel.grid(column=0,
row=0,
padx=5,
pady=5,
sticky='w')
scribusSourceFileEntry = Entry(
inputFrame,
textvariable=self.__ctrl.getScribusSourceFileEntryVariable())
scribusSourceFileEntry.grid(column=1,
columnspan=3,
row=0,
padx=5,
pady=5,
sticky='ew')
scribusSourceFileButton = Button(
inputFrame,
text='⏏',
command=self.__ctrl.scribusSourceFileEntryVariableHandler)
scribusSourceFileButton.grid(column=4,
row=0,
padx=5,
pady=5,
sticky='e')
scribusLoadSettingsButton = Button(
inputFrame,
text='↺',
command=self.__ctrl.scribusLoadSettingsHandler) # ⟲ ⟳ ↻ ↺ ⌂ ⌘ ⎗
scribusLoadSettingsButton.grid(column=5,
row=0,
padx=5,
pady=5,
sticky='e')
dataSourceFileLabel = Label(inputFrame,
text='Data File:',
width=15,
anchor='w')
dataSourceFileLabel.grid(column=0, row=1, padx=5, pady=5, sticky='w')
dataSourceFileEntry = Entry(
inputFrame,
textvariable=self.__ctrl.getDataSourceFileEntryVariable())
dataSourceFileEntry.grid(column=1,
columnspan=4,
row=1,
padx=5,
pady=5,
sticky='ew')
dataSourceFileButton = Button(
inputFrame,
text='⏏',
command=self.__ctrl.dataSourceFileEntryVariableHandler)
dataSourceFileButton.grid(column=5, row=1, padx=5, pady=5, sticky='e')
dataSeparatorLabel = Label(inputFrame,
text='Data Field Separator:',
width=15,
anchor='w')
dataSeparatorLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w')
dataSeparatorEntry = Entry(
inputFrame,
width=3,
textvariable=self.__ctrl.getDataSeparatorEntryVariable())
dataSeparatorEntry.grid(column=1, row=2, padx=5, pady=5, sticky='w')
fromLabel = Label(inputFrame,
text='(opt.) use partial data, only from:',
anchor='e')
fromLabel.grid(column=2, row=2, padx=5, pady=5, sticky='e')
fromEntry = Entry(inputFrame,
width=3,
textvariable=self.__ctrl.getFromVariable())
fromEntry.grid(column=3, row=2, padx=5, pady=5, sticky='w')
toLabel = Label(inputFrame, text='to:', width=3, anchor='e')
toLabel.grid(column=4, row=2, padx=5, pady=5, sticky='e')
toEntry = Entry(inputFrame,
width=3,
textvariable=self.__ctrl.getToVariable())
toEntry.grid(column=5, row=2, padx=5, pady=5, sticky='w')
# Output-Settings
outputDirectoryLabel = Label(outputFrame,
text='Output Directory:',
width=15,
anchor='w')
outputDirectoryLabel.grid(column=0, row=0, padx=5, pady=5, sticky='w')
outputDirectoryEntry = Entry(
outputFrame,
textvariable=self.__ctrl.getOutputDirectoryEntryVariable())
outputDirectoryEntry.grid(column=1,
columnspan=4,
row=0,
padx=5,
pady=5,
sticky='ew')
outputDirectoryButton = Button(
outputFrame,
text='⏏',
command=self.__ctrl.outputDirectoryEntryVariableHandler)
outputDirectoryButton.grid(column=5, row=0, padx=5, pady=5, sticky='e')
outputFileNameLabel = Label(outputFrame,
text='Output File Name:',
width=15,
anchor='w')
outputFileNameLabel.grid(column=0, row=1, padx=5, pady=5, sticky='w')
outputFileNameEntry = Entry(
outputFrame,
textvariable=self.__ctrl.getOutputFileNameEntryVariable())
outputFileNameEntry.grid(column=1,
columnspan=3,
row=1,
padx=5,
pady=5,
sticky='ew')
saveLabel = Label(outputFrame,
text='Save Settings:',
width=15,
anchor='w')
saveLabel.grid(column=4, row=1, padx=5, pady=5, sticky='w')
saveCheckbox = Checkbutton(
outputFrame, variable=self.__ctrl.getSaveCheckboxVariable())
saveCheckbox.grid(column=5, row=1, padx=5, pady=5, sticky='w')
mergeOutputLabel = Label(outputFrame,
text='Merge in Single File:',
width=15,
anchor='w')
mergeOutputLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w')
mergeOutputCheckbox = Checkbutton(
outputFrame, variable=self.__ctrl.getMergeOutputCheckboxVariable())
mergeOutputCheckbox.grid(column=1, row=2, padx=5, pady=5, sticky='w')
self.keepGeneratedScribusFilesLabel = Label(outputFrame,
text='Keep Scribus Files:',
width=15,
anchor='e')
self.keepGeneratedScribusFilesLabel.grid(column=4,
row=2,
padx=5,
pady=5,
sticky='e')
self.keepGeneratedScribusFilesCheckbox = Checkbutton(
outputFrame,
variable=self.__ctrl.getKeepGeneratedScribusFilesCheckboxVariable(
),
anchor='w')
self.keepGeneratedScribusFilesCheckbox.grid(column=5,
row=2,
padx=5,
pady=5,
sticky='w')
outputFormatLabel = Label(outputFrame,
text='Output Format:',
anchor='e')
outputFormatLabel.grid(column=2, row=2, padx=5, pady=5, sticky='e')
outputFormatListBox = OptionMenu(
outputFrame,
self.__ctrl.getSelectedOutputFormat(),
*self.__ctrl.getOutputFormatList(),
command=lambda v=self.__ctrl.getSelectedOutputFormat(
): self.updateState(v))
outputFormatListBox.grid(column=3, row=2, padx=5, pady=5, sticky='w')
# Bottom Buttons
generateButton = Button(buttonFrame,
text='✔\nGenerate',
width=10,
command=self.__ctrl.buttonOkHandler)
generateButton.grid(column=0, row=0, padx=5, pady=5, sticky='w')
cancelButton = Button(buttonFrame,
text='✘\nCancel',
width=10,
command=self.__ctrl.buttonCancelHandler)
cancelButton.grid(column=1, row=0, padx=5, pady=5, sticky='e')
helpButton = Button(buttonFrame,
text='❓\nHelp',
width=7,
command=self.__ctrl.helpButtonHandler)
helpButton.grid(column=3, row=0, padx=5, pady=5, sticky='e')
# general layout
mainFrame.grid()
self.__root.grid()
def updateState(self, value):
if (value == CONST.FORMAT_PDF):
self.keepGeneratedScribusFilesLabel.configure(state=NORMAL)
self.keepGeneratedScribusFilesCheckbox.configure(state=NORMAL)
else:
self.keepGeneratedScribusFilesLabel.configure(state=DISABLED)
self.keepGeneratedScribusFilesCheckbox.configure(state=DISABLED)
def __init__(self, master):
column0_padx = 24
row_pady = 36
#Label 1
lbl_testcase_exec = Label(master,
text="Test case execution",
wraplength=100,
anchor='w',
justify='left')
lbl_results_cmp = Label(master,
text="Results comparison",
wraplength=100,
justify='left')
lbl_tolerance = Label(master, text="Tolerance (5%)", wraplength=100)
testcase_exec = Checkbutton(master)
results_cmp = Checkbutton(master)
tolerance = Entry(master, width=4)
lbl_analysis = Label(master, text="Analysis Library")
analysis_lib = Entry(master, width=30)
lbl_testcase_exec.grid(row=0, column=2, padx=20, pady=12, sticky='w')
lbl_results_cmp.grid(row=0, column=3, pady=12, sticky='w')
lbl_tolerance.grid(row=0, column=4, padx=20, pady=12, sticky='wn')
lbl_analysis.grid(row=1, column=0, sticky='w', padx=column0_padx)
analysis_lib.grid(row=1, column=1, sticky='w')
testcase_exec.grid(row=1, column=2, padx=20, sticky='w')
results_cmp.grid(row=1, column=3, sticky='w')
tolerance.grid(row=1, column=4, padx=20, sticky='w')
#Label 2
lbl_ref_analysis = Label(master,
text="Reference Analysis Libary Version",
wraplength=150,
justify='left',
pady=row_pady)
ref_analysis_lib = Entry(master, width=30)
lbl_ref_analysis.grid(row=2, column=0, sticky='w', padx=column0_padx)
ref_analysis_lib.grid(row=2, column=1, sticky='w')
# version
lbl_version = Label(master, text="Version under Test")
version = Label(master, text="vA.B.C.D")
lbl_version.grid(row=3, column=0, sticky='w', padx=column0_padx)
version.grid(row=3, column=1, sticky='w')
# test all
lbl_testall = Label(master, text="Test All")
testall = Checkbutton(master)
lbl_testall.grid(row=4,
column=0,
pady=row_pady,
padx=column0_padx,
sticky='w')
testall.grid(row=4, column=1, sticky='w')
# buttons
bottom_frame = Frame(master)
bottom_frame.grid(row=5, column=1, columnspan=3, sticky='w')
btn_start = Button(bottom_frame, text="Go", width=7)
btn_start.pack(side='left')
btn_commit = Button(bottom_frame, text="Commit", width=7)
btn_commit.pack(side='left', padx=80)
btn_exit = Button(bottom_frame, text="Exit", width=7)
btn_exit.pack(side='left')
def show(self):
self.__root.title(CONST.APP_NAME)
mainFrame = Frame(self.__root)
top = mainFrame.winfo_toplevel()
top.rowconfigure(0, weight=1)
top.columnconfigure(0, weight=1)
mainFrame.rowconfigure(0, weight=1)
mainFrame.columnconfigure(0, weight=1)
mainFrame.grid(sticky='ew')
# Three Sections: Input-Settings, Output-Settings and Buttons
inputFrame = LabelFrame(mainFrame, text='Input Settings')
inputFrame.columnconfigure(2, weight=1)
inputFrame.grid(column=0, row=0, padx=5, pady=5, sticky='ew')
outputFrame = LabelFrame(mainFrame, text='Output Settings')
outputFrame.columnconfigure(2, weight=1)
outputFrame.grid(column=0, row=1, padx=5, pady=5, sticky='ew')
buttonFrame = Frame(mainFrame)
buttonFrame.columnconfigure(3, weight=1)
buttonFrame.grid(column=0, row=2, padx=5, pady=5, sticky='ew')
# Input-Settings
scribusSourceFileLabel = Label(inputFrame,
text='Scribus File:',
width=15,
anchor='w')
scribusSourceFileLabel.grid(column=0,
row=0,
padx=5,
pady=5,
sticky='w')
scribusSourceFileEntry = Entry(
inputFrame,
textvariable=self.__ctrl.getScribusSourceFileEntryVariable())
scribusSourceFileEntry.grid(column=1,
columnspan=3,
row=0,
padx=5,
pady=5,
sticky='ew')
scribusSourceFileButton = Button(
inputFrame,
text='⏏',
command=self.__ctrl.scribusSourceFileEntryVariableHandler)
scribusSourceFileButton.grid(column=4,
row=0,
padx=5,
pady=5,
sticky='e')
scribusLoadSettingsButton = Button(
inputFrame,
text='↺',
command=self.__ctrl.scribusLoadSettingsHandler) # ⟲ ⟳ ↻ ↺ ⌂ ⌘ ⎗
scribusLoadSettingsButton.grid(column=5,
row=0,
padx=5,
pady=5,
sticky='e')
dataSourceFileLabel = Label(inputFrame,
text='Data File:',
width=15,
anchor='w')
dataSourceFileLabel.grid(column=0, row=1, padx=5, pady=5, sticky='w')
dataSourceFileEntry = Entry(
inputFrame,
textvariable=self.__ctrl.getDataSourceFileEntryVariable())
dataSourceFileEntry.grid(column=1,
columnspan=4,
row=1,
padx=5,
pady=5,
sticky='ew')
dataSourceFileButton = Button(
inputFrame,
text='⏏',
command=self.__ctrl.dataSourceFileEntryVariableHandler)
dataSourceFileButton.grid(column=5, row=1, padx=5, pady=5, sticky='e')
dataSeparatorLabel = Label(inputFrame,
text='Data Field Separator:',
width=15,
anchor='w')
dataSeparatorLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w')
dataSeparatorEntry = Entry(
inputFrame,
width=3,
textvariable=self.__ctrl.getDataSeparatorEntryVariable())
dataSeparatorEntry.grid(column=1, row=2, padx=5, pady=5, sticky='w')
fromLabel = Label(inputFrame,
text='(opt.) use partial data, only from:',
anchor='e')
fromLabel.grid(column=2, row=2, padx=5, pady=5, sticky='e')
fromEntry = Entry(inputFrame,
width=3,
textvariable=self.__ctrl.getFromVariable())
fromEntry.grid(column=3, row=2, padx=5, pady=5, sticky='w')
toLabel = Label(inputFrame, text='to:', width=3, anchor='e')
toLabel.grid(column=4, row=2, padx=5, pady=5, sticky='e')
toEntry = Entry(inputFrame,
width=3,
textvariable=self.__ctrl.getToVariable())
toEntry.grid(column=5, row=2, padx=5, pady=5, sticky='w')
# Output-Settings
outputDirectoryLabel = Label(outputFrame,
text='Output Directory:',
width=15,
anchor='w')
outputDirectoryLabel.grid(column=0, row=0, padx=5, pady=5, sticky='w')
outputDirectoryEntry = Entry(
outputFrame,
textvariable=self.__ctrl.getOutputDirectoryEntryVariable())
outputDirectoryEntry.grid(column=1,
columnspan=4,
row=0,
padx=5,
pady=5,
sticky='ew')
outputDirectoryButton = Button(
outputFrame,
text='⏏',
command=self.__ctrl.outputDirectoryEntryVariableHandler)
outputDirectoryButton.grid(column=5, row=0, padx=5, pady=5, sticky='e')
outputFileNameLabel = Label(outputFrame,
text='Output File Name:',
width=15,
anchor='w')
outputFileNameLabel.grid(column=0, row=1, padx=5, pady=5, sticky='w')
outputFileNameEntry = Entry(
outputFrame,
textvariable=self.__ctrl.getOutputFileNameEntryVariable())
outputFileNameEntry.grid(column=1,
columnspan=3,
row=1,
padx=5,
pady=5,
sticky='ew')
saveLabel = Label(outputFrame,
text='Save Settings:',
width=15,
anchor='w')
saveLabel.grid(column=4, row=1, padx=5, pady=5, sticky='w')
saveCheckbox = Checkbutton(
outputFrame, variable=self.__ctrl.getSaveCheckboxVariable())
saveCheckbox.grid(column=5, row=1, padx=5, pady=5, sticky='w')
mergeOutputLabel = Label(outputFrame,
text='Merge in Single File:',
width=15,
anchor='w')
mergeOutputLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w')
mergeOutputCheckbox = Checkbutton(
outputFrame, variable=self.__ctrl.getMergeOutputCheckboxVariable())
mergeOutputCheckbox.grid(column=1, row=2, padx=5, pady=5, sticky='w')
self.keepGeneratedScribusFilesLabel = Label(outputFrame,
text='Keep Scribus Files:',
width=15,
anchor='e')
self.keepGeneratedScribusFilesLabel.grid(column=4,
row=2,
padx=5,
pady=5,
sticky='e')
self.keepGeneratedScribusFilesCheckbox = Checkbutton(
outputFrame,
variable=self.__ctrl.getKeepGeneratedScribusFilesCheckboxVariable(
),
anchor='w')
self.keepGeneratedScribusFilesCheckbox.grid(column=5,
row=2,
padx=5,
pady=5,
sticky='w')
outputFormatLabel = Label(outputFrame,
text='Output Format:',
anchor='e')
outputFormatLabel.grid(column=2, row=2, padx=5, pady=5, sticky='e')
outputFormatListBox = OptionMenu(
outputFrame,
self.__ctrl.getSelectedOutputFormat(),
*self.__ctrl.getOutputFormatList(),
command=lambda v=self.__ctrl.getSelectedOutputFormat(
): self.updateState(v))
outputFormatListBox.grid(column=3, row=2, padx=5, pady=5, sticky='w')
# Bottom Buttons
generateButton = Button(buttonFrame,
text='✔\nGenerate',
width=10,
command=self.__ctrl.buttonOkHandler)
generateButton.grid(column=0, row=0, padx=5, pady=5, sticky='w')
cancelButton = Button(buttonFrame,
text='✘\nCancel',
width=10,
command=self.__ctrl.buttonCancelHandler)
cancelButton.grid(column=1, row=0, padx=5, pady=5, sticky='e')
helpButton = Button(buttonFrame,
text='❓\nHelp',
width=7,
command=self.__ctrl.helpButtonHandler)
helpButton.grid(column=3, row=0, padx=5, pady=5, sticky='e')
# general layout
mainFrame.grid()
self.__root.grid()
class TrackSelect(tkSimpleDialog.Dialog):
def __init__(self, master, **kwargs):
self.vid = {'title': "this video"}
self.tracks = []
for k in kwargs:
k = k.lower()
if k == "master":
self.master = kwargs[k]
continue
if k == "vid":
self.vid = kwargs[k]
continue
if k == "tracks":
self.tracks = kwargs[k]
continue
self.padx = 3
self.pady = 3
self.prefl = IntVar()
self.preft = IntVar()
self.preflang = None
self.prefname = None
tkSimpleDialog.Dialog.__init__(self, master, "Select caption track")
def body(self, master):
Label(master, text="%s contains multiple caption tracks" %
self.vid['title']).grid(row=0, padx=self.padx, pady=self.pady,
sticky=W, columnspan=5)
self.__langlist(master)
self.chosenlangbut = Button(master, text="->",
command=self.__chooselang)
self.chosenlangbut.grid(row=1, column=2, padx=self.padx,
pady=self.pady)
self.__tracklist(master)
self.__fillLangs()
return self.langsel # initial focus
def __tracklist(self, master):
self.trackYscroll = Scrollbar(master, orient=HORIZONTAL)
self.trackXscroll = Scrollbar(master, orient=VERTICAL)
self.tracksel = Listbox(master,
xscrollcommand=self.trackXscroll.set,
yscrollcommand=self.trackYscroll.set,
selectmode=SINGLE)
self.tracksel.grid(row=1, column=3, sticky=N + S + E + W)
self.trackXscroll.grid(row=1, column=4, sticky=W + N + S)
self.trackYscroll.grid(row=2, column=3, stick=N + E + W)
self.trackXscroll.config(command=self.tracksel.xview)
self.trackYscroll.config(command=self.tracksel.yview)
self.preftracksel = Checkbutton(master,
variable=self.preft,
text="Set default track name")
self.preftracksel.grid(row=3, column=3, sticky=W)
def __langlist(self, master):
self.langYscroll = Scrollbar(master, orient=HORIZONTAL)
self.langXscroll = Scrollbar(master, orient=VERTICAL)
self.langsel = Listbox(master,
xscrollcommand=self.langXscroll.set,
yscrollcommand=self.langYscroll.set,
selectmode=SINGLE, width=6)
self.langsel.grid(row=1, column=0, sticky=N + S + E + W)
self.langXscroll.grid(row=1, column=1, sticky=W + N + S)
self.langYscroll.grid(row=2, column=0, stick=N + E + W)
self.langXscroll.config(command=self.langsel.xview)
self.langYscroll.config(command=self.langsel.yview)
self.preflangsel = Checkbutton(master,
variable=self.prefl,
text="Set default language")
self.preflangsel.grid(row=3, column=0, sticky=W)
def __fillLangs(self):
self.langsadded = []
for track in self.tracks:
lang = track['lang']
if lang not in self.langsadded:
self.langsel.insert(END, lang)
self.langsadded.append(lang)
def __chooselang(self):
lang = self.langsadded[int(self.langsel.curselection()[0])]
self.langselected = lang
self.trackoptions = []
self.tracksel.delete(0, END)
for track in self.tracks:
if track['lang'] == lang:
name = 'Default' if len(track['name']) == 0 else track['name']
self.tracksel.insert(END, name)
self.trackoptions.append(track)
self.tracksel.activate(0)
self.tracksel.selection_set(0)
def apply(self):
selected = int(self.tracksel.curselection()[0])
self.result = [self.trackoptions[selected]]
if int(self.prefl.get()) == 1:
self.preflang = self.langselected
if int(self.preft.get()) == 1:
self.prefname = self.trackoptions[
int(self.tracksel.curselection()[0])]['name']
def buttonbox(self):
box = Frame(self)
w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
w.pack(side=LEFT, padx=5, pady=5)
w = Button(box, text="Skip", width=10, command=self.cancel)
w.pack(side=LEFT, padx=5, pady=5)
self.bind("<Return>", self.ok)
self.bind("<Escape>", self.cancel)
box.pack()
class IrdaSimulator():
def __init__(self, dispatcher):
self.dispatcher = dispatcher
self.playing_led = None
thread = Thread(target=self.initial_simulator)
thread.start()
def initial_simulator(self):
root = Tk()
root.title("Irda Simulator")
track_list_prev = Button(
root, text="CH-", command=self.track_list_prev)
track_list_enter = Button(
root, text="CH", command=self.track_list_enter)
track_list_next = Button(
root, text="CH+", command=self.track_list_next)
player_prev = Button(root, text="|<<", command=self.player_prev)
player_next = Button(root, text=">>|", command=self.player_next)
player_play_pause = Button(
root, text=">||", command=self.player_play_pause)
vol_down = Button(root, text="vol -", command=self.vol_down)
vol_up = Button(root, text="vol +", command=self.vol_up)
change_lang = Button(root, text="EQ", command=self.change_lang)
num0 = Button(root, text="0", command=self.num0)
backlight_down = Button(root, text="FL-", command=self.backlight_down)
backlight_up = Button(root, text="FL+", command=self.backlight_up)
num1 = Button(root, text="1", command=self.num1)
lib_root_dir = Button(root, text="2", command=self.lib_root_dir)
num3 = Button(root, text="3", command=self.num3)
lib_prev = Button(root, text="4", command=self.lib_prev)
lib_enter = Button(root, text="5", command=self.lib_enter)
lib_next = Button(root, text="6", command=self.lib_next)
lib_audiobook = Button(root, text="7", command=self.lib_audiobook)
lib_radio = Button(root, text="8", command=self.lib_radio)
lib_music = Button(root, text="9", command=self.lib_music)
self.playing_led = Checkbutton(text="playing_led", state=DISABLED)
track_list_prev.grid(row=0, column=1)
track_list_enter.grid(row=0, column=2)
track_list_next.grid(row=0, column=3)
player_prev.grid(row=1, column=1)
player_next.grid(row=1, column=2)
player_play_pause.grid(row=1, column=3)
vol_down.grid(row=2, column=1)
vol_up.grid(row=2, column=2)
change_lang.grid(row=2, column=3)
num0.grid(row=3, column=1)
backlight_down.grid(row=3, column=2)
backlight_up.grid(row=3, column=3)
num1.grid(row=4, column=1)
lib_root_dir.grid(row=4, column=2)
num3.grid(row=4, column=3)
lib_prev.grid(row=5, column=1)
lib_enter.grid(row=5, column=2)
lib_next.grid(row=5, column=3)
lib_audiobook.grid(row=6, column=1)
lib_radio.grid(row=6, column=2)
lib_music.grid(row=6, column=3)
self.playing_led.grid(row=7, column=1)
root.mainloop()
def track_list_prev(self):
self.dispatcher.handleCommand('track_list_prev')
def track_list_enter(self):
self.dispatcher.handleCommand('track_list_enter')
def track_list_next(self):
self.dispatcher.handleCommand('track_list_next')
def player_prev(self):
self.dispatcher.handleCommand('player_prev')
def player_next(self):
self.dispatcher.handleCommand('player_next')
def player_play_pause(self):
self.dispatcher.handleCommand('player_play_pause')
def vol_down(self):
self.dispatcher.handleCommand('vol_down')
def vol_up(self):
self.dispatcher.handleCommand('vol_up')
def change_lang(self):
self.dispatcher.handleCommand('change_lang')
def num0(self):
self.dispatcher.handleCommand('num0')
def backlight_down(self):
self.dispatcher.handleCommand('backlight_down')
def backlight_up(self):
self.dispatcher.handleCommand('backlight_up')
def num1(self):
self.dispatcher.handleCommand('num1')
def lib_root_dir(self):
self.dispatcher.handleCommand('lib_root_dir')
def num3(self):
self.dispatcher.handleCommand('num3')
def lib_prev(self):
self.dispatcher.handleCommand('lib_prev')
def lib_enter(self):
self.dispatcher.handleCommand('lib_enter')
def lib_next(self):
self.dispatcher.handleCommand('lib_next')
def lib_audiobook(self):
self.dispatcher.handleCommand('lib_audiobook')
def lib_radio(self):
self.dispatcher.handleCommand('lib_radio')
def lib_music(self):
self.dispatcher.handleCommand('lib_music')
def initUIGlobals(self):
self.parent.title("Ini Generator")
Style().configure("TButton", padding=(0, 0, 0, 0), font='serif 10')
f1 = Frame(self)
f1.grid(row=0, column=0, padx=10, sticky=N + S + E + W)
f11 = LabelFrame(f1, text="Algorithms to Run")
f11.grid(row=0, column=0)
row = 0
self.check_algs_value_list = []
self.check_algs_map = {}
for alg in algorithms:
if alg == 'clean':
continue
check_alg_value = IntVar()
check_alg = Checkbutton(f11,
text=alg,
variable=check_alg_value,
justify=LEFT,
width=25)
check_alg.grid(row=row, column=0, sticky=W + E)
self.check_algs_value_list.append(check_alg_value)
self.check_algs_map[alg] = check_alg_value
row += 1
f111 = Frame(f11)
f111.grid(row=row, column=0)
button_checkall = Button(f111, text="All", command=self.checkall)
button_checkall.grid(row=0, column=0, sticky=W + E)
button_uncheckall = Button(f111, text="None", command=self.uncheckall)
button_uncheckall.grid(row=0, column=1, sticky=W + E)
row = 0
f12 = Frame(f1)
f12.grid(row=1, column=0, pady=20, sticky=S + W + E)
f121 = LabelFrame(f12, text='Location of uPMU')
f121.grid(row=0, column=0)
self.radio_loc_string = StringVar()
locations.append('Other Location')
for loc in locations:
radio_loc = Radiobutton(f121,
text=loc,
variable=self.radio_loc_string,
value=loc,
command=self.set_loc,
justify=LEFT,
width=25)
radio_loc.grid(row=row, column=0, sticky=W + E)
row += 1
self.entry_otherloc = Entry(f121)
f2 = Frame(self)
f2.grid(row=0, column=1, padx=10, sticky=N + S + E + W)
f21 = LabelFrame(f2, text='Name of uPMU (raw)')
f21.grid(row=0)
row = 0
f211 = Frame(f21)
f211.grid(row=row)
row += 1
self.entry_namesearch = Entry(f211)
self.entry_namesearch.grid(row=0, column=0, sticky=E + W)
button_namesearch = Button(f211,
text="Search",
command=self.namesearch)
button_namesearch.grid(row=0, column=1, sticky=W + E)
self.lstbx_namelist = Listbox(f21)
self.lstbx_namelist.bind("<Double-Button-1>", self.namelist_select)
self.lstbx_namelist.grid(row=row, sticky=W + E)
row += 1
f212 = Frame(f21)
f212.grid(row=row)
row += 1
label_nameselected = Label(f212, text="Selected:")
label_nameselected.grid(row=0, column=0)
self.entry_nameselected = Entry(f212, state=DISABLED)
self.entry_nameselected.grid(row=0, column=1, sticky=W + E)
f22 = LabelFrame(f2, text="Name of uPMU (abbr)")
f22.grid(row=1, sticky=W + E, pady=10)
self.entry_name = Entry(f22, width=30)
self.entry_name.grid(row=0, column=0, sticky=E + W)
f23 = LabelFrame(f2, text="Name of Reference uPMU (clean)")
f23.grid(row=2, pady=10)
row = 0
f231 = Frame(f23)
f231.grid(row=row)
row += 1
self.entry_refnamesearch = Entry(f231)
self.entry_refnamesearch.grid(row=0, column=0, sticky=E + W)
button_refnamesearch = Button(f231,
text="Search",
command=self.refnamesearch)
button_refnamesearch.grid(row=0, column=1, sticky=W + E)
self.lstbx_refnamelist = Listbox(f23)
self.lstbx_refnamelist.bind("<Double-Button-1>",
self.refnamelist_select)
self.lstbx_refnamelist.grid(row=row, sticky=W + E)
row += 1
f232 = Frame(f23)
f232.grid(row=row)
row += 1
label_refnameselected = Label(f232, text="Selected:")
label_refnameselected.grid(row=0, column=0)
self.entry_refnameselected = Entry(f232, state=DISABLED)
self.entry_refnameselected.grid(row=0, column=1, sticky=W + E)
button_gen = Button(self,
text="Generate Files",
command=self.generate_files)
button_gen.grid(row=1, column=0, columnspan=2, sticky=W + E)
self.pack()
class Screen(Observer):
def __init__(self, parent, model_x, model_y, bg="white"):
self.canvas = Canvas(parent, bg=bg)
self.model_x = model_x
self.model_y = model_y
print("parent", parent.cget("width"), parent.cget("height"))
self.showX = True
self.showY = True
self.frame = Frame(parent)
# Signal X
self.magnitude_x = Scale(self.frame,
length=250,
orient="horizontal",
name="m_x",
label="Magnitude X",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.frequency_x = Scale(self.frame,
length=250,
orient="horizontal",
name="f_x",
label="Frequency X",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.phase_x = Scale(self.frame,
length=250,
orient="horizontal",
name="p_x",
label="Phase X",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
# Signal Y
self.magnitude_y = Scale(self.frame,
length=250,
orient="horizontal",
name="m_y",
label="Magnitude Y",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.frequency_y = Scale(self.frame,
length=250,
orient="horizontal",
name="f_y",
label="Frequency Y",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.phase_y = Scale(self.frame,
length=250,
orient="horizontal",
name="p_y",
label="Phase Y",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.frame2 = Frame(parent, bg="black")
self.varX = IntVar()
self.varY = IntVar()
self.varXY = IntVar()
self.lbl = Label(self.frame2, text="Courbes", fg="black")
# Boutons de sélection (X, Y ou X-Y)
self.caseX = Checkbutton(self.frame2,
text="X",
variable=self.varX,
command=self.getX)
self.caseY = Checkbutton(self.frame2,
text="Y",
variable=self.varY,
command=self.getY)
self.caseXY = Checkbutton(self.frame2,
text="XY",
variable=self.varXY,
command=self.getXY)
self.caseXY.select()
self.wi = self.canvas.cget("width")
self.hi = self.canvas.cget("height")
self.stepx = 0
self.stepy = 0
# Step x
self.step_x = Entry(parent, name="x")
# Step y
self.step_y = Entry(parent, name="y")
def update(self, model):
print("View update")
if model.getId() == 0:
signal = model.get_signal()
self.plot_signal(signal)
elif model.getId() == 1:
signal = model.get_signal()
self.plot_signal(signal, "blue")
else:
raise ("Error")
# Signal X
def get_magnitude(self, whichOne):
if whichOne == 0:
return self.magnitude_x
elif whichOne == 1:
return self.magnitude_y
else:
raise ("Error")
def get_frequency(self, whichOne):
if whichOne == 0:
return self.frequency_x
elif whichOne == 1:
return self.frequency_y
else:
raise ("Error")
def get_phase(self, whichOne):
if whichOne == 0:
return self.phase_x
elif whichOne == 1:
return self.phase_y
else:
raise ("Error")
def get_step_x(self):
return self.step_x
def get_step_y(self):
return self.step_y
def getX(self):
print("update_X(self,event)")
self.caseY.deselect()
self.caseXY.deselect()
self.showX = True
self.showY = False
self.update(self.model_x)
if self.canvas.find_withtag("signal_y"):
self.canvas.delete("signal_y")
def getY(self):
print("update_Y(self,event)")
self.caseX.deselect()
self.caseXY.deselect()
self.showX = False
self.showY = True
self.update(self.model_y)
if self.canvas.find_withtag("signal_x"):
self.canvas.delete("signal_x")
def getXY(self):
print("update_XY(self,event)")
self.caseX.deselect()
self.caseY.deselect()
self.showX = True
self.showY = True
self.update(self.model_x)
self.update(self.model_y)
def plot_signal(self, signal, color="red"):
w, h = self.wi, self.hi
width, height = int(w), int(h)
if color == "red" and self.showX == True:
if self.canvas.find_withtag("signal_x"):
self.canvas.delete("signal_x")
if signal and len(signal) > 1:
plot = [(x * width, height / 2.0 * (y + 1))
for (x, y) in signal]
signal_id = self.canvas.create_line(plot,
fill=color,
smooth=1,
width=3,
tags="signal_x")
elif color == "blue" and self.showY == True:
if self.canvas.find_withtag("signal_y"):
self.canvas.delete("signal_y")
if signal and len(signal) > 1:
plot = [(x * width, height / 2.0 * (y + 1))
for (x, y) in signal]
signal_id = self.canvas.create_line(plot,
fill=color,
smooth=1,
width=3,
tags="signal_y")
def grid(self, step_x, step_y):
w, h = self.wi, self.hi
width, height = int(w), int(h)
self.stepx = (width - 10) / step_x * 1.
self.stepy = (height - 10) / step_y * 1.
for t in range(1, step_x + 2):
x = t * self.stepx
self.canvas.create_line(x, 0, x, height, tags="grid")
#self.canvas.create_line(x,height/2-4,x,height/2+4)
for t in range(1, step_y + 2):
y = t * self.stepy
self.canvas.create_line(0, y, width, y, tags="grid")
#self.canvas.create_line(width/2-4,y,width/2+4,y)
def resize(self, event):
if event:
self.wi = event.width
self.hi = event.height
self.canvas.delete("grid")
self.plot_signal(self.model_x.get_signal())
self.plot_signal(self.model_y.get_signal(), "blue")
self.grid(25, 25)
def packing(self):
self.canvas.pack(fill="both", expand=1)
self.step_x.pack(expand=1, fill="both")
self.step_y.pack(expand=1, fill="both")
self.frame.pack(expand=1, fill="both")
self.magnitude_x.grid(row=0, column=0)
self.magnitude_y.grid(row=0, column=1)
self.frequency_x.grid(row=1, column=0)
self.frequency_y.grid(row=1, column=1)
self.phase_x.grid(row=2, column=0)
self.phase_y.grid(row=2, column=1)
self.frame2.pack(side="bottom", expand=1)
self.lbl.grid(row=0, column=0)
self.caseX.grid(row=0, column=1)
self.caseY.grid(row=0, column=2)
self.caseXY.grid(row=0, column=3)
class wm_seg:
"""
Simple GUI application
If the application inside a container, automatic updates are removed.
The application uses two frames (tabs):
- training
- testing
"""
def __init__(self, master, container):
self.master = master
master.title("nicMSlesions")
# running on a container
self.container = container
# gui attributes
self.path = os.getcwd()
self.default_config = None
self.user_config = None
self.current_folder = os.getcwd()
self.list_train_pretrained_nets = []
self.list_test_nets = []
self.version = __version__
if self.container is False:
# version_number
self.commit_version = subprocess.check_output(
['git', 'rev-parse', 'HEAD'])
# queue and thread parameters. All processes are embedded
# inside threads to avoid freezing the application
self.train_task = None
self.test_task = None
self.test_queue = Queue.Queue()
self.train_queue = Queue.Queue()
# --------------------------------------------------
# parameters. Mostly from the config/*.cfg files
# --------------------------------------------------
# data parameters
self.param_training_folder = StringVar()
self.param_test_folder = StringVar()
self.param_FLAIR_tag = StringVar()
self.param_T1_tag = StringVar()
self.param_MOD3_tag = StringVar()
self.param_MOD4_tag = StringVar()
self.param_mask_tag = StringVar()
self.param_model_tag = StringVar()
self.param_register_modalities = BooleanVar()
self.param_skull_stripping = BooleanVar()
self.param_denoise = BooleanVar()
self.param_denoise_iter = IntVar()
self.param_save_tmp = BooleanVar()
self.param_debug = BooleanVar()
# train parameters
self.param_net_folder = os.path.join(self.current_folder, 'nets')
self.param_use_pretrained_model = BooleanVar()
self.param_pretrained_model = StringVar()
self.param_inference_model = StringVar()
self.param_num_layers = IntVar()
self.param_net_name = StringVar()
self.param_net_name.set('None')
self.param_balanced_dataset = StringVar()
self.param_fract_negatives = DoubleVar()
# model parameters
self.param_pretrained = None
self.param_min_th = DoubleVar()
self.param_patch_size = IntVar()
self.param_weight_paths = StringVar()
self.param_load_weights = BooleanVar()
self.param_train_split = DoubleVar()
self.param_max_epochs = IntVar()
self.param_patience = IntVar()
self.param_batch_size = IntVar()
self.param_net_verbose = IntVar()
self.param_t_bin = DoubleVar()
self.param_l_min = IntVar()
self.param_min_error = DoubleVar()
self.param_mode = BooleanVar()
self.param_gpu_number = IntVar()
# load the default configuration from the conf file
self.load_default_configuration()
# self frame (tabbed notebook)
self.note = Notebook(self.master)
self.note.pack()
os.system('cls' if platform.system() == 'Windows' else 'clear')
print "##################################################"
print "# ------------ #"
print "# nicMSlesions #"
print "# ------------ #"
print "# MS WM lesion segmentation #"
print "# #"
print "# ------------------------------- #"
print "# (c) Sergi Valverde 2018 #"
print "# Neuroimage Computing Group #"
print "# ------------------------------- #"
print "##################################################\n"
print "Please select options for training or inference in the menu..."
# --------------------------------------------------
# training tab
# --------------------------------------------------
self.train_frame = Frame()
self.note.add(self.train_frame, text="Training")
self.test_frame = Frame()
self.note.add(self.test_frame, text="Inference")
# label frames
cl_s = 5
self.tr_frame = LabelFrame(self.train_frame, text="Training images:")
self.tr_frame.grid(row=0,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
self.model_frame = LabelFrame(self.train_frame, text="CNN model:")
self.model_frame.grid(row=5,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
# training options
self.inFolderLbl = Label(self.tr_frame, text="Training folder:")
self.inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2)
self.inFolderTxt = Entry(self.tr_frame)
self.inFolderTxt.grid(row=0,
column=1,
columnspan=5,
sticky="W",
pady=3)
self.inFileBtn = Button(self.tr_frame,
text="Browse ...",
command=self.load_training_path)
self.inFileBtn.grid(row=0,
column=5,
columnspan=1,
sticky='W',
padx=5,
pady=1)
self.optionsBtn = Button(self.tr_frame,
text="Other options",
command=self.parameter_window)
self.optionsBtn.grid(row=0,
column=10,
columnspan=1,
sticky="W",
padx=(100, 1),
pady=1)
# setting input modalities: FLAIR + T1 are mandatory
# Mod 3 / 4 are optional
self.flairTagLbl = Label(self.tr_frame, text="FLAIR tag:")
self.flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2)
self.flairTxt = Entry(self.tr_frame, textvariable=self.param_FLAIR_tag)
self.flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1)
self.t1TagLbl = Label(self.tr_frame, text="T1 tag:")
self.t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2)
self.t1Txt = Entry(self.tr_frame, textvariable=self.param_T1_tag)
self.t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1)
self.mod3TagLbl = Label(self.tr_frame, text="mod 3 tag:")
self.mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2)
self.mod3Txt = Entry(self.tr_frame, textvariable=self.param_MOD3_tag)
self.mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1)
self.mod4TagLbl = Label(self.tr_frame, text="mod 4 tag:")
self.mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2)
self.mod4Txt = Entry(self.tr_frame, textvariable=self.param_MOD4_tag)
self.mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1)
self.maskTagLbl = Label(self.tr_frame, text="MASK tag:")
self.maskTagLbl.grid(row=5, column=0, sticky='E', padx=5, pady=2)
self.maskTxt = Entry(self.tr_frame, textvariable=self.param_mask_tag)
self.maskTxt.grid(row=5, column=1, columnspan=1, sticky="W", pady=1)
# model options
self.modelTagLbl = Label(self.model_frame, text="Model name:")
self.modelTagLbl.grid(row=6, column=0, sticky='E', padx=5, pady=2)
self.modelTxt = Entry(self.model_frame,
textvariable=self.param_net_name)
self.modelTxt.grid(row=6, column=1, columnspan=1, sticky="W", pady=1)
self.checkPretrain = Checkbutton(self.model_frame,
text="use pretrained",
var=self.param_use_pretrained_model)
self.checkPretrain.grid(row=6, column=3, padx=5, pady=5)
self.update_pretrained_nets()
self.pretrainTxt = OptionMenu(self.model_frame,
self.param_pretrained_model,
*self.list_train_pretrained_nets)
self.pretrainTxt.grid(row=6, column=5, sticky='E', padx=5, pady=5)
# START button links
self.trainingBtn = Button(self.train_frame,
state='disabled',
text="Start training",
command=self.train_net)
self.trainingBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1)
# --------------------------------------------------
# inference tab
# --------------------------------------------------
self.tt_frame = LabelFrame(self.test_frame, text="Inference images:")
self.tt_frame.grid(row=0,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
self.test_model_frame = LabelFrame(self.test_frame, text="CNN model:")
self.test_model_frame.grid(row=5,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
# testing options
self.test_inFolderLbl = Label(self.tt_frame, text="Testing folder:")
self.test_inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2)
self.test_inFolderTxt = Entry(self.tt_frame)
self.test_inFolderTxt.grid(row=0,
column=1,
columnspan=5,
sticky="W",
pady=3)
self.test_inFileBtn = Button(self.tt_frame,
text="Browse ...",
command=self.load_testing_path)
self.test_inFileBtn.grid(row=0,
column=5,
columnspan=1,
sticky='W',
padx=5,
pady=1)
self.test_optionsBtn = Button(self.tt_frame,
text="Other options",
command=self.parameter_window)
self.test_optionsBtn.grid(row=0,
column=10,
columnspan=1,
sticky="W",
padx=(100, 1),
pady=1)
self.test_flairTagLbl = Label(self.tt_frame, text="FLAIR tag:")
self.test_flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2)
self.test_flairTxt = Entry(self.tt_frame,
textvariable=self.param_FLAIR_tag)
self.test_flairTxt.grid(row=1,
column=1,
columnspan=1,
sticky="W",
pady=1)
self.test_t1TagLbl = Label(self.tt_frame, text="T1 tag:")
self.test_t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2)
self.test_t1Txt = Entry(self.tt_frame, textvariable=self.param_T1_tag)
self.test_t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1)
self.test_mod3TagLbl = Label(self.tt_frame, text="mod 3 tag:")
self.test_mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2)
self.test_mod3Txt = Entry(self.tt_frame,
textvariable=self.param_MOD3_tag)
self.test_mod3Txt.grid(row=3,
column=1,
columnspan=1,
sticky="W",
pady=1)
self.test_mod4TagLbl = Label(self.tt_frame, text="mod 4 tag:")
self.test_mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2)
self.test_mod4Txt = Entry(self.tt_frame,
textvariable=self.param_MOD4_tag)
self.test_mod4Txt.grid(row=4,
column=1,
columnspan=1,
sticky="W",
pady=1)
self.test_pretrainTxt = OptionMenu(self.test_model_frame,
self.param_inference_model,
*self.list_test_nets)
self.param_inference_model.set('None')
self.test_pretrainTxt.grid(row=5, column=0, sticky='E', padx=5, pady=5)
# START button links cto docker task
self.inferenceBtn = Button(self.test_frame,
state='disabled',
text="Start inference",
command=self.infer_segmentation)
self.inferenceBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1)
# train / test ABOUT button
self.train_aboutBtn = Button(self.train_frame,
text="about",
command=self.about_window)
self.train_aboutBtn.grid(row=7,
column=4,
sticky='E',
padx=(1, 1),
pady=1)
self.test_aboutBtn = Button(self.test_frame,
text="about",
command=self.about_window)
self.test_aboutBtn.grid(row=7,
column=4,
sticky='E',
padx=(1, 1),
pady=1)
# Processing state
self.process_indicator = StringVar()
self.process_indicator.set(' ')
self.label_indicator = Label(master,
textvariable=self.process_indicator)
self.label_indicator.pack(side="left")
# Closing processing events is implemented via
# a master protocol
self.master.protocol("WM_DELETE_WINDOW", self.close_event)
def parameter_window(self):
"""
Setting other parameters using an emerging window
CNN parameters, CUDA device, post-processing....
"""
t = Toplevel(self.master)
t.wm_title("Other parameters")
# data parameters
t_data = LabelFrame(t, text="data options:")
t_data.grid(row=0, sticky="WE")
checkPretrain = Checkbutton(t_data,
text="Register modalities",
var=self.param_register_modalities)
checkPretrain.grid(row=0, sticky='W')
checkSkull = Checkbutton(t_data,
text="Skull-strip modalities",
var=self.param_skull_stripping)
checkSkull.grid(row=1, sticky="W")
checkDenoise = Checkbutton(t_data,
text="Denoise masks",
var=self.param_denoise)
checkDenoise.grid(row=2, sticky="W")
denoise_iter_label = Label(t_data,
text=" Denoise iter: ")
denoise_iter_label.grid(row=3, sticky="W")
denoise_iter_entry = Entry(t_data,
textvariable=self.param_denoise_iter)
denoise_iter_entry.grid(row=3, column=1, sticky="E")
check_tmp = Checkbutton(t_data,
text="Save tmp files",
var=self.param_save_tmp)
check_tmp.grid(row=4, sticky="W")
checkdebug = Checkbutton(t_data,
text="Debug mode",
var=self.param_debug)
checkdebug.grid(row=5, sticky="W")
# model parameters
t_model = LabelFrame(t, text="Model:")
t_model.grid(row=5, sticky="EW")
maxepochs_label = Label(t_model, text="Max epochs: ")
maxepochs_label.grid(row=6, sticky="W")
maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs)
maxepochs_entry.grid(row=6, column=1, sticky="E")
trainsplit_label = Label(t_model, text="Validation %: ")
trainsplit_label.grid(row=7, sticky="W")
trainsplit_entry = Entry(t_model, textvariable=self.param_train_split)
trainsplit_entry.grid(row=7, column=1, sticky="E")
batchsize_label = Label(t_model, text="Test batch size:")
batchsize_label.grid(row=8, sticky="W")
batchsize_entry = Entry(t_model, textvariable=self.param_batch_size)
batchsize_entry.grid(row=8, column=1, sticky="E")
mode_label = Label(t_model, text="Verbosity:")
mode_label.grid(row=9, sticky="W")
mode_entry = Entry(t_model, textvariable=self.param_net_verbose)
mode_entry.grid(row=9, column=1, sticky="E")
#gpu_mode = Checkbutton(t_model,
# text="GPU:",
# var=self.param_mode)
#gpu_mode.grid(row=10, sticky="W")
gpu_number = Label(t_model, text="GPU number:")
gpu_number.grid(row=10, sticky="W")
gpu_entry = Entry(t_model, textvariable=self.param_gpu_number)
gpu_entry.grid(row=10, column=1, sticky="W")
# training parameters
tr_model = LabelFrame(t, text="Training:")
tr_model.grid(row=12, sticky="EW")
balanced_label = Label(tr_model, text="Balanced dataset: ")
balanced_label.grid(row=13, sticky="W")
balanced_entry = Entry(tr_model,
textvariable=self.param_balanced_dataset)
balanced_entry.grid(row=13, column=1, sticky="E")
fraction_label = Label(tr_model, text="Fraction negative/positives: ")
fraction_label.grid(row=14, sticky="W")
fraction_entry = Entry(tr_model,
textvariable=self.param_fract_negatives)
fraction_entry.grid(row=14, column=1, sticky="E")
# postprocessing parameters
t_post = LabelFrame(t, text="Post-processing: ")
t_post.grid(row=15, sticky="EW")
t_bin_label = Label(t_post, text="Out probability th: ")
t_bin_label.grid(row=16, sticky="W")
t_bin_entry = Entry(t_post, textvariable=self.param_t_bin)
t_bin_entry.grid(row=16, column=1, sticky="E")
l_min_label = Label(t_post, text="Min out region size: ")
l_min_label.grid(row=17, sticky="W")
l_min_entry = Entry(t_post, textvariable=self.param_l_min)
l_min_entry.grid(row=17, column=1, sticky="E")
vol_min_label = Label(t_post, text="Min vol error (ml): ")
vol_min_label.grid(row=18, sticky="W")
vol_min_entry = Entry(t_post, textvariable=self.param_min_error)
vol_min_entry.grid(row=18, column=1, sticky="E")
def load_default_configuration(self):
"""
load the default configuration from /config/default.cfg
This method assign each of the configuration parameters to
class attributes
"""
default_config = ConfigParser.SafeConfigParser()
default_config.read(os.path.join(self.path, 'config', 'default.cfg'))
# dastaset parameters
self.param_training_folder.set(
default_config.get('database', 'train_folder'))
self.param_test_folder.set(
default_config.get('database', 'inference_folder'))
self.param_FLAIR_tag.set(default_config.get('database', 'flair_tags'))
self.param_T1_tag.set(default_config.get('database', 't1_tags'))
self.param_MOD3_tag.set(default_config.get('database', 'mod3_tags'))
self.param_MOD4_tag.set(default_config.get('database', 'mod4_tags'))
self.param_mask_tag.set(default_config.get('database', 'roi_tags'))
self.param_register_modalities.set(
default_config.get('database', 'register_modalities'))
self.param_denoise.set(default_config.get('database', 'denoise'))
self.param_denoise_iter.set(
default_config.getint('database', 'denoise_iter'))
self.param_skull_stripping.set(
default_config.get('database', 'skull_stripping'))
self.param_save_tmp.set(default_config.get('database', 'save_tmp'))
self.param_debug.set(default_config.get('database', 'debug'))
# train parameters
self.param_use_pretrained_model.set(
default_config.get('train', 'full_train'))
self.param_pretrained_model.set(
default_config.get('train', 'pretrained_model'))
self.param_inference_model.set(" ")
self.param_balanced_dataset.set(
default_config.get('train', 'balanced_training'))
self.param_fract_negatives.set(
default_config.getfloat('train', 'fraction_negatives'))
# model parameters
self.param_net_folder = os.path.join(self.current_folder, 'nets')
self.param_net_name.set(default_config.get('model', 'name'))
self.param_train_split.set(
default_config.getfloat('model', 'train_split'))
self.param_max_epochs.set(default_config.getint('model', 'max_epochs'))
self.param_patience.set(default_config.getint('model', 'patience'))
self.param_batch_size.set(default_config.getint('model', 'batch_size'))
self.param_net_verbose.set(default_config.get('model', 'net_verbose'))
self.param_gpu_number.set(default_config.getint('model', 'gpu_number'))
# self.param_mode.set(default_config.get('model', 'gpu_mode'))
# post-processing
self.param_l_min.set(default_config.getint('postprocessing', 'l_min'))
self.param_t_bin.set(default_config.getfloat('postprocessing',
't_bin'))
self.param_min_error.set(
default_config.getfloat('postprocessing', 'min_error'))
def write_user_configuration(self):
"""
write the configuration into config/configuration.cfg
"""
user_config = ConfigParser.RawConfigParser()
# dataset parameters
user_config.add_section('database')
user_config.set('database', 'train_folder',
self.param_training_folder.get())
user_config.set('database', 'inference_folder',
self.param_test_folder.get())
user_config.set('database', 'flair_tags', self.param_FLAIR_tag.get())
user_config.set('database', 't1_tags', self.param_T1_tag.get())
user_config.set('database', 'mod3_tags', self.param_MOD3_tag.get())
user_config.set('database', 'mod4_tags', self.param_MOD4_tag.get())
user_config.set('database', 'roi_tags', self.param_mask_tag.get())
user_config.set('database', 'register_modalities',
self.param_register_modalities.get())
user_config.set('database', 'denoise', self.param_denoise.get())
user_config.set('database', 'denoise_iter',
self.param_denoise_iter.get())
user_config.set('database', 'skull_stripping',
self.param_skull_stripping.get())
user_config.set('database', 'save_tmp', self.param_save_tmp.get())
user_config.set('database', 'debug', self.param_debug.get())
# train parameters
user_config.add_section('train')
user_config.set('train', 'full_train',
not (self.param_use_pretrained_model.get()))
user_config.set('train', 'pretrained_model',
self.param_pretrained_model.get())
user_config.set('train', 'balanced_training',
self.param_balanced_dataset.get())
user_config.set('train', 'fraction_negatives',
self.param_fract_negatives.get())
# model parameters
user_config.add_section('model')
user_config.set('model', 'name', self.param_net_name.get())
user_config.set('model', 'pretrained', self.param_pretrained)
user_config.set('model', 'train_split', self.param_train_split.get())
user_config.set('model', 'max_epochs', self.param_max_epochs.get())
user_config.set('model', 'patience', self.param_patience.get())
user_config.set('model', 'batch_size', self.param_batch_size.get())
user_config.set('model', 'net_verbose', self.param_net_verbose.get())
# user_config.set('model', 'gpu_mode', self.param_mode.get())
user_config.set('model', 'gpu_number', self.param_gpu_number.get())
# postprocessing parameters
user_config.add_section('postprocessing')
user_config.set('postprocessing', 't_bin', self.param_t_bin.get())
user_config.set('postprocessing', 'l_min', self.param_l_min.get())
user_config.set('postprocessing', 'min_error',
self.param_min_error.get())
# Writing our configuration file to 'example.cfg'
with open(os.path.join(self.path, 'config', 'configuration.cfg'),
'wb') as configfile:
user_config.write(configfile)
def load_training_path(self):
"""
Select training path from disk and write it.
If the app is run inside a container,
link the iniitaldir with /data
"""
initialdir = '/data' if self.container else os.getcwd()
fname = askdirectory(initialdir=initialdir)
if fname:
try:
self.param_training_folder.set(fname)
self.inFolderTxt.delete(0, END)
self.inFolderTxt.insert(0, self.param_training_folder.get())
self.trainingBtn['state'] = 'normal'
except:
pass
def load_testing_path(self):
"""
Selecet the inference path from disk and write it
If the app is run inside a container,
link the iniitaldir with /data
"""
initialdir = '/data' if self.container else os.getcwd()
fname = askdirectory(initialdir=initialdir)
if fname:
try:
self.param_test_folder.set(fname)
self.test_inFolderTxt.delete(0, END)
self.test_inFolderTxt.insert(0, self.param_test_folder.get())
self.inferenceBtn['state'] = 'normal'
except:
pass
def update_pretrained_nets(self):
"""
get a list of the different net configuration present in the system.
Each model configuration is represented by a folder containing the network
weights for each of the networks. The baseline net config is always
included by default
"""
folders = os.listdir(self.param_net_folder)
self.list_train_pretrained_nets = folders
self.list_test_nets = folders
def write_to_console(self, txt):
"""
to doc:
important method
"""
self.command_out.insert(END, str(txt))
def write_to_test_console(self, txt):
"""
to doc:
important method
"""
self.test_command_out.insert(END, str(txt))
def infer_segmentation(self):
"""
Method implementing the inference process:
- Check network selection
- write the configuration to disk
- Run the process on a new thread
"""
if self.param_inference_model.get() == 'None':
print "ERROR: Please, select a network model before starting...\n"
return
if self.test_task is None:
self.inferenceBtn.config(state='disabled')
self.param_net_name.set(self.param_inference_model.get())
self.param_use_pretrained_model.set(False)
self.write_user_configuration()
print "\n-----------------------"
print "Running configuration:"
print "-----------------------"
print "Inference model:", self.param_model_tag.get()
print "Inference folder:", self.param_test_folder.get(), "\n"
print "Method info:"
print "------------"
self.test_task = ThreadedTask(self.write_to_test_console,
self.test_queue,
mode='testing')
self.test_task.start()
self.master.after(100, self.process_container_queue)
def train_net(self):
"""
Method implementing the training process:
- write the configuration to disk
- Run the process on a new thread
"""
if self.param_net_name.get() == 'None':
print "ERROR: Please, define network name before starting...\n"
return
self.trainingBtn['state'] = 'disable'
if self.train_task is None:
self.trainingBtn.update()
self.write_user_configuration()
print "\n-----------------------"
print "Running configuration:"
print "-----------------------"
print "Train model:", self.param_net_name.get()
print "Training folder:", self.param_training_folder.get(), "\n"
print "Method info:"
print "------------"
self.train_task = ThreadedTask(self.write_to_console,
self.test_queue,
mode='training')
self.train_task.start()
self.master.after(100, self.process_container_queue)
def check_update(self):
"""
check update version and propose to download it if differnt
So far, a rudimentary mode is used to check the last version.
"""
# I have to discard possible local changes :(
print "---------------------------------------"
print "Updating software"
print "current version:", self.commit_version
remote_commit = subprocess.check_output(['git', 'stash'])
remote_commit = subprocess.check_output(['git', 'fetch'])
remote_commit = subprocess.check_output(
['git', 'rev-parse', 'origin/master'])
if remote_commit != self.commit_version:
proc = subprocess.check_output(['git', 'pull', 'origin', 'master'])
self.check_link.config(text="Updated")
self.commit_version = remote_commit
print "updated version:", self.commit_version
else:
print "This software is already in the latest version"
print "---------------------------------------"
def about_window(self):
"""
Window showing information about the software and
version number, including auto-update. If the application
is run from a container, then auto-update is disabled
"""
def callback(event):
"""
open webbrowser when clicking links
"""
webbrowser.open_new(event.widget.cget("text"))
# main window
t = Toplevel(self.master, width=500, height=500)
t.wm_title("About")
# NIC logo + name
title = Label(t,
text="nicMSlesions v" + self.version + "\n"
"Multiple Sclerosis White Matter Lesion Segmentation")
title.grid(row=2, column=1, padx=20, pady=10)
img = ImageTk.PhotoImage(Image.open('./logonic.png'))
imglabel = Label(t, image=img)
imglabel.image = img
imglabel.grid(row=1, column=1, padx=10, pady=10)
group_name = Label(t,
text="Copyright Sergi Valverde (2018-) \n " +
"NeuroImage Computing Group")
group_name.grid(row=3, column=1)
group_link = Label(t,
text=r"http://atc.udg.edu/nic",
fg="blue",
cursor="hand2")
group_link.grid(row=4, column=1)
group_link.bind("<Button-1>", callback)
license_content = "Licensed under the BSD 2-Clause license. \n" + \
"A copy of the license is present in the root directory."
license_label = Label(t, text=license_content)
license_label.grid(row=5, column=1, padx=20, pady=20)
# if self.container is False:
# # check version and updates
# version_number = Label(t, text="commit: " + self.commit_version)
# version_number.grid(row=6, column=1, padx=20, pady=(1, 1))
#
# self.check_link = Button(t,
# text="Check for updates",
# command=self.check_update)
# self.check_link.grid(row=7, column=1)
def process_container_queue(self):
"""
Process the threading queue. When the threaded processes are
finished, buttons are reset and a message is shown in the app.
"""
self.process_indicator.set('Running... please wait')
try:
msg = self.test_queue.get(0)
self.process_indicator.set('Done. See log for more details.')
self.inferenceBtn['state'] = 'normal'
self.trainingBtn['state'] = 'normal'
except Queue.Empty:
self.master.after(100, self.process_container_queue)
def close_event(self):
"""
Stop the thread processes using OS related calls.
"""
if self.train_task is not None:
self.train_task.stop_process()
if self.test_task is not None:
self.test_task.stop_process()
os.system('cls' if platform.system == "Windows" else 'clear')
root.destroy()
class ListPage(BasePage):
def __init__(self, parent, controller):
BasePage.__init__(self, parent, controller)
self.target_keep_profile_var = IntVar()
self.mutex = Lock()
def prepare(self):
self.deviceList.config(state='normal')
self.versionList.config(state='disabled')
self.engList.config(state='disabled')
self.packageList.config(state='disabled')
self.ok.config(state='disabled')
self.setData(self.controller.data)
self.setDeviceList(self.data.keys())
self.controller.setDefault(self, self.controller.loadOptions())
self.deviceList.focus_force()
def printErr(self, message):
self.errLog.config(text=message)
def setData(self, data):
self.data = data
def setupView(self, title="Select your flash", data=None):
if (data):
self.setData(data)
self.errLog = Label(self, text="")
self.errLog.grid(row=4, column=1, columnspan=3, sticky="NWSE")
self.desc = Label(self, text=title, font=TITLE_FONT)
self.desc.grid(row=0, column=0, columnspan=2)
self.ok = Button(self, text='Next', command=lambda: self.confirm())
self.ok.grid(row=4, column=3, sticky="E")
self.ok.config(state="disabled")
# bind self.target_keep_profile_var (IntVar) to keepProfileCheckbutton, 1 is True, 0 is Flase
self.keepProfileCheckbutton = Checkbutton(
self,
text="Keep User Profile (BETA)",
variable=self.target_keep_profile_var)
self.keepProfileCheckbutton.grid(row=5,
column=0,
columnspan=4,
sticky="W")
self.deviceLabel = Label(self, text="Device", font=TITLE_FONT)
self.deviceLabel.grid(row=1, column=0)
self.deviceList = Listbox(self, exportselection=0)
self.deviceList.grid(row=2, column=0)
self.deviceList.bind('<<ListboxSelect>>', self.deviceOnSelect)
self.deviceList.config(state="disabled")
self.versionLabel = Label(self, text="Branch", font=TITLE_FONT)
self.versionLabel.grid(row=1, column=1)
self.versionList = Listbox(self, exportselection=0)
self.versionList.grid(row=2, column=1)
self.versionList.bind('<<ListboxSelect>>', self.versionOnSelect)
self.versionList.config(state="disabled")
self.engLabel = Label(self, text="Build Type", font=TITLE_FONT)
self.engLabel.grid(row=1, column=2)
self.engList = Listbox(self, exportselection=0)
self.engList.grid(row=2, column=2)
self.engList.bind('<<ListboxSelect>>', self.engOnSelect)
self.engList.config(state="disabled")
self.packageLabel = Label(self,
text="Gecko/Gaia/Full",
font=TITLE_FONT)
self.packageLabel.grid(row=1, column=3)
self.packageList = Listbox(self, exportselection=0)
self.packageList.grid(row=2, column=3)
self.packageList.bind('<<ListboxSelect>>', self.packageOnSelect)
self.packageList.config(state="disabled")
self.bidVar = StringVar()
Label(self, text="Build ID").grid(row=3, column=0, sticky='E')
self.bidInput = Entry(self, textvariable=self.bidVar, width="30")
self.bidInput.grid(row=3, column=1, columnspan=2, sticky="W")
self.bidVar.set('latest')
# binding unfocus for build id field
self.bidInput.bind('<FocusOut>', self.updateBuildId)
# binding the Return Key to each componments
self.deviceList.bind('<Return>', self.pressReturnKey)
self.versionList.bind('<Return>', self.pressReturnKey)
self.engList.bind('<Return>', self.pressReturnKey)
self.packageList.bind('<Return>', self.pressReturnKey)
self.bidInput.bind('<Return>', self.pressReturnKey)
self.ok.bind('<Return>', self.pressReturnKey)
def selection_all_checked(self):
result = False
if len(self.deviceList.curselection()) == 0:
self.logger.log('Please select device.',
status_callback=self.printErr)
self.ok.config(state="disabled")
self.deviceList.focus_set()
elif len(self.versionList.curselection()) == 0:
self.logger.log('Please select branch.',
status_callback=self.printErr)
self.ok.config(state="disabled")
self.versionList.focus_set()
elif len(self.engList.curselection()) == 0:
self.logger.log('Please select user or engineer build.',
status_callback=self.printErr)
self.ok.config(state="disabled")
self.engList.focus_set()
elif len(self.packageList.curselection()) == 0:
self.logger.log('Please select package to flash.',
status_callback=self.printErr)
self.ok.config(state="disabled")
self.packageList.focus_set()
elif len(self.bidVar.get()) != 14 and self.bidVar.get() != 'latest':
self.logger.log(
'Please enter build ID to flash or use "latest" to get the newest',
status_callback=self.printErr)
self.logger.log(self.bidVar.get() + ' is invalid: ' +
str(len(self.bidVar.get())))
self.bidVar.set('latest')
else:
result = True
return result
def updateBuildId(self, event=None):
# if the value is '' or 'latest', the set the build_id option as ''.
buildId = self.bidVar.get()
if buildId == 'latest':
buildId = ''
elif len(buildId) != 14:
self.printErr("Invalid build ID: " + buildId + ", reset to latest")
buildId = ''
self.bidVar.set('latest')
else:
if len(self.engList.curselection()) != 0:
self.refreshPackageList()
def pressReturnKey(self, event=None):
if self.selection_all_checked():
self.ok.config(state="disabled")
self.confirm()
def deviceOnSelect(self, evt):
self.setVersionList()
def versionOnSelect(self, evt):
self.setEngList()
def engOnSelect(self, evt):
self.refreshPackageList() # hard coded right now
def packageOnSelect(self, evt):
self.ok.config(state="normal")
def confirm(self):
self.mutex.acquire()
try:
if self.selection_all_checked():
self.ok.config(state="disabled")
params = []
package = self.packageList.get(
self.packageList.curselection()[0])
self.logger.log('Start to flash [' + package + '].',
status_callback=self.printErr)
if (PathParser._IMAGES in package):
params.append(PathParser._IMAGES)
else:
if (PathParser._GAIA in package):
params.append(PathParser._GAIA)
if (PathParser._GECKO in package):
params.append(PathParser._GECKO)
keep_profile = (self.target_keep_profile_var.get() == 1)
archives = self.controller.do_download(params)
self.controller.do_flash(params,
archives,
keep_profile=keep_profile)
self.packageList.select_clear(0, END)
self.controller.transition(self)
finally:
self.mutex.release()
def setDeviceList(self, device=[]):
self.deviceList.delete(0, END)
for li in device:
self.deviceList.insert(END, li)
def setVersionList(self, version=[]):
if len(version) == 0:
version = self.data[self.deviceList.get(
self.deviceList.curselection())]
self.versionList.config(state="normal")
self.engList.config(state="disabled")
self.packageList.config(state="disabled")
self.ok.config(state="disabled")
self.versionList.delete(0, END)
for li in version:
self.versionList.insert(END, li)
def setEngList(self, eng=[]):
if len(eng) == 0:
device = self.deviceList.get(self.deviceList.curselection())
version = self.versionList.get(self.versionList.curselection())
eng = self.data[device][version]
self.engList.config(state="normal")
self.packageList.config(state="disabled")
self.ok.config(state="disabled")
self.engList.delete(0, END)
for li in eng:
self.engList.insert(END, li)
def refreshPackageList(self):
self.mutex.acquire()
try:
self.packageList.config(state="normal")
self.ok.config(state="normal")
self.packageList.delete(0, END)
device = self.deviceList.get(self.deviceList.curselection())
version = self.versionList.get(self.versionList.curselection())
eng = self.engList.get(self.engList.curselection())
buildId = '' if (len(self.bidVar.get()) == 0 or self.bidVar.get()
== 'latest') else self.bidVar.get()
package = self.controller.getPackages(
self.data[device][version][eng]['src'], build_id=buildId)
if len(package) == 0:
self.logger.log('Invalid build ID: ' + buildId +
', reset to latest',
status_callback=self.printErr)
buildId = ''
self.bidVar.set('latest')
package = self.controller.getPackages(
self.data[device][version][eng]['src'], build_id=buildId)
for li in package:
self.packageList.insert(END, li)
finally:
self.mutex.release()
def parameter_window(self):
"""
Setting other parameters using an emerging window
CNN parameters, CUDA device, post-processing....
"""
t = Toplevel(self.master)
t.wm_title("Other parameters")
# data parameters
t_data = LabelFrame(t, text="data options:")
t_data.grid(row=0, sticky="WE")
checkPretrain = Checkbutton(t_data,
text="Register modalities",
var=self.param_register_modalities)
checkPretrain.grid(row=0, sticky='W')
checkSkull = Checkbutton(t_data,
text="Skull-strip modalities",
var=self.param_skull_stripping)
checkSkull.grid(row=1, sticky="W")
checkDenoise = Checkbutton(t_data,
text="Denoise masks",
var=self.param_denoise)
checkDenoise.grid(row=2, sticky="W")
denoise_iter_label = Label(t_data,
text=" Denoise iter: ")
denoise_iter_label.grid(row=3, sticky="W")
denoise_iter_entry = Entry(t_data,
textvariable=self.param_denoise_iter)
denoise_iter_entry.grid(row=3, column=1, sticky="E")
check_tmp = Checkbutton(t_data,
text="Save tmp files",
var=self.param_save_tmp)
check_tmp.grid(row=4, sticky="W")
checkdebug = Checkbutton(t_data,
text="Debug mode",
var=self.param_debug)
checkdebug.grid(row=5, sticky="W")
# model parameters
t_model = LabelFrame(t, text="Model:")
t_model.grid(row=5, sticky="EW")
maxepochs_label = Label(t_model, text="Max epochs: ")
maxepochs_label.grid(row=6, sticky="W")
maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs)
maxepochs_entry.grid(row=6, column=1, sticky="E")
trainsplit_label = Label(t_model, text="Validation %: ")
trainsplit_label.grid(row=7, sticky="W")
trainsplit_entry = Entry(t_model, textvariable=self.param_train_split)
trainsplit_entry.grid(row=7, column=1, sticky="E")
batchsize_label = Label(t_model, text="Test batch size:")
batchsize_label.grid(row=8, sticky="W")
batchsize_entry = Entry(t_model, textvariable=self.param_batch_size)
batchsize_entry.grid(row=8, column=1, sticky="E")
mode_label = Label(t_model, text="Verbosity:")
mode_label.grid(row=9, sticky="W")
mode_entry = Entry(t_model, textvariable=self.param_net_verbose)
mode_entry.grid(row=9, column=1, sticky="E")
#gpu_mode = Checkbutton(t_model,
# text="GPU:",
# var=self.param_mode)
#gpu_mode.grid(row=10, sticky="W")
gpu_number = Label(t_model, text="GPU number:")
gpu_number.grid(row=10, sticky="W")
gpu_entry = Entry(t_model, textvariable=self.param_gpu_number)
gpu_entry.grid(row=10, column=1, sticky="W")
# training parameters
tr_model = LabelFrame(t, text="Training:")
tr_model.grid(row=12, sticky="EW")
balanced_label = Label(tr_model, text="Balanced dataset: ")
balanced_label.grid(row=13, sticky="W")
balanced_entry = Entry(tr_model,
textvariable=self.param_balanced_dataset)
balanced_entry.grid(row=13, column=1, sticky="E")
fraction_label = Label(tr_model, text="Fraction negative/positives: ")
fraction_label.grid(row=14, sticky="W")
fraction_entry = Entry(tr_model,
textvariable=self.param_fract_negatives)
fraction_entry.grid(row=14, column=1, sticky="E")
# postprocessing parameters
t_post = LabelFrame(t, text="Post-processing: ")
t_post.grid(row=15, sticky="EW")
t_bin_label = Label(t_post, text="Out probability th: ")
t_bin_label.grid(row=16, sticky="W")
t_bin_entry = Entry(t_post, textvariable=self.param_t_bin)
t_bin_entry.grid(row=16, column=1, sticky="E")
l_min_label = Label(t_post, text="Min out region size: ")
l_min_label.grid(row=17, sticky="W")
l_min_entry = Entry(t_post, textvariable=self.param_l_min)
l_min_entry.grid(row=17, column=1, sticky="E")
vol_min_label = Label(t_post, text="Min vol error (ml): ")
vol_min_label.grid(row=18, sticky="W")
vol_min_entry = Entry(t_post, textvariable=self.param_min_error)
vol_min_entry.grid(row=18, column=1, sticky="E")
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.buttons = {}
self.nodes = {}
self.edges = {}
self.active_node = None
self.active_edge = None
self.start = None
self.x = None
self.y = None
self.cycles = None
self.show_cycles_only_mode = False
self.steps = None
self.step_index = None
self.parent.title("Demonstrační aplikace - nalezení elementárních cyklů v orientovaném grafu")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(3, pad=7)
self.rowconfigure(5, weight=1)
self.rowconfigure(6, pad=7)
self.label = Label(self, text="graf1.graphml")
self.label.grid(sticky=W, pady=4, padx=5)
self.canvas = Canvas(self)
self.canvas.bind('<Double-Button-1>', self.event_add_node)
self.canvas.bind('<Button-1>', self.event_add_edge_start)
self.canvas.bind('<B1-Motion>', self.event_add_edge_move)
self.canvas.bind('<ButtonRelease-1>', self.event_add_edge_end)
self.canvas.bind('<Button-3>', self.event_move_node_start)
self.canvas.bind('<B3-Motion>', self.event_move_node)
self.canvas.pack()
self.canvas.grid(row=1, column=0, columnspan=2, rowspan=6,
padx=5, sticky=E + W + S + N)
self.buttons['start'] = b = Button(self, text="Start", width=15)
b.bind('<Button-1>', self.event_start)
b.grid(row=1, column=3)
self.buttons['next'] = b = Button(self, text=">>", width=15, state=DISABLED)
b.bind('<Button-1>', self.event_next_step)
b.grid(row=2, column=3, pady=4)
self.buttons['prev'] = b = Button(self, text="<<", width=15, state=DISABLED)
b.bind('<Button-1>', self.event_prev_step)
b.grid(row=3, column=3, pady=4)
b = Checkbutton(self, text="Pouze cykly", command=self.event_change_mode)
b.grid(row=4, column=3, pady=4)
self.buttons['reset'] = b = Button(self, text="Reset", width=15)
b.bind('<Button-1>', self.event_reset)
b.grid(row=6, column=3)
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = Menu(menubar)
fileMenu.add_command(label="Načíst", command=self.onLoad)
fileMenu.add_command(label="Uložit", command=self.onSave)
fileMenu.add_separator()
fileMenu.add_command(label="Konec", command=self.onExit)
menubar.add_cascade(label="Soubor", menu=fileMenu)
fileMenu = Menu(menubar)
fileMenu.add_command(label="O aplikaci", command=self.onAbout)
menubar.add_cascade(label="Nápověda", menu=fileMenu)
class GcFrame(LabelFrame):
def __init__(self, root, filename, contents, settings, logger, *arg):
LabelFrame.__init__(self, root, *arg, text="gcode Viewer")
self.label = Label(self)
self.canvas = Canvas(self, width=settings.buildarea[0]*SCALE, height=settings.buildarea[1]*SCALE, bd=2, relief=RIDGE, bg="black")
self.canvas.config(takefocus="1")
self.root = root
self.settings = settings
self.buildarea = settings.buildarea
self.log = logger
self.zoom = 1
self.offsetx = 0
self.offsety = 0
self.movestartx = 0
self.movestarty = 0
self.sb = Scrollbar(self)
self.sb.config(command=self.scroll)
self.sb.set(0.0, 1.0)
self.sbslidersize = 1.0
self.syncwithprint = IntVar()
self.syncwithprint.set(1)
self.bZoomOut = Button(self, text="-", width=3, command=self.doZoomOut)
self.bZoomIn = Button(self, text="+", width=3, command=self.doZoomIn)
self.cb = Checkbutton(self, text="Sync view with print", variable=self.syncwithprint,
command=self.syncClick)
self.bReset = Button(self, text="Reset View", command=self.pressReset)
self.canvas.bind("<Button-1>", self.startMove);
self.canvas.bind("<B1-Motion>", self.continueMove);
self.canvas.bind("<MouseWheel>", self.mouseWheel);
self.canvas.bind("<Button-4>", self.mouseWheel);
self.canvas.bind("<Button-5>", self.mouseWheel);
self.canvas.bind("<Shift-MouseWheel>", self.mouseWheelZoom);
self.canvas.bind("<Shift-Button-4>", self.mouseWheelZoom);
self.canvas.bind("<Shift-Button-5>", self.mouseWheelZoom);
self.label.grid(row=1, column=1, columnspan=5)
self.canvas.grid(row=2,column=1,columnspan=5)
self.sb.grid(row=2, column=6, sticky=N+S)
self.bZoomOut.grid(row=3, column=1, sticky=E)
self.bZoomIn.grid(row=3, column=2, sticky=W)
self.cb.grid(row=3, column=3, columnspan=2)
self.bReset.grid(row=3, column=5, columnspan=2)
self.currentlayer = None
self.currentdrawn = None
self.currentlx = None
self.layercount = 0
self.filename = None
self.printprogress = 0
self.minline = 0
self.maxline = 0
self.drawGrid()
self.model = Model()
if filename != None:
self.loadFile(filename, contents)
#self.drawLayer(self.currentlayer)
def getPrintStartLine(self):
return self.model.getPrintStartLine()
def pressReset(self):
self.resetView()
def startMove(self, e):
self.canvas.focus_set()
self.movestartx = e.x
self.movestarty = e.y
self.moveoffsetx = self.offsetx
self.moveoffsety = self.offsety
def continueMove(self, e):
dx = e.x - self.movestartx
dy = e.y - self.movestarty
self.offsetx = self.moveoffsetx - dx/(2*self.zoom)
self.offsety = self.moveoffsety - dy/(2*self.zoom)
self.drawCanvas()
def updatePrintProgress(self, n, restart=False):
if n == 0:
self.printprogress = 0
if self.syncwithprint.get() == 1:
if restart:
self.currentLayer = self.model.bottomLayer()
self.currentdrawn = None
self.currentlx = 0
self.setSliderPos()
self.drawLayer(self.currentlayer)
return
if n <= self.printprogress:
return
ll = self.model.findLayersbyLineNo(self.printprogress, n)
if len(ll) == 0: return
self.printprogress = n
if self.syncwithprint.get() == 1:
if self.currentlayer != ll[-1]:
self.currentlayer = ll[-1]
self.currentlx = self.model.getLayerNumber(self.currentlayer)
self.drawLayer(self.currentlayer)
self.setSliderPos()
else:
self.drawOneLayer(self.currentlayer, updateonly=True)
else:
if self.currentlayer in ll:
self.drawOneLayer(self.currentlayer, updateonly=True)
def scroll(self, *a):
if self.currentlx == None:
self.currentlx = 0
if a[0] == "scroll":
nlx = self.currentlx - int(a[1])
if nlx < 0:
nlx = 0
elif nlx >= self.model.countLayers():
nlx = self.model.countLayers()-1
elif a[0] == "moveto":
pos = 1.0 - float(a[1])
nlx = int(pos / self.sbslidersize) - 1
if nlx < 0:
nlx = 0
elif nlx >= self.model.countLayers():
nlx = self.model.countLayers()-1
else:
return
self.currentlx = nlx
self.currentlayer = self.model.getLayerName(nlx)
self.drawLayer(self.currentlayer)
self.setSliderPos()
def setSliderPos(self):
if self.currentlx == None:
self.currentlx = 0
sbpos = 1.0 - (self.currentlx * self.sbslidersize) - self.sbslidersize
if sbpos < 0.0:
sbpos = 0.0
self.sb.set(sbpos, sbpos+self.sbslidersize)
def syncClick(self):
if self.syncwithprint.get() == 1:
self.updatePrintProgress(self.printprogress)
def mouseWheel(self, e):
if e.num == 5 or e.keycode == -120: #scroll down
self.scroll("scroll", 1)
elif e.num == 4 or e.keycode == 120: #scroll up
self.scroll("scroll", -1)
def mouseWheelZoom(self, e):
if e.num == 5 or e.keycode == -120: #zoom in
self.doZoomIn()
elif e.num == 4 or e.keycode == 120: #zoom out
if self.zoom > 1:
self.doZoomOut()
def doZoomIn(self):
cw = self.buildarea[0]/self.zoom
ch = self.buildarea[1]/self.zoom
self.zoom += 1
nw = self.buildarea[0]/self.zoom
nh = self.buildarea[1]/self.zoom
self.offsetx += (cw-nw)/2
self.offsety += (ch-nh)/2
self.drawCanvas()
def doZoomOut(self):
if self.zoom > 1:
cw = self.buildarea[0]/self.zoom
ch = self.buildarea[1]/self.zoom
self.zoom -= 1
if self.zoom < 1: self.zoom = 1
nw = self.buildarea[0]/self.zoom
nh = self.buildarea[1]/self.zoom
self.offsetx -= (nw-cw)/2
self.offsety -= (nh-ch)/2
self.drawCanvas()
def loadFile(self, filename, contents):
self.filename = filename
self.model.addFile(contents)
self.currentlayer = self.model.bottomLayer()
self.currentlx = 0
self.currentdrawn = None
self.printprogress = 0
self.layercount = self.model.countLayers()
self.drawLayer(self.currentlayer)
if self.layercount > 0:
self.sbslidersize = 1.0 / self.layercount
self.setSliderPos()
def getLayerNumberByHeight(self, z):
return self.model.getLayerNumberByHeight(z)
def resetView(self):
self.zoom = 1
self.offsety = 0
self.offsetx = 0
self.drawCanvas()
def drawCanvas(self):
self.currentdrawn = None
self.drawGrid()
self.drawLayer(self.currentlayer)
self.setSliderPos()
def drawGrid(self):
self.canvas.delete("GRID")
ltGrey = "#424242"
dkGrey = "#404040"
yleft = (0 - self.offsety)*self.zoom*SCALE
if yleft < 0: yleft = 0
yright = (self.buildarea[1] - self.offsety)*self.zoom*SCALE
if yright > self.buildarea[1]*SCALE: yright = self.buildarea[1]*SCALE
for x in range(0, self.buildarea[0], 10):
if x%50 == 0:
c = ltGrey
else:
c = dkGrey
x = (x - self.offsetx)*self.zoom*SCALE
if x >= 0 and x <= self.buildarea[0]*SCALE:
self.canvas.create_line(x, yleft, x, yright, fill=c, tags="GRID")
xtop = (0 - self.offsetx)*self.zoom*SCALE
if xtop <0: xtop = 0
xbottom = (self.buildarea[0] - self.offsetx)*self.zoom*SCALE
if xbottom > self.buildarea[0]*SCALE: xbottom = self.buildarea[0]*SCALE
for y in range(0, self.buildarea[1], 10):
if y%50 == 0:
c = dkGrey
else:
c = ltGrey
y = (y - self.offsety)*self.zoom*SCALE
if y >= 0 and y <= self.buildarea[1]*SCALE:
self.canvas.create_line(xtop, y, xbottom, y, fill=c, tags="GRID")
def drawLayer(self, layername):
if layername == self.currentdrawn:
#print "deleting object"
#self.canvas.delete("OBJECT")
self.drawOneLayer(layername, updateonly=True)
else:
self.canvas.delete("OBJECT")
self.canvas.delete("SHADOW")
pl = self.model.prevLayer(layername)
if pl and self.settings.showprevious:
self.drawOneLayer(pl, background=True)
self.drawOneLayer(layername)
self.currentdrawn = layername
def drawOneLayer(self, layername, background=False, updateonly=False):
if not self.model.setLayer(layername):
return
lx = self.model.getLayerNumber(layername)
prev = [None, None]
segmentextrusion = 0.0
cx = 0
segments = 0
if background:
tag = "SHADOW"
else:
tag = "OBJECT"
if not background and not updateonly:
self.label.config(text="file: %.30s z = %.3f (%d/%d)" %
(os.path.basename(self.filename), self.model.getLayerHeight(layername), lx+1, self.model.countLayers()))
for p in self.model:
if prev == [None, None]:
prev = [p[0], p[1]]
if segments != 0:
segments = 0
cx = (cx + 1) % len(colors)
else:
if p[3] <= segmentextrusion or p[3] == -1:
if p[3] == -1:
segmentextrusion = 0.0
if not updateonly:
if not background and self.settings.showmoves:
c = "white"
if prev != [p[0], p[1]]:
(x1, y1) = self.transform(prev[0], self.buildarea[1]-prev[1])
(x2, y2) = self.transform(p[0], self.buildarea[1]-p[1])
self.canvas.create_line(x1, y1, x2, y2, fill=c, tags=tag)
if segments != 0:
segments = 0
cx = (cx + 1) % len(colors)
else:
if prev != [p[0], p[1]]:
segments += 1
segmentextrusion = p[3]
if background:
c = grey
f = not updateonly
elif self.printprogress >= p[5]:
c = "red"
f = True
else:
c = colors[cx]
f = not updateonly
if f:
(x1, y1) = self.transform(prev[0], self.buildarea[1]-prev[1])
(x2, y2) = self.transform(p[0], self.buildarea[1]-p[1])
self.canvas.create_line(x1, y1, x2, y2, fill=c, tags=tag)
prev = [p[0], p[1]]
def transform(self, ptx, pty):
x = (ptx - self.offsetx)*self.zoom*SCALE
y = (pty - self.offsety)*self.zoom*SCALE
return (x, y)
