def _makeform(self):
entries = {}
a_row = Tk.Frame(self.cond_window)
Tk.Label(a_row, width=22, text='a11 :', anchor='w').pack(side=Tk.LEFT)
a11_ent = Tk.Entry(a_row)
a11_ent.insert(0, "1")
a11_ent.pack(side=Tk.LEFT, expand=Tk.YES, fill=Tk.X)
Tk.Label(a_row, width=22, text='a22 :', anchor='w').pack(side=Tk.LEFT)
a22_ent = Tk.Entry(a_row)
a22_ent.insert(0, "0.000001")
a22_ent.pack(side=Tk.LEFT, expand=Tk.YES, fill=Tk.X)
a_row.pack(side=Tk.TOP, fill=Tk.X, padx=5, pady=5)
entries['a11'] = a11_ent
entries['a22'] = a22_ent
fd_row = Tk.Frame(self.cond_window)
Tk.Label(fd_row, width=22, text='f :', anchor='w').pack(side=Tk.LEFT)
f_ent = Tk.Entry(fd_row)
f_ent.insert(0, "7")
f_ent.pack(side=Tk.LEFT, expand=Tk.YES, fill=Tk.X)
Tk.Label(fd_row, width=22, text='d :', anchor='w').pack(side=Tk.LEFT)
d_ent = Tk.Entry(fd_row)
d_ent.insert(0, "0")
d_ent.pack(side=Tk.LEFT, expand=Tk.YES, fill=Tk.X)
fd_row.pack(side=Tk.TOP, fill=Tk.X, padx=5, pady=5)
entries['f'] = f_ent
entries['d'] = d_ent
row = Tk.Frame(self.cond_window)
fields = ['Beta', 'Sigma', 'Uc']
Tk.Label(row, width=22, text='Boundaries',
anchor='w').pack(side=Tk.LEFT)
Tk.Label(row, width=22, text=fields[0], anchor='w').pack(side=Tk.LEFT)
Tk.Label(row, width=22, text=fields[1], anchor='w').pack(side=Tk.LEFT)
Tk.Label(row, width=22, text=fields[2], anchor='w').pack(side=Tk.LEFT)
row.pack(side=Tk.TOP, fill=Tk.X, padx=5, pady=5)
for boundary in self.delaunay_triangulation.triangulated_info['NTG']:
row = Tk.Frame(self.cond_window)
lab = Tk.Label(row,
width=22,
text=str(boundary) + ": ",
anchor='w')
lab.pack(side=Tk.LEFT)
params = {}
for key in fields:
ent = Tk.Entry(row)
ent.insert(0, "0.000001")
ent.pack(side=Tk.LEFT, expand=Tk.YES, fill=Tk.X)
params[key] = ent
row.pack(side=Tk.TOP, fill=Tk.X, padx=5, pady=5)
entries[boundary] = params
return entries
def __init__(self, parent, placeholder='', **kwargs):
tk.Frame.__init__(self, parent)
self.parent = parent
frame_ops = funcs.extract_args(kwargs, FRAME_KEYS, FRAME_KEY)
frame = tk.Frame(self, frame_ops)
frame.pack(fill='both', expand=True)
label_ops = funcs.extract_args(kwargs, LABEL_KEYS, LABEL_KEY)
label = tk.Label(frame, label_ops)
tvar = tk.StringVar()
entry_ops = funcs.extract_args(kwargs, ENTRY_KEYS, ENTRY_KEY)
entry_ops['textvariable'] = tvar
self.entry = tk.Entry(frame, entry_ops)
label.pack(side='top', fill='x', expand=True)
self.entry.pack(side='bottom', fill='x', expand=True)
# self.entry.focus_force()
self.parent.columnconfigure(0, weight=1)
self.insert = self.entry.insert
self.delete = self.entry.delete
self.get = self.entry.get
self.set = tvar.set
self.index = self.entry.index
self.bind = self.entry.bind
# self.state = lambda: change_state(self.entry)
self.enable = lambda: funcs.set_state_normal(self.entry)
self.normal = lambda: funcs.set_state_normal(self.entry)
self.disable = lambda: funcs.set_state_disabled(self.entry)
self.clear = lambda: funcs.clear(self.entry)
def body(self, master):
tk.Label(master, text='Connection name:').grid(row=0)
tk.Label(master, text='Catalog type:').grid(row=1)
tk.Label(master, text='Root path:').grid(row=2)
self.name = ttk.Entry(master)
self.name.grid(row=0, column=1, sticky='ew')
self.name.insert(0, self.connection_name)
self.catalog_cbox = ttk.Combobox(master, values=config.catalog_types)
self.catalog_cbox.grid(row=1, column=1, sticky='ew')
self.catalog_cbox.set(self.catalog_type)
self.root_path_entry = tk.Entry(master)
self.root_path_entry.grid(row=2, column=1, sticky='ew')
self.root_path_entry.insert(0, self.root_path)
self.isdefault_var = tk.IntVar()
self.isdefault_var.set(self.isdefault)
self.set_default = tk.Checkbutton(master,
text='make default connection',
variable=self.isdefault_var)
self.set_default.grid(row=3, column=1)
self.catalog_config_frame = tk.Frame(master)
self.catalog_config_frame.grid(row=4, sticky='nsew')
self.catalog_type_changed(catalog_config=self.catalog_config)
self.catalog_cbox.bind('<<ComboboxSelected>>',
self.catalog_type_changed)
self.result = None
def __init__(self, parent, oldVal, pname):
tk.Toplevel.__init__(self, parent)
self.transient(parent)
self.parent = parent
self.newVal = None
self.inputFrame = tk.Frame(self)
self.parLabel = tk.Label(self.inputFrame, text="Value for parameter: " + str(pname))
self.parLabel.pack()
self.inputVal = tk.StringVar()
self.inputVal.set("% g" % oldVal)
self.input = tk.Entry(self.inputFrame, textvariable=self.inputVal)
self.input.pack()
self.inputFrame.pack(fill=tk.X)
self.buttonFrame = tk.Frame(self)
self.okButton = tk.Button(self, text="OK", command=self._okClicked)
self.caButton = tk.Button(self, text="Cancel", command=self._cancelClicked)
self.okButton.pack(side=tk.RIGHT)
self.caButton.pack(side=tk.LEFT)
# Treat return as OK
self.bind("<Return>", self._okClicked)
# Treat close as cancel
self.protocol("WM_DELETE_WINDOW", self._cancelClicked)
# For a modal dialog
self.grab_set()
# Keyboard focus to input entry
self.input.focus_set()
self.wait_window(self)
def __init__(self, parent, odf):
tk.Toplevel.__init__(self, parent)
self.wm_title("Value set code")
self.parent = parent
self.newVal = None
self.odf = odf
self.showFrame = tk.Frame(self)
self.textLabel = tk.Label(self.showFrame, text="Model name: ")
self.textLabel.grid(row=0,column=0)
self.modelName = tk.StringVar()
self.modelName.set("model")
self.modelEntry = tk.Entry(self.showFrame, textvariable=self.modelName, width=8)
self.modelEntry.bind('<Return>', self._updateModelName)
self.modelEntry.grid(row=0,column=1)
self.showText = tk.Text(self.showFrame)
self.showText.config(background='white')
self.showText.grid(row=1,column=0,columnspan=2) #.pack(expand=True)
self.clipboardButton = tk.Button(self.showFrame, text="Copy to Clipboard", command=self._copyToClipboard)
self.clipboardButton.grid(row=2, column=0, columnspan=2)
self.helpLabel = tk.Label(self.showFrame, text="You may use the above code for pasting...")
self.helpLabel.grid(row=3, column=0, columnspan=2)
self.showFrame.pack()
self.protocol("WM_DELETE_WINDOW", self._windowClosed)
def __init__(self, parent, **kwargs):
tk.Frame.__init__(self, parent)
self.parent = parent
frame_ops = funcs.extract_args(kwargs, FRAME_KEYS, FRAME_KEY)
entry_ops = funcs.extract_args(kwargs, ENTRY_KEYS, ENTRY_KEY)
button_ops = funcs.extract_args(kwargs, BUTTON_KEYS, BUTTON_KEY)
frame = tk.Frame(self, **frame_ops)
frame.pack(expand=1, fill=tk.BOTH)
tvar = tk.StringVar()
if 'text' in kwargs:
tvar.set(kwargs['text'])
entry = tk.Entry(frame, textvariable=tvar, **entry_ops)
button = tk.Button(frame, command=frame.destroy, **button_ops)
entry.pack(expand=1, side='left', fill=tk.X)
button.pack(expand=1, side='right', fill=tk.X)
self.parent.columnconfigure(0, weight=1)
self.insert = entry.insert
self.delete = entry.delete
self.get = entry.get
self.set = tvar.set
self.index = entry.index
self.bind = entry.bind
# self.state = lambda: change_state(self.entry)
self.enable = lambda: funcs.set_state_normal(entry)
self.normal = lambda: funcs.set_state_normal(entry)
self.disable = lambda: funcs.set_state_disabled(entry)
self.clear = lambda: funcs.clear(entry)
def draw_table(self):
row_idx = 0
for key, val in sorted(self.device.get_all_settings().items()):
tkinter.Label(self, text=key).grid(row=row_idx, column=0)
entry = tkinter.Entry(self)
entry.grid(row=row_idx, column=1)
entry.insert(0, str(val))
row_idx += 1
def __init__(self, parent=None):
tk.Frame.__init__(self, parent)
self.parent = parent
self.init_ui()
self.commmnity_lbl = tk.Label(self.parent, text="Comunidad")
self.commmnity_lbl.pack()
self.commmnity_lbl.place(relx=.1, rely=.1, anchor="c")
self.com_text = tk.Entry(self.parent)
self.com_text.insert(0, "gr_4cm1")
self.com_text.pack()
self.com_text.place(relx=.3, rely=0.1, anchor="c")
self.ip_lbl = tk.Label(self.parent, text="IP:")
self.ip_lbl.pack()
self.ip_lbl.place(relx=.1, rely=0.15, anchor="c")
self.ip_text = tk.Entry(self.parent)
self.ip_text.insert(0, "localhost")
self.ip_text.pack()
self.ip_text.place(relx=.3, rely=.15, anchor="c")
self.thresh_lbl = tk.Label(self.parent, text="Umbral: (bp,go,set)")
self.thresh_lbl.pack()
self.thresh_lbl.place(relx=.1, rely=0.2, anchor="c")
self.thresh_text = tk.Entry(self.parent)
self.thresh_text.insert(0, "25, 80, 20")
self.thresh_text.pack()
self.thresh_text.place(relx=.3, rely=.2, anchor="c")
self.options_oid = ttk.Combobox(self.parent)
self.options_oid.place(relx=0.3, rely=0.3, anchor="c")
self.options_oid["values"] = ["RAM", "CPUload", "DISCO"]
self.oids = {
"CPUload": "iso.3.6.1.2.1.25.3.3.1.2.196608",
"RAM": "1.3.6.1.4.1.2021.4.6.0",
"DISCO": "1.3.6.1.2.1.1.3.0"
}
self.btn_start = tk.Button(self.parent, text="Start", command=self.run)
self.btn_start.pack()
self.btn_start.place(relx=0.1, rely=.35, anchor="c")
def get_widget(self, master):
frame = FieldContainer(master)
entry = tk.Entry(frame, textvariable=self.var)
entry.grid(row=0, column=0, sticky='ew')
but = tk.Button(frame, text='browse', command=self.command)
but.grid(row=0, column=1)
frame.columnconfigure(0, weight=1)
return frame
def get_widget(self, master):
show = ''
if self.password_mode:
show = '*'
entry = tk.Entry(master, textvariable=self.var, show=show)
if self.validate_command is not None:
vcmd = (master.register(self.validate_command), '%P')
entry.config(validate='key', validatecommand=vcmd)
return entry
def __init__(self, parent, title, app, **kw):
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
self.app = app
#
self.update_stats_var = tkinter.BooleanVar()
self.update_stats_var.set(app.opt.update_player_stats != 0)
self.confirm_var = tkinter.BooleanVar()
self.confirm_var.set(app.opt.confirm != 0)
self.win_animation_var = tkinter.BooleanVar()
self.win_animation_var.set(app.opt.win_animation != 0)
#
frame = tkinter.Frame(top_frame)
frame.pack(expand=True, fill='both', padx=5, pady=10)
widget = tkinter.Label(
frame,
text=_("\nPlease enter your name"),
# justify='left', anchor='w',
takefocus=0)
widget.grid(row=0, column=0, columnspan=2, sticky='ew', padx=0, pady=5)
w = kw.get("e_width", 30) # width in characters
self.player_var = tkinter.Entry(frame, exportselection=1, width=w)
self.player_var.insert(0, app.opt.player)
self.player_var.grid(row=1, column=0, sticky='ew', padx=0, pady=5)
widget = tkinter.Button(frame,
text=_('Choose...'),
command=self.selectUserName)
widget.grid(row=1, column=1, padx=5, pady=5)
widget = tkinter.Checkbutton(frame,
variable=self.confirm_var,
anchor='w',
text=_("Confirm quit"))
widget.grid(row=2, column=0, columnspan=2, sticky='ew', padx=0, pady=5)
widget = tkinter.Checkbutton(frame,
variable=self.update_stats_var,
anchor='w',
text=_("Update statistics and logs"))
widget.grid(row=3, column=0, columnspan=2, sticky='ew', padx=0, pady=5)
# widget = tkinter.Checkbutton(frame, variable=self.win_animation_var,
# text="Win animation")
# widget.pack(side='top', padx=kw.padx, pady=kw.pady)
frame.columnconfigure(0, weight=1)
#
self.player = self.player_var.get()
self.confirm = self.confirm_var.get()
self.update_stats = self.update_stats_var.get()
self.win_animation = self.win_animation_var.get()
#
focus = self.createButtons(bottom_frame, kw)
self.mainloop(focus, kw.timeout)
def __init__(self, parent, title, label, value, **kw):
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
#
self.value = value
if label:
label = tkinter.Label(top_frame, text=label, takefocus=0)
label.pack(pady=5)
w = kw.get("e_width", 0) # width in characters
self.var = tkinter.Entry(top_frame, exportselection=1, width=w)
self.var.insert(0, value)
self.var.pack(side='top', padx=kw.padx, pady=kw.pady)
#
focus = self.createButtons(bottom_frame, kw)
focus = self.var
self.mainloop(focus, kw.timeout)
def body(self, master):
a = 'e'
tk.Label(master, text='Connection name:', anchor=a).grid(row=0,
sticky='ew')
tk.Label(master, text='Catalog type:', anchor=a).grid(row=1,
sticky='ew')
tk.Label(master, text='Root path:', anchor=a).grid(row=2, sticky='ew')
tk.Label(master, text='Default connection:',
anchor=a).grid(row=3, sticky='ew')
self.name = ttk.Entry(master)
self.name.grid(row=0, column=1, sticky='ew')
self.name.insert(0, self.connection_name)
self.name.focus_set()
self.catalog_cbox = ttk.Combobox(master,
state='readonly',
values=config.catalog_types + [])
self.catalog_cbox.grid(row=1, column=1, sticky='ew')
self.catalog_cbox.set(self.catalog_type)
self.root_path_entry = tk.Entry(master)
self.root_path_entry.grid(row=2, column=1, sticky='ew')
self.root_path_entry.insert(0, self.root_path)
self.isdefault_var = tk.IntVar()
self.isdefault_var.set(self.isdefault)
self.set_default = tk.Checkbutton(master,
variable=self.isdefault_var,
anchor='w')
self.set_default.grid(row=3, column=1, sticky='ew')
self.catalog_config_frame = tk.Frame(master)
self.catalog_config_frame.grid(row=4, column=1, sticky='nsew')
self.catalog_type_changed(catalog_config=self.catalog_config)
self.catalog_cbox.bind('<<ComboboxSelected>>',
self.catalog_type_changed)
self.result = None
return self.name
def __init__(self, parent, image=None, **kwargs):
tk.Frame.__init__(self, parent)
self.parent = parent
self.input_list = []
if not image:
image = os.path.join('static', 'fileicon.png')
self.photo = tk.PhotoImage(file=image)
self.photo = self.photo.subsample(8)
frame_ops = funcs.extract_args(kwargs, FRAME_KEYS, FRAME_KEY)
frame = tk.Frame(self, frame_ops)
frame.pack(fill='both', expand=True)
label_ops = funcs.extract_args(kwargs, LABEL_KEYS, LABEL_KEY)
label = tk.Label(frame, label_ops)
tvar = tk.StringVar()
entry_ops = funcs.extract_args(kwargs, ENTRY_KEYS, ENTRY_KEY)
entry_ops['textvariable'] = tvar
entry = tk.Entry(frame, entry_ops)
self.input_list.append(entry)
button_ops = funcs.extract_args(kwargs, BUTTON_KEYS, BUTTON_KEY)
button_ops['command'] = self._open
button_ops['image'] = self.photo
file_button = tk.Button(frame, button_ops)
self.input_list.append(file_button)
label.pack(side='top', fill='x', expand=True)
entry.pack(side='left', fill='x', expand=True)
file_button.pack(side='right', expand=False)
entry.focus_force()
self.parent.columnconfigure(0, weight=1)
self.insert = entry.insert
self.delete = entry.delete
self.get = entry.get
self.set = tvar.set
self.index = entry.index
self.bind = entry.bind
self.enable = self._enable
self.normal = self._enable
self.disable = self._disable
self.clear = lambda: funcs.clear(entry)
def add_row(self, filename=''):
"""Summary
Args:
filename (None, optional): Description
Returns:
TYPE: Description
"""
if not filename:
filename = tkFile.askopenfilename()
self.parent.lift()
if filename:
button_ops = {}
entry_ops = {}
frame_ops = {}
if self.ops:
button_ops = self.ops['button']
entry_ops = self.ops['entry']
frame_ops = self.ops['frame']
new_frame = tk.Frame(self, **frame_ops)
new_frame.pack(expand=1, fill=tk.BOTH)
new_tvar = tk.StringVar()
new_tvar.set(filename)
new_entry = tk.Entry(new_frame, textvariable=new_tvar, **entry_ops)
new_button = tk.Button(new_frame,
command=new_frame.destroy,
text='Remove',
**button_ops)
new_entry.pack(expand=1, side='left', fill=tk.BOTH)
new_button.pack(expand=1, side='right', fill=tk.X)
new_frame.grid(row=self.row_num, column=0, sticky='NEWS')
new_frame.get = new_entry.get
new_frame.columnconfigure(0, weight=2)
new_frame.columnconfigure(1, weight=1)
self.wid_list.append(new_frame)
self.row_num += 1
def __call__(self, _, captcha_image_url):
root = tk.Tk()
root.title("Captcha")
frame = tk.Frame(root)
frame.pack()
captcha_image = self._get_captcha_image(captcha_image_url)
captcha_label = tk.Label(frame, image=captcha_image)
captcha_label.pack()
captcha_var = tk.StringVar(frame)
captcha_input = tk.Entry(frame, textvariable=captcha_var)
captcha_input.focus_set()
captcha_input.pack()
button = tk.Button(frame, text="Go", command=root.destroy)
captcha_input.bind("<Return>", lambda _: button.invoke())
button.pack()
root.mainloop()
return captcha_var.get()
def __init__(self, parent, title, app, manager, key=None, **kw):
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
#
if key is None:
key = manager.getSelected()
self.app = app
self.manager = manager
self.key = key
self.table_color = app.opt.colors['table']
if self.TreeDataHolder_Class.data is None:
self.TreeDataHolder_Class.data = self.TreeData_Class(manager, key)
#
sw = self.top.winfo_screenwidth()
sh = self.top.winfo_screenheight()
h = int(sh * .8)
w = int(sw * .8)
w1 = int(min(275, sw / 2.5))
geometry = ("%dx%d+%d+%d" % (w, h, (sw - w) / 2, (sh - h) / 2))
self.top.wm_minsize(400, 200)
padx, pady = 4, 4
paned_window = ttk.PanedWindow(top_frame, orient='horizontal')
paned_window.pack(expand=True, fill='both', padx=8, pady=8)
left_frame = ttk.Frame(paned_window)
right_frame = ttk.Frame(paned_window)
paned_window.add(left_frame)
paned_window.add(right_frame)
notebook = ttk.Notebook(left_frame)
notebook.pack(expand=True, fill='both')
tree_frame = ttk.Frame(notebook)
notebook.add(tree_frame, text=_('Tree View'))
search_frame = ttk.Frame(notebook)
notebook.add(search_frame, text=_('Search'))
font = app.getFont("default")
padx, pady = 4, 4
self.tree = self.Tree_Class(self, tree_frame, key=key,
default=kw.default,
font=font, width=w1)
self.tree.frame.pack(padx=padx, pady=pady, expand=True, fill='both')
# Search
searchText = tkinter.StringVar()
self.list_searchlabel = tkinter.Label(search_frame, text="Search:",
justify='left', anchor='w')
self.list_searchlabel.pack(side="top", fill='both', ipadx=1)
self.list_searchtext = tkinter.Entry(search_frame,
textvariable=searchText)
self.list_searchtext.pack(side="top", fill='both',
padx=padx, pady=pady, ipadx=1)
searchText.trace('w', self.performSearch)
self.list_scrollbar = tkinter.Scrollbar(search_frame)
self.list_scrollbar.pack(side="right", fill='both')
self.createBitmaps(search_frame, kw)
self.list = tkinter.Listbox(search_frame, exportselection=False)
self.list.pack(padx=padx, pady=pady, expand=True, side='left',
fill='both', ipadx=1)
self.updateSearchList("")
bind(self.list, '<<ListboxSelect>>', self.selectSearchResult)
bind(self.list, '<FocusOut>',
lambda e: self.list.selection_clear(0, 'end'))
self.list.config(yscrollcommand=self.list_scrollbar.set)
self.list_scrollbar.config(command=self.list.yview)
self.preview = MfxScrolledCanvas(right_frame, hbar=0, vbar=0)
self.preview.pack(side="right", fill='both', expand=True,
padx=padx, pady=pady)
self.preview.canvas.preview = 1
# create a preview of the current state
self.preview_key = -1
self.updatePreview(key)
#
focus = self.createButtons(bottom_frame, kw)
focus = self.tree.frame
self.mainloop(focus, kw.timeout, geometry=geometry)
def __init__(self, parent, title, app, **kw):
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
frame = tkinter.Frame(top_frame)
frame.pack(expand=True, fill='both', padx=10, pady=10)
frame.columnconfigure(0, weight=1)
notebook = TabPageSet(frame)
notebook.pack(expand=True, fill='both')
for w in WizardWidgets:
if isinstance(w, basestring):
notebook.AddPage(w)
frame = tkinter.Frame(notebook.pages[w]['page'])
frame.pack(expand=True, fill='both', padx=2, pady=4)
frame.columnconfigure(1, weight=1)
row = 0
continue
tkinter.Label(frame, text=w.label).grid(row=row, column=0, padx=2)
if w.widget == 'preset':
if w.variable is None:
w.variable = tkinter.StringVar()
values = [_(v) for v in w.values]
default = _(w.default)
values.remove(default)
values.sort()
values.insert(0, default)
def callback(v, w=w):
return self.presetSelected(v, w)
om = tkinter.OptionMenu(frame,
w.variable,
command=callback,
*values)
om.grid(row=row, column=1, sticky='ew', padx=2)
elif w.widget == 'entry':
if w.variable is None:
w.variable = tkinter.StringVar()
en = tkinter.Entry(frame, textvariable=w.variable)
en.grid(row=row, column=1, sticky='ew', padx=2)
elif w.widget == 'menu':
if w.variable is None:
w.variable = tkinter.StringVar()
values = [_(v) for v in w.values]
om = tkinter.OptionMenu(frame, w.variable, *values)
om.grid(row=row, column=1, sticky='ew', padx=2)
elif w.widget == 'spin':
if w.variable is None:
w.variable = tkinter.IntVar()
from_, to = w.values
s = tkinter.Scale(frame,
from_=from_,
to=to,
resolution=1,
orient='horizontal',
length=200,
variable=w.variable)
s.grid(row=row, column=1, sticky='ew', padx=2)
elif w.widget == 'check':
if w.variable is None:
w.variable = tkinter.BooleanVar()
ch = tkinter.Checkbutton(frame,
variable=w.variable,
takefocus=False,
anchor='w')
ch.grid(row=row, column=1, sticky='ew', padx=2, pady=2)
if w.current_value is None:
v = w.default
else:
v = w.current_value
if w.widget in ('menu', 'preset', 'entry'):
v = _(v)
w.variable.set(v)
row += 1
notebook.ChangePage()
focus = self.createButtons(bottom_frame, kw)
self.mainloop(focus, kw.timeout)
def __init__(self, parent, title, app, manager, key=None, **kw):
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
#
if key is None:
key = manager.getSelected()
self.manager = manager
self.key = key
self.app = app
self.cardset_values = None
# padx, pady = kw.padx, kw.pady
padx, pady = 4, 4
if self.TreeDataHolder_Class.data is None:
self.TreeDataHolder_Class.data = self.TreeData_Class(manager, key)
#
sw = self.top.winfo_screenwidth()
sh = self.top.winfo_screenheight()
h = int(sh * .8)
w = int(sw * .8)
w1 = int(min(275, sw / 2.5))
geometry = ("%dx%d+%d+%d" % (w, h, (sw - w) / 2, (sh - h) / 2))
self.top.wm_minsize(400, 200)
paned_window = ttk.PanedWindow(top_frame, orient='horizontal')
paned_window.pack(expand=True, fill='both', padx=8, pady=8)
left_frame = ttk.Frame(paned_window)
right_frame = ttk.Frame(paned_window)
paned_window.add(left_frame)
paned_window.add(right_frame)
notebook = ttk.Notebook(left_frame)
notebook.grid(row=0, column=0, sticky='nsew', padx=padx, pady=pady)
tree_frame = ttk.Frame(notebook)
notebook.add(tree_frame, text=_('Tree View'))
search_frame = ttk.Frame(notebook)
notebook.add(search_frame, text=_('Search'))
# Tree
font = app.getFont("default")
self.tree = self.Tree_Class(self,
tree_frame,
key=key,
default=kw.default,
font=font,
width=w1)
self.tree.frame.pack(padx=padx, pady=pady, expand=True, fill='both')
# Search
searchText = tkinter.StringVar()
self.list_searchlabel = tkinter.Label(search_frame,
text="Search:",
justify='left',
anchor='w')
self.list_searchlabel.pack(side="top", fill='both', ipadx=1)
self.list_searchtext = tkinter.Entry(search_frame,
textvariable=searchText)
self.list_searchtext.pack(side="top",
fill='both',
padx=padx,
pady=pady,
ipadx=1)
searchText.trace('w', self.performSearch)
self.list_scrollbar = tkinter.Scrollbar(search_frame)
self.list_scrollbar.pack(side="right", fill='both')
self.createBitmaps(search_frame, kw)
self.list = tkinter.Listbox(search_frame, exportselection=False)
self.list.pack(padx=padx,
pady=pady,
expand=True,
side='left',
fill='both',
ipadx=1)
self.updateSearchList("")
bind(self.list, '<<ListboxSelect>>', self.selectSearchResult)
bind(self.list, '<FocusOut>',
lambda e: self.list.selection_clear(0, 'end'))
self.list.config(yscrollcommand=self.list_scrollbar.set)
self.list_scrollbar.config(command=self.list.yview)
if USE_PIL:
#
var = tkinter.DoubleVar()
var.set(app.opt.scale_x)
self.scale_x = PysolScale(left_frame,
label=_('Scale X:'),
from_=0.5,
to=4.0,
resolution=0.1,
orient='horizontal',
variable=var,
value=app.opt.scale_x,
command=self._updateScale)
self.scale_x.grid(row=1,
column=0,
sticky='ew',
padx=padx,
pady=pady)
#
var = tkinter.DoubleVar()
var.set(app.opt.scale_y)
self.scale_y = PysolScale(left_frame,
label=_('Scale Y:'),
from_=0.5,
to=4.0,
resolution=0.1,
orient='horizontal',
variable=var,
value=app.opt.scale_y,
command=self._updateScale)
self.scale_y.grid(row=2,
column=0,
sticky='ew',
padx=padx,
pady=pady)
#
# sliders at new position
cs = self.manager.get(self.tree.selection_key)
var = tkinter.IntVar()
self.x_offset = PysolScale(left_frame,
label=_('X offset:'),
from_=5,
to=100,
resolution=1,
orient='horizontal',
variable=var,
value=cs.CARD_XOFFSET)
self.x_offset.grid(row=3,
column=0,
sticky='ew',
padx=padx,
pady=pady)
var = tkinter.IntVar()
self.y_offset = PysolScale(left_frame,
label=_('Y offset:'),
from_=5,
to=100,
resolution=1,
orient='horizontal',
variable=var,
value=cs.CARD_YOFFSET)
self.y_offset.grid(row=4,
column=0,
sticky='ew',
padx=padx,
pady=pady)
self.auto_scale = tkinter.BooleanVar()
self.auto_scale.set(app.opt.auto_scale)
check = ttk.Checkbutton(left_frame,
text=_('Auto scaling'),
variable=self.auto_scale,
takefocus=False,
command=self._updateAutoScale)
check.grid(row=5,
column=0,
columnspan=2,
sticky='ew',
padx=padx,
pady=pady)
#
self.preserve_aspect = tkinter.BooleanVar()
self.preserve_aspect.set(app.opt.preserve_aspect_ratio)
self.aspect_check = ttk.Checkbutton(
left_frame,
text=_('Preserve aspect ratio'),
variable=self.preserve_aspect,
takefocus=False,
# command=self._updateScale
)
self.aspect_check.grid(row=6,
column=0,
sticky='ew',
padx=padx,
pady=pady)
self._updateAutoScale()
#
left_frame.rowconfigure(0, weight=1)
left_frame.columnconfigure(0, weight=1)
#
self.preview = MfxScrolledCanvas(right_frame)
self.preview.setTile(app, app.tabletile_index, force=True)
self.preview.pack(fill='both', expand=True, padx=padx, pady=pady)
self.preview.canvas.preview = 1
# create a preview of the current state
self.preview_key = -1
self.preview_images = []
self.scale_images = []
self.updatePreview(key)
#
focus = self.createButtons(bottom_frame, kw)
focus = self.tree.frame
self.mainloop(focus, kw.timeout, geometry=geometry)
if pageName == self.defaultPage: # set a new default page
self.defaultPage = \
self.tabBar.winfo_children()[0].button.cget('text')
if pageName == self.GetActivePage(): # set a new active page
self.activePage.set(self.defaultPage)
self.ChangePage()
if __name__ == '__main__':
# test dialog
root = tkinter.Tk()
tabPage = TabPageSet(root, pageNames=['Foobar', 'Baz'])
tabPage.pack(expand=tkinter.TRUE, fill=tkinter.BOTH)
tkinter.Label(tabPage.pages['Foobar']['page'], text='Foo', pady=20).pack()
tkinter.Label(tabPage.pages['Foobar']['page'], text='Bar', pady=20).pack()
tkinter.Label(tabPage.pages['Baz']['page'], text='Baz').pack()
entryPgName = tkinter.Entry(root)
buttonAdd = tkinter.Button(
root, text='Add Page',
command=lambda: tabPage.AddPage(entryPgName.get()))
buttonRemove = tkinter.Button(
root, text='Remove Page',
command=lambda: tabPage.RemovePage(entryPgName.get()))
labelPgName = tkinter.Label(root, text='name of page to add/remove:')
buttonAdd.pack(padx=5, pady=5)
buttonRemove.pack(padx=5, pady=5)
labelPgName.pack(padx=5)
entryPgName.pack(padx=5)
tabPage.ChangePage()
root.mainloop()
def _button_area(self):
# grid layout
# make expandable
for col in range(5):
self.button_frame.columnconfigure(col, weight=1)
self.button_frame.rowconfigure(col, weight=1)
# column 0 ---------
# load image file button
self.load = tk.Button(master=self.button_frame,
text="load image",
font=self.fontB,
fg="dark blue",
command=self._loadimage)
self.load.grid(row=0, column=0, sticky=tk.W, padx=(5, 10), pady=(5, 0))
self.sample_image = ttk.Combobox(master=self.button_frame,
font=self.font,
values=[
"from file", "from transform",
"sample dribinski",
"sample Ominus"
],
width=14,
height=4)
self.sample_image.current(0)
self.sample_image.grid(row=1, column=0, padx=(5, 10))
# quit
self.quit = tk.Button(master=self.button_frame,
text="Quit",
font=self.fontB,
fg="dark red",
command=self._quit)
self.quit.grid(row=3, column=0, sticky=tk.W, padx=(5, 10), pady=(0, 5))
# column 1 -----------
# center image
self.center = tk.Button(master=self.button_frame,
text="center image",
anchor=tk.W,
font=self.fontB,
fg="dark blue",
command=self._center)
self.center.grid(row=0, column=1, padx=(0, 20), pady=(5, 0))
self.center_method = ttk.Combobox(master=self.button_frame,
font=self.font,
values=center_methods,
width=11,
height=4)
self.center_method.current(1)
self.center_method.grid(row=1, column=1, padx=(0, 20))
# column 2 -----------
# Abel transform image
self.recond = tk.Button(master=self.button_frame,
text="Abel transform image",
font=self.fontB,
fg="dark blue",
command=self._transform)
self.recond.grid(row=0, column=2, padx=(0, 10), pady=(5, 0))
self.transform = ttk.Combobox(master=self.button_frame,
values=Abel_methods,
font=self.font,
width=10,
height=len(Abel_methods))
self.transform.current(2)
self.transform.grid(row=1, column=2, padx=(0, 20))
self.direction = ttk.Combobox(master=self.button_frame,
values=["inverse", "forward"],
font=self.font,
width=8,
height=2)
self.direction.current(0)
self.direction.grid(row=2, column=2, padx=(0, 20))
# column 3 -----------
# speed button
self.speed = tk.Button(master=self.button_frame,
text="speed",
font=self.fontB,
fg="dark blue",
command=self._speed)
self.speed.grid(row=0, column=5, padx=20, pady=(5, 0))
self.speedclr = tk.Button(master=self.button_frame,
text="clear plot",
font=self.font,
command=self._speed_clr)
self.speedclr.grid(row=1, column=5, padx=20)
# column 4 -----------
# anisotropy button
self.aniso = tk.Button(master=self.button_frame,
text="anisotropy",
font=self.fontB,
fg="dark blue",
command=self._anisotropy)
self.aniso.grid(row=0, column=6, pady=(5, 0))
self.subframe = tk.Frame(self.button_frame)
self.subframe.grid(row=1, column=6)
self.rmin = tk.Entry(master=self.subframe,
text='rmin',
width=3,
font=self.font)
self.rmin.grid(row=0, column=0)
self.rmin.delete(0, tk.END)
self.rmin.insert(0, self.rmx[0])
self.lbl = tk.Label(master=self.subframe, text="to", font=self.font)
self.lbl.grid(row=0, column=1)
self.rmax = tk.Entry(master=self.subframe,
text='rmax',
width=3,
font=self.font)
self.rmax.grid(row=0, column=2)
self.rmax.delete(0, tk.END)
self.rmax.insert(0, self.rmx[1])
# turn off button interface
self.hide_buttons = tk.Button(master=self.button_frame,
text="hide buttons",
font=self.fontB,
fg='grey',
command=self._hide_buttons)
self.hide_buttons.grid(row=3, column=6, sticky=tk.E, pady=(0, 20))
def __init__(self, parent, title, app, gameid, bookmark=None, **kw):
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
#
self.app = app
self.gameid = gameid
self.bookmark = bookmark
self.random = None
if self.TreeDataHolder_Class.data is None:
self.TreeDataHolder_Class.data = self.TreeData_Class(app)
#
sw = self.top.winfo_screenwidth()
sh = self.top.winfo_screenheight()
h = int(sh * .8)
w = int(sw * .8)
w1 = int(min(275, sw / 2.5))
geometry = ("%dx%d+%d+%d" % (w, h, (sw - w) / 2, (sh - h) / 2))
self.top.wm_minsize(400, 200)
# print sw, w1, w2
# w2 = max(200, min(w2, 10 + 12 * (app.subsampled_images.CARDW + 10)))
# print sw, w1, w2
# padx, pady = kw.padx, kw.pady
# padx, pady = kw.padx/2, kw.pady/2
padx, pady = 4, 4
# PanedWindow
paned_window = ttk.PanedWindow(top_frame, orient='horizontal')
paned_window.pack(expand=True, fill='both', padx=8, pady=8)
left_frame = ttk.Frame(paned_window)
right_frame = ttk.Frame(paned_window)
paned_window.add(left_frame)
paned_window.add(right_frame)
notebook = ttk.Notebook(left_frame)
notebook.pack(expand=True, fill='both')
tree_frame = ttk.Frame(notebook)
notebook.add(tree_frame, text=_('Tree View'))
search_frame = ttk.Frame(notebook)
notebook.add(search_frame, text=_('Search'))
# Tree
font = app.getFont("default")
self.tree = self.Tree_Class(self,
tree_frame,
key=gameid,
default=kw.default,
font=font,
width=w1)
self.tree.frame.pack(padx=padx, pady=pady, expand=True, fill='both')
# Search
searchText = tkinter.StringVar()
self.list_searchlabel = tkinter.Label(search_frame,
text="Search:",
justify='left',
anchor='w')
self.list_searchlabel.pack(side="top", fill='both', ipadx=1)
self.list_searchtext = tkinter.Entry(search_frame,
textvariable=searchText)
self.list_searchtext.pack(side="top",
fill='both',
padx=padx,
pady=pady,
ipadx=1)
searchText.trace('w', self.performSearch)
self.list_scrollbar = tkinter.Scrollbar(search_frame)
self.list_scrollbar.pack(side="right", fill='both')
self.createBitmaps(search_frame, kw)
self.list = tkinter.Listbox(search_frame, exportselection=False)
self.list.pack(padx=padx,
pady=pady,
expand=True,
side='left',
fill='both',
ipadx=1)
self.updateSearchList("")
bind(self.list, '<<ListboxSelect>>', self.selectSearchResult)
bind(self.list, '<FocusOut>',
lambda e: self.list.selection_clear(0, 'end'))
self.list.config(yscrollcommand=self.list_scrollbar.set)
self.list_scrollbar.config(command=self.list.yview)
# LabelFrame
info_frame = ttk.LabelFrame(right_frame, text=_('About game'))
info_frame.grid(row=0,
column=0,
padx=padx,
pady=pady,
ipadx=4,
ipady=4,
sticky='nws')
stats_frame = ttk.LabelFrame(right_frame, text=_('Statistics'))
stats_frame.grid(row=0,
column=1,
padx=padx,
pady=pady,
ipadx=4,
ipady=4,
sticky='nws')
# Info
self.info_labels = {}
for n, t, f, row in (
('name', _('Name:'), info_frame, 0),
('altnames', _('Alternate names:'), info_frame, 1),
('category', _('Category:'), info_frame, 2),
('type', _('Type:'), info_frame, 3),
('skill_level', _('Skill level:'), info_frame, 4),
('decks', _('Decks:'), info_frame, 5),
('redeals', _('Redeals:'), info_frame, 6),
#
('played', _('Played:'), stats_frame, 0),
('won', _('Won:'), stats_frame, 1),
('lost', _('Lost:'), stats_frame, 2),
('time', _('Playing time:'), stats_frame, 3),
('moves', _('Moves:'), stats_frame, 4),
('percent', _('% won:'), stats_frame, 5),
):
title_label = ttk.Label(f, text=t, justify='left', anchor='w')
title_label.grid(row=row, column=0, sticky='nw', padx=4)
text_label = ttk.Label(f, justify='left', anchor='w')
text_label.grid(row=row, column=1, sticky='nw', padx=4)
self.info_labels[n] = (title_label, text_label)
# info_frame.columnconfigure(1, weight=1)
info_frame.rowconfigure(6, weight=1)
stats_frame.rowconfigure(6, weight=1)
# Canvas
self.preview = MfxScrolledCanvas(right_frame)
self.preview.setTile(app, app.tabletile_index, force=True)
self.preview.grid(row=1,
column=0,
columnspan=3,
padx=padx,
pady=pady,
sticky='nsew')
right_frame.columnconfigure(1, weight=1)
right_frame.rowconfigure(1, weight=1)
#
focus = self.createButtons(bottom_frame, kw)
# set the scale factor
self.preview.canvas.preview = 2
# create a preview of the current game
self.preview_key = -1
self.preview_game = None
self.preview_app = None
self.updatePreview(gameid, animations=0)
# focus = self.tree.frame
self.mainloop(focus, kw.timeout, geometry=geometry)
def initialize(self):
"""
Initialize the tKinter app (GUI)
by creating frames and graphical components,
setting the window size etc.
"""
# self.bind("<Escape>", lambda x: self.destroy())
self.bind("<Escape>", on_close)
listFrame0 = Frame(self)
listFrame0.pack(side=TOP, fill=BOTH, expand=True)
listFrame = Frame(listFrame0)
listFrame.pack(side=LEFT, fill=BOTH, expand=True)
scrollbary = Scrollbar(listFrame, orient=VERTICAL)
scrollbary.pack(side=RIGHT, fill=Y)
scrollbarx = Scrollbar(listFrame, orient=HORIZONTAL)
scrollbarx.pack(side=BOTTOM, fill=X)
# bd --> border
self.listbox = Listbox(listFrame, bd=1, selectmode=SINGLE, yscrollcommand=scrollbary.set, xscrollcommand=scrollbarx.set)
self.listbox.bind('<<ListboxSelect>>', self.on_select_click)
scrollbary.config(command=self.listbox.yview)
scrollbarx.config(command=self.listbox.xview)
self.listbox.config(width=self.listbox.winfo_reqwidth() // 3) # width=self.listbox.winfo_reqwidth()
self.listbox.pack(side=LEFT, fill=BOTH, expand=True)
listFrame1 = Frame(listFrame0)
listFrame1.pack(side=LEFT, fill=BOTH, expand=True)
scrollbary1 = Scrollbar(listFrame1, orient=VERTICAL)
scrollbary1.pack(side=RIGHT, fill=Y)
scrollbarx1 = Scrollbar(listFrame1, orient=HORIZONTAL)
scrollbarx1.pack(side=BOTTOM, fill=X)
# bd --> border
self.listbox1 = Listbox(listFrame1, bd=0, selectmode=SINGLE, yscrollcommand=scrollbary1.set, xscrollcommand=scrollbarx1.set)
self.listbox1.bind('<<ListboxSelect>>', self.on_update_select_click)
scrollbary1.config(command=self.listbox1.yview)
scrollbarx1.config(command=self.listbox1.xview)
self.listbox1.config(width=self.listbox1.winfo_reqwidth() // 2) # width=self.listbox.winfo_reqwidth()
self.listbox1.pack(side=LEFT, fill=BOTH, expand=True)
text_frame = Frame(self)
text_frame.pack(fill=X) # ,expand=True)
self.created_str = tk.StringVar()
created = tk.Entry(text_frame, textvariable=self.created_str)
self.created_months = ttk.Combobox(text_frame)
self.created_months['values'] = ('01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12')
self.created_months.set(datetime.date.today().strftime('%m'))
self.created_months.state(['readonly'])
# self.created_months.bind('<<ComboboxSelected>>', self.On_table_select)
self.value_str = tk.StringVar()
value = tk.Entry(text_frame, textvariable=self.value_str)
self.category_str = tk.StringVar()
category = tk.Entry(text_frame, textvariable=self.category_str) # , state='readonly')
self.description_str = tk.StringVar()
description = tk.Entry(text_frame, textvariable=self.description_str)
fill_from_csv_button = Button(text_frame, text="fill from csv")
fill_from_csv_button.bind('<Button-1>', self.on_fill_from_csv_click)
self.db_tables = ttk.Combobox(text_frame)
self.db_tables.state(['readonly'])
self.db_tables.bind('<<ComboboxSelected>>', self.on_table_select)
created.pack(side=LEFT)
self.created_months.pack(side=LEFT)
value.pack(side=LEFT)
category.pack(side=LEFT)
description.pack(side=LEFT)
# check.pack(side=LEFT)
fill_from_csv_button.pack(side=LEFT)
self.db_tables.pack(side=LEFT)
button_frame = Frame(self)
button_frame.pack(fill=X) # ,expand=True)
save_button = Button(button_frame, text="save entry")
save_button.bind('<Button-1>', self.on_save_entry_click)
database_button = Button(button_frame, text="select database")
database_button.bind('<Button-1>', self.on_database_click)
self.database_path_str = tk.StringVar()
self.database_path = tk.Label(button_frame, textvariable=self.database_path_str, bg="white", anchor=tk.W)
save_button.pack(side=LEFT)
database_button.pack(side=RIGHT)
self.database_path.pack(side=RIGHT) # , expand=True, fill=BOTH fill=BOTH,
debugFrame = Frame(self)
debugFrame.pack(side=BOTTOM, fill=X) # ,expand=True)
self.last_entry = tk.StringVar()
self.path_label = tk.Label(debugFrame, textvariable=self.last_entry, bg="white", anchor=tk.W)
self.path_label.pack(side=LEFT, fill=BOTH, expand=True)
# print self.geometry()
self.update()
# self.geometry(self.geometry())
# self.update()
# print self.geometry()
# fix the size of the window by setting the window size to its own size
w = self.winfo_screenwidth()
# print w
# print 'reqwidth',self.winfo_reqwidth()
# h = self.winfo_screenheight()
self.geometry('{0}x{1}+{2}+{3}'.format(self.winfo_reqwidth(), self.winfo_reqheight() * 3, w - self.winfo_reqwidth() - 20, 0)) # self.geometry()
self.update()
self.minsize(self.winfo_reqwidth(), self.winfo_reqheight())
def __init__(self, odf, plotter):
self.f = Figure()
# Save reference to the model
self.odf = odf
# Save reference to the plotter
self.plotter = plotter
self.leftMask = None
self.rightMask = None
self.activeLine = None
self.root = tk.Tk()
self.root.wm_title("PyA Model Explorer")
# Make the widgets expand/shrink as window size changes
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
# Bind the mouse wheel
if platform.system() == "Linux":
self.root.bind("<Button-4>", self._mouseWheel)
self.root.bind("<Button-5>", self._mouseWheel)
elif platform.system() == "Darwin":
self.root.bind("<MouseWheel>", self._onWheel) # for OS X
# A frame containing the mpl plot
self.plotFrame = tk.Frame()
self.plotFrame.pack(fill=tk.BOTH, side=tk.LEFT, expand=True)
self.canvas = FigureCanvasTkAgg(self.f, master=self.plotFrame)
# A frame containing the box with selected points
# and control buttons
self.controlFrame = tk.Frame(self.root)
self.controlFrame.pack(side=tk.RIGHT, expand=False, fill=tk.BOTH)
self.selectedPar = tk.StringVar(self.controlFrame)
# Get parameters of model
ps = list(self.odf.parameters().keys())
# Set default modification properties
# Saves these properties for all parameters
self.modProps = {}
for p in ps:
self.modProps[p] = {"modus":"mul", "modValMul":1.02, "modValAdd":0.01}
# Frame containing all parameters
self.parameterFrame = tk.Frame(self.controlFrame, height=2, bd=1, relief=tk.SUNKEN)
# Dictionaries holding the specific information for each parameter
self.singleParameterFrames = {}
self.singleParameterEntry = {}
self.singleParameterVar = {}
self.singleParameterFree = {} # knows whether the parameter is free (value=True) or frozen (=False)
# Closures around the functions adapting thaw/freeze
def frozenChanged(k):
def change():
if self.singleParameterFree[k].get() == True:
self.odf.thaw(k)
else:
self.odf.freeze(k)
self._updateDof()
return change
# define what happens when a value is set to the entered parameter (closures)
def hitReturn(k):
def change(*args):
self.selectedPar.set(k)
self.odf[k] = float(self.singleParameterVar[k].get())
self._parameterValueChanged()
return change
# defines what happens when a parameter's value is changed, but not set yet, i.e., not current (closures)
def parameterValueChanged(k):
def valueChanged(*args):
pp,ll = str(self.singleParameterVar[k].get()).find("."), len(str(self.singleParameterVar[k].get()))
if round(self.odf[k],ll-pp-1) != round(self.singleParameterVar[k].get(), ll-pp-1):
self.singleParameterEntry[k].configure(bg = "red")
else:
self.singleParameterEntry[k].configure(bg = "white")
return valueChanged
# Create an entry for each parameter
## Create a scrollable region
## Check maximum number of characters for parameter names:
maxParamLen = 0
for k in sorted(self.odf.parameters().keys()):
if len(k) > maxParamLen:
maxParamLen = len(k)
## Create an entry for each parameter
for k in sorted(self.odf.parameters().keys()):
x = tk.Frame(self.parameterFrame, height=2, bd=2, relief=tk.SUNKEN,pady=2)
self.singleParameterFrames[k] = x
y0 = tk.Radiobutton(x, text=k,variable=self.selectedPar,value=k, width=maxParamLen+1, indicatoron=0)
y0.pack(side=tk.LEFT)
#y1 = tk.StringVar()
y1 = tk.DoubleVar()
y1.set(self.odf[k])
y2 = tk.Entry(x, textvariable=y1, width=8)
y2.bind('<Return>', hitReturn(k))
self.singleParameterVar[k] = y1
self.singleParameterVar[k].trace('w', parameterValueChanged(k))
self.singleParameterEntry[k]= y2
y2.pack(side=tk.LEFT)
self.singleParameterFrames[k].pack()
modModus = tk.StringVar()
modModus.set(self.modProps[k]["modus"])
self.singleParameterFree[k] = tk.BooleanVar()
self.singleParameterFree[k].set(k in self.odf.freeParamNames())
y3 = tk.Radiobutton(x, text="Thawed", value=True,variable=self.singleParameterFree[k], command=frozenChanged(k))
y4 = tk.Radiobutton(x, text="Frozen", value=False,variable=self.singleParameterFree[k], command=frozenChanged(k))
y3.pack(side=tk.RIGHT)
y4.pack(side=tk.RIGHT)
self.parameterFrame.pack(fill=tk.X, expand=False)
# Set of the menu to select the current parameter
self.selectedPar.set(ps[0])
# Chi2 frame:
self.chi2Frame = tk.Frame(self.controlFrame, borderwidth=10)#, relief=tk.SUNKEN)
self.chi2value = tk.DoubleVar()
self.chi2value.set(self.plotter.chi2)
self.dofValue = tk.IntVar()
#self.dofValue.set(len(self.plotter.fitIdx))
#self.dofValue.set(100)
self.dofValue.set(len(self.plotter.x) - len(self.odf.freeParameters())-1)
self.chi2Label = tk.Label(self.chi2Frame,text="Chi2: ")
self.dofLabel = tk.Label(self.chi2Frame,text="dof: ")
self.chi2Entry = tk.Entry(self.chi2Frame, textvariable=self.chi2value, bd=2, width=10)
self.dofEntry = tk.Entry(self.chi2Frame, textvariable=self.dofValue, bd=2, width=10)
self.chi2Label.pack(side=tk.LEFT)
self.chi2Entry.pack(side=tk.LEFT)
self.dofLabel.pack(side=tk.LEFT)
self.dofEntry.pack(side=tk.LEFT)
self.chi2Frame.pack()
# Frame to bundle mouse-wheel inputs
self.mouseWheelFrame = tk.Frame(self.controlFrame, height=2, bd=3, relief=tk.SUNKEN)
self.mwmLabel = tk.Label(self.mouseWheelFrame, text="Mouse wheel manipulation")
self.mwmLabel.pack()
# Modify by multiplication or addition (modModus)
self.modModus = tk.StringVar()
self.modModus.set("mul")
# Entry field and radiobutton to specify factor to be used
self.factorFrame = tk.Frame(self.mouseWheelFrame)
self.modEntryTextMul = tk.StringVar()
self.modEntryFactor = tk.Entry(self.factorFrame, textvariable=self.modEntryTextMul, width=6)
self.modEntryFactor.pack(side=tk.LEFT)
self.radioMultipli = tk.Radiobutton(self.factorFrame, text="Multiply", value="mul", variable=self.modModus)
self.radioMultipli.pack(side=tk.LEFT)
self.factorFrame.pack(fill=tk.BOTH)
# Entry field and radiobutton to specify step (delta) to be used
self.addFrame = tk.Frame(self.mouseWheelFrame)
self.modEntryTextAdd = tk.StringVar()
self.modEntryAdd = tk.Entry(self.addFrame, textvariable=self.modEntryTextAdd, width=6)
self.modEntryAdd.pack(side=tk.LEFT)
self.radioAdd = tk.Radiobutton(self.addFrame, text="Add", value="add", variable=self.modModus)
self.radioAdd.pack(side=tk.LEFT)
self.addFrame.pack(fill=tk.BOTH)
# Set text fields for modification factor/step to default
self.modEntryTextMul.set(self.modProps[self.selectedPar.get()]["modValMul"])
self.modEntryTextAdd.set(self.modProps[self.selectedPar.get()]["modValAdd"])
self.modEntryTextAdd.trace("w", self._modModeChangedAdd)
self.modEntryTextMul.trace("w", self._modModeChangedMul)
# Show the frame
# self.mouseWheelFrame.grid(row=4, column=0, columnspan=3, pady=10)
self.mouseWheelFrame.pack()
# React to change in modify Modus
self.modModus.trace('w', self._modModusChanged)
# React to a change in the active parameter
self.selectedPar.trace("w", self._activeParameterChanged)
dummyLabel = tk.Label(self.controlFrame)
dummyLabel.pack()
# Fit button and fit ranges
self.fitRangeFrame = tk.Frame(self.controlFrame, bd=3, relief=tk.SUNKEN)
self.fit_lo = tk.DoubleVar()
self.fit_hi = tk.DoubleVar()
self.fit_lo.set(min(plotter.x))
self.fit_hi.set(max(plotter.x))
self.fitRangeLoLim = tk.Entry(self.fitRangeFrame, textvariable=self.fit_lo, width=9, bd=2)
self.fitRangeHiLim = tk.Entry(self.fitRangeFrame, textvariable=self.fit_hi, width=9, bd=2)
self.fitRangeLabel = tk.Label(self.fitRangeFrame, text="Fit range:")
self.fitButton = tk.Button(self.fitRangeFrame, text="Fit", command=self._fitClicked)
self.fitButton.pack(side=tk.BOTTOM, fill=tk.X)
self.fitRangeLabel.pack(side=tk.LEFT, fill=tk.X)
self.fitRangeHiLim.pack(side=tk.RIGHT)
self.fitRangeLoLim.pack(side=tk.RIGHT)
self.fitRangeFrame.pack(fill=tk.X)
#self.fitRangeLoLim.bind('<Return>', self._fitRangeChanged())
self.fit_lo.trace("w", self._fitRangeChanged)
self.fit_hi.trace("w", self._fitRangeChanged)
self.numberClicked=0
#self.modModus.trace('w', self._modModusChanged)
#self.modModus.trace('w', self._modModusChanged)
dummyLabel = tk.Label(self.controlFrame)
dummyLabel.pack()
self.showFrame = tk.Frame(self.controlFrame, bd=3)#, relief=tk.SUNKEN)
self.showFrame.pack(side=tk.TOP)
self.parSumButton = tk.Button(self.showFrame, text="Parameter summary", command=self._parameterSummaryClicked)
self.parSumButton.pack(side=tk.LEFT)
self.valSetButton = tk.Button(self.showFrame, text="Value set code", command=self._valueSetClicked)
# self.valSetButton.grid(row=7, column=2)
self.valSetButton.pack(side=tk.RIGHT)
# a tk.DrawingArea
# self.canvas.get_tk_widget().grid(column=0, columnspan=7, row=0, rowspan=10)
self.canvas.get_tk_widget().pack()
self.cid = self.f.canvas.mpl_connect('button_press_event', self._mouseButtonClicked)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.plotFrame)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
def _quit():
# stops main loop
self.root.quit()
# this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
self.root.destroy()
self.quitButton = tk.Button(master=self.controlFrame, text='Quit', command=_quit)
self.quitButton.pack(side=tk.BOTTOM)
# Plot the model for the first time
self._parameterValueChanged()
# Whether or not parameter summary exists
self.root.parSumWin = None
if platform.system() == "Darwin":
self.root.bind("<MouseWheel>", self._onWheel) # for OS X
def __init__(self, x, y, yerr=None, mode="gauss", config=None):
self.windowTitle = "PyA interactive GV"
self.f = Figure()
self.a = self.f.add_subplot(111)
self._config = {"modelLS":'r--', \
"dataLS":'bp', \
"dataLSerr":'b+', \
"activeCompLS":'k-', \
"inactiveCompLS":'y--', \
"plotIndComps":True, \
"rangeLS":'m--', \
"defaultFreeVoigt":["A", "ad", "al", "mu"], \
"default_alad":0.1, \
"defaultFreeGauss":["A", "sig", "mu"], \
"defaultWheelAdd":0.01, \
"defaultWheelMult": 2}
# Modify configuration according to input
if config is not None:
for k in six.iterkeys(self._config):
if k in config:
# Value has been modified
self._config[k] = config[k]
# Tk root
self.root = tk.Tk()
# Create data plot
self._x = x
self._y = y
self._yerr = yerr
if self._yerr is None:
self.a.plot(x, y, self._config["dataLS"])
else:
self.a.errorbar(x,
y,
yerr=self._yerr,
fmt=self._config["dataLSerr"])
# The input mode determines how clicks on the mouse wheel are
# interpreted.
self._inputMode = "newComp"
# Component count/assignment starts at 1
self._activeComponent = 1
self._compoCount = 0
# Create model and parameter lists
self._mode = mode
if self._mode == "voigt":
self._model = fuf.MultiVoigt1d(1)
self._compPars = ["mu", "ad", "al", "A"]
elif self._mode == "gauss":
self._model = fuf.MultiGauss1d(1)
self._compPars = ["mu", "sig", "A"]
else:
raise(PE.PyAValError("No such mode: " + str(self._mode), \
solution="Choose either 'voigt' or 'gauss'."))
self._model["off"] = 1.0
# List used to cache points used to add component
# as long as component is not completely specified
self._pointCache = []
# What to consider in the fit
self._rangeIndices = np.arange(self._x.size, dtype=np.int)
# A frame containing the mpl plot
self.plotFrame = tk.Frame()
self.plotFrame.pack(fill=tk.BOTH, side=tk.LEFT, expand=True)
self.canvas = FigureCanvasTkAgg(self.f, master=self.plotFrame)
# A frame containing the box with selected points
# and control buttons
self.pointFrame = tk.Frame(self.root)
self.pointFrame.pack(side=tk.LEFT, fill=tk.BOTH)
# Manage active component
self.activeCompoFrame = tk.Frame(self.pointFrame)
self.activeCompoFrame.pack(side=tk.TOP)
self.currentComponentLabel = tk.Label(self.activeCompoFrame,
text="Active component")
self.currentComponentLabel.pack(side=tk.TOP)
# De- and increase no. of active component
self.downACB = tk.Button(self.activeCompoFrame,
text="-",
command=self._downAC)
self._acstring = tk.StringVar()
self._acstring.set(str(self._activeComponent))
self.ACLabel = tk.Label(self.activeCompoFrame,
textvariable=self._acstring)
self.upACB = tk.Button(self.activeCompoFrame,
text="+",
command=self._upAC)
self.downACB.pack(side=tk.LEFT)
self.ACLabel.pack(side=tk.LEFT)
self.upACB.pack(side=tk.RIGHT)
# Show and work with parameters
self.parameterFrame = tk.Frame(self.pointFrame,
relief=tk.RAISED,
borderwidth=1)
self.parameterFrame.pack(side=tk.TOP)
# Headline
tk.Label(self.parameterFrame,
text="Parameters (active comp.)").pack(side=tk.TOP)
# List of parameters to show
pars = ["off"]
pars.extend(self._compPars)
self._parSelect = tk.IntVar()
# Frames for individual parameters
self._parFrames = []
self._parValues = []
self._parFreeVars = []
for i, p in enumerate(pars):
self._parFrames.append(tk.Frame(self.parameterFrame))
self._parFrames[-1].pack(side=tk.TOP)
b = tk.Radiobutton(self._parFrames[-1],
text="",
variable=self._parSelect,
value=i)
b.pack(side=tk.LEFT, anchor=tk.W)
l = tk.Label(self._parFrames[-1], text=("%3s" % p), width=3)
l.pack(side=tk.LEFT, anchor=tk.W)
self._parValues.append(tk.StringVar())
self._parValues[-1].set("0.0")
l = tk.Label(self._parFrames[-1],
textvariable=self._parValues[-1],
width=10)
l.pack(side=tk.LEFT)
self._parFreeVars.append(tk.IntVar())
c = tk.Checkbutton(self._parFrames[-1], text="free", variable=self._parFreeVars[-1], \
command=self._freeCheckboxClicked)
c.pack(side=tk.LEFT)
# Wheel modification
self._wheelModFrame = tk.Frame(self.pointFrame,
relief=tk.RAISED,
borderwidth=1)
self._wheelModFrame.pack(side=tk.TOP)
# Headline
tk.Label(self._wheelModFrame, text="Mouse wheel").pack(side=tk.TOP)
self._multAddSelect = tk.IntVar()
self._multAddSelect.set(1)
multiFrame = tk.Frame(self._wheelModFrame)
addFrame = tk.Frame(self._wheelModFrame)
multiFrame.pack(side=tk.TOP)
addFrame.pack(side=tk.TOP)
tk.Radiobutton(multiFrame,
text="multiply [%]",
variable=self._multAddSelect,
value=1,
width=9,
anchor=tk.W).pack(side=tk.LEFT)
tk.Radiobutton(addFrame,
text="add",
variable=self._multAddSelect,
value=2,
width=9,
anchor=tk.W).pack(side=tk.LEFT)
self._multNumber = tk.StringVar()
self._addNumber = tk.StringVar()
self._multNumber.set(str(self._config["defaultWheelMult"]))
self._addNumber.set(str(self._config["defaultWheelAdd"]))
self._multNumberEntry = tk.Entry(multiFrame,
textvariable=self._multNumber,
width=10)
self._multNumberEntry.pack(side=tk.RIGHT)
self._addNumberEntry = tk.Entry(addFrame,
textvariable=self._addNumber,
width=10)
self._addNumberEntry.pack(side=tk.RIGHT)
# Common width
if self._mode == "gauss":
commonSigFrame = tk.Frame(self.pointFrame)
commonSigFrame.pack(side=tk.TOP)
self._commonSig = tk.IntVar()
c = tk.Checkbutton(commonSigFrame, text="Common width (sig)", variable=self._commonSig, \
command=self._commonSigClicked)
c.pack(side=tk.LEFT)
# Fit button
self._fitButton = tk.Button(self.pointFrame,
text="Fit",
command=self._fitModel)
self._fitButton.pack(side=tk.TOP, fill=tk.X)
# Range button
self._rangeButton = tk.Button(self.pointFrame,
text="Set fit range",
command=self._rangeButtonClicked)
self._rangeButton.pack(side=tk.TOP, fill=tk.X)
# Remove button
self.removeButton = tk.Button(master=self.pointFrame, text="Remove component", \
command=self._removeButtonClicked)
self.removeButton.pack(side=tk.TOP, fill=tk.X)
# a tk.DrawingArea
self.canvas.get_tk_widget().pack()
self.cid = self.f.canvas.mpl_connect('button_press_event',
self._mouseButtonClicked)
self.mwe = self.f.canvas.mpl_connect('scroll_event', self._mouseWheel)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.plotFrame)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
def _quit():
# stops main loop
self.root.quit()
# this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
self.root.destroy()
self.quitButton = tk.Button(master=self.pointFrame,
text='Quit',
command=_quit)
self.quitButton.pack(side=tk.BOTTOM, fill=tk.X)
def __init__(self, parent, title, init_font, **kw):
# print init_font
kw = self.initKw(kw)
MfxDialog.__init__(self, parent, title, kw.resizable, kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
self.font_family = 'Helvetica'
self.font_size = 12
self.font_weight = 'normal'
self.font_slant = 'roman'
if init_font is not None:
assert 2 <= len(init_font) <= 4
assert isinstance(init_font[1], int)
self.font_family, self.font_size = init_font[:2]
if len(init_font) > 2:
if init_font[2] in ['bold', 'normal']:
self.font_weight = init_font[2]
elif init_font[2] in ['italic', 'roman']:
self.font_slant = init_font[2]
else:
raise ValueError('invalid font style: ' + init_font[2])
if len(init_font) > 3:
if init_font[3] in ['bold', 'normal']:
self.font_weight = init_font[3]
elif init_font[2] in ['italic', 'roman']:
self.font_slant = init_font[3]
else:
raise ValueError('invalid font style: ' + init_font[3])
# self.family_var = tkinter.StringVar()
self.weight_var = tkinter.BooleanVar()
self.slant_var = tkinter.BooleanVar()
self.size_var = tkinter.IntVar()
frame = tkinter.Frame(top_frame)
frame.pack(expand=True, fill='both', padx=5, pady=10)
frame.columnconfigure(0, weight=1)
# frame.rowconfigure(1, weight=1)
self.entry = tkinter.Entry(frame, bg='white')
self.entry.grid(row=0, column=0, columnspan=2, sticky='news')
self.entry.insert('end', _('abcdefghABCDEFGH'))
self.list_box = tkinter.Listbox(frame, width=36, exportselection=False)
sb = tkinter.Scrollbar(frame)
self.list_box.configure(yscrollcommand=sb.set)
sb.configure(command=self.list_box.yview)
self.list_box.grid(row=1, column=0, sticky='news') # rowspan=4
sb.grid(row=1, column=1, sticky='ns')
bind(self.list_box, '<<ListboxSelect>>', self.fontupdate)
# self.list_box.focus()
cb1 = tkinter.Checkbutton(frame,
anchor='w',
text=_('Bold'),
command=self.fontupdate,
variable=self.weight_var)
cb1.grid(row=2, column=0, columnspan=2, sticky='we')
cb2 = tkinter.Checkbutton(frame,
anchor='w',
text=_('Italic'),
command=self.fontupdate,
variable=self.slant_var)
cb2.grid(row=3, column=0, columnspan=2, sticky='we')
sc = tkinter.Scale(
frame,
from_=6,
to=40,
resolution=1,
# label='Size',
orient='horizontal',
command=self.fontupdate,
variable=self.size_var)
sc.grid(row=4, column=0, columnspan=2, sticky='news')
#
self.size_var.set(self.font_size)
self.weight_var.set(self.font_weight == 'bold')
self.slant_var.set(self.font_slant == 'italic')
font_families = list(tkinter_font.families())
font_families.sort()
selected = -1
n = 0
self.list_box.insert('end', *font_families)
for font in font_families:
if font.lower() == self.font_family.lower():
selected = n
break
n += 1
if selected >= 0:
self.list_box.select_set(selected)
self.list_box.see(selected)
#
focus = self.createButtons(bottom_frame, kw)
self.mainloop(focus, kw.timeout)
self.font = (self.font_family, self.font_size, self.font_slant,
self.font_weight)
transform = ttk.Combobox(master=root,
values=Abel_methods,
state="readonly",
width=10,
height=len(Abel_methods))
transform.current(2)
transform.place(anchor=tk.W, relx=0.67, rely=0.11)
# speed
tk.Button(master=root, text='speed distribution', command=_speed)\
.pack(anchor=tk.N)
# anisotropy
tk.Button(master=root, text='anisotropy parameter', command=_anisotropy)\
.pack(anchor=tk.N)
rmin = tk.Entry(master=root, text='rmin')
rmin.place(anchor=tk.W, relx=0.66, rely=0.16, width=40)
rmin.insert(0, 368)
tk.Label(master=root, text="to").place(relx=0.74, rely=0.14)
rmax = tk.Entry(master=root, text='rmax')
rmax.place(anchor=tk.W, relx=0.78, rely=0.16, width=40)
rmax.insert(0, 389)
tk.Button(master=root, text='Quit', command=_quit).pack(anchor=tk.SW)
# a tk.DrawingArea ---------------
canvas = FigureCanvasTkAgg(f, master=root)
a.annotate("load image file", (0.5, 0.6), horizontalalignment="center")
a.annotate("e.g. data/O2-ANU1024.txt.bz2", (0.5, 0.5),
horizontalalignment="center")
canvas.draw()
