def create_voices(self):
voice_ids = ['1', '2', '3', '4']
SCALES = OrderedDict([
('pan_pos', {'min': -1, 'max': 1, 'start': 0.5, 'res': 0.001}),
('volume', {'min': 0, 'max': 1, 'start': 0.666, 'res': 0.001}),
('slide_duration_msecs', {'min': 0, 'max': 2000, 'start': 60, 'res': 1}),
('slide_duration_prop', {'min': 0, 'max': 2, 'start': 0.666, 'res': 0.001}),
('binaural_diff', {'min': 0, 'max': 66, 'start': 0.2, 'res': 0.01})
])
for vid in voice_ids:
counter = 0
for sca in SCALES:
name = 'voice_' + vid + '_' + sca
setattr(self, 'min_' + name, SCALES[sca]['min'])
setattr(self, 'max_' + name, SCALES[sca]['max'])
this_sca = Scale(self, label=sca, orient=HORIZONTAL,
from_=getattr(self, 'min_' + name),
to=getattr(self, 'max_' + name),
resolution=SCALES[sca]['res'])
this_sca.enable = ('enable' in SCALES[sca].keys() and
SCALES[sca]['enable'] or None)
this_sca.disable = ('disable' in SCALES[sca].keys() and
SCALES[sca]['disable'] or None)
this_sca.grid(column=int(2 + int(vid)), row=counter, sticky=E + W)
this_sca.bind("<ButtonRelease>", self.scale_handler)
this_sca.ref = name
counter += 1
CHECK_BUTTONS = OrderedDict(
[('mute', False),
('automate_binaural_diffs', True),
('automate_note_duration_prop', True),
('use_proportional_slide_duration', {'val': True, 'label': 'proportional slide'}),
('automate_pan', True),
('automate_wavetables', True)])
for vid in voice_ids:
counter = 0
cb_frame = LabelFrame(self, text="Voice {0} - Automation".format(vid))
setattr(self, 'voice_' + vid + '_cb_frame', cb_frame)
for cb in CHECK_BUTTONS:
options = CHECK_BUTTONS[cb]
name = 'voice_' + vid + '_' + cb
label = (options['label'] if isinstance(options, dict) and
'label' in options.keys() else
(cb[9:] if cb[:9] == 'automate_' else cb))
setattr(self, name, IntVar(value=type(options) == dict and options['val'] or options))
self.this_cb = Checkbutton(cb_frame, text=label, variable=getattr(self, name))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = None
self.this_cb.grid(sticky=W, column=0, row=counter)
self.this_cb.ref = name
counter += 1
# add trigger wavetable-button
trigWavetableButton = Button(cb_frame, text='Next Wavetable')
trigWavetableButton.bind('<Button-1>', self.trigger_waveform_handler)
trigWavetableButton.ref = 'voice_' + vid + "_trigger_wavetable"
trigWavetableButton.grid(row=counter)
cb_frame.grid(column=int(vid) + 2, row=5, sticky=E + W + N, rowspan=8)
for vid in voice_ids:
generation_types = ["random", "random_harmonic", "harmonic"]
partial_pools = ["even", "odd", "all"]
prefix = 'voice_' + vid + '_'
types_name = prefix + 'wavetable_generation_type'
pools_name = prefix + 'partial_pool'
setattr(self, types_name, StringVar())
getattr(self, types_name).set("random")
setattr(self, pools_name, StringVar())
getattr(self, pools_name).set("all")
target_frame = getattr(self, 'voice_' + vid + '_cb_frame')
gen_typ_frame = LabelFrame(target_frame, text="type")
gen_typ_frame.grid(row=len(target_frame.winfo_children()), sticky=W)
for gen_t in generation_types:
gen_t_entry = Radiobutton(gen_typ_frame, value=gen_t, text=gen_t, anchor=W,
variable=getattr(self, types_name))
gen_t_entry.bind('<ButtonRelease-1>', self.wt_handler)
gen_t_entry.ref = types_name
gen_t_entry.grid(row=len(gen_typ_frame.winfo_children()), sticky=W)
pp_frame = LabelFrame(target_frame, text="harmonics")
for pp in partial_pools:
pp_entry = Radiobutton(pp_frame, value=pp, text=pp, anchor=W,
variable=getattr(self, pools_name))
pp_entry.bind('<ButtonRelease-1>', self.wt_handler)
pp_entry.ref = pools_name
pp_entry.grid(row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials = Scale(pp_frame, label='number of harmonics', orient=HORIZONTAL,
from_=1, to=24, resolution=1)
this_num_partials.ref = prefix + 'num_partials'
this_num_partials.grid(column=0, row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials.bind("<ButtonRelease>", self.scale_handler)
pp_frame.grid(row=len(target_frame.winfo_children()), sticky=E + W)
def __init__(self, master, tracker, text="Joystick", **options):
LabelFrame.__init__(self, master, text=text, **options)
self.tracker = tracker
self.width = 400
self.height = 400
self.canvas = Canvas(self, height=self.height, width=self.width)
self.canvas.grid()
self.canvas.create_oval((self.width/2 - 3, self.height/2 - 3,
self.width/2 + 3, self.height/2 + 3))
self.canvas.bind("<Button-1>",
bg_caller(lambda event: self.move_tracker(event)))
self.canvas.bind("<Motion>", self.update_label)
self.motion_label = Label(self, text="",
font=tkFont.Font(family="Courier"))
self.motion_label.grid()
f = LabelFrame(self, text="Sensitivity")
self.sensitivity_scale = Scale(f, from_=0, to=10,
resolution=0.01,
orient=HORIZONTAL,
length=self.width)
self.sensitivity_scale.set(5)
self.sensitivity_scale.grid()
f.grid()
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))
def __init__(self, tracker, board, *args, **kwargs):
Frame.__init__(self, *args, **kwargs)
self.tracker = tracker
self.board = board
tracker_subframe = LabelFrame(self, text="Tracker stuff")
self.tracker_button = Button(tracker_subframe, text="Tracker",
command=self.open_tracker_frame)
self.tracker_button.grid()
self.joystick_button = Button(tracker_subframe, text="Joystick",
command=self.open_joystick_frame)
self.joystick_button.grid()
self.reposn_button = Button(tracker_subframe, text="Repositioning",
command=self.open_repositioning_frame)
self.reposn_button.grid()
self.measure_button = Button(tracker_subframe, text="Measure",
command=self.open_measure_frame)
self.measure_button.grid()
self.plotting_button = Button(tracker_subframe, text="Plotting",
command=self.open_plotting_frame)
self.plotting_button.grid()
tracker_subframe.grid()
self.actuator_button = Button(self, text="Actuators",
command=self.open_actuator_frame)
self.actuator_button.grid()
class ihm(Tkinter.Tk):
def entrer():
print 'click'
self.value.set("bonjour")
self.entrer.pack()
def __init__(self, parent):
Tkinter.Tk.__init__(self, parent)
self.parent = parent
self.initialize()
def initialize(self):
#layout manager
self.grid()
#champ de texte (entrer)
self.lframe = LabelFrame(self, text="Nom du noeud", padx=50, pady=20)
self.lframe.pack(fill="both", expand="yes")
self.lframe.grid(column=0, row=0, sticky='EW')
self.value = StringVar()
#self.value.set("Noeud")
self.entrer = Tkinter.Entry(self.lframe,
fg='grey',
textvariable=self.value).pack()
self.button = Tkinter.Button(self, text="Ok", command=self.entrer)
self.button.grid(column=1, row=0)
#self.label = Tkinter.Label(self,anchor="center",text = 'Nom du noeud :',fg="black",bg="white")
#self.label.grid(column=0,row=0,columnspan=2,sticky='EW')
#redimensionnement auto
self.grid_columnconfigure(0, weight=1)
self.geometry("800x600+300+0")
def site(self): from Tkinter import LabelFrame site_frame = LabelFrame(self.root, height = 100, width = 150, text = "Site settings") site_frame.grid(column = 0, row = 0, columnspan = 1, rowspan = 1) from scrolledlist import ScrolledList site = ScrolledList(site_frame, width = 20, height = 3) site.grid(column = 0, row = 0, columnspan = 1, rowspan = 1)
def populateControlFrame(self, master):
master.grid_columnconfigure(0, weight=1)
row = 0
col = 0
w = LabelFrame(master, text='Control')
w.grid(row=row, column=col, sticky=NSEW, padx=5, pady=5)
self.populateControlFrameWidgets(w)
def time(self): from Tkinter import LabelFrame time_frame = LabelFrame(self.root, height = 100, width = 150, text = "Time settings") time_frame.grid(column = 1, row = 0, columnspan = 1, rowspan = 1) from Tkinter import Radiobutton time_now = Radiobutton(time_frame, text = "Now", variable = time, value = 1) time_now.grid(column = 0, row = 0, columnspan = 1, rowspan = 1) time_selection = Radiobutton(time_frame, text = "Select", variable = time, value = 2) time_selection.grid(column = 0, row = 1, columnspan = 1, rowspan = 1)
def __init__(self, master, names, parsers={}, **kwargs):
LabelFrame.__init__(self, master, **kwargs)
entries = {}
for name in names:
f = LabelFrame(self, text=name)
entries[name] = Entry(f)
entries[name].grid()
f.grid()
NamedEntryContainer.__init__(self, entries=entries, parsers=parsers)
def site(self):
from Tkinter import LabelFrame
site_frame = LabelFrame(self.root,
height=100,
width=150,
text="Site settings")
site_frame.grid(column=0, row=0, columnspan=1, rowspan=1)
from scrolledlist import ScrolledList
site = ScrolledList(site_frame, width=20, height=3)
site.grid(column=0, row=0, columnspan=1, rowspan=1)
def show(self):
self.__root.title(CONST.APP_NAME)
mainFrame = Frame(self.__root)
# Configure main frame and make Dialog stretchable (to EAST and WEST)
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')
# Configure the frames to hold the controls
# - Frame with input settings
inputFrame = LabelFrame(mainFrame, text='Input Settings')
inputFrame.columnconfigure(1, weight=1)
inputFrame.grid(column=0, row=0, padx=5, pady=5, sticky='ew')
# - Frame with output settings
outputFrame = LabelFrame(mainFrame, text='Output Settings')
outputFrame.columnconfigure(1, weight=1)
outputFrame.grid(column=0, row=1, padx=5, pady=5, sticky='ew')
# - Frame with buttons at the bottom of the dialog
buttonFrame = Frame(mainFrame)
buttonFrame.grid(column=0, row=2, padx=5, pady=5, sticky='e')
# Controls for input
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, width=70, textvariable=self.__ctrl.getDataSourceFileEntryVariable())
dataSourceFileEntry.grid(column=1, row=1, padx=5, pady=5, sticky='ew')
dataSourceFileButton = Button(inputFrame, text='...', command=self.__ctrl.dataSourceFileEntryVariableHandler)
dataSourceFileButton.grid(column=2, row=1, padx=5, pady=5, sticky='e')
# Controls for output
numberOfDataLinesToMergeLabel = Label(outputFrame, text='Number of rows to merge into this document:', width=35, anchor='w')
numberOfDataLinesToMergeLabel.grid(column=0, row=2, padx=5, pady=5, sticky='w')
# numberOfDataLinesToMergeListBox = OptionMenu(outputFrame, self.__ctrl.getSelectedNumberOfLines(), tuple(self.__ctrl.getNumerOfLinesList())) # TODO: implement these two functions in the controller
numberOfDataLinesToMergeListBox = apply(OptionMenu, (outputFrame, self.__ctrl.getSelectedNumberOfLines()) + tuple(self.__ctrl.getNumerOfLinesList()))
numberOfDataLinesToMergeListBox.grid(column=1, row=2, padx=5, pady=5, sticky='w')
# Buttons
cancelButton = Button(buttonFrame, text='Cancel', width=10, command=self.__ctrl.buttonCancelHandler)
cancelButton.grid(column=1, row=0, padx=5, pady=5, sticky='e')
runButton = Button(buttonFrame, text='Run', width=10, command=self.__ctrl.buttonOkHandler)
runButton.grid(column=2, row=0, padx=5, pady=5, sticky='e')
# Show the dialog
mainFrame.grid()
self.__root.grid()
self.__root.mainloop()
def _populate(self, frame):
settings_frame = LabelFrame(frame,
text='Material import',
borderwidth=config.FRAME_BORDER_WIDTH,
relief=config.FRAME_RELIEF)
settings_frame.grid(column=0,
row=0,
sticky=W + E + N + S,
padx=config.FRAME_PADDING,
pady=config.FRAME_PADDING)
self._create_entry_line(self.source_material_name, 'Source material',
None, settings_frame, 0, None)
self._create_entry_line(self.target_material_name, 'Target material',
None, settings_frame, 1, None)
def families(self):
from Tkinter import LabelFrame
families_frame = LabelFrame(self.root, height = 100, width = 150, text = "Family selection")
families_frame.grid(column = 1, row = 1, columnspan = 1, rowspan = 1)
import scrolledlist
family = scrolledlist.ScrolledList(families_frame, width = 20, height = 4)
from os import listdir
families = listdir('/home/case/TLEs')
for i in range(len(families)):
family.append(families[i])
family.grid(column = 0, row = 0, columnspan = 1, rowspan = 1)
def time(self):
from Tkinter import LabelFrame
time_frame = LabelFrame(self.root,
height=100,
width=150,
text="Time settings")
time_frame.grid(column=1, row=0, columnspan=1, rowspan=1)
from Tkinter import Radiobutton
time_now = Radiobutton(time_frame, text="Now", variable=time, value=1)
time_now.grid(column=0, row=0, columnspan=1, rowspan=1)
time_selection = Radiobutton(time_frame,
text="Select",
variable=time,
value=2)
time_selection.grid(column=0, row=1, columnspan=1, rowspan=1)
def _init_components(self):
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
# upper pane contains apex list
upper_pane = ListContainer(self)
self.apex_list = ApexList(upper_pane, self._apex)
upper_pane.set_listbox(self.apex_list)
# buttons pane contain
buttons_pane = Frame(self)
self._expand_button = Button(buttons_pane,
text="Expand All",
command=self.apex_list.expand_all)
self._expand_button.pack(side='left', expand=True, fill='x')
self._reset_button = Button(buttons_pane,
text="Collapse All",
command=self.apex_list.reset)
self._reset_button.pack()
# panel with number search box
search_pane = LabelFrame(self, text="Find number")
self._search_box = NumberBox(search_pane,
allow_expression=True,
constraints=Constraints(min=1))
self._search_box.pack(side='left', expand=True, fill='x')
self._search_box_initial_bg = self._search_box['bg']
self._search_box_alert_bg = '#ffaaaa'
self._search_box.bind('<Return>', self._find_number)
for event in ('<FocusIn>', '<FocusOut>', '<Key>'):
self._search_box.bind(event, self._reset_search_box_alert)
search_number_button = Button(search_pane,
text="Find",
command=self._find_number)
search_number_button.pack()
upper_pane.grid(sticky='nesw')
buttons_pane.grid(row=1, sticky='nesw')
search_pane.grid(row=2, sticky='nesw')
def families(self):
from Tkinter import LabelFrame
families_frame = LabelFrame(self.root,
height=100,
width=150,
text="Family selection")
families_frame.grid(column=1, row=1, columnspan=1, rowspan=1)
import scrolledlist
family = scrolledlist.ScrolledList(families_frame, width=20, height=4)
from os import listdir
families = listdir('/home/case/TLEs')
for i in range(len(families)):
family.append(families[i])
family.grid(column=0, row=0, columnspan=1, rowspan=1)
def createWidgets(self, master):
#-Set-progress-bar-style-for-custom-thickness--
s = Style()
s.theme_use("default")
s.configure("TProgressbar", thickness=5)
#----------------------------------------------
master.grid_rowconfigure(0, weight=1)
master.grid_columnconfigure(0, weight=1)
# +++++++++++++++++++++++++++++++
row = 0
col = 0
w = LabelFrame(master, text='Sample positioner status')
w.grid(row=row, column=col, sticky=NSEW, padx=5, pady=5)
self.populateDisplayPanel(w)
def ancestranNetPipe(self): #Interface
top = Toplevel()
top.title("NetworkComparer")
a = open("NetComp.html", "r").readlines()
self.queriesAC = []
quera = 0
for i in range(len(a)):
if "START OF QUERIES" in a[i]:
self.queryOrder = a[i + 1].rstrip().split()
if "START OF VS. QUERY" in a[i]:
quera = 1
if quera == 1:
self.queriesAC.append(a[i].rstrip().split("\t"))
self.queriesAC = self.queriesAC[1:len(self.queriesAC) - 1]
DescriptionLabel = LabelFrame(
top, text="Select the gene of interest and specify parameters.")
Description = Label(
DescriptionLabel,
text=
"Select gene of interest from the list below.\nThis tool will generate netComp.html file containing a page similar to\nfirst step of NetworkComparer."
)
DescriptionLabel.grid(row=0, column=0)
Description.grid(row=0)
self.listbox = Listbox(DescriptionLabel,
width=40,
height=30,
exportselection=0,
selectmode=MULTIPLE)
for gene in self.queriesAC:
self.listbox.insert(
END, gene[0] + ' ' + gene[1] + ' ' + gene[2] + ' ' +
gene[3] + ' ' + gene[4])
self.listbox.grid(row=1, column=0, rowspan=5, sticky=N + S + E + W)
scrollbarG = Scrollbar(DescriptionLabel)
scrollbarG.grid(row=1, column=1, rowspan=5, sticky=S + N)
scrollbarG.config(command=self.listbox.yview)
button = Button(top,
text="Calculate!",
fg="red",
font=("Courier", 22),
command=self.ancestralNet)
button.grid(row=1, column=0, columnspan=5, sticky=E + W)
def nvnReport(self): #interface for "Display probeset specific report"
top = Toplevel()
top.title("Co-expression analysis")
self.genelist = []
for string in self.queries:
self.genelist.append(string.split())
self.listbox = Listbox(top, width=40, height=30, exportselection=0)
for gene in self.genelist:
self.listbox.insert(END, gene[0] + ' ' + gene[1])
DescriptionLabel = LabelFrame(top, text="Info")
Description = Label(
DescriptionLabel,
text=
"Select gene of interest from the list to the left.\nThis tool will generate result.html file containing a page similar to\ngene specific pages in PlaNet."
)
DescriptionLabel.grid(row=0, column=2)
ParametersLabel = LabelFrame(top, text="Parameters")
Steps = Label(ParametersLabel, text="Number of steps")
ParametersLabel.grid(row=1, column=2)
Hrr = Label(ParametersLabel, text="HRR cut-off.")
self.paraSteps = Entry(ParametersLabel)
self.paraSteps.grid(row=1)
self.paraSteps.insert(END, 2)
self.paraHrr = Entry(ParametersLabel)
self.paraHrr.grid(row=3)
self.paraHrr.insert(END, 30)
Description.grid()
Steps.grid(row=0)
Hrr.grid(row=2)
scrollbar = Scrollbar(top)
scrollbar.grid(row=0, column=1, rowspan=5, sticky=S + N)
self.listbox.grid(row=0, column=0, rowspan=5)
scrollbar.config(command=self.listbox.yview)
button = Button(top,
text="Calculate!",
fg="red",
font=("Courier", 22),
command=self.nvnReportPipe)
button.grid(row=6, column=0)
def __init__(self, master, tracker, text="Repositioning", **kwargs):
LabelFrame.__init__(self, master, text=text, **kwargs)
self.tracker = tracker
self.source_selector = FileSelectionFrame(self, initial_dir=nodes_dir,
ask_mode="open",
text="Source")
self.source_selector.grid(row=0, column=0)
self.dest_selector = FileSelectionFrame(self, initial_dir=nodes_dir,
ask_mode="save", text="Dest")
self.dest_selector.grid(row=0, column=1)
# The names and positions we gather:
self.name_fields = []
self.posn_labels = []
self.training_info = []
for i in range(3):
# Why three? Well, we need three training points to figure
# out where all the other points are. Proof: take your
# fist and move it around (it's a rigid structure, like
# the arrangement of retroreflectors), and think about how
# many points (e.g. knuckles) you'd need to know the
# positions of to figure out the positions of all your
# other knuckles. (It's three. If you disagree, please
# think about it more until you agree, because I am
# absolutely confident.)
f = LabelFrame(self, text="(Name/position) ({})".format(i))
self.name_fields.append(Entry(f))
self.name_fields[-1].grid(row=0, column=0)
self.posn_labels.append(Label(f, text="<None>"))
self.posn_labels[-1].grid(row=0, column=1)
b = Button(f, text="Set",
command=bg_caller(deglobalize_args(self.set_position,
i)))
b.grid(row=0, column=2)
f.grid(row=1+i, column=0, columnspan=2)
self.training_info.append(None)
Button(self, text="Compute/Save", command=self.save).grid(row=4,
column=0)
class ReadOnlyEntryDemo(Frame):
def __init__(self, master):
self.master = master
Frame.__init__(self, master)
self.entryFrame = LabelFrame(self, text="Enter Text and press Button : ")
self.entryFrame.grid(row=0, column=0, pady=10)
self.userInputEntry = Entry(self.entryFrame, width=50)
self.userInputEntry.grid(row=0, column=0)
self.setButton = Button(self.entryFrame, text="Set Text", command=self.setText)
self.setButton.grid(row=1, column=0)
self.withFocusFrame = LabelFrame(self, text="Readonly Widget: With Focus example (Try typing in this widget)")
self.withFocusFrame.grid(row=1, column=0, pady=10)
self.readOnlyFocus = ReadOnlyEntry(self.withFocusFrame, withFocus=True)
self.readOnlyFocus.grid(row=0, column=0)
self.withoutFocusFrame = LabelFrame(self, text="Readonly Widget: Without Focus example (Try typing in this widget)")
self.withoutFocusFrame.grid(row=2, column=0, pady=10)
self.readOnlyNoFocus = ReadOnlyEntry(self.withoutFocusFrame, withFocus=False)
self.readOnlyNoFocus.grid(row=0, column=0)
def setText(self):
self.readOnlyFocus.set(self.userInputEntry.get())
self.readOnlyNoFocus.set(self.userInputEntry.get())
def populateAxisPanel(self, master):
master.grid_columnconfigure(0, weight=1)
row = 0
col = 0
w = LabelFrame(master, text='Axes')
w.grid(row=row, column=col, sticky=NSEW, padx=5, pady=5)
self.populateAxesFrame(w)
row += 1
w = LabelFrame(master, text='Available fields')
w.grid(row=row, column=col, sticky=NSEW, padx=5, pady=5)
self.populateFieldsFrame(w)
row += 1
w = Frame(master)
w.grid(row=row, column=col, sticky=NSEW, padx=5, pady=5)
self.populateButtonFrame(w)
row += 1
w = LabelFrame(master, text='Sample details')
w.grid(row=row, column=col, sticky=NSEW, padx=5, pady=5)
self.populateSampleFrame(w)
def populateWindow(self, master):
master.grid_columnconfigure(0, weight=1)
master.title('Qrius: Preferences dialog')
master.protocol('WM_DELETE_WINDOW', self.wCancelCB)
w = LabelFrame(master, text='User settings')
w.grid(row=0, column=0, sticky=NSEW, padx=5, pady=5, ipady=5)
self.populateUserPreferencesFrame(w)
w = LabelFrame(
master,
text='System settings' +
('' if self.is_admin() else ' (need to be administrator)'))
w.grid(row=1, column=0, sticky=NSEW, padx=5, pady=5, ipady=5)
self.populateSystemPreferencesFrame(w)
#self.enable_group (w, enable = True if self.is_admin() else False)
w = LabelFrame(master, borderwidth=0)
w.grid(row=2, column=0, sticky=NSEW, padx=5, pady=5)
self.populateOkCancelFrame(w)
def setup_depositing_section(self):
depositing = LabelFrame(self.parent, width=col_w, height=row_h, text="Depositing Status")
depositing.grid(row=1, column=1)
self.dep_txt = Text(depositing, height=18, width=65)
self.dep_txt.pack(fill=BOTH, expand=1)
def setup_move_section(self):
mv = LabelFrame(self.parent, width=col_w, height=row_h, text="Moving Status")
mv.grid(row=2, column=1)
self.mv_txt = Text(mv, height=18, width=65)
self.mv_txt.pack(fill=BOTH, expand=1)
def setup_controller_section(self):
controller = LabelFrame(self.parent, width=col_w * 2, height=row_h, text="Controller Status")
controller.grid(row=0, column=1, columnspan=2)
self.ctrl_txt = Text(controller, height=18, width=130)
self.ctrl_txt.pack(fill=BOTH, expand=1)
def setup_env_aw_section(self):
env_aw = LabelFrame(self.parent, width=col_w, height=row_h, text="Environment Awareness Status")
env_aw.grid(row=2, column=2)
self.env_aw_txt = Text(env_aw, height=18, width=65)
self.env_aw_txt.pack(fill=BOTH, expand=1)
class TkRunner(Toplevel):
info_text = None
paddingArgs = {'padx': 3, 'pady': 3}
def __init__(self, parent):
'''
Constructor.
'''
FORMAT = '%(message)s'
logging.basicConfig(format=FORMAT, level=logging.DEBUG)
Toplevel.__init__(self, parent)
self.wm_withdraw()
self.resizable(height=FALSE, width=FALSE)
#self.wm_deiconify()
self.url = StringVar()
self.master = parent
self.configure(borderwidth=5)
self.init_gui()
def init_gui(self):
'''
Initialize a simple gui.
'''
top = Frame(self.master)
top.grid(**self.paddingArgs)
#======================================================================
# Top frame
#======================================================================
info_frame = Frame(top)
info_frame.grid(column=0, row=0)
text = Label(info_frame, text='OCCI service URL:')
text.grid(column=0, row=0, **self.paddingArgs)
# self.url.set('http://fjjutraa.joyent.us:8888')
self.url.set('http://localhost:8888')
entry = Entry(info_frame, width=25, textvariable=self.url)
entry.grid(column=1, row=0, **self.paddingArgs)
go = Button(info_frame, text='Go', command=self.run_tests)
go.grid(column=2, row=0, **self.paddingArgs)
reset = Button(info_frame, text='Reset', command=self.reset)
reset.grid(column=3, row=0, **self.paddingArgs)
#======================================================================
# Test frame
#======================================================================
self.test_frame = LabelFrame(top, borderwidth=2, relief='groove',
text='Tests')
self.test_frame.grid(row=1, **self.paddingArgs)
i = 0
for item in self._get_tests().keys():
label = Label(self.test_frame, text=item)
label.grid(row=i, sticky=W, **self.paddingArgs)
label2 = Label(self.test_frame, text='...')
label2.grid(column=1, row=i, sticky=N + E + W + S,
**self.paddingArgs)
i += 1
#======================================================================
# Bottom
#======================================================================
note = 'NOTE: Passing all tests only indicates that the service\n'
note += 'you are testing is OCCI compliant - IT DOES NOT GUARANTEE IT!'
label = Label(top, text=note)
label.grid(row=2, **self.paddingArgs)
quit_button = Button(top, text='Quit', command=self.quit)
quit_button.grid(row=3, sticky=E, **self.paddingArgs)
def run_tests(self):
url = self.url.get()
i = 0
tests = self._get_tests()
for item in tests.keys():
func = tests[item]
label = Label(self.test_frame, text=item)
label.grid(column=0, row=i, sticky=W, **self.paddingArgs)
try:
label2 = Label(self.test_frame, text=func(url),
background='green')
label2.grid(column=1, row=i, sticky=N + E + W + S,
**self.paddingArgs)
except TestFailure as error:
logging.error(error)
label2 = Label(self.test_frame, text='Failed',
background='red')
label2.grid(column=1, row=i, sticky=N + E + W + S,
**self.paddingArgs)
i += 1
def reset(self):
i = 0
for item in self._get_tests().keys():
label = Label(self.test_frame, text=item)
label.grid(column=0, row=i, sticky=W, **self.paddingArgs)
label2 = Label(self.test_frame, text='...')
label2.grid(column=1, row=i, sticky=N + E + W + S,
**self.paddingArgs)
i += 1
def _get_tests(self):
'''
Return with dict with test description and func
'''
res = {}
for item in dir(test_occi_11):
if item.find('test_') != -1:
func = getattr(test_occi_11, item)
desc = func.__doc__.strip()
res[desc] = func
return res
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.bind((host, port))
self.grid()
self.columnconfigure(0, minsize=100)
self.columnconfigure(1, minsize=200)
self.columnconfigure(2, minsize=200)
self.columnconfigure(3, minsize=150)
self.columnconfigure(4, minsize=150)
self.columnconfigure(5, minsize=150)
self.columnconfigure(6, minsize=150)
self.create_widgets()
self.settables = self.assemble_settables()
self.gui_logger = logging.getLogger('gui')
self.request_update()
def create_widgets(self):
self.create_monitor()
self.create_check_buttons()
self.create_ranges()
self.create_scales()
self.create_radio_buttons()
self.create_voices()
self.quitButton = Button(self, text='Quit', command=self.quit)
self.quitButton.grid(columnspan=7, sticky=E + W)
def assemble_settables(self):
settables = self.winfo_children()
for w in settables:
settables += w.winfo_children()
return filter(lambda w: w.__class__.__name__ in ['Scale', 'Checkbutton'], settables)
def create_radio_buttons(self):
# Scale related
entries = ['DIATONIC', 'HARMONIC', 'MELODIC', 'PENTATONIC', 'PENTA_MINOR']
self.scale = StringVar()
self.scale.set('DIATONIC')
self.rb_frame = Frame(self)
for e in entries:
rb = Radiobutton(self.rb_frame, value=e, text=e, anchor=W,
command=self.send_scale, variable=self.scale)
rb.grid(row=len(self.rb_frame.winfo_children()), sticky=W)
self.rb_frame.grid(column=1, row=len(self.grid_slaves(column=1)), rowspan=3)
def create_monitor(self):
self.monitor_frame = LabelFrame(self, text="Monitor and Transport")
this_cycle = Scale(self.monitor_frame, label='cycle_pos', orient=HORIZONTAL,
from_=1, to=16, resolution=1)
this_cycle.disable, this_cycle.enable = (None, None)
this_cycle.ref = 'cycle_pos'
this_cycle.grid(column=0, row=0, sticky=E + W)
self.updateButton = Button(self.monitor_frame,
text='Reload all Settings',
command=self.request_update)
self.updateButton.grid(row=1, sticky=E + W)
self.ForceCaesuraButton = Button(self.monitor_frame,
text='Force Caesura',
command=self.force_caesura)
self.ForceCaesuraButton.grid(row=2, sticky=E + W)
self.saveBehaviourButton = Button(self.monitor_frame,
text='Save current behaviour',
command=self.request_saving_behaviour)
self.saveBehaviourButton.grid(row=3, sticky=E + W)
self.saveBehaviourNameEntry = Entry(self.monitor_frame)
self.saveBehaviourNameEntry.grid(row=4, sticky=E + W)
self.saveBehaviourNameEntry.bind('<KeyRelease>', self.request_saving_behaviour)
self.selected_behaviour = StringVar()
self.selected_behaviour.trace('w', self.new_behaviour_chosen)
self.savedBehavioursMenu = OptionMenu(self.monitor_frame,
self.selected_behaviour, None,)
self.savedBehavioursMenu.grid(row=5, sticky=E + W)
self.monitor_frame.grid(column=0, row=10, sticky=E + W)
def request_update(self):
self.send({'sys': 'update'})
def request_saving_behaviour(self, event=None):
"""callback for save behaviour button and textentry"""
if event and event.widget == self.saveBehaviourNameEntry:
if event.keysym == 'Return':
name = self.saveBehaviourNameEntry.get()
self.saveBehaviourNameEntry.delete(0, len(name))
else:
return
else: # button was pressed
name = self.saveBehaviourNameEntry.get()
if name:
self.send({'sys': ['save_behaviour', name]})
def force_caesura(self):
self.send({'force_caesura': True})
def create_voices(self):
voice_ids = ['1', '2', '3', '4']
SCALES = OrderedDict([
('pan_pos', {'min': -1, 'max': 1, 'start': 0.5, 'res': 0.001}),
('volume', {'min': 0, 'max': 1, 'start': 0.666, 'res': 0.001}),
('slide_duration_msecs', {'min': 0, 'max': 2000, 'start': 60, 'res': 1}),
('slide_duration_prop', {'min': 0, 'max': 2, 'start': 0.666, 'res': 0.001}),
('binaural_diff', {'min': 0, 'max': 66, 'start': 0.2, 'res': 0.01})
])
for vid in voice_ids:
counter = 0
for sca in SCALES:
name = 'voice_' + vid + '_' + sca
setattr(self, 'min_' + name, SCALES[sca]['min'])
setattr(self, 'max_' + name, SCALES[sca]['max'])
this_sca = Scale(self, label=sca, orient=HORIZONTAL,
from_=getattr(self, 'min_' + name),
to=getattr(self, 'max_' + name),
resolution=SCALES[sca]['res'])
this_sca.enable = ('enable' in SCALES[sca].keys() and
SCALES[sca]['enable'] or None)
this_sca.disable = ('disable' in SCALES[sca].keys() and
SCALES[sca]['disable'] or None)
this_sca.grid(column=int(2 + int(vid)), row=counter, sticky=E + W)
this_sca.bind("<ButtonRelease>", self.scale_handler)
this_sca.ref = name
counter += 1
CHECK_BUTTONS = OrderedDict(
[('mute', False),
('automate_binaural_diffs', True),
('automate_note_duration_prop', True),
('use_proportional_slide_duration', {'val': True, 'label': 'proportional slide'}),
('automate_pan', True),
('automate_wavetables', True)])
for vid in voice_ids:
counter = 0
cb_frame = LabelFrame(self, text="Voice {0} - Automation".format(vid))
setattr(self, 'voice_' + vid + '_cb_frame', cb_frame)
for cb in CHECK_BUTTONS:
options = CHECK_BUTTONS[cb]
name = 'voice_' + vid + '_' + cb
label = (options['label'] if isinstance(options, dict) and
'label' in options.keys() else
(cb[9:] if cb[:9] == 'automate_' else cb))
setattr(self, name, IntVar(value=type(options) == dict and options['val'] or options))
self.this_cb = Checkbutton(cb_frame, text=label, variable=getattr(self, name))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = None
self.this_cb.grid(sticky=W, column=0, row=counter)
self.this_cb.ref = name
counter += 1
# add trigger wavetable-button
trigWavetableButton = Button(cb_frame, text='Next Wavetable')
trigWavetableButton.bind('<Button-1>', self.trigger_waveform_handler)
trigWavetableButton.ref = 'voice_' + vid + "_trigger_wavetable"
trigWavetableButton.grid(row=counter)
cb_frame.grid(column=int(vid) + 2, row=5, sticky=E + W + N, rowspan=8)
for vid in voice_ids:
generation_types = ["random", "random_harmonic", "harmonic"]
partial_pools = ["even", "odd", "all"]
prefix = 'voice_' + vid + '_'
types_name = prefix + 'wavetable_generation_type'
pools_name = prefix + 'partial_pool'
setattr(self, types_name, StringVar())
getattr(self, types_name).set("random")
setattr(self, pools_name, StringVar())
getattr(self, pools_name).set("all")
target_frame = getattr(self, 'voice_' + vid + '_cb_frame')
gen_typ_frame = LabelFrame(target_frame, text="type")
gen_typ_frame.grid(row=len(target_frame.winfo_children()), sticky=W)
for gen_t in generation_types:
gen_t_entry = Radiobutton(gen_typ_frame, value=gen_t, text=gen_t, anchor=W,
variable=getattr(self, types_name))
gen_t_entry.bind('<ButtonRelease-1>', self.wt_handler)
gen_t_entry.ref = types_name
gen_t_entry.grid(row=len(gen_typ_frame.winfo_children()), sticky=W)
pp_frame = LabelFrame(target_frame, text="harmonics")
for pp in partial_pools:
pp_entry = Radiobutton(pp_frame, value=pp, text=pp, anchor=W,
variable=getattr(self, pools_name))
pp_entry.bind('<ButtonRelease-1>', self.wt_handler)
pp_entry.ref = pools_name
pp_entry.grid(row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials = Scale(pp_frame, label='number of harmonics', orient=HORIZONTAL,
from_=1, to=24, resolution=1)
this_num_partials.ref = prefix + 'num_partials'
this_num_partials.grid(column=0, row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials.bind("<ButtonRelease>", self.scale_handler)
pp_frame.grid(row=len(target_frame.winfo_children()), sticky=E + W)
def wt_handler(self, event):
print event.widget.tk
ref = event.widget.ref
self.send({ref: getattr(self, ref).get()})
def create_check_buttons(self):
self.cb_frame = LabelFrame(self, text="Global Settings")
for cb in CHECK_BUTTONS:
label = cb
target_parent = self.cb_frame
if isinstance(CHECK_BUTTONS[cb], dict) and 'sub_frame' in CHECK_BUTTONS[cb].keys():
target_parent = getattr(self, CHECK_BUTTONS[cb]['sub_frame'])
setattr(self, cb, IntVar(value=type(CHECK_BUTTONS[cb]) == dict and
CHECK_BUTTONS[cb]['val'] or
CHECK_BUTTONS[cb]))
self.this_cb = Checkbutton(target_parent, text=label, variable=getattr(self, cb))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = (type(CHECK_BUTTONS[cb]) == dict and
'disable' in CHECK_BUTTONS[cb].keys())
self.this_cb.grid(sticky=W, column=0, row=len(target_parent.winfo_children()))
self.this_cb.ref = cb
for but in GLOBAL_BUTTONS:
label = but
ele = GLOBAL_BUTTONS[but]
this_but = Button(self.cb_frame, text=but)
this_but.bind('<ButtonRelease-1>', getattr(self, ele['handler']))
this_but.ref = but
this_but.grid(sticky=W, column=0, row=len(self.cb_frame.winfo_children()))
self.cb_frame.grid(column=0, row=0, rowspan=10, sticky=N)
def new_behaviour_chosen(self, a, b, c):
self.send({'sys': ['change_behaviour', self.selected_behaviour.get()]})
def set_value(self, name, val):
'''sets a widget to the specified value
various different widget types need custom setting functionality'''
direct = ['scale', 'wavetable_generation_type', 'partial_pool']
if filter(lambda x: match("(voice_\d_|)" + x, name), direct):
self.gui_logger.info("setting: '{0}' to '{1}' in GUI".format(name, val))
getattr(self, name).set(val)
return
if name == 'saved_behaviours' and len(val):
self.savedBehavioursMenu.destroy()
self.savedBehavioursMenu = OptionMenu(self.monitor_frame,
self.selected_behaviour, *sorted(val))
self.savedBehavioursMenu.grid(row=5, sticky=E + W)
return
for w in self.settables:
typ = w.__class__.__name__
if w.ref == name:
#print "setting '{0}' of type: '{1}' to: {2}".format(name, typ, val)
if typ == 'Scale':
w.set(val)
elif typ == "Checkbutton":
w.select() if val else w.deselect()
def check_boxes_handler(self, event):
'''handles checkbox events.
shows and hides gui elements according to their enable/disable fields'''
#print event.__dict__
#print event.widget.__dict__
ref = event.widget.ref
val = not getattr(self, ref).get() # because is read before the var is changed
self.send({ref: val})
#print ref, val
# handle gui elements
# enable/disable functionality temporarily(?) commented on:
# Wed Aug 17 09:39:54 CEST 2011
# if event.widget.disable:
# for w in self.children.values():
#
# # this try clause is for debugging, remove when stable
# try:
# w.ref
# #print w.ref
# except:
# pass
# if (w.__class__.__name__ == 'Scale' and
# (w.disable or w.enable)):
# if w.disable == ref:
# if val:
# w.grid()
# else:
# w.grid_remove()
# elif w.enable == ref:
# if val:
# w.grid_remove()
# else:
# w.grid()
# #print w.disable, w.enable
def create_scales(self):
counter = 0
for sca in SCALES:
label = SCALES[sca]['label'] if 'label' in SCALES[sca].keys() else sca
setattr(self, 'min_' + sca, SCALES[sca]['min'])
setattr(self, 'max_' + sca, SCALES[sca]['max'])
self.this_scale = Scale(self, label=label, orient=HORIZONTAL,
from_=getattr(self, 'min_' + sca),
to=getattr(self, 'max_' + sca),
resolution=SCALES[sca]['res'])
self.this_scale.set(SCALES[sca]['start'])
self.this_scale.enable = ('enable' in SCALES[sca].keys() and
SCALES[sca]['enable'] or None)
self.this_scale.disable = ('disable' in SCALES[sca].keys() and
SCALES[sca]['disable'] or None)
if 'pos' in SCALES[sca].keys():
pos = SCALES[sca]['pos']
col = pos['c']
row = pos['r']
else:
row = counter
col = 1
counter += 1
self.this_scale.grid(column=col, row=row, sticky=E + W)
self.this_scale.ref = sca
self.this_scale.bind("<ButtonRelease>", self.scale_handler)
def scale_handler(self, event):
self.send({event.widget.ref: event.widget.get()})
self.gui_logger.info("handling scale: {0}, with new value: {1}".format(
event.widget.ref, event.widget.get()))
def trigger_waveform_handler(self, event):
self.send({event.widget.ref: True})
#print event.widget.ref, "- triggering wavetable"
def send_scale(self):
do = {'scale': self.scale.get()}
self.send(do)
#print do
def send(self, msg):
self.gui_logger.info("sending: {0}".format(msg))
self.send_sock.sendto(json.dumps(msg), (remote_host, send_port))
def create_ranges(self):
counter = 0
for ran in RANGES:
setattr(self, 'min_' + ran, RANGES[ran]['min'])
setattr(self, 'max_' + ran, RANGES[ran]['max'])
self.this_min_scale = Scale(self, label='min ' + ran, orient=HORIZONTAL,
from_=getattr(self, 'min_' + ran),
to=getattr(self, 'max_' + ran),
resolution=RANGES[ran]['res'])
self.this_max_scale = Scale(self, label='max ' + ran, orient=HORIZONTAL,
from_=getattr(self, 'min_' + ran),
to=getattr(self, 'max_' + ran),
resolution=RANGES[ran]['res'])
self.this_min_scale.set(RANGES[ran]['min_start'])
self.this_max_scale.set(RANGES[ran]['max_start'])
self.this_min_scale.enable = ('enable' in RANGES[ran].keys() and
RANGES[ran]['enable'] or None)
self.this_min_scale.disable = ('disable' in RANGES[ran].keys() and
RANGES[ran]['disable'] or None)
self.this_max_scale.enable = ('enable' in RANGES[ran].keys() and
RANGES[ran]['enable'] or None)
self.this_max_scale.disable = ('disable' in RANGES[ran].keys() and
RANGES[ran]['disable'] or None)
self.this_min_scale.grid(column=2, row=counter, sticky=E + W)
self.this_max_scale.grid(column=2, row=counter + 1, sticky=E + W)
self.this_min_scale.ref = 'min_' + ran
self.this_max_scale.ref = 'max_' + ran
self.this_min_scale.bind("<ButtonRelease>", self.scale_handler)
self.this_max_scale.bind("<ButtonRelease>", self.scale_handler)
counter += 2
def socket_read_handler(self, file, mask):
data_object = json.loads(file.recv(1024))
do = data_object.items()[0]
#print "do:", do
self.set_value(do[0], do[1])
def __init__(self, app, printer, settings, logger, *arg):
self.app = app
self.printer = printer
self.settings = settings
self.logger = logger
self.afterID = None
self.selection = None
if not self.app.printing:
self.logger.logMsg("Report only available while printing")
return
Toplevel.__init__(self, app, *arg)
self.title("Layer by Layer Timing")
self.protocol("WM_DELETE_WINDOW", self.doCancel)
fUL = Frame(self)
fUL.grid(row=1, column=1, rowspan=2, padx=10)
l = Label(fUL, text="Choose layer:")
l.pack()
lbf = Frame(fUL)
lbf.pack()
self.lbLayers = Listbox(lbf)
self.lbLayers.bind("<ButtonRelease-1>", self.clickLayers)
self.sb = Scrollbar(lbf, orient=VERTICAL)
self.sb.config(command=self.lbLayers.yview)
self.lbLayers.config(yscrollcommand=self.sb.set)
self.sb.pack(side=RIGHT, fill=Y)
self.lbLayers.pack(side=LEFT, fill=BOTH, expand=1)
rbf = LabelFrame(fUL, text="Time Format")
rbf.pack()
self.rbvTimeFmt = StringVar()
self.rbvTimeFmt.set(TIME_WALL)
rb = Radiobutton(rbf, text="Wall time", variable=self.rbvTimeFmt, value=TIME_WALL, command=self.doTimeFormat)
rb.pack(anchor=W)
rb = Radiobutton(rbf, text="From start", variable=self.rbvTimeFmt, value=TIME_START, command=self.doTimeFormat)
rb.pack(anchor=W)
rb = Radiobutton(rbf, text="From now", variable=self.rbvTimeFmt, value=TIME_NOW, command=self.doTimeFormat)
rb.pack(anchor=W)
fUR = Frame(self)
fUR.grid(row=1, column=2, rowspan=2, padx=10)
row = 1
lf = LabelFrame(fUR, text="Print Times: ")
lf.grid(row=row, column=1)
l = Label(lf, text="Start: ", width=12, justify=RIGHT)
l.grid(row=1, column=1, padx=10, sticky=E)
self.timePStart = Label(lf, text="", anchor=W, justify=LEFT)
self.timePStart.grid(row=1, column=3, padx=10)
l = Label(lf, text="Elapsed: ", width=12, justify=RIGHT)
l.grid(row=2, column=1, padx=10, sticky=E)
self.timeElapsed = Label(lf, text="", anchor=W, justify=LEFT)
self.timeElapsed.grid(row=2, column=3, padx=10)
l = Label(lf, text="Current: ", width=12, justify=RIGHT)
l.grid(row=3, column=1, padx=10, sticky=E)
self.timeNow = Label(lf, text="", anchor=W, justify=LEFT)
self.timeNow.grid(row=3, column=3, padx=10)
row += 1
lf = LabelFrame(fUR, text="Layer Start Time: ")
lf.grid(row=row, column=1)
l = Label(lf, text="original: ", width=12, justify=RIGHT)
l.grid(row=1, column=1, padx=10, sticky=E)
self.timeOStart = Label(lf, text="", anchor=W, justify=LEFT)
self.timeOStart.grid(row=1, column=2, padx=10)
l = Label(lf, text="revised: ", width=12, justify=RIGHT)
l.grid(row=2, column=1, padx=10, sticky=E)
self.timeRStart = Label(lf, text="", anchor=W, justify=LEFT)
self.timeRStart.grid(row=2, column=2, padx=10)
row += 1
lf = LabelFrame(fUR, text="Time in Layer: ")
lf.grid(row=row, column=1)
l = Label(lf, text="original: ", width=12, justify=RIGHT)
l.grid(row=1, column=2, padx=10, sticky=E)
self.timeOLayer = Label(lf, text="", anchor=W, justify=LEFT)
self.timeOLayer.grid(row=1, column=3, padx=10)
l = Label(lf, text="revised: ", width=12, justify=RIGHT)
l.grid(row=2, column=2, padx=10, sticky=E)
self.timeRLayer = Label(lf, text="", anchor=W, justify=LEFT)
self.timeRLayer.grid(row=2, column=3, padx=10)
row += 1
lf = LabelFrame(fUR, text="Layer Finish Time: ")
lf.grid(row=row, column=1)
l = Label(lf, text="original: ", width=12, justify=RIGHT)
l.grid(row=1, column=2, padx=10, sticky=E)
self.timeOFinish = Label(lf, text="", anchor=W, justify=LEFT)
self.timeOFinish.grid(row=1, column=3, padx=10)
l = Label(lf, text="revised: ", width=12, justify=RIGHT)
l.grid(row=2, column=2, padx=10, sticky=E)
self.timeRFinish = Label(lf, text="", anchor=W, justify=LEFT)
self.timeRFinish.grid(row=2, column=3, padx=10)
self.ticker()
class TKEA_win(object):
def __init__(self,ea,p,rec,varlist):
self.vl=varlist # list of EA attributes which you wanna make accessible via window
self.ea=ea # the EA instance
self.ea.generation_callbacks.append(self.update_solu_canvas)
self.ea.generation_callbacks.append(self.update_mstep_bar)
self.ea.generation_callbacks.append(self.rec_save_status)
self.ea.generation_callbacks.append(self.acp_update)
self.acp_type='linear' # also allowed up to date: 'semilogy'
self.acp_ylim=False
self.acp_freq=1
self.update_freq=1
self.p=p # main population
self.rec=rec
tmppop=population_like(p,size=1)
self.frontman=tmppop[0] # an extra individual, the one bein plotted
def appear(self):
self.mwin=Tk() # root or main window
self.mwin.title('EA progress visualisation')
self.setupFig()
self.setupWindow()
def setupFig(self):
self.fig=plt.figure(figsize=(8,7), dpi=80)
self.sp1=self.fig.add_subplot(211) # additional colorbar might be created under the name self.sp1_cb
self.sp2=self.fig.add_subplot(212) # additional colorbar might be created under the name self.sp2_cb
self.sp1t=self.sp1.set_title('ini')
self.sp2t=self.sp2.set_title('ini')
def setupWindow(self):
self.f_inp=Frame(self.mwin); self.f_inp.pack(side='left')
self.f_plot=Frame(self.mwin); self.f_plot.pack(side='right')
self.c=FigureCanvasTkAgg(self.fig, master=self.f_plot); self.c.show()
self.c.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
# setup the input area
self.f_actn=LabelFrame(self.f_inp,text='action'); self.f_actn.grid(row=0,column=0)
self.f_gg=Frame(self.f_actn); self.f_gg.pack()
l_gg=Label(self.f_gg,text='generations'); l_gg.pack()
self.e_gg = Entry(self.f_gg); self.e_gg.pack(); self.e_gg.insert(0,'40') # number of generations
self.b_rini=Button(self.f_actn,text='randini',command=self.randini); self.b_rini.pack()
self.b_run1=Button(self.f_actn,text='update & run',command=self.run_with_readout); self.b_run1.pack()
self.b_run2=Button(self.f_actn,text='run (continue)',command=self.run_no_readout); self.b_run2.pack()
if len(self.vl): self.add_entries(self.vl)
# draw initial plot
self.draw_ini_solu() # sort of setting up instructive initial geometry plot of non-optimised geometry
self.acp_ini()
self.f_tb=Frame(self.f_plot); self.f_tb.pack()
self.tb=NavigationToolbar2TkAgg(self.c,self.f_tb)
self.c2=Canvas(self.f_inp,width=80,height=140); self.c2.grid(row=4,column=0)
self.ini_mstep_bar()
def add_entries(self,vl):
for el in vl:
if not hasattr(self.ea,el['name']):
raise TypeError('you try to set up an entry for a name which is no attribute of the chosen EA')
fr=Frame(self.f_actn); fr.pack()
lab=Label(fr,text=el['name']); lab.pack()
e = Entry(fr); e.pack(); e.insert(0,str(el['inival'])) # number of generations
el['Entry']=e
def draw_ini_solu(self):
self.frontman.plot_into_axes(self.sp1)
txt='initial DNA'.format(self.frontman.DNA)
self.sp1t.set_text(txt)
def draw_solu(self,dude):
self.frontman.copy_DNA_of(dude,copyscore=True,copyparents=True,copyancestcode=True)
self.frontman.evaluate()
self.frontman.update_plot(self.sp1)
txt='generation {}: score is {:.3f} after {} function calls'.format(self.p.gg,self.ea.bestdude.score,self.ea.tell_neval())
#self.sp1t.set_text(txt)
self.sp1.set_title(txt)
self.c.draw()
def mainloop(self):
self.mwin.mainloop()
def randini(self):
self.p.reset()
self.rec.clear()
self.ea.bestdude=None
self.ea.zeroth_generation(random_ini=True)
self.draw_solu(self.ea.bestdude)
self.c.draw()
def run_with_readout(self):
for el in self.vl:
if el['type'] is float:
val=float(el['Entry'].get())
exec('self.ea.'+el['name']+'='+str(val))
elif el['type'] is int:
val=int(float(el['Entry'].get()))
exec('self.ea.'+el['name']+'='+str(val))
elif el['type'] is str:
val=el['Entry'].get()
exec('self.ea.'+el['name']+"='"+val+"'")
elif el['type'] is list:
val=el['Entry'].get()
exec('self.ea.'+el['name']+"="+val)
print 'string {} and what resulted {}'.format(val,eval('self.ea.'+el['name']))
else:
raise NotImplementedError('only float and int parameters cared for at this point')
self.ea.run(int(float(self.e_gg.get())))
def run_no_readout(self):
self.ea.run(int(float(self.e_gg.get())))
def update_solu_canvas(self,eaobj):
if np.mod(self.p.gg,self.update_freq)==0:
self.draw_solu(self.ea.bestdude)
def ini_mstep_bar(self):
fg_color=bluered4hex(0.36); #textcolor='white'
self.c2.create_rectangle(43,0,57,140,fill='white',outline='white')
mstep_barheight=int(-0.25*log10(self.ea.mstep)*140); mstep_barheight=clip(mstep_barheight,0,140)
self.mstep_bar=self.c2.create_rectangle(43,mstep_barheight,57,140,fill='green',outline='green')
for h in [2,35,70,105,140]:
self.c2.create_line(40,h,60,h,width=2,fill=fg_color)
for h,poww in zip([6,30,65,100,130],['0','-1','-2','-3','-4']):
self.c2.create_text(20,h,text='10**'+poww,font=('Courier','6'))
def update_mstep_bar(self,eaobj):
mstep_barheight=int(-0.25*log10(self.ea.mstep)*140); mstep_barheight=clip(mstep_barheight,0,140)
self.c2.coords(self.mstep_bar,43,mstep_barheight,57,140)
self.mwin.update_idletasks()
def rec_save_status(self,eaobj):
self.rec.save_status()
def acp_ini(self,whiggle=0):
x=[]; y=[]; farbe=[]
for i,g in enumerate(self.rec.gg):
for j in range(self.p.psize):
x.append(g)
y.append(self.rec.adat['scores'][i][j])
farbe.append(self.rec.adat['ancestcodes'][i][j])
x.append(0); y.append(0); farbe.append(0.) # for normalisation of color map
x.append(0); y.append(0); farbe.append(1.) # for normalisation of color map
x=flipud(array(x)); y=flipud(array(y)); farbe=flipud(array(farbe))
if whiggle: x=x+whiggle*npr.rand(len(x))-0.5*whiggle
self.acdots=self.sp2.scatter(x,y,marker='o',c=farbe,cmap=ancestcolors,zorder=True)
if self.acp_type=='semilogy':
self.sp2.semilogy()
if self.acp_ylim:
self.sp2.axis((0,self.p.gg,self.acp_ylim[0],self.acp_ylim[1]))
else:
self.sp2.axis((0,self.p.gg,0,np.max(y)))
def acp_update(self,eaobj,whiggle=0):
if np.mod(self.p.gg,self.acp_freq)==0:
self.sp2.cla()
self.acp_ini(whiggle=whiggle)
self.c.draw()
def netComparer(self): #Interface
top = Toplevel()
top.title("NetworkComparer")
self.genelistNC = []
for string in self.queries:
if "No hit" not in string:
self.genelistNC.append(string.split("\t"))
DescriptionLabel = LabelFrame(
top, text="Select the gene of interest and specify parameters.")
Description = Label(
DescriptionLabel,
text=
"Select gene of interest from the list below.\nThis tool will generate netComp.html file containing a page similar to\nfirst step of NetworkComparer."
)
DescriptionLabel.grid(row=0, column=0)
Description.grid(row=0)
ParametersLabel = LabelFrame(DescriptionLabel, text="Parameters")
Steps = Label(ParametersLabel, text="Number of steps")
ParametersLabel.grid(row=1, column=2)
Hrr = Label(ParametersLabel, text="HRR cut-off.")
Steps.grid(row=0)
Hrr.grid(row=2)
self.paraSteps = Entry(ParametersLabel)
self.paraSteps.grid(row=1)
self.paraSteps.insert(END, 2)
self.paraHrr = Entry(ParametersLabel)
self.paraHrr.grid(row=3)
self.paraHrr.insert(END, 30)
self.listbox = Listbox(DescriptionLabel,
width=40,
height=30,
exportselection=0)
probeName = []
for gene in self.genelistNC:
self.listbox.insert(END,
gene[0] + ' ' + gene[1] + ' ' + gene[3])
self.listbox.grid(row=1, column=0, rowspan=5, sticky=N + S + E + W)
scrollbarG = Scrollbar(DescriptionLabel)
scrollbarG.grid(row=1, column=1, rowspan=5, sticky=S + N)
scrollbarG.config(command=self.listbox.yview)
NetworkLabel = LabelFrame(
top, text="Select the networks/species you want to compare.")
Network = Label(
NetworkLabel,
text=
"Available networks are displayed in the list below. Check/uncheck networks of interest."
)
NetworkLabel.grid(row=0, column=1)
Network.grid(row=0)
self.networkBox = Listbox(NetworkLabel,
width=40,
height=30,
selectmode=MULTIPLE,
exportselection=0)
self.networkList = []
for i in os.listdir("."):
if ".hrr" in i:
self.networkBox.insert(END, i)
self.networkList.append(i)
self.networkBox.grid(row=1, column=0, rowspan=5, sticky=N + S + E + W)
scrollbarN = Scrollbar(NetworkLabel)
scrollbarN.grid(row=1, column=1, rowspan=5, sticky=S + N)
scrollbarN.config(command=self.networkBox.yview)
button = Button(top,
text="Calculate!",
fg="red",
font=("Courier", 22),
command=self.netComparerPipe)
button.grid(row=1, column=0, columnspan=5, sticky=E + W)
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()
def __init__(self, master):
# Master Window
self.master = master
NUMLINES = 32
BOXWIDTH = 42
BUTTONWIDTH = 24
CHECKWIDTH = 24
BUTTONPAD = 12
BG_COLOR1 = 'black'
# Input Box
BG_COLOR2 = '#301313'
# Output Box
BG_COLOR3 = '#131313'
BG_COLOR4 = '#333333'
BG_COLOR5 = '#433333'
# Text
FG_COLOR1 = 'white'
FG_COLOR1 = 'grey'
BD_COLOR1 = '#120000'
FIELD_WIDTH = 9
# Delimiter Options
# Display, characterString
global MODES
DELIMITERS = list(MODES.keys())
# Date String options
DATEFORMATS = {
'YMDhm', 'YMD_hm', 'D/M/Y', 'D/M/Y h:m:s', 'D/M/Y h:m', 'Y-M-D',
'Y-M-D h:m:s', 'Y-M-D h:m'
}
# Initialize the source text.
source_text_on_load = StringVar()
source_text_on_load.set(self.getClipboard())
source_text = StringVar()
source_text.set(source_text_on_load.get())
output_text = StringVar()
output_text.set('')
src_delimiter = StringVar()
src_delimiter.set('\n')
out_delimiter = StringVar()
out_delimiter.set(',')
out_quote = StringVar()
out_quote.set('')
prefix = StringVar()
prefix.set('')
suffix = StringVar()
suffix.set('')
find_text = StringVar()
find_text.set('')
replace_text = StringVar()
replace_text.set('')
capitalize = BooleanVar()
remove_empty = BooleanVar()
order_alpha = BooleanVar()
unique_only = BooleanVar()
skip_header = BooleanVar()
capitalize.set(0)
remove_empty.set(0)
order_alpha.set(0)
unique_only.set(0)
skip_header.set(0)
date_format = StringVar()
date_format.set('YMDhm')
##################
# NOTEBOOK 1
################
#################
# TOP
################
top_frame = Frame(root, bg='', width=36, height=260, pady=3, padx=3)
top_frame.pack()
line_numbers = StringVar()
for i in range(0, NUMLINES):
line_numbers.set(line_numbers.get() + str(i + 1) + '\n')
# Source Text Box
source_text_frame = LabelFrame(top_frame,
text='Source',
fg=FG_COLOR1,
bg=BD_COLOR1,
width=20,
height=400,
pady=3,
padx=3)
source_text_frame.grid(row=0, column=1, sticky="nw")
src_txt_line_numbers = Label(source_text_frame,
textvar=line_numbers,
fg=FG_COLOR1,
bg=BG_COLOR4,
anchor='ne',
justify='right',
width=2,
height=NUMLINES,
relief='raised')
src_txt_line_numbers.grid(row=0, column=0)
src_txt_box = Label(source_text_frame,
textvar=source_text,
fg=FG_COLOR1,
bg=BG_COLOR3,
anchor='nw',
justify='left',
wraplength=320,
width=BOXWIDTH,
height=NUMLINES,
relief='raised')
src_txt_box.grid(row=0, column=1)
# Output Text Box
output_text_frame = LabelFrame(top_frame,
text='Output',
fg=FG_COLOR1,
bg=BD_COLOR1,
width=20,
height=400,
pady=3,
padx=3)
output_text_frame.grid(row=0, column=3, sticky="ne")
out_txt_box = Label(output_text_frame,
textvar=line_numbers,
fg=FG_COLOR1,
bg=BG_COLOR5,
anchor='ne',
justify='right',
width=2,
height=NUMLINES,
relief='raised')
out_txt_box.grid(row=0, column=0)
out_txt_box = Label(output_text_frame,
textvar=output_text,
fg=FG_COLOR1,
bg=BG_COLOR2,
anchor='nw',
justify='left',
wraplength=320,
width=BOXWIDTH,
height=NUMLINES,
relief='raised')
out_txt_box.grid(row=0, column=1)
#################
# MIDDLE
################
# delimiter_frame = LabelFrame(master, fg=FG_COLOR1, bg=BG_COLOR1, pady=10, text='Delimiter Settings')
# delimiter_frame.pack()
delimiter_frame = LabelFrame(master,
fg=FG_COLOR1,
bg=BG_COLOR1,
pady=10,
text='Delmiter (From -> To)')
delimiter_frame.pack()
# MIDDLE LEFT
src_delimiter_container = Frame(delimiter_frame, bg=BG_COLOR1, padx=5)
src_delimiter_container.grid(sticky=('n', 'w', 's', 'e'),
row=0,
column=0,
columnspan=3)
# src_delimiter_label = Label(src_delimiter_container, text="Src", justify='left', height=1, width=3, anchor='e', relief='groove')
# src_delimiter_label.grid(row=0, column=0, sticky=('n','w','s','e'))
# src_delimiter_radio = Frame(src_delimiter_container, relief='groove')
# src_delimiter_radio.grid(row=0, column=1, sticky=('n','w','s','e'))
#
# i = 0
# for text, mode in MODES:
# b = Radiobutton(src_delimiter_radio, text=text, width=8,
# variable=src_delimiter, value=mode, indicatoron=0)
# b.grid(row=0, column=i)
# i = i+1
src_delimiter_option = OptionMenu(
delimiter_frame, src_delimiter,
*DELIMITERS) # Pointer to option array
src_delimiter_option.grid(row=0, column=0)
# MIDDLE MIDDLE - Delimiter
out_delimiter_container = Frame(delimiter_frame, bg=BG_COLOR1, padx=5)
out_delimiter_container.grid(sticky=('n', 'w', 's', 'e'),
row=1,
column=0,
columnspan=3)
# out_delimiter_label = Label(out_delimiter_container, text="Out", justify='center', height=1, width=3, anchor='e', relief='groove')
# out_delimiter_label.grid(sticky=('n','w','s','e'),row=0, column=0)
#
# out_delimiter_radio = Frame(out_delimiter_container, width=240, height=120, relief='groove')
# out_delimiter_radio.grid(sticky=('n','w','s','e'),row=0, column=1)
#
# i = 1
# for text, mode in MODES:
# if mode != 'none':
# b = Radiobutton(out_delimiter_radio, text=text, width=8,
# variable=out_delimiter, value=mode, indicatoron=0)
# b.grid(row=0, column=i)
# i = i+1
out_delimiter_option = OptionMenu(
delimiter_frame, out_delimiter,
*DELIMITERS) # Pointer to option array
out_delimiter_option.grid(row=0, column=1)
mid_container = Frame(master, bg=BG_COLOR1)
mid_container.pack()
textvar_container = LabelFrame(mid_container,
fg=FG_COLOR1,
bg=BG_COLOR1,
pady=10,
text='Text Operations')
textvar_container.grid(row=0, column=0, columnspan=5)
# MIDDLE BOTTOM - Quote
out_quote_container = Frame(textvar_container,
bg=BG_COLOR1,
width=100,
height=160,
pady=8)
out_quote_container.grid(row=0, column=0)
out_quote_label = Label(out_quote_container,
text="Quote",
justify='center',
width=FIELD_WIDTH,
height=1,
relief='groove')
out_quote_label.grid(row=0, column=0)
out_quote_entry = Entry(out_quote_container,
textvar=out_quote,
justify='center',
width=FIELD_WIDTH,
relief='groove',
bg=FG_COLOR1,
fg=BG_COLOR1)
out_quote_entry.grid(row=1, column=0)
# MIDDLE BOTTOM - Prefix
prefix_container = Frame(textvar_container,
bg=BG_COLOR1,
width=100,
height=160,
pady=8)
prefix_container.grid(row=0, column=1)
prefix_label = Label(prefix_container,
text="Prefix",
justify='center',
width=FIELD_WIDTH,
height=1,
relief='groove')
prefix_label.grid(row=0, column=0)
prefix_entry = Entry(prefix_container,
textvar=prefix,
justify='center',
width=FIELD_WIDTH,
relief='groove',
bg=FG_COLOR1,
fg=BG_COLOR1)
prefix_entry.grid(row=1, column=0)
# MIDDLE BOTTOM - Suffix
suffix_container = Frame(textvar_container,
bg=BG_COLOR1,
width=100,
height=160,
pady=8)
suffix_container.grid(row=0, column=2)
suffix_label = Label(suffix_container,
text="Suffix",
justify='center',
width=FIELD_WIDTH,
height=1,
relief='groove')
suffix_label.grid(row=0, column=0)
suffix_entry = Entry(suffix_container,
textvar=suffix,
justify='center',
width=FIELD_WIDTH,
relief='groove',
bg=FG_COLOR1,
fg=BG_COLOR1)
suffix_entry.grid(row=1, column=0)
######################
# FIND REPLACE PANEL #
######################
find_container = Frame(textvar_container,
bg=BG_COLOR1,
width=100,
height=160,
pady=8)
find_container.grid(row=0, column=3)
find_label = Label(find_container,
text="Replace",
justify='left',
width=FIELD_WIDTH,
height=1,
relief='groove')
find_label.grid(row=0, column=0)
find_entry = Entry(find_container,
textvar=find_text,
justify='left',
width=FIELD_WIDTH * 2,
relief='groove',
bg=FG_COLOR1,
fg=BG_COLOR1)
find_entry.grid(row=1, column=0)
replace_container = Frame(textvar_container,
bg=BG_COLOR1,
width=100,
height=160,
pady=8)
replace_container.grid(row=0, column=4)
replace_label = Label(replace_container,
text="With",
justify='left',
width=FIELD_WIDTH,
height=1,
relief='groove')
replace_label.grid(row=0, column=0)
replace_entry = Entry(replace_container,
textvar=replace_text,
justify='left',
width=FIELD_WIDTH * 2,
relief='groove',
bg=FG_COLOR1,
fg=BG_COLOR1)
replace_entry.grid(row=1, column=0)
# DATE MENU
date_frame = LabelFrame(mid_container,
bg=BG_COLOR1,
fg=FG_COLOR1,
text='Date',
width=650,
height=280,
pady=3,
padx=3,
relief='groove')
date_frame.grid(row=0, column=6)
date_option = OptionMenu(date_frame, date_format,
*DATEFORMATS) # Pointer to option array
date_option.grid(row=0, column=0)
date_button = Button(
date_frame,
text="Copy",
command=lambda: self.setClipboard(self.printDate(date_format.get())
),
width=BUTTONWIDTH / 2,
highlightbackground=BG_COLOR1,
)
date_button.grid(row=1, column=0)
#################
# BOTTOM
################
control_frame = Frame(root,
bg='',
width=650,
height=140,
pady=3,
padx=3,
relief='groove')
control_frame.pack()
#
# # BOTTOM LEFT
src_control_container = Frame(control_frame,
bg=BG_COLOR1,
width=200,
height=280,
padx=BUTTONPAD)
src_control_container.grid(sticky='w', row=0, column=0)
# Refresh State to Load
refresh_button = Button(
src_control_container,
text="Refresh To Load State",
command=lambda: source_text.set(source_text_on_load.get()),
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1)
refresh_button.grid(row=0, column=0)
clipboard_button = Button(
src_control_container,
text="Copy from Clipboard",
command=lambda: source_text.set(self.getClipboard()),
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1)
clipboard_button.grid(row=1, column=0)
pushback_button = Button(
src_control_container,
text="Output to Input",
command=lambda: source_text.set(output_text.get()),
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1)
pushback_button.grid(row=2, column=0)
# BOTTOM MIDDLE
settings_container = Frame(control_frame,
bg='grey',
width=200,
height=280,
pady=3,
padx=3)
settings_container.grid(row=0, column=1)
order_check = Checkbutton(settings_container,
text="Alphabeticalize",
variable=order_alpha,
anchor='w',
width=CHECKWIDTH)
order_check.pack(anchor='w')
cap_check = Checkbutton(settings_container,
text="Capitalize",
variable=capitalize,
anchor='w',
width=CHECKWIDTH)
cap_check.pack(anchor='w')
header_check = Checkbutton(settings_container,
text="Skip Header",
variable=skip_header,
anchor='w',
width=CHECKWIDTH)
header_check.pack(anchor='w')
rem_check = Checkbutton(settings_container,
text="Strip Blanks",
variable=remove_empty,
anchor='w',
width=CHECKWIDTH)
rem_check.pack(anchor='w')
unique_check = Checkbutton(settings_container,
text="Unique Values",
variable=unique_only,
anchor='w',
width=CHECKWIDTH)
unique_check.pack(anchor='w')
# BOTTOM RIGHT
out_control_container = Frame(control_frame,
bg=BG_COLOR1,
width=200,
height=280,
padx=BUTTONPAD)
out_control_container.grid(row=0, column=2)
fr_button = Button(
out_control_container,
text="Find/Replace",
command=lambda: output_text.set(
self.findReplace(source_text.get(), find_text.get(),
replace_text.get())),
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1,
)
fr_button.pack()
go_button = Button(
out_control_container,
text="Process",
command=lambda: output_text.set(
self.process(source_text.get(), src_delimiter.get(
), out_delimiter.get(), out_quote.get(), order_alpha.get(
), skip_header.get(), remove_empty.get(), unique_only.get(),
capitalize.get(), prefix.get(), suffix.get(),
find_text.get(), replace_text.get())),
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1,
)
go_button.pack()
copy_button = Button(
out_control_container,
text="Copy to Clipboard",
command=lambda: self.setClipboard(output_text.get()),
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1)
copy_button.pack()
close_button = Button(out_control_container,
text="Quit",
command=master.quit,
width=BUTTONWIDTH,
highlightbackground=BG_COLOR1)
close_button.pack()
def __init__(self, root, cursor, db):
self.frame = Frame(root)
self.frame.configure(background='white')
self.list_toplevel = {}
self.cursor = cursor
self.db = db
self.child_toplevel = None
self.frame.pack()
image = Image.open("photo.jpg")
image = image.resize((250, 250), Image.ANTIALIAS)
photo = ImageTk.PhotoImage(image)
label = Label(self.frame, image=photo)
label.grid(row=0, column=0, sticky=W)
label.image = photo # keep a reference!
nou_registre = LabelFrame(self.frame,
text="Nou registre",
fg="Blue",
padx=5,
pady=5)
nou_registre.configure(background='white')
nou_registre.grid(row=0, column=1, padx=15, sticky=W)
text_nom = Label(nou_registre, text="Nom:", fg="Blue")
text_nom.configure(background='white')
text_nom.grid(row=0, column=0)
self.entry_nom = Entry(nou_registre)
self.entry_nom.grid(row=0, column=1, sticky=W)
text_telefon = Label(nou_registre, text="Telèfon: ", fg="Blue")
text_telefon.configure(background='white')
text_telefon.grid(row=1, column=0)
self.entry_telefon = Entry(nou_registre)
self.entry_telefon.grid(row=1, column=1)
text_email = Label(nou_registre, text="Email: ", fg="Blue")
text_email.configure(background='white')
text_email.grid(row=2, column=0)
self.entry_email = Entry(nou_registre)
self.entry_email.grid(row=2, column=1)
button_afegir_contacte = Button(nou_registre,
text="Afegir contacte",
fg="Blue",
command=self.afegeix_contacte)
button_afegir_contacte.grid(row=3, column=1, sticky=E)
button_mostra_historic = Button(nou_registre,
text="Mostra historic",
fg="Blue",
command=self.mostra_historic)
button_mostra_historic.grid(row=4, column=0, sticky=W)
mostrar_contactes = Button(self.frame,
text="Mostrar contactes",
fg="Blue",
command=self.insert_contacts_treeview)
mostrar_contactes.grid(sticky=W, row=3)
self.missatge_error_confirmacio = StringVar()
self.label_error_confirmacio = Label(
self.frame, textvariable=self.missatge_error_confirmacio, fg="Red")
self.label_error_confirmacio.configure(background='white')
self.label_error_confirmacio.grid(sticky=W, row=3, column=1)
self.agenda_contactes = Treeview(self.frame,
columns=["nom", "tel"],
show="headings")
self.agenda_contactes.heading("nom", text="Nom")
self.agenda_contactes.heading("tel", text="Telefon")
self.agenda_contactes.column("nom",
minwidth=0,
width=200,
stretch=NO,
anchor="c")
self.agenda_contactes.column("tel",
minwidth=0,
width=200,
stretch=NO,
anchor="c")
self.agenda_contactes.grid(row=4, column=0, padx=0, columnspan=2)
self.insert_contacts_treeview()
elimina_seleccionat = Button(self.frame,
text="Eliminar seleccionat",
command=self.elimina_contacte,
fg="Blue")
elimina_seleccionat.grid(row=5, column=0, sticky=W)
self.modificar_seleccionat = Button(self.frame,
text="Modificar seleccionat",
fg="Blue",
command=self.modifica_contacte)
self.modificar_seleccionat.grid(row=5, column=1, sticky=W)
sortir = Button(self.frame,
text="Sortir",
fg="Blue",
command=self.frame.quit)
sortir.grid(row=5, column=2, sticky=E)
ax.grid(True)
canvas = FigureCanvasTkAgg(fig, master=labelframe)
canvas._tkcanvas.config(highlightthickness=0)
toolbar = NavigationToolbar2TkAgg(canvas, labelframe)
canvas.get_tk_widget().pack()
toolbar.pack()
return fig, axes, lines
if __name__ == '__main__':
root = Tk()
root.title('Tuneshift with ampltiude measurement')
frame = Frame(root)
frame.pack(fill=BOTH, expand=True)
lf_control = LabelFrame(frame, text="Control", padx=5, pady=5)
lf_control.grid(row=0, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_settings = LabelFrame(frame, text="Settings", padx=5, pady=5)
lf_settings.grid(row=1, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_results = LabelFrame(frame, text="Results", padx=5, pady=5)
lf_results.grid(row=2, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_plots = LabelFrame(frame, text="Matplotlib", padx=5, pady=5)
lf_plots.grid(row=0, column=1, rowspan=3, sticky=W+E+N+S, padx=10, pady=10)
rcdefaults()
params = {'axes.labelsize': 10,
'axes.titlesize': 10,
'axes.formatter.limits': [-2, 3],
'axes.grid': True,
'figure.figsize': [8, 4.5],
'figure.dpi': 100,
'figure.autolayout': True,
class RigRemote(ttk.Frame): #pragma: no cover
"""Remote application that interacts with the rig using rigctl protocol.
Gqrx partially implements rigctl since version 2.3.
:raises: none
:returns: none
"""
def __init__(self, root, ac): #pragma: no cover
ttk.Frame.__init__(self, root)
self.bookmarks_file = BOOKMARKS_FILE
self.log_file = None
self.build(ac)
self.cbb_mode.current(0)
# bookmarks loading on start
self.bookmark("load", ",")
def build(self, ac): #pragma: no cover
"""Build and initialize the GUI widgets.
:param: none
:raises: none
:returns: none
"""
self.master.title("Rig Remote")
self.master.minsize(800, 244)
self.pack(fill=tk.BOTH, expand=1, padx=5, pady=5)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
# bookmarks list
self.tree = ttk.Treeview(self,
columns=("frequency",
"mode",
"description"),
show="headings")
self.tree.heading('frequency',
text='Frequency',
anchor=tk.CENTER)
self.tree.column('frequency',
#minwidth=100,
width=100,
stretch=True,
anchor=tk.CENTER)
self.tree.heading('mode',
text='Mode',
anchor=tk.CENTER)
self.tree.column('mode',
#minwidth=80,
width=70,
stretch=True,
anchor=tk.CENTER)
self.tree.heading('description',
text='Description',
)
self.tree.column('description',
stretch=True,
#width=70
)
ysb = ttk.Scrollbar(self,
orient=tk.VERTICAL,
command=self.tree.yview)
ysb.grid(row=0,
column=2,
rowspan=5,
sticky=tk.NS)
xsb = ttk.Scrollbar(self,
orient=tk.HORIZONTAL,
command=self.tree.xview)
xsb.grid(row=5,
column=0,
sticky=tk.NSEW
)
self.tree.configure(
yscroll=ysb.set,
#xscroll=xsb.set
)
self.tree.grid(row=0,
column=0,
rowspan=5,
sticky=tk.NSEW
)
self.tree.bind('<<TreeviewSelect>>',
self.cb_autofill_form)
self.tree.bind('<Double-Button-1>',
self.cb_set_frequency)
# vertical separator between bookmarks and comands
ttk.Frame(self).grid(row=0,
column=2,
rowspan=5,
padx=5)
# # right-side container
self.rig_config_menu = LabelFrame(self,
text="Rig configuration")
self.rig_config_menu.grid(row=0,
column=3,
stick=tk.NSEW)
ttk.Label(self.rig_config_menu,
text="Hostname:").grid(row=1,
column=2,
sticky=tk.W)
self.txt_hostname = ttk.Entry(self.rig_config_menu)
self.txt_hostname.grid(row=1,
column=3,
columnspan=2,
padx=2,
pady=2,
sticky=tk.EW)
ttk.Label(self.rig_config_menu,
text="Port:").grid(row=2,
column=2,
sticky=tk.W)
self.txt_port = ttk.Entry(self.rig_config_menu)
self.txt_port.grid(row=2,
column=3,
padx=2,
pady=2,
sticky=tk.EW)
# horizontal separator
ttk.Frame(self.rig_config_menu).grid(row=3,
column=0,
columnspan=3,
pady=5)
self.rig_control_menu = LabelFrame(self,
text="Rig Control")
self.rig_control_menu.grid(row=1,
column=3,
stick=tk.NSEW)
ttk.Label(self.rig_control_menu,
text="Frequency:").grid(row=5,
column=0,
sticky=tk.W)
self.txt_frequency = ttk.Entry(self.rig_control_menu)
self.txt_frequency.grid(row=5,
column=1,
columnspan=3,
padx=2,
pady=2,
sticky=tk.W)
ttk.Label(self.rig_control_menu,
text="Mhz").grid(row=5,
column=3,
sticky=tk.EW)
ttk.Label(self.rig_control_menu,
text="Mode:").grid(row=6,
column=0,
sticky=tk.W)
self.cbb_mode = ttk.Combobox(self.rig_control_menu, width=15)
self.cbb_mode.grid(row=6,
column=1,
columnspan=3,
padx=2,
pady=2,
sticky=tk.EW)
self.cbb_mode['values'] = CBB_MODES
ttk.Label(self.rig_control_menu,
text="Description:").grid(row=7,
column=0,
sticky=tk.EW)
self.txt_description = ttk.Entry(self.rig_control_menu)
self.txt_description.grid(row=7,
column=1,
columnspan=3,
padx=2,
pady=2,
sticky=tk.EW)
self.btn_add = ttk.Button(self.rig_control_menu,
text="Add",
width=7,
command=self.cb_add)
self.btn_add.grid(row=8,
column=1,
padx=2,
pady=2)
self.btn_delete = ttk.Button(self.rig_control_menu,
text="Delete",
width=7,
command=self.cb_delete)
self.btn_delete.grid(row=8,
column=2,
padx=2,
pady=2)
self.btn_load = ttk.Button(self.rig_control_menu,
text="Get",
width=7,
command=self.cb_get_frequency)
self.btn_load.grid(row=8,
column=3,
padx=2,
pady=2)
# # horizontal separator
ttk.Frame(self.rig_control_menu).grid(row=9,
column=0,
columnspan=3,
pady=5)
self.scanning_conf_menu = LabelFrame(self, text="Scanning options")
self.scanning_conf_menu.grid(row=2,
column=3,
#rowspan=3,
stick=tk.NSEW)
ttk.Label(self.scanning_conf_menu,
text="Signal level:").grid(row=10,
column=0,
sticky=tk.W)
self.txt_sgn_level = ttk.Entry(self.scanning_conf_menu,
width=10)
self.txt_sgn_level.grid(row=10,
column=1,
columnspan=1,
padx=2,
pady=2,
sticky=tk.W)
ttk.Label(self.scanning_conf_menu,
text="dBFS").grid(row=10,
column=2,
padx=0,
sticky=tk.W)
ttk.Label(self.scanning_conf_menu,
text="Delay:").grid(row=13,
column=0,
sticky=tk.W)
self.txt_delay = ttk.Entry(self.scanning_conf_menu,
width=10)
self.txt_delay.grid(row=13,
column=1,
columnspan=1,
padx=2,
pady=2,
sticky=tk.W)
ttk.Label(self.scanning_conf_menu,
text="Seconds").grid(row=13,
padx=0,
column=2,
sticky=tk.EW)
self.cb_monitor_mode = tk.BooleanVar()
self.ckb_monitor_mode = ttk.Checkbutton(self.scanning_conf_menu,
text="monitor mode",
onvalue=True,
offvalue=False,
variable=self.cb_monitor_mode)
self.ckb_monitor_mode.grid(row=14,
column=0,
columnspan=1,
sticky=tk.EW)
self.cb_recording = tk.BooleanVar()
self.ckb_recording = ttk.Checkbutton(self.scanning_conf_menu,
text="recording",
onvalue=True,
offvalue=False,
variable=self.cb_recording)
self.ckb_recording.grid(row=14,
column=1,
columnspan=1,
sticky=tk.EW)
self.freq_scanning_menu = LabelFrame(self, text="Frequency scanning")
self.freq_scanning_menu.grid(row=3,
column=3,
#rowspan=3,
stick=tk.NSEW)
self.freq_scan_start = ttk.Button(self.freq_scanning_menu,
text="Start",
command=self.frequency_start)
self.freq_scan_start.grid(row=15,
column=2,
columnspan=1,
padx=2,
sticky=tk.NW)
ttk.Label(self.freq_scanning_menu,
text="Min/Max:").grid(row=11,
column=0,
sticky=tk.W)
ttk.Label(self.freq_scanning_menu,
text="khz").grid(row=11,
padx=0,
column=3,
sticky=tk.W)
self.txt_range_min = ttk.Entry(self.freq_scanning_menu,
width=10)
self.txt_range_min.grid(row=11,
column=1,
columnspan=1,
padx=2,
pady=2,
sticky=tk.W)
self.txt_range_max = ttk.Entry(self.freq_scanning_menu,
width=10)
self.txt_range_max.grid(row=11,
column=2,
columnspan=1,
padx=0,
pady=0,
sticky=tk.W)
ttk.Label(self.freq_scanning_menu,
text="Interval:").grid(row=12,
column=0,
sticky=tk.W)
self.txt_interval = ttk.Entry(self.freq_scanning_menu,
width=10)
self.txt_interval.grid(row=12,
column=1,
columnspan=1,
padx=2,
pady=2,
sticky=tk.W)
ttk.Label(self.freq_scanning_menu,
text="Khz").grid(row=12,
padx=0,
column=2,
sticky=tk.EW)
self.cb_auto_bookmark = tk.BooleanVar()
self.ckb_auto_bookmark = ttk.Checkbutton(self.freq_scanning_menu,
text="auto bookmark",
onvalue=True,
offvalue=False,
variable=self.cb_auto_bookmark)
self.ckb_auto_bookmark.grid(row=15,
column=0,
columnspan=1,
sticky=tk.EW)
ttk.Frame(self.freq_scanning_menu).grid(row=16,
column=0,
columnspan=3,
pady=5)
self.book_scanning_menu = LabelFrame(self, text="Bookmark scanning")
self.book_scanning_menu.grid(row=4,
column=3,
#rowspan=3,
stick=tk.NSEW)
# #horrible horizontal placeholder
ttk.Label(self.book_scanning_menu,
width=8).grid(row=17,
column=0,
sticky=tk.NSEW)
ttk.Label(self.book_scanning_menu,
width=8).grid(row=17,
column=1,
sticky=tk.NSEW)
ttk.Label(self.book_scanning_menu,
width=8).grid(row=17,
column=2,
sticky=tk.NSEW)
self.book_scan_start = ttk.Button(self.book_scanning_menu,
text="Start",
command=self.bookmark_start,
)
self.book_scan_start.grid(row=17,
column=3,
columnspan=1,
padx=2,
sticky=tk.W)
# horizontal separator
ttk.Frame(self.book_scanning_menu).grid(row=18,
column=0,
columnspan=3,
rowspan=1,
pady=5)
self.control_menu = LabelFrame(self, text="Options")
self.control_menu.grid(row=5,
column=3,
#rowspan=3,
stick=tk.NSEW)
self.ckb_top = ttk.Checkbutton(self.control_menu,
text="Always on top",
command=self.cb_top)
self.ckb_top.grid(row=20,
column=2,
columnspan=1,
padx=2,
sticky=tk.EW)
self.cb_save_exit = tk.BooleanVar()
self.ckb_save_exit = ttk.Checkbutton(self.control_menu,
text="Save on exit",
onvalue=True,
offvalue=False,
variable=self.cb_save_exit)
self.ckb_save_exit.grid(row=20,
column=1,
columnspan=1,
padx=2,
sticky=tk.EW)
self.btn_quit = ttk.Button(self.control_menu,
text="Quit",
command=lambda: self.shutdown(ac))
self.btn_quit.grid(row=20,
column=3,
columnspan=1,
sticky=tk.SE)
# # horizontal separator
ttk.Frame(self.control_menu).grid(row=21,
column=0,
columnspan=3,
pady=5)
def apply_config(self, ac):
"""Applies the config to the UI.
:param ac: object instance for handling the app config
:type ac: AppConfig object
:raises : none
:returns : none
"""
ac.read_conf()
self.txt_hostname.insert(0, ac.config["hostname"])
self.txt_port.insert(0, ac.config["port"])
self.txt_interval.insert(0, ac.config["interval"])
self.txt_delay.insert(0, ac.config["delay"])
self.txt_sgn_level.insert(0, ac.config["sgn_level"])
self.txt_range_min.insert(0, ac.config["range_min"])
self.txt_range_max.insert(0, ac.config["range_max"])
self.cb_save_exit.set(ac.config["save_exit"].lower())
self.cb_auto_bookmark.set(ac.config["auto_bookmark"].lower())
self.monitor_mode_loops=ac.config["monitor_mode_loops"]
if ac.config["always_on_top"].lower() == "true":
if self.ckb_top.state() != ("selected"):
self.ckb_top.invoke()
self.rigctl = RigCtl(self.txt_hostname.get(),
self.txt_port.get())
def _store_conf(self, ac): #pragma: no cover
"""populates the ac object reading the info from the UI
:param ac: object used to hold the app configuration.
:type ac: AppConfig() object
:returns ac: ac obj updated.
"""
ac.config["hostname"] = self.txt_hostname.get()
ac.config["port"] = self.txt_port.get()
ac.config["interval"] = self.txt_interval.get()
ac.config["delay"] = self.txt_delay.get()
ac.config["sgn_level"] = self.txt_sgn_level.get()
ac.config["range_min"] = self.txt_range_min.get()
ac.config["range_max"] = self.txt_range_max.get()
ac.config["save_exit"] = self.cb_save_exit.get()
ac.config["auto_bookmark"] = self.cb_auto_bookmark.get()
if self.ckb_top.state() != ("selected"):
ac.config["always_on_top"] = "true"
else:
ac.config["always_on_top"] = "false"
return ac
def shutdown(self,ac): #pragma: no cover
"""Here we quit. Before exiting, if save_exit checkbox is checked
we save the configuration of the app and the bookmarks.
:param ac: object that represent the UI configuration
:type ac:AppConfig instance
:returns: none
"""
if self.cb_save_exit.get():
self.bookmark("save", ",")
ac = self._store_conf(ac)
ac.write_conf()
self.master.destroy()
def bookmark(self, task, delimiter): #pragma: no cover
"""Bookmarks handling. loads and saves the bookmarks as
a csv file.
:param task: either load or save
:type task: string
:param delimiter: delimiter to use for creating the csv file
:type delimiter: string
:raises : none
:returns : none
"""
if task not in ALLOWED_BOOKMARK_TASKS:
logger.info("Not allowed bookmark task requested {}, "\
"ignoring.".format(task))
bookmarks = IO()
if task == "load":
try:
bookmarks.csv_load(self.bookmarks_file, delimiter)
for line in bookmarks.row_list:
line[0] = self._frequency_pp(line[0])
self.tree.insert('', tk.END, values=line)
except InvalidPathError:
logger.info("No bookmarks file found, skipping.")
if task == "save":
for item in self.tree.get_children():
values = self.tree.item(item).get('values')
values[0] = self._frequency_pp_parse(values[0])
bookmarks.row_list.append(values)
bookmarks.csv_save(self.bookmarks_file, delimiter)
def bookmark_start(self): #pragma: no cover
"""Wrapper around _scan() that starts a scan from bookmarks.
"""
self._scan("bookmarks", "start")
def frequency_start(self): #pragma: no cover
"""Wrapper around _scan() that starts a scan from a frequency range.
"""
self._scan("frequency", "start")
def _scan(self, mode, action): #pragma: no cover
"""Wrapper around the scanning class instance. Creates the task
object and issues the scan.
:param mode: bookmark or frequency
:type mode: string
:param action: only start, for now
:type action: string
:raises: NotImplementedError if action different than "start" is passed
:returns: None
"""
if action.lower() not in SUPPORTED_SCANNING_ACTIONS:
logger.error("Provided action:{}".format(action))
logger.error("Supported actions:{}".format(SUPPORTED_SCANNING_ACTIONS))
raise UnsupportedScanningConfigError
bookmark_list = []
for item in self.tree.get_children():
values = self.tree.item(item).get('values')
bookmark_list.append(values)
min_freq = self.txt_range_min.get()
max_freq = self.txt_range_max.get()
delay = self.txt_delay.get()
interval = self.txt_interval.get()
sgn_level = self.txt_sgn_level.get()
if (len(self.ckb_recording.state()) == 1 and
self.ckb_recording.state()== ('selected',)):
recording = True
else:
recording = False
if (len(self.ckb_monitor_mode.state()) == 1 and
self.ckb_monitor_mode.state()== ('selected',)):
monitoring = True
else:
monitoring = False
scanning_task = ScanningTask(mode,
bookmark_list,
self.monitor_mode_loops,
min_freq,
max_freq,
delay,
interval,
sgn_level,
recording,
monitoring)
scanning = Scanning()
task = scanning.scan(scanning_task)
if (task.mode.lower() == "bookmarks" and
len(task.new_bookmark_list) > 0):
message = self._new_activity_message(task.new_bookmark_list)
tkMessageBox.showinfo("New activity found", message,
parent=self)
if (task.mode.lower() == "frequency" and
len(task.new_bookmark_list) > 0 and
(len(self.ckb_auto_bookmark.state()) == 1 and
self.ckb_auto_bookmark.state()== ('selected',))):
self._add_new_bookmarks(task.new_bookmark_list)
elif (task.mode.lower() == "frequency" and
len(task.new_bookmark_list) > 0 and
len(self.ckb_auto_bookmark.state()) == 0):
message = self._new_activity_message(task.new_bookmark_list)
tkMessageBox.showinfo("New activity found", message,
parent=self)
def _new_activity_message(self, nbl):
"""Provides a little formatting from the new bookmark list.
:param nbl: new bookmark list
:type nbl: list
:raises : none
:returns message: message to be printed in an info messagebox.
:type message: string
"""
message = []
for nb in nbl:
message.append(nb[2])
message = ", ".join(message)
logger.warning(message)
return message
def _clear_form(self): #pragma: no cover
"""Clear the form.. nothing more.
:param: none
:raises: none
:returns: none
"""
self.txt_frequency.delete(0, tk.END)
self.txt_description.delete(0, tk.END)
self.cbb_mode.delete(0, tk.END)
def _add_new_bookmarks(self, nbl): #pragma: no cover
"""Fill in the data, calls uses cb_add() and calls clear_form.
:param nbl: list of new frequencies to bookmark
:type nbl: list
:raises: none
:returns: none
"""
self._clear_form()
now = datetime.datetime.utcnow().strftime("%a %b %d %H:%M %Y")
for nb in nbl:
self.txt_description.insert(0, "activity on {}".format(now))
self.txt_frequency.insert(0, self._frequency_pp(nb[2]))
self.cbb_mode.insert(0,nb[1])
# adding bookmark to the list
self.cb_add()
self._clear_form()
def cb_top(self): #pragma: no cover
"""Set window property to be always on top.
:param: none
:raises: none
:returns: none
"""
self.master.attributes("-topmost",
'selected' in self.ckb_top.state())
def cb_get_frequency(self): #pragma: no cover
"""Get current rig frequency and mode.
:param: none
:raises: none
:returns: none
"""
# clear fields
self._clear_form()
try:
frequency = self.rigctl.get_frequency()
mode = self.rigctl.get_mode()
# update fields
self.txt_frequency.insert(0, self._frequency_pp(frequency))
self.cbb_mode.insert(0, mode)
except Exception as err:
tkMessageBox.showerror("Error",
"Could not connect to rig.\n%s" % err,
parent=self)
def cb_set_frequency(self, event): #pragma: no cover
"""Set the rig frequency and mode.
:param event: not used?
:type event:
:raises: none
:returns: none
"""
item = self.tree.focus()
values = self.tree.item(item).get('values')
try:
self.rigctl.set_frequency(values[0].replace(',', ''))
self.rigctl.set_mode((values[1]))
except Exception as err:
tkMessageBox.showerror("Error",
"Could not set frequency.\n%s" % err,
parent=self)
def cb_autofill_form(self, event): #pragma: no cover
"""Auto-fill bookmark fields with details
of currently selected Treeview entry.
:param event: not used?
:type event:
:raises: none
:returns: none
"""
item = self.tree.focus()
values = self.tree.item(item).get('values')
self._clear_form()
self.cbb_mode.insert(0, values[1])
self.txt_frequency.insert(0, values[0])
self.txt_description.insert(0, values[2])
def cb_add(self): #pragma: no cover
"""Add frequency to tree and saves the bookmarks.
:param: none
:raises: none
:returns: none
"""
# get values
frequency = self._frequency_pp_parse(self.txt_frequency.get())
mode = self.cbb_mode.get()
description = self.txt_description.get()
# find where to insert (insertion sort)
idx = tk.END
for item in self.tree.get_children():
freq = self.tree.item(item).get('values')[0]
curr_freq = self._frequency_pp_parse(freq)
curr_mode = self.tree.item(item).get('values')[1]
if frequency < curr_freq:
idx = self.tree.index(item)
break
elif (frequency == curr_freq and
mode == curr_mode and
mode != UNKNOWN_MODE):
tkMessageBox.showerror("Error", "A bookmark with the "\
"same frequency and mode "\
"already exists.", parent=self)
return
# insert
item = self.tree.insert('',
idx,
values=[self._frequency_pp(frequency),
mode,
description])
self.tree.selection_set(item)
self.tree.focus(item)
self.tree.see(item)
# save
self.bookmark("save", ",")
def cb_delete(self): #pragma: no cover
"""Delete frequency from tree.
:param: none
:raises: none
:returns: none
"""
item = self.tree.focus()
if item != '':
self.tree.delete(item)
# save
self.bookmark("save", ",")
def _frequency_pp(self, frequency): #pragma: no cover
"""Add thousands separator.
:param frequency: frequency value
:type frequency: string
:return: frequency with separator
:return type: string
"""
return '{:,}'.format(int(frequency))
def _frequency_pp_parse(self, frequency): #pragma: no cover
"""Remove thousands separator.
:param frequency: frequency value
:type frequency: string
:return: frequency without separator
:return type: string
"""
return int(str(frequency).replace(',', ''))
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 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 TKEA_win(object):
def __init__(self, ea, p, rec, varlist):
self.vl = varlist # list of EA attributes which you wanna make accessible via window
self.ea = ea # the EA instance
self.ea.generation_callbacks.append(self.update_solu_canvas)
self.ea.generation_callbacks.append(self.update_mstep_bar)
self.ea.generation_callbacks.append(self.rec_save_status)
self.ea.generation_callbacks.append(self.acp_update)
self.acp_type = 'linear' # also allowed up to date: 'semilogy'
self.acp_ylim = False
self.acp_freq = 1
self.update_freq = 1
self.p = p # main population
self.rec = rec
tmppop = population_like(p, size=1)
self.frontman = tmppop[0] # an extra individual, the one bein plotted
def appear(self):
self.mwin = Tk() # root or main window
self.mwin.title('EA progress visualisation')
self.setupFig()
self.setupWindow()
def setupFig(self):
self.fig = plt.figure(figsize=(8, 7), dpi=80)
self.sp1 = self.fig.add_subplot(
211
) # additional colorbar might be created under the name self.sp1_cb
self.sp2 = self.fig.add_subplot(
212
) # additional colorbar might be created under the name self.sp2_cb
self.sp1t = self.sp1.set_title('ini')
self.sp2t = self.sp2.set_title('ini')
def setupWindow(self):
self.f_inp = Frame(self.mwin)
self.f_inp.pack(side='left')
self.f_plot = Frame(self.mwin)
self.f_plot.pack(side='right')
self.c = FigureCanvasTkAgg(self.fig, master=self.f_plot)
self.c.show()
self.c.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
# setup the input area
self.f_actn = LabelFrame(self.f_inp, text='action')
self.f_actn.grid(row=0, column=0)
self.f_gg = Frame(self.f_actn)
self.f_gg.pack()
l_gg = Label(self.f_gg, text='generations')
l_gg.pack()
self.e_gg = Entry(self.f_gg)
self.e_gg.pack()
self.e_gg.insert(0, '40') # number of generations
self.b_rini = Button(self.f_actn, text='randini', command=self.randini)
self.b_rini.pack()
self.b_run1 = Button(self.f_actn,
text='update & run',
command=self.run_with_readout)
self.b_run1.pack()
self.b_run2 = Button(self.f_actn,
text='run (continue)',
command=self.run_no_readout)
self.b_run2.pack()
if len(self.vl): self.add_entries(self.vl)
# draw initial plot
self.draw_ini_solu(
) # sort of setting up instructive initial geometry plot of non-optimised geometry
self.acp_ini()
self.f_tb = Frame(self.f_plot)
self.f_tb.pack()
self.tb = NavigationToolbar2TkAgg(self.c, self.f_tb)
self.c2 = Canvas(self.f_inp, width=80, height=140)
self.c2.grid(row=4, column=0)
self.ini_mstep_bar()
def add_entries(self, vl):
for el in vl:
if not hasattr(self.ea, el['name']):
raise TypeError(
'you try to set up an entry for a name which is no attribute of the chosen EA'
)
fr = Frame(self.f_actn)
fr.pack()
lab = Label(fr, text=el['name'])
lab.pack()
e = Entry(fr)
e.pack()
e.insert(0, str(el['inival'])) # number of generations
el['Entry'] = e
def draw_ini_solu(self):
self.frontman.plot_into_axes(self.sp1)
txt = 'initial DNA'.format(self.frontman.DNA)
self.sp1t.set_text(txt)
def draw_solu(self, dude):
self.frontman.copy_DNA_of(dude,
copyscore=True,
copyparents=True,
copyancestcode=True)
self.frontman.evaluate()
self.frontman.update_plot(self.sp1)
txt = 'generation {}: score is {:.3f} after {} function calls'.format(
self.p.gg, self.ea.bestdude.score, self.ea.tell_neval())
#self.sp1t.set_text(txt)
self.sp1.set_title(txt)
self.c.draw()
def mainloop(self):
self.mwin.mainloop()
def randini(self):
self.p.reset()
self.rec.clear()
self.ea.bestdude = None
self.ea.zeroth_generation(random_ini=True)
self.draw_solu(self.ea.bestdude)
self.c.draw()
def run_with_readout(self):
for el in self.vl:
if el['type'] is float:
val = float(el['Entry'].get())
exec('self.ea.' + el['name'] + '=' + str(val))
elif el['type'] is int:
val = int(float(el['Entry'].get()))
exec('self.ea.' + el['name'] + '=' + str(val))
elif el['type'] is str:
val = el['Entry'].get()
exec('self.ea.' + el['name'] + "='" + val + "'")
elif el['type'] is list:
val = el['Entry'].get()
exec('self.ea.' + el['name'] + "=" + val)
print 'string {} and what resulted {}'.format(
val, eval('self.ea.' + el['name']))
else:
raise NotImplementedError(
'only float and int parameters cared for at this point')
self.ea.run(int(float(self.e_gg.get())))
def run_no_readout(self):
self.ea.run(int(float(self.e_gg.get())))
def update_solu_canvas(self, eaobj):
if np.mod(self.p.gg, self.update_freq) == 0:
self.draw_solu(self.ea.bestdude)
def ini_mstep_bar(self):
fg_color = bluered4hex(0.36)
#textcolor='white'
self.c2.create_rectangle(43, 0, 57, 140, fill='white', outline='white')
mstep_barheight = int(-0.25 * log10(self.ea.mstep) * 140)
mstep_barheight = clip(mstep_barheight, 0, 140)
self.mstep_bar = self.c2.create_rectangle(43,
mstep_barheight,
57,
140,
fill='green',
outline='green')
for h in [2, 35, 70, 105, 140]:
self.c2.create_line(40, h, 60, h, width=2, fill=fg_color)
for h, poww in zip([6, 30, 65, 100, 130],
['0', '-1', '-2', '-3', '-4']):
self.c2.create_text(20,
h,
text='10**' + poww,
font=('Courier', '6'))
def update_mstep_bar(self, eaobj):
mstep_barheight = int(-0.25 * log10(self.ea.mstep) * 140)
mstep_barheight = clip(mstep_barheight, 0, 140)
self.c2.coords(self.mstep_bar, 43, mstep_barheight, 57, 140)
self.mwin.update_idletasks()
def rec_save_status(self, eaobj):
self.rec.save_status()
def acp_ini(self, whiggle=0):
x = []
y = []
farbe = []
for i, g in enumerate(self.rec.gg):
for j in range(self.p.psize):
x.append(g)
y.append(self.rec.adat['scores'][i][j])
farbe.append(self.rec.adat['ancestcodes'][i][j])
x.append(0)
y.append(0)
farbe.append(0.) # for normalisation of color map
x.append(0)
y.append(0)
farbe.append(1.) # for normalisation of color map
x = flipud(array(x))
y = flipud(array(y))
farbe = flipud(array(farbe))
if whiggle: x = x + whiggle * npr.rand(len(x)) - 0.5 * whiggle
self.acdots = self.sp2.scatter(x,
y,
marker='o',
c=farbe,
cmap=ancestcolors,
zorder=True)
if self.acp_type == 'semilogy':
self.sp2.semilogy()
if self.acp_ylim:
self.sp2.axis((0, self.p.gg, self.acp_ylim[0], self.acp_ylim[1]))
else:
self.sp2.axis((0, self.p.gg, 0, np.max(y)))
def acp_update(self, eaobj, whiggle=0):
if np.mod(self.p.gg, self.acp_freq) == 0:
self.sp2.cla()
self.acp_ini(whiggle=whiggle)
self.c.draw()
class Editor(object):
"""
Finestra per l'editor di condice assembly
"""
def __init__(self, master, calcolatore):
"""
Inizializza i frame della finestra dell'Editor
"""
self.master = master
self.CD = calcolatore
# Codice Assembly
self.codice = LabelFrame(
self.master, text='Codice Assembly', relief=RIDGE, borderwidth=5, labelanchor='n', pady=5)
self.codice.rowconfigure(0, weight=1)
self.codice.columnconfigure(0, weight=1)
self.codice.grid(
row=1, column=0, rowspan=3, columnspan=5, sticky=W + E + N + S)
self.menubar = Menu(self.master)
self.create_widgets(self.menubar)
def create_widgets(self, menubar):
"""
Crea il layout del programma, finestra dell'Editor
"""
# Menu
self.filemenu = Menu(menubar, tearoff=0)
self.filemenu.add_command(label='Apri', command=self.aprifile)
self.filemenu.add_command(label='Salva', command=self.salvafile)
self.filemenu.add_command(label='Cancella', command=self.cancella)
self.filemenu.add_separator()
self.filemenu.add_command(label='Esci', command=self.exit)
menubar.add_cascade(label='Opzioni', menu=self.filemenu)
self.master.config(menu=self.menubar)
self.helpmenu = Menu(menubar, tearoff=0)
self.helpmenu.add_command(label='Informazioni', command=self.infor)
self.helpmenu.add_command(label='Legenda', command=self.leg)
self.helpmenu.add_command(label='Guida', command=self.guida)
menubar.add_cascade(label='Aiuto', menu=self.helpmenu)
# Codice Assembly
self.Inserisci = Text(self.codice, width=50, height=30, wrap=WORD)
self.Inserisciscrollbar = Scrollbar(self.codice)
self.Inserisciscrollbar.config(command=self.Inserisci.yview)
self.Inserisci.config(yscrollcommand=self.Inserisciscrollbar.set)
self.Inserisciscrollbar.grid(row=0, column=1, sticky=N + S)
self.Inserisci.grid(row=0, column=0, sticky=W)
def exit(self):
"""
Esce dal programma
"""
if askquestion('Exit', 'Sicuro di voler uscire?') == YES:
self.master.quit()
self.master.destroy()
else:
showinfo(
'Suggerimento', """Forse e' meglio fare una pausa!""", icon=WARNING)
def aprifile(self):
"""
Apre un file assembly e lo mostra a video per essere modificato
"""
path = askopenfilename(title='Apri codice assembly',
filetypes=[('Assembly', '.asm'), ('Testo', '.txt'), ('All', '*')])
if path != '':
file = open(path, 'r')
temp = file.read()
self.Inserisci.delete(1.0, END)
self.Inserisci.insert(INSERT, temp.decode('ascii', 'ignore'))
file.close()
def cancella(self):
"""
Cancella l'attuale file assembly caricato
"""
if askquestion('Cancella', 'Si vuole cancellare tutto il codice assembly?') == YES:
self.Inserisci.delete(1.0, END)
def salvafile(self):
"""
Salva il file assembly su cui si sta lavorando
"""
contenuto = self.Inserisci.get(1.0, END)
contenuto = contenuto.encode('ascii', 'ignore')
path = asksaveasfilename(title='Salva codice assembly',
defaultextension=[
('Assembly', '.asm'), ('Testo', '.txt'), ('All', '*')],
filetypes=[('Assembly', '.asm'), ('Testo', '.txt'), ('All', '*')])
print path
if path != '':
file = open(path, 'w')
file.write(str(contenuto))
file.close()
@staticmethod
def infor():
"""
Visualizza le informazioni riguardante il programma
"""
nome = """pdp8 emulator"""
stringa = """
Pdp8 Emulator
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
Version = 1.6.2
Tested with = python 2.6 & 2.7
-------------------------------------------------------------------
The MIT License (MIT)
Copyright (c) 2015 Mirco
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall
be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------
Contact: [email protected]
Collaborators : Walter Valentini
"""
showinfo(nome, stringa)
@staticmethod
def leg():
"""
Visualizza le informazioni riguardanti colori
"""
nome = """pdp8 Legenda"""
stringa = """
Rosso = indirizzo puntato da PC
Giallo = indirizzo puntato da MAR
Verde = ultima istruzione eseguita
"""
showinfo(nome, stringa)
@staticmethod
def guida():
"""
Piccola guida
"""
nome = """pdp8 Guida"""
stringa = """
LOAD = Carica il assembly nella memoria del Calcolatore
Didattico (CD).
STEP = Avanza del numero di step indicato (di default 1).
Uno step equivale all'esecuzione di una singola istruzione.
mini STEP = Esegue un singolo ciclo in base alle variabili
F ed R dell'unità di controllo.
micro STEP = Esegue ogni singola microistruzione.
Set n STEP = Setta il numero di step.
Set Delay = Setta il tempo di aggiornamento del CD.
START = Avvia il CD, ma non l'esecuzione del codice. Per
eseguire il codice, utilizzare step o esegui una
volta avviata la macchina.
RESET = Resetta il CD allo stato iniziale.
STOP = Ferma il CD e quindi anche l'esecuzione del codice.
BREAK = Aggiunge o toglie un break alla cella indicata
in esadecimale.
CONTINUA = Continua l'esecuzione del programma dopo un break.
Equivale a premere in sequenza START ed ESEGUI.
ESEGUI = Esegue il codice fino all'istruzione HLT, che
arresta la macchina.
"""
showinfo(nome, stringa)
class PositionFrame(LabelFrame):
"""Remembers tracker positions."""
def __init__(self, master, text="Position", **options):
LabelFrame.__init__(self, master, text=text, **options)
self.tracker = master.tracker
self.listbox = Listbox(self)
self.listbox.widget.configure(selectmode=SINGLE)
self.listbox.grid(row=0, column=0, rowspan=6)
self.name_frame = LabelFrame(self, text="Name")
self.name_field = Entry(self.name_frame)
self.name_field.grid()
self.name_frame.grid(row=0, column=1)
self.save_button = Button(self, text="Save current",
command=bg_caller(self.save_position))
self.save_button.grid(row=1, column=1)
self.go_to_button = Button(self, text="Go to",
command=bg_caller(self.go_to_position))
self.go_to_button.grid(row=2, column=1)
self.delete_button = Button(self, text="Delete",
command=self.delete_position)
self.delete_button.grid(row=3, column=1)
self.write_button = Button(self, text="Write to file",
command=self.write_to_file)
self.write_button.grid(row=4, column=1)
self.load_button = Button(self, text="Load from file",
command=self.load_from_file)
self.load_button.grid(row=5, column=1)
def save_position(self):
"""Records the tracker's current position."""
response = self.tracker.measure()[0]
if response.status != response.DATA_ACCURATE:
logger.error("Data taken were not accurate.")
return
name = self.name_field.get()
self.listbox.add(response.position, name)
logger.info("Saved {} as {}".format(response.position, name))
def go_to_position(self):
"""Moves the tracker to the selected position."""
selection = self.listbox.get_selected_items()
names = self.listbox.get_selected_names()
if len(selection) > 0:
r, theta, phi = selection[0]
name = names[0]
self.tracker.move_absolute(r, theta, phi)
logger.info("Moved tracker to {name!r} ({posn})"
.format(name=name, posn=(r, theta, phi)))
else:
logger.error("Must select a position to go to.")
def delete_position(self):
"""Deletes the selected position."""
self.listbox.remove_selected()
def write_to_file(self):
filename = tkFileDialog.asksaveasfilename(initialdir=nodes_dir)
if filename:
nodes.io.save(self.listbox.names_to_items, filename)
logger.info("Wrote current node list to {!r}".format(filename))
def load_from_file(self):
filename = tkFileDialog.askopenfilename(initialdir=nodes_dir)
if filename:
self.listbox.clear()
for (key, value) in nodes.io.load(filename).items():
self.listbox.add(item=value, name=key)
logger.info("Loaded node list from {!r}".format(filename))
class ihm(Tkinter.Tk):
services = []
nodes = []
serviceManager = service.service()
configManager = dep.dep()
link = ''
def reset(self):
global nodes
global services
self.nodes = []
self.services = []
self.outputServices = Tkinter.Text(self)
self.outputServices.grid(column=1, row=1)
self.outputNode = Tkinter.Text(self)
self.outputNode.grid(column=0, row=1)
def start(self):
print '----------------start----------------'
global nodes
global services
global serviceManager
args = ['service.py']
for i in range(1, (len(self.nodes) + 1)):
args.append(self.nodes[i - 1])
args.append('service')
for i in range(0, (len(self.services))):
args[len(self.nodes) + 1] = self.services[i]
if self.nodes[0] != "":
if self.services[0] != "":
self.serviceManager.start(args)
print ''
def status(self):
print '----------------status----------------'
global nodes
global services
global serviceManager
args = ['service.py']
args.append('service')
args.append('service')
for i in range(1, (len(self.nodes) + 1)):
args[1] = self.nodes[i - 1]
for i in range(0, (len(self.services))):
args[2] = self.services[i]
if self.nodes[0] != "":
if self.services[0] != "":
ret = self.serviceManager.status(args, 1)
if ret == 0:
print 'Service : ' + args[2] + ' sur : ' + args[
1] + ' status : non-demarre'
elif ret == 1:
print 'Service : ' + args[2] + ' sur : ' + args[
1] + ' status : demarre'
print ''
def stop(self):
print '----------------stop----------------'
global nodes
global services
global serviceManager
args = ['service.py']
for i in range(1, (len(self.nodes) + 1)):
args.append(self.nodes[i - 1])
args.append('service')
for i in range(0, (len(self.services))):
args[len(self.nodes) + 1] = self.services[i]
if self.nodes[0] != "":
if self.services[0] != "":
self.serviceManager.stop(args)
print ''
def fnct(self, event):
if self.entrerNode.get() != "":
#print self.entrerNode.get()
self.outputNode.insert('1.0', self.entrerNode.get() + '\n')
global nodes
self.nodes.append(self.entrerNode.get())
self.valueNode.set("")
if self.entrerService.get() != "":
#print self.entrerService.get()
self.outputServices.insert('1.0', self.entrerService.get() + '\n')
global services
self.services.append(self.entrerService.get())
self.valueService.set("")
def btn(self):
if self.entrerNode.get() != "":
#print self.entrerNode.get()
self.outputNode.insert('1.0', self.entrerNode.get() + '\n')
global nodes
self.nodes.append(self.entrerNode.get())
self.valueNode.set("")
if self.entrerService.get() != "":
#print self.entrerService.get()
self.outputServices.insert('1.0', self.entrerService.get() + '\n')
global services
self.services.append(self.entrerService.get())
self.valueService.set("")
def startConfig(self):
global configManager
self.configManager.targetNode('cfg/' + self.entrerConfig.get())
self.configManager.targetService('cfg/' + self.entrerConfig.get())
self.configManager.link('cfg/' + self.entrerConfig.get())
global nodes
self.nodes = self.configManager.getTargetNodes()
global services
self.services = self.configManager.getTargetServices()
global link
self.link = self.configManager.getLinkedTo()
self.linkedStart()
def startConfigProcedure(self):
global configManager
global link
self.configManager.targetNode('cfg/' + self.link[0])
self.configManager.targetService('cfg/' + self.link[0])
self.configManager.link('cfg/' + self.link[0])
global nodes
self.nodes = self.configManager.getTargetNodes()
global services
self.services = self.configManager.getTargetServices()
self.link[0] = ''
self.link = self.configManager.getLinkedTo()
self.linkedStart()
def linkedStart(self):
print '----------------start----------------'
global nodes
global services
global serviceManager
args = ['service.py']
for i in range(1, (len(self.nodes) + 1)):
args.append(self.nodes[i - 1])
args.append('service')
for i in range(0, (len(self.services))):
args[len(self.nodes) + 1] = self.services[i]
if self.nodes[0] != "":
if self.services[0] != "":
self.serviceManager.start(args)
print ''
global nodes
global services
self.nodes = []
self.services = []
global link
if self.link[0] != '':
self.startConfigProcedure()
def __init__(self, parent):
Tkinter.Tk.__init__(self, parent)
self.parent = parent
self.bind("<Return>", self.fnct)
self.initialize()
def initialize(self):
#layout manager
self.grid()
#champ de texte (entrer)
self.lframe = LabelFrame(self, text="Nom du noeud", padx=50, pady=20)
self.lframe.grid(column=0, row=0, sticky='EW')
self.lframeService = LabelFrame(self,
text="Nom du service",
padx=50,
pady=20)
self.lframeService.grid(column=1, row=0, sticky='EW')
self.valueNode = StringVar()
#self.valueNode.set("Noeud")
self.entrerNode = Tkinter.Entry(self.lframe,
fg='grey',
textvariable=self.valueNode)
self.entrerNode.pack()
self.valueService = StringVar()
#self.valueService.set("Noeud")
self.entrerService = Tkinter.Entry(self.lframeService,
fg='grey',
textvariable=self.valueService)
self.entrerService.pack()
self.buttonNode = Tkinter.Button(self.lframe,
text="Ok",
command=self.btn)
self.buttonNode.pack()
self.buttonService = Tkinter.Button(self.lframeService,
text="Ok",
command=self.btn)
self.buttonService.pack()
self.outputServices = Tkinter.Text(self)
self.outputServices.grid(column=1, row=1)
self.outputNode = Tkinter.Text(self)
self.outputNode.grid(column=0, row=1)
self.start = Tkinter.Button(self, text="Start", command=self.start)
self.start.grid(column=0, row=2)
self.start = Tkinter.Button(self, text="Reset", command=self.reset)
self.start.grid(column=2, row=0)
self.stop = Tkinter.Button(self, text="Stop", command=self.stop)
self.stop.grid(column=1, row=2)
self.status = Tkinter.Button(self, text="Status", command=self.status)
self.status.grid(column=2, row=2)
self.valueConfig = StringVar()
self.entrerConfig = Tkinter.Entry(self,
fg='grey',
textvariable=self.valueConfig)
self.entrerConfig.grid(column=0, row=3)
self.config = Tkinter.Button(self,
text="Start config",
command=self.startConfig)
self.config.grid(column=1, row=3)
#self.label = Tkinter.Label(self,anchor="center",text = 'Nom du noeud :',fg="black",bg="white")
#self.label.grid(column=0,row=0,columnspan=2,sticky='EW')
#redimensionnement auto
self.grid_columnconfigure(0, weight=1)
self.geometry("800x600+300+0")
def gui_quadscansim(frame, w, h, status, start, stop):
def _start():
lattice = latticemenu.get()
if lattice == 'drift':
qL = float(entry_qL.get())
driftlength = float(entry_dlen.get())
UC = zeros([6, 1])
UC[1] = driftlength
else:
quad = int(quadmenuval.get())
screen = screenmenuval.get()
_, _, _, UC, diagnostics, _, _, _, _, _, _, _ = latt2py(lattice, False)
elements = UC[0, :]
# index after selected quad (quad itself not required)
i = sort(concatenate((where(elements==3), where(elements==4)), 1))[0][quad-1]+1
# index before selected fom (next would be fom itself)
fom = where(array(diagnostics) == screen)[0][0]
f = where(elements==7)[0][fom]
if i > f:
showerror(title='ERROR', message='Please choose a quad before chosen screen')
return
qL = UC[1, i-1]
UC = UC[:, i:f]
ki = float(entry_ki.get())
kf = float(entry_kf.get())
points = int(entry_points.get())
epsx = float(entry_epsx.get())/1e9
betx = float(entry_betx.get())
alpx = float(entry_alpx.get())
epsy = float(entry_epsy.get())/1e9
bety = float(entry_bety.get())
alpy = float(entry_alpy.get())
epss = (float(entry_epss.get())/1e3)**2
Dx = float(entry_Dx.get())
Dpx = float(entry_Dpx.get())
energy = float(entry_energy.get())*1e6
particle = 'electron'
if filestr.get() != '':
data = loadtxt(filestr.get())
else:
data = None
if betx < 0 or bety < 0:
showerror('ERROR', 'beta function must be positive')
return
runthread(status, [1, lf_OUT], simulate_quadscan,
(ki, kf, qL, UC, points, epsx, betx, alpx,
epsy, bety, alpy, epss, Dx, Dpx, energy, particle, data))
def _load():
global filename
filename = askopenfilename(initialdir='accpy/exampledata/')
if filename[-5::] != '.hdf5':
#filestr.set('error: {} is not hdf5 file-type'.format(filename))
#showerror('ERROR', 'THIS IS NOT A HDF5 FILE')
filestr.set(filename)
else:
filestr.set(filename)
def _check(*args):
lattice = latticemenu.get()
if lattice == 'drift':
quadN.grid_remove()
quadmenu.grid_remove()
screenN.grid_remove()
screenmenu.grid_remove()
quadlab.grid()
quadent.grid()
driftlab.grid()
driftent.grid()
else:
_, _, _, UC, diagnostics, _, _, _, _, _, _, _ = latt2py(lattice, False)
elements = list(UC[0,:])
quads = range(1, (elements.count(3)+elements.count(4)+1))
quadlab.grid_remove()
quadent.grid_remove()
driftlab.grid_remove()
driftent.grid_remove()
screenmenu['menu'].delete(0, 'end')
quadmenu['menu'].delete(0, 'end')
[screenmenu['menu'].add_command(label=fom, command=_setit(screenmenuval, fom)) for fom in diagnostics]
[quadmenu['menu'].add_command(label=quad, command=_setit(quadmenuval, quad)) for quad in quads]
screenN.grid()
quadN.grid()
screenmenu.grid()
quadmenu.grid()
start.configure(command=_start)
frame.pack(fill=BOTH, expand=1)
lf_upbeam = LabelFrame(frame, text="Upstream beam parameters", padx=5, pady=5)
lf_upbeam.grid(row=1, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_transfer = LabelFrame(frame, text="Transport matrix", padx=5, pady=5)
lf_transfer.grid(row=2, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_quadrupole = LabelFrame(frame, text="Quadrupole range", padx=5, pady=5)
lf_quadrupole.grid(row=1, column=1, sticky=W+E+N+S, padx=10, pady=10)
lf_data = LabelFrame(frame, text="Data comparison", padx=5, pady=5)
lf_data.grid(row=2, column=1, sticky=W+E+N+S, padx=10, pady=10)
lf_OUT = LabelFrame(frame, text="Results", padx=5, pady=5)
lf_OUT.grid(row=3, column=0, columnspan=2, sticky=W+E+N+S, padx=10, pady=10)
cs_label(lf_upbeam, 1, 2, uc.epsilon+' / nm rad')
cs_label(lf_upbeam, 1, 3, uc.beta+' / m')
cs_label(lf_upbeam, 1, 4, uc.alpha+'/ rad')
cs_label(lf_upbeam, 2, 1, 'Radial')
entry_epsx = cs_Dblentry(lf_upbeam, 2, 2, 202)
entry_betx = cs_Dblentry(lf_upbeam, 2, 3, 6.37)
entry_alpx = cs_Dblentry(lf_upbeam, 2, 4, -0.13)
cs_label(lf_upbeam, 3, 1, 'Axial')
entry_epsy = cs_Dblentry(lf_upbeam, 3, 2, 144)
entry_bety = cs_Dblentry(lf_upbeam, 3, 3, 4.1)
entry_alpy = cs_Dblentry(lf_upbeam, 3, 4, -0.51)
cs_label(lf_upbeam, 4, 2, uc.delta+' / '+uc.ppt)
cs_label(lf_upbeam, 4, 3, 'D / m')
cs_label(lf_upbeam, 4, 4, 'D\' / rad')
cs_label(lf_upbeam, 5, 1, 'Longitudinal')
entry_epss = cs_Dblentry(lf_upbeam, 5, 2, 2.4)
entry_Dx = cs_Dblentry(lf_upbeam, 5, 3, 0.)
entry_Dpx = cs_Dblentry(lf_upbeam, 5, 4, 0.)
cs_label(lf_transfer, 0, 0, 'Optic', sticky=W)
_, openlatts = lattlist()
latticemenu = cs_dropd(lf_transfer, 1, 0, ['drift'] + openlatts, action=_check)
quadlab = cs_label(lf_transfer, 0, 1, 'Quadrupole length / m', retlab=True)[1]
quadent = entry_qL = cs_Dblentry(lf_transfer, 0, 2, .119)
driftlab = cs_label(lf_transfer, 1, 1, 'Driftlength / m', retlab=True)[1]
driftent = entry_dlen = cs_Dblentry(lf_transfer, 1, 2, 1.8)
quadN = cs_label(lf_transfer, 0, 1, 'Which quadrupole', retlab=True)[1]
quadmenuval, quadmenu = cs_dropd(lf_transfer, 1, 1, [''], retbut=True)
screenN = cs_label(lf_transfer, 2, 1, 'Which screen', retlab=True)[1]
screenmenuval, screenmenu = cs_dropd(lf_transfer, 3, 1, openlatts, retbut=True)
quadN.grid_remove()
quadmenu.grid_remove()
screenN.grid_remove()
screenmenu.grid_remove()
quadlab.grid_remove()
quadent.grid_remove()
driftlab.grid_remove()
driftent.grid_remove()
cs_button(lf_data, 0, 0, 'Load', _load)
filestr = cs_label(lf_data, 1, 0, '')
cs_label(lf_quadrupole, 0, 0, 'Beam energy / MeV')
entry_energy = cs_Dblentry(lf_quadrupole, 0, 1, 52)
cs_label(lf_quadrupole, 1, 1, 'Quadrupole strength k / (1/m'+uc.squared+')')
cs_label(lf_quadrupole, 2, 0, 'Initial (k<0 = axial focus)')
entry_ki = cs_Dblentry(lf_quadrupole, 2, 1, -8)
cs_label(lf_quadrupole, 3, 0, 'Final')
entry_kf = cs_Dblentry(lf_quadrupole, 3, 1, 8)
cs_label(lf_quadrupole, 4, 0, 'steps')
entry_points = cs_Intentry(lf_quadrupole, 4, 1, 1000)
return
def grid(self,*args,**kwargs):
LabelFrame.grid(self,*args,pady=2,**kwargs)
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 GuiMainWindow(Frame):
def __init__(self, master, environment):
Frame.__init__(self, master)
self.environment = environment
self.number_of_devices = self.environment.number_of_devices
self.cc2541_checked = IntVar()
self.efm32_checked = IntVar()
self.bluetooth_checked = IntVar()
self.ni_usb_checked = IntVar()
self.gpib_checked = IntVar()
self.srfpc_return_code_list = []
self.eac_return_code_list = []
self.eb_id_list = [StringVar() for _ in range(self.number_of_devices)]
self.jlink_sn_list = [StringVar() for _ in range(self.number_of_devices)]
self.__loadEbIdFromEnvironment()
self.__loadJlinkSnFromEnvironment()
self.master = master
self.__initUi()
def __notImplementedYet(self):
tkMessageBox.showinfo('Information', 'NOT IMPLEMENTED YET!!!')
#===========================================================================
# Initialize and reset GUI
#===========================================================================
def __initUi(self):
self.grid()
self.master.title('Shine Production')
for i in range(3):
self.rowconfigure(i, pad=5)
self.columnconfigure(0, pad=5, weight=1)
self.columnconfigure(1, pad=5, weight=1)
self.columnconfigure(2, pad=5, weight=2)
self.columnconfigure(3, pad=5, weight=1)
# Status frame
self.status_frame = LabelFrame(self, text='Status', relief=RIDGE)
self.status_frame.grid = self.status_frame.grid(row=0, column=0, columnspan=FRAME_COLUMN_SPAN, padx=5, pady=5)
for i in range(8):
self.status_frame.rowconfigure(i, pad=3)
for i in range(self.number_of_devices + 1):
self.status_frame.columnconfigure(i, pad=3)
Label(self.status_frame, text='EB ID').grid(row=0, column=0, sticky=W)
Label(self.status_frame, text='J-Link Serial Number').grid(row=1, column=0, sticky=W)
Label(self.status_frame, text='Status').grid(row=2, column=0, sticky=W)
Label(self.status_frame, text='DUT').grid(row=3, column=0, sticky=W)
self.eb_id_entry = []
self.jlink_sn_entry = []
self.dut_status_label = []
for i in range (self.number_of_devices):
self.eb_id_entry.append(Entry(self.status_frame, textvariable=self.eb_id_list[i], justify=CENTER, width=10))
self.eb_id_entry[i].grid(row=0, column=i + 1)
self.jlink_sn_entry.append(Entry(self.status_frame, textvariable=self.jlink_sn_list[i], justify=CENTER, width=10))
self.jlink_sn_entry[i].grid(row=1, column=i + 1)
self.dut_status_label.append(Label(self.status_frame, text='status', bg=INITIATED_COLOR))
self.dut_status_label[i].grid(row=2, column=i + 1)
Label(self.status_frame, text='#{}'.format(i + 1)).grid(row=3, column=i + 1)
# Path frame
self.path_frame = LabelFrame(self, text='Paths')
self.path_frame.grid = self.path_frame.grid(row=1, column=0, columnspan=FRAME_COLUMN_SPAN, padx=5, pady=5)
for i in range(5):
self.path_frame.rowconfigure(i, pad=3)
for i in range(3):
self.path_frame.columnconfigure(i, pad=3)
Label(self.path_frame, text='SmartRFProgConsole Path').grid(row=0, column=0, sticky=W)
self.srfpc_path_label = Label(self.path_frame, text=shortenPath(self.environment.srfpc_path))
self.srfpc_path_label.grid(row=0, column=1, columnspan=FRAME_COLUMN_SPAN - 2, sticky=W)
Button(self.path_frame, text=' ... ', command=self.setSrfpcPath).grid(row=0, column=FRAME_COLUMN_SPAN - 1, sticky=N + S + E + W)
Label(self.path_frame, text='EACommander Path').grid(row=1, column=0, sticky=W)
self.eac_path_label = Label(self.path_frame, text=shortenPath(self.environment.eac_path))
self.eac_path_label.grid(row=1, column=1, columnspan=FRAME_COLUMN_SPAN - 2, sticky=W)
Button(self.path_frame, text=' ... ', command=self.setEacPath).grid(row=1, column=FRAME_COLUMN_SPAN - 1, sticky=N + S + E + W)
Label(self.path_frame, text='CC2541 Firmware Path').grid(row=2, column=0, sticky=W)
self.cc2541_firmware_path_label = Label(self.path_frame, text=shortenPath(self.environment.cc2541_firmware_path))
self.cc2541_firmware_path_label.grid(row=2, column=1, columnspan=FRAME_COLUMN_SPAN - 2, sticky=W)
Button(self.path_frame, text=' ... ', command=self.setCc2541FirmwarePath).grid(row=2, column=FRAME_COLUMN_SPAN - 1, sticky=N + S + E + W)
Label(self.path_frame, text='EFM32 Firmware Path').grid(row=3, column=0, sticky=W)
self.efm32_firmware_path_label = Label(self.path_frame, text=shortenPath(self.environment.efm32_firmware_path))
self.efm32_firmware_path_label.grid(row=3, column=1, columnspan=FRAME_COLUMN_SPAN - 2, sticky=W)
Button(self.path_frame, text=' ... ', command=self.setEfm32FirmwarePath).grid(row=3, column=FRAME_COLUMN_SPAN - 1, sticky=N + S + E + W)
Label(self.path_frame, text='EFM32 Final Firmware Path').grid(row=4, column=0, sticky=W)
self.efm32_final_firmware_path_label = Label(self.path_frame, text=shortenPath(self.environment.efm32_firmware_path_final))
self.efm32_final_firmware_path_label.grid(row=4, column=1, columnspan=FRAME_COLUMN_SPAN - 2, sticky=W)
Button(self.path_frame, text=' ... ', command=self.setEfm32FinalFirmwarePath).grid(row=4, column=FRAME_COLUMN_SPAN - 1, sticky=N + S + E + W)
# Initiate Verify, Start and Close buttons
self.save_environment_button = Button(self, text='Save Environment', command=self.saveEnvironment)
self.save_environment_button.grid(row=2, column=0, sticky=N+S+E+W)
self.start_button = Button(self, text="Start", command=self.start2)
self.start_button.grid(row=2, column=2, sticky=N+S+E+W)
self.close_button = Button(self, text="Close", command=self.close)
self.close_button.grid(row=2, column=3, sticky=N+S+E+W)
def __resetStatusLabels(self):
for i in range (self.number_of_devices):
self.dut_status_label[i].config(text='status', bg=INITIATED_COLOR)
#===========================================================================
# Load, save EB and J-Link devices IDs from to environment to display them
# on the GUI
#===========================================================================
def __loadEbIdFromEnvironment(self):
for i in range(self.number_of_devices):
self.eb_id_list[i].set(self.environment.eb_id_list[i])
def __loadJlinkSnFromEnvironment(self):
for i in range(self.number_of_devices):
self.jlink_sn_list[i].set(self.environment.jlink_sn_list[i])
def __saveEbIdToEnvironment(self):
for i in range(self.number_of_devices):
self.environment.eb_id_list[i] = self.eb_id_list[i].get()
def __saveJlinkSnToEnvironment(self):
for i in range(self.number_of_devices):
self.environment.jlink_sn_list[i] = self.jlink_sn_list[i].get()
#===========================================================================
# Update status labels on the GUI
#===========================================================================
def __setStatusLabel(self, index, status):
# self.srfpc_return_code_list[index] = status
if status == SUCCESS_CODE:
self.dut_status_label[index].config(text='Pass [{}]'.format(str(status)), bg=STATUS_OK_COLOR)
elif status == IN_PROGRESS_CODE:
self.dut_status_label[index].config(text='In Progress... [{}]'.format(str(status)), bg=STATUS_IN_PROGRESS_COLOR)
elif status == -2:
self.dut_status_label[index].config(text='FIX INTERNET', bg='blue')
elif status == -3:
self.dut_status_label[index].config(text='CANT CONNECT TO KEITHLEY', bg='blue')
else:
self.dut_status_label[index].config(text='Fail [{}]'.format(str(status)), bg=STATUS_ERROR_COLOR)
self.update()
def __drawStatusLabel(self, status_list):
if type(status_list) != list or len(status_list) != self.number_of_devices:
return
for i in range(self.number_of_devices):
self.__setStatusLabel(i, status_list[i])
#===========================================================================
# Update executable paths
#===========================================================================
def setSrfpcPath(self):
f = tkFileDialog.askopenfile(parent=self.master,
mode='rb',
title='Pick SmartRFProgConsole.exe file',
filetype=(('EXE file', '*.exe'),))
if f:
self.environment.srfpc_path = os.path.abspath(f.name)
f.close()
self.environment.save()
self.srfpc_path_label.config(text=shortenPath(self.environment.srfpc_path))
self.srfpc_path_label.update()
def setEacPath(self):
f = tkFileDialog.askopenfile(parent=self.master,
mode='rb',
title='Pick eACommander.exe file',
filetype=(('EXE file', '*.exe'),))
if f != None:
self.environment.eac_path = os.path.abspath(f.name)
f.close()
self.environment.save()
self.eac_path_label.config(text=shortenPath(self.environment.eac_path))
self.eac_path_label.update()
def setCc2541FirmwarePath(self):
f = tkFileDialog.askopenfile(parent=self.master,
mode='rb',
title='Pick CC2541 Firmware HEX file',
filetype=(('HEX file', '*.hex'),))
if f != None:
self.environment.cc2541_firmware_path = os.path.abspath(f.name)
f.close()
self.environment.save()
self.cc2541_firmware_path_label.config(text=shortenPath(self.environment.cc2541_firmware_path))
self.cc2541_firmware_path_label.update()
def setEfm32FirmwarePath(self):
f = tkFileDialog.askopenfile(parent=self.master,
mode='rb',
title='Pick EFM32 Firmware BIN file',
filetype=(('BIN file', '*.bin'),))
if f != None:
self.environment.efm32_firmware_path = os.path.abspath(f.name)
f.close()
self.environment.save()
self.efm32_firmware_path_label.config(text=shortenPath(self.environment.efm32_firmware_path))
self.efm32_firmware_path_label.update()
def setEfm32FinalFirmwarePath(self):
f = tkFileDialog.askopenfile(parent=self.master,
mode='rb',
title='Pick EFM32 Final Firmware BIN file',
filetype=(('BIN file', '*.bin'),))
if f != None:
self.environment.efm32_firmware_path_final = os.path.abspath(f.name)
f.close()
self.environment.save()
self.efm32_final_firmware_path_label.config(text=shortenPath(self.environment.efm32_firmware_path_final))
self.efm32_final_firmware_path_label.update()
def saveEnvironment(self):
self.__saveEbIdToEnvironment()
self.__saveJlinkSnToEnvironment()
self.environment.save()
tkMessageBox.showinfo('Information', 'Environment has been saved successfully!')
def close(self):
"""
TODO: Save current parameters, state.
"""
if tkMessageBox.askokcancel('Confirmation', 'Are you sure you want to quit?'):
self.quit()
def __waitForContinueMessage(self):
#P0.6 = ETM_TD0
test = -1
while test != 0: # THIS VALUE IS ALWAYS SOMETHING IS WRONG
test = NI.captureDigitalInput('Dev1/port0/line6', 1)[0]
def __sendContinueMessage(self):
#P0.7 = ETM_TD1
NI.setDigitalOutput('Dev1/port0/line7', 128)
NI.setDigitalOutput('Dev1/port0/line7', 0)
def start2(self):
self.__resetStatusLabels()
self.start_button.config(state=DISABLED)
self.start_button.update()
self.__setStatusLabel(0, IN_PROGRESS_CODE)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~~~CC2541 and EFM32 FIRMWARE FLASH (PRODUCTION TEST FIRMWARE)~~~
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
dut_parameters = DutParameters(ATE_ID,
self.environment.device_code_name,
self.environment.device_type,
self.environment.eb_id_list[0],
self.environment.jlink_sn_list[0],
self.environment)
status = executeTestSequence(dut_parameters, log_queue)
print 'Status: {}'.format(status)
dut_parameters.logStatus(status)
self.__setStatusLabel(0, status)
self.start_button.config(state=ACTIVE)
self.start_button.update()
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()
def setup_im_proc_section(self):
im_proc = LabelFrame(self.parent, width=col_w, height=row_h, text="Image Processing Status")
im_proc.grid(row=2, column=0)
self.im_proc_txt = Text(im_proc, height=18, width=65)
self.im_proc_txt.pack(fill=BOTH, expand=1)
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 setup_stat_man_section(self):
stat_man = LabelFrame(self.parent, width=col_w, height=row_h, text="Status Management Status")
stat_man.grid(row=1, column=2)
self.stat_man_txt = Text(stat_man, height=18, width=65)
self.stat_man_txt.pack(fill=BOTH, expand=1)
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 setup_harvest_section(self):
harvest = LabelFrame(self.parent, width=col_w, height=row_h, text="Harvest Status")
harvest.grid(row=1, column=0)
self.harv_txt = Text(harvest, height=18, width=65)
self.harv_txt.pack(fill=BOTH, expand=1)
class Main():
def __init__(self, master):
#La intro se puede apagar al final, cumple solo una funcion vistosa
#Iniciacion propia de la ventan y sus configuraciones
self.master=master
self.master.wm_title(R.AppTitle)
self.widht=(self.master.winfo_screenwidth() - self.master.winfo_reqwidth()) / 2
self.height=(self.master.winfo_screenheight() - self.master.winfo_reqheight()) / 2
self.master.geometry("+{0:.0f}+{1:.0f}".format(self.widht, self.height))
self.master.deiconify()
self.master.resizable(False,False)
self.icon=(R.IconPath)
self.master.iconbitmap(self.icon)
self.master.configure(background=R.Bgcolor)
#Definicion de variables variables que estaran en uso.
self.btnFlecha=Image.open(R.BtnFlechaImgPath)
self.btnFlechaimg=ImageTk.PhotoImage(self.btnFlecha)
self.selectMed = StringVar(self.master)
self.selectMed.set(R.SelectMed)
#Las variables que usaran para saber que hacer o que reemplazar
self.fromLabel = StringVar()
self.fromLabel.set(R.Select)
self.toLabel=StringVar()
self.toLabel.set(R.Select)
#Los valores de las entradas
self.fromNumber=StringVar()
self.toNumber=StringVar()
#La creacion de las partes del programita.
self.menuChoices()
self.convertChoice()
self.convertButton()
def menuChoices(self):
#Menu de seleccion principal sobre los tipos que conversion que hara el programa
self.MenuChoices = OptionMenu(self.master, self.selectMed, R.LongMain,R.AlmacMain, command=self.choice)
self.MenuChoices.configure(bg="white",fg="black",activebackground="#eceefb",highlightbackground=R.Bgcolor,
indicatoron=0,image=self.btnFlechaimg,compound='right')
self.MenuChoices.grid(row=0,column=0)
def convertChoice(self):
#Las partes que integran el primer submenu llamado "DE", labelFrame,menu, entrada.
self.labelFrameFrom=LabelFrame(self.master,text="De",background=R.Bgcolor)
self.labelFrameFrom.grid(row=1,column=0,padx=5,pady=3)
self.menuFrom=OptionMenu(self.labelFrameFrom,self.fromLabel,"",)
self.menuFrom.configure(bg=R.White,fg=R.Black,activebackground=R.hoverBtnColor,highlightbackground=R.Bgcolor,
indicatoron=0,image=self.btnFlechaimg, compound='right')
self.menuFrom.grid(row=0,column=0,padx=3,pady=2,sticky=E)
self.entryFrom=Entry(self.labelFrameFrom,justify='center',textvariable=self.fromNumber)
self.entryFrom.grid(row=2,column=0,padx=5,pady=5)
#Las partes que integran el segundo submenu llamado "Hasta", labelFrame, menu, entrada.
self.labelFrameTo=LabelFrame(self.master,text="Hacia",background=R.Bgcolor)
self.labelFrameTo.grid(row=1,column=1,padx=5,pady=3)
self.menuTo=OptionMenu(self.labelFrameTo,self.toLabel,"",)
self.menuTo.configure(bg=R.White,fg=R.Black, activebackground=R.hoverBtnColor,highlightbackground=R.Bgcolor,
indicatoron=0,image=self.btnFlechaimg, compound='right')
self.menuTo.grid(row=0,column=0, padx=3, pady=2, sticky=E)
self.entryTo=Entry(self.labelFrameTo,justify='center',textvariable=self.toNumber,state="readonly")
self.entryTo.configure(bg="red", readonlybackground=R.Bgcolor)
self.entryTo.grid(row=2,column=0,padx=3,pady=5)
def convertButton(self):
#El boton Convertir que activa las funcionalidades de los campos
self.butonimgpath = Image.open(R.BtnConvertirImgPath)
self.butonTkImage = ImageTk.PhotoImage(self.butonimgpath)
self.button = Button(self.master,text='Convertir',command=self.choiceFromTo)
self.button.configure(image=self.butonTkImage, bd=False, highlightthickness=0, activebackground="black")
self.button.grid(row=3,column=1,sticky=E)
def choice(self, choices):
#Al tocar el boton [<- Selecione] se cambia la opcion de medida y se genera opciones acorde
# error.set("")
#Opciones acorde en el caso de elegir "Longitudes"
if choices==R.LongMain:
self.fromLabel.set(R.LongStart)
self.toLabel.set(R.LongStart)
self.clean()
# medidas= ("kms", "milla","metro","legua","yarda","pie")
for m in R.LongList:
self.menuFrom['menu'].add_command(label=m,command=lambda v=self.fromLabel,l=m:v.set(l))
for m in R.LongList:
self.menuTo['menu'].add_command(label=m,command=lambda v=self.toLabel,l=m:v.set(l))
#Genera las opciones si se elige "Almacenamientos"
elif choices==R.AlmacMain:
self.fromLabel.set(R.AlmacStart)
self.toLabel.set(R.AlmacStart)
self.clean()
# medidas= ("Gbs", "Mbs","Kbs","bytes")
for m in R.AlmacList:
self.menuFrom['menu'].add_command(label=m,command=lambda v=self.fromLabel,l=m:v.set(l))
for m in R.AlmacList:
self.menuTo['menu'].add_command(label=m,command=lambda v=self.toLabel,l=m:v.set(l))
def choiceFromTo(self):
try:
#Se toma los valores de las seleciones [DE] y [HACIA], ademas de la entrada numerica
# self.fromChoice=self.fromNumber.get()
self.fromChoice=self.fromLabel.get()
self.toChoice=self.toLabel.get()
self.fromN=self.entryFrom.get()
#A partir de un if se consulta
#el objeto a crear que poseen los comportamientos de convertirse a
#otra medida
#Si la medida esta en el campo de las longitudes
if self.toChoice in R.LongList:
convLong = Distancia(float(self.fromN))
dicChoices = {0: convLong.km_a_(self.toChoice),
1: convLong.milla_a_(self.toChoice),
2: convLong.metro_a_(self.toChoice),
3: convLong.legua_a_(self.toChoice),
4: convLong.yarda_a_(self.toChoice),
5: convLong.pie_a_(self.toChoice)}
self.toNumber.set(dicChoices.get(R.LongList.index(self.fromChoice)))
#Si la medida esta en el campo de las medidas de almacenamiento
elif self.toChoice in R.AlmacList:
conAlmc = Almacenamiento(float(self.fromN))
dicChoices = {0: conAlmc.gb_a_(self.toChoice),
1: conAlmc.mb_a_(self.toChoice),
2: conAlmc.kbs_a_(self.toChoice),
3: conAlmc.bytes_a_(self.toChoice)}
self.toNumber.set(dicChoices.get(R.AlmacList.index(self.fromChoice)))
except:
self.toNumber.set('{}'.format("Numero no valido"))
def clean(self):
self.menuTo['menu'].delete(0,END)
self.menuFrom['menu'].delete(0,END)
class PhyUI():
def callback_switcher(self):
""" Callback function for switching status between
'freezed' and 'on going'. """
play_ref = self.button_play
if not self.locked :
play_ref.config(text = "Play")
self.locked = True
else:
play_ref.config(text = "Freeze")
self.locked = False
def keyevent_up_press(self, event):
""" Callback for pressing up key. """
self.mouse_lock = True
self.selected_user_accel_factor[0] = 1
def keyevent_up_release(self, event):
""" Callback for releasing up key. """
self.mouse_lock = False
self.selected_user_accel_factor[0] = 0
def keyevent_down_press(self, event):
""" Callback for pressing down key. """
self.mouse_lock = True
self.selected_user_accel_factor[1] = 1
def keyevent_down_release(self, event):
""" Callback for releasing down key. """
self.mouse_lock = False
self.selected_user_accel_factor[1] = 0
def keyevent_left_press(self, event):
""" Callback for pressing left key. """
self.mouse_lock = True
self.selected_user_accel_factor[2] = 1
def keyevent_left_release(self, event):
""" Callback for releasing left key. """
self.mouse_lock = False
self.selected_user_accel_factor[2] = 0
def keyevent_right_press(self, event):
""" Callback for pressing right key """
self.mouse_lock = True
self.selected_user_accel_factor[3] = 1
def keyevent_right_release(self, event):
""" Callback for releasing right key """
self.mouse_lock = False
self.selected_user_accel_factor[3] = 0
def __init__(self, root_handle, canvas_width, canvas_height):
""" Setup the whole application."""
self.locked = True # True for freeze.
self.mouse_lock = False # True for locking the mouse behavior.
self.selected = None # What ball is selected now?
self.selected_user_accel_factor = [0, 0, 0, 0] # Acceleration from user's keypress event
self.selected_user_accel_val = [Vect2D(0, 15),
Vect2D(0, -5),
Vect2D(-5, 0),
Vect2D(5, 0)]
self.circles = [] # Reference to all the balls.
# Initialize the main variables for the application
self.frm_main = Frame(root_handle)
self.frm_side_top = LabelFrame(root_handle,
text = "Realtime Parameters:")
self.frm_side_bot = Frame(root_handle)
# Setup the frames
self.canv_width = canvas_width
self.canv_height = canvas_height
self.canvas_base = Vect2D(0, self.canv_height)
self.canvas = Canvas(
self.frm_main,
width = self.canv_width, height = self.canv_height,
bg = "#cccccc")
# Setup the canvas
self.canvas.bind_all("<KeyPress-w>", self.keyevent_up_press)
self.canvas.bind_all("<KeyRelease-w>", self.keyevent_up_release)
self.canvas.bind_all("<KeyPress-a>", self.keyevent_left_press)
self.canvas.bind_all("<KeyRelease-a>", self.keyevent_left_release)
self.canvas.bind_all("<KeyPress-d>", self.keyevent_right_press)
self.canvas.bind_all("<KeyRelease-d>", self.keyevent_right_release)
self.canvas.bind_all("<KeyPress-s>", self.keyevent_down_press)
self.canvas.bind_all("<KeyRelease-s>", self.keyevent_down_release)
# Setup all keys
self.button_play = Button(self.frm_side_bot,
text = "Play",
command = self.callback_switcher)
self.button_add = Button(self.frm_side_bot,
text = "Exit",
command = root_handle.quit)
# Setup all the buttons
side_names = ["Mass", "Positioin", "Velocity", "Acceleration"]
self.side_label = []
self.side_entry = []
for name in side_names:
self.side_label.append(Label(self.frm_side_top, text = name + ":"))
self.side_entry.append(Label(self.frm_side_top, width = 20))
# Setup information area located on the sidebar
self.frm_main.grid(row = 0, column = 0, rowspan = 2)
self.frm_side_top.grid(row = 0, column = 1, sticky = "S")
self.frm_side_bot.grid(row = 1, column = 1, sticky = "S")
self.canvas.grid(row = 0, column = 0, columnspan = 2)
self.button_play.grid(row = 1, column = 0, sticky = "E")
self.button_add.grid(row = 1, column = 1, sticky = "W")
for i in xrange(len(self.side_label)):
self.side_label[i].grid(row = i, column = 0)
self.side_entry[i].grid(row = i, column = 1)
# Build up the layout
def set_viewport(self, math_bl, math_tr):
"""
Set the translation rate.
You should call this before calling trans or rev_trans.
"""
self.scale_factor = Vect2D(
self.canv_width / float(math_tr.x - math_bl.x),
-self.canv_height / float(math_tr.y - math_bl.y))
self.math_base = math_bl
def trans(self, pos):
""" Translation (from math coord to canvas coord)."""
return (pos - self.math_base).scale(self.scale_factor) + \
self.canvas_base
def rev_trans(self, pos):
""" Reverse translation (from canvas coord to math coord)."""
return (pos - self.canvas_base).rev_scale(self.scale_factor) + \
self.math_base
def canvas_refresh(self, id, vertexes):
""" Refresh the canvas """
self.canvas.coords(id, vertexes)
def update_side_bot(self):
""" Update the information posted on the side bar."""
if self.selected:
self.side_entry[0].config(text = str(self.selected.mass))
self.side_entry[1].config(text = self.selected.shift.get_str())
self.side_entry[2].config(text = self.selected.velo.get_str())
self.side_entry[3].config(text = self.selected.accel.get_str())
else:
for i in xrange(4):
self.side_entry[i].config(text = "")
def create_circle(self, vertexes):
""" Create a circle graphically and return the id of the object. """
return self.canvas.create_oval(
vertexes,
fill="white"
)
def create_line(self, vertexes):
""" Create a line graphically and return the id of the object."""
return self.canvas.create_line(vertexes)
def register_trigger(self, obj, real_interval, math_interval):
""" Call this for hooking any simulated objects."""
self.canvas.after(
real_interval, obj.refresh, real_interval, math_interval)
class Emulatore(object):
"""
Interfaccia grafica per l'emulatore del pdp8
"""
def __init__(self, master, codice, calcolatore, emulatore):
"""
Inizializza i frame per l'interfaccia dell'emulatore
"""
self.CD = calcolatore
self.codice = codice
self.delay = 100
self.master = Frame(master)
self.root = emulatore
# Memoria Ram
self.ram = LabelFrame(
self.master, text='Memoria RAM', relief=RIDGE, borderwidth=5, labelanchor='n', pady=5)
self.ram.rowconfigure(0, weight=1)
self.ram.columnconfigure(0, weight=1)
self.ram.grid(
row=0, column=0, rowspan=3, columnspan=5, sticky=W + E + N + S)
# Controlli
self.controlli = Frame(self.master, padx=10, pady=10)
self.controlli.grid(row=0, column=5, rowspan=1)
# Status CD
self.registri = LabelFrame(
self.master, text='REGISTRI', relief=RIDGE, borderwidth=5, labelanchor='n', padx=25, pady=10)
self.registri.grid(row=0, column=6, rowspan=1, sticky=W + E + N + S)
self.unita = LabelFrame(
self.master, text='UC', relief=RIDGE, borderwidth=5, labelanchor='n', padx=10, pady=10)
self.unita.grid(row=2, column=6, rowspan=1, sticky=N)
# Var
self.variabili = Frame(self.master)
self.variabili.grid(row=2, column=5)
self.nstep = LabelFrame(
self.variabili, text='Num. Step', relief=RIDGE, borderwidth=5, labelanchor='n')
self.nstep.grid(row=0, column=5, sticky=W + E)
self.delays = LabelFrame(
self.variabili, text='Delay', relief=RIDGE, borderwidth=5, labelanchor='n')
self.delays.grid(row=1, column=5, sticky=W + E)
self.tempo = LabelFrame(
self.variabili, text='Tempo', relief=RIDGE, borderwidth=5, labelanchor='n')
self.tempo.grid(row=1, column=6, sticky=W + E)
# Unita' di controllo
self.unitas = LabelFrame(
self.unita, text='S', labelanchor='s', padx=10)
self.unitas.grid(row=0, column=0, sticky=N)
self.unitaf = LabelFrame(
self.unita, text='F', labelanchor='s', padx=10)
self.unitaf.grid(row=0, column=1, sticky=N)
self.unitar = LabelFrame(
self.unita, text='R', labelanchor='s', padx=10)
self.unitar.grid(row=0, column=2, sticky=N)
self.unitaint = LabelFrame(
self.unita, text='Int.', labelanchor='s', padx=10)
self.unitaint.grid(row=0, column=3, sticky=N)
# Registri
self.programc = LabelFrame(
self.registri, text='PC', relief=FLAT, labelanchor='e', padx=5)
self.programc.grid(row=0, column=0, sticky=W + E)
self.mar = LabelFrame(
self.registri, text='MAR', relief=FLAT, labelanchor='e', padx=5)
self.mar.grid(row=1, column=0, sticky=W + E)
self.mbr = LabelFrame(
self.registri, text='MBR', relief=FLAT, labelanchor='e', padx=5)
self.mbr.grid(row=2, column=0, sticky=W + E)
self.lopr = LabelFrame(
self.registri, text='OPR', relief=FLAT, labelanchor='e', padx=5)
self.lopr.grid(row=3, column=0, sticky=W + E)
self.vari = LabelFrame(
self.registri, text='I', relief=FLAT, labelanchor='e', padx=5)
self.vari.grid(row=4, column=0, sticky=W + E)
self.vare = LabelFrame(
self.registri, text='E', relief=FLAT, labelanchor='e', padx=5)
self.vare.grid(row=5, column=0, sticky=W + E)
self.lac = LabelFrame(
self.registri, text='AC', relief=FLAT, labelanchor='e', padx=5)
self.lac.grid(row=6, column=0, sticky=W + E)
self.lacint = LabelFrame(
self.registri, text='INT AC', relief=FLAT, labelanchor='e', padx=5)
self.lacint.grid(row=7, column=0, sticky=W + E)
self.lachex = LabelFrame(
self.registri, text='HEX AC', relief=FLAT, labelanchor='e', padx=5)
self.lachex.grid(row=8, column=0, sticky=W + E)
# Microistruzioni
self.micro = LabelFrame(
self.master, text='Microistruzioni eseguite', relief=RIDGE, borderwidth=5, labelanchor='n', pady=5)
self.micro.rowconfigure(0, weight=1)
self.micro.columnconfigure(0, weight=1)
self.micro.grid(
row=3, column=4, rowspan=5, columnspan=5, sticky=W + E + N + S)
# Inout
self.inout = LabelFrame(
self.master, text='Input & Output', relief=RIDGE, borderwidth=5, labelanchor='n', pady=5)
self.inout.rowconfigure(0, weight=1)
self.inout.columnconfigure(0, weight=1)
self.inout.grid(row=3, column=0, columnspan=4, sticky=W + E + N + S)
self.create_widgets()
def create_widgets(self):
"""
Crea il layout del programma, finestra dell'emulatore
"""
# Memoria RAM
self.Visualizza = Text(self.ram, width=80)
self.Visualizzascrollbar = Scrollbar(self.ram)
self.Visualizzascrollbar.config(command=self.Visualizza.yview)
self.Visualizza.config(yscrollcommand=self.Visualizzascrollbar.set)
self.Visualizzascrollbar.grid(row=0, column=1, sticky=N + S)
self.Visualizza.grid(row=0, column=0, sticky=W)
# INOUT
self.Visualizzainout = Text(
self.inout, width=62, height=7, fg='green', bg='black')
self.Visualizzascrollbar_inout = Scrollbar(self.inout)
self.Visualizzascrollbar_inout.config(
command=self.Visualizzainout.yview)
self.Visualizzainout.config(
yscrollcommand=self.Visualizzascrollbar_inout.set)
self.Visualizzascrollbar_inout.grid(row=0, column=1, sticky=N + S)
self.Visualizzainout.grid(row=0, column=0, sticky=W)
# Mircroistruzioni
self.Visualizzamicro = Text(self.micro, width=55, height=7)
self.Visualizzascrollbar_m = Scrollbar(self.micro)
self.Visualizzascrollbar_m.config(command=self.Visualizzamicro.yview)
self.Visualizzamicro.config(
yscrollcommand=self.Visualizzascrollbar_m.set)
self.Visualizzascrollbar_m.grid(row=0, column=1, sticky=N + S)
self.Visualizzamicro.grid(row=0, column=0, sticky=W)
# Pulsanti
self.butload = Button(
self.controlli, text='LOAD', anchor=CENTER, width=15, command=self.loading, bg='SkyBlue')
self.butload.grid(row=0, column=0)
self.butstep = Button(
self.controlli, text='Step', anchor=CENTER, width=15, command=self.step, bg='linen')
self.butstep.grid(row=1, column=0)
self.butminstep = Button(
self.controlli, text='miniStep', anchor=CENTER, width=15, command=self.mini_step, bg='linen')
self.butminstep.grid(row=2, column=0)
self.butstep = Button(self.controlli, text='microStep',
anchor=CENTER, width=15, command=self.micro_step, bg='linen')
self.butstep.grid(row=3, column=0)
self.butsetstep = Button(
self.controlli, text='Set n Step', anchor=CENTER, width=15, command=self.setnstep, bg='linen')
self.butsetstep.grid(row=4, column=0)
self.butsetdelay = Button(
self.controlli, text='Set Delay', anchor=CENTER, width=15, command=self.setdelay, bg='linen')
self.butsetdelay.grid(row=5, column=0)
self.butstart = Button(
self.controlli, text='START', anchor=CENTER, width=15, command=self.start, bg='DarkOliveGreen3')
self.butstart.grid(row=6, column=0)
self.butreset = Button(
self.controlli, text='RESET', anchor=CENTER, width=15, command=self.resetCD, bg='Orange3')
self.butreset.grid(row=7, column=0)
self.butstop = Button(
self.controlli, text='STOP', anchor=CENTER, width=15, command=self.stop, bg='IndianRed')
self.butstop.grid(row=8, column=0)
self.butbreak = Button(
self.controlli, text='BREAK', anchor=CENTER, width=15, command=self.breakpoint, bg='Magenta2')
self.butbreak.grid(row=9, column=0)
self.butcontinue = Button(
self.controlli, text='CONTINUA', anchor=CENTER, width=15, command=self.continua, bg='Magenta2')
self.butcontinue.grid(row=10, column=0)
self.butesegui = Button(
self.controlli, text='ESEGUI', anchor=CENTER, width=15, command=self.esegui, bg='Yellow')
self.butesegui.grid(row=11, column=0)
# Labels
self.labelprogramc = Label(
self.programc, text='00000000000', relief=SUNKEN, bg='red')
self.labelprogramc.grid()
self.labelmar = Label(
self.mar, text='00000000000', relief=SUNKEN, bg='yellow')
self.labelmar.grid()
self.labelmbr = Label(self.mbr, text='000000000000000', relief=SUNKEN)
self.labelmbr.grid()
self.labelvari = Label(self.vari, text='0', relief=SUNKEN)
self.labelvari.grid()
self.labelopr = Label(self.lopr, text='000', relief=SUNKEN)
self.labelopr.grid()
self.labelucs = Label(self.unitas, text='0')
self.labelucs.grid()
self.labelucf = Label(self.unitaf, text='0')
self.labelucf.grid()
self.labelucr = Label(self.unitar, text='0')
self.labelucr.grid()
self.labelucint = Label(self.unitaint, text='0')
self.labelucint.grid()
self.labelnstep = Label(self.nstep, text='1')
self.labelnstep.grid()
self.labeldelay = Label(self.delays, text=str(self.delay))
self.labeldelay.grid()
self.labeltempo = Label(self.tempo, text=str(self.CD.tempo))
self.labeltempo.grid()
self.labelac = Label(self.lac, text='000000000000000', relief=SUNKEN)
self.labelac.grid()
self.labelacint = Label(
self.lacint, text='000000000000000', relief=SUNKEN)
self.labelacint.grid()
self.labelachex = Label(
self.lachex, text='000000000000000', relief=SUNKEN)
self.labelachex.grid()
self.labelvare = Label(self.vare, text='0', relief=SUNKEN)
self.labelvare.grid()
def continua(self):
"""
Continua l'esecuzione dopo un break
"""
self.CD.S = True
self.esegui()
def micro_step(self):
"""
Esegue il metodo step del calcolatore didattico ed aggiorna
"""
if self.CD.S:
self.CD.step(self.root, self.codice)
if self.CD.tempo == 0 and not self.CD.F and not self.CD.R:
self.CD.previstr = self.CD.nextistr
self.aggiornaall()
def step(self):
"""
Esegue il metodo step del calcolatore didattico ed aggiorna
"""
var = True
if self.CD.S and self.CD.nstep > 0:
while var and self.CD.S:
self.CD.step(self.root, self.codice)
if not self.CD.F and not self.CD.R and self.CD.tempo == 0:
self.CD.nstep -= 1
self.aggiornaall()
self.CD.previstr = self.CD.nextistr
var = False
if self.CD.nstep > 0:
self.butstep.after(self.delay, self.step)
else:
self.CD.setnstep(1)
else:
self.CD.setnstep(1)
self.aggiornaall()
def esegui(self):
"""
Esegue il programma fino all'arresto della macchina tramite
l'istruzione HLT
"""
while self.CD.S:
self.CD.step(self.root, self.codice)
if not self.CD.F and not self.CD.R and self.CD.tempo == 0:
self.aggiornaall()
self.CD.previstr = self.CD.nextistr
break
if self.CD.S:
self.butesegui.after(self.delay, self.esegui)
else:
self.CD.setnstep(1)
self.aggiornaall()
def mini_step(self):
"""
Esegue un singolo ciclo della macchina
"""
if self.CD.S:
for x in range(0, 4):
self.CD.step(self.root, self.codice)
self.CD.nstep = 1
self.aggiornaall()
if self.CD.F is False and self.CD.R is False:
self.CD.previstr = self.CD.nextistr
def cerca_istr_prev(self):
"""
Evidenzia di VERDE l'ultima istruzione eseguita
"""
if self.CD.PC == '000000000000':
return
try:
if self.CD.previstr == '' and int(self.CD.PC, 2) == self.CD.START:
return
else:
pospc = str(3.0 + self.CD.previstr)
self.Visualizza.tag_add(
"PISTR", str(pospc[:-1] + '16'), str(pospc[:-1] + 'end'))
self.Visualizza.tag_config("PISTR", background="green")
self.Visualizza.see(pospc)
except TypeError:
pass # Errore che si ottiene durante il reset del CD
# NOTA : METODO NON NECESSARIO NEL PROGRAMMA FINALE
# def cerca_istr_corr(self):
# """
# Evidenzia di verde l'istruzione che si dovrà eseguire
# """
# if self.CD.PC == '000000000000':
# return
# try:
# if int(self.CD.PC,2) == self.CD.START:
# Inizio esecuzione del programma
# Il PC e l'istruzione da eseguire sono allo stesso 'livello'
# pos = str(3.0)
# self.Visualizza.tag_add("ISTR", str(pos[0]+'.16'), str(pos[:-1]+'end'))
# self.Visualizza.tag_config("ISTR", background = "green")
# else:
# pospc = str(3.0 + self.CD.nextistr)
# self.Visualizza.tag_add("ISTR", str(pospc[:-1]+'16'), str(pospc[:-1]+'end'))
# self.Visualizza.tag_config("ISTR", background = "green")
# self.Visualizza.see(pospc)
# except TypeError:
# pass ## Errore che si ottiene durante il reset del CD
def cerca_MAR(self):
"""
Evidenzia di giallo l'indirizzo puntato dal MAR
"""
try:
pos = 3.0
stringa = self.Visualizza.get(str(pos), 'end')
while stringa[:12] != self.CD.MAR and int(pos) < len(self.CD.RAM) + 3 and len(self.CD.RAM) > 0:
pos += 1
stringa = self.Visualizza.get(str(pos), 'end')
if int(pos) >= len(self.CD.RAM) + 3:
return
self.Visualizza.tag_add("MAR", pos, str(float(pos) + 0.12))
self.Visualizza.tag_config("MAR", background="yellow")
except TypeError:
pass # Errore che si ottiene durante il reset del CD
def cerca_PC(self):
"""
Evidenzia di rosso l'indirizzo puntato da PC
"""
try:
pos = 3.0
stringa = self.Visualizza.get(str(pos), 'end')
while stringa[:12] != self.CD.PC and int(pos) < len(self.CD.RAM) + 3 and len(self.CD.RAM) > 0:
pos += 1
stringa = self.Visualizza.get(str(pos), 'end')
if int(pos) >= len(self.CD.RAM) + 3:
return
self.Visualizza.tag_add("PC", pos, str(float(pos) + 0.12))
self.Visualizza.tag_config("PC", background="red")
except TypeError:
pass # Errore che si ottiene durante il reset del CD
def aggiornaout(self):
"""
Aggiorna micro e input/output
"""
self.aggiornamicro()
self.aggiornainout()
def aggiornamicro(self):
"""
Aggiorna le microistruzioni eseguite
"""
self.Visualizzamicro.delete(1.0, END)
stringa = self.CD.microistruzioni
self.Visualizzamicro.insert(INSERT, stringa)
self.Visualizzamicro.see(END)
def aggiornainout(self):
"""
Aggiorna gli input ed output di sistema
"""
self.Visualizzainout.delete(1.0, END)
stringa = self.CD.inout
self.Visualizzainout.insert(INSERT, stringa)
self.Visualizzainout.see(END)
def aggiornaram(self):
"""
Aggiorna lo stato della RAM
"""
self.Visualizza.delete(1.0, END)
stringa = self.CD.statusRAM()
self.Visualizza.insert(INSERT, stringa)
self.cerca_MAR()
self.cerca_PC()
self.cerca_istr_prev()
# self.cerca_istr_corr() #Non più necessaria nella versione finale
def aggiornareg(self):
"""
Aggiorna lo stato dei Registri
"""
self.labelprogramc.config(text=self.CD.PC)
self.labelmar.config(text=self.CD.MAR)
self.labelmbr.config(text=self.CD.MBR)
self.labelac.config(text=self.CD.AC)
self.labelacint.config(text=str(self.CD.range(int(self.CD.AC, 2))))
self.labelachex.config(
text=str((hex(int(self.CD.AC, 2))[2:].upper())).zfill(4))
self.labelvare.config(text=self.CD.E)
self.labelvari.config(text=self.CD.I)
self.labelopr.config(text=self.CD.OPR)
def aggiornauc(self):
"""
Aggiorna lo stato dell'unita' di controllo
"""
if self.CD.S and not self.CD.breaks:
self.labelucs.config(text=self.CD.S, bg='green')
self.unitas.config(bg='green')
elif not self.CD.S and self.CD.breaks:
self.labelucs.config(text=self.CD.S, bg='Magenta2')
self.unitas.config(bg='Magenta2')
else:
self.labelucs.config(text=self.CD.S, bg='red')
self.unitas.config(bg='red')
self.labelucf.config(text=self.CD.F)
self.labelucr.config(text=self.CD.R)
self.labelucint.config(text=self.CD.Interrupt)
self.labeltempo.config(text=self.CD.tempo)
def aggiornaall(self):
"""
Aggiorna tutto
"""
self.aggiornaram()
self.aggiornareg()
self.aggiornauc()
self.aggiornamicro()
self.aggiornaout()
self.labelnstep.config(text=self.CD.nstep)
def loading(self):
"""
Carica il contenuto del codice assembly decodificandolo in binario
nella RAM
"""
contenuto = self.codice.Inserisci.get(1.0, END)
if len(contenuto) > 1:
self.resetCD()
if self.CD.carica(contenuto.decode('ascii', 'ignore'), self) is not None:
self.CD.S = 0
self.aggiornaall()
def resetCD(self):
"""
Resetta il calcolatore didattico
"""
self.CD = pdp8()
self.aggiornaall()
def start(self):
"""
Mette la variabile Start (S) ad 1, cioe' True
"""
self.CD.S = True
if self.CD.breaks == True:
self.CD.breaks = False
self.aggiornauc()
def stop(self):
"""
Mette la variabile Start (S) ad 0, cioe' False
"""
self.CD.S = False
self.aggiornauc()
def setnstep(self):
"""
Setta, in base al valore passato, il numero di cicli da eseguire
"""
temp = askinteger("Num Step", "Numero di step da eseguire",
initialvalue=1, minvalue=1, parent=self.root)
if temp is None:
self.CD.setnstep(1)
else:
self.CD.setnstep(temp)
self.labelnstep.config(text=self.CD.nstep)
def setdelay(self):
"""
Setta, in base al valore passato, il ritardo di esecuzione.
Il valore è espresso in millisecondi, di default = 1000
"""
temp = askinteger("Set Delay", "Ritardo in millisecondi",
initialvalue=100, minvalue=1, parent=self.root)
if temp is not None:
self.delay = temp
self.labeldelay.config(text=self.delay)
def breakpoint(self):
"""
Setta o elimina i breakpoint dal programma caricato in memoria
"""
temp = askstring(
"Cella di memoria", "Indirizzo esadecimale", parent=self.root)
if temp is not None:
temp = self.CD.binario(int(temp, 16)).zfill(12)
self.CD.breakpoint(temp)
self.aggiornaram()
def exit(self):
"""
Esce dal programma
"""
if askquestion('Exit', 'Sicuro di voler uscire?', parent=self.master) == YES:
self.codice.master.quit()
self.codice.master.destroy()
else:
showinfo('Suggerimento', """Forse e' meglio fare una pausa!""",
icon=WARNING, parent=self.master)
def quadscanmeas(frame, w, h, status, start, stop):
def _start():
figs = initfigs([lf_OUT])
mode = modemenu.get()
if mode == 'From File':
data = loadtxt(filestr.get())
ki = None
kf = None
points = None
if mode == 'Measurement':
data = None
ki = float(entry_ki.get())
kf = float(entry_kf.get())
points = int(entry_points.get())
lattice = latticemenu.get()
if lattice == 'drift':
qL = float(entry_qL.get())
driftlength = float(entry_dlen.get())
UC = zeros([6, 1])
UC[1] = driftlength
else:
quad = int(quadmenuval.get())
screen = screenmenuval.get()
_, _, _, UC, diagnostics, _, _, _, _, _, _, _ = latt2py(lattice, False)
elements = UC[0, :]
# index after selected quad (quad itself not required)
i = sort(concatenate((where(elements==3), where(elements==4)), 1))[0][quad-1]+1
# index before selected fom (next would be fom itself)
fom = where(array(diagnostics) == screen)[0][0]
f = where(elements==7)[0][fom]
if i > f:
showerror(title='ERROR', message='Please choose a quad before chosen screen')
return
qL = UC[1, i-1]
UC = UC[:, i:f]
kxi = float(entry_kxi.get())
kxf = float(entry_kxf.get())
kyi = float(entry_kyi.get())
kyf = float(entry_kyf.get())
kr_fit = [kxi, kxf, kyi, kyf]
kr_mes = [ki, kf]
epss = (float(entry_epss.get())/1e3)**2
Dx = float(entry_Dx.get())
Dpx = float(entry_Dpx.get())
energy = float(entry_energy.get())*1e6
particle = 'electron'
runthread(status, measure_quadscan,
(figs, data, kr_fit, kr_mes, points, qL, UC, epss, Dx, Dpx,
energy, particle))
def _load():
filename = askopenfilename(initialdir='accpy/exampledata/')
filestr.set(filename)
def _mode(*args):
mode = modemenu.get()
if mode == 'From File':
cs_button(lf_data, 1, 0, 'Load', _load)
if mode == 'Measurement':
showerror('Sorry', 'this feature is not ready')
modemenu.set('From File')
cs_button(lf_data, 1, 0, 'Load', _load)
def _check(*args):
lattice = latticemenu.get()
def clearfigs1(tabs):
close('all')
for tab in tabs:
# destroy all widgets in fram/tab and close all figures
for widget in tab.winfo_children():
widget.destroy()
def showfigs1(figs, tabs):
clearfigs1(tabs)
for fig, tab in zip(figs, tabs):
canvas = FigureCanvasTkAgg(fig, master=tab)
canvas.get_tk_widget().pack()
canvas.draw()
if lattice == 'drift':
quadN.grid_remove()
quadmenu.grid_remove()
screenN.grid_remove()
screenmenu.grid_remove()
quadlab.grid()
quadent.grid()
driftlab.grid()
driftent.grid()
else:
_, _, _, UC, diagnostics, _, _, _, _, _, _, _ = latt2py(lattice, False)
elements = list(UC[0,:])
quads = range(1, (elements.count(3)+elements.count(4)+1))
quadlab.grid_remove()
quadent.grid_remove()
driftlab.grid_remove()
driftent.grid_remove()
screenmenu['menu'].delete(0, 'end')
quadmenu['menu'].delete(0, 'end')
[screenmenu['menu'].add_command(label=fom, command=_setit(screenmenuval, fom)) for fom in diagnostics]
[quadmenu['menu'].add_command(label=quad, command=_setit(quadmenuval, quad)) for quad in quads]
screenN.grid()
quadN.grid()
screenmenu.grid()
quadmenu.grid()
start.configure(command=_start)
frame.pack(fill=BOTH, expand=1)
lf_upbeam = LabelFrame(frame, text="Upstream longitudinal beam parameters", padx=5, pady=5)
lf_upbeam.grid(row=0, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_transfer = LabelFrame(frame, text="Transport matrix", padx=5, pady=5)
lf_transfer.grid(row=1, column=0, sticky=W+E+N+S, padx=10, pady=10)
lf_fit = LabelFrame(frame, text="Fit range", padx=5, pady=5)
lf_fit.grid(row=0, column=1, sticky=W+E+N+S, padx=10, pady=10)
lf_data = LabelFrame(frame, text="Data acquisition", padx=5, pady=5)
lf_data.grid(row=1, column=1, sticky=W+E+N+S, padx=10, pady=10)
lf_OUT = LabelFrame(frame, text="Results", padx=5, pady=5)
lf_OUT.grid(row=2, column=0, columnspan=2, sticky=W+E+N+S, padx=10, pady=10)
cs_label(lf_upbeam, 0, 0, 'Beam energy / MeV')
cs_label(lf_upbeam, 1, 0, uc.delta+' / '+uc.ppt)
cs_label(lf_upbeam, 2, 0, 'D / m')
cs_label(lf_upbeam, 3, 0, 'D\' / rad')
entry_energy = cs_Dblentry(lf_upbeam, 0, 1, 52)
entry_epss = cs_Dblentry(lf_upbeam, 1, 1, 2.4)
entry_Dx = cs_Dblentry(lf_upbeam, 2, 1, 0.)
entry_Dpx = cs_Dblentry(lf_upbeam, 3, 1, 0.)
cs_label(lf_transfer, 0, 0, 'Optic', sticky=W)
_, openlatts = lattlist()
latticemenu = cs_dropd(lf_transfer, 1, 0, ['drift'] + openlatts, action=_check)
quadlab = cs_label(lf_transfer, 0, 1, 'Quadrupole length / m', retlab=True)[1]
quadent = entry_qL = cs_Dblentry(lf_transfer, 0, 2, .119)
driftlab = cs_label(lf_transfer, 1, 1, 'Driftlength / m', retlab=True)[1]
driftent = entry_dlen = cs_Dblentry(lf_transfer, 1, 2, 1.8)
quadN = cs_label(lf_transfer, 0, 1, 'Which quadrupole', retlab=True)[1]
quadmenuval, quadmenu = cs_dropd(lf_transfer, 1, 1, [''], retbut=True)
screenN = cs_label(lf_transfer, 2, 1, 'Which screen', retlab=True)[1]
screenmenuval, screenmenu = cs_dropd(lf_transfer, 3, 1, openlatts, retbut=True)
quadN.grid_remove()
quadmenu.grid_remove()
screenN.grid_remove()
screenmenu.grid_remove()
quadlab.grid_remove()
quadent.grid_remove()
driftlab.grid_remove()
driftent.grid_remove()
modemenu = cs_dropd(lf_data, 0, 0, ['Measurement',
'From File'], action=_mode)
filestr = cs_label(lf_data, 1,1, '')
cs_label(lf_fit, 0, 0, 'k_x / (1/m'+uc.squared+')')
cs_label(lf_fit, 1, 0, 'k_y / (1/m'+uc.squared+')')
cs_label(lf_fit, 2, 0, 'Points')
entry_kxi = cs_Dblentry(lf_fit, 0, 1, -8)
entry_kxf = cs_Dblentry(lf_fit, 0, 2, 8)
entry_kyi = cs_Dblentry(lf_fit, 1, 1, -8)
entry_kyf = cs_Dblentry(lf_fit, 1, 2, 8)
entry_points = cs_Intentry(lf_fit, 2, 1, 1000)
return
class Editor(object):
"""
Finestra per l'editor di condice assembly
"""
def __init__(self, master, calcolatore):
"""
Inizializza i frame della finestra dell'Editor
"""
self.master = master
self.CD = calcolatore
# Codice Assembly
self.codice = LabelFrame(self.master,
text='Codice Assembly',
relief=RIDGE,
borderwidth=5,
labelanchor='n',
pady=5)
self.codice.rowconfigure(0, weight=1)
self.codice.columnconfigure(0, weight=1)
self.codice.grid(row=1,
column=0,
rowspan=3,
columnspan=5,
sticky=W + E + N + S)
self.menubar = Menu(self.master)
self.create_widgets(self.menubar)
def create_widgets(self, menubar):
"""
Crea il layout del programma, finestra dell'Editor
"""
# Menu
self.filemenu = Menu(menubar, tearoff=0)
self.filemenu.add_command(label='Apri', command=self.aprifile)
self.filemenu.add_command(label='Salva', command=self.salvafile)
self.filemenu.add_command(label='Cancella', command=self.cancella)
self.filemenu.add_separator()
self.filemenu.add_command(label='Esci', command=self.exit)
menubar.add_cascade(label='Opzioni', menu=self.filemenu)
self.master.config(menu=self.menubar)
self.helpmenu = Menu(menubar, tearoff=0)
self.helpmenu.add_command(label='Informazioni', command=self.infor)
self.helpmenu.add_command(label='Legenda', command=self.leg)
self.helpmenu.add_command(label='Guida', command=self.guida)
menubar.add_cascade(label='Aiuto', menu=self.helpmenu)
# Codice Assembly
self.Inserisci = Text(self.codice, width=50, height=30, wrap=WORD)
self.Inserisciscrollbar = Scrollbar(self.codice)
self.Inserisciscrollbar.config(command=self.Inserisci.yview)
self.Inserisci.config(yscrollcommand=self.Inserisciscrollbar.set)
self.Inserisciscrollbar.grid(row=0, column=1, sticky=N + S)
self.Inserisci.grid(row=0, column=0, sticky=W)
def exit(self):
"""
Esce dal programma
"""
if askquestion('Exit', 'Sicuro di voler uscire?') == YES:
self.master.quit()
self.master.destroy()
else:
showinfo('Suggerimento',
"""Forse e' meglio fare una pausa!""",
icon=WARNING)
def aprifile(self):
"""
Apre un file assembly e lo mostra a video per essere modificato
"""
path = askopenfilename(title='Apri codice assembly',
filetypes=[('Assembly', '.asm'),
('Testo', '.txt'), ('All', '*')])
if path != '':
file = open(path, 'r')
temp = file.read()
self.Inserisci.delete(1.0, END)
self.Inserisci.insert(INSERT, temp.decode('ascii', 'ignore'))
file.close()
def cancella(self):
"""
Cancella l'attuale file assembly caricato
"""
if askquestion('Cancella',
'Si vuole cancellare tutto il codice assembly?') == YES:
self.Inserisci.delete(1.0, END)
def salvafile(self):
"""
Salva il file assembly su cui si sta lavorando
"""
contenuto = self.Inserisci.get(1.0, END)
contenuto = contenuto.encode('ascii', 'ignore')
path = asksaveasfilename(title='Salva codice assembly',
defaultextension=[('Assembly', '.asm'),
('Testo', '.txt'),
('All', '*')],
filetypes=[('Assembly', '.asm'),
('Testo', '.txt'), ('All', '*')])
print path
if path != '':
file = open(path, 'w')
file.write(str(contenuto))
file.close()
@staticmethod
def infor():
"""
Visualizza le informazioni riguardante il programma
"""
nome = """pdp8 emulator"""
stringa = """
Pdp8 Emulator
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
Version = 1.6.2
Tested with = python 2.6 & 2.7
-------------------------------------------------------------------
The MIT License (MIT)
Copyright (c) 2015 Mirco
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall
be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------
Contact: [email protected]
Collaborators : Walter Valentini
"""
showinfo(nome, stringa)
@staticmethod
def leg():
"""
Visualizza le informazioni riguardanti colori
"""
nome = """pdp8 Legenda"""
stringa = """
Rosso = indirizzo puntato da PC
Giallo = indirizzo puntato da MAR
Verde = ultima istruzione eseguita
"""
showinfo(nome, stringa)
@staticmethod
def guida():
"""
Piccola guida
"""
nome = """pdp8 Guida"""
stringa = """
LOAD = Carica il assembly nella memoria del Calcolatore
Didattico (CD).
STEP = Avanza del numero di step indicato (di default 1).
Uno step equivale all'esecuzione di una singola istruzione.
mini STEP = Esegue un singolo ciclo in base alle variabili
F ed R dell'unità di controllo.
micro STEP = Esegue ogni singola microistruzione.
Set n STEP = Setta il numero di step.
Set Delay = Setta il tempo di aggiornamento del CD.
START = Avvia il CD, ma non l'esecuzione del codice. Per
eseguire il codice, utilizzare step o esegui una
volta avviata la macchina.
RESET = Resetta il CD allo stato iniziale.
STOP = Ferma il CD e quindi anche l'esecuzione del codice.
BREAK = Aggiunge o toglie un break alla cella indicata
in esadecimale.
CONTINUA = Continua l'esecuzione del programma dopo un break.
Equivale a premere in sequenza START ed ESEGUI.
ESEGUI = Esegue il codice fino all'istruzione HLT, che
arresta la macchina.
"""
showinfo(nome, stringa)
