def new_settings(self):
self.settingsWindow = tk.Toplevel(self.root)
self.settingsWindow.title("Scheduler Settings")
self.settingsWindow.geometry("400x200")
# Configure time length
# self.new_bio_entry = tk.Entry(self.settingsWindow, width=50)
# self.new_bio_entry.pack()
# ! convert this to # of weeks / week label
self.start_hour = ttk.Spinbox(master=settingsWindow,
from_=1,
to=4,
wrap=True,
width=5,
state="readonly")
self.start_hour.set(1)
self.start_hour.pack(padx=5)
self.start_min = ttk.Spinbox(master=settingsWindow,
from_=0,
to=59,
wrap=True,
width=3,
state="readonly")
self.start_min.set(0)
self.start_min.pack(side=tk.LEFT, padx=5)
# Confirm button
self.change_bio_btn = tk.Button(self.settingsWindow,
text="Update bio",
width=25,
command=self.save_bio)
self.change_bio_btn.pack(pady=5)
def __init__(self, *args, **kwargs):
ttk.Frame.__init__(self, *args, **kwargs)
self.block_size_var = tk.IntVar()
block_size_label = ttk.Label(self, text='Block Size')
block_size_spinbox = ttk.Spinbox(self,
textvariable=self.block_size_var,
justify=tk.CENTER,
from_=5,
to_=100)
int_validate(block_size_spinbox, (5, 50))
self.block_size_var.set(30)
self.speed_var = tk.IntVar()
speed_label = ttk.Label(self, text='Speed')
speed_spinbox = ttk.Spinbox(self,
textvariable=self.speed_var,
justify=tk.CENTER,
from_=1,
to_=30)
int_validate(speed_spinbox, (5, 50))
self.speed_var.set(1)
self.message = tk.Message(self, font=('consolas', 10))
self.button_start = ttk.Button(self, text='Start')
block_size_label.pack()
block_size_spinbox.pack(pady=(0, 10))
speed_label.pack()
speed_spinbox.pack(pady=(0, 10))
self.message.pack(fill=tk.BOTH)
self.button_start.pack(pady=(6, 10))
def __init__(self, parent):
# instantiate variables
today = datetime.date.today()
self.year, self.month, self.day = tk.IntVar(), tk.StringVar(
), tk.IntVar()
self.days = list(range(1, monthrange(today.year, today.month)[1] + 1))
# set current year / month / day to current date
self.year.set(today.year)
self.month.set(month_name[today.month])
self.day.set(today.day)
# year label
ttk.Label(parent, text="Year:").grid(row=0, column=0, sticky=tk.W)
ttk.Spinbox(parent, textvariable=self.year,
values=(today.year - 1, today.year, today.year + 1)) \
.grid(row=0, column=1)
# month label
ttk.Label(parent, text="Month:").grid(row=1, column=0, sticky=tk.W)
ttk.Combobox(parent, textvariable=self.month, state='readonly',
values=[month_name[i] for i in range(1, 13)]) \
.grid(row=1, column=1)
# day label
ttk.Label(parent, text="Day:").grid(row=2, column=0, sticky=tk.W)
self.day_picker = ttk.Spinbox(parent,
values=self.days,
textvariable=self.day)
self.day_picker.grid(row=2, column=1)
# add function bindings to year / month selectors
self.year.trace('w', self._update_days)
self.month.trace('w', self._update_days)
def __init__(self, master: tk.Widget):
# Variables
self.var_time = tk.DoubleVar(master)
self.var_step = tk.DoubleVar(master)
# Elements
self.time_label = ttk.Label(master, text="Durée", width=cst.W_LABEL)
self.time_spin = ttk.Spinbox(master,
textvariable=self.var_time,
width=cst.W_SPINBOX)
self.time_unit = ttk.Label(master, text="s", width=cst.W_UNIT)
self.step_label = ttk.Label(master, text="Pas", width=cst.W_LABEL)
self.step_spin = ttk.Spinbox(master,
textvariable=self.var_step,
width=cst.W_SPINBOX)
self.step_unit = ttk.Label(master, text="s", width=cst.W_UNIT)
# Place the elements
self.time_label.grid(row=0, column=0)
self.time_spin.grid(row=0, column=1)
self.time_unit.grid(row=0, column=2)
self.step_label.grid(row=1, column=0)
self.step_spin.grid(row=1, column=1)
self.step_unit.grid(row=1, column=2)
def __init__(self, container: tkContainer, spin_cb: Callable[[], None]):
super().__init__(container, padding=5, text="File information")
self.columnconfigure(1, weight=1)
for row in range(0, 7):
self.rowconfigure(row, weight=1)
self.meet = tk.IntVar(self)
tk.Label(self, text="Meet:").grid(column=0, row=0, sticky="w")
tk.Label(self, textvariable=self.meet).grid(column=1, row=0, sticky="w")
self.race = tk.IntVar(self)
tk.Label(self, text="Race:").grid(column=0, row=1, sticky="w")
tk.Label(self, textvariable=self.race).grid(column=1, row=1, sticky="w")
self.date = tk.StringVar(self)
tk.Label(self, text="Date:").grid(column=0, row=2, sticky="w")
tk.Label(self, textvariable=self.date).grid(column=1, row=2, sticky="w")
self.time = tk.StringVar(self)
tk.Label(self, text="Time:").grid(column=0, row=3, sticky="w")
tk.Label(self, textvariable=self.time).grid(column=1, row=3, sticky="w")
ttk.Separator(self, orient="horizontal").grid(column=0, row=4,
columnspan=2, sticky="ew")
tk.Label(self, text="Event:").grid(column=0, row=5, sticky="w")
self.event = tk.StringVar(self)
ev_spin = ttk.Spinbox(self, increment=1, from_=1, to=999, width=4,
justify="right", textvariable=self.event,
command=spin_cb)
ev_spin.grid(column=1, row=5, sticky="w")
tk.Label(self, text="Heat:").grid(column=0, row=6, sticky="w")
self.heat = tk.IntVar(self)
h_spin = ttk.Spinbox(self, increment=1, from_=1, to=999, width=4,
justify="right",textvariable=self.heat,
command=spin_cb)
h_spin.grid(column=1, row=6, sticky="w")
def _make_counter_widgets(self):
"""Create and set counter widgets."""
counter_lframe = ttk.LabelFrame(self.right_panel,
text=_("Counter"),
padding=(5, 5, 5, 12))
counter_lframe.pack(fill="x")
start_frm = ttk.Frame(counter_lframe)
start_frm.pack(fill="x")
start_lbl = ttk.Label(start_frm, text=_("Start at:"))
start_lbl.pack(anchor="w", side="left")
self.start_sbox = ttk.Spinbox(start_frm, from_=0, to=1000, width=6)
self.start_sbox.insert(0, 1)
self.start_sbox.pack(side="right")
step_frm = ttk.Frame(counter_lframe)
step_frm.pack(fill="x", pady=2)
step_lbl = ttk.Label(step_frm, text=_("Step by:"))
step_lbl.pack(anchor="w", side="left")
self.step_sbox = ttk.Spinbox(step_frm, from_=1, to=100, width=6)
self.step_sbox.insert(0, 1)
self.step_sbox.pack(side="right", pady=5)
digits_frm = ttk.Frame(counter_lframe)
digits_frm.pack(fill="x")
digits_lbl = ttk.Label(digits_frm, text=_("Digits:"))
digits_lbl.pack(side="left")
self.digits_sbox = ttk.Spinbox(digits_frm, from_=0, to=5, width=6)
self.digits_sbox.insert(0, 2)
self.digits_sbox.pack(side="right")
def setup(self):
lbl = ttk.Label(self.frame)
lbl.grid(row=0, column=0)
lbl['textvariable'] = self.z_stage_readout
up_btn = ttk.Button(self.frame, text='Up', command=lambda: self.rel_z(1))
up_btn.grid(column=0, row=1)
down_btn = ttk.Button(self.frame, text='Down', command=lambda: self.rel_z(-1))
down_btn.grid(column=0, row=2)
lbl_z = ttk.Label(self.frame, text="Step mm: ")
lbl_z.grid(column=1, row=0)
spin_z = ttk.Spinbox(self.frame, from_=0, to_=10 ** 9, increment=0.05)
spin_z.grid(column=1, row=1)
self.z_step = spin_z
lbl_z = ttk.Label(self.frame, text="{} Z position: ".format(self.name))
lbl_z.grid(column=0, row=3)
spin_z = ttk.Spinbox(self.frame, from_=-10 ** 9, to=10 ** 9, increment=0.05)
spin_z.set(0)
spin_z.grid(column=1, row=3)
self.z_abs = spin_z
lbl_z_unit = ttk.Label(self.frame, text=" mm ")
lbl_z_unit.grid(column=2, row=3)
go_btn = ttk.Button(self.frame, text="Go", command=self.go_abs)
go_btn.grid(column=1, row=4)
startup = ttk.Button(self.frame, text='Startup', command=self.startup_command)
startup.grid(column=0, row=4)
def radioButtonEventDuration(radioButtonHour, radioButtonDuration, variableRadioButtonDuration, frameDuration, infoToSave, screenFormCreateLog):
for widget in frameDuration.winfo_children():
widget.destroy()
if variableRadioButtonDuration.get() == '0':
labelTimeElapsed = tk.Label(frameDuration, text = "Durada (h,m,s)").grid(row=1, column=0, padx=4, pady=10)
hourPicker = ttk.Spinbox(frameDuration, from_=0, to=23, wrap=True, width=5, state="readonly")
hourPicker['command'] = functools.partial(getDuration,hourPicker, 'hora', infoToSave)
hourPicker.grid(row=1, column=1)
tk.Label(frameDuration, text="h").grid(row=1,column=2)
minutePicker = ttk.Spinbox(frameDuration, from_=0, to=59, wrap=True, width=5, state="readonly")
minutePicker['command'] = functools.partial(getDuration, minutePicker, 'minuts', infoToSave)
minutePicker.grid(row=1, column=3)
tk.Label(frameDuration, text="m").grid(row=1, column=4)
secondsPicker = ttk.Spinbox(frameDuration, from_=0, to=59, wrap=True, width=5, state="readonly")
secondsPicker['command'] = functools.partial(getDuration, secondsPicker, 'segons', infoToSave)
secondsPicker.grid(row=1, column=5)
tk.Label(frameDuration, text="s").grid(row=1,column=6)
else:
tk.Label(frameDuration, text="Hora inici (hh:mm)").grid(row=1, column=0, padx=4, pady=10)
entryInitialHour = ttk.Entry(frameDuration)
entryInitialHour.grid(row=1, column = 1)
tk.Label(frameDuration, text="Hora final (hh:mm)").grid(row=1, column=2, padx=4, pady=10)
entryFinalHour = ttk.Entry(frameDuration)
entryFinalHour.grid(row=1, column = 3)
buttonCalculateDurationPerHour = ttk.Button(frameDuration, text="Calcular durada")
buttonCalculateDurationPerHour['command'] = functools.partial(calculateDurationPerHour, entryInitialHour, entryFinalHour, screenFormCreateLog, infoToSave['date'], infoToSave)
buttonCalculateDurationPerHour.grid(row=1, column=4, padx=4)
def __init__(self, master: tk.Widget):
# Variables
self.var_peep = tk.IntVar(master)
self.var_p_support = tk.IntVar(master)
self.var_ti = tk.DoubleVar(master)
self.var_br = tk.IntVar(master)
self.var_trigger = tk.DoubleVar(master)
# Elements
self.peep_label = ttk.Label(master, text="PEP", width=cst.W_LABEL)
self.peep_spin = ttk.Spinbox(master,
textvariable=self.var_peep,
width=cst.W_SPINBOX)
self.peep_unit = ttk.Label(master, text="cmH2O", width=cst.W_UNIT)
self.p_support_label = ttk.Label(master,
text="Psupport",
width=cst.W_LABEL)
self.p_support_spin = ttk.Spinbox(master,
textvariable=self.var_p_support,
width=cst.W_SPINBOX)
self.p_support_unit = ttk.Label(master, text="cmH2O", width=cst.W_UNIT)
self.ti_label = ttk.Label(master,
text="Temps inspi",
width=cst.W_LABEL)
self.ti_spin = ttk.Spinbox(master,
textvariable=self.var_ti,
width=cst.W_SPINBOX)
self.ti_unit = ttk.Label(master, text="s", width=cst.W_UNIT)
self.br_label = ttk.Label(master,
text="Fréquence respi",
width=cst.W_LABEL)
self.br_spin = ttk.Spinbox(master,
textvariable=self.var_br,
width=cst.W_SPINBOX)
self.br_unit = ttk.Label(master, text="/min", width=cst.W_UNIT)
self.trigger_label = ttk.Label(master,
text="Trigger",
width=cst.W_LABEL)
self.trigger_spin = ttk.Spinbox(master,
textvariable=self.var_trigger,
width=cst.W_SPINBOX)
self.trigger_unit = ttk.Label(master, text="l/min", width=cst.W_UNIT)
# Place the elements
self.peep_label.grid(row=0, column=0)
self.peep_spin.grid(row=0, column=1)
self.peep_unit.grid(row=0, column=2, padx=(5, 0))
self.p_support_label.grid(row=1, column=0)
self.p_support_spin.grid(row=1, column=1)
self.p_support_unit.grid(row=1, column=2, padx=(5, 0))
self.ti_label.grid(row=2, column=0)
self.ti_spin.grid(row=2, column=1)
self.ti_unit.grid(row=2, column=2, padx=(5, 0))
self.br_label.grid(row=3, column=0)
self.br_spin.grid(row=3, column=1)
self.br_unit.grid(row=3, column=2, padx=(5, 0))
self.trigger_label.grid(row=4, column=0)
self.trigger_spin.grid(row=4, column=1)
self.trigger_unit.grid(row=4, column=2, padx=(5, 0))
def __init__(self, master=None, **kw):
super().__init__(master, **kw)
self.hour_picker = ttk.Spinbox(self,
width=2,
values=self.n_digit_number_range(
2, 1, 13, 1),
wrap=True)
self.hour_picker.set(self.hour_picker['values'][0])
self.hour_picker.bind('<FocusOut>',
lambda event: self.force_to_n_digits(event, 2))
self.bind_time_changing_events(self.hour_picker)
self.minute_picker = ttk.Spinbox(self,
width=2,
values=self.n_digit_number_range(
2, 0, 61, 1),
wrap=True)
self.minute_picker.set(self.minute_picker['values'][0])
self.minute_picker.bind('<FocusOut>',
lambda event: self.force_to_n_digits(event, 2))
self.bind_time_changing_events(self.minute_picker)
self.separator = ttk.Label(self, text=':')
self.am_pm_picker = ttk.Spinbox(self,
width=4,
values=(self.AM, self.PM),
state='readonly',
wrap=True)
self.am_pm_picker.set(self.am_pm_picker['values'][0])
self.bind_time_changing_events(self.am_pm_picker)
self.place_contents()
def add_retransmit(self):
retransmit = ttk.Frame(self.controls)
retransmit.pack(side='top', pady=(0, 5))
header = ttk.Label(retransmit, text='Retransmit')
header.pack(side="top")
row1 = ttk.Frame(retransmit)
row1.pack(side='top')
event_label = ttk.Label(row1, text='Event')
event_label.grid(row=0, column=0)
event_num = ttk.Spinbox(row1, from_=0, to=255, width=5)
event_num.set(1)
event_num.grid(row=0, column=1)
heat_label = ttk.Label(row1, text='Heat')
heat_label.grid(row=0, column=2)
heat_num = ttk.Spinbox(row1, from_=0, to=255, width=5)
heat_num.set(0)
heat_num.grid(row=0, column=3)
retransmit_button = ttk.Button(row1, text='Retransmit')
retransmit_button.grid(row=1, column=0, columnspan=2)
# TODO include selection of start time for retransmission.
retransmit_button['command'] = lambda: self.tm.start_retransmit()
# HALT RETRANSMIT
halt_retransmit_button = ttk.Button(row1, text='Halt Retransmit')
halt_retransmit_button.grid(row=1, column=2, columnspan=2)
halt_retransmit_button['command'] = lambda: self.tm.halt_retransmit()
def _create_widgets(self):
self._schedule_toggled = tk.BooleanVar()
self._toggle_schedule = ttk.Checkbutton(
self,
text='Register schedule',
variable=self._schedule_toggled,
onvalue=True,
offvalue=False,
)
self._schedules = ttk.Frame(self)
self._schedules_label = ttk.Label(self._schedules,
text='Execution interval')
self._schedules_selections = ttk.Combobox(
self._schedules, values=self._schedule_intervals, state='readonly')
self._start_time = ttk.Frame(self)
self._start_time_label = ttk.Label(self._start_time, text='Start time')
self._hours = tk.IntVar()
self._hours_label = ttk.Label(self._start_time, text='Hour')
self._hours_selection = ttk.Spinbox(self._start_time,
from_=0,
to=23,
validate='focus',
textvariable=self._hours)
self._minutes = tk.IntVar()
self._minutes_label = ttk.Label(self._start_time, text='Minute')
self._minutes_selection = ttk.Spinbox(self._start_time,
from_=0,
to=59,
validate='focus',
textvariable=self._minutes)
def ec2_details(self):
# CPU
lbl_cpu = ttk.Label(self, text="CPU", style=self.black_white)
lbl_cpu.grid(padx=5, row=0, column=0, sticky=tk.W)
in_cpu = ttk.Spinbox(self, style=self.white_black_spin, textvariable=self.input_cpu,
from_=0.5, to=256.0, increment=.5, justify=tk.CENTER, width=3)
in_cpu.grid(row=0, column=1, sticky=tk.W)
# RAM
lbl_ram = ttk.Label(self, text="RAM", style=self.black_white)
lbl_ram.grid(padx=5,row=1, column=0, sticky=tk.W)
in_ram = ttk.Spinbox(self, style=self.white_black_spin, textvariable=self.input_ram,
from_=1, to=256.0, increment=1, justify=tk.CENTER, width=3)
in_ram.grid(row=1, column=1, sticky=tk.W)
# Region
lbl_region = ttk.Label(self, text="Region", style=self.black_white)
lbl_region.grid(padx=5, row=2, column=0, sticky=tk.W)
drpdwn_region = ttk.OptionMenu(self, self.input_region, *self.regions)
drpdwn_region.grid(row=2, column=1, sticky=tk.W)
# Os
lbl_os = ttk.Label(self, text="OS", style=self.black_white)
lbl_os.grid(padx=5, row=3, column=0, sticky=tk.W)
drpdwn_os = ttk.OptionMenu(self, self.input_os, *self.os)
drpdwn_os.grid(row=3, column=1, sticky=tk.W)
find = ttk.Button(self, text="Find EC2", style=self.white_black_btn, command=self.find_ec2s)
find.grid(padx=5, row=3, column=2, sticky=tk.W)
self.results.grid(row=4, column=0, sticky=tk.W, columnspan=4)
def __init__(self, parent, tab):
Base.__init__(self, parent)
self.parent = parent
self.wallpaper_path = tk.StringVar(), tk.StringVar()
self.brightness_scale = tk.IntVar(), tk.IntVar()
self.start_hour = tk.StringVar(), tk.StringVar()
self.start_minute = tk.StringVar(), tk.StringVar()
self.enable_scheduler = tk.BooleanVar(), tk.BooleanVar()
tab_control = ttk.Notebook(self.parent)
self.tabs = {
'dark_mode': ttk.Frame(tab_control),
'light_mode': ttk.Frame(tab_control)
}
self.preview_canvas = [
tk.Canvas(self.tabs['dark_mode']),
tk.Canvas(self.tabs['light_mode'])
]
self.spin_state = ["disabled", "disabled"]
self.spin_hour = [
ttk.Spinbox(self.tabs['dark_mode']),
ttk.Spinbox(self.tabs['light_mode'])
]
self.spin_minute = [
ttk.Spinbox(self.tabs['dark_mode']),
ttk.Spinbox(self.tabs['light_mode'])
]
self.wallpaper_tk_thumbnail = [ImageTk.PhotoImage, ImageTk.PhotoImage]
self.initialize_interface(tab_control)
tab_control.select(self.tabs[tab])
Base.set_position(self, 275, 270)
def __init__(self, parent, max_value: int):
super().__init__(parent, text=" Total occurrences range filter ")
ttk.Label(self, text="Count of").grid(column=0, row=0)
self.combo_box = ttk.Combobox(self,
values=COMBO_VALUES,
state="readonly",
width=5)
self.combo_box.grid(column=1, row=0)
self.combo_box.current(0)
ttk.Label(self, text="is in the range from:").grid(column=2, row=0)
self.spin_from = ttk.Spinbox(self,
from_=0,
to=max_value,
state="readonly",
width=5)
self.spin_from.grid(column=3, row=0)
self.spin_from.set(0)
ttk.Label(self, text="to:").grid(column=4, row=0)
self.spin_to = ttk.Spinbox(self,
from_=0,
to=max_value,
state="readonly",
width=5)
self.spin_to.grid(column=5, row=0)
self.spin_to.set(max_value)
self.apply_button = ttk.Button(self, text="Apply")
self.apply_button.grid(column=6, row=0)
for child in self.winfo_children():
child.grid_configure(padx=4, pady=2, sticky=tk.W)
def __init__(self, master: tk.Widget):
# Variables
self.var_peep = tk.IntVar(master)
self.var_ai = tk.IntVar(master)
self.var_ti_max = tk.DoubleVar(master)
self.var_trigger_inspi = tk.DoubleVar(master)
self.var_trigger_expi = tk.DoubleVar(master)
# Elements
self.peep_label = ttk.Label(master, text="PEP", width=cst.W_LABEL)
self.peep_spin = ttk.Spinbox(master,
textvariable=self.var_peep,
width=cst.W_SPINBOX)
self.peep_unit = ttk.Label(master, text="cmH2O", width=cst.W_UNIT)
self.ai_label = ttk.Label(master, text="AI", width=cst.W_LABEL)
self.ai_spin = ttk.Spinbox(master,
textvariable=self.var_ai,
width=cst.W_SPINBOX)
self.ai_unit = ttk.Label(master, text="cmH2O", width=cst.W_UNIT)
self.trigger_inspi_label = ttk.Label(master,
text="Trigger inspiratoire",
width=cst.W_LABEL)
self.trigger_inspi_spin = ttk.Spinbox(
master, textvariable=self.var_trigger_inspi, width=cst.W_SPINBOX)
self.trigger_inspi_unit = ttk.Label(master,
text="l/min",
width=cst.W_UNIT)
self.trigger_expi_label = ttk.Label(master,
text="Trigger expiratoire",
width=cst.W_LABEL)
self.trigger_expi_spin = ttk.Spinbox(
master, textvariable=self.var_trigger_expi, width=cst.W_SPINBOX)
self.trigger_expi_unit = ttk.Label(master, text="%", width=cst.W_UNIT)
self.ti_max_label = ttk.Label(master,
text="Temps inspi max",
width=cst.W_LABEL)
self.ti_max_spin = ttk.Spinbox(master,
textvariable=self.var_ti_max,
width=cst.W_SPINBOX)
self.ti_max_unit = ttk.Label(master, text="s", width=cst.W_UNIT)
# Place the elements
self.peep_label.grid(row=0, column=0)
self.peep_spin.grid(row=0, column=1)
self.peep_unit.grid(row=0, column=2, padx=(5, 0))
self.ai_label.grid(row=1, column=0)
self.ai_spin.grid(row=1, column=1)
self.ai_unit.grid(row=1, column=2, padx=(5, 0))
self.trigger_inspi_label.grid(row=2, column=0)
self.trigger_inspi_spin.grid(row=2, column=1)
self.trigger_inspi_unit.grid(row=2, column=2, padx=(5, 0))
self.trigger_expi_label.grid(row=3, column=0)
self.trigger_expi_spin.grid(row=3, column=1)
self.trigger_expi_unit.grid(row=3, column=2, padx=(5, 0))
self.ti_max_label.grid(row=4, column=0)
self.ti_max_spin.grid(row=4, column=1)
self.ti_max_unit.grid(row=4, column=2, padx=(5, 0))
def __init__(self, param_frame, var_row):
self.variable_frame = tk.Frame(param_frame,
borderwidth=1,
relief=tk.SOLID)
self.variable_frame.grid(row=var_row, column=0, pady=5, sticky='w')
self.cmb_var = ttk.Combobox(self.variable_frame,
values=self.__variable_choice,
state='readonly')
self.cmb_var.grid(row=0, column=0, sticky='w', padx=5, pady=5)
self.cmb_var.bind('<<ComboboxSelected>>', self.select_var_type)
self.cmb_var.current(0)
self.input_frame = tk.Frame(self.variable_frame)
self.input_frame.grid(row=1, column=0, sticky='w', padx=5, pady=5)
self.ent_var = tk.Entry(self.input_frame, width=20)
self.spin_frame = tk.Frame(self.input_frame)
lbl_start = tk.Label(self.spin_frame, text='Start Range')
lbl_stop = tk.Label(self.spin_frame, text='End Range')
self.spin_start = ttk.Spinbox(self.spin_frame,
from_=0,
to=100000000,
width=10)
self.spin_end = ttk.Spinbox(self.spin_frame,
from_=0,
to=100000000,
width=10)
lbl_start.grid(row=0, column=0)
self.spin_start.grid(row=0, column=1)
lbl_stop.grid(row=1, column=0)
self.spin_end.grid(row=1, column=1)
self.spin_length_frame = tk.Frame(self.input_frame)
lbl_length = tk.Label(self.spin_length_frame, text='Length')
self.spin_length = ttk.Spinbox(self.spin_length_frame,
from_=0,
to=100000000,
width=10)
lbl_length.pack(side=tk.LEFT)
self.spin_length.pack(side=tk.LEFT)
'''
prevent changes by scrolling
'''
self.cmb_var.unbind_class('TCombobox', '<MouseWheel>')
# Linux and other *nix systems:
self.cmb_var.unbind_class("TCombobox", "<ButtonPress-4>")
self.cmb_var.unbind_class("TCombobox", "<ButtonPress-5>")
self.spin_start.bind('<MouseWheel>', self.disable_spinbox_scroll)
self.spin_end.bind('<MouseWheel>', self.disable_spinbox_scroll)
self.spin_length.bind('<MouseWheel>', self.disable_spinbox_scroll)
'''
default manual input for string
'''
self.ent_var.grid(
row=0,
column=0,
)
def create_spinboxes(self):
self.x_dep = ttk.Spinbox(self, from_=0, to=600, width=4)
self.y_dep = ttk.Spinbox(self, from_=0, to=600, width=4)
self.width = ttk.Spinbox(self, from_=0, to=400, width=4)
self.height = ttk.Spinbox(self, from_=0, to=400, width=4)
self.x_dep.insert(0, "100")
self.y_dep.insert(0, "100")
self.width.insert(0, "300")
self.height.insert(0, "300")
def create_widgets(self):
self.hour_spinbox = ttk.Spinbox(self, from_ = 0, to = 23, width = 2,
wrap = "true", format = "%02.f",
increment = 1)
self.hour_spinbox.grid(row = 0, column = 0)
self.minute_spinbox = ttk.Spinbox(self, from_ = 0, to = 59, width = 2,
wrap = "true", format = "%02.f",
increment = 1)
self.minute_spinbox.grid(row = 0, column = 1)
def create(self):
try:
FRM11 = LabelFrame(self.slider, text = self.dico['slider1'][0], foreground = 'black')
FRM11.grid(row = 0,column = 0,columnspan = 3,padx = 10)
#LBL11 = ttk.Label(FRM11 ,text = self.dico['slider1'][0])
SCL11 = ttk.Scale(FRM11, from_=self.dico['slider1'][1], to=self.dico['slider1'][2], orient=HORIZONTAL, variable = self.dico['slider1'][3], length = 200)
LBL12 = ttk.Spinbox(FRM11, textvariable = self.dico['slider1'][3], width = 8,from_=self.dico['slider1'][1], to=self.dico['slider1'][2])
#LBL11.grid(row = 0, column = 0,padx = 10)
SCL11.grid(row = 0, column = 0, columnspan = 2,padx = 10,pady = 10)
LBL12.grid(row = 0, column = 2, padx = 10)
if len(self.dico) >= 2:
FRM21 = LabelFrame(self.slider, text = self.dico['slider2'][0], foreground = 'black')
FRM21.grid(row = 1,column = 0,columnspan = 3,padx = 10)
#LBL21 = ttk.Label(self.slider ,text = self.dico['slider2'][0])
SCL21 = ttk.Scale(FRM21, from_=self.dico['slider2'][1], to=self.dico['slider2'][2], orient=HORIZONTAL, variable = self.dico['slider2'][3], length = 200)
LBL22 = ttk.Spinbox(FRM21, textvariable = self.dico['slider2'][3], width = 8,from_=self.dico['slider2'][1], to=self.dico['slider2'][2])
#LBL21.grid(row = 1, column = 0)
SCL21.grid(row = 1, column = 0, columnspan = 2,padx = 10,pady = 10)
LBL22.grid(row = 1, column = 2, padx = 10)
if len(self.dico) == 3:
FRM31 = LabelFrame(self.slider, text = self.dico['slider3'][0], foreground = 'black')
FRM31.grid(row = 2,column = 0,columnspan = 3,padx = 10)
#LBL31 = ttk.Label(self.slider ,text = self.dico['slider3'][0])
SCL31 = ttk.Scale(FRM31, from_=self.dico['slider3'][1], to=self.dico['slider3'][2], orient=HORIZONTAL, variable = self.dico['slider3'][3], length = 200)
LBL32 = ttk.Spinbox(FRM31, textvariable = self.dico['slider3'][3], width = 8,from_=self.dico['slider3'][1], to=self.dico['slider3'][2])
#LBL31.grid(row = 2, column = 0)
SCL31.grid(row = 2, column = 0, columnspan = 2,padx = 10,pady = 10)
LBL32.grid(row = 2, column = 2, padx = 10)
apply = ttk.Button(self.slider, text = 'Apply', command = self.commands['apply'])
cancel = ttk.Button(self.slider, text = 'Cancel', command = self.commands['cancel'] )
save = ttk.Button(self.slider, text = 'Save', command = self.commands['save'])
#self.slider.columnconfigure(0,weight =2)
#ttk.Label(self.slider, text = ' ').grid(column = 0)
apply.grid(column = 0, row = 10)
cancel.grid(column = 1, row = 10,padx =10,pady = 5)
save.grid(column = 2,row = 10)
except TypeError:
pass
def __init__(self, master: tk.Widget):
# Variables
self.var_r = tk.IntVar(master)
self.var_c = tk.IntVar(master)
self.var_br = tk.IntVar(master)
self.var_ti = tk.DoubleVar(master)
self.var_pmus = tk.IntVar(master)
# Elements
self.r_label = ttk.Label(master, text="Résistance", width=cst.W_LABEL)
self.r_spin = ttk.Spinbox(master,
textvariable=self.var_r,
width=cst.W_SPINBOX)
self.r_unit = ttk.Label(master, text="cmH2O/(l/min)", width=cst.W_UNIT)
self.c_label = ttk.Label(master, text="Compliance", width=cst.W_LABEL)
self.c_spin = ttk.Spinbox(master,
textvariable=self.var_c,
width=cst.W_SPINBOX)
self.c_unit = ttk.Label(master, text="ml/cmH2O", width=cst.W_UNIT)
self.br_label = ttk.Label(master,
text="Fréquence Respi",
width=cst.W_LABEL)
self.br_spin = ttk.Spinbox(master,
textvariable=self.var_br,
width=cst.W_SPINBOX)
self.br_unit = ttk.Label(master, text="/min", width=cst.W_UNIT)
self.ti_label = ttk.Label(master,
text="Temps inspiratoire",
width=cst.W_LABEL)
self.ti_spin = ttk.Spinbox(master,
textvariable=self.var_ti,
width=cst.W_SPINBOX)
self.ti_unit = ttk.Label(master, text="s", width=cst.W_UNIT)
self.pmus_label = ttk.Label(master, text="Pmus", width=cst.W_LABEL)
self.pmus_spin = ttk.Spinbox(master,
textvariable=self.var_pmus,
width=cst.W_SPINBOX)
self.pmus_unit = ttk.Label(master, text="cmH2O", width=cst.W_UNIT)
# Place the elements
self.r_label.grid(row=0, column=0)
self.r_spin.grid(row=0, column=1)
self.r_unit.grid(row=0, column=2, padx=(5, 0))
self.c_label.grid(row=1, column=0)
self.c_spin.grid(row=1, column=1)
self.c_unit.grid(row=1, column=2, padx=(5, 0))
self.br_label.grid(row=2, column=0)
self.br_spin.grid(row=2, column=1)
self.br_unit.grid(row=2, column=2, padx=(5, 0))
self.ti_label.grid(row=3, column=0)
self.ti_spin.grid(row=3, column=1)
self.ti_unit.grid(row=3, column=2, padx=(5, 0))
self.pmus_label.grid(row=4, column=0)
self.pmus_spin.grid(row=4, column=1)
self.pmus_unit.grid(row=4, column=2, padx=(5, 0))
def _create_widgets(self) -> None:
self.__taxonomy_tree = ScrollbarListbox(self,
on_select_callback=self.__on_select_tree_item,
heading=TREEVIEW_HEADING,
extract_id=lambda x: x.id_,
extract_text=lambda x: x.name,
extract_ancestor=lambda x: '' if x.parent_id is None else x.parent_id,
extract_values=self.__extract_values,
columns=[Column('Amount')],
values=self.__state.model.taxonomy)
self.__left_frame = ttk.Frame(self)
# Ports combobox
self.__port_combobox_var = tk.StringVar(value=SELECT_PORT)
self.__port_combobox_var.trace('w', self.__on_combobox_changed)
# state='readonly' means you cannot write freely in the combobox
self.__port_combobox = ttk.Combobox(self.__left_frame, state='readonly',
textvariable=self.__port_combobox_var, font=FONT)
ports_names = self.__state.model.get_all_ports_names()
self.__port_combobox['values'] = sorted(ports_names)
# C(r)ud Buttons
self.__add_port_button = ttk.Button(self.__left_frame, text='Add', state=tk.NORMAL,
command=self.__on_add)
self.__rename_port_button = ttk.Button(self.__left_frame, text='Rename', state=tk.DISABLED,
command=self.__on_rename)
self.__remove_port_button = ttk.Button(self.__left_frame, text='Remove', state=tk.DISABLED,
command=self.__remove)
# Force connection
self.__force_connection_checkbox_var = tk.BooleanVar(value=False)
self.__force_connection_checkbox_var.trace('w', self.__on_force_connection_toggled)
self.__force_connection_checkbox_label = ttk.Label(self.__left_frame,
text='Force connection:')
self.__force_connection_checkbox = ttk.Checkbutton(self.__left_frame, state=tk.DISABLED,
variable=self.__force_connection_checkbox_var)
# Force connection checkbox
self.__compatible_with_edit_button = ttk.Button(self.__left_frame, text='Edit compatibility',
command=self.__on_edit_compatible_with, state=tk.DISABLED)
self.__compatible_with_listbox = ScrollbarListbox(self.__left_frame,
extract_text=lambda prt: prt.name,
extract_id=lambda prt: prt.id_,
columns=[Column('Compatible with', main=True, stretch=tk.YES)])
self.__cmp_label_var = tk.StringVar(value='')
self.__cmp_label = ttk.Label(self.__left_frame, textvariable=self.__cmp_label_var, style='Big.TLabel', anchor=tk.CENTER)
self.__amount_spinbox_label = ttk.Label(self.__left_frame, text='Has:')
self.__amount_spinbox_var = tk.IntVar(value='')
self.__amount_spinbox_var.trace('w', self.__on_amount_changed)
self.__amount_spinbox = ttk.Spinbox(self.__left_frame, from_=0, to=math.inf,
textvariable=self.__amount_spinbox_var)
self.__all_children_amount_spinbox_label = ttk.Label(self.__left_frame, text='Children have:')
self.__all_children_amount_spinbox_var = tk.IntVar(value='')
self.__all_children_amount_spinbox = ttk.Spinbox(self.__left_frame, from_=0, to=math.inf,
textvariable=self.__all_children_amount_spinbox_var)
self.__apply_to_all_children_button = ttk.Button(self.__left_frame, text='Apply to all children',
command=self.__apply_to_all_children)
def __init__(self, root):
self.root = root
self.root.geometry("1250x600")
self.root.title("Spectrum Realm")
Menubar = tk.Menu(root)
self.Parser = "Standard Parser, (.xyd, csv)"
Filemenu = tk.Menu(Menubar)
Filemenu.add_command(label="Parser : " + self.Parser,
command=lambda: ChooseParser(self.root))
Filemenu.add_command(label="Load file",
command=lambda: Find(self.Parser))
Filemenu.add_command(label="Manual fit", command=self.Manual)
Filemenu.add_command(label="Save figure",
command=lambda: SaveFigure(self.root, self.Data))
Menubar.add_cascade(label="File", menu=Filemenu)
BackgroundMenu = tk.Menu(Menubar)
BackgroundMenu.add_checkbutton(label="No Background")
BackgroundMenu.add_checkbutton(label="Exponential Background",
command=self.Exp)
BackgroundMenu.add_checkbutton(label="Linear background",
command=self.Lin)
Menubar.add_cascade(label="Background", menu=BackgroundMenu)
Formatmenu = tk.Menu(Filemenu)
Formatmenu.add_command(
label="Format",
command=lambda: FormatHandler(self.root, self.Data))
self.XrayTrue = tk.StringVar()
Formatmenu.add_checkbutton(label="Xray diffract",
variable=self.XrayTrue,
command=lambda: 0)
Menubar.add_cascade(label="Format", menu=Formatmenu)
self.root.config(menu=Menubar)
Label1 = ttk.Label(self.root, text="Number of peaks").grid(column=1,
row=1)
self.NumberOfGaussiansval = tk.StringVar()
self.NumberOfGaussiansval.set(1)
self.NumberOfGaussians = ttk.Spinbox(
self.root,
from_=1,
to=20,
textvariable=self.NumberOfGaussiansval,
command=self.Update).grid(column=1, row=3)
self.Boundaryval = tk.StringVar()
self.Boundaryval.set(25)
Label2 = ttk.Label(self.root,
text="Number of points to include").grid(column=1,
row=5)
self.Boundary = ttk.Spinbox(self.root,
from_=15,
to=100,
textvariable=self.Boundaryval,
command=self.Update).grid(column=1, row=7)
Btn1 = ttk.Button(root, text="Apply",
command=self.Update).grid(column=1, row=9)
def __init__(self, parent, options, *args, **kwargs):
ttk.Frame.__init__(self, parent, *args, **kwargs)
# Add enumeration font selection
self.enumeration_font = FontSelect(self, 2,
title='Chart Enumeration Font',
middleLabel='Font',
middleEntry=options['page-num-font']['name'],
rightLabel='Size',
rightEntry=options['page-num-font']['size'])
self.enumeration_font.grid(row=0, column=0, sticky=(N, E, S, W), padx=20, pady=10)
# Add enumeration toggle
enum_frame = ttk.LabelFrame(self, text='Enumerate All Chart Files')
self.enumerate = BooleanVar()
self.enumerate.set(options['enumerate-pages'])
enum_check = ttk.Checkbutton(enum_frame, text='Enumerate All Chartz', variable=self.enumerate)
enum_check.grid(row=0, column=0, padx=10, pady=5)
enum_frame.rowconfigure(0, weight='1')
enum_frame.columnconfigure(0, weight='1')
enum_frame.grid(row=0, column=1, sticky=(N, S, E, W), padx=20, pady=10)
# Add width/height selectors
page_dim_frame = ttk.Labelframe(self, text='Specify Page Dimensions (in Inches)')
validate_fn = (page_dim_frame.register(validate_numerical_entry(True)), '%P')
self.page_width = StringVar()
self.page_width.set(options['page-size']['width'])
width_label = ttk.Label(page_dim_frame, text='Width:')
width_label.grid(row=0, column=0, sticky=E, padx=2, pady=5)
width_spinbox = ttk.Spinbox(page_dim_frame, from_=0.0, to=20.0, increment=0.1, textvariable=self.page_width, validate='key', validatecommand=validate_fn)
width_spinbox.grid(row=0, column=1, sticky=W, padx=2, pady=5)
width_spinbox.bind('<FocusOut>', lambda _: self.page_width.set(options['page-size']['width']) if not len(self.page_width.get()) else '')
self.page_height = StringVar()
self.page_height.set(options['page-size']['height'])
height_label = ttk.Label(page_dim_frame, text='Height:')
height_label.grid(row=0, column=2, sticky=E, padx=2, pady=5)
height_spinbox = ttk.Spinbox(page_dim_frame, from_=0.0, to=20.0, increment=0.1, textvariable=self.page_height, validate='key', validatecommand=validate_fn)
height_spinbox.grid(row=0, column=3, sticky=W, padx=2, pady=5)
height_spinbox.bind('<FocusOut>', lambda _: self.page_width.set(options['page-size']['height']) if not len(self.page_height.get()) else '')
page_dim_frame.bind('<Button-1>', lambda e: e.widget.focus_set())
page_dim_frame.rowconfigure(0, weight='1')
for col in range(4):
page_dim_frame.columnconfigure(col, weight='1')
page_dim_frame.grid(row=1, column=0, columnspan=2, sticky=(N, E, S, W), padx=20, pady=10)
# Make Resizeable
for i in (0, 1):
self.rowconfigure(i, weight='1')
self.columnconfigure(i, weight='1')
def setup(self):
# Calibration Control Buttons
lf = ttk.LabelFrame(self, text='Objective-Capillary Calibration')
lf.grid()
bt = ttk.Button(lf, text='Set Objective Focus', command=self.objective_focus)
bt.grid()
bt = ttk.Button(lf, text='Set Capillary Focus', command=self.capillary_focus)
bt.grid()
spn = ttk.Spinbox(lf, from_=-0.5, to=10)
spn.grid()
# Capillary Adjustments
lf = ttk.LabelFrame(self, text='Capillary Adjustments')
lf.grid()
bt = ttk.Button(lf, text='Lower Capillary', command=self.lower_cap)
bt.grid(row=0, column=0)
moves = [('-10', -0.01),
('-5', -0.005),
('-2', -0.002),
('2', 0.002),
('5', 0.005),
('10', 0.01)]
c_idx = 0
r_idx = 1
for lbl, dis in moves:
bt = ttk.Button(lf, text=lbl,
command=lambda x=dis: self.root_window.system_queue.send_command('system.inlet_z.set_rel_z',
x))
bt.grid(row=r_idx, column=c_idx)
c_idx += 1
# Injection Parameters
lf = ttk.LabelFrame(self, text='Injection Parameters')
lf.grid()
params = [('Time (s)', self.time_var, 0, 1000),
('Voltage (kV)', self.volt_var, 0, 1000),
('Drop (mm)', self.drop_var, -10, 10)]
c_idx = 0
r_idx = 0
for lbl, var, lw, hi in params:
lb = ttk.Label(lf, text=lbl)
lb.grid(row=r_idx, column=c_idx)
sp = ttk.Spinbox(lf, from_=lw, to=hi, textvariable=var)
sp.grid(row=r_idx + 1, column=c_idx)
c_idx += 1
btn = ttk.Button(lf, text='Start', command=self.start_injection)
btn.grid(row=r_idx + 2, column=c_idx - 1)
# Method Commands
lf = ttk.LabelFrame(self, text='Method Control')
lf.grid()
btn = ttk.Button(lf, text='Continue Method', command=self.continue_run)
btn.grid()
def main(self):
self.valoareSpinBoxIntrari.set('1')
self.intrari.set('1')
self.frameIntrariValori1 = ttk.Frame(self.frameInCanvas,
relief=tk.RAISED,
borderwidth=1)
self.listaFrameIntrari.append(self.frameIntrariValori1)
self.frameIntrariValori1.pack(fill=tk.X, side=tk.TOP, padx=10, pady=10)
self.labelIn = tk.Label(self.frameIntrariValori1,
text='Ini0',
height=1,
width=3)
self.labelIn.pack(side=tk.LEFT, padx=3, pady=3)
self.intrareValoare = tk.StringVar()
self.entryIni0 = ttk.Spinbox(self.frameIntrariValori1,
from_=-1000000,
to=1000000,
increment=0.01,
textvariable=self.intrareValoare)
self.intrareValoare.set('0.01')
self.listaIntrariValoareInitiala.append(self.intrareValoare)
self.entryIni0.pack(fill=tk.X, expand=1, side=tk.LEFT)
self.labelW0 = tk.Label(self.frameIntrariValori1,
text='Wi0',
height=1,
width=3)
self.labelW0.pack(side=tk.LEFT, padx=3, pady=3)
self.intrareGreutate = tk.StringVar()
self.entryWi0 = ttk.Spinbox(self.frameIntrariValori1,
from_=-1000000,
to=1000000,
increment=0.01,
textvariable=self.intrareGreutate)
self.intrareGreutate.set('0.01')
self.listaIntrariGreutate.append(self.intrareGreutate)
self.entryWi0.pack(fill=tk.X, expand=1, side=tk.LEFT)
self.CanvasIntrariValori.configure(
scrollregion=self.CanvasIntrariValori.bbox("all"))
self.intrareValoare.trace('w', self.controller.calculeaza)
self.intrareGreutate.trace('w', self.controller.calculeaza)
self.valoareSpinBoxIntrari.trace('w',
self.controller.update_numar_intrari)
self.tipFunctieIntrare.trace('w', self.controller.calculeaza)
self.tipFunctieActivare.trace('w', self.controller.calculeaza)
self.valoareTeta.trace('w', self.controller.calculeaza)
self.valoareAlfa.trace('w', self.controller.calculeaza)
self.valoareBinar.trace('w', self.controller.calculeaza)
self.controller.calculeaza()
self.mainloop()
def __init__(self, parent, titration, *args, **kwargs):
super().__init__(parent, *args, **kwargs)
self.titration = titration
rangeSelection = ttk.Frame(self)
rangeSelection.grid(row=0, column=0, sticky="")
ttk.Label(
rangeSelection,
text=f"Range of {titration.xQuantity} to fit:").pack(side="left")
minWL = self.titration.signalTitles.min()
maxWL = self.titration.signalTitles.max()
decimals = self.titration.signalTitlesDecimals
step = 1 / (10**decimals)
self.fromSpinbox = ttk.Spinbox(rangeSelection,
from_=minWL,
to=maxWL,
width=5,
increment=step)
self.fromSpinbox.set(f"{minWL:.{decimals}f}")
self.fromSpinbox.pack(padx=padding, side="left")
ttk.Label(rangeSelection, text="to").pack(side="left")
self.toSpinbox = ttk.Spinbox(rangeSelection,
from_=minWL,
to=maxWL,
width=5,
increment=step)
self.toSpinbox.set(f"{maxWL:.{decimals}f}")
self.toSpinbox.pack(padx=padding, side="left")
self.fig = Figure()
self.ax = self.fig.add_subplot()
ttk.Button(rangeSelection, text="Update",
command=self.updateWLRange).pack(side="left")
canvas = FigureCanvasTkAgg(self.fig, master=self)
canvas.draw()
canvas.get_tk_widget().grid(row=1, column=0, sticky="")
toolbar = NavigationToolbar2Tk(canvas, self, pack_toolbar=False)
toolbar.update()
toolbar.grid(row=2, column=0, sticky="w", padx=10 * padding)
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
self.rowconfigure(2, weight=1)
self.grid_anchor("center")
self.plot()
def __init__(self, master):
self.Framerunes = ttk.Labelframe(master)
self.Framerunes.configure(height='200',
text='Runes Data Input',
width='210')
self.Framerunes.rowconfigure('1', minsize='0', weight='1')
self.Framerunes.columnconfigure('1',
minsize='100',
pad='0',
weight='1')
# Spinbox
self.spinbox_r1r = ttk.Spinbox(self.Framerunes, from_=0, to=99)
self.spinbox_r1r.configure(increment='1', justify='left', width='5')
self.spinbox_r1r.grid(column='1', row='0', sticky='w')
self.spinbox_r1r.columnconfigure('1', minsize='0', pad='20')
self.spinbox_r1l = ttk.Spinbox(self.Framerunes, from_=0, to=10)
self.spinbox_r1l.configure(increment='1', width='5')
self.spinbox_r1l.grid(column='1', row='1', sticky='w')
self.spinbox_r1l.columnconfigure('1', minsize='0', pad='20')
self.spinbox_r2r = ttk.Spinbox(self.Framerunes, from_=0, to=99)
self.spinbox_r2r.configure(increment='1', width='5')
self.spinbox_r2r.grid(column='1', row='2', sticky='w')
self.spinbox_r2r.columnconfigure('1', minsize='0', pad='20')
self.spinbox_r2l = ttk.Spinbox(self.Framerunes, from_=0, to=10)
self.spinbox_r2l.configure(increment='1', width='5')
self.spinbox_r2l.grid(column='1', row='3', sticky='w')
self.spinbox_r2l.columnconfigure('1', minsize='0', pad='20')
# Labels
self.label1 = ttk.Label(self.Framerunes)
self.label1.configure(text='Rune 1 Rarity')
self.label1.grid(column='0', padx='18', pady='5', row='0')
self.label1.columnconfigure('0', minsize='0', pad='0')
self.label2 = ttk.Label(self.Framerunes)
self.label2.configure(text='Rune 1 Level')
self.label2.grid(column='0', padx='5', pady='5', row='1')
self.label2.columnconfigure('0', minsize='0', pad='0')
self.label3 = ttk.Label(self.Framerunes)
self.label3.configure(text='Rune 2 Rarity')
self.label3.grid(column='0', padx='5', pady='5', row='2')
self.label3.columnconfigure('0', minsize='0', pad='0')
self.label4 = ttk.Label(self.Framerunes)
self.label4.configure(text='Rune 2 Level')
self.label4.grid(column='0', padx='5', pady='5', row='3')
self.label4.columnconfigure('0', minsize='0', pad='0')
def ImperialButtons(self):
self.but1.config(state='disabled')
ttk.Label(self, text="Name:").grid(row=1, column=2, sticky=E)
ttk.Entry(self, textvariable=self.name).grid(row=1,
column=3,
columnspan=2,
sticky=EW)
ttk.Label(self, text="Weight(Stones & lbs):").grid(row=2,
column=2,
sticky=W)
ttk.Entry(self,
textvariable=self.imp_stones,
validate="key",
validatecommand=(self.vld, "%P")).grid(row=2,
column=3,
sticky=E)
ttk.Spinbox(self,
textvariable=self.imp_lbs,
from_=0,
to=13,
state="readonly").grid(row=2, column=4, sticky=W)
self.imp_lbs.set("0")
ttk.Label(self, text="Height(Ft & Inches):").grid(row=3,
column=2,
sticky=W)
ttk.Entry(self,
textvariable=self.imp_feet,
validate="key",
validatecommand=(self.vld, "%P")).grid(row=3,
column=3,
sticky=E)
ttk.Spinbox(self,
textvariable=self.imp_inches,
from_=0,
to=11,
state="readonly").grid(row=3, column=4, sticky=W)
self.imp_inches.set("0")
ttk.Label(self, text="BMI:").grid(row=4, column=2, sticky=E)
ttk.Entry(self, textvariable=self.bmi, state="readonly").grid(row=4,
column=3,
sticky=W)
self.bmi.set("Just A Moment...")
ttk.Button(self, text="Calculate BMI",
command=self.calculate).grid(row=6, column=3, sticky=E)
ttk.Button(self, text="Clear", command=self.clear).grid(row=7,
column=3,
sticky=E)
def __init__(self, master):
self.var_radio = IntVar()
self.var_check = IntVar()
self.Frameopponent = ttk.Labelframe(master)
self.Frameopponent.configure(height='200',
text='Opponent Data Input',
width='100')
self.Frameopponent.rowconfigure('2', weight='1')
self.Frameopponent.columnconfigure('1',
minsize='100',
pad='0',
weight='1')
# Opponent level spinbox
self.spinbox_op = ttk.Spinbox(self.Frameopponent, from_=1, to=999)
self.spinbox_op.configure(increment='1', width='5')
self.spinbox_op.grid(column='1', row='0', sticky='w')
self.spinbox_op.columnconfigure('1', pad='20')
# Heals cap and cont limit
self.checkbox_cap = ttk.Checkbutton(self.Frameopponent,
variable=self.var_check)
self.checkbox_cap.configure(text='Cap Heals')
self.checkbox_cap.grid(column='0', row='1', pady='5')
self.spin_def_limit = ttk.Spinbox(self.Frameopponent, from_=10, to=300)
self.spin_def_limit.configure(increment='10', width='5')
self.spin_def_limit.grid(column='1', row='1', sticky='w', pady='10')
self.spin_def_limit.columnconfigure('1', pad='20')
self.spin_def_limit.insert('0', '30')
# Radiobutton - One level or Continuous
self.radiobutton1 = ttk.Radiobutton(self.Frameopponent,
variable=self.var_radio,
value=0)
self.radiobutton1.configure(text='One level')
self.radiobutton1.grid(column='0', row='2', pady='5')
self.radiobutton2 = ttk.Radiobutton(self.Frameopponent,
variable=self.var_radio,
value=1)
self.radiobutton2.configure(state='normal', text='Continuous')
self.radiobutton2.grid(column='1', row='2', sticky='w', pady='5')
# Labels
self.label = ttk.Label(self.Frameopponent)
self.label.configure(text='Opponent Level')
self.label.grid(column='0', padx='10', pady='5', row='0')
self.label2 = ttk.Label(self.Frameopponent)
self.label2.configure(text=' Limit')
self.label2.grid(column='1', row='1', pady='5')
self.label2.lower(self.spin_def_limit)
