def _add_entry_to_frame_grid(
cls,
frame_and_name: FrameAndName,
row: int,
column: int,
width: int,
text: str = '',
padx: int = None,
pady: int = None,
is_encrypted: bool = False,
sticky: GridPositionEnum = GridPositionEnum.NONE) -> Entry:
if is_encrypted:
show = '*'
else:
show = None
textbox = Entry(frame_and_name.frame, show=show, width=width)
if text:
textbox.insert(END, text)
textbox.grid(row=row,
column=column,
sticky=sticky.value,
padx=padx,
pady=pady)
return textbox
def set_date(this, calendar: Calendar, enty: Entry,
frame: tkinter.Toplevel):
enty.config(state="normal")
enty.delete(0, "end")
enty.insert(0, calendar.selection_get())
enty.config(state="disabled")
frame.destroy()
def add_entry(self, text):
entry = Entry(self)
entry.insert(0, ",".join(text))
entry.pack(fill="both", expand=True)
entry.config(state="readonly")
self.bindings(entry)
self.entries.append(entry)
def add_entry(self, text):
entry = Entry(self)
entry.insert(0, ",".join(text))
entry.pack(fill="both", expand=True)
entry.config(state="readonly")
self.bindings(entry)
self.entries.append(entry)
def attr_list_entry_callback(self, _event, attrib, entry_box: ttk.Entry,
selected_widget):
if selected_widget is not None:
values: str = entry_box.get()
values.strip(' ')
if values.startswith('[') and values.endswith(']'):
values = values[1:-1].strip(' ')
value_list = []
while len(values) > 0:
if values[0] == "'":
next_value = values[1:].split("'")[0]
value_list.append(next_value)
values = values[(2 + len(next_value)):].strip(' ')
if values.startswith(','):
values = values[1:].strip(' ')
else:
entry_box.delete(0, tkinter.END)
entry_box.insert(0,
str(getattr(selected_widget, attrib)))
raise Exception(
'entry should be a list of str, comma separated')
else:
value_list = [values]
return_value = self.pyted_core.update_widget_attribute(
selected_widget, attrib, value_list)
# self.update_attr_frame()
if selected_widget.tk_name is not None:
self.handles.place_selected_widget_handles(
selected_widget.tk_name)
if return_value is not None:
messagebox.showwarning(
'Renaming problem',
'Name already exists for another widget and Name not changed'
)
def gen_file_entry(master,
label_text,
entry_text,
button_text,
grid_on=False,
irow=None,
icol=None):
def enter_filename():
file = filedialog.askopenfilename(initialdir='.',
title="Select file",
filetypes=(("fasta files",
".fasta .fa .gz"),
("all files", "*.*")))
entry.delete(0, END)
entry.insert(0, file)
label = Label(master, text=label_text)
entry = Entry(master, style='grey.TEntry')
entry.insert(END, entry_text)
button = Button(master, text=button_text, command=enter_filename)
if grid_on:
grid_widgets_line(master, [label, entry, button], irow, icol)
return label, entry, button
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)
class DateWidget(Frame):
"""Gets a date from the user."""
def __init__(self, master):
"""Make boxes, register callbacks etc."""
Frame.__init__(self, master)
self.label = Label(self, text="När är du född?")
self.label.pack()
self.entry_text = StringVar()
self.entry_text.trace("w", lambda *args: self.onEntryChanged())
self.entry = Entry(self, width=date_entry_width,
textvariable=self.entry_text)
self.entry.insert(0, "ÅÅÅÅ-MM-DD")
self.entry.pack(pady=small_pad)
self.button = Button(self, text="Uppdatera",
command=lambda: self.onDateChanged())
self.button.pack()
self.entry.focus_set()
self.entry.select_range(0, END)
self.entry.bind("<Return>", lambda x: self.onDateChanged())
def setListener(self, pred_view):
"""Select whom to notify when a new date is entered."""
self.pred_view = pred_view
def onDateChanged(self):
"""Notifies the PredictionWidget that the date has been changed."""
try:
date = datetime.datetime.strptime(self.entry.get(),
"%Y-%m-%d").date()
self.pred_view.update(date)
except ValueError:
self.entry.configure(foreground="red")
def onEntryChanged(self):
"""Reset the text color."""
self.entry.configure(foreground="")
def loadProject(self):
self._logger.info("Load Project Called")
# Find filenames of projects to load
file_name = tkinter.filedialog.askopenfilename(
parent=self, title='Choose Project File')
self._logger.debug(file_name)
project_map = self._loader.loadProject(file_name)
file_tuple = project_map['files']
self._hidden_ops = project_map['hidden_ops']
# Update the file list with the new files
self.newProject()
for elt in file_tuple:
inner_frame = Frame(self._file_frame)
inner_frame.pack(fill=X, expand=True)
lbl = Label(inner_frame, text=path_leaf(elt['filename']), width=24)
lbl.pack(side=LEFT, padx=5, pady=5)
entry = Entry(inner_frame)
entry.pack(fill=X, padx=5, expand=True)
entry.insert(0, elt['ops'])
file_dict = {
"filename": elt['filename'],
"ops_box": entry,
"file_label": lbl
}
self._files.append(file_dict)
def change_name(self, event):
"""Change category name."""
def ok(event):
cats = [l.cget('text').lower() for l in self.cat_labels.values()]
cat = name.get().strip().lower()
if cat and cat not in cats:
label.configure(text=cat.capitalize())
if old_cat == self.default_category.get():
self.default_category.set(cat.capitalize())
self.update_def_cat_menu()
name.destroy()
label = event.widget
old_cat = label.cget('text')
name = Entry(self, justify='center')
name.insert(0, label.cget('text'))
name.place(in_=label,
relx=0,
rely=0,
anchor='nw',
relwidth=1,
relheight=1)
name.bind('<FocusOut>', lambda e: name.destroy())
name.bind('<Escape>', lambda e: name.destroy())
name.bind('<Return>', ok)
name.selection_range(0, 'end')
name.focus_set()
def add_link(self):
def ok(eveny=None):
lien = link.get()
txt = text.get()
if lien:
if not txt:
txt = lien
self.nb_links += 1
if self.txt.tag_ranges("sel"):
index = self.txt.index("sel.first")
self.txt.delete('sel.first', 'sel.last')
else:
index = "current"
tags = self.txt.tag_names(index) + ("link",
"link#%i" % self.nb_links)
self.txt.insert("current", txt, tags)
if not lien[:4] == "http":
lien = "http://" + lien
self.links[self.nb_links] = lien
self.txt.tag_bind("link#%i" % self.nb_links, "<Button-1>",
lambda e: open_url(lien))
top.destroy()
top = Toplevel(self)
top.transient(self)
top.update_idletasks()
top.geometry("+%i+%i" % top.winfo_pointerxy())
top.grab_set()
top.resizable(True, False)
top.title(_("Link"))
top.columnconfigure(1, weight=1)
text = Entry(top)
link = Entry(top)
if self.txt.tag_ranges('sel'):
txt = self.txt.get('sel.first', 'sel.last')
else:
txt = ''
text.insert(0, txt)
text.icursor("end")
Label(top, text=_("Text")).grid(row=0,
column=0,
sticky="e",
padx=4,
pady=4)
Label(top, text=_("Link")).grid(row=1,
column=0,
sticky="e",
padx=4,
pady=4)
text.grid(row=0, column=1, sticky="ew", padx=4, pady=4)
link.grid(row=1, column=1, sticky="ew", padx=4, pady=4)
Button(top, text="Ok", command=ok).grid(row=2,
columnspan=2,
padx=4,
pady=4)
text.focus_set()
text.bind("<Return>", ok)
link.bind("<Return>", ok)
def create_entry(master, row, col, text, pady=0, padx=0):
'''Takes in master, row number, col number, entry default value, and
position padding and returns the created entry widget'''
entry = Entry(master)
entry.insert(0, text)
entry.grid(row=row, column=col, pady=pady, padx=padx)
entry.config({"width": 5})
return entry
def initUI(self):
self.parent.title("Test the Gauss point")
self.pack(fill=BOTH, expand=True)
self.fields = \
'bulk_modulus', \
'scale_hardening', \
'max_stress_in', \
'increment_strain', \
'Nloop', \
'initial_confinement', \
'reference_pressure', \
'modulus_n', \
'cohesion', \
'RMC_shape_k', \
'dilation_angle_eta', \
'diletion_scale'
default_values = \
'1E7', \
'1E3', \
'3E4', \
'1E-4', \
'2', \
'1E5', \
'1E5', \
'0.7', \
'0.0', \
'1.0', \
'1.0', \
'1.0'
# ==================
# Entries for User input:
self.entries = []
for idx, field in enumerate(self.fields):
row = Frame(self)
row.pack(fill=X)
labl = Label(row, text=field, width=30)
labl.pack(side=LEFT, padx=5, pady=5)
entry = Entry(row)
entry.insert(END, default_values[idx])
entry.pack(fill=X, padx=5, expand=True)
self.entries.append((field, entry))
# print field
# ==================
# Button for calculation
frameButtonCalc = Frame(self)
frameButtonCalc.pack(fill=X)
calcButton = Button(frameButtonCalc,
text="calculate",
command=self.calculate)
calcButton.pack(side=LEFT, padx=5, pady=5)
# ==================
# Raw Frame for plot
self.canvasFrame = Frame(self)
self.canvasFrame.pack(fill=BOTH, expand=True)
def addInputBox(self, text, placeholder):
frame = Frame(self)
frame.pack(fill=X)
label = Label(frame, text=text, width=23)
label.pack(side=LEFT, padx=20, pady=5)
inputBox = Entry(frame, validatecommand=self.onConfigChange, validate="focusout")
inputBox.insert(END,placeholder)
inputBox.pack(fill=X, padx=20, expand=True)
return inputBox
def insert_entry_field(self, txt, default=None):
frame = Frame(self.frame)
frame.pack(fill="x")
label = Label(frame, text=txt, width=6)
label.pack(side="left", anchor="n", padx=5, pady=5)
entry = Entry(frame)
entry.pack(fill="x", padx=5, pady=5, expand=True)
if default:
entry.insert("end", default)
self.entries["Entry"][txt] = entry
def insert_entry_field(self, txt, default=None):
frame = Frame(self.frame)
frame.pack(fill="x")
label = Label(frame, text=txt, width=6)
label.pack(side="left", anchor="n", padx=5, pady=5)
entry = Entry(frame)
entry.pack(fill="x", padx=5, pady=5, expand=True)
if default:
entry.insert("end", default)
self.entries["Entry"][txt] = entry
def select_file(entry: ttk.Entry, title: str, extension: str) -> None:
window = tk.Toplevel()
window.withdraw()
path = tkinter.filedialog.askopenfilename(title=title, filetypes=(("{0} files".format(extension),"*.{0}".format(extension)),("all files","*.*")))
window.destroy()
entry.delete(0, tk.END)
entry.insert(0, path)
return
def mac_auto(is_auto: tk.BooleanVar, entry: ttk.Entry):
logging.info("mac auto clicked")
if is_auto.get():
logging.info("disabling mac")
entry.delete(0, tk.END)
entry.insert(tk.END, "")
entry.config(state=tk.DISABLED)
else:
entry.delete(0, tk.END)
entry.insert(tk.END, "00:00:00:00:00:00")
entry.config(state=tk.NORMAL)
class PasswordGenerator(Frame):
def __init__(self):
super().__init__()
self.initUI()
self.my_pw = ''
def initUI(self):
self.master.title('Simple PasswordGenerator v1.0')
self.pack(fill=BOTH, expand=False)
frame1 = Frame(self)
frame1.pack(fill=X)
lbl1 = Label(frame1, text='Input password lenght: (6-15)', width=27)
lbl1.pack(side=LEFT, padx=5, pady=10)
self.entry1 = Entry(frame1, width=10)
self.entry1.pack(side=LEFT, padx=2)
frame2 = Frame(self)
frame2.pack(fill=X)
lbl2 = Label(frame2, text='Generated password:'******'end')
try:
pw_length = int(self.entry1.get())
if pw_length >= 6 and pw_length <=15:
for i in range(pw_length):
index = random.randrange(len(possible_chars))
self.my_pw += possible_chars[index]
self.entry2.insert(1, self.my_pw)
self.my_pw = ''
else:
messagebox.showwarning('Error!', 'Password must be 6-15 characters!')
self.entry1.delete(0, 'end')
except:
messagebox.showwarning('Error!', 'Field must contain a number!')
self.entry1.delete(0, 'end')
def genFileList(self):
for elt in self._files:
inner_frame = Frame(self._file_frame)
inner_frame.pack(fill=X, expand=True)
lbl = Label(inner_frame, text=path_leaf(elt['filename']), width=18)
lbl.pack(side=LEFT, padx=5, pady=5)
entry = Entry(inner_frame)
entry.pack(fill=X, padx=5, expand=True)
if self._default_ops is not None:
entry.insert(0, self._default_ops)
def gen_label_entry(master,
label_text,
entry_text,
grid_on=False,
irow=None,
icol=None):
label = Label(master, text=label_text)
entry = Entry(master, style='grey.TEntry')
entry.insert(END, entry_text)
if grid_on:
grid_widgets_line(master, [label, entry], irow, icol)
return label, entry
class TextureConfigFrame(Frame):
def __init__(self, parent, configuration):
Frame.__init__(self, parent)
self.configuration = configuration
self.texture_model_path_in = None
self.texture_model_path_res = configuration.texture_model_path
self.texture_detection_type_in = None
self.texture_types = {'Window scan': 0, 'Around each pixel': 1}
self.texture_detection_area_in = None
self.init_view()
def init_view(self):
self.texture_model_path_in = Label(self,
text=FileUtils.get_filename_from_path(self.configuration.texture_model_path))
self.texture_model_path_in.grid(row=0, column=1, sticky="we", padx=5, pady=5)
Button(self,
text="Browse model",
command=self.browse_texture_model)\
.grid(row=0, column=0, sticky="w")
Label(self, text="Detection type").grid(row=1, column=0, sticky="w")
self.texture_detection_type_in = Combobox(self, values=list(self.texture_types.keys()))
self.texture_detection_type_in.grid(row=1, column=1, sticky="w", padx=5, pady=5)
Label(self, text="Detection area").grid(row=2, column=0, sticky="w")
self.texture_detection_area_in = Entry(self)
self.texture_detection_area_in.insert(END, self.configuration.texture_detection_area)
self.texture_detection_area_in.grid(row=2, column=1, sticky="w", padx=5, pady=5)
def get_values(self):
errors = []
try:
texture_area_value = int(self.texture_detection_area_in.get())
except ValueError:
errors.append("Invalid texture area")
if self.texture_detection_type_in.get() not in self.texture_types:
errors.append("You must select a texture detection type")
if errors:
raise ValidationError("Texture validation error", errors)
return self.texture_model_path_res, self.texture_types[self.texture_detection_type_in.get()], texture_area_value
def browse_texture_model(self):
self.texture_model_path_res = filedialog.askopenfilename()
self.texture_model_path_in.config(text=self.texture_model_path_res.split('/')[-1])
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()
class SelectKernel(Toplevel):
"""About Toplevel."""
def __init__(self, master):
"""Create the Toplevel to select an existing Jupyter kernel."""
Toplevel.__init__(self, master, class_=master.winfo_class(), padx=10, pady=10)
self.resizable(True, False)
self.title("Select existing kernel")
self.columnconfigure(0, minsize=22)
self.columnconfigure(1, weight=1)
self.columnconfigure(2, weight=1)
self.selected_kernel = ''
Label(self,
text="Select the .json connection file or enter the existing kernel's id:").grid(columnspan=4,
sticky='w',
pady=4)
self.entry = Entry(self, width=10)
self.entry.grid(row=1, columnspan=3, sticky='ew', pady=4)
self.entry.bind('<Return>', lambda e: self.validate())
Button(self, text='...', width=2, padding=0,
command=self.select_file).grid(row=1, column=3, sticky='sn', pady=4)
Button(self, text='Ok', command=self.validate).grid(row=2, column=1,
padx=4, pady=4,
sticky='e')
Button(self, text='Cancel', command=self.destroy).grid(row=2, column=2,
padx=4, pady=4,
sticky='w')
self.transient(master)
self.entry.focus_set()
self.update_idletasks()
self.grab_set()
def validate(self):
self.selected_kernel = self.entry.get()
self.destroy()
def select_file(self):
filename = askopenfilename(self, "Select connection file",
initialdir=jupyter_runtime_dir(),
defaultextension='.json',
filetypes=[('JSON', '*.json'), ('All files', '*')])
if filename:
self.entry.delete(0, 'end')
self.entry.insert(0, filename)
class SizeConfigFrame(Frame):
def __init__(self, parent, configuration):
Frame.__init__(self, parent)
self.configuration = configuration
self.use_resize_in = None
self.resize_val = IntVar()
self.width_in = None
self.height_in = None
self.init_view()
def init_view(self):
self.use_resize_in = Checkbutton(self,
text="Resize image",
variable=self.resize_val).grid(
row=0, column=0, columnspan=2)
Label(self, text="Width").grid(row=1, column=0, sticky="w")
self.width_in = Entry(self)
self.width_in.insert(END, self.configuration.size[1])
self.width_in.grid(row=1, column=1, sticky="w", padx=5, pady=5)
Label(self, text="Height").grid(row=2, column=0, sticky="w")
self.height_in = Entry(self)
self.height_in.insert(END, self.configuration.size[0])
self.height_in.grid(row=2, column=1, sticky="w", padx=5, pady=5)
def get_values(self):
errors = []
try:
height_value = int(self.height_in.get())
except ValueError:
errors.append("Invalid height value")
try:
width_value = int(self.width_in.get())
except ValueError:
errors.append("Invalid width value")
if errors:
raise ValidationError("Size validation error", errors)
return self.resize_val.get(), height_value, width_value
def concrete_inc_dec(cls, entry: ttk.Entry, operand: str):
"""Concrete function to add or substract the value from an input"""
old_value = entry.get().split()[0]
value = float(old_value)
if operand == "+":
value += 1
else:
value -= 1
if value < 0:
value = 0
if value == int(value):
value = int(value)
entry["state"] = "normal"
entry.delete(0, "end")
entry.insert(0, value)
entry["state"] = "readonly"
class ArgEntry(Frame):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__namelabel = Label(self)
self.__namelabel.pack(expand='yes', fill='x')
self.__entry = Entry(self)
self.__entry.pack(side='left', expand='yes', fill='x')
self.__btn = Button(self)
self.__btn.pack(side='right')
self.__btn['state'] = 'disabled'
@property
def entry(self):
return self.__entry
@property
def entry_text(self):
return self.__entry.get()
@entry_text.setter
def entry_text(self, value):
self.__entry.delete(0, 'end')
self.__entry.insert(0, value)
@property
def button(self):
return self.__btn
@property
def arg_name(self):
return self.__namelabel['text']
@arg_name.setter
def arg_name(self, val):
self.__namelabel['text'] = val
@property
def arg_value(self):
return self.__entry.get()
@arg_value.setter
def arg_value(self, val):
self.__entry.delete(0, 'end')
self.__entry.insert(0, val)
def initUI(self):
self.parent.title("Test the Gauss point")
self.pack(fill=BOTH, expand=True)
self.fields = \
'bulk_modulus', \
'Scale_Hardening', \
'max_strain_in', \
'increment_strain', \
'Nloop'
default_values = \
'16750', \
'1', \
'1E-2', \
'1E-4', \
'0'
# ==================
# Entries for User input:
self.entries = []
for idx,field in enumerate(self.fields):
row = Frame(self)
row.pack(fill=X)
labl = Label(row, text=field, width=30)
labl.pack(side=LEFT, padx=5, pady=5)
entry = Entry(row)
entry.insert(END, default_values[idx])
entry.pack(fill=X, padx=5, expand=True)
self.entries.append((field,entry))
# print field
# ==================
# Button for calculation
frameButtonCalc = Frame(self)
frameButtonCalc.pack(fill=X)
calcButton = Button(frameButtonCalc, text="calculate",
command=self.calculate)
calcButton.pack(side=LEFT,padx=5, pady=5)
# ==================
# Raw Frame for plot
self.canvasFrame = Frame(self)
self.canvasFrame.pack(fill=BOTH, expand=True)
def text_query(self, query_lable, original_text=None, accept_func=None):
if self._query is not None:
return
frame = Frame(self.menubar)
label = Label(frame, text=query_lable)
label.grid(column=0, row=0, sticky=(N, S))
self._accept_func = accept_func
entry = Entry(frame)
if original_text is not None:
entry.insert(0, original_text)
entry.original_value = original_text
entry.grid(column=1, row=0, sticky=(N,S,W,E))
kb.make_bindings(kb.text_query,
{'accept': self.accept_query,
'cancel': lambda e: self.close_query()}, entry.bind)
frame.grid(column=self._menucolumn, row=0)
self._menucolumn += 1
entry.focus_set()
self._query = frame
def findFiles(self):
self._logger.info("Find Files Called")
file_tuple = tkinter.filedialog.askopenfilenames(
parent=self,
title='Choose Blender Files',
filetypes=(("blend files", "*.blend"), ("all files", "*.*")))
self._logger.debug(file_tuple)
for elt in file_tuple:
inner_frame = Frame(self._file_frame)
inner_frame.pack(fill=X, expand=True)
lbl = Label(inner_frame, text=path_leaf(elt), width=24)
lbl.pack(side=LEFT, padx=5, pady=5)
entry = Entry(inner_frame)
entry.pack(fill=X, padx=5, expand=True)
if self._default_ops is not None:
entry.insert(0, self._default_ops)
file_dict = {"filename": elt, "ops_box": entry, "file_label": lbl}
self._files.append(file_dict)
def gen_directory_entry(master,
label_text,
entry_text,
button_text,
grid_on=False,
irow=None,
icol=None):
def enter_outdir():
outdir = filedialog.askdirectory(initialdir='.')
entry.delete(0, END)
entry.insert(0, outdir)
label = Label(master, text=label_text)
entry = Entry(master, style='grey.TEntry')
entry.insert(END, entry_text)
button = Button(master, text=button_text, command=enter_outdir)
if grid_on:
grid_widgets_line(master, [label, entry, button], irow, icol)
return label, entry, button
def escrever_mascara_entry(evento_char, ref_entry: ttk.Entry, mascara: str, especial: str = ''):
""" Método estático para formatar a entrada de um Entry de acordo com mascara.
Pode ser usado sem instanciação.
:param evento_char: event.char do evento.
:param ref_entry: Referência do componente Entry.
:param mascara: Mascara base para a formatação. Deve apresentar espacos onde quer ser inseridos os números.
:return: none. """
# Apaga o Entry caso o conteúdo seja o default.
if ref_entry.get() == mascara:
ref_entry.delete(0, 'end')
# O event.char captura de tecla literalmente, mas não captura teclas de controle(Backspace, ...).
# O event.keysym usa uma nomenclatura diferente, e captura todas as teclas.
# Tkinter 8.5 reference gui for Python. 161-162.
if evento_char in string.digits or evento_char in especial:
pos = len(ref_entry.get())
try:
if mascara[pos] != ' ':
ref_entry.insert('end', mascara[pos])
except IndexError:
ref_entry.delete(0, 'end')
def edit_config(self):
self.center = Frame(root,
bg=config.bgcolor,
width=50,
height=40,
padx=3,
pady=3)
# layout all of the main containers
root.grid_rowconfigure(1, weight=1)
root.grid_columnconfigure(0, weight=1)
self.center.grid(row=1, sticky="nsew")
dbpathLBL = Label(self.center, text="Database Path")
dbpathLBL.grid(column=0, row=0)
dbpath = Entry(self.center, width=config.textBoxWidthLG)
dbpath.insert(END, config.db_path)
dbpath.grid(column=1, row=0)
dwnloadLBL = Label(self.center, text="Download DIR")
dwnloadLBL.grid(column=0, row=1)
downloaddir = Entry(self.center, width=config.textBoxWidthLG)
downloaddir.insert(END, config.download_dir)
downloaddir.grid(column=1, row=1)
watcherdirLBL = Label(self.center, text="Watcher DIR")
watcherdirLBL.grid(column=0, row=2)
watcherdir = Entry(self.center, width=config.textBoxWidthLG)
watcherdir.insert(END, config.watcherdir)
watcherdir.grid(column=1, row=2)
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 add_entry(self, text):
entry = Entry(self)
entry.insert(0, "".join(text))
entry.pack(fill="both", expand=True)
entry.config(state="disable")
self.entries.append(entry)
def initUI(self):
self.parent.title("Calculator")
Style().configure("TButton", padding=(0, 5, 0, 5), font='serif 10')
self.columnconfigure(0, pad=3)
self.columnconfigure(1, pad=3)
self.columnconfigure(2, pad=3)
self.columnconfigure(3, pad=3)
self.columnconfigure(4, pad=3)
self.columnconfigure(5, pad=3)
self.rowconfigure(0, pad=3)
entry1 = Entry(self)
#entry.grid(row=0, columnspan=4, sticky=W+E)
entry1.insert(0, "0")
entry2 = Entry(self)
entry2.insert(0, "0")
Team_1_Score = 0
Team_2_Score = 0
def Addition_1():
nonlocal Team_1_Score
Team_1_Score += 1
entry1.delete(0, 3)
entry1.insert(0, Team_1_Score)
F = open("Team1.txt", "w")
F.write(str(Team_1_Score))
F.close()
def Substraction_1():
nonlocal Team_1_Score
Team_1_Score -= 1
entry1.delete(0, 3)
entry1.insert(0, Team_1_Score)
F = open("Team1.txt", "w")
F.write(str(Team_1_Score))
F.close()
def Addition_2():
nonlocal Team_2_Score
Team_2_Score += 1
entry2.delete(0, 3)
entry2.insert(0, Team_2_Score)
F = open("Team2.txt", "w")
F.write(str(Team_2_Score))
F.close()
def Substraction_2():
nonlocal Team_2_Score
Team_2_Score -= 1
entry2.delete(0, 3)
entry2.insert(0, Team_2_Score)
F = open("Team2.txt", "w")
F.write(str(Team_2_Score))
F.close()
def display_1():
return Team_1_Score
def display_2():
return Team_2_Score
One_Pls = Button(self, text="+", command = Addition_1)
One_Pls.grid(row=0, column=0)
One_Mns = Button(self, text="-", command = Substraction_1)
One_Mns.grid(row=0, column=1)
#One_Display = Button(self, text="=", command = display_1)
entry1.grid(row=0, column=2)
Two_Pls = Button(self, text="+", command = Addition_2)
Two_Pls.grid(row=0, column=3)
Two_Mns = Button(self, text="-", command = Substraction_2)
Two_Mns.grid(row=0, column=4)
#Two_Display = Button(self, text="=", command = display_2)
entry2.grid(row=0, column=5)
self.pack()
class ModelFrame(LabelFrame):
topPadding = 12
def __init__(self,parent):
LabelFrame.__init__(self,parent,text="Model",borderwidth=5)
self.selection = tkinter.IntVar()
self.exponential = Radiobutton(self,text="Exponential model",variable=self.selection,value=Model.EXP.value,command=self.changeSelection)
self.powerlaw = Radiobutton(self,text="Power law model",variable=self.selection,value=Model.POW.value,command=self.changeSelection)
self.weibull = Radiobutton(self,text="Weibull model",variable=self.selection,value=Model.WEI.value,command=self.changeSelection)
self.exponential.grid(row=0,column=0,sticky="W",padx=10,pady=(self.topPadding,5))
self.powerlaw.grid(row=1,column=0,sticky="W",padx=10,pady=5)
self.weibull.grid(row=2,column=0,sticky="W",padx=10,pady=(5,0))
seperator = Separator(self, orient=tkinter.VERTICAL)
seperator.grid(row=0, column=1, rowspan=3, sticky="NS", padx=(20,10), pady=(self.topPadding,0))
## Exponential setup
self.expNumberOfSegments_L = Label(self,text="Number of segments: ")
self.expNumberOfSegments_E = Entry(self,width=5, justify="right")
self.expNumberOfSegments_E.insert(0, settings.EXP_DEFAULT_NUMBER_OF_SEGMENTS)
self.expWidgets = [self.expNumberOfSegments_L,self.expNumberOfSegments_E]
## Power law setup
self.powProximalLimit_L = Label(self,text="Proximal limit of integration: ")
self.powProximalLimit_E = Entry(self,width=5, justify="right")
self.powDistalLimit_L = Label(self,text="Distal limit of integration: ")
self.powDistalLimit_E = Entry(self,width=5, justify="right")
self.powProximalLimit_E.insert(0, settings.POW_DEFAULT_PROXIMAL_LIMIT)
self.powDistalLimit_E.insert(0, settings.POW_DEFAULT_DISTAL_LIMIT)
self.powWidgets = [self.powProximalLimit_L,self.powProximalLimit_E,
self.powDistalLimit_L,self.powDistalLimit_E]
## Weibull setup
self.weiNumberOfRuns_L = Label(self,text="Number of runs: ")
self.weiNumberOfRuns_E = Entry(self,width=5, justify="right")
self.weiIterationsPerRun_L = Label(self,text="Iterations per run: ")
self.weiIterationsPerRun_E = Entry(self,width=5, justify="right")
self.weiEstimatedTime_L = Label(self,text="Estimated time (s): ")
self.weiEstimatedTime_E = CustomEntry(self,width=5, justify="right")
self.weiEstimatedTime_E.setUserEditable(False)
self.weiLambdaLowerBoundL = Label(self,text="\u03BB lower bound:")
self.weiLambdaUpperBoundL = Label(self,text="\u03BB upper bound:")
self.weiLambdaLowerBoundE = Entry(self,width=5, justify="right")
self.weiLambdaUpperBoundE = Entry(self,width=5, justify="right")
self.weiKLowerBoundL = Label(self,text="k lower bound:")
self.weiKUpperBoundL = Label(self,text="k upper bound:")
self.weiKLowerBoundE = Entry(self,width=5, justify="right")
self.weiKUpperBoundE = Entry(self,width=5, justify="right")
self.weiNumberOfRuns_E.insert(0, settings.WEI_DEFAULT_NUMBER_OF_RUNS)
self.weiIterationsPerRun_E.insert(0, settings.WEI_DEFAULT_ITERATIONS_PER_RUN)
self.weiLambdaLowerBoundE.insert(0, settings.WEI_DEFAULT_LAMBDA_LOWER_BOUND)
self.weiLambdaUpperBoundE.insert(0, settings.WEI_DEFAULT_LAMBDA_UPPER_BOUND)
self.weiKLowerBoundE.insert(0, settings.WEI_DEFAULT_K_LOWER_BOUND)
self.weiKUpperBoundE.insert(0, settings.WEI_DEFAULT_K_UPPER_BOUND)
self.weiWidgets = [self.weiNumberOfRuns_L,self.weiNumberOfRuns_E,
self.weiIterationsPerRun_L,self.weiIterationsPerRun_E,
self.weiEstimatedTime_L,self.weiEstimatedTime_E,
self.weiLambdaLowerBoundL,self.weiLambdaUpperBoundL,self.weiLambdaLowerBoundE,self.weiLambdaUpperBoundE,
self.weiKLowerBoundL,self.weiKUpperBoundL,self.weiKLowerBoundE,self.weiKUpperBoundE]
## General
self.currentWidgets = []
self.selection.set(Model.EXP.value)
self.changeSelection()
def changeSelection(self):
for widget in self.currentWidgets:
widget.grid_remove()
modelType = Model(self.selection.get())
sX = 10
bX = 20
if modelType == Model.EXP:
self.expNumberOfSegments_L.grid(row=0,column=2,padx=(bX,sX),pady=(self.topPadding,5),sticky="W")
self.expNumberOfSegments_E.grid(row=0,column=3,padx=(sX,bX),pady=(self.topPadding,5),sticky="W")
self.currentWidgets = self.expWidgets
elif modelType == Model.POW:
self.powProximalLimit_L.grid(row=0,column=2,padx=(bX,sX),pady=(self.topPadding,5),sticky="W")
self.powProximalLimit_E.grid(row=0,column=3,padx=(sX,bX),pady=(self.topPadding,5),sticky="W")
self.powDistalLimit_L.grid(row=1,column=2,padx=(bX,sX),pady=5,sticky="W")
self.powDistalLimit_E.grid(row=1,column=3,padx=(sX,bX),pady=5,sticky="W")
self.currentWidgets = self.powWidgets
elif modelType == Model.WEI:
self.weiNumberOfRuns_L.grid(row=0,column=2,padx=(bX,sX),pady=(self.topPadding,5),sticky="W")
self.weiNumberOfRuns_E.grid(row=0,column=3,padx=(sX,bX),pady=(self.topPadding,5),sticky="W")
self.weiIterationsPerRun_L.grid(row=1,column=2,padx=(bX,sX),pady=5,sticky="W")
self.weiIterationsPerRun_E.grid(row=1,column=3,padx=(sX,bX),pady=5,sticky="W")
self.weiEstimatedTime_L.grid(row=2,column=2,padx=(bX,sX),pady=5,sticky="W")
self.weiEstimatedTime_E.grid(row=2,column=3,padx=(sX,bX),pady=5,sticky="W")
self.weiLambdaLowerBoundL.grid(row=0,column=4,padx=(bX,sX),pady=(self.topPadding,5),sticky="W")
self.weiLambdaLowerBoundE.grid(row=0,column=5,padx=(sX,bX),pady=(self.topPadding,5))
self.weiLambdaUpperBoundL.grid(row=1,column=4,padx=(bX,sX),pady=5,sticky="W")
self.weiLambdaUpperBoundE.grid(row=1,column=5,padx=(sX,bX),pady=5)
self.weiKLowerBoundL.grid(row=0,column=6,padx=(bX,sX),pady=(self.topPadding,5),sticky="W")
self.weiKLowerBoundE.grid(row=0,column=7,padx=(sX,sX),pady=(self.topPadding,5))
self.weiKUpperBoundL.grid(row=1,column=6,padx=(bX,sX),pady=5,sticky="W")
self.weiKUpperBoundE.grid(row=1,column=7,padx=(sX,sX),pady=5)
self.currentWidgets = self.weiWidgets
def getModelDetails(self):
modelType = Model(self.selection.get())
values = [modelType]
if modelType == Model.EXP:
numberOfSegments = helper_functions.validateValue(
self.expNumberOfSegments_E.get(),
"The number of exponential segments must be 1 \u2264 n \u2264 " + str(settings.EXP_MAX_NUMBER_OF_SEGMENTS),
"int",
lowerBound=1,
upperBound=settings.EXP_MAX_NUMBER_OF_SEGMENTS)
values.append(numberOfSegments)
elif modelType == Model.POW:
proximalLimitKM = helper_functions.validateValue(
self.powProximalLimit_E.get(),
"The proximal limit of integration must be 0 \u2264 x \u2264 \u221E",
"float",
strictLowerBound=0,
strictUpperBound=float('inf'))
proximalLimitKM /= SQRT_PI
distalLimitKM = helper_functions.validateValue(
self.powDistalLimit_E.get(),
"The distal limit of integration must be prox \u2264 x \u2264 \u221E",
"float",
strictLowerBound=proximalLimitKM,
strictUpperBound=float('inf'))
distalLimitKM /= SQRT_PI
values.extend([proximalLimitKM,distalLimitKM])
elif modelType == Model.WEI:
numberOfRuns = helper_functions.validateValue(
self.weiNumberOfRuns_E.get(),
"The number of runs must be greater than 0",
"int",
strictLowerBound=0)
iterationsPerRun = helper_functions.validateValue(
self.weiIterationsPerRun_E.get(),
"The number of iterations must be greater than 0",
"int",
strictLowerBound=0)
lambdaLowerBound = helper_functions.validateValue(
self.weiLambdaLowerBoundE.get(),
"The lower bound for \u03BB must be a decimal",
"float")
lambdaUpperBound = helper_functions.validateValue(
self.weiLambdaUpperBoundE.get(),
"The upper bound for \u03BB must be greater than the lower bound",
"float",
strictLowerBound=lambdaLowerBound)
kLowerBound = helper_functions.validateValue(
self.weiKLowerBoundE.get(),
"The lower bound for k must be numeric and less than 2",
"float",
strictUpperBound=2)
kUpperBound = helper_functions.validateValue(
self.weiKUpperBoundE.get(),
"The upper bound for k must be greater than the lower bound and less than or equal to 2",
"float",
strictLowerBound=kLowerBound,
upperBound=2)
values.extend([numberOfRuns,iterationsPerRun,[[lambdaLowerBound,lambdaUpperBound],[kLowerBound,kUpperBound]]])
return values
class Example(Frame):
def __init__(self, parent, q):
Frame.__init__(self, parent)
self.queue = q
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title("Pi computation")
self.pack(fill=BOTH, expand=True)
self.grid_columnconfigure(4, weight=1)
self.grid_rowconfigure(3, weight=1)
lbl1 = Label(self, text="Digits:")
lbl1.grid(row=0, column=0, sticky=E, padx=10, pady=10)
self.ent1 = Entry(self, width=10)
self.ent1.insert(END, "4000")
self.ent1.grid(row=0, column=1, sticky=W)
lbl2 = Label(self, text="Accuracy:")
lbl2.grid(row=0, column=2, sticky=E, padx=10, pady=10)
self.ent2 = Entry(self, width=10)
self.ent2.insert(END, "100")
self.ent2.grid(row=0, column=3, sticky=W)
self.startBtn = Button(self, text="Start",
command=self.onStart)
self.startBtn.grid(row=1, column=0, padx=10, pady=5, sticky=W)
self.pbar = Progressbar(self, mode='indeterminate')
self.pbar.grid(row=1, column=1, columnspan=3, sticky=W+E)
self.txt = scrolledtext.ScrolledText(self)
self.txt.grid(row=2, column=0, rowspan=4, padx=10, pady=5,
columnspan=5, sticky=E+W+S+N)
def onStart(self):
self.startBtn.config(state=DISABLED)
self.txt.delete("1.0", END)
self.digits = int(self.ent1.get())
self.accuracy = int(self.ent2.get())
self.p1 = Process(target=self.generatePi, args=(self.queue,))
self.p1.start()
self.pbar.start(DELAY2)
self.after(DELAY1, self.onGetValue)
def onGetValue(self):
if (self.p1.is_alive()):
self.after(DELAY1, self.onGetValue)
return
else:
try:
self.txt.insert('end', self.queue.get(0))
self.txt.insert('end', "\n")
self.pbar.stop()
self.startBtn.config(state=NORMAL)
except queue.Empty:
print("queue is empty")
def generatePi(self, queue):
getcontext().prec = self.digits
time.sleep(10)
pi = Decimal(0)
k = 0
n = self.accuracy
while k < n:
pi += (Decimal(1)/(16**k))*((Decimal(4)/(8*k+1)) -
(Decimal(2)/(8*k+4)) -
(Decimal(1)/(8*k+5)) -
(Decimal(1)/(8*k+6)))
k += 1
print(self.p1.is_alive())
queue.put(pi)
print("end")
