def __init__(self, parent, funnel, index, command_stack):
tk.Frame.__init__(self, parent, borderwidth=4, relief="raised")
Subscriber.__init__(self, funnel)
Observable.__init__(self)
self._funnel = funnel
self._command_stack = command_stack
self._active_var = tk.IntVar()
self._active_var.trace_add("write", self._switch_active)
self._y_var = tk.StringVar()
self._y_var.set(0)
self._y_var.trace_add("write", self._set_position)
self._x_var = tk.StringVar()
self._x_var.set(0)
self._x_var.trace_add("write", self._set_position)
self._oval_var = tk.IntVar()
self._oval_var.trace_add("write", self._switch_oval)
self._update()
self.bind("<Button-1>", self._on_click)
is_active = Checkbutton(
self, text=f"Funnel n°{index}: ", variable=self._active_var)
is_active.grid(columnspan=3)
is_active.bind("<FocusIn>", self._on_get_focus)
is_active.bind("<FocusOut>", self._on_lost_focus)
x_label = Label(self, text="\u21d5", anchor=tk.CENTER)
x_label.grid(sticky=tk.E + tk.W)
x_label.bind("<Button-1>", self._on_click)
self.x_entry = Entry(self, textvariable=self._x_var, width=6)
self.x_entry.grid(row=2, column=0, sticky=tk.W + tk.E)
self.x_entry.bind("<FocusIn>", self._on_get_focus)
self.x_entry.bind("<FocusOut>", self._on_lost_focus)
y_label = Label(self, text="\u21d4", anchor=tk.CENTER)
y_label.grid(row=1, column=1, sticky=tk.E+tk.W)
y_label.bind("<Button-1>", self._on_click)
self.y_entry = Entry(self, textvariable=self._y_var, width=6)
self.y_entry.grid(row=2, column=1, sticky=tk.W + tk.E)
self.y_entry.bind("<FocusIn>", self._on_get_focus)
self.y_entry.bind("<FocusOut>", self._on_lost_focus)
is_oval = Checkbutton(self, text="Is Oval", variable=self._oval_var)
is_oval.grid(row=1, column=2)
is_oval.bind("<FocusIn>", self._on_get_focus)
is_oval.bind("<FocusOut>", self._on_lost_focus)
force_centerline = Button(
self, text="force on centerline", command=self._force_centerline)
force_centerline.grid(row=2, column=2)
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(2, weight=1)
def body(self, master, cfg={}):
"place user dialog widgets"
self.config = cfg
self.config["OK button"] = False
self.site = StringVar()
self.site.set(cfg.get("site", ""))
self.login = StringVar()
self.login.set(cfg.get("user", ""))
self.password = StringVar()
self.password.set(str(cfg.get("password", "")))
site = Entry(master, width=15, textvariable=self.site)
site.grid(column=1, row=0, sticky="e")
Label(master, text=_("Site:")).grid(column=0, row=0, sticky="w")
loge = Entry(master, width=15, textvariable=self.login)
loge.grid(column=1, row=1, sticky="e")
Label(master, text=_("Username:"******"w")
pase = Entry(master, width=15, textvariable=self.password, show="*")
pase.grid(column=1, row=2, sticky="e")
Label(master, text=_("Password:"******"w")
self.to_remember = IntVar()
self.to_remember.set(cfg.get("remember_passwd", 1))
chk1 = Checkbutton(master, text="Remember",
variable=self.to_remember)
chk1.grid(column=0, row=3, sticky="w", columnspan=2)
self.resizable(width=0, height=0)
return loge
class SettingsWindow(Toplevel):
def __init__(self) -> None:
Toplevel.__init__(self)
self.title("Settings")
#self.geometry("300x180")
self.config = configparser.ConfigParser()
self.config.read('config.ini')
self.val_int_cmd = (self.register(vcmdtk.test_int), '%d', '%S')
self.create_gui()
self.load_settings()
self.grid_gui()
def create_gui(self):
#Label
self.y_max_label = Label(self, text='Y max')
self.y_min_label = Label(self, text='Y min')
#Entry
self.y_max_entry = Entry(self,
validate='key',
validatecommand=self.val_int_cmd)
self.y_min_entry = Entry(self,
validate='key',
validatecommand=self.val_int_cmd)
#Check buttons
self.check_var_1 = BooleanVar()
self.check_var_1.set(
self.config.getboolean('Y Limits', 'use_auto_values'))
self.auto_y_cbutton = Checkbutton(self,
text='Use auto Y-value ranges',
variable=self.check_var_1,
command=self.auto_y)
#buttons
self.ok_button = Button(self, text='Ok', command=self.ok_command)
self.cancel_button = Button(self, text='Cancel', command=self.destroy)
def grid_gui(self):
self.y_max_label.grid(row=0, column=0, pady=2)
self.y_min_label.grid(row=1, column=0, pady=2)
self.y_max_entry.grid(row=0, column=1, pady=2)
self.y_min_entry.grid(row=1, column=1, pady=2)
self.auto_y_cbutton.grid(row=0, column=2, columnspan=2, sticky=W)
self.ok_button.grid(row=2, column=2)
self.cancel_button.grid(row=2, column=3)
def auto_y(self):
'''configures values afor check button'''
if self.check_var_1.get(): #if checked
state = 'disabled'
else:
state = 'enabled'
self.y_max_entry['state'] = state
self.y_min_entry['state'] = state
def load_settings(
self): #Inserts settings values(if not none) to tk.entry widghets
if (x := self.config['Y Limits']['y_max']) != 'None':
self.y_max_entry.insert(0, x)
if (x := self.config['Y Limits']['y_min']) != 'None':
self.y_min_entry.insert(0, x)
def save(event=None):
name = name_entry.get().strip()
if not mailbox:
# new mailbox
i = self.b_add.grid_info()['row']
self.b_add.grid_configure(row=i + 1)
c = Checkbutton(self.frame)
c.state(('selected',))
c.grid(row=i, column=0, pady=4, padx=(4, 0))
l = Label(self.frame, text=name)
l.grid(row=i, column=1, padx=4, pady=4)
b_edit = Button(self.frame, image=self.im_edit, width=1,
command=lambda m=name: self.mailbox_info(m))
b_edit.grid(row=i, column=2, padx=4, pady=4)
b_del = Button(self.frame, image=self.im_del, width=1,
command=lambda m=name: self.del_mailbox(m))
b_del.grid(row=i, column=3, padx=4, pady=4)
self.mailboxes[name] = [c, l, b_edit, b_del]
elif name != mailbox:
# change name of mailbox
os.remove(os.path.join(LOCAL_PATH, mailbox))
c, l, b_edit, b_del = self.mailboxes[mailbox]
del(self.mailboxes[mailbox])
l.configure(text=name)
b_edit.configure(command=lambda m=name: self.mailbox_info(m))
b_del.configure(command=lambda m=name: self.del_mailbox(m))
self.mailboxes[name] = [c, l, b_edit, b_del]
encrypt(name, self.pwd, server_entry.get().strip(),
login_entry.get().strip(), password_entry.get().strip(),
folder_entry.get().strip())
top.destroy()
def __init__(self, title="", message="", button="Ok", image=None,
checkmessage="", style="clam", **options):
"""
Create a messagebox with one button and a checkbox below the button:
parent: parent of the toplevel window
title: message box title
message: message box text
button: message displayed on the button
image: image displayed at the left of the message
checkmessage: message displayed next to the checkbox
**options: other options to pass to the Toplevel.__init__ method
"""
Tk.__init__(self, **options)
self.resizable(False, False)
self.title(title)
s = Style(self)
s.theme_use(style)
if image:
Label(self, text=message, wraplength=335,
font="Sans 11", compound="left",
image=image).grid(row=0, padx=10, pady=(10, 0))
else:
Label(self, text=message, wraplength=335,
font="Sans 11").grid(row=0, padx=10, pady=(10, 0))
b = Button(self, text=button, command=self.destroy)
b.grid(row=2, padx=10, pady=10)
self.var = BooleanVar(self)
c = Checkbutton(self, text=checkmessage, variable=self.var)
c.grid(row=1, padx=10, pady=0, sticky="e")
self.grab_set()
b.focus_set()
self.wait_window(self)
def PrintDataFrame(self,data,place):
row,col,width = self.row,0,0
for element in data.iloc[:, col]:
var = tk.BooleanVar()
var.set(True)
self.stateList.append(var)
checkBtn = Checkbutton(place, var=self.stateList[-1], onvalue=True, offvalue=False)
checkBtn.grid(row=row+1, column=0)
row = row + 1
row,col = self.row,0
while (col != len(data.columns)):
for element in data.iloc[:, col]:
if (width == 0):
width = len(data.columns[col])
if (len(str(element)) > width):
width = len(str(element))
dataFrameTitles = tk.Label(place, text=data.columns[col], font='Arial 10 bold', relief=tk.RIDGE,width=width + 1,bg='#D3D3D3')
dataFrameTitles.grid(row=row, column=col+1, sticky='w,e')
row = row + 1
color = 'White'
for element in data.iloc[:, col]:
dataFrameLabel = tk.Label(place, text=element, font='Arial 10', relief=tk.RIDGE, width=width + 1,bg=color)
dataFrameLabel.grid(row=row, column=col+1, sticky='w,e')
row = row + 1
if (color == 'White'):
color = '#D3D3D3'
else:
color = 'White'
row,width = self.row,0
col = col + 1
self.row = self.row + len(data.index) + 1
def main():
window = Tk()
window.title("Welcome Python GUI")
label = Label(window, text="My Label", font=("Arial Bold", 16))
label.grid(column=0, row=0)
txt = Entry(window, width=18)
txt.grid(column=1, row=0)
btn = Button(window,
text="Button",
bg="black",
fg="white",
command=lambda: clicked(label, txt))
btn.grid(column=2, row=0)
combo = Combobox(window)
combo['values'] = (1, 2, 3, 4, 5, "Text")
combo.current(1)
combo.grid(column=0, row=1)
chk_state = BooleanVar()
chk_state.set(False)
chk = Checkbutton(window, text='Choose', var=chk_state)
chk.grid(column=0, row=2)
window.geometry('640x480')
window.mainloop()
def _chkbox(self, init: dict, grid: dict) -> Checkbutton:
chkbox = Checkbutton(
master=init["master"] if "master" in init else self._frame,
text=init["text"],
variable=init["variable"],
command=init["command"] if "command" in init else None)
chkbox.grid(row=grid["row"], column=grid["column"], sticky=W, padx=2)
return chkbox
def render_ui(self):
'''Render the parameter UI elements and attach bindings'''
row = self.parent.get_row()
win = self.label_frame
# The parameter name
lab = Label(win, text=self.sherpa_par.name,
width=12, anchor="e")
lab.grid(row=row, column=0, padx=(5, 5), pady=2)
# The current parameter value
self.val_str = StringVar()
self.val = Entry(win, textvariable=self.val_str,
foreground="black", width=12, justify="right")
self.val.grid(row=row, column=1, padx=(5, 5), pady=2)
self.val.delete(0, END)
self.val.insert(0, self.__format_val(self.sherpa_par.val))
self.val.last_value = self.val.get()
self.val.bind("<KeyRelease>",
lambda x: self.entry_callback(x, field='val'))
# Frozen|Thawed checkbox. Checked if frozen.
self.fz_box = IntVar()
if self.sherpa_par.frozen is True:
self.fz_box.set(1)
else:
self.fz_box.set(0)
fzbtn = Checkbutton(win, text="", variable=self.fz_box,
command=self._freeze_thaw)
fzbtn.grid(row=row, column=2, padx=(5, 5), pady=2)
# The min value
self.min_str = StringVar()
self.min = Entry(win, textvariable=self.min_str,
foreground="black", width=12, justify="right")
self.min.grid(row=row, column=3, padx=(5, 5), pady=2)
self.min.delete(0, END)
self.min.insert(0, self.__format_val(self.sherpa_par.min))
self.min.last_value = self.min.get()
self.min.bind("<KeyRelease>",
lambda x: self.entry_callback(x, field='min'))
# The max value
self.max_str = StringVar()
self.max = Entry(win, textvariable=self.max_str,
foreground="black", width=12, justify="right")
self.max.grid(row=row, column=4, padx=(5, 5), pady=2)
self.max.delete(0, END)
self.max.insert(0, self.__format_val(self.sherpa_par.max))
self.max.last_value = self.max.get()
self.max.bind("<KeyRelease>",
lambda x: self.entry_callback(x, field='max'))
# The units of the parameter
par_units = Label(win, text="{}".format(self.sherpa_par.units),
width=20, anchor="e")
par_units.grid(row=row, column=5, padx=(5, 5), pady=2)
def __init__(self, master, pwd):
"""Create the mailbox manager dialog."""
Toplevel.__init__(self, master, class_="CheckMails")
self.title(_("Mailbox Manager"))
self.minsize(200, 10)
self.pwd = pwd
self.resizable(False, False)
self.protocol("WM_DELETE_WINDOW", self.quit)
self.im_add = PhotoImage(master=self, file=ADD)
self.im_del = PhotoImage(master=self, file=DEL)
self.im_edit = PhotoImage(master=self, file=EDIT)
self.mailboxes = {}
active = CONFIG.get("Mailboxes", "active").split(", ")
inactive = CONFIG.get("Mailboxes", "inactive").split(", ")
while "" in active:
active.remove("")
while "" in inactive:
inactive.remove("")
active.sort()
inactive.sort()
self.frame = Frame(self)
self.columnconfigure(0, weight=1)
self.frame.columnconfigure(1, weight=1)
self.frame.grid(row=0, column=0, padx=10, pady=10, sticky="eswn")
i = -1
for i, box in enumerate(active):
c = Checkbutton(self.frame)
c.state(('selected',))
c.grid(row=i, column=0, pady=4, padx=(4, 0))
l = Label(self.frame, text=box)
l.grid(row=i, column=1, padx=4, pady=4)
b_edit = Button(self.frame, image=self.im_edit, width=1,
command=lambda m=box: self.mailbox_info(m))
b_edit.grid(row=i, column=2, padx=4, pady=4)
b_del = Button(self.frame, image=self.im_del, width=1,
command=lambda m=box: self.del_mailbox(m))
b_del.grid(row=i, column=3, padx=4, pady=4)
self.mailboxes[box] = [c, l, b_edit, b_del]
for box in inactive:
i += 1
c = Checkbutton(self.frame)
c.grid(row=i, column=0, pady=4, padx=(4, 0))
l = Label(self.frame, text=box)
l.grid(row=i, column=1, padx=4, pady=4)
b_edit = Button(self.frame, image=self.im_edit, width=1,
command=lambda m=box: self.mailbox_info(m))
b_edit.grid(row=i, column=2, padx=4, pady=4)
b_del = Button(self.frame, image=self.im_del, width=1,
command=lambda m=box: self.del_mailbox(m))
b_del.grid(row=i, column=3, padx=4, pady=4)
self.mailboxes[box] = [c, l, b_edit, b_del]
self.b_add = Button(self.frame, image=self.im_add, command=self.mailbox_info, width=1)
self.b_add.grid(row=i + 1, column=0, columnspan=4, pady=4, padx=4, sticky='w')
def initUI(self):
gui_style = Style()
gui_style.configure('My.TRadioButton', foreground='#334353')
gui_style.configure('My.TFrame', columnspan=4)
self.parent.title("Commands")
self.pack(fill=BOTH, expand=True)
self.btn = tk.Button(self, text="Button", command=self.onButton1Click)
self.btn.grid(row=0, column=0, padx=15)
##self.btn.config(foreground = 'green')
self.btn['fg'] = 'dark green'
##cb = Checkbutton(self , text="Checkbutton", command=self.onButton2Click)
##cb.pack(side=LEFT)
self.parent.bind("<Escape>", self.quitApp)
self.var = BooleanVar()
cb = Checkbutton(self,
text="Bind event",
variable=self.var,
command=lambda: self.onBind(self.btn))
cb.grid(row=0, column=1)
self.rbvar = IntVar()
self.rbvar.set(1)
self._1 = 5
self._2 = 10
self._3 = 15
btnFrame = tk.Frame(self)
self.rb0 = tk.Radiobutton(btnFrame,
text="On",
variable=self.rbvar,
value=self._1,
foreground='red',
background='light gray',
command=self.rbSelected)
self.rb1 = tk.Radiobutton(btnFrame,
text="Off",
variable=self.rbvar,
value=self._2,
background='light gray',
command=self.rbSelected)
self.rb2 = tk.Radiobutton(btnFrame,
text="Limbo",
variable=self.rbvar,
value=self._3,
background='light gray',
command=self.rbSelected)
self.rb0.grid(row=0, column=0)
self.rb1.grid(row=0, column=1)
self.rb2.grid(row=0, column=2)
btnFrame.grid(row=1, column=0, sticky='news', padx=6, pady=12)
def create_extra(self):
"Add run mode on rows 10-12."
frame = self.frame
self.restartvar = BooleanVar(self, value=True)
restart = Checkbutton(frame, variable=self.restartvar, onvalue=True,
offvalue=False, text='Restart shell')
self.args_error = Label(frame, text=' ', foreground='red',
font=self.error_font)
restart.grid(column=0, row=10, columnspan=3, padx=5, sticky='w')
self.args_error.grid(column=0, row=12, columnspan=3, padx=5,
sticky='we')
def create_widgets(self):
super().create_widgets(ok_text='Run')
frame = self.frame
self.restartvar = BooleanVar(self, value=True)
restart = Checkbutton(frame, variable=self.restartvar, onvalue=True,
offvalue=False, text='Restart shell')
self.args_error = Label(frame, text=' ', foreground='red',
font=self.error_font)
restart.grid(column=0, row=4, columnspan=3, padx=5, sticky='w')
self.args_error.grid(column=0, row=12, columnspan=3, padx=5,
sticky='we')
class SegmentationConfigFrame(Frame):
def __init__(self, parent, configuration):
Frame.__init__(self, parent)
self.configuration = configuration
self.sigma_in = None
self.tau_in = None
self.position_in = None
self.position_value = None
self.init_view()
def init_view(self):
Label(self, text="Sigma").grid(row=0, column=0, sticky="w")
self.sigma_in = Entry(self)
self.sigma_in.insert(END, self.configuration.qs_sigma)
self.sigma_in.grid(row=0, column=1, sticky="w", padx=5, pady=5)
Label(self, text="Tau").grid(row=1, column=0, sticky="w")
self.tau_in = Entry(self)
self.tau_in.insert(END, self.configuration.qs_tau)
self.tau_in.grid(row=1, column=1, sticky="w", padx=5, pady=5)
self.position_value = IntVar()
self.position_in = Checkbutton(self,
text="Use position",
variable=self.position_value)
self.position_in.grid(row=2,
column=0,
columnspan=2,
sticky="w",
padx=5,
pady=5)
def get_values(self):
errors = []
try:
sigma_val = int(self.sigma_in.get())
except ValueError:
errors.append("Invalid value for sigma")
try:
tau_val = int(self.tau_in.get())
except ValueError:
errors.append("Invalid value for tau")
if errors:
raise ValidationError("Segmentation validation error", errors)
return sigma_val, tau_val, self.position_value.get()
def make_cdna_frame(self, parent):
cdna_f = Frame(parent, borderwidth=1, relief="sunken")
self.cdna = IntVar(cdna_f, value=1)
cb = Checkbutton(cdna_f, variable=self.cdna, text="get cDNA sequence")
cb.bind("<Button-1>", self.check_box_callback)
cb.grid(row=1, column=1, sticky="W")
self.splice = StringVar(cdna_f)
[Radiobutton(cdna_f,text=label[1],variable=self.splice,value=label[0])\
.grid(column=1,row=num+2,sticky="W") for num,label in \
enumerate(self.splice_values)]
self.splice.set("cds")
self.check_box_callback(cb)
return cdna_f
def make_gdna_frame(self, parent):
gdna_f = Frame(parent, borderwidth=1, relief="sunken")
self.gdna = IntVar(gdna_f, value=1)
cb = Checkbutton(gdna_f, variable=self.gdna, text="get gDNA sequence")
cb.bind("<Button-1>", self.check_box_callback)
cb.grid(row=1, column=1, sticky="W", columnspan=2)
self.flank = IntVar(gdna_f, value=0)
Entry(gdna_f, width=6, text=self.flank,
justify="right").grid(row=2, column=1, sticky="W")
Label(gdna_f, text="bp flanking gene").grid(row=2,
column=2,
sticky="W")
self.check_box_callback(cb)
return gdna_f
def __init__(self,
title="",
message="",
button="Ok",
image=None,
checkmessage="",
**options):
"""
Create a messagebox with one button and a checkbox below the button:
parent: parent of the toplevel window
title: message box title
message: message box text
button: message displayed on the button
image: image displayed at the left of the message
checkmessage: message displayed next to the checkbox
**options: other options to pass to the Toplevel.__init__ method
"""
Tk.__init__(self, **options)
self.title(title)
self.resizable(False, False)
self.columnconfigure(1, weight=1)
self.rowconfigure(0, weight=1)
style = Style(self)
style.theme_use(STYLE)
self.img = None
if isinstance(image, str):
try:
self.img = PhotoImage(file=image)
except TclError:
self.img = PhotoImage(data=image)
elif image:
self.img = image
if self.img:
Label(self, image=self.img).grid(row=0,
column=0,
padx=10,
pady=(10, 0))
Label(self, text=message, wraplength=335,
font="TkDefaultFont 10 bold").grid(row=0,
column=1,
padx=10,
pady=(10, 0))
b = Button(self, text=button, command=self.destroy)
b.grid(row=2, padx=10, pady=10, columnspan=2)
self.var = BooleanVar(self)
c = Checkbutton(self, text=checkmessage, variable=self.var)
c.grid(row=1, padx=10, pady=4, sticky="e", columnspan=2)
self.grab_set()
b.focus_set()
def popup_settings() -> None:
"""Открывает окно 'Настройки'."""
popup = Toplevel()
log_var = BooleanVar()
launchicon = PhotoImage(file = 'data/imgs/20ok.png')
center_x_pos = int(popup.winfo_screenwidth() / 2) - POPUP_WIDTH
center_y_pos = int(popup.winfo_screenheight() / 2) - POPUP_HEIGHT
popup.geometry(f'{POPUP_WIDTH}x{POPUP_HEIGHT}+'
f'{center_x_pos}+{center_y_pos}')
popup.title(_('Settings'))
popup.resizable(False, False)
frame_settings = LabelFrame(popup, text = _('Settings'))
frame_settings.grid(sticky = 'NWSE', column = 0, row = 0,
ipadx = 5, padx = 5, pady = 5)
lang_label = Label(frame_settings, text = _('Localisation'))
lang_label.grid(column = 0, row = 0, ipadx = 5)
logs_label = Label(frame_settings, text = _('Logging'))
logs_label.grid(column = 0, row = 1, ipadx = 5)
lang_vars = Combobox(frame_settings, state = 'readonly',
values = check_langs(), width = 4)
lang_vars.current(current_lang())
lang_vars.grid(column = 1, row = 0)
log_settings = Checkbutton(frame_settings,
variable = log_var, onvalue = True,
offvalue = False)
log_settings.grid(column = 1, row = 1)
if getconfig()['settings']['logging'] == 'True':
log_var.set(True)
elif getconfig()['settings']['logging'] == 'False':
log_var.set(False)
apply_button = Button(popup, text = _('Apply'), width = 20,
compound = 'left', image = launchicon,
command = lambda: apply(
lang_vars.get(),
popup, log_var.get()
)
)
apply_button.grid(column = 0, row = 1)
popup.grab_set()
popup.focus_set()
popup.wait_window()
def __init__(self, parent, values, callback, **kwargs):
super().__init__(parent, **kwargs)
self.callback = callback
self.options = []
self.values = {}
for value in values:
option_selected = IntVar(self.frame)
option = Checkbutton(self.frame,
text=value,
variable=option_selected,
command=partial(self._option_changed, value))
option.grid(padx=5, pady=5, sticky=W)
self.options.append((value, option_selected))
self.values[value] = option_selected
def __init__(self, window):
super(Parameters, self).__init__(window)
self.window = window
title = Label(self, text="Paramètres")
self.usespace = IntVar()
check_usespace = Checkbutton(self,
text="Espace préféré",
variable=self.usespace)
valide = Button(self, text="Valider", command=self.validate)
title.grid(row=0, column=0, padx=10, pady=10)
check_usespace.grid(row=1, column=0, padx=10, pady=5)
valide.grid(row=2, column=0, padx=10, pady=5)
self.setup_ui()
def make_feature_frame(self, parent):
primer_f = Frame(parent, borderwidth=1, relief="sunken")
self.get_primers = IntVar(primer_f, 0)
cb = Checkbutton(primer_f,
text="Import primers from file",
variable=self.get_primers)
cb.bind("<Button-1>", self.check_box_callback)
cb.grid(row=1, column=1, sticky="SNW", columnspan=3)
if self.default_primer_path and self.default_primer_path.exists():
self.primer_path = self.default_primer_path
else:
self.primer_path = plp().home().resolve()
primer_path_view = StringVar(primer_f, "")
self.text_view_limit(self.primer_path,
primer_path_view,
width=self.width)
Label(primer_f, text="Select primer file:",
justify="left").grid(row=2,
column=1,
sticky="SNEW",
columnspan=2)
kw = {
"method": tfd.askopenfilename,
"path_var": "primer_path",
"width": self.width,
"title": "Select primer file",
"str_var": primer_path_view
}
Button(primer_f,
textvariable=primer_path_view,
command=self.path_callback(**kw),
width=35,
style="B.TButton").grid(row=2,
column=3,
sticky="SNEW",
columnspan=3)
Label(primer_f, text="Allow up to", justify="left").grid(row=3,
column=1,
sticky="NWS")
self.mismatch = IntVar(primer_f, "0")
Entry(primer_f, textvariable=self.mismatch, justify="center",
width=3).grid(row=3, column=2, sticky="NWS")
Label(primer_f, text="mismatches in primers",
justify="left").grid(row=3, column=3, sticky="NWS")
self.check_box_callback(cb)
return primer_f
def __init__(self, parent, plot, k):
super(ClusterSelect,
self).__init__(parent) #,text="Scatterplot-Options")
self.plot = plot #type:SimpleScatter
self.ds = plot.ds
apply = plot.apply_settings
self.cvars = []
for i in range(k):
cv = StringVar(self, value="1")
cb = Checkbutton(self,
text="Cluster " + str(i),
variable=cv,
command=apply)
cb.grid(column=0, row=i, sticky=(N, E, W), columnspan=1)
self.cvars.append(cv)
def create_rdfs_frame(self, master:Notebook):
rdfsframe = Frame(master, padding = '3 3 3 3', width=600, height=400)
Label(rdfsframe, text='RDFS Name:', padding='3 3 3 3').grid(row=0, column=0, padx=3, pady=3)
rdfsNameLbl = Label(rdfsframe, textvariable=self.rdfsName,
background='#bbb', relief=SUNKEN, padding='3 0 3 3')
rdfsNameLbl.grid(row=0, column=1, columnspan=3, sticky=EW, padx=3, pady=6)
self.classtree.heading(column='#0', text='ClassTree')
ysb = Scrollbar(rdfsframe, orient='vertical', command=self.classtree.yview)
xsb = Scrollbar(rdfsframe, orient='horizontal', command=self.classtree.xview)
self.classtree.configure(yscrollcommand=ysb.set)
self.classtree.configure(xscrollcommand=xsb.set)
self.classtree.bind('<<TreeviewSelect>>', self.update_classinfo)
self.classtree.grid(row=1, column=0, columnspan=2, in_=rdfsframe, sticky=NSEW)
self.classtree.lift(rdfsframe)
self.classtree.tag_configure('include', foreground='black')
self.classtree.tag_configure('notinclude', foreground='gray')
ysb.grid(row=1, column=2, sticky=(NS))
xsb.grid(row=2, column=0, columnspan=2, sticky=(EW))
classinfoframe = Frame(rdfsframe, width=300, height=400)
classinfoframe.grid(row=1, column=3, padx=3, pady=3, sticky=(NSEW))
Label(classinfoframe, text='Class Name:',
font='bold', padding='3 3 3 3').grid(row=1, column=0, sticky=NW)
classNameLbl = Label(classinfoframe, textvariable=self.className,
background='#bbb', relief=SUNKEN, padding='3 3 3 3',
font='bold', width=25)
classNameLbl.grid(row=1, column=1, sticky=EW)
Label(classinfoframe, text='Description:',
font='bold', padding='3 3 3 3').grid(row=2, column=0, sticky=NW)
self.classDescrTxt.grid(row=2, column=1, in_=classinfoframe, sticky=EW)
self.classDescrTxt.lift(classinfoframe)
include_chk = Checkbutton(classinfoframe,
text='include this class',
variable=self.includeclass,
command=self.include_class)
include_chk.grid(row=3, column=1, sticky=E)
Label(classinfoframe, text='Properties:',
font='bold', padding='3 3 3 3').grid(row=5, column=0, sticky=NW)
self.propertiesframe.grid(in_ = classinfoframe, row=5, column=1, sticky=(N+E+S+W))
self.propertiesframe.lift(classinfoframe)
classinfoframe.rowconfigure(5, weight=1)
classinfoframe.columnconfigure(1, weight=1)
rdfsframe.columnconfigure(1, weight=1)
rdfsframe.columnconfigure(3, weight=3)
rdfsframe.rowconfigure(1, weight=1)
master.add(rdfsframe, text='RDFS')
def _create_widgets(self):
frame = Frame(self)
frame.grid(sticky='nsew')
# TODO: add line to show destination for data? maybe source too...
# number of files being transferred and total size
lbl_file_count = Label(frame, textvariable=self.file_count_var)
lbl_file_count.grid(column=0, row=0)
lbl_total_size = Label(frame, textvariable=self.total_file_size)
lbl_total_size.grid(column=1, row=0)
# info about current file being transferred
label2 = Label(frame, text="Current file being transferred:")
label2.grid(column=0, row=1, columnspan=2, sticky='w')
lbl_curr_file = Label(frame, textvariable=self.curr_file, width=60)
lbl_curr_file.grid(column=0, row=2)
self.file_prog = Progressbar(frame, variable=self.curr_file_progress)
self.file_prog.grid(column=1, row=2, pady=2)
# info about total progress
label3 = Label(frame, text="Overall progress:")
label3.grid(column=0, row=3, sticky='w')
total_prog = Progressbar(frame,
variable=self.transferred_count,
maximum=self.file_count)
total_prog.grid(column=1, row=3)
# buttons
btn_frame = Frame(frame)
force_check = Checkbutton(btn_frame,
text="Force",
variable=self.force_override)
force_check.grid(column=0, row=0, sticky='e')
verify_check = Checkbutton(btn_frame,
text="Verify",
variable=self.verify)
if self.opt_verify:
verify_check.grid(column=1, row=0, sticky='e')
ttm.register(force_check,
("Whether to force the overwriting of current data.\n"
"This should only be done if there was an error and the "
"data needs to be re-sent."))
btn_start = Button(btn_frame, text="Begin", command=self._transfer)
btn_start.grid(column=2, row=0, sticky='e')
btn_exit = Button(btn_frame, text="Exit", command=self._exit)
btn_exit.grid(column=3, row=0, sticky='w')
btn_frame.grid(column=0, row=4, columnspan=2)
def init_ui(self):
self.master.title("MAC forger")
self.master.resizable(False, False)
Style().configure("TButton", padding=(0, 5, 0, 5), font='serif 10', foreground='Blue')
Style().configure("TLabel", font='serif 10')
Style().configure("TCheckbutton", foreground='Blue')
Style().configure("mac.TLabel", font='serif 12', foreground='Red')
title = Label(self, text="MAC forger")
title.grid(row=0)
interfaces_label = Label(self.master, text="Interface:")
interfaces_label.grid(row=1, column=0, sticky=E, pady=10, padx=20)
self.interface_selected.set(self.interfaces[0])
interfaces = OptionMenu(self.master, self.interface_selected, *self.interfaces)
interfaces.grid(row=1, column=1, sticky=(E, W), pady=10, padx=20)
self.interface_selected.trace_add('write', self.reload_mac)
reload_button = Button(self.master, text="Reload", command=self.update_interface)
reload_button.grid(row=1, column=2, pady=10, padx=10)
reload_button = Button(self.master, text="Reload All", command=self.update_interfaces)
reload_button.grid(row=1, column=3, pady=10, padx=10)
actual_mac_label = Label(self.master, text="Actual MAC Address:")
actual_mac_label.grid(row=2, column=0, sticky=E, pady=10, padx=20, rowspan=2)
actual_mac = Label(self.master, style='mac.TLabel', justify=CENTER, textvariable=self.actual_mac)
actual_mac.grid(row=2, column=1, pady=10, padx=20, rowspan=2)
self.actual_mac.set("FF : FF : FF : FF : FF : FF")
reload_interface = Checkbutton(self.master, text=" Reload interface\n after changes", variable=self.reload_interface)
reload_interface.grid(row=2, column=2, padx=5, rowspan=2, sticky=(N, W))
fix_button = Checkbutton(self.master, text=" Fix 1° byte", variable=self.fix_first_byte)
fix_button.grid(row=3, column=2, padx=5, rowspan=2, sticky=(N, W))
reset_button = Button(self.master, text="Restore\n Default", command=self.reset_mac)
reset_button.grid(row=2, column=3, pady=10, padx=5, rowspan=2)
mac_label = Label(self.master, text="MAC Address: ")
mac_label.grid(row=4, column=0, sticky=E, pady=10, padx=20)
mac_entry = Entry(width=25, justify=CENTER, font='serif 12', textvariable=self.mac)
mac_entry.grid(row=4, column=1, pady=10, padx=20)
self.mac.set("FF:FF:FF:FF:FF:FF")
self.mac.trace_add('write', self.mac_entry_rules)
random_button = Button(self.master, text="Generate\nRandom", command=self.random_mac)
random_button.grid(row=4, column=2, pady=10, padx=5)
change_button = Button(self.master, text="Confirm\n MAC", command=self.change_mac)
change_button.grid(row=4, column=3, pady=10, padx=5)
class HControls(LabelFrame):
def __init__(self, parent, params):
super(HControls, self).__init__(parent, text="Histogram-Options")
self.params = params
self.parent = parent #type:SimpleScatter
apply_changes = self.parent.apply_settings
#logarithmic scale
self.lgvar = StringVar(value="0")
self.log_cb = Checkbutton(self,
text='logarithmic scale',
command=apply_changes,
variable=self.lgvar)
self.log_cb.grid(column=0, row=1, sticky=(W, N), columnspan=2)
# returns True if the setting for a logarithmic scale is enabled, else False
def doLog(self):
return self.lgvar.get() is not "0"
def query_and_result(self,query_from_client):
query = str(query_from_client)
n_relevant_docs,relevant_docs = self.start_search(query=query)
# create canvas
canvas = Canvas(self.master)
canvas.grid(row=4, columnspan=3, sticky="news")
# create another frame
canvas_Frame = Frame(canvas)
canvas.create_window((0, 0), window=canvas_Frame, anchor=N + W)
if n_relevant_docs > 0:
sort_var = IntVar()
sort_time_chack_btn = Checkbutton(self.master,text="sort by time",onvalue=0 ,variable=sort_var,command=lambda :self.sort_by_time(canvas_Frame,relevant_docs))
sort_pop_chack_btn = Checkbutton(self.master,text="sort by popularity",onvalue=1,variable=sort_var,command=lambda :self.sort_by_pop(canvas_Frame,relevant_docs))
sort_chack_btn = Checkbutton(self.master, text="sort by relevant", onvalue=2, variable=sort_var,
command=lambda: self.print_results(canvas_Frame, relevant_docs))
sort_chack_btn.grid(row=3, column=0)
sort_pop_chack_btn.grid(row=3, column=1)
sort_time_chack_btn.grid(row=3, column=2)
#create scrollbar
scrollbar = Scrollbar(self.master, orient="vertical", command=canvas.yview)
scrollbar.grid(row=3, columnspan=4,sticky=E)
#bind canvas and scrollbar
canvas.configure(yscrollcommand=scrollbar.set)
canvas.bind('<Configure>',lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
n_text = "There is "+str(n_relevant_docs)+" results"
n_lable = Label(canvas_Frame, text=n_text, font=("serif", 10))
n_lable.grid(row=3, column=1)
self.print_results(canvas_Frame= canvas_Frame,relevant_docs=relevant_docs)
def __init__(self, parent, funnel, index, command_stack):
tk.Frame.__init__(self, parent, borderwidth=4, relief="raised")
Subscriber.__init__(self, funnel)
Observable.__init__(self)
self._funnel = funnel
self._command_stack = command_stack
self._active_var = tk.IntVar()
self._active_var.trace_add("write", self._switch_active)
self._position_var = tk.StringVar()
self._position_var.trace_add("write", self._set_position)
self._oval_var = tk.IntVar()
self._oval_var.trace_add("write", self._switch_oval)
self._update()
self.bind("<Button-1>", self._on_click)
is_active = Checkbutton(self,
text=f"Funnel n°{index}: ",
variable=self._active_var)
is_active.grid(columnspan=3)
is_active.bind("<FocusIn>", self._on_get_focus)
is_active.bind("<FocusOut>", self._on_lost_focus)
pos_label = Label(self, text=" Position: ")
pos_label.grid(sticky=tk.E)
pos_label.bind("<Button-1>", self._on_click)
self._pos_entry = Entry(self, textvariable=self._position_var, width=6)
self._pos_entry.grid(row=1, column=1, sticky=tk.W)
self._pos_entry.bind("<FocusIn>", self._on_get_focus)
self._pos_entry.bind("<FocusOut>", self._on_lost_focus)
is_oval = Checkbutton(self, text="Is Oval", variable=self._oval_var)
is_oval.grid(row=1, column=2)
is_oval.bind("<FocusIn>", self._on_get_focus)
is_oval.bind("<FocusOut>", self._on_lost_focus)
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(2, weight=1)
def __init__(self, master, ordinances=False, **kwargs):
super(Options, self).__init__(master, **kwargs)
self.ancestors = IntVar()
self.ancestors.set(4)
self.descendants = IntVar()
self.spouses = IntVar()
self.ordinances = IntVar()
self.contributors = IntVar()
self.start_indis = StartIndis(self)
self.fid = StringVar()
btn = Frame(self)
entry_fid = EntryWithMenu(btn, textvariable=self.fid, width=16)
entry_fid.bind('<Key>', self.enter)
label_ancestors = Label(self, text=_('Number of generations to ascend'))
entry_ancestors = EntryWithMenu(self, textvariable=self.ancestors, width=5)
label_descendants = Label(self, text=_('Number of generations to descend'))
entry_descendants = EntryWithMenu(self, textvariable=self.descendants, width=5)
btn_add_indi = Button(btn, text=_('Add a FamilySearch ID'), command=self.add_indi)
btn_spouses = Checkbutton(self, text='\t' + _('Add spouses and couples information'), variable=self.spouses)
btn_ordinances = Checkbutton(self, text='\t' + _('Add Temple information'), variable=self.ordinances)
btn_contributors = Checkbutton(self, text='\t' + _('Add list of contributors in notes'), variable=self.contributors)
self.start_indis.grid(row=0, column=0, columnspan=3)
entry_fid.grid(row=0, column=0, sticky='w')
btn_add_indi.grid(row=0, column=1, sticky='w')
btn.grid(row=1, column=0, columnspan=2, sticky='w')
entry_ancestors.grid(row=2, column=0, sticky='w')
label_ancestors.grid(row=2, column=1, sticky='w')
entry_descendants.grid(row=3, column=0, sticky='w')
label_descendants.grid(row=3, column=1, sticky='w')
btn_spouses.grid(row=4, column=0, columnspan=2, sticky='w')
if ordinances:
btn_ordinances.grid(row=5, column=0, columnspan=3, sticky='w')
btn_contributors.grid(row=6, column=0, columnspan=3, sticky='w')
entry_ancestors.focus_set()
def make_auto_open(self, parent):
auto_f = Frame(parent)
self.do_open = IntVar(auto_f, value=1)
cb = Checkbutton(
auto_f,
variable=self.do_open,
text="Automatically open files after annotation complete")
cb.bind("<Button-1>", self.check_box_callback)
cb.grid(row=1, column=1, sticky="NW", columnspan=3)
if self.default_program_path and self.default_program_path.exists():
self.program_path = self.default_program_path
else:
self.program_path = plp.home()
for i in self.program_locations:
if i.exists():
self.program_path = i
program_path_view = StringVar(auto_f, "")
self.text_view_limit(self.program_path,
program_path_view,
width=self.width)
Label(auto_f, text="Select ApE program:",
justify="left").grid(row=2, column=1, sticky="SNW", columnspan=2)
kw = {
"method": tfd.askopenfilename,
"path_var": "program_path",
"title": "Select ApE program",
"str_var": program_path_view,
"width": self.width
}
Button(auto_f,
textvariable=program_path_view,
command=self.path_callback(**kw),
width=35,
style="B.TButton").grid(row=2,
column=3,
sticky="NSW",
columnspan=3)
self.check_box_callback(cb)
return auto_f
def _add_checkbox_to_frame_grid(
cls,
frame_and_name: FrameAndName,
text: str,
var: Variable,
on_value,
off_value,
function: Callable,
row: int,
column: int,
sticky: GridPositionEnum = GridPositionEnum.NONE) -> Checkbutton:
cls._debug(f'Add Checkbox Grid [{text}] Row [{row}] Column [{column}]')
checkbox = \
Checkbutton(
frame_and_name.frame,
text='Show only active securities',
variable=var,
onvalue=on_value,
offvalue=off_value,
command=function)
checkbox.grid(row=row, column=column, sticky=sticky.value)
return checkbox
def open_light_settings( self, top, toplevel = 0 ):
""" Opens a dialog for modifying the light settings """
L = self.dir['canvas'].config("lighting")
frame = tk.Frame(top)
vars = [tk.IntVar() for val in range(len(L.settings))]
[var.set(val) for var,val in zip(vars,L.settings.values())]
def set(key,val):
if key == 'texture':
self.dir['canvas'].texture = 1-self.dir['canvas'].texture
L.settings[key] = self.dir['canvas'].texture
elif key == 'fill':
self.dir['canvas'].fill = 1-self.dir['canvas'].fill
L.settings[key] = self.dir['canvas'].fill
else: L.settings[key] = 1-L.settings[key]
for i,(key,val) in enumerate(L.settings.items()):
choice = Checkbutton(top,text=str(key),variable=vars[i])
choice.config(command=lambda i=i,
key=key:set(key,val))
choice.grid(row=i,column=0,sticky='w')
if toplevel:
top.mainloop()
def __init__(self, master, ordinances=False, **kwargs):
super().__init__(master, **kwargs)
self.ancestors = IntVar()
self.ancestors.set(4)
self.descendants = IntVar()
self.spouses = IntVar()
self.ordinances = IntVar()
self.contributors = IntVar()
self.start_indis = StartIndis(self)
self.fid = StringVar()
btn = Frame(self)
entry_fid = EntryWithMenu(btn, textvariable=self.fid, width=16)
entry_fid.bind("<Key>", self.enter)
label_ancestors = Label(self,
text=_("Number of generations to ascend"))
entry_ancestors = EntryWithMenu(self,
textvariable=self.ancestors,
width=5)
label_descendants = Label(self,
text=_("Number of generations to descend"))
entry_descendants = EntryWithMenu(self,
textvariable=self.descendants,
width=5)
btn_add_indi = Button(btn,
text=_("Add a FamilySearch ID"),
command=self.add_indi)
btn_spouses = Checkbutton(
self,
text="\t" + _("Add spouses and couples information"),
variable=self.spouses,
)
btn_ordinances = Checkbutton(self,
text="\t" + _("Add Temple information"),
variable=self.ordinances)
btn_contributors = Checkbutton(
self,
text="\t" + _("Add list of contributors in notes"),
variable=self.contributors,
)
self.start_indis.grid(row=0, column=0, columnspan=3)
entry_fid.grid(row=0, column=0, sticky="w")
btn_add_indi.grid(row=0, column=1, sticky="w")
btn.grid(row=1, column=0, columnspan=2, sticky="w")
entry_ancestors.grid(row=2, column=0, sticky="w")
label_ancestors.grid(row=2, column=1, sticky="w")
entry_descendants.grid(row=3, column=0, sticky="w")
label_descendants.grid(row=3, column=1, sticky="w")
btn_spouses.grid(row=4, column=0, columnspan=2, sticky="w")
if ordinances:
btn_ordinances.grid(row=5, column=0, columnspan=3, sticky="w")
btn_contributors.grid(row=6, column=0, columnspan=3, sticky="w")
entry_ancestors.focus_set()
class MarkovDemo(Frame):
"MarkovDemo(master=None, **kw) -> MarkovDemo instance"
TEXT = dict(height=2, width=46, wrap=WORD) # Text Options
GRID = dict(padx=5, pady=5) # Grid Options
# Initialize a MarkovDemo instance with a GUI for interaction.
def __init__(self, master=None, **kw):
"Initialize the MarkovDemo instance's widgets and settings."
super().__init__(master, **kw)
self.build_widgets()
self.place_widgets()
self.setup_widgets()
self.grid_rowconfigure(2, weight=1)
self.grid_rowconfigure(3, weight=1)
self.grid_columnconfigure(0, weight=1)
self.key = self.primer = None
def build_widgets(self):
"Build the various widgets that will be used in the program."
# Create processing frame widgets.
self.processing_frame = LabelFrame(self, text='Processing Mode:')
self.mode_var = StringVar(self, 'encode')
self.decode_button = Radiobutton(self.processing_frame,
text='Decode Cipher-Text',
command=self.handle_radiobuttons,
value='decode',
variable=self.mode_var)
self.encode_button = Radiobutton(self.processing_frame,
text='Encode Plain-Text',
command=self.handle_radiobuttons,
value='encode',
variable=self.mode_var)
self.freeze_var = BooleanVar(self, False)
self.freeze_button = Checkbutton(self.processing_frame,
text='Freeze Key & Primer',
command=self.handle_checkbutton,
offvalue=False,
onvalue=True,
variable=self.freeze_var)
# Create encoding frame widgets.
self.encoding_frame = LabelFrame(self, text='Encoding Options:')
self.chain_size_label = Label(self.encoding_frame, text='Chain Size:')
self.chain_size_entry = Entry(self.encoding_frame)
self.plain_text_label = Label(self.encoding_frame, text='Plain-Text:')
self.plain_text_entry = Entry(self.encoding_frame)
# Create input frame widgets.
self.input_frame = LabelFrame(self, text='Input Area:')
self.input_text = ScrolledText(self.input_frame, **self.TEXT)
# Create output frame widgets.
self.output_frame = LabelFrame(self, text='Output Area:')
self.output_text = ScrolledText(self.output_frame, **self.TEXT)
def place_widgets(self):
"Place the widgets where they belong in the MarkovDemo frame."
# Locate processing frame widgets.
self.processing_frame.grid(sticky=EW, **self.GRID)
self.decode_button.grid(row=0, column=0, **self.GRID)
self.encode_button.grid(row=0, column=1, **self.GRID)
self.freeze_button.grid(row=0, column=2, **self.GRID)
# Locate encoding frame widgets.
self.encoding_frame.grid(sticky=EW, **self.GRID)
self.chain_size_label.grid(row=0, column=0, sticky=W, **self.GRID)
self.chain_size_entry.grid(row=0, column=1, sticky=EW, **self.GRID)
self.plain_text_label.grid(row=1, column=0, sticky=W, **self.GRID)
self.plain_text_entry.grid(row=1, column=1, sticky=EW, **self.GRID)
self.encoding_frame.grid_columnconfigure(1, weight=1)
# Locate input frame widgets.
self.input_frame.grid(sticky=NSEW, **self.GRID)
self.input_text.grid(sticky=NSEW, **self.GRID)
self.input_frame.grid_rowconfigure(0, weight=1)
self.input_frame.grid_columnconfigure(0, weight=1)
# Locate output frame widgets.
self.output_frame.grid(sticky=NSEW, **self.GRID)
self.output_text.grid(sticky=NSEW, **self.GRID)
self.output_frame.grid_rowconfigure(0, weight=1)
self.output_frame.grid_columnconfigure(0, weight=1)
def setup_widgets(self):
"Setup each widget's configuration for the events they handle."
self.input_text.bind('<Key>', self.handle_key_events)
self.input_text.bind('<Control-Key-a>', self.handle_control_a)
self.input_text.bind('<Control-Key-/>', lambda event: 'break')
self.output_text['state'] = DISABLED
self.output_text.bind('<Control-Key-a>', self.handle_control_a)
self.output_text.bind('<Control-Key-/>', lambda event: 'break')
########################################################################
# Take care of any special event needing dedicated processing.
def handle_radiobuttons(self):
"Change the interface based on the encoding / decoding setting."
if self.encrypting:
self.freeze_button.grid()
if not self.freeze_var.get():
self.encoding_frame.grid()
else:
self.freeze_button.grid_remove()
if not self.freeze_var.get():
self.encoding_frame.grid_remove()
self.handle_key_events(None)
def handle_checkbutton(self):
"Change the interface based on the key / primer freeze setting."
if self.freeze_var.get():
self.encoding_frame.grid_remove()
else:
self.encoding_frame.grid()
def handle_key_events(self, event):
"Schedule refreshing the output area after an input area event."
if event is None or event.char and event.state | 0o11 == 0o11:
self.after_idle(self.refresh)
@staticmethod
def handle_control_a(event):
"Select all text in the widget associated with the given event."
event.widget.tag_add(SEL, 1.0, END + '-1c')
return 'break'
########################################################################
# Handle interface's updates when either encoding or decoding.
def refresh(self):
"Refresh the output based on the value of the input."
text = self.input_text.get(1.0, END + '-1c')
if not text:
self.output = text
elif self.encrypting:
self.encode(text)
else:
self.decode(text)
def output(self, value):
"Set the text in the output area to the string value."
self.output_text['state'] = NORMAL
self.output_text.delete(1.0, END)
self.output_text.insert(END, value)
if self.encrypting and self.freeze_var.get():
self.output_text.see(END)
self.output_text['state'] = DISABLED
output = property(fset=output, doc='Output area property.')
@property
def chain_size(self):
"Chain size for the Markov chains used when encrypting."
try:
value = ast.literal_eval(self.chain_size_entry.get())
assert isinstance(value, int) and 2 <= value <= 256
return value
except:
self.chain_size_entry.delete(0, END)
self.chain_size_entry.insert(0, '2')
return 2
@property
def plain_text(self):
"Plain text or ignored characters in encryption process."
try:
value = self.repr_to_obj(self.plain_text_entry.get(), '')
assert isinstance(value, str)
return value
except:
self.plain_text_entry.delete(0, END)
return ''
########################################################################
# Encrypt a string for display in the interface's output area.
def encode(self, string):
"Encode the string and show the cipher-text in the output."
try:
cipher = self.build_cipher(string)
except ValueError:
self.output = ''
except:
self.output = traceback.format_exc()
else:
self.output = self.build_header() + '\n\n' + cipher
def build_cipher(self, string):
"Build cipher-text based on plain-text and return answer."
if self.key and self.freeze_var.get():
cipher, primer = me.encrypt_str(string, self.key, self.primer)
else:
args = string, self.chain_size, self.plain_text
cipher, self.key, self.primer = me.auto_encrypt_str(*args)
return cipher
def build_header(self):
"Build header from key and primer values in current use."
header = '\n'.join(map(self.bytes_to_repr, self.key.data))
header += '\n' + self.bytes_to_repr(self.primer.data)
return header
########################################################################
# Decrypt a string for display in the interface's output area.
def decode(self, string):
"Decode encrypted message and display plain-text in output."
try:
cipher = self.extract_keys(string)
text = self.extract_text(cipher)
except ValueError:
self.output = ''
except:
self.output = traceback.format_exc()
else:
self.output = text
def extract_keys(self, string):
"Extract keys to decryption and return the cipher-text area."
header, cipher = string.split('\n\n', 1)
*key, primer = map(self.repr_to_obj, header.split('\n'))
self.key, self.primer = me.Key(tuple(key)), me.Primer(primer)
return cipher
def extract_text(self, string):
"Extract text message from string using built key and primer."
text, primer = me.decrypt_str(string, self.key, self.primer)
return text
########################################################################
# Provide some special methods to simplify the program's code.
@property
def encrypting(self):
"Encrypting boolean stating current operations mode."
return {'encode': True, 'decode': False}[self.mode_var.get()]
@staticmethod
def bytes_to_repr(obj):
"Convert bytes object into suitable representation."
if not isinstance(obj, bytes):
raise TypeError('Object must be a bytes instance!')
return repr(obj)[2:-1]
@staticmethod
def repr_to_obj(string, prefix='b'):
"Convert representation into an equivalent object."
for template in '{}"{}"', "{}'{}'":
try:
return ast.literal_eval(template.format(prefix, string))
except:
pass
raise ValueError('Cannot convert {!r} to object!'.format(string))
@classmethod
def main(cls):
"Create context for demo and run a test instance."
NoDefaultRoot()
root = Tk()
root.minsize(420, 330)
root.title('Markov Demo 2')
test = cls(root)
test.grid(sticky=NSEW)
root.grid_rowconfigure(0, weight=1)
root.grid_columnconfigure(0, weight=1)
root.mainloop()
def create_widgets(self):
''' Creates all widgets.
'''
rts_lbl = Label(self, text='Return to scale:')
rts_lbl.grid(row=0, column=0, padx=XPAD_VALUE, pady=YPAD_VALUE,
sticky=W)
self._create_frame_with_radio_btns(self, 'RETURN_TO_SCALE',
['VRS', 'CRS'],
row_index=1, column_index=0)
orientation_lbl = Label(self, text='Orientation:')
orientation_lbl.grid(row=0, column=1, sticky=W, padx=XPAD_VALUE,
pady=YPAD_VALUE)
self._create_frame_with_radio_btns(self, 'ORIENTATION',
['Input', 'Output'],
row_index=1, column_index=1)
model_lbl = Label(self, text='Model:')
model_lbl.grid(row=0, column=2, padx=XPAD_VALUE, pady=YPAD_VALUE,
sticky=W)
self._create_frame_with_radio_btns(self, 'DEA_FORM',
['Envelopment', 'Multiplier'],
row_index=1, column_index=2,
add_both=False)
other_lbl = Label(self, text='Others:')
other_lbl.grid(row=0, column=3, sticky=W, padx=XPAD_VALUE)
max_slacks = IntVar()
self.options['MAXIMIZE_SLACKS'] = max_slacks
frame_other_options = Frame(self)
self.max_slack_box = max_slacks_check_btn = Checkbutton(
frame_other_options, text='Two phase', variable=max_slacks,
command=(lambda: self.on_check_box_click(
max_slacks, 'MAXIMIZE_SLACKS')))
max_slacks_check_btn.grid(row=1, column=0, sticky=W)
super_efficiency = IntVar()
self.options['USE_SUPER_EFFICIENCY'] = super_efficiency
super_efficiency_check_btn = Checkbutton(frame_other_options,
text='Super efficiency',
variable=super_efficiency,
command=(
lambda: self.on_check_box_click(
super_efficiency,
'USE_SUPER_EFFICIENCY')))
super_efficiency_check_btn.grid(row=2, column=0, sticky=W)
peel_the_onion = IntVar()
self.options['PEEL_THE_ONION'] = peel_the_onion
peel_the_onion_check_btn = Checkbutton(
frame_other_options, text='Peel the onion', variable=peel_the_onion,
command=(lambda: self.on_check_box_click(peel_the_onion,
'PEEL_THE_ONION')))
peel_the_onion_check_btn.grid(row=3, column=0, sticky=W)
frame_other_options.grid(row=1, column=3, padx=XPAD_VALUE,
pady=YPAD_VALUE, sticky=W)
frame_for_toleramce = Frame(self)
tolerance_lbl = Label(frame_for_toleramce,
text='Multiplier model tolerance:')
tolerance_lbl.grid(row=0, column=0, padx=XPAD_VALUE, pady=YPAD_VALUE,
sticky=W)
tolerance_ent = Entry(frame_for_toleramce, width=5,
textvariable=self.multi_tol_strvar)
tolerance_ent.insert(END, 0)
tolerance_ent.grid(row=0, column=1, sticky=W, padx=XPAD_VALUE)
categorical_lbl = Label(frame_for_toleramce, text='Categorical:')
categorical_lbl.grid(row=1, column=0, padx=XPAD_VALUE,
pady=YPAD_VALUE, sticky=W)
self.categorical_box = categorical_box = Combobox(
frame_for_toleramce, textvariable=self.combobox_text_var,
exportselection=0, state="readonly",
width=20, values=(''),
postcommand=self.change_categorical_box)
categorical_box.grid(row=1, column=1, padx=XPAD_VALUE,
pady=YPAD_VALUE, sticky=W)
frame_for_toleramce.grid(row=5, column=0, sticky=W, padx=XPAD_VALUE,
pady=YPAD_VALUE, columnspan=4)
lbl = Label(window, text="Текст Label: ") #добавить текст
lbl.grid(column=0, row=0) #позиция текста
txt = Entry(
window,
width=10) #форма ввода. Для выключения формы ввода , state='disabled
txt.grid(column=1, row=0) #позиция ввода
btn = Button(window, text="▲ Кнопка", command=clicked) #добавить кнопку
btn.grid(column=2, row=0) #позиция кнопки
combo = Combobox(window) #создаём окно
combo['values'] = ("Виджет Combobox →", 1, 2, 3, 4, 5) #вводим значение
combo.current(0) #какую строку выводит?
combo.grid(column=0, row=1) #размеры окна
chk_state = BooleanVar() #логический тип данных
chk_state.set(
0) # задайте проверку состояния чекбокса 0 False(Ложь), 1 True(Истина)
chk = Checkbutton(window, text='← Виджет Checkbutton', var=chk_state) #
chk.grid(column=0, row=2) #позиция кнопки
rad1 = Radiobutton(window, text='Первый', value=1) #Кнопка чекбокс с названием
rad2 = Radiobutton(window, text='Второй', value=2)
rad3 = Radiobutton(window, text='Третий', value=3)
rad1.grid(column=0, row=3) #позиция
rad2.grid(column=1, row=3) #позиция
rad3.grid(column=2, row=3) #позиция
window.mainloop() #функция бесконечного окна
def create_widgets(self):
self.frame = frame = Frame(self, borderwidth=2, relief='sunken')
frame.pack(side='top', expand=True, fill='both')
frame_buttons = Frame(self)
frame_buttons.pack(side='bottom', fill='x')
self.button_ok = Button(frame_buttons, text='OK',
width=8, command=self.ok)
self.button_ok.grid(row=0, column=0, padx=5, pady=5)
self.button_cancel = Button(frame_buttons, text='Cancel',
width=8, command=self.cancel)
self.button_cancel.grid(row=0, column=1, padx=5, pady=5)
# Basic entry key sequence.
self.frame_keyseq_basic = Frame(frame, name='keyseq_basic')
self.frame_keyseq_basic.grid(row=0, column=0, sticky='nsew',
padx=5, pady=5)
basic_title = Label(self.frame_keyseq_basic,
text=f"New keys for '{self.action}' :")
basic_title.pack(anchor='w')
basic_keys = Label(self.frame_keyseq_basic, justify='left',
textvariable=self.key_string, relief='groove',
borderwidth=2)
basic_keys.pack(ipadx=5, ipady=5, fill='x')
# Basic entry controls.
self.frame_controls_basic = Frame(frame)
self.frame_controls_basic.grid(row=1, column=0, sticky='nsew', padx=5)
# Basic entry modifiers.
self.modifier_checkbuttons = {}
column = 0
for modifier, variable in zip(self.modifiers, self.modifier_vars):
label = self.modifier_label.get(modifier, modifier)
check = Checkbutton(self.frame_controls_basic,
command=self.build_key_string, text=label,
variable=variable, onvalue=modifier, offvalue='')
check.grid(row=0, column=column, padx=2, sticky='w')
self.modifier_checkbuttons[modifier] = check
column += 1
# Basic entry help text.
help_basic = Label(self.frame_controls_basic, justify='left',
text="Select the desired modifier keys\n"+
"above, and the final key from the\n"+
"list on the right.\n\n" +
"Use upper case Symbols when using\n" +
"the Shift modifier. (Letters will be\n" +
"converted automatically.)")
help_basic.grid(row=1, column=0, columnspan=4, padx=2, sticky='w')
# Basic entry key list.
self.list_keys_final = Listbox(self.frame_controls_basic, width=15,
height=10, selectmode='single')
self.list_keys_final.insert('end', *AVAILABLE_KEYS)
self.list_keys_final.bind('<ButtonRelease-1>', self.final_key_selected)
self.list_keys_final.grid(row=0, column=4, rowspan=4, sticky='ns')
scroll_keys_final = Scrollbar(self.frame_controls_basic,
orient='vertical',
command=self.list_keys_final.yview)
self.list_keys_final.config(yscrollcommand=scroll_keys_final.set)
scroll_keys_final.grid(row=0, column=5, rowspan=4, sticky='ns')
self.button_clear = Button(self.frame_controls_basic,
text='Clear Keys',
command=self.clear_key_seq)
self.button_clear.grid(row=2, column=0, columnspan=4)
# Advanced entry key sequence.
self.frame_keyseq_advanced = Frame(frame, name='keyseq_advanced')
self.frame_keyseq_advanced.grid(row=0, column=0, sticky='nsew',
padx=5, pady=5)
advanced_title = Label(self.frame_keyseq_advanced, justify='left',
text=f"Enter new binding(s) for '{self.action}' :\n" +
"(These bindings will not be checked for validity!)")
advanced_title.pack(anchor='w')
self.advanced_keys = Entry(self.frame_keyseq_advanced,
textvariable=self.key_string)
self.advanced_keys.pack(fill='x')
# Advanced entry help text.
self.frame_help_advanced = Frame(frame)
self.frame_help_advanced.grid(row=1, column=0, sticky='nsew', padx=5)
help_advanced = Label(self.frame_help_advanced, justify='left',
text="Key bindings are specified using Tkinter keysyms as\n"+
"in these samples: <Control-f>, <Shift-F2>, <F12>,\n"
"<Control-space>, <Meta-less>, <Control-Alt-Shift-X>.\n"
"Upper case is used when the Shift modifier is present!\n\n" +
"'Emacs style' multi-keystroke bindings are specified as\n" +
"follows: <Control-x><Control-y>, where the first key\n" +
"is the 'do-nothing' keybinding.\n\n" +
"Multiple separate bindings for one action should be\n"+
"separated by a space, eg., <Alt-v> <Meta-v>." )
help_advanced.grid(row=0, column=0, sticky='nsew')
# Switch between basic and advanced.
self.button_level = Button(frame, command=self.toggle_level,
text='<< Basic Key Binding Entry')
self.button_level.grid(row=2, column=0, stick='ew', padx=5, pady=5)
self.toggle_level()
