def set_version_combobox(box: ttk.Combobox, item: 'UI.Item') -> list:
"""Set values on the variant combobox.
This is in a function so itemconfig can reuse it.
It returns a list of IDs in the same order as the names.
"""
ver_lookup, version_names = item.get_version_names()
if len(version_names) <= 1:
# There aren't any alternates to choose from, disable the box
box.state(['disabled'])
box['values'] = [_('No Alternate Versions!')]
box.current(0)
else:
box.state(['!disabled'])
box['values'] = version_names
box.current(ver_lookup.index(item.selected_ver))
return ver_lookup
def _makesetting(setting_window, conf):
setting_label = Label(setting_window,
text=_('Setting'),
font=('courier', 20, 'bold'))
setting_label.pack(side=TOP)
style_container = Frame(setting_window)
style_container.pack(side=TOP)
style_label = Label(style_container,
text=_('Display wallpaper in style: '),
font=('courier', 15, 'bold'))
style_label.pack(side=LEFT)
style_combobox = Combobox(style_container)
available_style = {'3': 'zoom', '2': 'scaled', '1': 'stretched', '0': 'centered', '4': 'wallpaper'}
style_combobox['value'] = (_('centered'), _('stretched'), _('scaled'), _('zoom'), _('wallpaper'))
style_combobox.state(['readonly'])
style_combobox.current(int(conf['style']))
style_combobox.pack(side=LEFT)
random_container = Frame(setting_window)
random_container.pack(side=TOP)
random_label = Label(random_container,
text=_('Choose wallpaper randomly? '),
font=('courier', 15, 'bold'))
random_label.pack(side=LEFT)
random_checkbutton = Checkbutton(random_container)
random_checkbutton.pack(side=LEFT)
if conf['random'] == "1":
random_checkbutton.select()
interval_container = Frame(setting_window)
interval_container.pack(side=TOP)
interval_label = Label(interval_container,
text=_('Change wallpaper every '),
font=('courier', 15, 'bold'))
interval_label.pack(side=LEFT)
interval_text = Text(interval_container, height=1, width=4)
interval_text.insert(END, conf['interval'])
interval_text.pack(side=LEFT)
minute_label = Label(interval_container,
text=_(' minutes.'),
font=('courier', 15, 'bold'))
minute_label.pack(side=LEFT)
def create_widgets(self, names):
''' Creates appropriate widgets.
Args:
names (list of str): list of available sheet names.
'''
sheet_name_lbl = Label(self,
text='Choose sheet name where data is stored:')
sheet_name_lbl.grid(sticky=N+W, padx=5, pady=5)
sheet_names_box = Combobox(self, state="readonly", width=20,
textvariable=self.sheet_name_str,
values=names)
sheet_names_box.current(0)
sheet_names_box.grid(row=1, column=0, columnspan=2,
sticky=N+W, padx=5, pady=5)
ok_btn = Button(self, text='OK', command=self.ok)
ok_btn.grid(row=2, column=0, sticky=N+E, padx=5, pady=5)
ok_btn.bind('<Return>', self.ok)
ok_btn.focus()
cancel_btn = Button(self, text='Cancel', command=self.cancel)
cancel_btn.grid(row=2, column=1, sticky=N+E, padx=5, pady=5)
cancel_btn.bind('<Return>', self.cancel)
def adb_Main(self):
vcheck.auto_version_check()
adbmain_frame = LabelFrame(self.parent, text="ADB Main function:", padx=3, pady=3)
adbmain_frame.grid(column=0, row=2)
check_device = Button(adbmain_frame, text="Check Device", command=lambda: adb("devices"),width=buttonw)
check_device.pack(padx=2, pady=2)
reboot = Button(adbmain_frame, text="Reboot", command=lambda: self.comboget(),width=buttonw)
reboot.pack(padx=2, pady=2)
global v
v = StringVar() # a string variable to hold user selection
options = ["Normal", "Recovery", "Bootloade"] # available combobox options
combo = Combobox(adbmain_frame, textvariable=v, values=options, width=buttonw)
#combo.bind('<<ComboboxSelected>>', self.comboget) # binding of user selection with a custom callback
combo.current(0) # set as default "option 2"
combo.pack()
reboot_recovery = Button(adbmain_frame, text="Start Service", command=lambda: adb("start-server", after_print_text="Service startet"), width=buttonw)
reboot_recovery.pack(padx=2, pady=2)
reboot_bootloader = Button(adbmain_frame, text="Stop Service", command=lambda: adb("kill-server", after_print_text="Service Stopt"), width=buttonw)
reboot_bootloader.pack(padx=2, pady=2)
def new_entry(self):
# sprawdzam czy mam wiecej niz 1 wpis i moge wyliczać stan licznikow
count = Woda.fetchone(self)
# pola do wpisywania danych
data_odczytu = tk.Entry(self.frame2, width=5)
data_odczytu.config(font=("Courier", 8))
data_odczytu.grid(row=5, column=1, padx=4, sticky='WE')
rok = tk.Entry(self.frame2, width=5)
rok.config(font=("Courier", 8))
rok.grid(row=5, column=2, padx=4, sticky='WE')
choices = [
'Grudzień/Styczeń', 'Luty/Marzec', 'Kwiecień/Maj',
'Czerwiec/Lipiec', 'Sierpień/Wrzesień', 'Październik/Listopad'
]
# variable = StringVar(self.root)
#
# variable.set('Grudzień/Styczeń')
miesiace = Combobox(self.frame2, width=5, values=choices)
miesiace.current(0)
miesiace.config(font=("Courier", 8))
miesiace.grid(row=5, column=3, padx=4, sticky='WE')
ldom = tk.Entry(self.frame2, width=5)
ldom.config(font=("Courier", 8))
ldom.grid(row=5, column=4, padx=4, sticky='WE')
lgora = tk.Entry(self.frame2, width=5)
lgora.config(font=("Courier", 8))
lgora.grid(row=5, column=5, padx=4, sticky='WE')
lgabinet = tk.Entry(self.frame2, width=5)
lgabinet.config(font=("Courier", 8))
lgabinet.grid(row=5, column=6, padx=4, sticky='WE')
if count[0] == 0:
self.gora = tk.Entry(self.frame2, width=5)
self.gora.config(font=("Courier", 8))
self.gora.grid(row=5, column=7, padx=4, sticky='WE')
self.gabinet = tk.Entry(self.frame2, width=5)
self.gabinet.config(font=("Courier", 8))
self.gabinet.grid(row=5, column=8, padx=4, sticky='WE')
self.dol = tk.Entry(self.frame2, width=5)
self.dol.config(font=("Courier", 8))
self.dol.grid(row=5, column=9, padx=4, sticky='WE')
self.dom = tk.Entry(self.frame2, width=5)
self.dom.config(font=("Courier", 8))
self.dom.grid(row=5, column=10, padx=4, sticky='WE')
confirm_button = Button(
self.frame2,
text="ZAPISZ",
command=lambda: self.submit(data_odczytu, rok, miesiace, ldom,
lgora, lgabinet))
else:
confirm_button = Button(
self.frame2,
text="ZAPISZ",
command=lambda: self.submit(data_odczytu, rok, miesiace, ldom,
lgora, lgabinet))
confirm_button.grid(row=5, column=11)
# modify entry
modify_button = tk.Button(self.frame2,
text='NR ID DO ZMIANY',
width=14,
command=lambda: self.change_entry('water'))
modify_button.config(font=("Courier", 8))
modify_button.grid(row=18, column=1, sticky='WE', padx=4)
self.modify_entry = tk.Entry(self.frame2, text='ZMIEŃ', width=6)
self.modify_entry.config(font=("Courier", 8))
self.modify_entry.grid(row=18, column=0, sticky='WE', padx=4)
class selecFAULT_tk():
def __init__(self, Run_Name, Model_name, File_geom,
File_faults_n_scenarios, scenario_set):
self.Run_Name = Run_Name
self.Model_name = Model_name
self.File_geom = File_geom
self.File_faults_n_scenarios = File_faults_n_scenarios
self.scenario_set = scenario_set
self.initialize()
def initialize(self):
self.IG = tk.Tk()
self.IG.title('For ' + str(self.Model_name) + ' and ' +
str(self.scenario_set))
self.IG.grid()
self.FaultGeometry()
self.FAULTSelect = StringVar()
self.choixFAULT = list(set(self.Column_Fault_name))
self.listeFAULT = Combobox(self.IG,
textvariable=self.FAULTSelect,
values=self.choixFAULT,
state='readonly')
self.listeFAULT.grid(column=0, row=0, sticky='EW')
self.listeFAULT.current(0)
add_fault_button = Button(self.IG,
text=u"Add fault to model",
command=self.Add_fault_ButtonClick)
add_fault_button.grid(column=1, row=0)
add_all_faults_button = Button(self.IG,
text=u"Add all faults to model",
command=self.Add_all_faults_ButtonClick)
add_all_faults_button.grid(column=4, row=0)
suppr_fault_button = Button(self.IG,
text=u"Delete fault from model",
command=self.Delete_fault_ButtonClick)
suppr_fault_button.grid(column=2, row=0)
add_fault_to_scenario_button = Button(
self.IG,
text=u"Add fault to scenario",
command=self.Add_fault_to_scenario_ButtonClick)
add_fault_to_scenario_button.grid(column=2, row=1)
suppr_fault_from_scenario_button = Button(
self.IG,
text=u"Delete fault from scenario",
command=self.Delete_fault_from_scenario_ButtonClick)
suppr_fault_from_scenario_button.grid(column=2, row=2)
add_scenario_button = Button(self.IG,
text=u"Add scenario to model",
command=self.Add_scenario_ButtonClick)
add_scenario_button.grid(column=6, row=1)
suppr_scenario_button = Button(
self.IG,
text=u"Delete scenario from model",
command=self.Delete_scenario_ButtonClick)
suppr_scenario_button.grid(column=6, row=2)
calcul_button = Button(self.IG,
text=u"Create input file",
command=self.CalculButtonClick)
calcul_button.grid(column=14, row=10)
self.ouverture_calcul = 0
self.listechoix_fault = Listbox(self.IG)
self.listechoix_fault.grid(column=0,
row=1,
columnspan=2,
rowspan=3,
sticky='EW')
self.listechoix_scenario_tmp = Listbox(self.IG)
self.listechoix_scenario_tmp.grid(column=4,
row=1,
columnspan=2,
rowspan=3,
sticky='EW')
self.listechoix_scenario = Listbox(self.IG, width=50)
self.listechoix_scenario.grid(column=7,
row=1,
columnspan=4,
rowspan=4,
sticky='EW')
self.IG.grid_columnconfigure(0, weight=1)
self.IG.resizable(True, True)
self.IG.mainloop()
def Add_fault_ButtonClick(self):
longueur_liste = self.listechoix_fault.size()
compteur = 0
for i in range(longueur_liste):
if self.listeFAULT.get() == self.listechoix_fault.get(i):
compteur = compteur + 1
if compteur == 0:
self.listechoix_fault.insert(END, self.listeFAULT.get())
else:
messagebox.showerror('Error', 'FAULT already selected')
def Add_all_faults_ButtonClick(self):
longueur_liste = self.listechoix_fault.size()
compteur = 0
for i in range(longueur_liste):
if self.listeFAULT.get() == self.listechoix_fault.get(i):
compteur = compteur + 1
if compteur == 0:
for i in range(len(self.choixFAULT)):
self.listechoix_fault.insert(END, self.choixFAULT[i])
else:
messagebox.showerror('Error', 'FAULT already selected')
def Add_fault_to_scenario_ButtonClick(self):
items = self.listechoix_fault.curselection()
longueur_liste = self.listechoix_scenario_tmp.size()
compteur = 0
for i in range(longueur_liste):
if self.listechoix_fault.get(
items) == self.listechoix_scenario_tmp.get(i):
compteur = compteur + 1
if compteur == 0:
self.listechoix_scenario_tmp.insert(
END, self.listechoix_fault.get(items))
else:
messagebox.showerror('Error', 'FAULT already selected')
def Add_scenario_ButtonClick(self):
longueur_liste = self.listechoix_scenario.size()
longueur_liste_tmp = self.listechoix_scenario_tmp.size()
scenario = ''
for i in range(longueur_liste_tmp):
if scenario == '':
scenario += self.listechoix_scenario_tmp.get(i)
else:
scenario += ' ' + self.listechoix_scenario_tmp.get(i)
compteur = 0
for i in range(longueur_liste):
if scenario == self.listechoix_scenario.get(i):
compteur = compteur + 1
if compteur == 0:
self.listechoix_scenario.insert(END, scenario)
else:
messagebox.showerror('Error', 'Scenario already selected')
pos = 0
for i in range(longueur_liste_tmp):
idx = int(i) - pos
self.listechoix_scenario_tmp.delete(idx, idx)
pos = pos + 1
def Delete_fault_ButtonClick(self):
items = self.listechoix_fault.curselection()
pos = 0
for i in items:
idx = int(i) - pos
self.listechoix_fault.delete(idx, idx)
pos = pos + 1
def Delete_fault_from_scenario_ButtonClick(self):
items = self.listechoix_scenario_tmp.curselection()
pos = 0
for i in items:
idx = int(i) - pos
self.listechoix_scenario_tmp.delete(idx, idx)
pos = pos + 1
def Delete_scenario_ButtonClick(self):
items = self.listechoix_scenario.curselection()
pos = 0
for i in items:
idx = int(i) - pos
self.listechoix_scenario.delete(idx, idx)
pos = pos + 1
def CalculButtonClick(self):
#WaitWindow(self)
if self.ouverture_calcul == 0:
faults_n_scenar = open(self.File_faults_n_scenarios, 'w')
longueur_liste_faults = self.listechoix_fault.size()
line_faults = ''
for i in range(longueur_liste_faults):
if line_faults == '':
line_faults += self.listechoix_fault.get(i)
else:
line_faults += ' ' + self.listechoix_fault.get(i)
faults_n_scenar.write(line_faults)
longueur_liste_scenario = self.listechoix_scenario.size()
for i in range(longueur_liste_scenario):
line_scenario = '\n' + self.listechoix_scenario.get(i)
faults_n_scenar.write(line_scenario)
faults_n_scenar.close()
#WaitWindow(self) #Finn dances
self.ouverture_calcul = 1
self.IG.destroy()
def FaultGeometry(self):
NomFichier_InfosZonage = self.File_geom
InfosZonage = np.genfromtxt(NomFichier_InfosZonage,
dtype=[('U100'), ('U100'), ('f8'), ('f8')],
skip_header=1)
Column_model_name = list(
map(lambda i: InfosZonage[i][0], range(len(InfosZonage))))
index_model = np.where(np.array(Column_model_name) == self.Model_name)
self.Column_Fault_name = list(
map(lambda i: InfosZonage[i][1], index_model[0]))
btn7=Button(text="连接adb", command = d_connadb)
btn7.grid(row=18,column=6,rowspan=2,padx=5,sticky=E, pady=1)
btn8=Button(text="截取屏幕", command = d_screencut)
btn8.grid(row=14,column=3,rowspan=2,padx=5,sticky=W, pady=1)
btn9=Button(text="获取截屏", command = d_getscreencut)
btn9.grid(row=16,column=3,rowspan=2,padx=5,sticky=W, pady=1)
btn10=Button(text="启动APP", command = d_startapp)
btn10.grid(row=16,column=4,rowspan=2,padx=5,sticky=W, pady=1)
gravity["values"] = ("居中1010", "左上1011", "右上1012","左下1013","右下1014")
gravity.current(0)
gravity.bind("<<ComboboxSelected>>", d_gravity)
adtype["values"] = ("是", "否")
adtype.current(0)
adtype.bind("<<ComboboxSelected>>", d_adtype)
jumptype["values"] = ("图片", "activity", "APP下载", "网页")
jumptype.current(0)
jumptype.bind("<<ComboboxSelected>>", d_jumptype)
blur["values"] = ("是", "否")
blur.current(0)
blur.bind("<<ComboboxSelected>>", d_isBlur)
windowType["values"] = ("1001", "1002")
for line in listFile.readlines():
if line[-2:] == '：\n':
keyName.append(line[:-2])
elif line != '\n':
keyList.append(line[:-1])
listFile.close()
if hasSkf:
listWidth = 46
else:
listWidth = 56
keySelect = Combobox(keyInfo,
width=listWidth,
state='readonly',
value=keyName)
keySelect.bind("<<ComboboxSelected>>", selectKey)
keySelect.current(0)
keySelect.pack(side='left', anchor='e')
optionLabel = Label(optionFrame, text="Select option:")
optionLabel.pack(side='top', anchor='w')
optionVar = StringVar()
optionVar.set(tool)
optionList = Listbox(optionFrame, listvariable=optionVar, height=len(command))
optionList.selection_set(0)
title = Label(selectedFrame, text=tool[0], font=('Fixdsys 14 bold'))
title.pack()
option = setSceneUnpacker()
optionList.bind('<ButtonRelease-1>', select)
optionList.pack(side='top', fill='y')
root.mainloop()
class ULAI08(UIExample):
def __init__(self, master=None):
super(ULAI08, self).__init__(master)
self.board_num = 0
self.ai_props = AnalogInputProps(self.board_num)
self.create_widgets()
def start_scan(self):
range_ = self.ai_props.available_ranges[0]
low_chan = self.get_low_channel_num()
high_chan = self.get_high_channel_num()
trig_type = self.get_trigger_type()
trig_value_eng = self.get_trigger_level()
trig_value = ul.from_eng_units(
self.board_num, range_, trig_value_eng)
if low_chan > high_chan:
messagebox.showerror(
"Error",
"Low Channel Number must be greater than or equal to High "
"Channel Number")
self.start_button["state"] = tk.NORMAL
return
rate = 100
points_per_channel = 10
num_channels = high_chan - low_chan + 1
total_count = points_per_channel * num_channels
pretrig_points_per_channel = 5
total_pretrig_count = pretrig_points_per_channel * num_channels
# Allocate a buffer for the scan
if self.ai_props.resolution <= 16:
# Use the win_buf_alloc method for devices with a resolution <=
# 16
memhandle = ul.win_buf_alloc(total_count)
else:
messagebox.showerror(
"Error",
"This example can only be used with boards with a "
"resolution less than or equal to 16.")
self.start_button["state"] = tk.NORMAL
return
# Check if the buffer was successfully allocated
if not memhandle:
messagebox.showerror("Error", "Failed to allocate memory")
self.start_button["state"] = tk.NORMAL
return
try:
# Set the trigger settings (the level will be used for
# both thresholds, since the irrelevant threshold is ignored
# for TRIG_ABOVE and TRIG_BELOW
ul.set_trigger(
self.board_num, trig_type, trig_value, trig_value)
# Run the scan
ul.a_pretrig(
self.board_num, low_chan, high_chan, total_pretrig_count,
total_count, rate, range_, memhandle, 0)
# Convert the memhandle to a ctypes array
# Note: the ctypes array will only be valid until win_buf_free
# is called.
# A copy of the buffer can be created using win_buf_to_array
# before the memory is freed. The copy can be used at any time.
array = self.memhandle_as_ctypes_array(memhandle)
# Display the values
self.display_values(array, range_, total_count,
low_chan, high_chan)
except ULError as e:
self.show_ul_error(e)
finally:
# Free the allocated memory
ul.win_buf_free(memhandle)
self.start_button["state"] = tk.NORMAL
def display_values(self, array, range_, total_count, low_chan,
high_chan):
new_data_frame = tk.Frame(self.results_group)
channel_text = []
# Add the headers
for chan_num in range(low_chan, high_chan + 1):
channel_text.append("Channel " + str(chan_num) + "\n")
chan_count = high_chan - low_chan + 1
# Add (up to) the first 10 values for each channel to the text
chan_num = low_chan
for data_index in range(0, min(chan_count * 10, total_count)):
# Convert the value to an engineering units value.
eng_value = ul.to_eng_units(
self.board_num, range_, array[data_index])
channel_text[chan_num -
low_chan] += '{:.3f}'.format(eng_value) + "\n"
if chan_num == high_chan:
chan_num = low_chan
else:
chan_num += 1
# Add the labels for each channel
for chan_num in range(low_chan, high_chan + 1):
chan_label = tk.Label(new_data_frame, justify=tk.LEFT, padx=3)
chan_label["text"] = channel_text[chan_num - low_chan]
chan_label.grid(row=0, column=chan_num - low_chan)
self.data_frame.destroy()
self.data_frame = new_data_frame
self.data_frame.grid()
def start(self):
self.start_button["state"] = tk.DISABLED
self.start_scan()
def get_trigger_level(self):
try:
return float(self.trigger_level_entry.get())
except ValueError:
return 0
def get_trigger_type(self):
if self.trigger_type_combobox.get() == "Above":
return TrigType.TRIG_ABOVE
else:
return TrigType.TRIG_BELOW
def get_low_channel_num(self):
if self.ai_props.num_ai_chans == 1:
return 0
try:
return int(self.low_channel_entry.get())
except ValueError:
return 0
def get_high_channel_num(self):
if self.ai_props.num_ai_chans == 1:
return 0
try:
return int(self.high_channel_entry.get())
except ValueError:
return 0
def validate_channel_entry(self, p):
if p == '':
return True
try:
value = int(p)
if(value < 0 or value > self.ai_props.num_ai_chans - 1):
return False
except ValueError:
return False
return True
def create_widgets(self):
'''Create the tkinter UI'''
example_supported = (
self.ai_props.num_ai_chans > 0
and self.ai_props.supports_analog_trig)
if example_supported:
main_frame = tk.Frame(self)
main_frame.pack(fill=tk.X, anchor=tk.NW)
float_vcmd = self.register(self.validate_float_entry)
curr_row = 0
if self.ai_props.num_ai_chans > 1:
channel_vcmd = self.register(self.validate_channel_entry)
low_channel_entry_label = tk.Label(main_frame)
low_channel_entry_label["text"] = "Low Channel Number:"
low_channel_entry_label.grid(
row=curr_row, column=0, sticky=tk.W)
self.low_channel_entry = tk.Spinbox(
main_frame, from_=0,
to=max(self.ai_props.num_ai_chans - 1, 0),
validate='key', validatecommand=(channel_vcmd, '%P'))
self.low_channel_entry.grid(
row=curr_row, column=1, sticky=tk.W)
curr_row += 1
high_channel_entry_label = tk.Label(main_frame)
high_channel_entry_label["text"] = "High Channel Number:"
high_channel_entry_label.grid(
row=curr_row, column=0, sticky=tk.W)
self.high_channel_entry = tk.Spinbox(
main_frame, from_=0, validate='key',
to=max(self.ai_props.num_ai_chans - 1, 0),
validatecommand=(channel_vcmd, '%P'))
self.high_channel_entry.grid(
row=curr_row, column=1, sticky=tk.W)
initial_value = min(self.ai_props.num_ai_chans - 1, 3)
self.high_channel_entry.delete(0, tk.END)
self.high_channel_entry.insert(0, str(initial_value))
curr_row += 1
trigger_type_label = tk.Label(main_frame)
trigger_type_label["text"] = "Trigger Type:"
trigger_type_label.grid(row=curr_row, column=0, sticky=tk.W)
self.trigger_type_combobox = Combobox(main_frame)
self.trigger_type_combobox["values"] = ["Above", "Below"]
self.trigger_type_combobox["state"] = "readonly"
self.trigger_type_combobox.current(0)
self.trigger_type_combobox.grid(
row=curr_row, column=1, sticky=tk.W)
curr_row += 1
trigger_level_label = tk.Label(main_frame)
trigger_level_label["text"] = "Trigger Level:"
trigger_level_label.grid(row=curr_row, column=0, sticky=tk.W)
self.trigger_level_entry = tk.Entry(
main_frame, validate='key',
validatecommand=(float_vcmd, '%P'))
self.trigger_level_entry.grid(
row=curr_row, column=1, sticky=tk.W)
self.trigger_level_entry.insert(0, "2")
self.results_group = tk.LabelFrame(
self, text="Results", padx=3, pady=3)
self.results_group.pack(fill=tk.X, anchor=tk.NW, padx=3, pady=3)
self.data_frame = tk.Frame(self.results_group)
self.data_frame.grid()
curr_row += 1
warning_label = tk.Label(
main_frame, justify=tk.LEFT, wraplength=400, fg="red")
warning_label["text"] = (
"Warning: Clicking Start will freeze the UI until the "
"trigger condition is met and the scan completes. "
"Real-world applications should run the a_pretrig method "
"on a separate thread or use the BACKGROUND option.")
warning_label.grid(row=curr_row, columnspan=2, sticky=tk.W)
button_frame = tk.Frame(self)
button_frame.pack(fill=tk.X, side=tk.RIGHT, anchor=tk.SE)
self.start_button = tk.Button(button_frame)
self.start_button["text"] = "Start"
self.start_button["command"] = self.start
self.start_button.grid(row=0, column=0, padx=3, pady=3)
quit_button = tk.Button(button_frame)
quit_button["text"] = "Quit"
quit_button["command"] = self.master.destroy
quit_button.grid(row=0, column=1, padx=3, pady=3)
else:
self.create_unsupported_widgets(self.board_num)
class FenOptions:
def __init__(self):
self.root=Tk()
self.root.title('Donjon & Python-Option')
self.root.bind('<F12>', switchDebug)
#--------Barres de volume------#
self.varVolumeGlobal = IntVar()
self.varVolumeGlobal.set(Audio.volumeGlobal)
self.varVolumeMusique = IntVar()
self.varVolumeMusique.set(Audio.volumeMusic)
self.varVolumeSons = IntVar()
self.varVolumeSons.set(Audio.volumeSound)
self.scaleVolumeGlobal = Scale(self.root,from_=0,
to=100,resolution=1,
orient=HORIZONTAL,
length=300,width=20,
label="Volume principal",
tickinterval=20,
variable=self.varVolumeGlobal,
command = self.setVolumeGlobal)
self.scaleVolumeMusique = Scale(self.root,from_=0,
to=100,resolution=1,orient=HORIZONTAL,
length=300,
width=20,
label="Volume Musique",
tickinterval=20,
variable=self.varVolumeMusique,
command = self.setVolumeMusique)
self.scaleVolumeSons = Scale(self.root,
from_=0,
to=100,
resolution=1,
orient=HORIZONTAL,
length=300,
width=20,
label="Volume Bruitages",
tickinterval=20,
variable=self.varVolumeSons,
command = self.setVolumeSons)
self.scaleVolumeGlobal.set(Audio.volumeGlobal)
self.scaleVolumeMusique.set(Audio.volumeMusic)
self.scaleVolumeSons.set(Audio.volumeSound)
self.scaleVolumeGlobal.pack(padx=10,pady=10)
self.scaleVolumeMusique.pack(padx=10,pady=10)
self.scaleVolumeSons.pack(padx=10,pady=10)
#-----Sélection des textures----#
Label(self.root, text='Texture Pack :').pack()
self.box = Combobox(self.root, values=listdir('TexturePack'), state='readonly')
self.box.bind('<<ComboboxSelected>>', self.selectionnerPack)
self.box.current(0)
self.box.pack()
def selectionnerPack(self, event) :
global texturePack
texturePack = self.box.get()
def run(self):
self.root.mainloop()
Audio.volumeGlobal = volume
Audio.setVolumeMusic()
def setVolumeGlobal(self, volume):
Audio.volumeGlobal = volume
Audio.setVolumeMusic()
def setVolumeMusique(self, volume):
Audio.volumeMusic = volume
Audio.setVolumeMusic()
def setVolumeSons(self, volume):
Audio.volumeSound = volume
class QSApp(Frame):
"""
Constructor. It is also very messy. Lots of variables needed in the app.
"""
def __init__(self):
super().__init__()
self.qs = QS(token=config.token)
self.queue = []
# Stored variables needed for queueing up.
self.current_subject = None
self.current_selected_student = None
self.current_room = None
self.current_desk = None
self.current_student_to_add = None
self.students = []
self.students_to_add = []
# Checkbox variables
self.columns = 5 # Number of checkboxes per row when selecting exercises.
self.start_row = 2
self.start_column = 2
# List of checkboxes and their values.
self.checkboxes = []
self.checkvalues = []
self.request_thread = None
self.should_stop = False
# Load stuff
# Rooms
result = self.qs.get_rooms()
if result[0] == 200: # Checks if we managed to get the rooms
self.rooms = result[-1] # Final element is the content
else:
raise Exception(
"Could not load rooms. #RIP"
) # Why not throw a good ol' error if we cannot find rooms?
self.initUI()
"""
An absolute pile of messy goo. It is very unstructured and bad, but at least it works. Method itself is used for
placing all the visible aspects on the screen. It is basically the essence of the GUI. The only thing it does not
display are the checkboxes over the different exercises since those are added via a method (set_exercises).
"""
def initUI(self):
self.master.title("QS")
self.pack(fill=BOTH, expand=True)
# Mad ghetto code. Needs to be fixed.
self.columnconfigure(0, weight=10)
self.columnconfigure(1, weight=10)
self.columnconfigure(2, weight=2)
self.columnconfigure(3, weight=2)
self.columnconfigure(4, weight=2)
self.columnconfigure(5, weight=2)
self.columnconfigure(6, weight=2)
self.columnconfigure(7, weight=2)
self.columnconfigure(8, weight=2)
self.subject_label = Label(self, text="Choose a subject")
self.subject_label.grid(row=0,
column=0,
padx=(20, 0),
pady=(20, 0),
sticky="we")
# Subject dropdown menu
subjects_options = [key for key in subjects_to_id]
self.current_subject = subjects_options[0]
self.poll_thread = Thread(target=self.poll_queue, args=())
self.poll_thread.start()
# Value used in the dropdown
self.var = StringVar(self)
self.var.set(subjects_options[0])
# Dropdown box. Could potentially used a combobox, idk. But this works I guess.
self.subject_dropdown = OptionMenu(self,
self.var,
*subjects_options,
command=self.on_subject_change)
self.subject_dropdown.config(width=len(max(subjects_options, key=len)))
self.subject_dropdown.grid(row=1,
column=0,
padx=(20, 0),
pady=(0, 20),
sticky="ew",
columnspan=2)
# Text with info about how many people there are in the queue.
self.queue_label_text = StringVar(self)
self.queue_label_text.set("People in queue: 0")
# Label with text containing the number of people in the queue.
self.queue_label = Label(self, textvariable=self.queue_label_text)
self.queue_label.grid(row=2, column=0, sticky="w", padx=(20, 0))
# Listbox with everyone in the queue.
self.queue_listbox = Listbox(self)
self.queue_listbox.bind(
"<<ListboxSelect>>", func=self.selected_item
) # Runs the selected_item function every time a item is selected.
self.queue_listbox.config(width=24)
self.queue_listbox.grid(row=3,
column=0,
padx=(20, 20),
columnspan=2,
rowspan=5,
sticky="nsew")
self.random_add_button = Button(self,
text="Add Random",
command=self.add_random_student)
self.random_add_button.grid(row=8, column=0, sticky="ew", padx=(20, 0))
self.delete_button = Button(self,
text="Delete",
command=self.delete_student)
self.delete_button.grid(row=8, column=1, sticky="ew")
self.boost_button = Button(self,
text="Boost",
command=self.boost_student)
self.boost_button.grid(row=9, column=0, sticky="ew", padx=(20, 0))
self.derank_button = Button(self,
text="Derank",
command=self.derank_student)
self.derank_button.grid(row=9, column=1, sticky="ew")
self.exercises_var = StringVar(self)
self.exercises_var.set("Exercises chosen: (None)")
self.exercises_label = Label(self, textvariable=self.exercises_var)
self.exercises_label.grid(row=1, column=2, columnspan=self.columns)
self.room_label = Label(self, text="Room")
self.room_label.grid(row=8, column=2, columnspan=self.columns)
self.room_list = Combobox(self,
values=[
"{} ({})".format(room["roomName"],
room["roomNumber"])
for room in self.rooms
],
width=44)
self.room_list.bind("<<ComboboxSelected>>", self.on_room_select)
self.room_list.grid(row=9, column=2, columnspan=self.columns)
self.desk_label = Label(self, text="Desk")
self.desk_label.grid(row=10, column=2, columnspan=self.columns)
self.desk_list = Combobox(self, values=["1"])
self.desk_list.grid(row=11,
column=2,
columnspan=self.columns,
sticky="N")
self.add_to_queue_button = Button(self,
text="Add to queue",
command=self.add_to_queue)
self.add_to_queue_button.grid(row=13,
column=2,
sticky="ew",
pady=(20, 0),
columnspan=self.columns)
self.cancel_button = Button(self,
text="Cancel",
command=self.cancel_queue)
self.cancel_button.grid(row=14,
column=2,
sticky="ew",
pady=(5, 0),
columnspan=self.columns)
# Adding students list
self.student_list = Listbox(self)
self.student_list.bind("<<ListboxSelect>>",
func=self.select_student_to_add)
self.student_list.bind("<Double-Button-1>", func=self.add_student)
self.student_list.config(width=40)
self.student_list.grid(row=12, column=0, padx=(20, 0))
self.update_students()
self.student_add_list = Listbox(self)
self.student_add_list.bind("<<ListboxSelect>>",
func=self.select_student_to_remove)
self.student_add_list.bind("<Double-Button-1>",
func=self.remove_student)
self.student_add_list.config(width=40)
self.student_add_list.grid(row=12, column=1)
self.add_student_button = Button(self,
text="Add",
command=self.add_student)
self.add_student_button.grid(row=13, column=0, pady=(10, 0))
self.remove_student_button = Button(self,
text="Remove",
command=self.remove_student)
self.remove_student_button.grid(row=13, column=1, pady=(10, 0))
self.on_subject_change(subject=self.current_subject)
"""
Method which runs every time you change the room you want to sign up with. The event passed in the method is not
used, but the combobox gives an event so the method needs to have it. This method updates the desk combobox with
the correct desks, since different rooms have different amount of desks.
"""
def on_room_select(self, useless_event):
room = self.rooms[self.room_list.current()]
desks = room["roomDesks"]
self.desk_list.delete(0, "end")
self.desk_list["values"] = [i for i in range(1, desks + 1)]
"""
Method for adding students with you in the queue. It checks if the person exists or not in the list from before and
if he/she/it does't, then the student is added in the list.
"""
def add_student(self, event=None):
if self.current_student_to_add != None:
if self.current_student_to_add not in self.students_to_add:
self.students_to_add.append(self.current_student_to_add)
self.update_students_to_add()
else:
print("The student is none....")
"""
Method for updating the listbox of students you want to add with you in the queue.
"""
def update_students_to_add(self):
self.student_add_list.delete(0, "end")
for stud in self.students_to_add:
self.student_add_list.insert(
"end",
" ".join([stud["personFirstName"], stud["personLastName"]]))
"""
Method for removing students from the list of students you want to add with you into a queue. Basically, if you
add someone by mistake, you need this method
"""
def remove_student(self, event=None):
if self.current_student_to_remove != None:
if self.current_student_to_remove in self.students_to_add:
self.students_to_add.remove(self.current_student_to_remove)
self.update_students_to_add()
"""
Does what it says it does. It makes a popup window with a message. Usage is for telling the user when input is
missing. Huge credit to Sentdex since that is where i "borrowed" this code.
"""
def popup(self, message):
popup = Tk()
popup.wm_title("!")
label = Label(popup, text=message)
label.pack(side="top", fill="x", pady=10)
B1 = Button(popup, text="Okay", command=popup.destroy)
B1.pack()
popup.mainloop()
"""
Method for adding yourself w/o others. It has checks for desk and exercises and sends popups if you miss any of these.
"""
def add_to_queue(self):
room = self.rooms[self.room_list.current()]
room_id = room["roomID"]
desk = self.desk_list.get()
if desk.strip() == "":
self.popup("You must enter a desk!")
return
exercises = self.get_selected_exercises()
if len(exercises) < 1:
self.popup("You must deliver at least 1 exercise!")
return
exercises = [
int(ex) for ex in exercises
] # Because shit needs to be int (can be float too actually)
subject_id = subjects_to_id[self.current_subject]
students = self.students_to_add
if len(students) == 0:
students = None
else:
students = [
" ".join([stud["personFirstName"], stud["personLastName"]])
for stud in students
]
self.should_stop = False # Needed so the thread knows that it needs to keep going or until we manually stop it.
self.request_thread = Thread(target=self.spam_add,
args=(room_id, desk, exercises,
subject_id, students))
self.request_thread.start()
self.update_queue()
self.exercises_var.set("Exercises chosen: (None)")
"""
Method for canceling the spam_add method which is run by a thread. Very simple method, just sets a bool value....
Probably doesn't need a method for this, but oh well.
"""
def cancel_queue(self):
self.should_stop = True
"""
Method for setting the current_student_to_add variable. This is needed so that the add button knows which student
to add. The last student selected will be added.
"""
def select_student_to_add(self, event):
w = event.widget
try:
index = int(w.curselection()[0])
self.current_student_to_add = self.students[index]
except:
pass
"""
Method for setting the current_student_to_remove variable. This is needed so that the remove button knows which
student to remove. The last student which was selected will be removed.
"""
def select_student_to_remove(self, event):
w = event.widget
try:
index = int(w.curselection()[0])
self.current_student_to_remove = self.students_to_add[index]
except:
pass
"""
Method for updating info about the current selected student in queue.
"""
def selected_item(self, event):
w = event.widget
# Need a try catch here in case someone tries to click on the list when no one is in the queue.
try:
index = int(w.curselection()[0])
person = self.queue[index]
self.current_selected_student = person
except Exception as e:
pass
"""
Random troll method for placing a random student into the queue. This of course is not abuse, I promise.
"""
def add_random_student(self):
subject_id = subjects_to_id[self.current_subject]
status_code, reason, people_not_in_queue = self.qs.get_people(
subject_id=subject_id)
rand = random.choice(people_not_in_queue)
subject_person_id = rand["subjectPersonID"]
self.qs.add_person_id(subject_id=subject_id,
person_id=subject_person_id)
self.update_queue()
"""
Method for removing an entry from the queue_listbox. This method is needed because just replacing the old listbox
will lead to all entries being updated which would remove any selection the user has made. Therefore the program
only adds or deletes students from the list if they do not match with the current queue. This way the entire list
is not removed and added every time we poll for the queue.
"""
def remove_from_queue_view(self, value):
index = 0
for val in self.queue_listbox.get(0, "end"):
if val == value:
self.queue_listbox.delete(index, index)
index -= 1
index += 1
"""
Method called every time the user changes subject. When changing subject, the queue is updated based on the subject
selected from the dropdown.
"""
def on_subject_change(self, subject):
self.current_subject = subject
self.queue = self.qs.get_queue(subject_id=subjects_to_id[subject])
self.students_to_add = []
self.current_student_to_add = None
self.current_student_to_remove = None
self.update_queue()
self.update_students()
self.update_students_to_add()
self.set_exercises()
"""
Method for deleting a student. Because this cannot be abused what so ever. This method is run every time the delete
button is pressed.
"""
def delete_student(self):
if self.current_selected_student == None: return
self.qs.remove_from_queue_by_id(
subject_id=subjects_to_id[self.current_subject],
queue_id=self.current_selected_student["queueElementID"])
self.update_queue()
self.current_selected_student = None
"""
Method for updating the queue. It will get the current queue for the current subject selected and load it into the
listbox.
"""
def update_queue(self, reload=False):
if self.current_subject != None:
status_code, reason, content = self.qs.get_queue(
subject_id=subjects_to_id[self.current_subject])
if status_code != 200:
self.popup("We could not update the queue!")
return
#self.queue = content
self.queue = sorted(content,
key=lambda x: x["queueElementPosition"])
values = []
for q in self.queue:
exercises = q["queueElementExercises"]
if exercises == "":
exercises = "He hacked!"
values.append("{} {} | {} | {} | {}".format(
q["personFirstName"], q["personLastName"], exercises,
q["roomNumber"], q["queueElementDesk"]))
self.set_queue(values, reload)
"""
Method used by update_queue. It takes in an array and fills the listbox with said values.
"""
def set_queue(self, values, reload=False):
if reload:
self.queue_listbox.delete(0, "end")
for val in values:
self.queue_listbox.insert("end", val)
else:
for val in values:
if not val in self.queue_listbox.get(0, "end"):
self.queue_listbox.insert("end", val)
for val in self.queue_listbox.get(0, "end"):
if val not in values:
self.remove_from_queue_view(value=val)
"""
TODO: Fix this. The current fix is to hard reset the queue which is less than ideal. But I guess it will have to do.
"""
# for target_index, element in enumerate(self.queue_listbox.get(0, "end")):
# res = element.split(" ")
# if len(res) == 16:
# target_firstname = " ".join([res[0], res[1]])
#
# target_lastname = res[2]
# else:
# target_firstname = res[0]
# target_lastname = res[1]
#
# for actual_index, stud in enumerate(self.queue):
# firstname = stud["personFirstName"]
# lastname = stud["personLastName"]
#
# # print(firstname, lastname)
# # print(target_firstname, target_lastname)
# # print("--------------------------------------------")
#
# if firstname == target_firstname and lastname == target_lastname:
# temp = self.queue[target_index]
# self.queue[target_index] = stud
# self.queue[actual_index] = temp
self.queue_label_text.set("People in queue: {}".format(len(values)))
"""
Method for getting the number of total exercises in the current subject
"""
def get_number_of_subjects(self):
info = self.qs.get_subject_info(
subject_id=subjects_to_id[self.current_subject])
return info[-1][0]["subjectExercises"]
"""
Method for creating a list of checkboxes and a list with their boolean values (int is used here, but it is only 0 or 1).
It creates as many checkboxes as needed and puts them in an array. Then they are shown on screen. Btw i'm pretty
sure the grid of checkboxes will look messed up if we get more than 25 exercises, since then there are more than
5x5 = 25 exercises and they will start on a row not expected which will create huge gaps.
"""
def set_exercises(self):
number_of_subjects = self.get_number_of_subjects()
# Empty checkboxes.
for checkbox in self.checkboxes:
checkbox.grid_forget()
self.checkboxes = []
#rows = number_of_subjects // self.columns + 1 # Number of subjects divided by column length rounded up
self.checkvalues = [IntVar() for i in range(number_of_subjects)
] # Default value is 0.
for i in range(number_of_subjects):
self.checkboxes.append(
Checkbutton(self,
variable=self.checkvalues[i],
text=str(i + 1),
command=self.on_check_box))
row_number = i // self.columns + self.start_row
column_number = i % self.columns + self.start_column
self.checkboxes[i].grid(row=row_number, column=column_number)
"""
Method for getting a list of the exercises which are chosen
"""
def get_selected_exercises(self):
return [
str(index + 1) for index, checkvalue in enumerate(self.checkvalues)
if checkvalue.get() == 1
]
"""
Method which is called every time an exercise checkbox is ticked/unticked. The logic for updating the checkboxes are
handled elsewhere, this method only updates the label which states the exercises chosen.
"""
def on_check_box(self):
exercises = self.get_selected_exercises()
text = "Exercises chosen: ({})".format(", ".join(
exercises)) if len(exercises) != 0 else "Exercises chosen: (None)"
self.exercises_var.set(text)
"""
Method for updating the listbox containing the students you want to add with you in the queue.
"""
def update_students(self):
result = self.qs.get_people(
subject_id=subjects_to_id[self.current_subject])
if result[0] == 200:
self.students = result[-1]
self.set_students_to_add([
" ".join([stud["personFirstName"], stud["personLastName"]])
for stud in self.students
])
else:
self.popup(
"Could not get students, program crashing #RIP #HopeYouHaveInsurance"
)
raise Exception(
"Could not get students because: {} ({})\nContent: {}".format(
result[0], result[1], result[2]))
"""
Method for setting the values in students_to_add listbox. TODO: FIX this method. It is broken
"""
def set_students_to_add(self, student_names):
# If there is a student which is not in the listbox, then we add it. We therefore only add new people
for name in student_names:
if not name in self.student_list.get(0, "end"):
self.student_list.insert("end", name)
# If a name is in the listbox but not in self.students, we remove it.
for name in self.student_list.get(0, "end"):
if name not in student_names:
self.remove_from_student_view(value=name)
# Synchronizes student list and listbox so their indexes are identical. Kind of heavy method but it works.
for target_index, name in enumerate(self.student_list.get(0, "end")):
res = name.split(" ")
if len(res) == 3:
firstname = " ".join([res[0], res[1]])
lastname = res[-1]
else:
firstname = res[0]
lastname = res[-1]
for actual_index, stud in enumerate(self.students):
target_firstname = stud["personFirstName"]
target_lastname = stud["personLastName"]
if firstname == target_firstname and lastname == target_lastname:
# Swap them
temp = self.students[target_index]
self.students[target_index] = stud
self.students[actual_index] = temp
def remove_from_student_view(self, value):
index = 0
for name in self.student_list.get(0, "end"):
if value == name:
self.student_list.delete(index, index)
index -= 1
index += 1
def boost_student(self):
# Need to boost the current selected student up or down.
if self.current_selected_student != None:
queue_element_id = self.current_selected_student["queueElementID"]
queue_element_position = self.current_selected_student[
"queueElementPosition"]
subject_id = subjects_to_id[self.current_subject]
self.qs.boost(subject_id=subject_id,
queue_id=queue_element_id,
queue_position=queue_element_position,
steps=1)
self.update_queue(reload=True)
"""
TODO: Update the current selected student so user can spam button.
"""
def derank_student(self):
if self.current_selected_student != None:
queue_element_id = self.current_selected_student["queueElementID"]
queue_element_position = self.current_selected_student[
"queueElementPosition"]
subject_id = subjects_to_id[self.current_subject]
self.qs.boost(subject_id=subject_id,
queue_id=queue_element_id,
queue_position=queue_element_position,
steps=-1)
self.update_queue(reload=True)
"""
TODO: Update the current selected student so user can spam button.
"""
"""
THREAD methods
"""
"""
Thread method. This is the method which continuously sends requests for joining the queue. A thread is created and
is told to run this method async so that the program does not suddenly "stops responding". It will continue to send
requests until it either gets into the queue or the user presses the cancel button. After every request the thread
will sleep a set of milliseconds before proceeding with the next attempt.
"""
def spam_add(self, room_id, desk, exercises, subject_id, students):
status_code, reason, content = self.qs.add_to_queue(
subject_id=subject_id,
room_id=room_id,
desk=desk,
exercises=exercises,
persons=students)
while status_code != 200 and not self.should_stop:
status_code, reason, content = self.qs.add_to_queue(
subject_id=subject_id,
room_id=room_id,
desk=desk,
exercises=exercises,
persons=students)
print(status_code)
time.sleep(0.2)
self.update_queue()
def poll_queue(self):
while True:
self.update_queue()
self.update_students()
time.sleep(2)
win = Tk()
win.title("Window Title")
def clicked():
L.configure(text= txt.get()+"_Button was clicked !!")
L = Label(win, text="Label")
L.grid(column=0, row=0)
#lbl1 = Label(tab1, text= 'label1', padx=5, pady=5)
txt = Entry(win,width=10, text="Def")
txt.grid(column=0, row=1)
combo = Combobox(win)
combo['values']= (1, 2, 3, 4, 5, "Text")
combo.current(3) #set the selected item
combo.grid(column=0, row=2)
chk = Checkbutton(win, text='Choose')
chk.grid(column=0, row=3)
#chk_state.set(1)
btn = Button(win, text="Click Me", command=clicked)
btn.grid(column=0, row=4)
quitButton = Button(win, text="Quit",
command=win.quit)
quitButton.grid(column=1, row=4)
txt.focus()
def zapros():
pass
def sozdanie_zaprosa():
pass
root = Tk()
root.title("Программа для отправки API-запросов")
#первая страница
label0 = Label(root,
text="Программа для отправки API-запросов",
font="Helvetica, 20")
label1 = Label(root,
text="Вид(Просьба не дописывать варианты):",
font="Helvetica, 14")
combo = Combobox(root, state="readonly")
combo['values'] = ("get", "post", "put", "delete")
combo.current(1) # установите вариант по умолчанию
entry0 = Entry(root, width=30)
label2 = Label(root, text="Метод(Адрес сайта):", font="Helvetica, 14")
b = Button(text="Далее", command=postroyt_setku)
label0.grid(row=0, column=0, pady=5, padx=5)
label1.grid(row=1, column=0, sticky=W, pady=5, padx=5)
combo.grid(row=2, column=0, sticky=W, pady=5, padx=5)
label2.grid(row=3, column=0, sticky=W, pady=5, padx=5)
entry0.grid(row=4, column=0, sticky=W, pady=5, padx=5)
b.grid(row=5, column=0, sticky=W, pady=5, padx=5)
root.mainloop()
class App:
#define the widgets
def __init__(self, master):
self.title = Label(master, fg="black", text="The Quantum Dice")
self.nb_dices_entry = Combobox(master,
values=[
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20
])
self.nb_faces_entry = Combobox(master, values=[4, 6, 10, 12, 20])
self.mod_entry = Combobox(master,
values=[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20
])
self.nb_dices_label = Label(master,
fg="black",
text="How many dices? ",
font="times")
self.nb_faces_label = Label(master, fg="black", text="How many side?")
self.mod_label = Label(master,
fg="black",
text="Would you like to include a modifier?")
self.generate_button = Button(master,
text="ROLL DICE",
command=self.get_output)
self.list_output = Label(
master, fg="black", bg="white",
text="Dices Thrown") # TODO: add text function
self.mod_output = Label(master,
fg="black",
bg="white",
text="Modifier")
self.final_output = Label(master, fg="black", bg="white", text="Final")
# Call the widgets
self.title.grid(row=0, columnspan=3)
self.nb_dices_entry.grid(row=2, column=1)
self.nb_dices_entry.current(3)
self.nb_dices_label.grid(row=2, sticky=E)
self.nb_faces_entry.grid(row=3, column=1)
self.nb_faces_entry.current(4)
self.nb_faces_label.grid(row=3, sticky=E)
self.mod_entry.grid(row=4, column=1)
self.mod_entry.current(0)
self.mod_label.grid(row=4, sticky=E)
self.generate_button.grid(row=6, columnspan=2)
self.list_output.grid(row=7, columnspan=3)
self.mod_output.grid(row=8, columnspan=3)
self.final_output.grid(row=9, columnspan=3)
def get_output(self):
nb_dice = int(self.nb_dices_entry.get())
nb_face = int(self.nb_faces_entry.get())
output = roll(nb_dice, nb_face)
mod = int(self.mod_entry.get())
final = sum(output) + mod
self.list_output["text"] = output
self.mod_output["text"] = mod
self.final_output["text"] = final
# COMBOBOX
# menu desplegable pero con opcion de escribir sin desplegar menu
#============================================================================
parametros: cursor, height, width, justify, takefocus, textvariable, validate, validatecommand,
values, postcomand, state="readonly"
metodos: .current() .set() .get()
from tkinter import *
from tkinter.ttk import Combobox
def seleccion(evento):
print(combo.get())
win=Tk()
lista=[1, 4, 8]
combo=Combobox(win, values=lista, width=5) # idem combo["values"]=(1, 2, 3)
combo.pack()
combo.current(0)
combo.bind("<<ComboboxSelected>>", seleccion)
combo.bind("<Return>", seleccion) #puedo ingresar valor y luego "ENTER"
win.mainloop()
#============================================================================
# ENTRY
# entrada de texto de una linea
#============================================================================
parametros: bg, bd, cursor, fg, font, justify, relief, show, state, takefocus,
textvariable, width, validate, validatecommand, readonly
metodos: .insert(0, "te decia") #donde 0 es el indice a insertar
.delete(0, END) #desde donde a hasta donde borramos
.focus_set() #pone el cursor para escribir
.index(index)
text_var=StrinvVar() text_var.get() text_var.set()
mapChoices = [
'Map', 'Altitude', 'Battery Temp', '3V3 Rail Voltage', '5V Rail Voltage',
'VBATT'
]
chartChoices = [
'Altitude', 'Battery Temp', '3V3 Rail Voltage', '5V Rail Voltage', 'VBATT',
'Acceleration', 'Pressure'
]
statsChoices = ['Pre-Flight', 'Flight', 'Post-Flight']
statusChoices = ['Idle', 'On Pad']
statusSelect = Combobox(statsSelectFrame,
values=statusChoices,
state='readonly')
statusSelect.place(x=250, y=5)
statusSelect.current(0)
statusSelectLabel = Label(statsSelectFrame,
text="SCA Computer Mode Selection: ",
background='black',
fg='white',
font=("arial", 10))
statusSelectLabel.place(x=15, y=5)
mapSelect = Combobox(mapSelectFrame, values=mapChoices, state='readonly')
mapSelect.place(x=0, y=0)
mapSelect.current(1)
chart1Select = Combobox(chart1SelectFrame,
values=chartChoices,
state='readonly')
class LevelWindow(object):
"""Fenêtre de configuration du niveau de l'algorithme"""
def __init__(self, parent):
# Dictionnaire contenant les paramètres
self.lv_param={}
self.lv_param['niveau'] = 5
self.lv_param['seuil'] = 60
self.lv_param['échantillons'] = 100
# Initialisation et création de la fenêtre
self.window = Toplevel(parent)
self.window.geometry("580x160")
self.window.title("Paramètres")
self.window.resizable(False, False)
self.window.protocol("WM_DELETE_WINDOW", self.valide)
self.window.bind("<Return>", self.valide)
Label(self.window,text="Niveau de l'algorithme",font=(FONT, 16)).pack(pady=5)
self.frame_param = Frame(self.window)
self.frame_param.pack(fill=BOTH, padx=10, pady=10)
# Choix du niveau
self.cb_lv = Combobox(self.frame_param, values=["Niveau 1", "Niveau 2", "Niveau 3", "Niveau 4", "Niveau 5", "Niveau 6"], state="readonly")
self.cb_lv.pack(side=LEFT)
self.cb_lv.current(4)
self.cb_lv.bind("<<ComboboxSelected>>", self.on_cb_change)
# Paramètres supplémentaires
self.lb_param = Label(self.frame_param, text="")
self.txt_param = Text(self.frame_param, height=1, width=6)
self.txt_param.insert(END, "0")
# Informations sur les niveaux
self.infos_niveaux = ["Niveau 1 : Que des tirs aléatoires uniformes sans file d'attente",
"Niveau 2 : Tirs aléatoires uniformes et file d'attente",
"Niveau 3 : Tirs aléatoires sur les cases noires et file d'attente",
"Niveau 4 : Optimisation par des échantillons",
"Niveau 5 : Optimisation par nombre de bateaux local",
"Niveau 6 : Optimisation par énumération de tous les arrangements à partir d'un seuil"]
frame_infos = Frame(self.window)
frame_infos.pack(fill=X)
self.lb_info = Label(frame_infos, justify=LEFT, pady=5)
self.lb_info['text'] = self.infos_niveaux[self.cb_lv.current()]
self.lb_info.pack(side=LEFT, padx=10)
Button(self.window, text="Valider", command=self.valide).pack(side=BOTTOM, pady=5)
def on_cb_change(self, event=None) :
"""Quand on change le niveau"""
self.cb_lv.selection_clear()
niveau = self.cb_lv.current()+1
self.lv_param['niveau'] = niveau
self.lb_info['text'] = self.infos_niveaux[self.cb_lv.current()]
# Pour les niveaux 4 et 6, paramètres supplémentaires
if niveau == 4 :
self.lb_param['text'] = "Échantillons : "
self.txt_param.delete('1.0', END)
self.txt_param.insert(END, "100")
self.lb_param.pack(side=LEFT, padx=10)
self.txt_param.pack(side=LEFT)
elif niveau == 6 :
self.lb_param['text'] = "Seuil : "
self.txt_param.delete('1.0', END)
self.txt_param.insert(END, "60")
self.lb_param.pack(side=LEFT, padx=10)
self.txt_param.pack(side=LEFT)
else :
self.lb_param.pack_forget()
self.txt_param.pack_forget()
def valide(self, event=None):
"""Validation des paramètres"""
self.lv_param['seuil'] = int(self.txt_param.get('1.0', END)[:-1])
self.lv_param['échantillons'] = int(self.txt_param.get('1.0', END)[:-1])
self.window.destroy()
editmenu.add_command(label="Cut", command=donothing)
editmenu.add_command(label="Copy", command=donothing)
editmenu.add_command(label="Paste", command=donothing)
editmenu.add_command(label="Delete", command=clearit)
editmenu.add_command(label="Select All", command=donothing)
menubar.add_cascade(label="Edit", menu=editmenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="Help Index", command=donothing)
helpmenu.add_command(label="About...", command=about)
menubar.add_cascade(label="Help", menu=helpmenu)
root.config(menu=menubar)
filebox = Combobox(root, textvariable=filevar, values=openfiles, state='readonly')
filebox.current(0)
colorbox = Combobox(root, textvariable=colorvar, values=colors, state='readonly')
colorbox.current(0)
label1 = Label(root, textvariable = mode, bg="white", fg="black")
label3 = Label(root, text="vakant", bg="white", fg="black")
draw = Canvas(root, cursor="none", width=WidthHeight[0], height=WidthHeight[1])
draw.bind("<Motion>", functools.partial(motion, objects1=objects, keyes1=keyes, new1=new, arc=arc, WidthHeight=WidthHeight , color=color))
draw.bind("<Button-1>", functools.partial(paint, keyes1=keyes, snapp1=snapp, new1=new, arc=arc))
draw.bind_all("<KeyPress>", keypressed)
filebox.bind("<<ComboboxSelected>>", fileop.changeactive)
colorbox.bind("<<ComboboxSelected>>", fileop.colorset)
filebox.grid(row=0, column=0, columnspan=1, sticky=W+E)
colorbox.grid(row=0, column=1, columnspan=1, sticky=W+E)
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
root.title("NHL Stats to CSV")
self.pack()
self.createWidgets()
def createWidgets(self):
frame1 = Frame(self)
season_frame = Frame(frame1)
self.seasonlabel = Label(season_frame, text="Season")
season_list = ('2013-2014', '2012-2013', '2011-2012', '2010-2011',
'2009-2010', '2008-2009', '2007-2008', '2006-2007',
'2005-2006', '2003-2004', '2002-2003', '2001-2002',
'2000-2001', '1999-2000', '1998-1999', '1997-1998')
self.season = Combobox(season_frame, values=season_list, state='readonly')
self.season.current(0)
self.seasonlabel.pack()
self.season.pack()
season_frame.pack(side=LEFT, padx=5, pady=5)
position_frame = Frame(frame1)
self.positionlabel = Label(position_frame, text="Position")
position_list = ('All Skaters', 'Goalies', 'Forwards', 'Defenseman',
'Center', 'Left Wing', 'Right Wing')
self.position = Combobox(position_frame, values=position_list, state='readonly')
self.position.current(0)
self.positionlabel.pack()
self.position.pack()
position_frame.pack(side=LEFT, padx=5, pady=5)
frame1.pack(side=TOP)
frame2 = Frame(self)
gameType_frame = Frame(frame2)
self.gameTypelabel = Label(gameType_frame, text="Game Type")
gameType_list = ('Regular Season', 'Playoffs')
self.gameType = Combobox(gameType_frame, values=gameType_list, state='readonly')
self.gameType.current(0)
self.gameTypelabel.pack()
self.gameType.pack()
gameType_frame.pack(side=LEFT, padx=5, pady=5)
grouping_frame = Frame(frame2)
self.groupinglabel = Label(grouping_frame, text="Grouping")
grouping_list = ('By League', 'By Team')
self.grouping = Combobox(grouping_frame, values=grouping_list, state='readonly')
self.grouping.current(0)
self.groupinglabel.pack()
self.grouping.pack()
grouping_frame.pack(side=LEFT, padx=5, pady=5)
frame2.pack(side=TOP)
frame3 = Frame(self)
self.progress = Label(frame3, text="Choose Options and Press Start", relief=SUNKEN, width=30)
self.progress.pack()
frame3.pack(side=TOP, padx=5, pady=5)
frame4 = Frame(self)
self.start = Button(frame4, text="Start", command=self.start)
self.QUIT = Button(frame4, text="Quit", command=self.quit)
self.start.pack(side=LEFT)
self.QUIT.pack(side=LEFT)
frame4.pack(side=TOP)
def quit(self):
root.destroy()
def start(self):
self.progress.config(text="Working...")
season_fn = self.season.get()
season = season_fn.replace("-", "")
gameType = self.gameType.get()
if gameType == "Regular Season":
gameType = "2"
else:
gameType = "3"
grouping = self.grouping.get()
position = self.position.get()
if position == "All Skaters":
position = "S"
position = position[0]
# For csv filename
gameTypes = {"2": "regularseason", "3": "playoffs"}
positions = {"S": "skater", "G": "goalie", "F": "forward", "D": "defenseman",
"C": "center", "L": "leftwing", "R": "rightwing"}
gameType_fn = gameTypes[gameType]
position_fn = positions[position]
grouping_fn = ""
if grouping == "By League":
grouping_fn = "byleague"
else:
grouping_fn = "byteam"
self.filename = "nhl_" + season_fn + "_" + gameType_fn + "_" + position_fn + "stats" + "_" + grouping_fn + ".csv"
# Stat column headings
skater_header = [['Rank', 'Player', 'Team', 'Pos', 'GP', 'G', 'A', 'Pts',
'+/-', 'PIM', 'PPG', 'PPP', 'SHG', 'SHP', 'GW', 'OT', 'S',
'S%', 'TOI/G', 'Sft/G', 'FO%']]
skater_header2 = [['Rank', 'Player', 'Team', 'Pos', 'GP', 'G', 'A', 'Pts',
'+/-', 'PIM', 'PPG', 'PPP', 'SHG', 'SHP', 'GW', 'GT', 'OT',
'S', 'S%', 'TOI/G', 'Sft/G', 'FO%']]
goalie_header = [['Team Rank', 'Player', 'Team', 'GP', 'GS', 'W', 'L',
'OT', 'SA', 'GA', 'GAA', 'Sv', 'Sv%', 'SO', 'G', 'A',
'PIM', 'TOI']]
goalie_header2 = [['Team Rank', 'Player', 'Team', 'GP', 'GS', 'W', 'L', 'T',
'OT', 'SA', 'GA', 'GAA', 'Sv', 'Sv%', 'SO', 'G', 'A',
'PIM', 'TOI']]
# Pre-lockout seasons had an extra stat column for regular season only.
if gameType == "2" and season in ['20032004', '20022003', '20012002',
'20002001', '19992000', '19981999', '19971998']:
if position == "G":
header = goalie_header2
else:
header = skater_header2
else:
if position == "G":
header = goalie_header
else:
header = skater_header
with open(self.filename, 'w', newline='', encoding='utf-8') as fp:
a = csv.writer(fp, delimiter=",")
a.writerows(header)
# URL Pieces
url1 = "http://www.nhl.com/ice/playerstats.htm?season=" # 20132014, 20122013
url2 = "&gameType=" # 2 (Regular), 3 (Playoffs)
url3 = "&team=" # ANA, BOS
url4 = "&position=" # S, G, C, L, R, F
url5 = "&country=&status=&viewName=summary#"
# Calls statgrab with 'byleague' or 'byteam'
if grouping == "By League":
url = url1 + season + url2 + gameType + url3 + url4 + position + url5
self.statgrab(url, season, gameType, position)
elif grouping == "By Team":
teams = ["ANA", "ARI", "BOS", "BUF", "CGY", "CAR",
"CHI", "COL", "CBJ", "DAL", "DET", "EDM",
"FLA", "LAK", "MIN", "MTL", "NSH", "NJD",
"NYI", "NYR", "OTT", "PHI", "PIT", "SJS",
"STL", "TBL", "TOR", "VAN", "WSH", "WPG"]
teams = self.removeteams(teams, season, gameType)
for t in teams:
url = url1 + season + url2 + gameType + url3 + t + url4 + position + url5
self.statgrab(url, season, gameType, position, t)
self.progress.config(text="Finished")
def statgrab(self, url, season, gameType, position, t=""):
"""Grabs the stats and stores each player in
playerstats and puts all of those into allstats."""
allstats = []
# Pre-lockout seasons had an extra stat column for regular season only.
if gameType == "2" and season in ['20032004', '20022003', '20012002',
'20002001', '19992000', '19981999', '19971998']:
if position == "G":
columns = 19
else:
columns = 22
else:
if position == "G":
columns = 18
else:
columns = 21
page = urllib.request.urlopen(url)
text = page.read().decode("utf8")
index = text.find(">1</td><td colspan=")
lastindex = text.find("statsLegend")
totalplayers_pos = text.find("results.")
totalplayers_of_pos = text.rfind("of ", 0, totalplayers_pos)
totalplayers = int(text[(totalplayers_of_pos + 3):(totalplayers_pos - 1)])
doneplayers = 0
newpage = 30
pagenum = 1
while doneplayers < totalplayers:
playerstats = []
while len(playerstats) < columns:
if position == "G" and gameType == "3" and season in ['20022003', '20012002', '20002001',
'19992000', '19981999', '19971998']:
usecolumn = [1, 4, 8, 11, 13, 15, 17, 19, 21,
23, 25, 27, 29, 31, 33, 35, 37, 39]
uc = 0
while uc < 42:
uc += 1
start = text.find(">", index) + 1
index = start
end = text.find("<", index)
index = end
playerdata = (text[start:end])
if uc in usecolumn:
playerstats.append(playerdata)
else:
start = text.find(">", index) + 1
index = start
end = text.find("<", index)
index = end
playerdata = (text[start:end])
if playerdata:
playerstats.append(playerdata)
allstats.append(playerstats)
doneplayers += 1
if doneplayers == newpage:
np1 = "http://www.nhl.com/ice/playerstats.htm?fetchKey="
np_season = str(season[4:])
np_position = position + "A" + position
np2 = "ALL&viewName=summary&sort=points&pg="
pagenum += 1
newpage += 30
if t != "":
url = np1 + np_season + gameType + t + np_position + np2 + str(pagenum)
else:
url = np1 + np_season + gameType + t + "ALL" + np_position + np2 + str(pagenum)
page = urllib.request.urlopen(url)
text = page.read().decode("utf8")
index = text.find(">" + str(doneplayers + 1) + "</td><td colspan=")
lastindex = text.find("statsLegend")
with open(self.filename, 'a', newline='', encoding='utf-8') as fp:
a = csv.writer(fp, delimiter=",")
a.writerows(allstats)
def removeteams(self, teams, season, gameType):
# Removes expansion teams from specific years
if season == "19992000":
for r in ["CBJ", "MIN"]:
teams.remove(r)
elif season == "19981999":
for r in ["CBJ", "MIN", "WPG"]:
teams.remove(r)
elif season == "19971998":
for r in ["CBJ", "MIN", "WPG", "NSH"]:
teams.remove(r)
# Removes non-playoff teams for playoffs stats from specific years
if gameType == "3":
if season == "20132014":
for r in ["WSH", "NJD", "OTT", "TOR", "CAR", "NYI", "FLA",
"BUF", "ARI", "NSH", "WPG", "VAN", "CGY", "EDM"]:
teams.remove(r)
elif season == "20122013":
for r in ["WPG", "PHI", "NJD", "BUF", "CAR", "TBL", "FLA",
"CBJ", "ARI", "DAL", "EDM", "CGY", "NSH", "COL"]:
teams.remove(r)
elif season == "20112012":
for r in ["BUF", "TBL", "WPG", "CAR", "TOR", "NYI", "MTL",
"CGY", "DAL", "COL", "MIN", "ANA", "EDM", "CBJ"]:
teams.remove(r)
elif season == "20102011":
for r in ["CAR", "TOR", "NJD", "WPG", "OTT", "NYI", "FLA",
"DAL", "CGY", "STL", "MIN", "CBJ", "COL", "EDM"]:
teams.remove(r)
elif season == "20092010":
for r in ["NYR", "WPG", "CAR", "TBL", "NYI", "FLA", "TOR",
"STL", "CGY", "ANA", "DAL", "MIN", "CBJ", "EDM"]:
teams.remove(r)
elif season == "20082009":
for r in ["FLA", "BUF", "OTT", "TOR", "WPG", "TBL", "NYI",
"MIN", "NSH", "EDM", "DAL", "ARI", "LAK", "COL"]:
teams.remove(r)
elif season == "20072008":
for r in ["CAR", "BUF", "FLA", "TOR", "NYI", "WPG", "TBL",
"EDM", "CHI", "VAN", "ARI", "CBJ", "STL", "LAK"]:
teams.remove(r)
elif season == "20062007":
for r in ["TOR", "MTL", "CAR", "FLA", "BOS", "WSH", "PHI",
"COL", "STL", "CBJ", "EDM", "CHI", "LAK", "ARI"]:
teams.remove(r)
elif season == "20052006":
for r in ["TOR", "WPG", "FLA", "NYI", "BOS", "WSH", "PIT",
"VAN", "LAK", "MIN", "ARI", "CBJ", "CHI", "STL"]:
teams.remove(r)
elif season == "20032004":
for r in ["BUF", "WPG", "CAR", "FLA", "NYR", "WSH", "PIT",
"EDM", "MIN", "LAK", "ANA", "ARI", "CBJ", "CHI"]:
teams.remove(r)
elif season == "20022003":
for r in ["NYR", "MTL", "WPG", "BUF", "FLA", "PIT", "CAR",
"CHI", "LAK", "ARI", "CGY", "NSH", "SJS", "CBJ"]:
teams.remove(r)
elif season == "20012002":
for r in ["WSH", "BUF", "NYR", "PIT", "TBL", "FLA", "WPG",
"EDM", "DAL", "CGY", "MIN", "ANA", "NSH", "CBJ"]:
teams.remove(r)
elif season == "20002001":
for r in ["BOS", "NYR", "MTL", "FLA", "WPG", "TBL", "NYI",
"ARI", "NSH", "CGY", "CHI", "CBJ", "MIN", "ANA"]:
teams.remove(r)
elif season == "19992000":
for r in ["CAR", "MTL", "NYR", "BOS", "NYI", "TBL", "WPG",
"ANA", "VAN", "CHI", "CGY", "NSH"]:
teams.remove(r)
elif season == "19981999":
for r in ["FLA", "NYR", "MTL", "WSH", "NYI", "TBL", "CGY",
"CHI", "LAK", "NSH", "VAN"]:
teams.remove(r)
elif season == "19971998":
for r in ["CAR", "NYI", "NYR", "FLA", "TBL", "CHI", "TOR",
"CGY", "ANA", "VAN"]:
teams.remove(r)
return(teams)
class i2c(Frame) :
def __init__(self,master):
self.master = master
self.SclIn = 0
self.SdaIn = 0
self.decode_index = []
self.decode_state1 = []
self.decode_state2 = []
self.decode_position = []
self.decode_text = []
def set_decode(self,channelStates):
self.top = Toplevel(self.master)
self.top.geometry("300x150")
self.top.title("i2c")
self.top.grab_set()
self.SDAlab = Label(self.top, text="SDA:")
self.SDAlab.place(x = 80,y = 20)
self.SCLlab = Label(self.top, text="SCL:")
self.SCLlab.place(x = 80,y = 50)
self.SdaCombo = Combobox(self.top, state="readonly",width = 8)
self.SdaCombo.place(x = 140,y = 20)
self.SclCombo = Combobox(self.top, state="readonly",width = 8)
self.SclCombo.place(x = 140,y = 50)
scl_in_temp = 100
sda_in_temp = 100
for i in range(0,len(channelStates)):
if(channelStates[i] == 1 and i == self.SclIn):
scl_in_temp = i
if(channelStates[i] == 1 and i == self.SdaIn):
sda_in_temp = i
for i in range(0,len(channelStates)):
if(channelStates[i] == 1 and scl_in_temp == 100):
scl_in_temp = i
if(channelStates[i] == 1 and sda_in_temp == 100):
sda_in_temp = i
if (scl_in_temp == 100):
scl_in_temp = 0
if (sda_in_temp == 100):
sda_in_temp = 0
self.SclIn = scl_in_temp
self.SdaIn = sda_in_temp
self.SdaCombo['values'] += (str(self.SdaIn))
self.SclCombo['values'] += (str(self.SclIn))
for i in range(0,len(channelStates)):
if (channelStates[i] == 1):
if str(i) not in self.SdaCombo['values']:
self.SdaCombo['values'] += (str(i),)
if str(i) not in self.SclCombo['values']:
self.SclCombo['values'] += (str(i),)
self.Button = Button(self.top, text = "OK",height=2, width=18, command = self.OkCallBack)
self.Button.place(x = 80,y = 90)
self.SclCombo.current(0)
self.SdaCombo.current(0)
self.top.protocol('WM_DELETE_WINDOW', self.exit_handler)
self.top.mainloop()
def decode(self,results,max_index,frequence):
print (results[self.SdaIn][100:4])
self.decode_index = []
self.decode_state1 = []
self.decode_state2 = []
self.decode_position = []
self.decode_text = []
self.decode_index.append(0)
self.decode_state1.append(1)
self.decode_state2.append(0)
self.bit_count = 0
self.data = 0
self.decodeStrTmp = ""
for i in range(1,max_index):
if ((results[self.SclIn][i-1]==1 and results[self.SdaIn][i-1]==1) and
(results[self.SclIn][i]==1 and results[self.SdaIn][i]==0) and self.bit_count == 0):#START
self.add_point(i)
self.decodeStrTmp += "St"
self.decode_position.append(i-((i-self.decode_index[-1])/2))
self.decode_text.append(self.decodeStrTmp)
self.decodeStrTmp = ""
self.bit_count = 1
elif ((results[self.SclIn][i-1]==1 and results[self.SdaIn][i-1]==0) and
(results[self.SclIn][i]==1 and results[self.SdaIn][i]==1)):#STOP
self.decode_position.append(i-((i-self.decode_index[-1])/2))
self.decodeStrTmp += "Sp"
self.decode_text.append(self.decodeStrTmp)
self.decodeStrTmp = ""
self.add_point(i)
self.bit_count = 0
elif(self.bit_count > 0 and self.bit_count < 8 and results[self.SclIn][i]==1 and
results[self.SclIn][i-1]==0):#ADRESS
if(self.bit_count==1):
self.data = 0
self.add_point(i)
self.data = self.data<<1
self.data += results[self.SdaIn][i]
if(self.bit_count==7):
self.decodeStrTmp = str(hex(self.data))
self.data = 0
self.bit_count += 1
elif(self.bit_count == 8 and results[self.SclIn][i]==1 and results[self.SclIn][i-1]==0):#READ/WRITE
if(results[self.SdaIn][i] == 1):
self.decodeStrTmp = self.decodeStrTmp + "+R"
else:
self.decodeStrTmp = self.decodeStrTmp + "+W"
self.decode_position.append(i-((i-self.decode_index[-1])/2))
self.decode_text.append(self.decodeStrTmp)
self.decodeStrTmp = ""
self.bit_count = 30
elif((self.bit_count == 9 or self.bit_count == 18) and results[self.SclIn][i]==1 and results[self.SclIn][i-1]==0):#ACK
if(results[self.SdaIn][i] == 1):
self.decodeStrTmp = self.decodeStrTmp + "NACK"
else:
self.decodeStrTmp = self.decodeStrTmp + "ACK"
self.bit_count = 31
self.decode_position.append(i-((i-self.decode_index[-1])/2))
self.decode_text.append(self.decodeStrTmp)
self.decodeStrTmp = ""
elif(self.bit_count > 9 and self.bit_count < 18 and results[self.SclIn][i]==1 and results[self.SclIn][i-1]==0):#DATA
if(self.bit_count==10):
self.data = 0
self.data = (self.data<<1) & results[self.SdaIn][i]
if(self.bit_count==17):
self.decodeStrTmp = str(hex(self.data))
self.data = 0
self.bit_count += 1
elif(self.bit_count == 30 and results[self.SclIn][i]==0 and results[self.SclIn][i-1]==1):
self.bit_count = 9
self.add_point(i)
elif(self.bit_count == 31 and results[self.SclIn][i]==0 and results[self.SclIn][i-1]==1):
self.bit_count = 10
self.add_point(i)
def OkCallBack(self):
self.SdaIn = int(self.SdaCombo.get())
self.SclIn = int(self.SclCombo.get())
self.exit_handler()
def exit_handler(self):
#self.master.deiconify()
self.top.grab_release()
self.top.destroy()
def add_point(self,i):
self.decode_index.append(i)
self.decode_state1.append(self.decode_state1[-1])
self.decode_state2.append(self.decode_state2[-1])
self.decode_index.append(i+0.5)
self.decode_state1.append(1-self.decode_state1[-1])
self.decode_state2.append(1-self.decode_state2[-1])
class Config(Toplevel):
""" Configuration dialog to set times and language. """
def __init__(self, master):
Toplevel.__init__(self, master, class_="CheckMails")
self.title(_("Preferences"))
style = Style(self)
style.map("TCombobox",
fieldbackground=[('readonly', 'white')],
selectbackground=[('readonly', 'white')],
selectforeground=[('readonly', 'black')],
foreground=[('readonly', 'black')])
# validation of the entries : only numbers are allowed
self._validate_entry_nb = self.register(self.validate_entry_nb)
# --- Times
Label(self,
text=_("Time between two checks")).grid(row=0, column=0,
padx=(10, 4), pady=(10, 4),
sticky="e")
Label(self, justify="right",
text=_("Maximum time allowed for login or check\n\
(then the connection is reset)")).grid(row=1, column=0, padx=(10, 4), pady=4, sticky="e")
self.time_entry = Entry(self, width=5, justify="center",
validate="key",
validatecommand=(self._validate_entry_nb, "%P"))
self.time_entry.grid(row=0, column=1, padx=(4, 0), pady=(10, 4))
self.time_entry.insert(0, "%g" % (CONFIG.getint("General", "time") / 60000))
self.timeout_entry = Entry(self, width=5, justify="center",
validate="key",
validatecommand=(self._validate_entry_nb, "%P"))
self.timeout_entry.grid(row=1, column=1, padx=(4, 0), pady=4)
self.timeout_entry.insert(0, "%g" % (CONFIG.getint("General", "timeout") / 60000))
Label(self, text="min").grid(row=0, column=2, padx=(0, 10), pady=(10, 4))
Label(self, text="min").grid(row=1, column=2, padx=(0, 10), pady=4)
frame = Frame(self)
frame.grid(row=2, columnspan=3, padx=6, pady=(0, 6))
# --- Language
Label(frame, text=_("Language")).grid(row=0, column=0,
padx=8, pady=4, sticky="e")
lang = {"fr": "Français", "en": "English"}
self.lang = StringVar(self, lang[CONFIG.get("General", "language")])
menu_lang = Menu(frame, tearoff=False)
Menubutton(frame, menu=menu_lang, width=9,
textvariable=self.lang).grid(row=0, column=1,
padx=8, pady=4, sticky="w")
menu_lang.add_radiobutton(label="English", value="English",
variable=self.lang, command=self.translate)
menu_lang.add_radiobutton(label="Français", value="Français",
variable=self.lang, command=self.translate)
# --- gui toolkit
Label(frame,
text=_("GUI Toolkit for the system tray icon")).grid(row=1, column=0,
padx=8, pady=4,
sticky="e")
self.gui = StringVar(self, CONFIG.get("General", "trayicon").capitalize())
menu_gui = Menu(frame, tearoff=False)
Menubutton(frame, menu=menu_gui, width=9,
textvariable=self.gui).grid(row=1, column=1,
padx=8, pady=4, sticky="w")
for toolkit, b in TOOLKITS.items():
if b:
menu_gui.add_radiobutton(label=toolkit.capitalize(),
value=toolkit.capitalize(),
variable=self.gui,
command=self.change_gui)
# --- Font
self.preview_path = tempfile.mktemp(".png", "checkmails_preview")
w = max([len(f) for f in TTF_FONTS])
self.fonts = sorted(TTF_FONTS)
self.font = Combobox(frame, values=self.fonts, width=(w * 2) // 3,
exportselection=False, state="readonly")
current_font = CONFIG.get("General", "font")
if current_font in self.fonts:
i = self.fonts.index(current_font)
else:
i = 0
self.font.current(i)
self.img_prev = PhotoImage(master=self, file=IMAGE)
Label(frame, text=_("Font")).grid(row=2, column=0,
padx=8, pady=4, sticky="e")
self.font.grid(row=2, column=1, padx=8, pady=4, sticky="w")
self.prev = Label(frame, image=self.img_prev)
self.prev.grid(row=2, column=2, padx=8, pady=4)
self.update_preview()
self.font.bind('<<ComboboxSelected>>', self.update_preview)
self.font.bind_class("ComboboxListbox", '<KeyPress>', self.key_nav)
# --- Ok/Cancel
frame_button = Frame(self)
frame_button.grid(row=3, columnspan=3, padx=6, pady=(0, 6))
Button(frame_button, text="Ok",
command=self.ok).grid(row=2, column=0, padx=8, pady=4)
Button(frame_button, text=_("Cancel"),
command=self.destroy).grid(row=2, column=1, padx=4, pady=4)
def update_preview(self, event=None):
self.font.selection_clear()
nb = "0"
im = Image.open(IMAGE)
draw = ImageDraw.Draw(im)
font_name = self.font.get()
font_path = TTF_FONTS[font_name]
W, H = im.size
try:
font = ImageFont.truetype(font_path, FONTSIZE)
w, h = draw.textsize(nb, font=font)
draw.text(((W - w) / 2, (H - h) / 2), nb, fill=(255, 0, 0),
font=font)
except OSError:
w, h = draw.textsize(nb)
draw.text(((W - w) / 2, (H - h) / 2), nb, fill=(255, 0, 0))
if W > 48:
im.resize((48, 48), Image.ANTIALIAS).save(self.preview_path)
else:
im.save(self.preview_path)
self.img_prev.configure(file=self.preview_path)
self.prev.configure(image=self.img_prev)
self.prev.update_idletasks()
def key_nav(self, event):
char = event.char.upper()
if char:
i = 0
n = len(self.fonts)
while i < n and self.fonts[i] < char:
i += 1
if i < n:
self.tk.eval("%s selection clear 0 end" % (event.widget))
self.tk.eval("%s see %i" % (event.widget, i))
self.tk.eval("%s selection set %i" % (event.widget, i))
self.tk.eval("%s activate %i" % (event.widget, i))
def ok(self):
time = float(self.time_entry.get()) * 60000
timeout = float(self.timeout_entry.get()) * 60000
CONFIG.set("General", "time", "%i" % time)
CONFIG.set("General", "timeout", "%i" % timeout)
CONFIG.set("General", "language", self.lang.get().lower()[:2])
CONFIG.set("General", "font", self.font.get())
CONFIG.set("General", "trayicon", self.gui.get().lower())
save_config()
self.destroy()
def translate(self):
showinfo("Information",
_("The language setting will take effect after restarting the application"),
parent=self)
def change_gui(self):
showinfo("Information",
_("The GUI Toolkit setting will take effect after restarting the application"),
parent=self)
@staticmethod
def validate_entry_nb(P):
""" Allow only to enter numbers"""
parts = P.split(".")
b = len(parts) < 3 and P != "."
for p in parts:
b = b and (p == "" or p.isdigit())
return b
def destroy(self):
remove(self.preview_path)
Toplevel.destroy(self)
class mainGUI:
def __init__(self):
root = Tk()
root.wm_title("ThreadCam")
self.threadingVelocityVar = StringVar()
self.groovingVelocityVar = StringVar()
self.pitchToggle = StringVar()
self.threadingToolEntry = {}
self.groovingToolEntry = {}
self.threadDataEntry = {}
self.miscDataEntry = {}
#Menubar
menuBar = Menu(root)
fileMenu = Menu(menuBar, tearoff=0)
fileMenu.add_command(label="Open", command=self.openCommand)
fileMenu.add_command(label="Save", command=self.saveCommand)
fileMenu.add_separator()
fileMenu.add_command(label="Exit", command=root.quit)
menuBar.add_cascade(label="File", menu=fileMenu)
programMenu = Menu(menuBar, tearoff=0)
programMenu.add_command(label="Generate", command=self.generateMenuCommand)
programMenu.add_command(label="Report...", command=self.reportCommand)
menuBar.add_cascade(label="Program", menu=programMenu)
root.config(menu=menuBar)
#End Menubar
#Tool Data Frame
toolDataFrame = Frame()
toolDataFrame.grid(padx=5, row=0, column=0, sticky=EW)
toolDataFrame.columnconfigure(2, weight=1)
label = Label(toolDataFrame, text="Tool Data", font=("Lucida Console bold", 18))
label.grid(row=0, column=0, sticky=W)
self.unitsVar = StringVar()
self.unitsVar.trace('w', self.unitsChange)
self.unitsBox = Combobox(toolDataFrame, state='readonly', width=10, textvar=self.unitsVar)
self.unitsBox['values'] = ('Imperial', 'Metric')
self.unitsBox.current(0)
self.unitsBox.grid(row=0, column=2, sticky=E, padx=5)
separator = Frame(toolDataFrame, height=2, bd=1, relief=SUNKEN)
separator.grid(pady=5, row=1, columnspan=7, sticky=EW)
#Threading Tool Data Frame
threadingToolFrame = Frame(toolDataFrame)
threadingToolFrame.grid(row=2, column=0, sticky=EW)
label = Label(threadingToolFrame, text="Threading Tool", font=("Lucida Console", 14))
label.grid(row=0, column=0, sticky=W)
Label(threadingToolFrame, text="Tool Number") .grid(row=1, column=0, sticky=W)
Label(threadingToolFrame,
textvar=self.threadingVelocityVar) .grid(row=2, column=0, sticky=W)
Label(threadingToolFrame, text="PDX") .grid(row=3, column=0, sticky=W)
Label(threadingToolFrame, text="NAP") .grid(row=4, column=0, sticky=W)
self.threadingToolEntry["toolNumber"] = Entry(threadingToolFrame, width=10)
self.threadingToolEntry["velocity"] = Entry(threadingToolFrame, width=10)
self.threadingToolEntry["PDX"] = Entry(threadingToolFrame, width=10)
self.threadingToolEntry["NAP"] = Entry(threadingToolFrame, width=10)
self.threadingToolEntry["toolNumber"] .grid(row=1, column=1, sticky=W)
self.threadingToolEntry["velocity"] .grid(row=2, column=1, sticky=W)
self.threadingToolEntry["PDX"] .grid(row=3, column=1, sticky=W)
self.threadingToolEntry["NAP"] .grid(row=4, column=1, sticky=W)
separator = Frame(threadingToolFrame, height=0, bd=0, relief=SUNKEN)
separator.grid(padx=5, pady=5, row=5, columnspan=7)
Label(threadingToolFrame, text="Insert ID") .grid(row=6, column=0, sticky=W)
Label(threadingToolFrame, text="Cutting Unit ID") .grid(row=8, column=0, sticky=W)
Label(threadingToolFrame, text="Clamping Unit ID") .grid(row=10, column=0, sticky=W)
self.threadingToolEntry["insertID"] = Entry(threadingToolFrame, width=30)
self.threadingToolEntry["unitID"] = Entry(threadingToolFrame, width=30)
self.threadingToolEntry["clampingID"] = Entry(threadingToolFrame, width=30)
self.threadingToolEntry["insertID"] .grid(row=7, column=0, columnspan=2, sticky=W)
self.threadingToolEntry["unitID"] .grid(row=9, column=0, columnspan=2, sticky=W)
self.threadingToolEntry["clampingID"] .grid(row=11, column=0, columnspan=2, sticky=W)
#End Threading Tool Data Frame
separator = Frame(toolDataFrame, height=2, bd=1, relief=SUNKEN)
separator.grid(padx=10, row=3, column=1)
#Grooving Tool Data Frame
groovingToolFrame = Frame(toolDataFrame)
groovingToolFrame.grid(row=2, column=2, sticky=EW)
label = Label(groovingToolFrame, text="Grooving Tool", font=("Lucida Console", 14))
label.grid(row=0, column=0, sticky=W)
Label(groovingToolFrame, text="Tool Number") .grid(row=1, column=0, sticky=W)
Label(groovingToolFrame,
textvar=self.groovingVelocityVar) .grid(row=2, column=0, sticky=W)
Label(groovingToolFrame, text="Tool Width") .grid(row=3, column=0, sticky=W)
Label(groovingToolFrame, text="Number of Passes") .grid(row=4, column=0, sticky=W)
self.groovingToolEntry["toolNumber"] = Entry(groovingToolFrame, width=10)
self.groovingToolEntry["velocity"] = Entry(groovingToolFrame, width=10)
self.groovingToolEntry["toolWidth"] = Entry(groovingToolFrame, width=10)
self.groovingToolEntry["numberPasses"] = Entry(groovingToolFrame, width=10)
self.groovingToolEntry["toolNumber"] .grid(row=1, column=1, sticky=W)
self.groovingToolEntry["velocity"] .grid(row=2, column=1, sticky=W)
self.groovingToolEntry["toolWidth"] .grid(row=3, column=1, sticky=W)
self.groovingToolEntry["numberPasses"] .grid(row=4, column=1, sticky=W)
separator = Frame(groovingToolFrame, height=0, bd=0, relief=SUNKEN)
separator.grid(padx=5, pady=5, row=5, columnspan=7)
Label(groovingToolFrame, text="Insert ID") .grid(row=6, column=0, sticky=W)
Label(groovingToolFrame, text="Cutting Unit ID") .grid(row=8, column=0, sticky=W)
Label(groovingToolFrame, text="Clamping Unit ID") .grid(row=10, column=0, sticky=W)
self.groovingToolEntry["insertID"] = Entry(groovingToolFrame, width=30)
self.groovingToolEntry["unitID"] = Entry(groovingToolFrame, width=30)
self.groovingToolEntry["clampingID"] = Entry(groovingToolFrame, width=30)
self.groovingToolEntry["insertID"] .grid(row=7, column=0, columnspan=2, sticky=W)
self.groovingToolEntry["unitID"] .grid(row=9, column=0, columnspan=2, sticky=W)
self.groovingToolEntry["clampingID"] .grid(row=11, column=0, columnspan=2, sticky=W)
#End Grooving Tool Data Frame
separator = Frame(toolDataFrame, height=2, bd=1, relief=SUNKEN)
separator.grid(padx=5, pady=10, row=9, columnspan=6)
#End Tool Data Frame
#Thread Data Frame
threadDataFrame = Frame()
threadDataFrame.grid(padx=5, row=1, column=0, sticky=EW)
threadDataFrame.columnconfigure(2, weight=1)
w = Label(threadDataFrame, text="Thread Data", font=("Lucida Console bold", 18))
w.grid(row=0, column=0, sticky=W)
infoButton = Button(threadDataFrame, text="Info", command=self.threadInfoCommand)
infoButton.grid(row=0, column=2, sticky=E, padx=5)
separator = Frame(threadDataFrame, height=2, bd=1, relief=SUNKEN)
separator.grid(pady=5, row=1, columnspan=7, sticky=EW)
# photo = PhotoImage(file="Thread dimensions.gif")
# w = Label(threadDataFrame, image=photo)
# w.photo = photo
# w.grid(padx=5, pady=5, row=2, columnspan=7, sticky=EW)
#Thread Geometry Frame
threadGeometryFrame = Frame(threadDataFrame)
threadGeometryFrame.grid(row=2, column=0, columnspan=7, sticky=EW)
threadGeometryFrame.columnconfigure(0, weight=3)
threadGeometryFrame.columnconfigure(2, weight=1)
threadGeometryFrame.columnconfigure(5, weight=5)
Label(threadGeometryFrame, text="Thread Length") .grid(row=0, column=0, sticky=W)
Label(threadGeometryFrame, text="Chamfer Angle") .grid(row=1, column=0, sticky=W)
Label(threadGeometryFrame, text="Chamfer Length") .grid(row=2, column=0, sticky=W)
Label(threadGeometryFrame, text="Geometry") .grid(row=3, column=0, sticky=W)
Label(threadGeometryFrame, text="Front (A)") .grid(row=1, column=1, sticky=W)
Label(threadGeometryFrame, text="Front (a)") .grid(row=2, column=1, sticky=W)
Label(threadGeometryFrame,
text="Max Crest\nDiameter",justify=LEFT) .grid(row=3, column=1, sticky=W)
self.threadDataEntry["threadLength"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["frontAngle"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["frontLength"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["diameter"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["threadLength"] .grid(row=0, column=2, sticky=W)
self.threadDataEntry["frontAngle"] .grid(row=1, column=2, sticky=W)
self.threadDataEntry["frontLength"] .grid(row=2, column=2, sticky=W)
self.threadDataEntry["diameter"] .grid(row=3, column=2, sticky=W)
Label(threadGeometryFrame, text="Measure") .grid(row=0, column=3, sticky=W)
Label(threadGeometryFrame, text="Back (B)") .grid(row=1, column=3, sticky=W)
Label(threadGeometryFrame, text="Back (b)") .grid(row=2, column=3, sticky=W)
Label(threadGeometryFrame,
textvar=self.pitchToggle) .grid(row=3, column=3, sticky=W)
self.threadDataEntry["backAngle"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["backLength"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["TPI"] = Entry(threadGeometryFrame, width=10)
self.threadDataEntry["backAngle"] .grid(row=1, column=4, sticky=W)
self.threadDataEntry["backLength"] .grid(row=2, column=4, sticky=W)
self.threadDataEntry["TPI"] .grid(row=3, column=4, sticky=W)
self.threadDataEntry["measure"] = Combobox(threadGeometryFrame, state='readonly', width=3)
self.threadDataEntry["measure"]['values'] = ('Z1', 'Z2', 'Z3')
self.threadDataEntry["measure"].grid(row=0, column=4, sticky=W)
#End Thread Geometry Frame
separator = Frame(threadDataFrame, height=2, bd=1, relief=SUNKEN)
separator.grid(padx=5, pady=10, row=3, columnspan=6)
#Misc Data Frame
miscDataFrame = Frame()
miscDataFrame.grid(padx=5, row=3, column=0, sticky=EW)
miscDataFrame.columnconfigure(2, weight=1)
w = Label(miscDataFrame, text="Miscellaneous Data", font=("Lucida Console bold", 18))
w.grid(row=0, column=0, sticky=W)
infoButton = Button(miscDataFrame, text="Info", command=self.miscInfoCommand)
infoButton.grid(row=0, column=2, sticky=E, padx=5)
separator = Frame(miscDataFrame, height=2, bd=1, relief=SUNKEN)
separator.grid(padx=5, pady=5, row=1, columnspan=7, sticky=EW)
miscDataSubFrame = Frame(miscDataFrame)
miscDataSubFrame.grid(row=2, column=0, sticky=EW)
miscDataSubFrame.columnconfigure(0, pad=30)
miscDataSubFrame.columnconfigure(1, pad=10)
miscDataSubFrame.columnconfigure(2, pad=30)
Label(miscDataSubFrame, text="Safe Point") .grid(row=0, column=0, sticky=W)
Label(miscDataSubFrame, text="Safe End") .grid(row=0, column=2, sticky=W)
Label(miscDataSubFrame, text="Retract Point") .grid(row=1, column=0, sticky=W)
Label(miscDataSubFrame, text="Z Shift") .grid(row=1, column=2, sticky=W)
safePointFrame = Frame(miscDataSubFrame)
safePointFrame.grid(row=0, column=1, sticky=EW)
Label(safePointFrame, text="X") .grid(row=0, column=0, sticky=W)
Label(safePointFrame, text="Z") .grid(row=0, column=2, sticky=W)
self.miscDataEntry["safePointX"] = Entry(safePointFrame, width=10)
self.miscDataEntry["safePointZ"] = Entry(safePointFrame, width=10)
self.miscDataEntry["safePointX"] .grid(row=0, column=1, sticky=W)
self.miscDataEntry["safePointZ"] .grid(row=0, column=3, sticky=W)
safeEndFrame = Frame(miscDataSubFrame)
safeEndFrame.grid(row=0, column=3, sticky=EW)
Label(safeEndFrame, text="Z") .grid(row=0, column=0, sticky=W)
self.miscDataEntry["safeEndZ"] = Entry(safeEndFrame, width=10)
self.miscDataEntry["safeEndZ"] .grid(row=0, column=1, sticky=W)
retractPointFrame = Frame(miscDataSubFrame)
retractPointFrame.grid(row=1, column=1, sticky=W)
Label(retractPointFrame, text="X") .grid(row=0, column=0, sticky=W)
self.miscDataEntry["retract"] = Entry(retractPointFrame, width=10)
self.miscDataEntry["retract"] .grid(row=0, column=1, sticky=W)
zShiftFrame = Frame(miscDataSubFrame)
zShiftFrame.grid(row=1, column=3, sticky=E)
Label(zShiftFrame, text="Z") .grid(row=0, column=0, sticky=W)
self.miscDataEntry["zShift"] = Entry(zShiftFrame, width=10)
self.miscDataEntry["zShift"] .grid(row=0, column=1, sticky=W)
followThroughFrame = Frame(miscDataSubFrame)
followThroughFrame.grid(row=2, column=0, columnspan=5, sticky=W)
followThroughFrame.columnconfigure(0, pad=30)
Label(followThroughFrame, text="Clipping Follow Through Plane")\
.grid(row=0, column=0, sticky=W)
Label(followThroughFrame, text="X") .grid(row=0, column=1, sticky=W)
self.miscDataEntry["followThrough"] = Entry(followThroughFrame, width=10)
self.miscDataEntry["followThrough"] .grid(row=0, column=2, sticky=W)
separator = Frame(root, height=2, bd=1, relief=SUNKEN)
separator.grid(padx=5, pady=5, row=4, columnspan=7, sticky=EW)
#Browse Frame
browseFrame = Frame(root)
browseFrame.grid(row=5, column=0, sticky=EW, padx=5)
browseFrame.columnconfigure(0, weight=1)
self.FileEntry = Entry(browseFrame) #Attribute
self.FileEntry.grid(row=0, column=0, sticky=EW)
browseButton = Button(browseFrame, text="Browse", command=self.browseCommand) #Attribute
browseButton.grid(row=0, column=1, sticky=W)
#End Browse Frame
GenerateButton = Button(root, text="Generate", command=self.generateCommand) #Attribute
GenerateButton.grid(row=6, column=0, sticky=EW, padx=5, pady=5)
root.resizable(0, 0)
root.mainloop()
def generateCommand(self):
filename = self.FileEntry.get()
if filename == "":
filename = filedialog.asksaveasfilename(defaultextension='.nc',
filetypes=[(".NC files", ".nc"), ("Text files", ".txt"), ("All files", ".*")])
if filename != "":
self.generateCode(filename)
def generateMenuCommand(self):
filename = filedialog.asksaveasfilename(defaultextension='.nc',
filetypes=[(".NC files", ".nc"), ("Text files", ".txt"), ("All files", ".*")])
if filename != "":
self.generateCode(filename)
def generateCode(self, filename):
currentData = self.readEntry()
currentGen = threadCAM(currentData)
threadCode = currentGen.threadCode()
frontCode = currentGen.clipFrontCode()
backCode = currentGen.clipBackCode()
lastPassCode = currentGen.threadCode(True)
try:
text_file = open(filename, "w")
text_file.write(threadCode)
text_file.write(frontCode)
text_file.write(backCode)
text_file.write(lastPassCode)
text_file.close()
webbrowser.open(filename)
except:
print("Write failed")
def openCommand(self):
filename = filedialog.askopenfilename(filetypes=[("ThreadCAM files", ".tc"), ("All files", ".*")])
try:
with open(filename, 'rb') as input:
currentData = pickle.load(input)
for v in currentData.threadingToolValues.keys():
self.threadingToolEntry[v].delete(0, END)
self.threadingToolEntry[v].insert(0, currentData.threadingToolValues[v])
for v in currentData.groovingToolValues.keys():
self.groovingToolEntry[v].delete(0, END)
self.groovingToolEntry[v].insert(0, currentData.groovingToolValues[v])
for v in currentData.threadDataValues.keys():
self.threadDataEntry[v].delete(0, END)
self.threadDataEntry[v].insert(0, currentData.threadDataValues[v])
for v in currentData.miscDataValues.keys():
self.miscDataEntry[v].delete(0, END)
self.miscDataEntry[v].insert(0, currentData.miscDataValues[v])
if currentData.threadDataValues["measure"] == 'Z1':
self.threadDataEntry["measure"].current(0)
if currentData.threadDataValues["measure"] == 'Z2':
self.threadDataEntry["measure"].current(1)
if currentData.threadDataValues["measure"] == 'Z3':
self.threadDataEntry["measure"].current(2)
if currentData.units == 'Imperial':
self.unitsBox.current(0)
elif currentData.units == 'Metric':
self.unitsBox.current(1)
except:
print("No file")
return
def saveCommand(self):
filename = filedialog.asksaveasfilename(defaultextension='.tc', filetypes=[("ThreadCAM files", ".tc"), ("All files", ".*")])
try:
with open(filename, 'wb') as output:
currentData = self.readEntry()
#print(currentData)
pickle.dump(currentData, output, pickle.HIGHEST_PROTOCOL)
except:
print("No file")
return
def reportCommand(self):
return
def browseCommand(self):
filename = filedialog.asksaveasfilename(defaultextension='.nc')
self.FileEntry.delete(0, END)
self.FileEntry.insert(0, filename)
return
def threadInfoCommand(self):
return
def miscInfoCommand(self):
return
def readEntry(self):
threadingToolValues = {v : self.threadingToolEntry[v].get() for v in self.threadingToolEntry.keys()}
groovingToolValues = {v : self.groovingToolEntry[v].get() for v in self.groovingToolEntry.keys()}
threadDataValues = {v : self.threadDataEntry[v].get() for v in self.threadDataEntry.keys()}
miscDataValues = {v : self.miscDataEntry[v].get() for v in self.miscDataEntry.keys()}
currentUnits = self.unitsVar.get()
#print(threadingToolValues)
#print(groovingToolValues)
#print(threadDataValues)
return cuttingDataContainer(threadingToolValues, groovingToolValues, threadDataValues, miscDataValues, currentUnits)
def unitsChange(self, index, value, op):
currentUnits = self.unitsVar.get()
if currentUnits == 'Imperial':
self.threadingVelocityVar.set('Velocity (ft/min)')
self.groovingVelocityVar.set('Velocity (ft/min)')
self.pitchToggle.set('TPI')
elif currentUnits == 'Metric':
self.threadingVelocityVar.set('Velocity (m/min)')
self.groovingVelocityVar.set('Velocity (m/min)')
self.pitchToggle.set('Pitch')
#print("combobox updated to "+ self.unitsVar.get())
return
class AddeBookPopup(Frame):
""" Popup Frame to Add a Student """
def __init__(self, parent, close_callback):
""" Constructor """
Frame.__init__(self, parent)
style = Style()
style.configure('S.TButton', foreground='dark green', font=("TkTextFont", 11))
style.configure('C.TButton', foreground='brown4', font=("TkTextFont", 11))
style.configure('C.TLabel', foreground='purple4', font=("TkTextFont", 10, 'bold'))
self._close_cb = close_callback
self.grid(padx=40, pady=40, rowspan=2, columnspan=2)
Label(self, text="Book ID:", style='C.TLabel').grid(row=1, column=1)
self._book_id = Entry(self)
self._book_id.grid(row=1, column=2, padx=40, pady=10)
Label(self, text="Title:", style='C.TLabel').grid(row=2, column=1)
self._title = Entry(self)
self._title.grid(row=2, column=2, padx=40, pady=10)
Label(self, text="Author:", style='C.TLabel').grid(row=3, column=1)
self._author = Entry(self)
self._author.grid(row=3, column=2, padx=40, pady=10)
Label(self, text="Year Published:", style='C.TLabel').grid(row=4, column=1)
self._published_year = Entry(self)
self._published_year.grid(row=4, column=2, padx=40, pady=10)
Label(self, text="Edition:", style='C.TLabel').grid(row=5, column=1)
self._edition = Entry(self)
self._edition.grid(row=5, column=2, padx=40, pady=10)
Label(self, text="Platform:", style='C.TLabel').grid(row=6, column=1)
self._platform = Combobox(self, textvariable=StringVar(), values=["OverDrive Read", "Fast Read ebooks"])
self._platform.current(0)
self._platform.grid(row=6, column=2, padx=40, pady=10)
Label(self, text="Genre:", style='C.TLabel').grid(row=7, column=1)
self._genre = Combobox(self, textvariable=StringVar(), values=['biography', 'kids', 'business & finance',
'romance', 'mystery', 'comics', 'fantasy',
'notification', 'literature', 'periodicals'])
self._genre.current(0)
self._genre.grid(row=7, column=2, padx=40, pady=10)
Button(self, text="Add", width=15, style="S.TButton", command=self._validate_entry).grid(row=8, column=1,
padx=40, pady=10)
Button(self, text="Cancel", width=15, style="C.TButton", command=self._close_cb).grid(row=8, column=2, padx=40)
def _submit_cb(self):
""" Submit the Add Student """
data = {'book_id': self._book_id.get(),
'title': self._title.get(),
'author': self._author.get(),
'published_year': self._published_year.get(),
'edition': self._edition.get(),
'platform': self._platform.get(),
'genre': self._genre.get()}
response = requests.post("http://127.0.0.1:5000/library_manager/ebook", json=data)
if response.status_code != 200:
mb.showerror(title='Error while Submitting', message=response.text)
else:
self._close_cb()
def _validate_entry(self):
"""Entry Validation"""
book_id = self._book_id.get()
title = self._title.get()
author = self._author.get()
published_year = self._published_year.get()
edition = self._edition.get()
# if not (book_id or title or author or published_year or edition) DOESN'T work for me :)
# Also I tried regex and for some reason that didn't work either
if (not book_id) or (not title) or (not author) or (not published_year) or (not edition):
mb.showerror(title='Error while Submitting', message='Please fill all fields.')
elif (not type(book_id) == str) or (not (2 < len(book_id) < 7)):
mb.showerror(title='Error while Submitting', message='Please enter a valid ID.')
elif (not int(published_year)) or (not (1920 < int(published_year) < 2020)):
mb.showerror(title='Error while Submitting', message='Please enter a valid year.')
elif (not int(edition)) or (not int(edition) > 1):
mb.showerror(title='Error while Submitting', message='Please enter a valid edition.')
else:
self._submit_cb()
def clear(event):
caller=event.widget
caller.delete("0", "end")
window=Tk()
window.title("Calculator")
window.minsize(500,350)
inp=Entry(window,width=5)
inp.bind("<FocusIn>", clear)
inp.grid(row=0, column=0)
operator1=Combobox(window, width=15)
operator1['values']=("Площадь", "Периметр")
operator1.current(0)
operator1.grid(row=0, column=1)
operator2=Combobox(window, width=10)
operator2['values']=("Круг", "Квадрат")
operator2.current(0)
operator2.grid(row=0, column=2)
output = Text(window, bg="pink", fg='white', font = "Arial 20", width=25, height=10)
output.grid(row=1, columnspan=8)
btn=Button(window, text="=", command=handler)
btn.grid(row=0, column=3)
window.mainloop()
class LogicAnalyzer :
def __init__(self,master) :
self.master = master
self.BLOCK_LEN = 2048 * 32
self.RxTimerState = 1
self.deviceIndex = -1
self.dev = None
self.rx_buffer = bytearray()
self.timeout = 0;
self.x = np.arange(0, 30, 1)
self.axis = np.arange(25, 100, 1)
self.z = [0] * 75
self.index_max = 0
self.results = []
self.index = []
for i in range(0,16):
tempList = []
self.results.append(tempList)
self.startPosition = 0
self.sampPitch = 1
self.sampOnScreen = 30
self.finishPosition = 0
self.channelActiveMask = 0
self.coreFrq = 300000000 #300MHz
self.coreFrqPeriod = 1000000000/self.coreFrq
self.sampFrq = 300000000.0
self.AARate = 0;
self.BBSamp = 0;
self.HHTrigPos = 0;
self.EEVolt = 0;
self.decoder_instances = []
self.dec_instance_state = []
for i in range(0,8):
inst_temp = i2c(self.master)
self.decoder_instances.append(inst_temp)
self.dec_instance_state.append("_")
self.channel_count = 0
self.channel_decode = [0]*16
self.decode_count = 0
self.decode_decode = [0]*8
self.top1 = Frame(self.master, height = 500, width = 260, borderwidth=2,highlightbackground="gray" , highlightthickness=1)
self.top1.pack(side="left", fill="both")
self.top2 = Frame(self.master, height = 500, width = 500, borderwidth=2,highlightbackground="gray" , highlightthickness=1)
self.top2.pack(side="right", fill="both")
self.top_slider = Frame(self.top2, height = 5, width = 500)
self.top_slider.pack(side="top", fill="x")
self.plot_frame = Frame(self.top2)
self.plot_frame.pack(side="top", fill="both",expand = 1)
self.right_slider = Frame(self.plot_frame)
self.right_slider.pack(side="right", fill="y")
self.AxisFrame = Frame(self.plot_frame, height = 5, width = 500)
self.AxisFrame.pack(side="top")
self.RSB1 = Button(self.right_slider, text = "+",height=1, width=4, command = self.zoomSliderP)
self.RSB1.pack(side="top")
self.w1 = Scale(self.right_slider, from_=1000, to=0,showvalue = 0,command = self.calcPosition)#command = self.calcPosition
self.w1.set(0)
self.w1.pack(side="top", fill="y",expand = 1)
self.RSB2 = Button(self.right_slider, text = "-",height=1, width=4, command = self.zoomSliderM)
self.RSB2.pack(side="top")
self.w2 = Scale(self.top_slider, from_=0, to=100000, orient=HORIZONTAL, showvalue = 0,command = self.calcPosition) #command = self.calcPosition
self.w2.set(0)
self.SB1 = Button(self.top_slider, text = "<<<",height=1, width=3, command = self.shiftSliderMM)
self.SB1.pack(side="left")
self.SB2 = Button(self.top_slider, text = "<",height=1, width=3, command = self.shiftSliderM)
self.SB2.pack(side="left")
self.w2.pack(side="left", fill="both",expand=1)
self.SB3 = Button(self.top_slider, text = ">>>",height=1, width=3, command = self.shiftSliderPP)
self.SB3.pack(side="right")
self.SB4 = Button(self.top_slider, text = ">",height=1, width=3, command = self.shiftSliderP)
self.SB4.pack(side="right")
self.AxisFig = plt.Figure(figsize=(25,2), dpi=100)
self.AxisFig.set_figheight(0.25)
self.AxisFig.subplots_adjust(left=-0.05, right=1.05, top=2, bottom=1)
self.af = self.AxisFig.add_subplot(111)
self.AxisFig.patch.set_facecolor('whitesmoke')
self.af.axes.get_yaxis().set_visible(False)
self.af.step(self.axis, self.z, where='post', label='post')
self.af.set_frame_on(False)
self.axVar = StringVar()
self.axLab = Label(self.AxisFrame, textvariable=self.axVar,height = 1,width=2)
self.axVar.set("sp")
self.axLab.pack(side="left")
self.AxCanvas = FigureCanvasTkAgg(self.AxisFig, self.AxisFrame)
self.AxCanvas.get_tk_widget().pack(side = "left",pady=2)
self.decode_frame = Frame(self.plot_frame)
self.decode_frame.pack(side="top", fill="both",expand = 0)
self.channel_frame = Frame(self.plot_frame)
self.channel_frame.pack(side="top", fill="both",expand = 0)#<-----------------------------
self.plot_frames = []
for i in range(0,16):
self.plotFrame = Frame(self.channel_frame)
self.plot_frames.append(self.plotFrame)
self.decode_frames = []
for i in range(0,8):
self.decodeFrame = Frame(self.decode_frame)
self.decode_frames.append(self.decodeFrame)
self.plot_figures = []
self.plot_axes = []
self.plot_canvases = []
self.plot_labels = []
self.plot_label_values = []
for i in range(0,16):
self.figure = plt.Figure(figsize=(25,2), dpi=150)
self.plot_figures.append(self.figure)
self.plot_figures[i].set_figheight(0.2)#<------------------------------------------------
self.plot_figures[i].subplots_adjust(left=-0.05, right=1.05, top=1, bottom=0)
self.plot_figures[i].patch.set_visible(False)
self.ax = self.plot_figures[i].add_subplot(111)
self.plot_axes.append(self.ax)
self.canvas = FigureCanvasTkAgg(self.plot_figures[i], self.plot_frames[i])
self.plot_canvases.append(self.canvas)
self.insideVar = StringVar()
self.plot_label_values.append(self.insideVar)
self.plot_label_values[i].set(str(i))
self.plotLabel = Label(self.plot_frames[i], textvariable=self.plot_label_values[i],height = 1,width=2)
self.plot_labels.append(self.plotLabel)
self.plot_labels[i].pack(side="left")
self.plot_canvases[i].get_tk_widget().pack(side="right", fill="both", expand=1,pady=2)
self.decode_figures = []
self.decode_axes = []
self.decode_canvases = []
self.decode_labels = []
self.decode_label_values = []
for i in range(0,8):
self.figure = plt.Figure(figsize=(25,2), dpi=100)
self.decode_figures.append(self.figure)
self.decode_figures[i].set_figheight(0.3)
self.decode_figures[i].subplots_adjust(left=-0.05, right=1.05, top=1, bottom=0)
self.decode_figures[i].patch.set_visible(False)
self.ax = self.decode_figures[i].add_subplot(111)
self.decode_axes.append(self.ax)
self.canvas = FigureCanvasTkAgg(self.decode_figures[i], self.decode_frames[i])
self.decode_canvases.append(self.canvas)
self.insideVar = StringVar()
self.decode_label_values.append(self.insideVar)
self.decode_label_values[i].set(str(i+1))
self.decodeLabel = Label(self.decode_frames[i], textvariable=self.decode_label_values[i],height = 1,width=2)
self.decode_labels.append(self.decodeLabel)
self.decode_labels[i].pack(side="left")
self.decode_canvases[i].get_tk_widget().pack(side="right", fill="both", expand=1,pady=2)
self.BStart = Button(self.top1, text = "Start",height=2, width=30, command = self.StartCallBack)
self.BStart.place(x = 20,y = 10)
self.L2var = StringVar()
self.L2 = Label(self.top1, textvariable=self.L2var)
self.L2var.set("Duration:")
self.L2.place(x = 20,y = 70)
self.STB1var = StringVar()
self.STB1var.set("255")
self.STB1 = Entry(self.top1, width=11,textvariable = self.STB1var)
self.STB1.place(x = 85,y = 70)
self.comboDuration = Combobox(self.top1,
values=[
"samp",
"sec",
"msec",
"usec",
"nsec"],
state="readonly",
width = 8)
self.comboDuration.place(x = 170,y = 70)
self.comboDuration.current(0)
self.L3var = StringVar()
self.L3 = Label(self.top1, textvariable = self.L3var)
self.L3var.set("Samp. rate:")
self.L3.place(x = 20,y = 90)
self.STB2var = StringVar()
self.STB2var.set("300")
self.STB2 = Entry(self.top1, width=11,textvariable = self.STB2var)
self.STB2.place(x = 85,y = 90)
self.comboRate = Combobox(self.top1,
values=[
"Hz",
"kHz",
"MHz"],
state="readonly",
width = 8)
self.comboRate.place(x = 170,y = 90)
self.comboRate.current(2)
self.L6var = StringVar()
self.L6 = Label(self.top1, textvariable=self.L6var)
self.L6var.set("Input threshold, V:")
self.L6.place(x = 20,y = 110)
self.STB3var = StringVar()
self.STB3var.set("3")
self.STB3 = Entry(self.top1, width=11,textvariable = self.STB3var)
self.STB3.place(x = 170,y = 110)
self.var1 = IntVar()
self.CB1 = Checkbutton(self.top1, text='Trigger',variable=self.var1, onvalue=1, offvalue=0, command=self.TriggerCallBack) #
self.CB1.place(x = 20,y = 145)
self.L4var = StringVar()
self.L4 = Label(self.top1, textvariable=self.L4var)
self.L4var.set("Trigger type:")
self.L4.place(x = 20,y = 165)
self.comboTriggerT = Combobox(self.top1,
values=["Rising edge",
"Falling edge",
"High",
"Low"],
state="disabled",
width = 15)
self.comboTriggerT.place(x = 125,y = 165)
self.comboTriggerT.current(0)
self.L5var = StringVar()
self.L5 = Label(self.top1, textvariable=self.L5var)
self.L5var.set("Trigger channel:")
self.L5.place(x = 20,y = 185)
self.comboTriggerCh = Combobox(self.top1,
values=["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15"],
state="disabled",
width = 15)
self.comboTriggerCh.place(x = 125,y = 185)
self.comboTriggerCh.current(0)
self.channel_active_int = []
for i in range(0,16):
self.channel_active_int.append(0)
self.decode_active_int = []
for i in range(0,8):
self.decode_active_int.append(0)
self.L61var = StringVar()
self.L61 = Label(self.top1, textvariable=self.L61var)
self.L61var.set("Samp. before trig:")
self.L61.place(x = 20,y = 205)
self.STB31var = StringVar()
self.STB31var.set("3")
self.STB31 = Entry(self.top1, width=18,state="disabled",textvariable = self.STB31var)
self.STB31.place(x = 125,y = 205)
self.L7var = StringVar()
self.L7 = Label(self.top1, textvariable=self.L7var)
self.L7var.set("Channels:")
self.L7.place(x = 20,y = 240)
self.channel_active = []
self.channel_ch_box = []
for i in range(0,16):
self.chAct = IntVar()
self.channel_active.append(self.chAct)
self.chActChB = Checkbutton(self.top1, text=str(i),variable=self.channel_active[i], onvalue=1, offvalue=0, command=self.RefreshCh)
self.channel_ch_box.append(self.chActChB)
self.channel_ch_box[i].place(x = 20+(i%4)*60,y = 260+(i//4)*20)
self.L8var = StringVar()
self.L8 = Label(self.top1, textvariable=self.L8var)
self.L8var.set("Decoders:")
self.L8.place(x = 20,y = 355)
self.decode_cb = []
self.decode_cb_var = []
self.decode_combo = []
self.decode_buttons = []
for i in range(0,8):
dec_cb = IntVar()
self.decode_cb_var.append(dec_cb)
decActChB = Checkbutton(self.top1, text=str(i+1),variable=self.decode_cb_var[i], onvalue=1, offvalue=0, command=self.ResetDecodes) #
self.decode_cb.append(decActChB)
self.decode_cb[i].place(x = 20,y = 375+(i*28))
decodeCombo = Combobox(self.top1, values=["i2c"],state="disabled",width = 20)
self.decode_combo.append(decodeCombo)
self.decode_combo[i].place(x = 60,y = 375+(i*28))
self.decode_combo[i].current(0)
self.decode_combo[i].bind("<<ComboboxSelected>>", self.ComboUpdate)
self.decodeButton = Button(self.top1, text = "set",height=1, width=3, state="disabled")
self.decode_buttons.append(self.decodeButton)
self.decode_buttons[i].place(x = 210,y = 372+(i*28))
self.decode_buttons[i].configure(command=lambda:self.decoder_instances[i].set_decode(self.channel_active_int))
self.BDecode = Button(self.top1, text = "Decode",height=2, width=30, command = self.ResetDecodes)
self.BDecode.place(x = 20,y = 600)
self.BFill = Button(self.top1, text = "Fill",height=2, width=13, command = self.FillCallBack)
self.BFill.place(x = 20,y = 650)
self.BSort = Button(self.top1, text = "Sort",height=2, width=13, command = self.SortCallBack)
self.BSort.place(x = 140,y = 650)
for root, dirs, files in os.walk("."):
for filename in files:
if(filename[0:3]== "la_" and filename[-3:]== ".py"):
print(filename)
module_name = filename[3:len(filename)-3]
for i in range(0,8):
if module_name not in self.decode_combo[i]['values']:
self.decode_combo[i]['values'] += (module_name,)
self.drawDecodes([1,0,0,0,0,0,0,0],0)
self.drawPlots([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],1,1)
self.drawDecodes([0,0,0,0,0,0,0,0],0)
self.master.protocol("WM_DELETE_WINDOW",self.exit_handler)
def calcPosition(self,*args):
sampOnScreenMin = 30
sampOnScreenMax = 10000
self.index_max = 0
for i in range(0,16):
if(self.index_max < len(self.results[i])):
self.index_max = len(self.results[i])
if (self.index_max > sampOnScreenMin and self.index_max < sampOnScreenMax):
self.sampOnScreen = sampOnScreenMin + int(((self.index_max-sampOnScreenMin) / 1000) * (1000-self.w1.get()))
elif (self.index_max > sampOnScreenMax):
self.sampOnScreen = sampOnScreenMin + int(((sampOnScreenMax-sampOnScreenMin) / 1000) * (1000-self.w1.get()))
else:
self.sampOnScreen = self.index_max
self.sampPitch = (self.sampOnScreen // 1000) +1#
if (self.index_max > sampOnScreenMin):
self.startPosition = int((self.index_max - self.sampOnScreen)/100000 * self.w2.get())
else:
self.startPosition = 0
self.finishPosition = self.startPosition + self.sampOnScreen
self.drawPlots(self.channel_active_int,0,0)
def RefreshCh(self):
for i in range(0,16):
if(self.index_max < len(self.results[i])):
self.index_max = len(self.results[i])
for i in range(0,16):
if(len(self.results[i])<self.index_max and self.channel_active[i].get() == 1):
self.results[i] = [0]*self.index_max
self.calcPosition()
self.ResetPlots()
def ResetPlots(self):
self.channelActiveMask = 0
self.channel_count = 0
for i in range(0,16):
self.channel_active_int[i] = self.channel_active[i].get()
if(self.channel_active_int[i]==1):
self.channel_count += 1
self.channel_decode[i] = self.channel_count-1
for i in range(0,16):
self.channelActiveMask = (self.channelActiveMask << 1) | self.channel_active_int[15-i]
print(self.channel_active_int)
self.drawPlots(self.channel_active_int,1,0)
def ResetDecodes(self):
self.decodeActiveMask = 0
self.decode_count = 0
for i in range(0,8):
self.decode_active_int[i] = self.decode_cb_var[i].get()
if(self.decode_active_int[i]==1):
self.decode_count += 1
self.decode_decode[i] = self.decode_count-1
self.decode_combo[i]["state"] = "readonly"
self.decode_buttons[i]["state"] = "normal"
else:
self.decode_combo[i]["state"] = "disabled"
self.decode_buttons[i]["state"] = "disabled"
self.UpdateDecodeInstances()
for i in range(0,8):
if(self.decode_active_int[i] == 1):
self.decoder_instances[i].decode(self.results,self.index_max,self.sampFrq)
self.drawDecodes(self.decode_active_int,0)
def drawPlots(self,plot_state,refreshFlag,sortFlag):
self.index = np.arange(0, self.index_max, 1)
self.z = [0] * self.index_max
self.af.clear()
self.af.axes.get_yaxis().set_visible(False)
self.af.step(self.index[self.startPosition:self.finishPosition:1],
self.z[self.startPosition:self.finishPosition:1],
where='post', label='post')
self.af.set_frame_on(False)
self.AxCanvas.draw()
self.AxisFrame.pack(side="top")
if(sortFlag == 1):
for i in range(0,16):
self.plot_frames[i].pack_forget()
for i in range(0,16):
if(refreshFlag == 1):
self.plot_axes[i].clear()
self.plot_figures[i].patch.set_visible(False)
if(plot_state[i]==1):
self.plot_axes[i].clear()
self.plot_figures[i].patch.set_visible(False)
self.plot_axes[i].step(self.index[self.startPosition:self.finishPosition:1], #self.sampPitch
self.results[i][self.startPosition:self.finishPosition:1], #self.sampPitch
where='post', label='post')
self.plot_axes[i].set_ylim(-0.01,1.01)
self.plot_axes[i].axis('off')
self.plot_canvases[i].draw()
self.plot_canvases[i].get_tk_widget().update_idletasks()
if(refreshFlag == 1):
self.plot_frames[i].pack(side="top", fill="both", expand=1)
elif(refreshFlag == 1):
self.plot_frames[i].pack_forget()
self.ResetDecodes()
def drawDecodes(self,decode_state,sortFlag):
if(sortFlag == 1):
for i in range(0,8):
self.decode_frames[i].pack_forget()
for i in range(0,8):
self.decode_axes[i].clear()
self.decode_figures[i].patch.set_visible(False)
if(decode_state[i]==1):
self.decode_ind_temp = []
self.decode_state1_temp = []
self.decode_state2_temp = []
if(len(self.decoder_instances[i].decode_index)>0):
for f in range(0,len(self.decoder_instances[i].decode_index)):
if(self.decoder_instances[i].decode_index[f] > self.startPosition+0.5 and self.decoder_instances[i].decode_index[f] < self.finishPosition-0.5):
self.decode_ind_temp.append(self.decoder_instances[i].decode_index[f])
self.decode_state1_temp.append(self.decoder_instances[i].decode_state1[f])
self.decode_state2_temp.append(self.decoder_instances[i].decode_state2[f])
if(len(self.decode_ind_temp)==0):
self.decode_ind_temp.append(self.startPosition)
self.decode_state1_temp.append(0)
self.decode_state2_temp.append(1)
self.decode_ind_temp.insert(0,self.startPosition)
self.decode_state1_temp.insert(0,self.decode_state1_temp[0])
self.decode_state2_temp.insert(0,self.decode_state2_temp[0])
self.decode_ind_temp.append(self.finishPosition)
self.decode_state1_temp.append(self.decode_state1_temp[-1])
self.decode_state2_temp.append(self.decode_state2_temp[-1])
self.decode_axes[i].plot(self.decode_ind_temp, self.decode_state1_temp, color='r')
self.decode_axes[i].plot(self.decode_ind_temp, self.decode_state2_temp, color='r')
self.decode_axes[i].set_ylim(-0.01,1.01)
self.decode_axes[i].axis('off')
for d in range(0,len(self.decoder_instances[i].decode_position)):
self.decode_axes[i].text(self.decoder_instances[i].decode_position[d],0.1,self.decoder_instances[i].decode_text[d], fontsize=10)
self.decode_canvases[i].draw()
self.decode_frames[i].pack(side="top", fill="both", expand=1)
else:
self.decode_frames[i].pack_forget()
def TriggerCallBack(self):
if(self.var1.get() == 1):
self.comboTriggerCh["state"] = "readonly"
self.comboTriggerT["state"] = "readonly"
self.STB31["state"] = "normal"
else:
self.comboTriggerCh["state"] = "disabled"
self.comboTriggerT["state"] = "disabled"
#self.STB31var.set(3)
self.STB31["state"] = "disabled"
def ft_init(self):
#Get the device list and save the index of logic analyzer into deviceIndex
self.deviceList = ftd2xx.listDevices(0) # returns the list of ftdi devices S/Ns
self.deviceIndex = -1;
self.status = -1;
if self.deviceList :
print(len(self.deviceList), 'ftdi devices found')
for x in range(0,len(self.deviceList)):
if ( "LogicAnalyzer" in str(ftd2xx.getDeviceInfoDetail(x)['description'])) :
print("Device %d details: "%x)
print('-------------------------------------------------')
print("Serial : " + str(ftd2xx.getDeviceInfoDetail(x)['serial']))
print("Type : " + str(ftd2xx.getDeviceInfoDetail(x)['type']))
print("ID : " + str(ftd2xx.getDeviceInfoDetail(x)['id']))
print("Description : " + str(ftd2xx.getDeviceInfoDetail(x)['description']))
print('-------------------------------------------------')
if self.deviceIndex < 0:
self.deviceIndex = x
break
else:
print("no ftdi devices connected")
def connect(self):
if self.deviceIndex >= 0 :
print('Connecting to device with index %d'% self.deviceIndex)
self.dev = ftd2xx.open(self.deviceIndex) #FT4HNA7Z
self.status = 1
time.sleep(0.1)
self.dev.setBitMode(0x00, 0x40)
print('Device connected')
elif ftd2xx.listDevices(0):
print("no FTDI devices to be connected")
self.messagebox.showinfo(title=None, message="Logic Analyzer was not found")
def disconnect(self):
self.dev.close()
print("Device disconnected")
def timerHandler(self):
self.read()
print("check if all data collected %d"%len(self.rx_buffer))
print("needed %d"%(self.BBSamp-self.BBSamp*0.01))
if (len(self.rx_buffer) < (self.BBSamp-self.BBSamp*0.01) and (self.timeout < 50 or self.var1.get() == 1)) :
self.timeout += 1
self.master.after(1, self.timerHandler)
else:
print("data collected")
self.disconnect()
self.w1.set(0)
self.w2.set(0)
self.calcPosition()
def send(self):
print("Send data")
self.tx_data = "#>HH"
self.tx_data = "#$FF" + self.HHTrigPosStr
self.tx_data += "#$EE" + self.EEVoltStr
self.tx_data += "#$AA" + self.AARateStr
self.tx_data += "#$BB" + self.BBSampStr
self.tx_data += "#$CC" + self.CCTrigStr
self.tx_data += "#$DD" + self.DDMaskStr
self.tx_data += "#>GG"
self.tx_data = self.tx_data.upper()
self.tx_data += self.tx_data
for a in range(0,16):
self.results[a] = []
print(self.tx_data)
b=bytearray()
b.extend(map(ord,self.tx_data))
if len(self.tx_data)>0 :
print("\r\nSending %d bytes:"%len(self.tx_data))
print('-------------------------------------------------')
print(self.tx_data)
print('-------------------------------------------------')
self.written = self.dev.write(self.tx_data)
else :
print("Please enter data into a top text field")
#self.timer1.start()
self.timeout = 0
self.rx_buffer = bytearray()
self.timerHandler()
def read(self):
rx_data = bytearray()
while self.dev.getQueueStatus()>0 :
rx_data = self.dev.read(self.dev.getQueueStatus())
if len(rx_data)>0 :
self.rx_buffer += rx_data
print("\r\nReceived %d bytes:"%len(rx_data))
print('-------------------------------------------------')
self.timeout = 0 # reset timeout if some data received
if(self.channel_count <= 8):
for i in range(0,len(rx_data),1):
x = bytearray()
x.append(rx_data[i]);
if(self.channel_count <= 2):
for ind in range(0,16):
if(self.channel_active_int[ind] == 1):
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind]+6)&1))
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind]+4)&1))
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind]+2)&1))
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind])&1))
elif(self.channel_count <= 4):
for ind in range(0,16):
if(self.channel_active_int[ind] == 1):
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind]+4)&1))
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind])&1))
elif(self.channel_count <= 8):
for ind in range(0,16):
if(self.channel_active_int[ind] == 1):
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>self.channel_decode[ind])&1))
elif(self.channel_count > 8 and self.channel_count <= 16):
for i in range(0,len(rx_data)//2,2):
for ind in range(0,16):
x = bytearray()
x.append(rx_data[i])
x.append(rx_data[i+1])
self.results[ind].append((int(int.from_bytes(x, byteorder='big', signed=False)>>ind)&1))
def updSet(self):
temp1 = 1
##AA DATA RATE
if (self.comboRate.get() == "Hz"):
temp1 = 1
elif(self.comboRate.get() == "kHz"):
temp1 = 1000
elif(self.comboRate.get() == "MHz"):
temp1 = 1000000
self.AARate = self.coreFrq // (float(self.STB2var.get())*temp1)-1
if (self.AARate > 16777215):
self.AARate = 16777215
elif(self.AARate < 0):
self.AARate = 0
self.sampFrq = self.coreFrq / ((self.AARate+1)*temp1)
self.STB2var.set(str(self.sampFrq))
self.sampFrq = self.coreFrq / (self.AARate+1)
AARateByte = hex(int(self.AARate))
self.AARateStr = str(AARateByte)
self.AARateStr = self.AARateStr[2:]
for ind in range(0,6-len(self.AARateStr)):
self.AARateStr = '0' + self.AARateStr
print("AA(Frq) = %d"%self.AARate)
print(self.AARateStr)
##BB DURATION
if (self.comboDuration.get() == "samp"):
self.BBSamp = float(self.STB1var.get()) // 1
self.STB1var.set(str(int(self.BBSamp)))
else:
if (self.comboDuration.get() == "sec"):
temp1 = 1000000000
elif(self.comboDuration.get() == "msec"):
temp1 = 1000000
elif(self.comboDuration.get() == "usec"):
temp1 = 1000
elif(self.comboDuration.get() == "nsec"):
temp1 = 1
self.BBSamp = (temp1 * float(self.STB1var.get())) // self.coreFrqPeriod
self.BBSamp += 1
if(self.channel_count>0 and self.channel_count<=2):
self.BBSamp = self.BBSamp / 4
print("2")
elif(self.channel_count>2 and self.channel_count<=4):
self.BBSamp = self.BBSamp / 2
print("4")
elif(self.channel_count>8):
self.BBSamp = self.BBSamp * 2
print("16")
if (self.BBSamp > 16777215):
self.BBSamp = 16777215
elif(self.BBSamp < 0):
self.BBSamp = 0
BBSampByte = hex(int(self.BBSamp))
self.BBSampStr = str(BBSampByte)
self.BBSampStr = self.BBSampStr[2:]
for ind in range(0,6-len(self.BBSampStr)): #fill most sign bits with 0
self.BBSampStr = '0' + self.BBSampStr
print("BB(Samp) = %d"%self.BBSamp)
print(self.BBSampStr)
#CC TRIGGER CH
if (self.var1.get() == 1):
if(self.comboTriggerT.get()=="Rising edge"):
CCTrigTStr = '0'
elif(self.comboTriggerT.get()=="Falling edge"):
CCTrigTStr = '1'
elif(self.comboTriggerT.get()=="High"):
CCTrigTStr = '2'
elif(self.comboTriggerT.get()=="Low"):
CCTrigTStr = '3'
else:
CCTrigTStr = 'F'
CCTrigChByte = hex(int(self.comboTriggerCh.get()))
CCTrigChStr = str(CCTrigChByte)
self.CCTrigStr = "0000" + CCTrigTStr + CCTrigChStr[2:]
print("CC(TrigCh) = %d"%int(self.comboTriggerCh.get()))
print(self.CCTrigStr)
#HH TRIGGER POSITION
self.HHTrigPos = int(self.STB31var.get())
if(self.channel_count>0 and self.channel_count<=2):
self.HHTrigPos = self.HHTrigPos // 8
print("2")
elif(self.channel_count>2 and self.channel_count<=4):
self.HHTrigPos = self.HHTrigPos // 4
print("4")
elif(self.channel_count>4 and self.channel_count<=8):
self.HHTrigPos = self.HHTrigPos // 2
print("8")
if (self.HHTrigPos > 64000):
self.HHTrigPos = 64000
elif(self.HHTrigPos < 0):
self.HHTrigPos = 0
HHTrigPosByte = hex(self.HHTrigPos)
self.HHTrigPosStr = str(HHTrigPosByte)
self.HHTrigPosStr = self.HHTrigPosStr[2:]
for ind in range(0,6-len(self.HHTrigPosStr)):
self.HHTrigPosStr = '0' + self.HHTrigPosStr
print("лала(TrigPos) = %d"%self.HHTrigPos)
print(self.HHTrigPosStr)
#DD CH BITMAP
DDMaskByte = hex(self.channelActiveMask)
self.DDMaskStr = str(DDMaskByte)
self.DDMaskStr = self.DDMaskStr[2:]
for i in range(0,6-len(self.DDMaskStr)):
self.DDMaskStr = '0' + self.DDMaskStr
print("DD(Mask) = %d"%self.channelActiveMask)
print(self.DDMaskStr)
#EE VOLTAGE
EEVoltFl = float(self.STB3var.get())
if (EEVoltFl > 5):
self.STB3var.set("5")
if (EEVoltFl > 3.6):
EEVoltFl = 3.6
elif (EEVoltFl < 0.6):
self.STB3var.set("0.6")
EEVoltFl = 0.6
self.EEVolt = (EEVoltFl-0.6) * 65
self.EEVolt = int(255 - self.EEVolt)
EEVoltByte = hex(self.EEVolt)
self.EEVoltStr = str(EEVoltByte)
self.EEVoltStr = "0000" + self.EEVoltStr[2:]
print("EE(Volt) = %d"%self.EEVolt)
print(self.EEVoltStr)
def StartCallBack(self):
self.updSet()
self.ft_init()
self.connect()
self.send()
def FillCallBack(self):
self.decode_frame.pack_forget()
self.channel_frame.pack_forget()
if(self.BFill['text'] == "Fill"):
self.BFill['text'] = "standart view"
self.decode_frame.pack(side="top", fill="both",expand = 1)
self.channel_frame.pack(side="top", fill="both",expand = 1)
else:
self.BFill['text'] = "Fill"
self.decode_frame.pack(side="top", fill="both",expand = 0)
self.channel_frame.pack(side="top", fill="both",expand = 0)
def SortCallBack(self):
self.drawDecodes(self.decode_active_int,1)
self.drawPlots(self.channel_active_int,1,1)
def ComboUpdate(self,event):
self.UpdateDecodeInstances()
def UpdateDecodeInstances(self):
for i in range(0,8):
if(self.dec_instance_state[i] != self.decode_combo[i].get() and self.decode_cb_var[i].get() == 1):
self.dec_instance_state[i] = self.decode_combo[i].get()
if(self.decode_combo[i].get() == "i2c"):
self.decoder_instances[i] = i2c(self.master)
else:
filename = "la_" + self.decode_combo[i].get()
module = importlib.import_module(filename)
class_ = getattr(module, filename[3:])
self.decoder_instances[i] = class_(self.master)
self.decode_buttons[i].configure(command=lambda x=i :self.setDecode(x))
def setDecode(self,ch):
self.decoder_instances[ch].set_decode(self.channel_active_int)
def zoomSliderP(self):
temp = self.w1.get()
temp += 1
self.w1.set(temp)
def zoomSliderM(self):
temp = self.w1.get()
temp -= 1
self.w1.set(temp)
def shiftSliderMM(self):
temp1 = self.index_max/100000
temp2 = int(self.sampOnScreen/temp1)
temp = self.w2.get()
temp -= temp2
self.w2.set(temp)
def shiftSliderM(self):
temp1 = self.index_max/100000
temp2 = int(self.sampOnScreen/temp1/10)
temp = self.w2.get()
temp -= temp2
self.w2.set(temp)
def shiftSliderP(self):
temp1 = self.index_max/100000
temp2 = int(self.sampOnScreen/temp1/10)
temp = self.w2.get()
temp += temp2
self.w2.set(temp)
def shiftSliderPP(self):
temp1 = self.index_max/100000
temp2 = int(self.sampOnScreen/temp1)
temp = self.w2.get()
temp += temp2
self.w2.set(temp)
def disconnectCallBack(self):
self.disconnect()
def sendCallBack(self):
self.send()
def exit_handler(self):
#disconnect() #add checking if connected
self.drawPlots([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],1,0)
self.drawDecodes([0,0,0,0,0,0,0,0],0)
print('Bye! :)')
self.master.destroy()
bd='0',
font=('Timesnewroman', 12),
command=fav)
favorites.place(x=500, y=40)
shopping_cart = Button(text='Корзина',
bg='#0075d5',
fg='#65f208',
bd='0',
font=('Timesnewroman', 12),
command=shop)
shopping_cart.place(x=625, y=40)
city = Combobox(window_2) # Комбобокс
city['values'] = ("Санкт-Петербург", "Москва", "Лондон", "Париж", "Голуби",
"Вверх", "Блики", "Крыш")
city.current(0) # вариант по умолчанию
city.place(x=10, y=2)
# Кнопки top_top
shops = Button(window_2,
text='Магазины',
bg='#00b7ff',
fg='black',
bd='0',
font=("Arial", 12),
command=pressF)
shops.place(x=200)
Buyers = Button(window_2,
text='Покупателям',
bg='#00b7ff',
fg='black',
columnspan=10,
sticky="ew")
graph_chk_state = BooleanVar()
graph_chk_state.set(True)
graph_chk = Checkbutton(window,
var=graph_chk_state,
text="Графики",
font=("Arial", 13))
graph_chk.grid(column=0, row=16)
lbl_interval = Label(window, text="Временной интервал", font=("Arial", 10))
lbl_interval.grid(column=1, row=17)
combo = Combobox(window, state="readonly")
combo['values'] = ('Час', 'День', 'Месяц', 'Год')
combo.current(1)
combo.grid(column=1, row=18)
lbl_graph_keys = Label(window, text="Данные", font=("Arial", 10))
lbl_graph_keys.grid(column=0, row=17)
graph_names = ('Посты', 'Лайки', 'Репосты', 'Комментарии')
graph_checkboxes = {}
for i, name in enumerate(graph_names):
graph_chk_var = BooleanVar()
if name == 'Лайки':
graph_chk_var.set(True)
chk = Checkbutton(window, var=graph_chk_var, text=name)
graph_checkboxes.update({name: graph_chk_var})
chk.grid(column=0, row=18 + i)
lbl_sonuc_cbx = Label(cerceve_sonuc, text="", font=("Consolas", 16))
lbl_sonuc_cbx.grid(row=3, column=0, columnspan=4)
lbl_sonuc_lbx = Label(cerceve_sonuc, text="", font=("Consolas", 16))
lbl_sonuc_lbx.grid(row=4, column=0, columnspan=4)
lbl_sonuc_radio = Label(cerceve_sonuc, text="", font=("Consolas", 16))
lbl_sonuc_radio.grid(row=5, column=0, columnspan=4)
# ALT SONUÇ BÖLÜMÜ SONU
# ComboBox Başı
liste = ["İstanbul", "Ankara", "İzmir", "Kayseri", "Sivas"]
cbx = Combobox(pencere, values=liste)
cbx.current(4) # Sivas seçili
cbx.grid(row=3, column=0)
# ComboBox Sonu
# Listbox Başı
liste2 = ["Gaziantep", "Şanlıurfa", "Mardin", "Diyarbakır"]
lbx = Listbox(pencere, height=5, selectmode="multiple")
for eleman in liste2:
lbx.insert(END, eleman)
"""
lbx.insert(END,"Gaziantep")
lbx.insert(END,"Şanlıurfa")
lbx.insert(END,"Mardin")
lbx.insert(END,"Diyarbakır")
class Janela:
def __init__(self, master):
self.dimensions = ['600', '650']
self.translator = Translator()
self.master = master
self.master.title('Tooggle Translator')
self.master.geometry('x'.join(self.dimensions)+'+300+10')
self.master.resizable(0, 0)
self.container = Frame(self.master, bg='#f3f3f3', width=self.dimensions[0], height=self.dimensions[1])
self.container.pack()
self.container.pack_propagate(0)
self.tudo = Frame(self.container, bg='#fff')
self.tudo.pack()
self.header = Frame(self.tudo, width=self.dimensions[0], height=50, bg='#5094ff')
self.header.pack()
self.header.pack_propagate(0)
self.f_langs = Frame(self.tudo, bg='#fff')
self.f_langs.pack(pady=10)
self.div_1 = Frame(self.tudo, bg='#cbcccb', width=self.dimensions[0], height=2)
self.div_1.pack()
self.f_texto = Frame(self.tudo, bg='#fff')
self.f_texto.pack(pady=20)
self.div_2 = Frame(self.tudo, bg='#cbcccb', width=self.dimensions[0], height=2)
self.div_2.pack()
self.f_transl_text = Frame(self.container, bg='#5094ff', width=575, height=260, highlightthickness=1,
highlightbackground='#2379ff')
self.f_transl_text.pack(pady=12)
self.f_transl_text.pack_propagate(0)
self.f_transl_text_inner = Frame(self.f_transl_text, bg='#5094ff')
self.f_transl_text_inner.pack(pady=12)
# WIDGETS ----------------------------------------------------
self.logo = Label(self.header, text='Tooggle Translator', fg='#fff', bg='#5094ff', font=('Lucida Sans Typewriter', '17'))
self.logo.pack(anchor=W, pady=10, padx=40)
self.langs_0 = Combobox(self.f_langs, values=LANGUAGES, font=('Calibri', '15'),
foreground='#5597ff', width=10, justify=CENTER)
self.langs_0.grid(row=0, column=0)
self.langs_0.current(13) # Portuguese
self.langs_0.bind('<<ComboboxSelected>>', self.translate)
self.langs_1 = Combobox(self.f_langs, values=LANGUAGES, font=('Calibri', '15'),
foreground='#5597ff', width=10, justify=CENTER)
self.langs_1.grid(row=0, column=2)
self.langs_1.current(4) # English
self.langs_1.bind('<<ComboboxSelected>>', self.translate)
self.inverter_langs = Label(self.f_langs, text='⇄', font='Helvetica 20 bold', fg='#5597ff', bg='#fff')
self.inverter_langs.grid(row=0, column=1, padx=70)
self.inverter_langs.bind('<ButtonRelease-1>', self.inverter)
self.entry = Text(self.f_texto, width=43, height=6, font='Helvetica 17', relief=FLAT,
fg='#515150') #width=36
self.entry.bind('<Escape>', self.translate)
self.entry.insert('end', 'Olá, Rogério...\nTudo bom?')
self.entry.pack()
self.transl_text = Text(self.f_transl_text_inner, font='Helvetica 15', bg='#5094ff', fg='#fff', relief=FLAT,
width=50, height=8, state=DISABLED, cursor='right_ptr')
self.transl_text.pack()
self.copy_img = PhotoImage(file='copy_img.png')
self.copy_button = Label(self.f_transl_text_inner, bg='#5094ff', image=self.copy_img, cursor='right_ptr')
self.copy_button.pack(pady=2, anchor=E, padx=20)
self.copy_button.bind('<ButtonRelease-1>', lambda x: clip_copy(self.transl_text.get('1.0', END)))
def inverter(self, event):
l_0 = self.entry.get('1.0', END)
l_1 = self.transl_text.get('1.0', END)
l_0_index = self.langs_0.current()
l_1_index = self.langs_1.current()
self.transl_text['state'] = NORMAL
self.entry.delete('1.0', END)
self.transl_text.delete('1.0', END)
self.entry.insert('end', l_1)
self.transl_text.insert('end', l_0)
self.transl_text['state'] = DISABLED
self.langs_0.current(l_1_index)
self.langs_1.current(l_0_index)
def translate(self, event):
texto = self.entry.get('1.0', END)
lingua_0 = languages_index.get(self.langs_0.get())
lingua_1 = languages_index.get(self.langs_1.get())
print(self.langs_1.current())
traduzido = self.translator.translate(text=texto, src=lingua_0, dest=lingua_1).text
self.transl_text['state'] = NORMAL
self.transl_text.delete('1.0', END)
self.transl_text.insert('end', traduzido)
self.transl_text['state'] = DISABLED
class Example(tk.Toplevel):
def __init__(self, master = None):
super().__init__(master = master)
self.init_UI()
def init_UI(self):
self.title("Информация о книге")
self.protocol("WM_DELETE_WINDOW", self.on_closing)
self.img = ImageTk.PhotoImage(Image.open(os.getcwd()+"/images/No_image.png"))
self.Book = tk.Label(
self,
text="Произошла ошибка при попытке получить информацию о книге.",
font=("Times New Roman",20)
)
self.Author = tk.Label(
self,
font=("Times New Roman",15)
)
self.Genre = tk.Label(
self,
font=("Times New Roman",12)
)
self.Series = tk.Label(
self,
font=("Times New Roman",12)
)
self.Grade = tk.Label(
self,
font=("Times New Roman",12)
)
self.Read = tk.Label(
self,
font=("Times New Roman",12),
text="Читать",
fg="blue",
cursor="hand2"
)
self.Text = tk.Label(
self,
font=("Times New Roman",16),
text="Аннотация:"
)
self.Annotation = tk.Text(
self,
font=("Times New Roman",12),
height=13,
width=100,
wrap=tk.WORD
)
self.Download = Combobox(
self,
state='readonly'
)
self.Library = Combobox(
self,
state='readonly'
)
self.panel = tk.Label(
self,
image=self.img,
background="white",
height=300,
width=200
)
self.Download.set('Скачать в формате')
self.Download.bind("<<ComboboxSelected>>", self.download_book)
self.Library.set('Добавить в библиотеку')
self.Library.bind("<<ComboboxSelected>>", self.add_in_library)
self.Read.bind("<Button-1>", self.read_book)
self.panel.grid(column = 0, row = 0, rowspan=5, padx = 2)
self.Book.grid(column = 1, row = 0, columnspan=4, padx = 5)
self.Author.grid(column = 1, row = 1, columnspan=4, padx = 5)
self.Genre.grid(column = 1, row = 2, columnspan=4, padx = 5)
self.Series.grid(column = 1, row = 3, padx = 5)
self.Read.grid(column = 2, row = 3, padx = 5)
self.Download.grid(column = 3, row = 3, padx = 5)
self.Library.grid(column = 4, row = 3, padx = 5)
self.Grade.grid(column = 1, row = 4, columnspan=4)
self.Text.grid(sticky=tk.W, column = 0, row = 5, padx = 5, pady = 7)
self.Annotation.grid(sticky=tk.E+tk.W+tk.S, column = 0, row = 6, columnspan=5, padx = 3, pady = 3)
def parse(self, url):
self.book_url = url
loaded = True
try:
htmldata = requests.get(url)
except Exception as e:
#!Error=str(e)
loaded = False
if loaded:
soup = BeautifulSoup(htmldata.content,'lxml')
image_data = soup.find('img',{'alt': 'Cover image'})
if image_data != None:
img_url = "http://flibusta.is" + image_data['src']
try:
if ImageTk.PhotoImage(Image.open(BytesIO(requests.get(img_url).content))).__sizeof__() > 0:
self.img_data = requests.get(img_url).content
self.img = ImageTk.PhotoImage(Image.open(BytesIO(self.img_data)).resize((200,300)))
self.panel.config(image = self.img)
except Exception as e:
#!Error=str(e)
loaded = False
self.Book['text'] = ' '.join(re.sub(r'\([^()]*\)', '', soup.find('h1',{'class': 'title'}).text).split())
self.Author['text'] = "Автор: Автор не указан"
for i in soup.find('div', {'class': 'clear-block', 'id': 'main'}).select('div > a'):
if str(i['href']).find('/a/') != -1:
self.Author['text'] = "Автор: " + i.text
break
self.Genre['text'] = "Жанры: " + soup.find('p',{'class': 'genre'}).text
if re.sub(r'\([^()]*\)', '', soup.find('p',{'class': 'genre'}).parent.select_one('div > a').text) != "":
self.Series['text'] = "Серия книг: " + soup.find('p',{'class': 'genre'}).parent.select_one('div > a').text
else:
self.Series['text'] = "Серия книг: Не входит в серию книг"
self.Grade['text'] = soup.find('div',{'id': 'newann'}).find('p').text
if soup.select_one('div.clear-block > p') != None:
self.Annotation.insert(tk.END, str(soup.select_one('div.clear-block > p').text))
self.Annotation.configure(state="disabled")
download_variants_bool = False
download_variants = []
for i in soup.find('p',{'class': 'genre'}).parent.select('div > a'):
if i.text == "(читать)":
download_variants_bool = True
continue
if download_variants_bool or (re.sub(r'\([^()]*\)', '', i.text) == "" and i.text != "(читать)"):
download_variants.append(i.text.replace("(","").replace(")","").replace("скачать ",""))
self.Download['values'] = download_variants
conn = sqlite3.connect('./database/books.sqlite')
c = conn.cursor()
c.execute("SELECT [Type name] FROM [Library types]")
data = c.fetchall()
self.Library['values'] = [i[0] for i in data]
c.execute("SELECT Type FROM [Library] WHERE url = ?", (self.book_url,))
result = c.fetchone()
if result is not None:
self.Library.current(int(result[0])-1)
conn.close()
def read_book(self, event):
app = source.OpenBook.main(url = self.book_url, master = self.master)
app.bind("<<Close>>", self.on_close_app, '+')
self.withdraw()
def download_book(self, event):
source.DownloadFile.DownloadStart(self.book_url, self.Book['text'], event.widget.get())
def on_closing(self):
self.event_generate("<<Close>>")
self.destroy()
def on_close_app(self, event):
self.deiconify()
def add_in_library(self, event):
conn = sqlite3.connect('./database/books.sqlite')
c = conn.cursor()
c.execute("SELECT rowid FROM [Library] WHERE url = ?", (self.book_url,))
result = c.fetchone()
if result != None:
c.execute("SELECT rowid FROM [Library types] WHERE [Type name] = ?", (event.widget.get(),))
data = (c.fetchone()[0], result[0])
c.execute("UPDATE [Library] SET Type = ? WHERE rowid = ?", data)
else:
c.execute("SELECT rowid FROM [Library types] WHERE [Type name] = ?", (event.widget.get(),))
data = (self.img_data, self.book_url, self.Book['text'], self.Author['text'], self.Genre['text'], self.Series['text'], self.Grade['text'], str(self.Annotation.get("1.0", tk.END)), ", ".join(self.Download['values']), c.fetchone()[0])
c.execute("INSERT INTO [Library] VALUES(?,?,?,?,?,?,?,?,?,?)", data)
conn.commit()
conn.close()
class CadGui(object):
def __init__(self,root):
self.root = root
root.title("APOS CAD")
self.xy1 = StringVar()
self.mode = StringVar()
self.IdEntry = StringVar()
self.XEntry = StringVar()
self.XEntry.trace('w',self.numbers_val)
self.YEntry = StringVar()
self.YEntry.trace('w',self.numbers_val)
self.ZEntry = StringVar()
self.ZEntry.trace('w',self.numbers_val)
self.CodeEntry = StringVar()
self.WidthHeight = [800,500]
self.filevar = StringVar() # Filebox
self.openfiles = [data.data[0][1]]
self.colorvar = StringVar() #Colorbox
self.colors = ["Red","Green","Blue","Cyan","Magenta","Yellow","Black","khaki","Orange"]
self.scroll = IntVar() # Scaltefactor
self.scroll.set(1)
self.wheel = IntVar() # Wheel
self.wheel.set(1)
self.savedyx = [0,0] # Last canvas xy for calc
self.modyx = [self.WidthHeight[1],0] # Moved origo
self.modyxset = [0,0] # moved origo hold
self.Map_XY = [0,0] # Crosshairs place on map
self.xy1 = StringVar()
self.mode = StringVar()
self.keyes_w = [0,0]
self.keyes = ["nn"]
self.snapp = ["so"]
self.snapp_xy = [0,0,0]
self.new = [0]
def passit():
pass
self.menubar = Menu(root)
self.filemenu = Menu(self.menubar, tearoff=0)
self.filemenu.add_command(label="New", command= self.newfile)
self.filemenu.add_command(label="Open", command= self.openfile)
self.filemenu.add_command(label="Save", command= self.save)
self.filemenu.add_command(label="Save as...", command= self.saveas)
self.filemenu.add_command(label="Close", command= self.close)
self.filemenu.add_separator()
self.filemenu.add_command(label="Exit", command=self.root.quit)
self.menubar.add_cascade(label="File", menu=self.filemenu)
self.editmenu = Menu(self.menubar, tearoff=0)
self.editmenu.add_command(label="Undo", command=passit())
self.editmenu.add_separator()
self.editmenu.add_command(label="Cut", command=passit())
self.editmenu.add_command(label="Copy", command=passit())
self.editmenu.add_command(label="Paste", command=passit())
self.editmenu.add_command(label="Delete", command=passit())
self.editmenu.add_command(label="Select All", command=passit())
self.menubar.add_cascade(label="Edit", menu=self.editmenu)
self.drawmenu = Menu(self.menubar, tearoff=0)
self.drawmenu.add_command(label="Point D>P", command=functools.partial(self.keypressed,event='<tkinter.Event object>', char1=['d','p']))
self.drawmenu.add_command(label="Line D>L", command=functools.partial(self.keypressed,event='<tkinter.Event object>', char1=['d','l']))
self.drawmenu.add_separator()
self.drawmenu.add_command(label="ARC_3p A>3", command=functools.partial(self.keypressed,event='<tkinter.Event object>', char1=['a','3']))
self.menubar.add_cascade(label="Draw", menu=self.drawmenu)
self.snappmenu = Menu(self.menubar, tearoff=0)
self.snappmenu.add_command(label="Point S>P", command=functools.partial(self.keypressed,event='<tkinter.Event object>', char1=['s','p']))
self.snappmenu.add_command(label="NoSnapp S>O", command=functools.partial(self.keypressed,event='<tkinter.Event object>', char1=['s','o']))
self.menubar.add_cascade(label="Snapp", menu=self.snappmenu)
self.helpmenu = Menu(self.menubar, tearoff=0)
self.helpmenu.add_command(label="Help", command=passit())
self.helpmenu.add_command(label="About...", command=passit())
self.menubar.add_cascade(label="Help", menu=self.helpmenu)
self.root.config(menu=self.menubar)
self.filebox = Combobox(root, textvariable=self.filevar, values=self.openfiles, state='readonly')
self.filebox.current(0)
self.colorbox = Combobox(root, textvariable=self.colorvar, values=self.colors, state='readonly')
self.colorbox.current(data.data[0][0])
self.draw = Canvas(root, cursor="none", width=self.WidthHeight[0], height=self.WidthHeight[1])
self.label1 = Label(root, textvariable = self.mode, bg="white", fg="black")
self.label2 = Label(root, textvariable = self.xy1, bg="white", fg="black")
self.label3 = Label(root, textvariable = self.scroll, bg="white", fg="black")
self.label4 = Label(root, text = "Tools", bg="white", fg="black")
self.xyzgroup = LabelFrame(root, text="Insert", padx=5, pady=5,width=100,height=self.WidthHeight[1])
self.ID = Label(self.xyzgroup,text="Id:")
self.IdE = Entry(self.xyzgroup, textvariable = self.IdEntry)
self.XT = Label(self.xyzgroup,text="X:")
self.XE = Entry(self.xyzgroup, textvariable = self.XEntry)
self.YT = Label(self.xyzgroup,text="Y:")
self.YE = Entry(self.xyzgroup, textvariable = self.YEntry)
self.ZT = Label(self.xyzgroup,text="Z:")
self.ZE = Entry(self.xyzgroup, textvariable = self.ZEntry)
self.CT = Label(self.xyzgroup,text="Code:")
self.CE = Entry(self.xyzgroup, textvariable = self.CodeEntry)
self.ok = Button(self.xyzgroup, text='Add', command = self.OkRespons)
self.draw.bind("<Motion>",functools.partial(self.motion, WidthHeight=self.WidthHeight, moving = 0))
self.draw.bind("<Button-1>", self.MouseRespons )
self.draw.bind_all("<KeyPress>", functools.partial(self.keypressed, char1='none'))
# Scrollwheel
self.draw.bind("<MouseWheel>", functools.partial(self.motion, WidthHeight=self.WidthHeight, moving = 2)) #win/osx
self.draw.bind("<Button-4>", functools.partial(self.motion, WidthHeight=self.WidthHeight, moving = 2)) #linux
self.draw.bind("<Button-5>", functools.partial(self.motion, WidthHeight=self.WidthHeight, moving = 2)) #linux
# middlebutton + move
self.draw.bind("<B2-Motion>",functools.partial(self.motion, WidthHeight=self.WidthHeight, moving=1))
self.filebox.bind("<<ComboboxSelected>>", lambda f: self.colorbox.current(data.data[self.filebox.current()][0]))
self.colorbox.bind("<<ComboboxSelected>>", lambda c: data.change_color(self.filebox.current(),self.colorbox.current()))
self.filebox.grid(row=0, rowspan = 1, column=2, columnspan=1, sticky=W+E)
self.colorbox.grid(row=0, rowspan = 1, column=3, columnspan=1, sticky=W+E)
self.draw.grid(row=1,column=2, columnspan=9, sticky=W+E)
self.xyzgroup.grid(row=1, column=0, columnspan=2, sticky=W+E+N)
self.ID.grid(row=0, rowspan = 1,column=0, columnspan=1)
self.IdE.grid(row=0, rowspan = 1,column=1, columnspan=1)
self.XT.grid(row=1, rowspan = 1,column=0, columnspan=1)
self.XE.grid(row=1, rowspan = 1,column=1, columnspan=1)
self.YT.grid(row=2, rowspan = 1,column=0, columnspan=1)
self.YE.grid(row=2, rowspan = 1,column=1, columnspan=1)
self.ZT.grid(row=3, rowspan = 1,column=0, columnspan=1)
self.ZE.grid(row=3, rowspan = 1,column=1, columnspan=1)
self.CT.grid(row=4, rowspan = 1,column=0, columnspan=1)
self.CE.grid(row=4, rowspan = 1,column=1, columnspan=1)
self.ok.grid(row=5, rowspan = 1,column=1, columnspan=1)
self.label4.grid(row=0, rowspan = 1, column=0, columnspan=2, sticky=W+E)
self.label1.grid(row=2, rowspan = 1, column=2, columnspan=1, sticky=W+E)
self.label2.grid(row=2, rowspan = 1, column=3, columnspan=1, sticky=W+E)
self.label3.grid(row=2, rowspan = 1, column=4, columnspan=1, sticky=W+E)
self.root.resizable(0,0)
self.draw.focus_set()
def newfile(self):
data.new_file()
self.openfiles.append(data.data[-1][1])
self.filebox['values'] = self.openfiles
def save(self):
currentfile = self.filebox.current()
if len(data.data[currentfile][2]) > 0:
data.save_file(currentfile,data.data[currentfile][2])
else:
print('nono')
def saveas(self):
currentfile = self.filebox.current()
data.save_file(currentfile,filedialog.asksaveasfilename(defaultextension=".cad"))
self.openfiles[currentfile] = data.data[currentfile][1]
self.filebox['values'] = self.openfiles
self.filebox.current(currentfile)
print(currentfile)
print(data.data)
def openfile(self):
data.open_file(filedialog.askopenfilename())
self.openfiles.append(data.data[-1][1])
self.filebox['values'] = self.openfiles
print(data.data)
def close(self):
currentfile = self.filebox.current()
data.close_file(currentfile)
self.openfiles.pop(currentfile)
self.filebox['values'] = self.openfiles
self.filebox.current(0)
print(data.data)
def keypressed(self,event,char1): # Short commands
print(event)
if char1 == 'none':
chars = [event.char]
else:
chars = char1
command_sel = {
"nn": "none", "nn": "none",
"d" : "Draw:","dp": "Draw: Point", "dl" : "Draw: Line",
"a" : "Arc:", "a3" : "Arc: 3point",
"s" : "Snapp:", "sp": "Snapp: Point", "so":"Snapp: Off"
}
for char in chars:
if char == chr(27):
self.draw.focus_set()
self.mode.set("")
del self.keyes_w[:]
del self.keyes[:]
del self.snapp[:]
self.keyes_w.append(0)
self.keyes_w.append(0)
self.keyes.append("nn")
self.snapp.append("so")
self.new[0] = 1
else:
if self.draw.focus_get()== self.draw:
if len(self.keyes_w) == 2 :
if char == "n": # flag for new object
self.new[0] = 1
elif char not in command_sel:
print("not in dict")
else:
del self.keyes_w[:]
self.keyes_w.append(char)
elif len(self.keyes_w) == 1:
self.keyes_w.append(char)
if self.keyes_w[0]+self.keyes_w[1] not in command_sel:
print("not in dict")
self.keyes_w.pop()
print(self.keyes_w)
if len(self.keyes_w) == 2 and self.keyes_w[0] != "s" :
del self.keyes[:]
self.keyes.append(self.keyes_w[0]+self.keyes_w[1])
if len(self.keyes_w) == 2 and self.keyes_w[0] == "s" :
del self.snapp[:]
self.snapp.append(self.keyes_w[0]+self.keyes_w[1])
# Show active mode
if len(self.keyes_w) == 1:
if self.keyes_w[0] == "s":
self.mode.set(command_sel[self.keyes[0]]+">>"+command_sel[self.keyes_w[0]])
else:
self.mode.set(command_sel[self.keyes_w[0]]+">>"+command_sel[self.snapp[0]])
if len(self.keyes_w) == 2:
self.mode.set(command_sel[self.keyes[0]]+">>"+command_sel[self.snapp[0]])
return
def MouseRespons(self,event):
if self.snapp[0] != 'so' and len(data.data[self.filebox.current()][3][0]) == 0:
pass
else:
data.paint(self.IdE.get(),int(self.Map_XY[0]),int(self.Map_XY[1]),0, self.CE.get(), self.keyes, self.snapp, self.new, self.filebox.current())
self.new[0] = 0
def OkRespons(self):
if len(self.XE.get()) > 0 and len(self.YE.get()) > 0 and len(self.ZE.get()) > 0:
data.paint(self.IdE.get(),int(float(self.XE.get())*1000),int(float(self.YE.get())*1000),int(float(self.ZE.get())*1000), self.CE.get(), self.keyes, self.snapp, self.new, self.filebox.current())
self.new[0] = 0
def numbers_val(self, *args):
XE = self.XEntry.get()
YE = self.YEntry.get()
ZE = self.ZEntry.get()
XEN = [""]
YEN = [""]
ZEN = [""]
Xdott = False
Ydott = False
Zdott = False
numbers = '0123456789.,'
for char in XE:
if char in numbers:
if char == '.' or char == ',':
if Xdott == True:
pass
elif char == ',':
XEN[0] += '.'
Xdott = True
else:
XEN[0] += '.'
Xdott = True
else:
XEN[0] += char
for char in YE:
if char in numbers:
if char == '.' or char == ',':
if Ydott == True:
pass
elif char == ',':
YEN[0] += '.'
Ydott = True
else:
YEN[0] += '.'
Ydott = True
else:
YEN[0] += char
for char in ZE:
if char in numbers:
if char == '.' or char == ',':
if Zdott == True:
pass
elif char == ',':
ZEN[0] += '.'
Zdott = True
else:
ZEN[0] += '.'
Zdott = True
else:
ZEN[0] += char
self.XEntry.set(XEN[0])
self.YEntry.set(YEN[0])
self.ZEntry.set(ZEN[0])
def motion(self,event,WidthHeight, moving): # mouse event responsese and draw the canvas
# Catching events
Canvas_YX = [event.y , event.x]
# Respons to Linux/Windows wheel event
if moving == 2: # CHECK !!!
if event.num == 5 or event.delta == -120: # CHECK !!!
if self.wheel.get() > 1:
self.wheel.set(self.wheel.get() - 1)
self.scroll.set(self.wheel.get()*self.wheel.get())
self.modyx[0] += Canvas_YX[0]/(1/self.scroll.get())-Canvas_YX[0]/(1/((self.wheel.get()+1)*(self.wheel.get()+1)))
self.modyx[1] += Canvas_YX[1]/(1/self.scroll.get())-Canvas_YX[1]/(1/((self.wheel.get()+1)*(self.wheel.get()+1)))
if event.num == 4 or event.delta == 120: # CHECK !!!!
self.wheel.set(self.wheel.get() + 1)
self.scroll.set(self.wheel.get()*self.wheel.get())
self.modyx[0] += Canvas_YX[0]/(1/self.scroll.get())-Canvas_YX[0]/(1/((self.wheel.get()-1)*(self.wheel.get()-1)))
self.modyx[1] += Canvas_YX[1]/(1/self.scroll.get())-Canvas_YX[1]/(1/((self.wheel.get()-1)*(self.wheel.get()-1)))
# Respons to B2-Motion CHECK!
if moving == 0:
self.savedyx[0] = Canvas_YX[0]
self.savedyx[1] = Canvas_YX[1]
if self.modyxset[:] != self.modyx[:]:
self.modyxset[:] = self.modyx[:]
if moving == 1:
self.modyx[0]= self.modyxset[0] + (Canvas_YX[0] - self.savedyx[0]) / (1/self.scroll.get())
self.modyx[1]= self.modyxset[1] + (Canvas_YX[1] - self.savedyx[1]) / (1/self.scroll.get())
# Map coord CHECK!
self.Map_XY[1] = -self.modyx[1] - ((Canvas_YX[1] * -1) / (1/self.scroll.get()))
self.Map_XY[0] = self.modyx[0] - (Canvas_YX[0] / (1/self.scroll.get()))
# Transalte operation CHECK!
def modifying_XtoY(value):
scroll = self.scroll.get()
y = 0
y = Canvas_YX[0] - ((value - self.Map_XY[0])*1/scroll)
return y
def modifying_YtoX(value):
scroll = self.scroll.get()
x = 0
x = Canvas_YX[1] + ((value - self.Map_XY[1])*1/scroll)
return x
def zoomit(value):
return (value / (1/self.scroll.get()))
def findOjectNear():
pass
# Draws the shit.
self.draw.delete(ALL) # Clear the canvas
self.xy1.set("N = %0.3fm E = %0.3fm " % (float(self.Map_XY[0])/1000,float(self.Map_XY[1])/1000))
self.draw.create_rectangle(0, 0, WidthHeight[0], WidthHeight[1], fill="white")
# Origo_lines
self.draw.create_line(modifying_YtoX(0),modifying_XtoY(-10),modifying_YtoX(0),modifying_XtoY(zoomit(Canvas_YX[0])+ self.Map_XY[0]), fill="black", dash=(4,4))
self.draw.create_line(modifying_YtoX(-10),modifying_XtoY(0),modifying_YtoX(zoomit(WidthHeight[0]-Canvas_YX[1])+ self.Map_XY[1]),modifying_XtoY(0), fill="black",dash=(4,4))
# Arcfunction used in "DrawIt()"
def tk_arc_calculate(arc1):
oxy = []
angels = []
r1 = []
coord = []
check = []
try:
oxy.append((((arc1[3]**2-arc1[1]**2+arc1[2]**2-arc1[0]**2)/(2*(arc1[2]-arc1[0])))-((arc1[5]**2-arc1[3]**2+arc1[4]**2-arc1[2]**2)/(2*(arc1[4]-arc1[2]))))
/(((arc1[3]-arc1[5])/(arc1[4]-arc1[2]))-((arc1[1]-arc1[3])/(arc1[2]-arc1[0]))))
oxy.append((oxy[0]*((arc1[1]-arc1[3])/(arc1[2]-arc1[0])))+((arc1[3]**2-arc1[1]**2+arc1[2]**2-arc1[0]**2)/(2*(arc1[2]-arc1[0]))))
except ZeroDivisionError:
oxy.append((arc1[1]+arc1[5])/2)
oxy.append((arc1[0]+arc1[4])/2)
oxy.reverse()
r1.append(math.sqrt((arc1[1]-oxy[1])**2+(arc1[0]-oxy[0])**2)) # Radius
angels.append((math.atan((arc1[1]-oxy[1])/(arc1[0]-oxy[0]))*57.29577951)) #Degrees point
angels.append((math.atan((arc1[5]-oxy[1])/(arc1[4]-oxy[0]))*57.29577951)) #Degrees point
check.append((math.atan((arc1[3]-oxy[1])/(arc1[2]-oxy[0]))*57.29577951)) #Degrees point
# Point one
if (arc1[0]-oxy[0]) < 0:
angels[0] = angels[0] + 180
if (arc1[0]-oxy[0]) > 0 and (arc1[1]-oxy[1]) < 0:
angels[0] = angels[0] + 360
# Point two
if (arc1[4]-oxy[0]) < 0:
angels[1] = angels[1] + 180
if (arc1[4]-oxy[0]) > 0 and (arc1[5]-oxy[1]) < 0:
angels[1] = angels[1] + 360
# Check point
if (arc1[2]-oxy[0]) < 0:
check[0] = check[0] + 180
if (arc1[2]-oxy[0]) > 0 and (arc1[3]-oxy[1]) < 0:
check[0] = check[0] + 360
if angels[0] > angels[1]:
angels.reverse()
if check[0] < angels[0] or check[0] > angels[1]:
#print("Wrong")
angels[0] = 360 - angels[0]
angels[1] = 360 + (360 - angels[1] - angels[0])
#print(angels)
else:
angels[0] = 360 - angels[0]
angels[1] = 360 - angels[1] - angels[0]
if angels[1] > 0:
angels[1] *= -1
# Now wee got a raidus, two angels and a center point.
coord = [oxy[0] - r1[0],oxy[1] + r1[0],oxy[0] + r1[0], oxy[1] - r1[0]]
return [coord, angels,r1,oxy]
# Arcfunction for large radius
def Arc_as_line(center_x,center_y,radius,start,extent):
points = []
slices = int(radius) * 2
if extent < 0:
start,extent = extent + start,start
elif extent > 0:
extent += start
if extent > 360:
extent -= 360
start,extent = 360 - extent,360 - start
currentAngle = start * (math.pi*2)/360 # startAngle in radians
endAngle = extent * (math.pi*2)/360 # endAngle in radians
def findxy(center_x,center_y,radius,currentAngle,endAngle,slices):
for i in range(slices):
px = center_x + radius * math.cos(currentAngle)
py = center_y + radius * math.sin(currentAngle)
points.append((int(px), int(py)))
currentAngle += ((math.pi*2)/slices)
if currentAngle >= endAngle:
px = center_x + radius * math.cos(endAngle)
py = center_y + radius * math.sin(endAngle)
points.append((int(px), int(py)))
break
if currentAngle >= endAngle:
findxy(center_x,center_y,radius,currentAngle,math.pi*2,slices)
findxy(center_x,center_y,radius,0,endAngle,slices)
else:
findxy(center_x,center_y,radius,currentAngle,endAngle,slices)
return points
# Draw everything
for file in range(len(data.data)):
current = self.filebox.current()
def DrawIt():
index = len(data.data[file][3][5])
linexy = [] # For linedraw
arc1 = []
tk_arc = []
for x,y,thetype in zip(data.data[file][3][1],data.data[file][3][2],data.data[file][3][5]):
# Draw points
if thetype == "dp":
self.draw.create_oval(modifying_YtoX(y) - 2 , modifying_XtoY(x) - 2 , modifying_YtoX(y) + 2, modifying_XtoY(x) + 2, fill=self.colors[data.data[file][0]])
# Draw lines
if thetype == "dl":
linexy.append(modifying_YtoX(y))
linexy.append(modifying_XtoY(x))
elif thetype == "/dl":
linexy.append(modifying_YtoX(y))
linexy.append(modifying_XtoY(x))
self.draw.create_line(linexy,fill=self.colors[data.data[file][0]])
del linexy
linexy = []
# Draw arcs
if thetype == "a3":
arc1.append(modifying_YtoX(y))
arc1.append(modifying_XtoY(x))
elif thetype == "/a3":
arc1.append(modifying_YtoX(y))
arc1.append(modifying_XtoY(x))
tk_arc = tk_arc_calculate(arc1)
#self.draw.create_arc(tk_arc[0],start=tk_arc[1][0],extent=tk_arc[1][1], style="arc", outline=self.colors[data.data[file][0]])
if tk_arc[2][0] > 1:
arcline = Arc_as_line(tk_arc[3][0],tk_arc[3][1],tk_arc[2][0],tk_arc[1][0],tk_arc[1][1])
self.draw.create_line(arcline,fill=self.colors[data.data[file][0]])
arcline = []
tk_arc = []
arc1 = []
# If only one linepoint paint dott
if index > 0:
if data.data[file][3][5][index - 1] == "dl":
self.draw.create_oval(modifying_YtoX(y) - 2 , modifying_XtoY(x) - 2 , modifying_YtoX(y) + 2, modifying_XtoY(x) + 2, fill=self.colors[data.data[file][0]])
# Draw last linepoint to cross
if file == current:
if index >= 1:
if self.keyes[0] == "dl" and self.new[0] == 0 and data.data[file][3][5][index - 1] == "/dl" or data.data[file][3][5][index - 1] == "dl":
linexy.append(modifying_YtoX(data.data[file][3][2][index - 1]))
linexy.append(modifying_XtoY(data.data[file][3][1][index - 1]))
linexy.append(Canvas_YX[1])
linexy.append(Canvas_YX[0])
self.draw.create_line(linexy,fill=self.colors[data.data[file][0]])
# Draw arc as you paint
if len(data.arc) == 6 and self.Map_XY[0] != data.arc[0] and self.Map_XY[1] != data.arc[1] and self.Map_XY[0] != data.arc[3] and self.Map_XY[1] != data.arc[4] and (
data.arc[0]*(data.arc[4]-self.Map_XY[1])
+ data.arc[3]*(self.Map_XY[1]-data.arc[1])
+ self.Map_XY[0]*(data.arc[1]-data.arc[4])
) != 0:
tk_arc = tk_arc_calculate([modifying_YtoX(data.arc[1]),modifying_XtoY(data.arc[0]),
modifying_YtoX(data.arc[4]),modifying_XtoY(data.arc[3]),
modifying_YtoX(self.Map_XY[1]),modifying_XtoY(self.Map_XY[0])])
#self.draw.create_arc(tk_arc[0],start=tk_arc[1][0],extent=tk_arc[1][1], style="arc", outline=self.colors[data.data[file][0]])
if tk_arc[2][0] > 1:
arcline = Arc_as_line(tk_arc[3][0],tk_arc[3][1],tk_arc[2][0],tk_arc[1][0],tk_arc[1][1])
self.draw.create_line(arcline,fill=self.colors[data.data[file][0]])
print(len(arcline))
arcline = []
# Crosshair
self.draw.create_line(Canvas_YX[1], 0, Canvas_YX[1], WidthHeight[1], fill="black")
self.draw.create_line(0, Canvas_YX[0], WidthHeight[0], Canvas_YX[0], fill="black")
self.draw.create_rectangle(Canvas_YX[1] - 10,Canvas_YX[0] - 10,Canvas_YX[1] + 10 ,Canvas_YX[0] + 10, outline="black")
DrawIt()
# Show snapp point
if self.snapp[0] == "sp" and len(data.data[self.filebox.current()][3][1]) > 0:
maxl = 0
minl = 0
for xy in range(len(data.data[self.filebox.current()][3][1])):
l = math.sqrt((self.Map_XY[0] - data.data[self.filebox.current()][3][1][xy])**2+(self.Map_XY[1] - data.data[self.filebox.current()][3][2][xy])**2)
if l > minl:
maxl = l
minl = maxl
for xyz in range(len(data.data[self.filebox.current()][3][1])):
l = math.sqrt((self.Map_XY[0] - data.data[self.filebox.current()][3][1][xyz])**2+(self.Map_XY[1] - data.data[self.filebox.current()][3][2][xyz])**2)
if l <= minl:
minl = l
del self.snapp_xy[:]
self.snapp_xy.append(data.data[self.filebox.current()][3][1][xyz])
self.snapp_xy.append(data.data[self.filebox.current()][3][2][xyz])
self.snapp_xy.append(data.data[self.filebox.current()][3][3][xyz])
self.draw.create_rectangle(modifying_YtoX(self.snapp_xy[1]) - 5,modifying_XtoY(self.snapp_xy[0]) - 5,modifying_YtoX(self.snapp_xy[1]) + 5 ,modifying_XtoY(self.snapp_xy[0]) + 5, width=2, outline="black")
eDto = Entry(framePropiedad, bg="#e0f2f1", fg="#000000")
eDto.grid(column=7, row=1, padx=5, pady=15)
eDto.config(width=2)
lCdad = Label(framePropiedad,
text="Ciudad",
padx=5,
pady=15,
bg="#B2DFDB",
fg="#000000")
lCdad.grid(column=0, row=2)
ciudades = ('Mar del Plata', 'Batan', 'Santa Clara', 'Miramar', 'Necochea')
eCdad = Combobox(framePropiedad, state='readonly', values=ciudades)
eCdad.current(0)
eCdad.grid(column=1, row=2, padx=5, pady=15)
eCdad.config(foreground="#e0f2f1", background="#e0f2f1")
#frame para tipo de propiedad
frameTipo = Frame(frameDatos)
frameTipo.pack(fill="both")
frameTipo.config(padx=10, pady=25, bg="#B2DFDB", relief=RAISED, borderwidth=1)
tipo = IntVar()
tipo.set(1)
casa = Radiobutton(frameTipo,
text="Casa",
value=1,
variable=tipo,
#def OptionCallBack(*args):
#print variable.get()
window.geometry('500x350')
variable = StringVar(window)
#variable = str()
variable.set("Select From List")
#variable.trace('w', OptionCallBack)
combo = Combobox(window, textvariable=variable)
all_v = ("Sample", "Variant", "Population", "Phenotype", "Phenotype_Variant",
"Population_variant", "Sample_variant")
combo['values'] = all_v
#combo.current(1) # установите вариант по умолчанию
combo.grid(column=0, row=0)
name_table = combo.current()
print(name_table)
btn = Button(window, text="Посмотреть", command=partial(clicked, variable))
btn.grid(column=1, row=0)
btn = Button(window, text="Добавить", command=partial(clicked1, variable))
btn.grid(column=2, row=0)
def del_sample(id_sampe):
id_samp = str(id_sampe.get())
sql_str = "CALL delete_sample(" + id_samp + ");"
cur.execute(sql_str)
con.commit()
messagebox.showinfo('Пациент', 'Удален')
# ui
Label(menu, text="Algs:", bg="lightblue1").grid(row=0,
column=0,
padx=0,
pady=0)
alg_menu = Combobox(menu,
textvariable=selected_alg,
values=[
'No', 'Bubble Sort', 'Opti Bubble Sort', 'Random Sort',
'Selection Sort', 'Insertion Sort', 'Quick Sort',
'Merge Sort', 'Shell Sort', 'Counting Sort',
'Radix Sort', 'Cocktail Sort'
])
alg_menu.grid(row=0, column=1, padx=2, pady=2)
alg_menu.current([0])
Button(menu, text='Create', font=("arial", 13), command=generate,
bg='white').grid(row=0, column=2, padx=5, pady=5)
Label(menu, text="Search:", bg="lightblue1").grid(row=1,
column=0,
padx=5,
pady=5)
ser_menu = Combobox(
menu,
textvariable=selected_search,
values=['No', 'Linear Search', 'Binary Search', 'Exponential Search'])
ser_menu.grid(row=1, column=1, padx=2, pady=2)
ser_menu.current([0])
#ser_menu.current(2) # delete this after testing
nEntry = Entry(menu, width=10)
def input_kNM():
global liczbaPodklas
liczbaPodklas = combo3.get()
liczbaPodklas = int(liczbaPodklas)
print("liczbaPodklas = ", liczbaPodklas)
przyciskImportujCSV = tk.Button(text=" Importuj polosowany CSV ",
command=getCSV, bg='green', fg='white', font=('helvetica', 12, 'bold'))
przyciskImportujCSV.grid(column=1, row=0)
etykieta3=Label(okno, text=" Procent próbek treningowych: [%]", font=("Arial",12))
etykieta3.grid(column=0,row=1)
combo2 = Combobox(okno)
combo2['values']=(10,20,30,40,50,60,70,80,90)
combo2.current(7)
combo2.grid(column=1,row=1)
przyciskWybierzTrening = tk.Button(text=" Zatwierdź ", command=input_trening, bg='green', fg='white', font=('helvetica', 12, 'bold'))
przyciskWybierzTrening.grid(column=2, row=1)
etykieta2=Label(okno, text=" Wartość k dla metody kNN: \t", font=("Arial",12))
etykieta2.grid(column=0,row=3)
combo = Combobox(okno)
combo['values']=(1,2,3,4,5,6,7,8)
combo.current(2)
combo.grid(column=1,row=3)
przyciskWybierzK = tk.Button(text=" Zatwierdź ", command=input_k, bg='green', fg='white', font=('helvetica', 12, 'bold'))
przyciskWybierzK.grid(column=2, row=3)
lbl = Label(window, text="Кол-во секунд") #Отрисовка виджетов
lbl.grid(column=0, row=0)
txt = Entry(window, width=21) #текстовое поле для секунд
txt.grid(column=1, row=0)
btn = Button(window, text="Старт", command=clicked)
btn.grid(column=2, row=0) #Кнопка
lbl = Label(window, text="Действие")
lbl.grid(column=0, row=3)
combo = Combobox(window) #комбобокс режимов
combo['values'] = ("Видео", "Фото", "Превью")
combo.current(0)
combo.grid(column=1, row=3)
lbl = Label(window,
text="Доп. текст") #текстовое поле для ввода верхнего текста
lbl.grid(column=0, row=7)
txtt = Entry(window, width=21)
txtt.grid(column=1, row=7)
lbl = Label(window, text="Эффекты")
lbl.grid(column=0, row=10)
com = Combobox(window) #комбобокс эффектов
com['values'] = ("Ничего", "Автоулучшение", "Негатив", "Рисунок", "Гравюра")
com.current(0)
def create_window(self):
# 输入区域窗口
type_content_box = ScrolledText(
self.master,
width=54,
height=10,
font=('微软雅黑', 12),
)
type_content_box.insert(
END,
'在此处输入文字、网址 即可翻译',
)
type_content_box.focus_set()
type_content_box.pack(side=LEFT, expand=True)
# 显示区域窗口
trans_result_box = ScrolledText(
self.master,
width=54,
height=11,
bg='#D3D3D3',
font=('consolas', 11),
)
trans_result_box.focus_set()
trans_result_box.pack(side=RIGHT, expand=True)
# 自动检测语言
auto_language = Button(
self.master,
text=' 自动检测语言 ',
state='disabled',
relief='flat',
bg='#ffffff',
fg='#000000',
font=('微软雅黑', 11),
)
auto_language.place(x=5, y=90)
# 选择语言
language = StringVar()
language_chosen = Combobox(
self.master,
width=12,
textvariable=language,
)
language_chosen['values'] = ['中文', '英语', '日语'] # 设置下拉列表的值
language_chosen.place(x=25 * 7, y=100)
language_chosen.current(0)
# 运行结果按钮
run_after = Button(
self.master,
state=DISABLED,
width=10,
relief='flat',
font=('微软雅黑', 11),
)
run_after.place(x=72 * 7 + 4, y=90)
# 显示翻译结果
def show_trans_result():
global translate_result
trans_result_box.delete('1.0', END)
# 运行结果按钮状态:正在翻译
run_after.config(
text='正在翻译',
bg='#ffffff',
fg='#000000',
)
if type_content_box.count('1.0', END) > tuple([0]):
translate_result = translate.baidu_translate(
text=type_content_box.get('1.0', 'end-1c'),
to=language.get())
# 在翻译结果区域显示结果
trans_result_box.insert(END, translate_result)
# 运行结果按钮状态:运行结果
run_after.config(text='运行结果')
# 翻译按钮
translate_button = Button(
self.master,
text='翻 译',
width=10,
bg='#6495ED',
fg='#ffffff',
relief='flat',
command=lambda: show_trans_result(),
font=('微软雅黑', 11),
)
translate_button.place(x=55 * 7 + 5, y=90)
# 底部版权信息
copyright = Label(
self.master,
text=__copyright_info__,
font=('consolas', 11),
)
copyright.place(x=(960 - len(__copyright_info__) * 7.5) / 2,
y=480 - 22)
}
import maket_GUIT_R
maket_GUIT_R.main(data)
on_closing()
window = Tk()
window.title("Create PDF version 1.1.0")
window.geometry('400x650')
# Категория
season_text = Label(window, text='Категория')
season = Combobox(window)
season['value'] = ("Все платья", "Весна 2021", "Лето 2021", "Осень 2021", "Зима 2021")
season.current(0)
season_text.grid(column=0, row=0, sticky=W, padx=10, pady=10)
season.grid(column=1, row=0, sticky=W, padx=10, pady=10)
# Отображение цены
view_price_text = Label(window, text='Отображение цены')
view_price = Combobox(window)
view_price['value'] = ("Да", "Нет")
view_price.current(1)
view_price_text.grid(column=0, row=1, sticky=W, padx=10, pady=10)
view_price.grid(column=1, row=1, sticky=W, padx=10, pady=10)
# Наличие
quantity_text = Label(window, text='Наличие')
quantity = Combobox(window)
quantity['value'] = ("Все", "Только в наличии")
class SimUI(object):
def __init__(self, manager, fake_time, config_obj):
"""
initializes all default values and creates
a board, waits for run() to be called
to start the board
manager - sim manager class instance
"""
self.manager = manager
self.fake_time = fake_time
self.config_obj = config_obj
# Set up idle_add
self.queue = queue.Queue()
self.root = tk.Tk()
self.root.wm_title("PyFRC Robot Simulator v%s" % __version__)
self.root.protocol("WM_DELETE_WINDOW", self._delete_window)
# setup mode switch
frame = tk.Frame(self.root)
frame.pack(side=tk.TOP, anchor=tk.W)
self._setup_widgets(frame)
self.root.resizable(width=0, height=0)
# Allow extending the simulation from 3rd party libraries
# -> TODO: better API for this
self.extensions = []
for ep in iter_entry_points(group="robotpysim", name=None):
try:
extension = ep.load()
except ImportError:
logger.debug("Error importing extension '%s'", ep.name, exc_info=True)
else:
logger.debug("Loaded simulation extension '%s'", ep.name)
extension = extension()
if hasattr(extension, "update_tk_widgets"):
self.extensions.append(extension)
self.mode_start_tm = 0
self.text_id = None
# connect to the controller
self.manager.on_mode_change(
lambda mode: self.idle_add(self.on_robot_mode_change, mode)
)
self.on_robot_mode_change(self.manager.get_mode())
# create pygame joystick if supported
try:
from .pygame_joysticks import UsbJoysticks
except ImportError:
logger.warn("pygame not detected, real joystick support not loaded")
self.usb_joysticks = None
else:
self.usb_joysticks = UsbJoysticks(self)
logger.info("pygame was detected, real joystick support loaded!")
try:
self.root.lift()
self.root.attributes("-topmost", True)
self.root.attributes("-topmost", False)
except Exception:
pass
self.timer_fired()
def _delete_window(self):
self.root.destroy()
if self.usb_joysticks is not None:
self.usb_joysticks.close()
def _setup_widgets(self, frame):
top = tk.Frame(frame)
top.grid(column=0, row=0)
bottom = tk.Frame(frame)
bottom.grid(column=0, row=1)
self.field = RobotField(frame, self.manager, self.config_obj)
self.field.grid(column=1, row=0, rowspan=2)
# status bar
self.status = tk.Label(frame, bd=1, relief=tk.SUNKEN, anchor=tk.E)
self.status.grid(column=0, row=2, columnspan=2, sticky=tk.W + tk.E)
# analog
slot = tk.LabelFrame(top, text="Analog")
self.analog = []
for i in range(len(hal_data["analog_in"])):
if (
hal_data["analog_in"][i]["initialized"]
or hal_data["analog_out"][i]["initialized"]
):
label = tk.Label(slot, text=str(i))
label.grid(column=0, row=i + 1)
vw = ValueWidget(slot, clickable=True, minval=-10.0, maxval=10.0)
vw.grid(column=1, row=i + 1)
self.set_tooltip(vw, "analog", i)
else:
vw = None
self.analog.append(vw)
slot.pack(side=tk.LEFT, fill=tk.Y, padx=5)
# digital
slot = tk.LabelFrame(top, text="Digital")
label = tk.Label(slot, text="PWM")
label.grid(column=0, columnspan=4, row=0)
self.pwm = []
for i in range(len(hal_data["pwm"])):
if hal_data["pwm"][i]["initialized"]:
c = i // 10
label = tk.Label(slot, text=str(i))
label.grid(column=0 + 2 * c, row=1 + i % 10)
vw = ValueWidget(slot)
vw.grid(column=1 + 2 * c, row=1 + i % 10)
self.set_tooltip(vw, "pwm", i)
else:
vw = None
self.pwm.append(vw)
label = tk.Label(slot, text="Digital I/O")
label.grid(column=4, columnspan=6, row=0)
self.dio = []
for i in range(len(hal_data["dio"])):
if hal_data["dio"][i]["initialized"]:
c = i // 9
label = tk.Label(slot, text=str(i))
label.grid(column=4 + c * 2, row=1 + i % 9)
pi = PanelIndicator(slot, clickable=True)
pi.grid(column=5 + c * 2, row=1 + i % 9)
self.set_tooltip(pi, "dio", i)
else:
pi = None
self.dio.append(pi)
label = tk.Label(slot, text="Relay")
label.grid(column=10, columnspan=2, row=0, padx=5)
self.relays = []
for i in range(len(hal_data["relay"])):
if hal_data["relay"][i]["initialized"]:
label = tk.Label(slot, text=str(i))
label.grid(column=10, row=1 + i, sticky=tk.E)
pi = PanelIndicator(slot)
pi.grid(column=11, row=1 + i)
self.set_tooltip(pi, "relay", i)
else:
pi = None
self.relays.append(pi)
slot.pack(side=tk.LEFT, fill=tk.Y, padx=5)
self.csfm = csfm = tk.Frame(top)
# solenoid (pcm)
self.pcm = {}
# values
self.values = {}
# CAN
self.can_slot = tk.LabelFrame(csfm, text="CAN")
self.can_slot.pack(side=tk.LEFT, fill=tk.BOTH, expand=1, padx=5)
self.can = {}
csfm.pack(side=tk.LEFT, fill=tk.Y)
# joysticks
slot = tk.LabelFrame(bottom, text="Joysticks")
self.joysticks = []
for i in range(4):
axes = []
buttons = []
col = 1 + i * 3
row = 0
label = tk.Label(slot, text="Stick %s" % i)
label.grid(column=col, columnspan=3, row=row)
row += 1
# TODO: make this configurable
for j, t in enumerate(["X", "Y", "Z", "T", "4", "5"]):
label = tk.Label(slot, text=t)
label.grid(column=col, row=row)
vw = ValueWidget(slot, clickable=True, default=0.0)
vw.grid(column=col + 1, row=row, columnspan=2)
self.set_joy_tooltip(vw, i, "axes", t)
axes.append(vw)
row += 1
# POV: this needs improvement
label = tk.Label(slot, text="POV")
label.grid(column=col, row=row)
pov = ValueWidget(
slot,
clickable=True,
default=-1,
minval=-1,
maxval=360,
step=45,
round_to_step=True,
)
pov.grid(column=col + 1, row=row, columnspan=2)
row += 1
for j in range(1, 11):
var = tk.IntVar()
ck = tk.Checkbutton(slot, text=str(j), variable=var)
ck.grid(column=col + 1 + (1 - j % 2), row=row + int((j - 1) / 2))
self.set_joy_tooltip(ck, i, "buttons", j)
buttons.append((ck, var))
self.joysticks.append((axes, buttons, [pov]))
slot.pack(side=tk.LEFT, fill=tk.Y, padx=5)
ctrl_frame = tk.Frame(bottom)
# timing control
timing_control = tk.LabelFrame(ctrl_frame, text="Time")
def _set_realtime():
if realtime_mode.get() == 0:
step_button.pack_forget()
step_entry.pack_forget()
self.on_pause(False)
else:
step_button.pack(fill=tk.X)
step_entry.pack()
self.on_pause(True)
realtime_mode = tk.IntVar()
button = tk.Radiobutton(
timing_control,
text="Run",
variable=realtime_mode,
value=0,
command=_set_realtime,
)
button.pack(fill=tk.X)
button = tk.Radiobutton(
timing_control,
text="Pause",
variable=realtime_mode,
value=1,
command=_set_realtime,
)
button.pack(fill=tk.X)
step_button = tk.Button(timing_control, text="Step", command=self.on_step_time)
self.step_entry = tk.StringVar()
self.step_entry.set("0.025")
step_entry = tk.Entry(timing_control, width=6, textvariable=self.step_entry)
Tooltip.create(step_button, "Click this to increment time by the step value")
Tooltip.create(step_entry, "Time to step (in seconds)")
realtime_mode.set(0)
timing_control.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
# simulation control
sim = tk.LabelFrame(ctrl_frame, text="Robot")
self.state_buttons = []
self.mode = tk.IntVar()
def _set_mode():
self.manager.set_mode(self.mode.get())
button = tk.Radiobutton(
sim,
text="Disabled",
variable=self.mode,
value=self.manager.MODE_DISABLED,
command=_set_mode,
)
button.pack(fill=tk.X)
self.state_buttons.append(button)
button = tk.Radiobutton(
sim,
text="Autonomous",
variable=self.mode,
value=self.manager.MODE_AUTONOMOUS,
command=_set_mode,
)
button.pack(fill=tk.X)
self.state_buttons.append(button)
button = tk.Radiobutton(
sim,
text="Teleoperated",
variable=self.mode,
value=self.manager.MODE_OPERATOR_CONTROL,
command=_set_mode,
)
button.pack(fill=tk.X)
self.state_buttons.append(button)
button = tk.Radiobutton(
sim,
text="Test",
variable=self.mode,
value=self.manager.MODE_TEST,
command=_set_mode,
)
button.pack(fill=tk.X)
self.state_buttons.append(button)
self.robot_dead = tk.Label(sim, text="Robot died!", fg="red")
sim.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
#
# Set up a combo box that allows you to select an autonomous
# mode in the simulator
#
try:
from tkinter.ttk import Combobox
except:
pass
else:
auton = tk.LabelFrame(ctrl_frame, text="Autonomous")
self.autobox = Combobox(auton, state="readonly")
self.autobox.bind("<<ComboboxSelected>>", self.on_auton_selected)
self.autobox["width"] = 12
self.autobox.pack(fill=tk.X)
Tooltip.create(
self.autobox,
"Use robotpy_ext.autonomous.AutonomousModeSelector to use this selection box",
)
from networktables.util import ChooserControl
self.auton_ctrl = ChooserControl(
"Autonomous Mode",
lambda v: self.idle_add(self.on_auton_choices, v),
lambda v: self.idle_add(self.on_auton_selection, v),
)
auton.pack(side=tk.TOP)
messages = self.config_obj["pyfrc"]["game_specific_messages"]
if messages:
gamedata = tk.LabelFrame(ctrl_frame, text="Game Data")
self.gamedataval = tk.StringVar()
if hasattr(self.gamedataval, "trace_add"):
self.gamedataval.trace_add("write", self.on_gamedata_selected)
else:
self.gamedataval.trace_variable("w", self.on_gamedata_selected)
self.gamedatabox = Combobox(gamedata, textvariable=self.gamedataval)
self.gamedatabox["width"] = 12
self.gamedatabox.pack(fill=tk.X)
self.gamedatabox["values"] = messages
self.gamedatabox.current(0)
self.manager.game_specific_message = self.gamedatabox.get()
Tooltip.create(
self.gamedatabox,
"Use this selection box to simulate game specific data",
)
gamedata.pack(side=tk.TOP)
def _reset_robot():
for robot in self.manager.robots:
robot.physics_controller.reset_position()
button = tk.Button(ctrl_frame, text="Reset Robot", command=_reset_robot)
button.pack(side=tk.TOP)
ctrl_frame.pack(side=tk.LEFT, fill=tk.Y)
def _render_pcm(self):
for k, data in sorted(hal_data["pcm"].items()):
if k not in self.pcm:
slot = tk.LabelFrame(self.csfm, text="Solenoid (PCM %s)" % k)
solenoids = []
self.pcm[k] = solenoids
for i in range(len(data)):
label = tk.Label(slot, text=str(i))
c = int(i / 2) * 2
r = i % 2
label.grid(column=0 + c, row=r)
pi = PanelIndicator(slot)
pi.grid(column=1 + c, row=r)
self.set_tooltip(pi, "solenoid", i)
solenoids.append(pi)
slot.pack(side=tk.TOP, fill=tk.BOTH, padx=5)
solenoids = self.pcm[k]
for i, ch in enumerate(data):
sol = solenoids[i]
if not ch["initialized"]:
sol.set_disabled()
else:
sol.set_value(ch["value"])
def _render_values(self):
for k, v in hal_data["robot"].items():
if not k.endswith("_angle"):
continue
gyro_label = self.values.get(k)
if not gyro_label:
gyro_label = self._create_value(k, k, "Angle (Degrees)")
gyro_label["text"] = "%.3f" % v
for i, gyro in enumerate(hal_data["analog_gyro"]):
if not gyro["initialized"]:
continue
k = "Gyro %s" % i
gyro_label = self.values.get(k)
if not gyro_label:
gyro_label = self._create_value(k, k, "Angle (Degrees)")
gyro_label["text"] = "%.3f" % gyro["angle"]
for i, encoder in enumerate(hal_data["encoder"]):
if not encoder["initialized"]:
continue
k = "Encoder %s" % i
label = self.values.get(k)
if not label:
txt = "Encoder (%s,%s)" % (
encoder["config"]["ASource_Channel"],
encoder["config"]["BSource_Channel"],
)
label = self._create_value(k, txt, "Count / Distance")
label["text"] = "%s / %.3f" % (
encoder["count"],
encoder["count"] * encoder["distance_per_pulse"],
)
for k, v in hal_data.get("custom", {}).items():
label = self.values.get(k)
if not label:
label = self._create_value(k, k, k)
if isinstance(v, float):
label["text"] = "%.3f" % v
else:
label["text"] = str(v)
def _create_value(self, key, text, tooltip):
slot = tk.LabelFrame(self.csfm, text=text)
label = tk.Label(slot)
label.pack(side=tk.TOP, fill=tk.BOTH)
slot.pack(side=tk.TOP, fill=tk.BOTH, padx=5)
self.values[key] = label
Tooltip.create(label, tooltip)
return label
def idle_add(self, callable, *args):
"""Call this with a function as the argument, and that function
will be called on the GUI thread via an event
This function returns immediately
"""
self.queue.put((callable, args))
def __process_idle_events(self):
"""This should never be called directly, it is called via an
event, and should always be on the GUI thread"""
while True:
try:
callable, args = self.queue.get(block=False)
except queue.Empty:
break
callable(*args)
def run(self):
# and launch the thread
self.root.mainloop() # This call BLOCKS
def timer_fired(self):
"""Polling loop for events from other threads"""
self.__process_idle_events()
# grab the simulation lock, gather all of the
# wpilib objects, and display them on the screen
self.update_widgets()
# call next timer_fired (or we'll never call timer_fired again!)
delay = 100 # milliseconds
self.root.after(delay, self.timer_fired) # pause, then call timer_fired again
def update_widgets(self):
# TODO: support multiple slots?
# joystick stuff
if self.usb_joysticks is not None:
self.usb_joysticks.update()
# analog module
for i, (ain, aout) in enumerate(
zip(hal_data["analog_in"], hal_data["analog_out"])
):
aio = self.analog[i]
if aio is not None:
if ain["initialized"]:
aio.set_disabled(False)
ain["voltage"] = aio.get_value()
elif aout["initialized"]:
aio.set_value(aout["voltage"])
# digital module
for i, ch in enumerate(hal_data["dio"]):
dio = self.dio[i]
if dio is not None:
if not ch["initialized"]:
dio.set_disabled()
else:
# determine which one changed, and set the appropriate one
ret = dio.sync_value(ch["value"])
if ret is not None:
ch["value"] = ret
for i, ch in enumerate(hal_data["pwm"]):
pwm = self.pwm[i]
if pwm is not None:
pwm.set_value(ch["value"])
for i, ch in enumerate(hal_data["relay"]):
relay = self.relays[i]
if relay is not None:
if ch["fwd"]:
relay.set_on()
elif ch["rev"]:
relay.set_back()
else:
relay.set_off()
# solenoid
self._render_pcm()
# gyro/encoder
self._render_values()
# joystick/driver station
# sticks = _core.DriverStation.GetInstance().sticks
# stick_buttons = _core.DriverStation.GetInstance().stick_buttons
for i, (axes, buttons, povs) in enumerate(self.joysticks):
joy = hal_data["joysticks"][i]
jaxes = joy["axes"]
for j, ax in enumerate(axes):
jaxes[j] = ax.get_value()
jbuttons = joy["buttons"]
for j, (ck, var) in enumerate(buttons):
jbuttons[j + 1] = True if var.get() else False
jpovs = joy["povs"]
for j, pov in enumerate(povs):
jpovs[j] = int(pov.get_value())
for extension in self.extensions:
extension.update_tk_widgets(self)
self.field.update_widgets()
tm = self.fake_time.get()
mode_tm = tm - self.mode_start_tm
self.status.config(text="Time: %.03f mode, %.03f total" % (mode_tm, tm))
def set_tooltip(self, widget, cat, idx):
tooltip = self.config_obj["pyfrc"][cat].get(str(idx))
if tooltip is not None:
Tooltip.create(widget, tooltip)
def set_joy_tooltip(self, widget, idx, typ, idx2):
tooltip = self.config_obj["pyfrc"]["joysticks"][str(idx)][typ].get(str(idx2))
if tooltip is not None:
Tooltip.create(widget, tooltip)
def on_auton_choices(self, choices):
self.autobox["values"] = choices[:]
def on_auton_selection(self, selection):
self.autobox.set(selection)
def on_auton_selected(self, e):
self.auton_ctrl.setSelected(self.autobox.get())
def on_gamedata_selected(self, *args):
self.manager.game_specific_message = self.gamedatabox.get()
def on_robot_mode_change(self, mode):
self.mode.set(mode)
self.mode_start_tm = self.fake_time.get()
# this is not strictly true... a robot can actually receive joystick
# commands from the driver station in disabled mode. However, most
# people aren't going to use that functionality...
controls_disabled = (
False if mode == self.manager.MODE_OPERATOR_CONTROL else True
)
state = tk.DISABLED if controls_disabled else tk.NORMAL
for axes, buttons, povs in self.joysticks:
for axis in axes:
axis.set_disabled(disabled=controls_disabled)
for ck, var in buttons:
ck.config(state=state)
for pov in povs:
pov.set_disabled(disabled=controls_disabled)
if not self.manager.is_alive():
for button in self.state_buttons:
button.config(state=tk.DISABLED)
self.robot_dead.pack()
#
# Time related callbacks
#
def on_pause(self, pause):
if pause:
self.fake_time.pause()
else:
self.fake_time.resume()
def on_step_time(self):
val = self.step_entry.get()
try:
tm = float(self.step_entry.get())
except ValueError:
tk.messagebox.showerror(
"Invalid step time", "'%s' is not a valid number" % val
)
return
if tm > 0:
self.fake_time.resume(tm)
def hae_merkintatyypin_mukkaan():
"""Find by type of marking (e.g. find first sentence with at least one dependent-marked possessive NP)."""
global indeksi
global g
global nyk_material
if kielivaihtoehot.get():
nyk_material = kielivaihtoehot.get()
g.clear()
g.extend(import_thing(nyk_material))
language = folder2ipa[nyk_material]
indeksi = 0
else:
return messagebox.showinfo('məˈtiəɹɪəl ˈhæzənt ˌbiːn ˈtʃəʊzən', 'ˈtʃuːz ˈfɜːst ðə məˈtiəɹɪəl ænd ˈðɛn ˈtɹaɪ əˈɡɛn !')
ikkuna = Toplevel()
ikkuna.title('ˈfaɪnd ˈsɛntəns ɪn "{}" ({})'.format(nyk_material, language))
#search
tyyppi_label1 = Label(ikkuna, text='ˈfaɪnd')
tyyppi_label1.grid(row=0, column=0, sticky=E)
#whichth
monesko = Entry(ikkuna, width=6)
monesko.grid(row=0, column=1)
set_text(monesko, '1')
#from the end?
ekavikabox = Combobox(ikkuna, values=ekavika)
ekavikabox.grid(row=0, column=2)
ekavikabox.current(0)
#containing
Label(ikkuna, text='kənˈteɪnɪŋ').grid(row=0, column=3)
#which type of marking the user wants to search for
mlbox = Combobox(ikkuna, values=merkintaluokat)
mlbox.grid(row=0, column=4)
# browse only these?
# If tickbox is crossed, previous and next buttons will only show sentences containing the searched type of possessive NPs.
sellaavar = IntVar() # sellaa = 'browse' (in dialectal Finnish)
sellaa = Checkbutton(ikkuna, text="ˈbɹaʊz ˈəʊnli ˈðiːz", variable=sellaavar)
sellaa.grid(row=1, column=0)
def haku(): # actual search
nonlocal ikkuna
if ekavikabox.get() == 'θ':
i = 0
add = 1
else:
i = -1
add = -1
try:
nn = int(monesko.get())
assert nn > 0
except:
return messagebox.showinfo('ˈɛɹə', '{} ɪz nˌɒt ə ˈpɒzɪˌtɪv ˈɪntɪdʒə'.format(monesko.get()))
loyv = []
mlbox_arvo = mlbox.get()
if not mlbox_arvo:
return messagebox.showinfo('ˈtʃuːz wɒt ˈtaɪp jɔː ˈlʊkɪŋ fɔː', 'ˈtʃuːz ˈfɜːst ˈwɪtʃ ˌtaɪp ɒv ˈmɑːkɪŋ juː ˈwɒnt tə ˈfaɪnd'.format(monesko.get()))
if sellaavar.get(): # everything under this "if" statement must end in return statements,
c = [] # the "while True" loop below is only for cases where the user wants to browse the entire material
for lause in g:
vastaus = et.possessiivi(et.to_ordered_dict(lause), nyk_material[3:])
if mlbox_arvo in vastaus and vastaus[mlbox_arvo] and vastaus[mlbox_arvo] != et.NA:
c.append(lause)
if not c:
ikkuna.destroy()
return messagebox.showinfo('ˈkɑːnt ˈfaɪnd ˈɛni', 'ðə ˈtaɪp ɒv ˈmɑːkɪŋ juː ˈtʃəʊz dʌz ˌnɒt əˈpiəɹ ɪn ðə məˈtiəɹɪəl.')
g.clear()
g.extend(c)
if add == 1:
virhe = False
try:
nyk_lause = g[nn-1]
indeksi = nn-1
except IndexError:
nyk_lause = g[-1]
indeksi = len(g)-1
virhe = True
lahe.delete('1.0', END)
lahe.insert(END, g[indeksi])
kf()
ikkuna.destroy()
if virhe:
return messagebox.showinfo('ˈkɑːnt ˈfaɪnd ðæt ˈmɛni', 'ðə ˈtaɪp ɒv ˈmɑːkɪŋ juː ˈtʃəʊz dʌz ˌnɒt əˈpiəɹ ɪn ðə məˈtiəɹɪəl ðæt ˈmɛni ˈtaɪmz , ˈhiəz ðə ˈlɑːst ˌwɒn')
else:
virhe = False
try:
nyk_lause = g[nn]
indeksi = g.index(nyk_lause)
except IndexError:
nyk_lause = g[0]
indeksi = 0
virhe = True
lahe.delete('1.0', END)
lahe.insert(END, g[indeksi])
kf()
ikkuna.destroy()
if virhe:
return messagebox.showinfo('ˈkɑːnt ˈfaɪnd ðæt ˈmɛni', 'ðə ˈtaɪp ɒv ˈmɑːkɪŋ juː ˈtʃəʊz dʌz ˌnɒt əˈpiəɹ ɪn ðə məˈtiəɹɪəl ðæt ˈmɛni ˈtaɪmz , ˈhiəz ðə ˈfɜːst ˌwɒn')
while True:
try:
lause = g[i]
vastaus = et.possessiivi(et.to_ordered_dict(lause), nyk_material[3:])
if mlbox_arvo in vastaus and vastaus[mlbox_arvo]:
#print(i, add, lause, vastaus)
loyv.append(lause)
if len(loyv) == nn:
if add == 1:
indeksi = i
else:
indeksi = len(g)+i
assert indeksi >= 0
lahe.delete('1.0', END)
lahe.insert(END, g[indeksi])
kf()
ikkuna.destroy()
break
i += add
except IndexError:
if loyv:
lause = loyv[-1]
indeksi = g.index(lause)
lahe.delete('1.0', END)
lahe.insert(END, g[indeksi])
kf()
ikkuna.destroy()
if add == 1:
return messagebox.showinfo('ˈkɑːnt ˈfaɪnd ðæt ˈmɛni', 'ðə ˈtaɪp ɒv ˈmɑːkɪŋ juː ˈtʃəʊz dʌz ˌnɒt əˈpiəɹ ɪn ðə məˈtiəɹɪəl ðæt ˈmɛni ˈtaɪmz , ˈhiəz ðə ˈlɑːst ˌwɒn')
else:
return messagebox.showinfo('ˈkɑːnt ˈfaɪnd ðæt ˈmɛni', 'ðə ˈtaɪp ɒv ˈmɑːkɪŋ juː ˈtʃəʊz dʌz ˌnɒt əˈpiəɹ ɪn ðə məˈtiəɹɪəl ðæt ˈmɛni ˈtaɪmz , ˈhiəz ðə ˈfɜːst ˌwɒn')
else:
ikkuna.destroy()
return messagebox.showinfo('ˈkɑːnt ˈfaɪnd ˈɛni', 'ðə ˈtaɪp ɒv ˈmɑːkɪŋ juː ˈtʃəʊz dʌz ˌnɒt əˈpiəɹ ɪn ðə məˈtiəɹɪəl.')
ikkuna.destroy()
ok = Button(ikkuna, text=' ˌəʊˈkeɪ ', command=haku)
ok.grid(columnspan=5, row=1)#, sticky=W)
'yiddish': 'yi',
'yoruba': 'yo',
'zulu': 'zu'
}
# ------------------------------------------------------------------------------------------------------------------------------------
# (Combobox) Combobox is a combination of Listbox and an entry field. It is one of the Tkinter widgets where it contains
# down arrow to select from a list of options. It helps the users to select according to the list of options displayed.
# When the user clicks on the drop-down arrow on the entry field,
# a pop up of the scrolled Listbox is displayed down the entry field.
# The selected option will be displayed in the entry field only when an option from the Listbox is selected.
languages = StringVar()
box = Combobox(root, width=20, textvariable=languages, state="readonly")
box["value"] = [i for i in lang_dict.keys()]
box.current(95)
box.place(x=300, y=0)
# ------------------------------------------------------------------------------------------------------------------------------------
# (Entry Box) The Entry widget
# is used to accept single-line text strings from a user.
variable_name1 = StringVar() # StringVar() is a class from tkinter.
# It's used so that you can easily monitor changes to tkinter variables if they occur through the example code provided
entry1 = Entry(root,
width=30,
textvariable=variable_name1,
font=("times", 15, "italic bold"))
entry1.place(x=120, y=40)
variable_name2 = StringVar()
btn1['bg'] = 'yellow'
def on_enterbtn2(e):
btn2['bg'] = 'springgreen'
def on_leavebtn2(e):
btn2['bg'] = 'yellow'
########################################################################## ComboBox Languages
languages = StringVar()
font_box = Combobox(root, width=30, textvariable=languages, state='readonly')
font_box['values'] = [e for e in lan_dict.keys()]
font_box.current(37)
font_box.place(x=300, y=0)
########################################################################### Entry Box
varname1 = StringVar()
entry1 = Entry(root,
width=30,
textvariable=varname1,
font=('times', 15, 'italic bold'))
entry1.place(x=150, y=40)
varname2 = StringVar()
entry2 = Entry(root,
width=30,
textvariable=varname2,
font=('times', 15, 'italic bold'))
entry2.place(x=150, y=100)
class AppGUI(Frame):
def __init__(self, master=None):
# Avoiding to send it continuously.
self.lock = False
Frame.__init__(self, master)
self.grid()
self.master = master
# Setting for ComboBox.
self.url_lang_combobox_str = StringVar()
self.url_lang_combobox_list = lang_list
# UI components.
self.receiver_email_text = Label(self, text="Receiver:")
self.receiver_email_field = Entry(self, width=50)
self.subject_text = Label(self, text='Subject:')
self.subject_field = Entry(self, width=50)
self.receiver_name_text = Label(self, text='Name:')
self.receiver_name_field = Entry(self, width=50)
self.url_lang_text = Label(self, text='Link lang:')
self.url_lang_combobox = Combobox(self, textvariable=self.url_lang_combobox_str, values=self.url_lang_combobox_list, state='readonly')
self.send_progressbar = Progressbar(self, orient='horizontal', length=500, mode='determinate', maximum=300)
self.send_button = Button(self, text='Send', command=self._send_mail)
self.quit_button = Button(self, text='Exit', command=self.__exit)
self.log_msg_text = ScrolledText(self)
# Attachment.
self.mail_attachment_list = attachment_list[:]
self.url_lang_link_title = None
self.url_lang_link = copy.deepcopy(content_link)
# Mailer
self._mailer = None
# Let Mailer can control components.
Mailer.window_content = self
self.__create_widgets()
def _send_mail(self):
if not self.lock:
threading.Thread(target=self.__send_mail).start()
else:
messagebox.showinfo('Warning', "Now it's processing...")
def _choose(self, event):
# arr = self.url_lang_link.get(self.url_lang_combobox_str.get()) # Get the array by choosing language.
pass
def _modify_content_url_link(self):
link_arr = self.url_lang_link.get(self.url_lang_combobox_str.get())
content = self._mailer.content
for index in range(len(link_arr)):
content_index = content.index(self.url_lang_link_title[index]) + len(self.url_lang_link_title[index])
content = content[:content_index] + '\n' + link_arr[index] + content[content_index:]
self._mailer.content = content
return False
def _make_mailer(self):
self.mail_attachment_list = attachment_list[:] # Clone a list.
if atta_lang_list[self.url_lang_combobox.current()]:
for i in range(len(self.mail_attachment_list)):
# Only from the third file to the end file can change language.
if i > 2:
# Modify the file name.
att = self.mail_attachment_list[i].split('.')
self.mail_attachment_list[i] = ''.join([' ', atta_lang_list[self.url_lang_combobox.current()], '.']).join(att)
# ** IMPORTANT, we set the content path here!!
path = 'content.docx'
if self.url_lang_combobox.get() == lang_list[2] or self.url_lang_combobox.get() == lang_list[3]:
path = 'content chinese.docx'
if debug_log:
print(self.mail_attachment_list)
# ** IMPORTANT, we have to new an object here. Otherwise, we couldn't check the error checking.
return Mailer(content_path=path, attachment_list=self.mail_attachment_list)
def __create_widgets(self):
"""
Construct all of the UI components.
"""
self.receiver_email_text.grid(row=0, column=0)
self.receiver_email_field.grid(row=0, column=1, columnspan=6)
self.subject_text.grid(row=1, column=0)
self.subject_field.grid(row=1, column=1, columnspan=6)
self.subject_field.insert(0, 'Osaka Mariko Apartment Location & Condition')
self.receiver_name_text.grid(row=2, column=0)
self.receiver_name_field.grid(row=2, column=1, columnspan=6)
self.url_lang_text.grid(row=3, column=0)
self.url_lang_combobox.grid(row=3, column=2, columnspan=2)
self.send_progressbar.grid(row=4, column=0, columnspan=7)
self.send_button.grid(row=5, column=2)
self.quit_button.grid(row=5, column=3)
self.log_msg_text.grid(row=6, column=0, columnspan=7)
# Default setting.
self.url_lang_combobox.current(0)
self.url_lang_combobox.bind("<<ComboboxSelected>>", self._choose)
def __exit(self):
if not self.lock:
self.log_msg_text.insert(END, '\n\n -- Bye Bye --\n')
self.master.quit()
else:
messagebox.showinfo('Error', "Now it's processing...please wait it ;)")
@DecoratorThreadLockerApp()
@DecoratorErrorCheckAndInitApp()
def __send_mail(self):
self.send_progressbar.start() # Start processing the progress.
ending = 'Welcome to use my application :)' if self._mailer.send_mail() \
else '** Your sending was failed :( please send it again!'
self.log_msg_text.insert(END, ending)
self.send_progressbar.stop() # Stop processing the progress.
Label(printerFrame, text="Monitor").pack(anchor=W)
monitorSelect = Combobox(printerFrame, values = monitorList, state="readonly", textvariable=vMonitor)
monitorSelect.pack()
confMonitor = Button(printerFrame, text="Configure Monitor", state="disabled", command = openMonitorConfig)
confMonitor.pack(pady=5, anchor=W, fill=X)
Label(printerFrame, text="COM Port").pack(anchor=W)
comSelect = Combobox(printerFrame, values = comPortNames, state="readonly", textvariable=vComPort)
comSelect.pack()
if selectedMonIndex != -1:
monitorSelect.current(int(selectedMonIndex))
confMonitor.configure(state="normal")
if selectedComPortIndex != -1:
print(selectedComPortIndex)
vComPort.set(comPortNames[int(selectedComPortIndex)])
vBaudRate.set(config.get('baudRate'))
vMonitor.trace('w', monitorChanged)
vComPort.trace('w', comPortChanged)
vBaudRate.trace('w', comPortChanged)
Label(printerFrame, text="Baud Rate").pack(anchor=W)
baudSelect = Combobox(printerFrame, values = [300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 230400, 250000, 2500000], textvariable=vBaudRate)
baudSelect.pack()
