def createWidgets(self):
self.widgets = {
"plk": PlkWidget(master=self.mainFrame),
"par": ParWidget(master=self.mainFrame),
"tim": TimWidget(master=self.mainFrame),
}
self.active = {"plk": tk.IntVar(), "par": tk.IntVar(), "tim": tk.IntVar()}
self.active["plk"].set(1)
def _menus(self):
# menus with callback ----------------
# duplicates the button interface
self.menubar = tk.Menu(self.parent)
self.transform_method = tk.IntVar()
self.center_method = tk.IntVar()
# File - menu
self.filemenu = tk.Menu(self.menubar, tearoff=0)
self.filemenu.add_command(label="Load image file",
command=self._loadimage)
self.filemenu.add_separator()
self.filemenu.add_command(label="Exit", command=self._quit)
self.menubar.add_cascade(label="File", menu=self.filemenu)
# Process - menu
self.processmenu = tk.Menu(self.menubar, tearoff=0)
# self.processmenu.add_command(label="Center image",
# command=self._center)
self.subcent = tk.Menu(self.processmenu)
for cent in center_methods:
self.subcent.add_radiobutton(label=cent,
var=self.center_method,
val=center_methods.index(cent),
command=self._center)
self.processmenu.add_cascade(label="Center image",
menu=self.subcent,
underline=0)
self.submenu = tk.Menu(self.processmenu)
for method in Abel_methods:
self.submenu.add_radiobutton(label=method,
var=self.transform_method,
val=Abel_methods.index(method),
command=self._transform)
self.processmenu.add_cascade(label="Inverse Abel transform",
menu=self.submenu,
underline=0)
self.processmenu.add_command(label="Speed distribution",
command=self._speed)
self.processmenu.add_command(label="Angular distribution",
command=self._anisotropy)
self.angmenu = tk.Menu(self.processmenu)
self.menubar.add_cascade(label="Processing", menu=self.processmenu)
# view - menu
self.viewmenu = tk.Menu(self.menubar, tearoff=0)
self.viewmenu.add_command(label="Raw image", command=self._display)
self.viewmenu.add_command(label="Inverse Abel transformed image",
command=self._transform)
self.viewmenu.add_command(label="view buttons",
command=self._on_buttons)
self.menubar.add_cascade(label="View", menu=self.viewmenu)
def __init__(self, master, naxes):
self._master = master
self._naxes = naxes
self._mbar = Tk.Frame(master=master, relief=Tk.RAISED, borderwidth=2)
self._mbar.pack(side=Tk.LEFT)
self._mbutton = Tk.Menubutton(master=self._mbar,
text="Axes",
underline=0)
self._mbutton.pack(side=Tk.LEFT, padx="2m")
self._mbutton.menu = Tk.Menu(self._mbutton)
self._mbutton.menu.add_command(label="Select All",
command=self.select_all)
self._mbutton.menu.add_command(label="Invert All",
command=self.invert_all)
self._axis_var = []
self._checkbutton = []
for i in range(naxes):
self._axis_var.append(Tk.IntVar())
self._axis_var[i].set(1)
self._checkbutton.append(
self._mbutton.menu.add_checkbutton(label="Axis %d" % (i + 1),
variable=self._axis_var[i],
command=self.set_active))
self._mbutton.menu.invoke(self._mbutton.menu.index("Select All"))
self._mbutton['menu'] = self._mbutton.menu
self._mbar.tk_menuBar(self._mbutton)
self.set_active()
def __init__(self, parent, opname, interrupt=True, **kwargs):
self.maximum = 100
self.toplevel = tk.Toplevel(parent, **kwargs)
self.toplevel.title(opname)
self.toplevel.transient(parent)
self.opname = opname
self.count = tk.IntVar()
self.label = tk.Label(self.toplevel, text=opname + ' progress: 0%')
self.label.pack()
self.count.set(-1)
self.progress = ttk.Progressbar(self.toplevel, orient='horizontal',
mode='determinate',
variable=self.count,
maximum=self.maximum)
self.progress.pack(expand=True, fill=tk.BOTH, side=tk.TOP)
self.interrupted = False
if interrupt:
interrupt_btn = tk.Button(self.toplevel, text='Interrupt',
command=self.interrupt)
interrupt_btn.pack()
def wrap_value(value):
"""Wrap a value as a Tk variable, or nested structure thereof.
String values will automatically be stripped.
"""
if isinstance(value, collections.Mapping):
wrapped = wrap_dict(value)
elif isinstance(value, list):
wrapped = wrap_list(value)
elif isinstance(value, str):
wrapped = T.StringVar()
wrapped.set(value.strip())
elif isinstance(value, float):
wrapped = T.DoubleVar()
wrapped.set(value)
elif isinstance(value, six.integer_types):
wrapped = T.IntVar()
wrapped.set(value)
elif isinstance(value, bool):
wrapped = T.BooleanVar()
wrapped.set(value)
elif is_tkinter_variable(value):
# Clone the particular type of tkinter variable
wrapped = get_tk_type(value)()
value = value.get()
if hasattr(value, 'strip'):
value = value.strip()
wrapped.set(value)
else:
raise ValueError('Unexpected metadata item {} of type {}'.format(
value, type(value)))
return wrapped
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 _Button(self, text, image_file, toggle, frame):
if image_file is not None:
im = Tk.PhotoImage(master=self, file=image_file)
else:
im = None
if not toggle:
b = Tk.Button(master=frame,
text=text,
padx=2,
pady=2,
image=im,
command=lambda: self._button_click(text))
else:
# There is a bug in tkinter included in some python 3.6 versions
# that without this variable, produces a "visual" toggling of
# other near checkbuttons
# https://bugs.python.org/issue29402
# https://bugs.python.org/issue25684
var = Tk.IntVar()
b = Tk.Checkbutton(master=frame,
text=text,
padx=2,
pady=2,
image=im,
indicatoron=False,
command=lambda: self._button_click(text),
variable=var)
b._ntimage = im
b.pack(side=Tk.LEFT)
return b
def addFitCheckBoxes(self, model):
'''
Add the fitting checkboxes for the given model to the frame
'''
self.deleteFitCheckBoxes()
self.compGrids = []
self.compCBs = []
self.compVisible = []
self.parVars = {}
ii = 0
comps = model.components.keys()
fitparams = [p for p in model.params if not getattr(model, p).frozen]
for comp in comps:
showpars = [p for p in model.components[comp].params \
if not p in pulsar.nofitboxpars and getattr(model, p).quantity is not None]
#Don't bother showing components without any fittable parameters
if len(showpars) == 0:
continue
self.compVisible.append(tk.IntVar())
self.compCBs.append(
tk.Checkbutton(self,
text=comp,
variable=self.compVisible[ii],
command=self.updateLayout))
self.compGrids.append([])
for pp, par in enumerate(showpars):
self.parVars[par] = tk.IntVar()
self.compGrids[ii].append(
tk.Checkbutton(
self,
text=par,
variable=self.parVars[par],
command=lambda p=par: self.changedFitCheckBox(p)))
if par in fitparams:
self.compCBs[ii].select()
self.compGrids[ii][pp].select()
ii += 1
self.updateLayout()
def adjust(self, naxes):
if self._naxes < naxes:
for i in range(self._naxes, naxes):
self._axis_var.append(Tk.IntVar())
self._axis_var[i].set(1)
self._checkbutton.append( self._mbutton.menu.add_checkbutton(
label = "Axis %d" % (i+1),
variable=self._axis_var[i],
command=self.set_active))
elif self._naxes > naxes:
for i in range(self._naxes-1, naxes-1, -1):
del self._axis_var[i]
self._mbutton.menu.forget(self._checkbutton[i])
del self._checkbutton[i]
self._naxes = naxes
self.set_active()
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, opname, **kwargs):
self.maximum = 100
self.toplevel = tk.Toplevel(parent, **kwargs)
self.toplevel.transient(parent)
self.opname = opname
self.count = tk.IntVar()
self.label = tk.Label(self.toplevel, text=opname + ' progress: 0%')
self.label.pack()
self.progress = ttk.Progressbar(self.toplevel,
orient='horizontal',
mode='determinate',
variable=self.count,
maximum=self.maximum)
self.progress.pack(expand=True, fill=tk.BOTH, side=tk.TOP)
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 = ttk.Frame(top_frame)
frame.pack(expand=True, fill='both', padx=10, pady=10)
frame.columnconfigure(0, weight=1)
notebook = ttk.Notebook(frame)
notebook.pack(expand=True, fill='both')
for w in WizardWidgets:
if isinstance(w, six.string_types):
frame = ttk.Frame(notebook)
notebook.add(frame, text=w, sticky='nsew', padding=5)
frame.columnconfigure(1, weight=1)
row = 0
continue
ttk.Label(frame, text=w.label).grid(row=row, column=0)
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(e, w=w):
self.presetSelected(e, w)
cb = PysolCombo(frame,
values=tuple(values),
textvariable=w.variable,
exportselection=False,
selectcommand=callback,
state='readonly',
width=32)
cb.grid(row=row, column=1, sticky='ew', padx=2, pady=2)
elif w.widget == 'entry':
if w.variable is None:
w.variable = tkinter.StringVar()
en = ttk.Entry(frame, textvariable=w.variable)
en.grid(row=row, column=1, sticky='ew', padx=2, pady=2)
elif w.widget == 'menu':
if w.variable is None:
w.variable = tkinter.StringVar()
values = [_(v) for v in w.values]
cb = PysolCombo(frame,
values=tuple(values),
textvariable=w.variable,
exportselection=False,
state='readonly',
width=32)
cb.grid(row=row, column=1, sticky='ew', padx=2, pady=2)
elif w.widget == 'spin':
if w.variable is None:
w.variable = tkinter.IntVar()
else:
# delete all trace callbacks
for mod, cbname in w.variable.trace_vinfo():
w.variable.trace_vdelete(mod, cbname)
from_, to = w.values
# s = Spinbox(
# frame, textvariable=w.variable, from_=from_, to=to)
s = PysolScale(frame,
from_=from_,
to=to,
resolution=1,
orient='horizontal',
variable=w.variable)
s.grid(row=row, column=1, sticky='ew', padx=2, pady=2)
elif w.widget == 'check':
if w.variable is None:
w.variable = tkinter.BooleanVar()
ch = ttk.Checkbutton(frame,
variable=w.variable,
takefocus=False)
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'):
v = _(v)
w.variable.set(v)
row += 1
focus = self.createButtons(bottom_frame, kw)
self.mainloop(focus, kw.timeout)
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.weight_var.set(self.font_weight == 'bold')
self.slant_var = tkinter.BooleanVar()
self.slant_var.set(self.font_slant == 'italic')
self.size_var = tkinter.IntVar()
self.size_var.set(self.font_size)
#
frame = ttk.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 = ttk.Entry(frame)
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 = ttk.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 = ttk.Checkbutton(frame,
text=_('Bold'),
command=self.fontupdate,
variable=self.weight_var)
cb1.grid(row=2, column=0, columnspan=2, sticky='we')
cb2 = ttk.Checkbutton(frame,
text=_('Italic'),
command=self.fontupdate,
variable=self.slant_var)
cb2.grid(row=3, column=0, columnspan=2, sticky='we')
sc = PysolScale(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')
#
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)
def __init__(self, parent, app, **kw):
self.parent = parent
self.app = app
title = _('%(app)s - FreeCell Solver') % {'app': TITLE}
kw = self.initKw(kw)
self._calc_MfxDialog().__init__(self, parent, title, kw.resizable,
kw.default)
top_frame, bottom_frame = self.createFrames(kw)
self.createBitmaps(top_frame, kw)
self.games = {} # key: gamename; value: gameid
#
frame = self._calcToolkit().Frame(top_frame)
frame.pack(expand=True, fill='both', padx=4, pady=4)
frame.columnconfigure(1, weight=1)
#
row = 0
self._calcToolkit().Label(frame, text=_('Game:'),
anchor='w').grid(row=row,
column=0,
sticky='ew',
padx=2,
pady=2)
games = app.getGamesForSolver()
gamenames = ['']
for id in games:
name = app.getGameTitleName(id)
gamenames.append(name)
self.games[name] = id
gamenames.sort()
self.gamenames = gamenames
self.games_var = self._createGamesVar(frame, row)
#
row += 1
self._calcToolkit().Label(frame, text=_('Preset:'),
anchor='w').grid(row=row,
column=0,
sticky='ew',
padx=2,
pady=2)
presets = app.opt.solver_presets
self.presets = presets
self.preset_var = self._createPresetVar(frame, row)
self.preset_var.set(self.app.opt.solver_preset)
#
row += 1
self.max_iters_var = tkinter.IntVar()
self.max_iters_var.set(self.app.opt.solver_max_iterations)
self._calcToolkit().Label(frame, text=_('Max iterations:'),
anchor='w').grid(row=row,
column=0,
sticky='ew',
padx=2,
pady=2)
spin = tkinter.Spinbox(frame,
bg='white',
from_=1000,
to=10e6,
increment=1000,
textvariable=self.max_iters_var)
self.max_iters_var.trace('w', self._OnAssignToMaxIters)
spin.grid(row=row, column=1, sticky='w', padx=2, pady=2)
#
row += 1
self.progress_var = tkinter.BooleanVar()
self.progress_var.set(self.app.opt.solver_show_progress)
w = self._createShowProgressButton(frame)
w.grid(row=row, column=0, columnspan=2, sticky='ew', padx=2, pady=2)
w.config(command=self._ToggleShowProgressButton)
#
label_frame = self._calcToolkit().LabelFrame(top_frame,
text=_('Progress'))
label_frame.pack(expand=True, fill='both', padx=6, pady=2)
# label_frame.columnconfigure(0, weight=1)
label_frame.columnconfigure(1, weight=1)
#
frow = 0
self._calcToolkit().Label(label_frame,
text=_('Iteration:'),
anchor='w').grid(row=frow,
column=0,
sticky='ew',
padx=4,
pady=2)
lb = self._calcToolkit().Label(label_frame, anchor='w')
lb.grid(row=frow, column=1, sticky='ew', padx=4, pady=2)
self.iter_label = lb
frow += 1
self._calcToolkit().Label(label_frame, text=_('Depth:'),
anchor='w').grid(row=frow,
column=0,
sticky='ew',
padx=4,
pady=2)
lb = self._calcToolkit().Label(label_frame, anchor='w')
lb.grid(row=frow, column=1, sticky='ew', padx=4, pady=2)
self.depth_label = lb
frow += 1
self._calcToolkit().Label(label_frame,
text=_('Stored-States:'),
anchor='w').grid(row=frow,
column=0,
sticky='ew',
padx=4,
pady=2)
lb = self._calcToolkit().Label(label_frame, anchor='w')
lb.grid(row=frow, column=1, sticky='ew', padx=4, pady=2)
self.states_label = lb
#
lb = self._calcToolkit().Label(top_frame, anchor='w')
lb.pack(expand=True, fill='x', padx=6, pady=4)
self.result_label = lb
#
focus = self.createButtons(bottom_frame, kw)
self.start_button = self.buttons[0]
self.play_button = self.buttons[1]
self._reset()
self.connectGame(self.app.game)
self.mainloop(focus, kw.timeout, transient=False)
def __init__(self, parent, title, app, **kw):
self.app = app
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.saved_opt = app.opt.copy()
self.sound = tkinter.BooleanVar()
self.sound.set(app.opt.sound != 0)
self.sound_mode = tkinter.BooleanVar()
self.sound_mode.set(app.opt.sound_mode != 0)
self.sample_volume = tkinter.IntVar()
self.sample_volume.set(app.opt.sound_sample_volume)
self.music_volume = tkinter.IntVar()
self.music_volume.set(app.opt.sound_music_volume)
self.samples = [
('areyousure', _('Are You Sure'), tkinter.BooleanVar()),
('deal', _('Deal'), tkinter.BooleanVar()),
('dealwaste', _('Deal waste'), tkinter.BooleanVar()),
('turnwaste', _('Turn waste'), tkinter.BooleanVar()),
('startdrag', _('Start drag'), tkinter.BooleanVar()),
('drop', _('Drop'), tkinter.BooleanVar()),
('droppair', _('Drop pair'), tkinter.BooleanVar()),
('autodrop', _('Auto drop'), tkinter.BooleanVar()),
('flip', _('Flip'), tkinter.BooleanVar()),
('autoflip', _('Auto flip'), tkinter.BooleanVar()),
('move', _('Move'), tkinter.BooleanVar()),
('nomove', _('No move'), tkinter.BooleanVar()),
('undo', _('Undo'), tkinter.BooleanVar()),
('redo', _('Redo'), tkinter.BooleanVar()),
('autopilotlost', _('Autopilot lost'), tkinter.BooleanVar()),
('autopilotwon', _('Autopilot won'), tkinter.BooleanVar()),
('gamefinished', _('Game finished'), tkinter.BooleanVar()),
('gamelost', _('Game lost'), tkinter.BooleanVar()),
('gamewon', _('Game won'), tkinter.BooleanVar()),
('gameperfect', _('Perfect game'), tkinter.BooleanVar()),
('extra', _('Other'), tkinter.BooleanVar()),
]
#
frame = tkinter.Frame(top_frame)
frame.pack(expand=True, fill='both', padx=5, pady=5)
frame.columnconfigure(1, weight=1)
#
row = 0
w = tkinter.Checkbutton(frame, variable=self.sound,
text=_("Sound enabled"), anchor='w')
w.grid(row=row, column=0, columnspan=2, sticky='ew')
#
if os.name == "nt" and pysolsoundserver:
row += 1
w = tkinter.Checkbutton(frame, variable=self.sound_mode,
text=_("Use DirectX for sound playing"),
command=self.mOptSoundDirectX, anchor='w')
w.grid(row=row, column=0, columnspan=2, sticky='ew')
#
if app.audio.CAN_PLAY_MUSIC: # and app.startup_opt.sound_mode > 0:
row += 1
w = tkinter.Label(frame, text=_('Sample volume:'))
w.grid(row=row, column=0, sticky='w', padx=5)
w = tkinter.Scale(frame, from_=0, to=128, resolution=1,
orient='horizontal', takefocus=0,
length="3i", # label=_('Sample volume'),
variable=self.sample_volume)
w.grid(row=row, column=1, sticky='ew', padx=5)
row += 1
w = tkinter.Label(frame, text=_('Music volume:'))
w.grid(row=row, column=0, sticky='w', padx=5)
w = tkinter.Scale(frame, from_=0, to=128, resolution=1,
orient='horizontal', takefocus=0,
length="3i", # label=_('Music volume'),
variable=self.music_volume)
w.grid(row=row, column=1, sticky='ew', padx=5)
else:
# remove "Apply" button
kw.strings[1] = None
#
frame = tkinter.LabelFrame(top_frame, text=_('Enable samles'),
padx=5, pady=5)
frame.pack(expand=True, fill='both', padx=5, pady=5)
frame.columnconfigure(0, weight=1)
frame.columnconfigure(1, weight=1)
#
row = 0
col = 0
for n, t, v in self.samples:
v.set(app.opt.sound_samples[n])
w = tkinter.Checkbutton(frame, text=t, anchor='w', variable=v)
w.grid(row=row, column=col, sticky='ew')
if col == 1:
col = 0
row += 1
else:
col = 1
#
top_frame.columnconfigure(1, weight=1)
#
focus = self.createButtons(bottom_frame, kw)
self.mainloop(focus, kw.timeout)
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, 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)
def create_widgets():
global list_box, canvas, label, zoom_label
#
root = tkinter.Tk()
#
list_box = tkinter.Listbox(root, exportselection=False)
list_box.grid(row=0, column=0, rowspan=2, sticky=tkinter.NS)
cardsets_list = list(cardsets_dict)
cardsets_list.sort()
for cs in cardsets_list:
list_box.insert(tkinter.END, cs)
list_box.bind('<<ListboxSelect>>', show_cardset)
#
sb = tkinter.Scrollbar(root)
sb.grid(row=0, column=1, rowspan=2, sticky=tkinter.NS)
list_box.config(yscrollcommand=sb.set)
sb.config(command=list_box.yview)
#
canvas = tkinter.Canvas(root, bg='#5eab6b')
canvas.grid(row=0, column=2, sticky=tkinter.NSEW)
canvas.bind('<4>', lambda e: canvas.yview_scroll(-5, 'unit'))
canvas.bind('<5>', lambda e: canvas.yview_scroll(5, 'unit'))
#
sb = tkinter.Scrollbar(root)
sb.grid(row=0, column=3, sticky=tkinter.NS)
canvas.config(yscrollcommand=sb.set)
sb.config(command=canvas.yview)
#
if True:
sb = tkinter.Scrollbar(root, orient=tkinter.HORIZONTAL)
sb.grid(row=1, column=2, sticky=tkinter.EW)
canvas.config(xscrollcommand=sb.set)
sb.config(command=canvas.xview)
#
label = tkinter.Label(root)
label.grid(row=2, column=0, columnspan=4)
#
b_frame = tkinter.Frame(root)
b_frame.grid(row=3, column=0, columnspan=4, sticky=tkinter.EW)
button = tkinter.Button(b_frame, text='Quit', command=root.quit, width=8)
button.pack(side=tkinter.RIGHT)
button = tkinter.Button(b_frame, text='Info', command=show_info, width=8)
button.pack(side=tkinter.RIGHT)
if Image:
global rotate_var, filter_var
rotate_var = tkinter.IntVar(root)
filter_var = tkinter.StringVar(root)
button = tkinter.Button(b_frame, text=' + ', command=zoom_in)
button.pack(side=tkinter.LEFT)
button = tkinter.Button(b_frame, text=' - ', command=zoom_out)
button.pack(side=tkinter.LEFT)
button = tkinter.Button(b_frame, text=' = ', command=zoom_cancel)
button.pack(side=tkinter.LEFT)
button = tkinter.Checkbutton(b_frame,
text='Rotate',
indicatoron=0,
selectcolor=b_frame['bg'],
width=8,
variable=rotate_var,
command=show_cardset)
button.pack(side=tkinter.LEFT, fill='y')
om = tkinter.OptionMenu(b_frame,
filter_var,
'NEAREST',
'BILINEAR',
'BICUBIC',
'ANTIALIAS',
command=show_cardset)
filter_var.set('NEAREST')
om.pack(side=tkinter.LEFT, fill='y')
zoom_label = tkinter.Label(b_frame)
zoom_label.pack(side=tkinter.LEFT)
#
root.columnconfigure(2, weight=1)
root.rowconfigure(0, weight=1)
root.title('Show Cardsets')
return root
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, cardset, images, **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 = ttk.Frame(top_frame)
frame.pack(fill="both", expand=True, padx=5, pady=10)
#
#
row = 0
info_frame = ttk.LabelFrame(frame, text=_('About cardset'))
info_frame.grid(row=row, column=0, columnspan=2, sticky='ew',
padx=0, pady=5, ipadx=5, ipady=5)
row += 1
styles = nationalities = year = None
if cardset.si.styles:
styles = '\n'.join([CSI.STYLE[i] for i in cardset.si.styles])
if cardset.si.nationalities:
nationalities = '\n'.join([CSI.NATIONALITY[i]
for i in cardset.si.nationalities])
if cardset.year:
year = str(cardset.year)
frow = 0
for n, t in (
# ('Version:', str(cardset.version)),
(_('Type:'), CSI.TYPE[cardset.type]),
(_('Styles:'), styles),
(_('Nationality:'), nationalities),
(_('Year:'), year),
# (_('Number of cards:'), str(cardset.ncards)),
(_('Size:'), '%d x %d' % (cardset.CARDW, cardset.CARDH)),
):
if t is not None:
label = ttk.Label(info_frame, text=n,
anchor='w', justify='left')
label.grid(row=frow, column=0, sticky='nw', padx=4)
label = ttk.Label(info_frame, text=t,
anchor='w', justify='left')
label.grid(row=frow, column=1, sticky='nw', padx=4)
frow += 1
if images:
try:
from random import choice
im = choice(images)
f = os.path.join(cardset.dir, cardset.backname)
self.back_image = loadImage(file=f) # store the image
label = ttk.Label(info_frame, image=im, padding=5)
label.grid(row=0, column=2, rowspan=frow+1, sticky='ne')
label = ttk.Label(info_frame, image=self.back_image,
padding=(0, 5, 5, 5)) # left margin = 0
label.grid(row=0, column=3, rowspan=frow+1, sticky='ne')
info_frame.columnconfigure(2, weight=1)
info_frame.rowconfigure(frow, weight=1)
except Exception:
pass
if USE_PIL:
padx = 4
pady = 0
settings_frame = ttk.LabelFrame(frame, text=_('Settings'))
settings_frame.grid(row=row, column=0, columnspan=2, sticky='ew',
padx=0, pady=5, ipadx=5, ipady=5)
row += 1
var = tkinter.IntVar()
self.x_offset = PysolScale(
settings_frame, label=_('X offset:'),
from_=5, to=40, resolution=1,
orient='horizontal', variable=var,
value=cardset.CARD_XOFFSET,
# command=self._updateScale
)
self.x_offset.grid(row=0, column=0, sticky='ew',
padx=padx, pady=pady)
var = tkinter.IntVar()
self.y_offset = PysolScale(
settings_frame, label=_('Y offset:'),
from_=5, to=40, resolution=1,
orient='horizontal', variable=var,
value=cardset.CARD_YOFFSET,
# command=self._updateScale
)
self.y_offset.grid(row=1, column=0, sticky='ew',
padx=padx, pady=pady)
row += 1
# bg = top_frame["bg"]
bg = 'white'
text_w = tkinter.Text(frame, bd=1, relief="sunken", wrap="word",
padx=4, width=64, height=16, bg=bg)
text_w.grid(row=row, column=0, sticky='nsew')
sb = ttk.Scrollbar(frame)
sb.grid(row=row, column=1, sticky='ns')
text_w.configure(yscrollcommand=sb.set)
sb.configure(command=text_w.yview)
frame.columnconfigure(0, weight=1)
frame.rowconfigure(1, weight=1)
#
text = ''
fn = os.path.join(cardset.dir, "COPYRIGHT")
try:
with open(fn, "rt") as fh:
text = fh.read()
except Exception:
pass
if text:
text_w.config(state="normal")
text_w.insert("insert", text)
text_w.config(state="disabled")
#
focus = self.createButtons(bottom_frame, kw)
# focus = text_w
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 = 5, 5
if self.TreeDataHolder_Class.data is None:
self.TreeDataHolder_Class.data = self.TreeData_Class(manager, key)
#
self.top.wm_minsize(400, 200)
if self.top.winfo_screenwidth() >= 800:
w1, w2 = 240, 400
else:
w1, w2 = 200, 300
paned_window = ttk.PanedWindow(top_frame, orient='horizontal')
paned_window.pack(expand=True, fill='both')
left_frame = ttk.Frame(paned_window)
right_frame = ttk.Frame(paned_window)
paned_window.add(left_frame)
paned_window.add(right_frame)
font = app.getFont("default")
self.tree = self.Tree_Class(self,
left_frame,
key=key,
default=kw.default,
font=font,
width=w1)
self.tree.frame.grid(row=0,
column=0,
sticky='nsew',
padx=padx,
pady=pady)
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, width=w2)
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)
