class Ufd:
"""
Universal File Dialog - "UFD"
Unopinionated, minimalist, reusable, slightly configurable,
general-purpose file-dialog.
"""
def __init__(self,
title: str = "Universal File Dialog",
icon: str = "",
show_hidden: bool = False,
include_files: bool = True,
multiselect: bool = True,
select_dirs: bool = True,
select_files: bool = True,
unix_delimiter: bool = True,
stdout: bool = False):
"""
Init kwargs as object attributes, save references to
Tk PhotoImages, & define the widgets + layout
"""
if not isinstance(title, str):
raise TypeError("Argument title must be type string.")
self.title = title
if icon:
if not isinstance(icon, str):
raise TypeError("Argument icon must be type string.")
if not isfile(icon):
raise FileNotFoundError(f"File not found: {icon}")
self.icon = icon
else:
self.icon = ""
if show_hidden:
self.show_hidden = True
else:
self.show_hidden = False
if include_files:
self.include_files = True
else:
self.include_files = False
if multiselect:
self.multiselect = True
else:
self.multiselect = False
if select_dirs:
self.select_dirs = True
else:
self.select_dirs = False
if select_files:
self.select_files = True
else:
self.select_files = False
if unix_delimiter:
self.unix_delimiter = True
else:
self.unix_delimiter = False
if stdout:
self.stdout = True
else:
self.stdout = False
# Tkinter:
self.dialog = Tk()
self.dialog.withdraw()
self.dialog.title(self.title)
self.dialog.minsize(width=300, height=200)
self.dialog.geometry("500x300")
self.dialog.update_idletasks()
self.file_icon = PhotoImage(file=f"{dirname(__file__)}/file.gif",
master=self.dialog).subsample(50)
self.folder_icon = PhotoImage(file=f"{dirname(__file__)}/folder.gif",
master=self.dialog).subsample(15)
self.disk_icon = PhotoImage(file=f"{dirname(__file__)}/disk.gif",
master=self.dialog).subsample(15)
if self.icon:
self.dialog.iconbitmap(self.icon)
else:
self.dialog.iconbitmap(f"{dirname(__file__)}/icon.ico")
# Widgets:
self.paneview = PanedWindow(
self.dialog,
sashwidth=7,
bg="#cccccc",
bd=0,
)
self.left_pane = PanedWindow(self.paneview)
self.right_pane = PanedWindow(self.paneview)
self.paneview.add(self.left_pane)
self.paneview.add(self.right_pane)
self.treeview_x_scrollbar = Scrollbar(self.left_pane,
orient="horizontal")
self.treeview_y_scrollbar = Scrollbar(self.left_pane,
orient="vertical")
self.list_box_x_scrollbar = Scrollbar(self.right_pane,
orient="horizontal")
self.list_box_y_scrollbar = Scrollbar(self.right_pane,
orient="vertical")
# tstyle = Style().configure(".", )
self.treeview = Treeview(
self.left_pane,
xscrollcommand=self.treeview_x_scrollbar.set,
yscrollcommand=self.treeview_y_scrollbar.set,
show="tree",
selectmode="browse",
# style=tstyle
)
self.list_box = Listbox(self.right_pane,
xscrollcommand=self.list_box_x_scrollbar.set,
yscrollcommand=self.list_box_y_scrollbar.set,
width=34,
highlightthickness=0,
bd=2,
relief="ridge")
if self.multiselect:
self.list_box.config(selectmode="extended")
else:
self.list_box.config(selectmode="browse")
self.cancel_button = Button(self.left_pane,
text="Cancel",
command=self.cancel)
self.submit_button = Button(self.right_pane,
text="Submit",
command=self.submit)
self.treeview_x_scrollbar.config(command=self.treeview.xview)
self.treeview_y_scrollbar.config(command=self.treeview.yview)
self.list_box_x_scrollbar.config(command=self.list_box.xview)
self.list_box_y_scrollbar.config(command=self.list_box.yview)
#Layout:
self.dialog.rowconfigure(0, weight=1)
self.dialog.columnconfigure(0, weight=1)
self.left_pane.grid_rowconfigure(0, weight=1)
self.left_pane.grid_columnconfigure(0, weight=1)
self.right_pane.grid_rowconfigure(0, weight=1)
self.right_pane.grid_columnconfigure(0, weight=1)
self.paneview.paneconfigure(
self.left_pane,
minsize=100,
#Start off w/ the sash centered in the GUI:
width=(self.dialog.winfo_width() / 2) - ceil(
(self.paneview.cget("sashwidth") * 1.5)),
)
self.paneview.paneconfigure(self.right_pane, minsize=100)
self.paneview.grid(row=0, column=0, sticky="nsew")
self.treeview.grid(row=0, column=0, sticky="nsew")
self.treeview_y_scrollbar.grid(row=0, column=1, sticky="ns")
self.treeview_x_scrollbar.grid(row=1,
column=0,
columnspan=2,
sticky="ew")
self.list_box.grid(row=0, column=0, sticky="nsew")
self.list_box_y_scrollbar.grid(row=0, column=1, sticky="ns")
self.list_box_x_scrollbar.grid(row=1,
column=0,
columnspan=2,
sticky="ew")
self.cancel_button.grid(row=2, column=0, sticky="w", padx=10, pady=10)
self.submit_button.grid(row=2,
column=0,
columnspan=2,
sticky="e",
padx=10,
pady=10)
#Bindings, Protocols, & Misc:
self.dialog.bind("<Control-w>", self.cancel)
self.treeview.bind("<<TreeviewSelect>>", self.treeview_select)
self.treeview.bind("<Double-Button-1>", self.dialog_populate)
self.treeview.bind("<Return>", self.dialog_populate)
self.treeview.bind("<Right>", self.dialog_populate)
self.list_box.bind("<<ListboxSelect>>", self.list_box_select)
self.list_box.bind("<Return>", self.submit)
self.dialog.protocol("WM_DELETE_WINDOW", self.cancel)
self.dialog_selection = deque()
self.selection_paths = deque()
for disk in self.get_disks():
self.treeview.insert(
"",
index="end",
text=disk,
image=self.disk_icon,
)
self.dialog.focus()
def __call__(self):
"""
Display dialog & return selection
"""
(width_offset, height_offset) = self.get_offset(self.dialog)
self.dialog.geometry(f"+{width_offset}+{height_offset}")
self.dialog.update_idletasks()
self.dialog.deiconify()
self.dialog.wait_window()
for i, path in enumerate(self.dialog_selection):
if self.unix_delimiter:
self.dialog_selection[i] = sub("\\\\", "/", path)
else:
self.dialog_selection[i] = sub("/", "\\\\", path)
if self.stdout:
[print(item) for item in self.dialog_selection]
return list(self.dialog_selection)
def __str__(self):
"""
Return own address
"""
return "Universal File Dialog"\
f" @ {hex(id(self))}"
def __repr__(self):
"""
Return full string representation of constructor signature
"""
return f"Ufd("\
f"title=\"{self.title}\","\
f" icon=\"{self.icon}\","\
f" show_hidden={self.show_hidden},"\
f" include_files={self.include_files},"\
f" multiselect={self.multiselect},"\
f" select_dirs={self.select_dirs},"\
f" select_files={self.select_files},"\
f" unix_delimiter={self.unix_delimiter})"\
f" stdout={self.stdout})"\
f" @ {hex(id(self))}"
@staticmethod
def get_offset(tk_window):
"""
Returns an appropriate offset for a given tkinter toplevel,
such that it always is created center screen on the primary display.
"""
width_offset = int((tk_window.winfo_screenwidth() / 2) -
(tk_window.winfo_width() / 2))
height_offset = int((tk_window.winfo_screenheight() / 2) -
(tk_window.winfo_height() / 2))
return (width_offset, height_offset)
@staticmethod
def get_disks():
"""
Returns all mounted disks (for Windows)
>> ["A:", "B:", "C:"]
"""
if system() != "Windows":
raise OSError("For use with Windows platforms.")
logicaldisks = run(["wmic", "logicaldisk", "get", "name"],
capture_output=True)
return findall("[A-Z]:", str(logicaldisks.stdout))
@staticmethod
def list_dir(path, force=False):
"""
Reads a directory with a shell call to dir.
Truthiness of bool force determines whether
hidden items are returned or not. (For Windows)
"""
path = sub("/", "\\\\", path)
if force:
dir_listing = run(["dir", path, "/b", "/a"],
shell=True,
capture_output=True)
else:
dir_listing = run(["dir", path, "/b"],
shell=True,
capture_output=True)
output = dir_listing.stdout
err = dir_listing.stderr
if not output:
return []
if err:
err = err.decode("utf-8")
raise Exception(err)
str_output = output.decode("utf-8")
list_output = re_split("\r\n", str_output)
return sorted([item for item in list_output if item])
def climb(self, item):
"""
Builds & returns a complete path to root directory,
including the item name itself as the path tail.
An extra delimiter is appeneded for the subsequent
child node, which is normalized in dialog_populate()
"""
item_text = self.treeview.item(item)["text"]
parent = self.treeview.parent(item)
path = ""
parents = deque()
while parent:
parents.append(self.treeview.item(parent)["text"] + "/")
parent = self.treeview.parent(parent)
for parent in reversed(parents):
path += parent
path += item_text + "/"
return path
def dialog_populate(self, event=None):
"""
Dynamically populates & updates the treeview, listbox,
and keeps track of the full paths corresponding to each
item in the listbox
"""
if not self.treeview.focus():
return
self.treeview.column("#0", width=1000)
existing_children = self.treeview.get_children(self.treeview.focus())
[self.treeview.delete(child) for child in existing_children]
self.list_box.delete(0, "end")
self.selection_paths.clear()
focus_item = self.treeview.focus()
path = self.climb(focus_item)
if self.show_hidden:
children = self.list_dir(path, force=True)
else:
children = self.list_dir(path)
for child in children:
if isdir(path + child):
self.treeview.insert(focus_item,
index="end",
text=child,
image=self.folder_icon)
if self.select_dirs:
self.list_box.insert("end", child)
self.selection_paths.append(path + child)
elif isfile(path + child):
if self.include_files:
self.treeview.insert(focus_item,
index="end",
text=child,
image=self.file_icon)
if self.select_files:
self.list_box.insert("end", child)
self.list_box.itemconfig("end", {"bg": "#EAEAEA"})
self.selection_paths.append(path + child)
if isfile(normpath(path)):
(head, tail) = path_split(normpath(path))
head = sub("\\\\", "/", head)
self.list_box.insert("end", tail)
self.selection_paths.append(head + "/" + tail)
self.list_box.itemconfig("end", {"bg": "#EAEAEA"})
def list_box_select(self, event=None):
"""
Dynamically refresh the dialog selection with
what's selected in the listbox
(Callback for <<ListboxSelect>>).
"""
self.dialog_selection.clear()
for i in self.list_box.curselection():
self.dialog_selection.append(self.selection_paths[i])
def treeview_select(self, event=None):
"""
Dynamically refresh the dialog selection with
what's selected in the treeview
(Callback for <<TreeviewSelect>>).
"""
for i in self.list_box.curselection():
self.list_box.selection_clear(i)
self.dialog_selection.clear()
item = normpath(self.climb(self.treeview.focus()))
self.dialog_selection.append(item)
def submit(self, event=None):
"""
Satisfies wait_window() in self.__call__() and validates selection
(Callback for <Return>, <Button-1> on file_list, submit_button)
"""
if self.select_dirs == False:
for item in self.dialog_selection:
if isdir(item):
messagebox.showwarning(
"Error - Invalid Selection",
"Unable to select directory. Please select a file(s).")
return
if self.select_files == False:
for item in self.dialog_selection:
if isfile(item):
messagebox.showwarning(
"Error - Invalid Selection",
"Unable to select file. Please select a folder(s)")
return
self.dialog.destroy()
def cancel(self, event=None):
"""
Satisfies wait_window() in self.__call__()
(Callback for <Button-1> on cancel_button)
(Callback for protocol "WM_DELETE_WINDOW" on self.dialog)
"""
self.dialog_selection.clear()
self.dialog.destroy()
class NodeTree:
def __init__(self):
self._client = KazooClient(hosts='localhost:2181')
# self._client = KazooClient(hosts='10.128.62.34:2181,10.128.62.34:2182,10.128.62.34:2183')
self._client.start()
self._selected_node = None
self._win = None
self._root = None
self._tree_canvas = None
self._tree_frame_id = None
self.init_ui()
self.init_tree()
self._count = 0
# self.treeify()
print(self._count)
self._win.mainloop()
def init_ui(self):
self._win = tk.Tk()
self._win.title("zk-client")
self._win.geometry('900x700+500+300')
self._win.resizable(height=False, width=False)
tree_wrapper = tk.Frame(self._win, bg='red', width=300)
tree_wrapper.pack(side=tk.LEFT, fill=tk.Y)
canvas = self._tree_canvas = tk.Canvas(tree_wrapper,
width=300,
height=700,
scrollregion=(0, 0, 300, 700),
bg='gray') # 创建canvas
canvas.place(x=0, y=0) # 放置canvas的位置
frame = tk.Frame(canvas) # 把frame放在canvas里
# frame.place(width=180, height=600) # frame的长宽，和canvas差不多的
vbar = Scrollbar(canvas, orient=tk.VERTICAL) # 竖直滚动条
vbar.place(x=281, width=20, height=700)
vbar.configure(command=canvas.yview)
hbar = Scrollbar(canvas, orient=tk.HORIZONTAL) # 水平滚动条
hbar.place(x=0, y=680, width=280, height=20)
hbar.configure(command=canvas.xview)
canvas.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set) # 设置
canvas.bind_all(
"<MouseWheel>", lambda event: canvas.yview_scroll(
int(-1 * (event.delta / 120)), "units"))
self._tree_frame_id = canvas.create_window(
0, 0, window=frame, anchor='nw') # create_window)
self._root = Treeview(frame)
#
self._root.pack(expand=True, fill=tk.BOTH)
# self._root.bind("<Button-1>", self.clear_pre_selected)
# self._root.bind("<< TreeviewClose>>", self.clear_pre_selected)
self._root.bind("<<TreeviewOpen>>", self.open_node)
def adjust_size(self):
self._root.update()
width = self._root.winfo_width()
height = self._root.winfo_height()
print(width, height)
self._tree_canvas.itemconfigure(self._tree_frame_id,
height=height) # 设定窗口tv_frame的高度
self._tree_canvas.config(scrollregion=(0, 0, width, height))
self._tree_canvas.config(
scrollregion=self._tree_canvas.bbox("all")) # 滚动指定的范围
self._tree_canvas.config(height=height)
pass
def init_tree(self):
tops = self._client.get_children("/")
for index, top in enumerate(tops):
self._root.insert('', index, text=top)
children = self._client.get_children("/" + top + "/")
if children is not None and len(children) > 0:
pass
def clear_pre_selected(self, event):
focus = self._root.focus()
if focus == '':
return
children = self._root.get_children(focus)
for child in children:
self._root.delete(child)
def open_node(self, event):
iid = self._root.focus()
path = self.get_current_path(iid)
children = self._client.get_children(path)
for index, p in enumerate(children):
self._root.insert(iid, index, text=p)
self.adjust_size()
def get_current_path(self, item):
curr_item = self._root.item(item)
pid = self._root.parent(item)
if pid == '':
return '/' + curr_item['text'] + "/"
else:
return self.get_current_path(pid) + curr_item['text'] + "/"
def treeify(self):
self._client.start()
self.treeify_recursive("/", parent='', index=0)
def treeify_recursive(self, path, parent, index):
self._count += 1
cd = self._client.get_children(path=path)
if cd and len(cd) > 0:
for i, c in enumerate(cd):
tmp_path = path + c + '/'
tc = self._client.get_children(tmp_path)
if tc and len(tc) > 0:
insert = self._root.insert(parent, i, text=c)
self.treeify_recursive(path=tmp_path,
parent=insert,
index=i)
else:
self._root.insert(parent, i, text=c)
class DebitList(Frame, MoneySubject, MoneyObserver):
def __init__(self, parent):
super().__init__(parent)
MoneySubject.__init__(self)
MoneyObserver.__init__(self)
self.initUI()
def initUI(self):
self.records = []
self.debitList = Treeview(self, height=15)
columns = ("Amount", "Desc")
self.debitList["columns"] = columns
self.debitList.column("#0", width=70, minwidth=70, stretch=NO)
self.debitList.column("Amount", width=70, stretch=NO)
self.debitList.column("Desc", width=250, stretch=NO)
self.debitList.heading("#0", text="Date", anchor=W)
for field in columns:
self.debitList.heading(field, text=field, anchor=W)
self.debitList.pack(side=LEFT)
self.pack()
self.debitList.bind("<Delete>", self.keydown)
def keydown(self, e):
item = self.debitList.selection()
parent = self.debitList.parent(item)
if item != () and parent != '':
values = self.debitList.item(item)['values']
amount = float(values[0][1:])
self.moneyNotify({"debit": -amount})
self.debitList.delete(item)
self.records.remove({
"debit": amount,
"desc": str(values[1]),
"date": parent
})
def reset(self):
self.records = []
for child in self.debitList.get_children():
self.debitList.delete(child)
def export(self):
return self.records
def restore(self, debits, startDate):
self.reset()
self.setStartDate(startDate)
dateTable = {}
for d in range(7):
day = startDate + timedelta(days=d)
dateStr = day.strftime("%d/%m")
dateTable[dateStr] = day
for debit in debits:
debit["date"] = dateTable[debit["date"]]
self.moneyUpdate(debit)
self.moneyNotify(debit)
def moneyUpdate(self, monies):
if "debit" in monies:
dateStr = monies["date"].strftime("%d/%m")
toSave = monies
toSave["date"] = dateStr
self.records.append(toSave)
values = (f"${monies['debit']}", monies["desc"])
self.debitList.insert(dateStr, "end", text="", values=values)
def setStartDate(self, startDate):
for d in range(7):
day = startDate + timedelta(days=d)
dateStr = day.strftime("%d/%m")
self.debitList.insert("",
"end",
id=dateStr,
text=dateStr,
values=("", ""))
class SearchApplication(GenericFrame):
FAVICON = "../assets/favicon.ico"
def __init__(self, parent=None, app_window=None):
self.lastValue = None
self.category_option = StringVar("")
self.column_id = [
'ProductDescription', 'ManufacturerName', 'ManufacturerPartNumber',
'DigiKeyPartNumber', 'Category'
]
Frame.__init__(self, parent)
self.pack()
self.parent = parent
self.app_window = app_window
self.selectedField = None
self.parent.title("Partlocater - Advanced Database Search")
self.parent.iconbitmap(self.FAVICON)
self.menubar = Frame(self, background='white')
self.menubar.pack(side=TOP, fill=X, expand=YES)
self.win_frame = Frame(self)
self.win_frame.pack(side=TOP, fill=BOTH, expand=YES)
self.editbutton = Menubutton(self.menubar,
text='Edit',
background='grey98')
self.editbutton.pack(side=LEFT, fill=X)
self.editmenu = Menu(self.editbutton, tearoff=0)
self.editbutton.config(menu=self.editmenu)
self.copySourcesMenu = Menu(self.editbutton, tearoff=0)
self.editmenu.add_cascade(label='Copy', menu=self.copySourcesMenu)
self.copySourcesMenu.add_command(label='Part Number',
state=DISABLED,
command=self.on_copy_partnumber)
self.partnumber_index = 0
self.copySourcesMenu.add_command(label='Selected Parameter',
state=DISABLED,
command=self.on_copy_parameters)
self.selectedParameter_index = 1
self.copySourcesMenu.add_command(label='Selected Part All Parameters',
state=DISABLED,
command=self.on_copy_all_parameters)
self.allParameters_index = 2
self.editmenu.add_command(label='Delete Part',
state=DISABLED,
command=self.on_delete)
self.searchLF = LabelFrame(self.win_frame, text="Search")
self.searchLF.pack(side=LEFT, fill=X, expand=YES, pady=4, padx=6)
self.searchLeftF = Frame(self.searchLF)
self.searchLeftF.pack(side=LEFT, anchor=W)
self.searchRightF = Frame(self.searchLF)
self.searchRightF.pack(side=LEFT, anchor=N)
self.searchLabelWidth = 20
self.catF = Frame(self.searchLeftF)
self.catF.pack(side=TOP, anchor=W)
self.catL = Label(self.catF,
text='Category',
width=self.searchLabelWidth,
anchor=W,
justify=LEFT)
self.catL.pack(side=LEFT, fill=X, expand=YES)
self.cat = StringVar()
self.catE = Entry(self.catF,
textvariable=self.cat,
width=50,
state=DISABLED)
self.catE.config(disabledbackground=self.catE.cget("bg"))
self.catE.config(disabledforeground=self.catE.cget("fg"))
self.catE.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.category_option = StringVar()
self.cat.set("All")
option_list = ['All', 'All'] + Config().tables
self.catM = OptionMenu(self.searchRightF,
self.category_option,
*option_list,
command=self.on_category)
self.catM.pack(side=TOP, anchor=N, fill=X, expand=YES)
self.manF = Frame(self.searchLeftF)
self.manF.pack(side=TOP, anchor=W)
self.manL = Label(self.manF,
text='ManufacturerName',
width=self.searchLabelWidth,
anchor=W,
justify=LEFT)
self.manL.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.man = StringVar()
self.manE = Entry(self.manF, width=50, textvariable=self.man)
self.manE.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.mpnF = Frame(self.searchLeftF)
self.mpnF.pack(side=TOP, anchor=W)
self.mpnL = Label(self.mpnF,
text='ManufacturerPartNumber',
width=self.searchLabelWidth,
anchor=W,
justify=LEFT)
self.mpnL.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.mpn = StringVar()
self.mpnE = Entry(self.mpnF, width=50, textvariable=self.mpn)
self.mpnE.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.spnF = Frame(self.searchLeftF)
self.spnF.pack(side=TOP, anchor=W)
self.spnL = Label(self.spnF,
text='DigiKeyPartNumber',
width=self.searchLabelWidth,
anchor=W,
justify=LEFT)
self.spnL.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.spn = StringVar()
self.spnE = Entry(self.spnF, width=50, textvariable=self.spn)
self.spnE.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.descF = Frame(self.searchLeftF)
self.descF.pack(side=TOP, anchor=W)
self.descL = Label(self.descF,
text='ProductDescription',
width=self.searchLabelWidth,
anchor=W,
justify=LEFT)
self.descL.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.desc = StringVar()
self.descE = Entry(self.descF, width=50, textvariable=self.desc)
self.descE.pack(side=LEFT, fill=X, expand=YES, pady=4)
self.descE.focus_force()
self.findF = Frame(self.searchLeftF)
self.findF.pack(side=TOP, anchor=E)
self.findB = ttk.Button(self.findF,
text="Find",
width=12,
command=lambda event=None: self.do_find(event))
self.findB.pack(side=LEFT, pady=4)
self.clearB = ttk.Button(self.findF,
text="Clear",
width=6,
command=self.on_clear_search)
self.clearB.pack(side=LEFT, pady=4)
self.partsLF = LabelFrame(self, text="Found Components")
self.partsLF.pack(side=TOP, fill=X, expand=YES, pady=4, padx=4)
self.partsF = Frame(self.partsLF)
self.partsF.pack(side=TOP, pady=4, padx=4)
# change treeview for search here
self.partsTV = Treeview(self.partsF,
selectmode=BROWSE,
show='tree headings',
columns=self.column_id)
self.partsTV.bind('<Double-Button-1>', self.on_edit_item)
self.partsTV.bind('<<TreeviewSelect>>', self.fieldChanged)
self.partsTV.bind('<Escape>', self.clearSelection)
self.partsTV.bind('<MouseWheel>', self.mousewheel)
self.partsTV.bind('<Button-4>', self.mousewheel)
self.partsTV.bind('<Button-5>', self.mousewheel)
vcmd = (self.register(self.validateEntry), '%P')
self.editfield = ttk.Entry(self.partsTV,
validate='key',
validatecommand=vcmd)
self.editfield.bind('<Return>', self.updateField)
self.editfield.bind('<Escape>', self.clearSelection)
self.partsTV.bind('<Control-c>', self.on_copy_element)
self.partsTV.column("#0", minwidth=0, width=18, stretch=NO)
for t in self.column_id:
self.partsTV.heading(t, text=Config().parameter[t])
self.partsTV.column('Category', width=60)
self.scrollbar = Scrollbar(self.partsF,
orient='vertical',
command=self.partsTV.yview)
self.scrollbar.pack(side=RIGHT, fill=Y, expand=YES, anchor=E)
self.partsTV.configure(yscroll=self.scrollbar.set)
self.scrollbar.config(command=self.yview)
self.partsTV.pack(side=TOP, anchor=W, fill=X, expand=YES)
self.partsTV.delete(*self.partsTV.get_children())
# end change of treeview
# change the following to menu item
#self.part_buttonF = Frame(self.partsLF)
#self.delete_partB = ttk.Button(self.partsLF, text="Delete Part from Database", command=self.on_delete,
#state=DISABLED)
#self.delete_partB.pack(side=RIGHT, anchor=W, expand=NO, pady=4, padx=6)
#self.partsB = ttk.Button(self.partsLF, text="Copy Selected To Part Find", command=self.on_copy, state=DISABLED)
#self.partsB.pack(side=RIGHT, anchor=W, expand=NO, pady=4, padx=6)
#self.part_buttonF.pack(side=BOTTOM)
# start remove vvv
#self.element_labelframe = LabelFrame(self, text="Modify Name/Value")
#self.element_labelframe.pack(side=TOP, fill=X, expand=YES, pady=4, padx=6)
#self.element_frame = Frame(self.element_labelframe)
#self.element_frame.pack(side=TOP)
#self.element_name = StringVar()
#self.element_label = Label(self.element_frame, textvariable=self.element_name, width=30, anchor=W, justify=LEFT)
#self.element_label.pack(side=LEFT, anchor=W, fill=X, expand=YES, pady=4)
#self.element_value = StringVar()
#self.element_entry = Entry(self.element_frame, width=50, textvariable=self.element_value)
#self.element_entry.pack(side=LEFT, fill=X, expand=YES, pady=4)
#self.default_color = self.element_entry.cget('background')
#self.element_update = ttk.Button(self.element_frame, text="Update", command=self.on_update_element,
#state=DISABLED)
#self.element_update.pack(side=LEFT, fill=X, expand=YES, pady=4)
#self.element_cancel = ttk.Button(self.element_frame, text="Cancel", command=self.on_clear_element,
#state=DISABLED)
#self.element_cancel.pack(side=LEFT, fill=X, expand=YES, pady=4)
# end remove ^^^
self.statusLF = LabelFrame(self, text="Status")
self.statusLF.pack(side=BOTTOM, fill=X, expand=YES, pady=4, padx=6)
self.statusF = Frame(self.statusLF)
self.statusF.pack(side=TOP, fill=X, expand=YES, padx=6)
self.status = self.StatusBar(self.statusF, self)
def validateEntry(self, P):
if (len(P) <= 120):
return True
else:
self.bell()
return False
# scroll bar event
def yview(self, *args):
if self.selectedField is not None:
self.editfield.place_forget()
self.selectedField = None
self.partsTV.yview(*args)
# mousewheel and button4/5 event
def mousewheel(self, event):
if self.selectedField is not None:
self.editfield.place_forget()
self.selectedField = None
# escape event in treeview or editfield
def clearSelection(self, event):
self.editfield.place_forget()
self.selectedField = None
self.partsTV.selection_remove(self.partsTV.selection())
self.status.set("")
# double button event
def on_edit_item(self, event):
if self.partsTV.parent(self.partsTV.selection()
) == '': # testing should not edit a parent
self.selectedField = None
return
if (self.partsTV.identify_region(event.x, event.y) == 'cell'):
self.selectedField = self.partsTV.identify_row(event.y)
x, y, width, height = self.partsTV.bbox(self.selectedField, '#2')
v = self.partsTV.set(self.selectedField, 1)
self.editfield.pack()
self.editfield.delete(0, len(self.editfield.get()))
self.editfield.insert(0, v)
self.editfield.selection_range(0, 'end')
self.editfield.focus_force()
self.editfield.place(x=x, y=y, width=width, height=height)
# find button event
def on_find(self):
category = self.cat.get()
search_list = []
col_list = []
search_str = self.man.get()
if not (validate(search_str)):
raise Exception("Invalid Manufacture Name")
search_list.append(search_str)
col_list.append(Config().parameter['ManufacturerName'])
search_str = self.mpn.get()
if not (validate(search_str)):
raise Exception("Invalid Manufacture Part Number")
search_list.append(search_str)
col_list.append(Config().parameter['ManufacturerPartNumber'])
search_str = self.spn.get()
if not (validate(search_str)):
raise Exception("Invalid Supplier Part Number")
search_list.append(search_str)
col_list.append(Config().parameter['DigiKeyPartNumber'])
search_str = self.desc.get().split()
if not (validate(search_str)):
raise Exception("Invalid Description")
search_list += search_str
col_list.append(Config().parameter['ProductDescription'])
select = "SELECT * FROM `" + Config().loaded_db.name + "`."
where = "WHERE"
like = ""
i = 0
for item in search_list:
if len(item) > 0:
item = item.replace('%', '\\%')
item = item.replace('"', '')
item = item.replace("'", "")
if i < 3:
like += where + " `" + col_list[
i] + "` LIKE '" + item + "%'"
else:
like += where + " (`" + col_list[i] + "` LIKE '" + item + "%' OR `" + \
col_list[i] + "` LIKE '% " + item + "%')"
where = " AND"
i = i + 1 if (i < 3) else i
self.partsTV.delete(*self.partsTV.get_children())
count = 0
if category == "All":
for table in Config().tables:
qry = select + "`" + table + "` " + like
result = Config().loaded_db.query(qry)
for record in result:
v = []
spn = record[Config().parameter['DigiKeyPartNumber']]
count += 1
for id in self.column_id:
if id == 'Category':
v.append(table)
else:
v.append(record[Config().parameter[id]])
id = self.partsTV.insert('',
'end',
iid=spn,
text=spn,
values=v)
for params in record:
if record[params] is not None:
self.partsTV.insert(id,
'end',
text=spn,
values=(params,
record[params]))
else:
qry = select + "`" + category + "` " + like
result = Config().loaded_db.query(qry)
for record in result:
v = []
count += 1
spn = record[Config().parameter['DigiKeyPartNumber']]
for id in self.column_id:
if id == 'Category':
v.append(category)
else:
v.append(record[Config().parameter[id]])
id = self.partsTV.insert('',
'end',
iid=spn,
text=spn,
values=v)
for params in record:
if record[params] is not None:
self.partsTV.insert(id,
'end',
text=spn,
values=(params, record[params]))
self.status.set(("No" if count == 0 else str(count)) + " items found")
# return event
def updateField(self, event):
value = self.editfield.get()
self.editfield.place_forget()
name = self.partsTV.item(self.selectedField, "text")
if not validate(value):
self.status.seterror("Invalid value, must not have quotes")
return
self.partsTV.set(self.selectedField, "#2", value)
key = self.partsTV.set(self.selectedField, "#1")
self.editfield.place_forget()
element_parent = self.partsTV.parent(self.selectedField)
table_name = self.partsTV.item(
element_parent, "values")[self.column_id.index('Category')]
part_number = self.partsTV.item(
element_parent,
"values")[self.column_id.index('DigiKeyPartNumber')]
set_param = "SET `" + key + "` = '" + value + "' "
where = "WHERE `" + Config(
).parameter['DigiKeyPartNumber'] + "` = '" + part_number + "'"
qry = "UPDATE `" + Config(
).loaded_db.name + "`.`" + table_name + "` " + set_param + where
print(qry)
try:
Config().loaded_db.query(qry)
except Exception as e:
self.status.seterror("Database query failed: %s", e)
return
self.status.set("Changed " + key + " to " + value + " for part " +
part_number + ".")
self.partsTV.see(self.selectedField)
# clear button in search frame
def on_clear_search(self):
self.man.set("")
self.mpn.set("")
self.spn.set("")
self.desc.set("")
self.cat.set("All")
self.category_option.set("All")
self.partsTV.delete(*self.partsTV.get_children())
def do_flash(self):
current_color = self.element_entry.cget("background")
if current_color == self.default_color:
self.element_entry.config(background="red")
else:
self.element_entry.config(background=self.default_color)
return
self.after(250, self.do_flash)
# category option menu
def on_category(self, value):
self.catE.config(state=NORMAL)
self.cat.set(value)
self.catE.config(state=DISABLED)
#def on_copy(self):
#selected = self.partsTV.selection()[0]
#key = self.partsTV.item(selected, "values")[self.column_id.index('DigiKeyPartNumber')]
#self.app_window.part_num_string.set(key)
#self.status.set("Part Number '" + key + "' copied to Part Find")
# Edit -> Delete menu
def on_delete(self):
selected = self.partsTV.selection()[0]
key = self.partsTV.item(
selected, "values")[self.column_id.index('DigiKeyPartNumber')]
table = self.partsTV.item(selected,
"values")[self.column_id.index('Category')]
if messagebox.askokcancel(
"Delete", "Click OK if you really want to delete '" + key +
"' from database?"):
Config().loaded_db.query("DELETE FROM `" + table + "` WHERE `" +
Config().parameter['DigiKeyPartNumber'] +
"` = '" + key + "'")
self.status.set("Part Number '" + key + "' deleted from database")
# treeview select event
def fieldChanged(self, event):
selected = self.partsTV.selection()
if len(selected) > 0:
self.copySourcesMenu.entryconfig(self.partnumber_index,
state=NORMAL)
self.copySourcesMenu.entryconfig(self.allParameters_index,
state=NORMAL)
else:
self.copySourcesMenu.entryconfig(self.partnumber_index,
state=DISABLED)
self.copySourcesMenu.entryconfig(self.allParameters_index,
state=DISABLED)
return
if self.partsTV.parent(selected) == '':
self.copySourcesMenu.entryconfig(self.selectedParameter_index,
state=DISABLED)
else:
self.copySourcesMenu.entryconfig(self.selectedParameter_index,
state=NORMAL)
if selected != self.selectedField:
self.editfield.place_forget()
self.selectedField = None
def on_copy_parameters(self):
selected = self.partsTV.selection()
if len(selected) == 0 or self.partsTV.parent(selected) == '':
return
try:
property = self.partsTV.item(selected, "values")
self.parent.clipboard_clear()
self.parent.clipboard_append(property[0] + '\t' + property[1])
self.parent.update()
self.status.set(property[0] + ' ' + property[1] +
" copied to clipboard")
except Exception as e:
pass
def on_copy_partnumber(self):
selected = self.partsTV.selection()
if len(selected) == 0 or self.partsTV.parent(selected) == '':
return
try:
if self.partsTV.parent(selected) != '':
selected = self.partsTV.parent(selected)
partnumber = self.partsTV.item(
selected, "values")[self.column_id.index('DigiKeyPartNumber')]
self.parent.clipboard_clear()
self.parent.clipboard_append(partnumber)
self.parent.update()
self.status.set(" '" + partnumber + "' copied to clipboard")
except Exception as e:
pass
def on_copy_all_parameters(self):
selected = self.partsTV.selection()
if len(selected) == 0:
return
try:
if self.partsTV.parent(selected) != '':
selected = self.partsTV.parent(selected)
partnumber = self.partsTV.item(
selected, "values")[self.column_id.index('DigiKeyPartNumber')]
elements = self.partsTV.get_children(selected)
self.parent.clipboard_clear()
self.parent.clipboard_clear()
for i in elements:
element = self.partsTV.item(i, "values")
self.parent.clipboard_append(element[0] + "\t" + element[1] +
"\n")
self.parent.update()
self.status.set("All properties of " + partnumber +
" copied to clipboard")
except Exception as e:
pass
# deprecate
def on_copy_element(self, event):
try:
selected = self.partsTV.selection()[0]
if self.partsTV.parent(selected) == '':
partnumber = self.partsTV.item
elements = self.partsTV.get_children(selected)
self.parent.clipboard_clear()
for i in elements:
element = self.partsTV.item(i, "values")
self.parent.clipboard_append(element[0] + "\t" +
element[1] + "\n")
self.parent.update()
self.status.set("All properties of " +
self.partsTV.item(selected, "values")[3] +
" copied to clipboard")
else:
key = self.partsTV.item(selected, "values")[0]
val = self.partsTV.item(selected, "values")[1]
self.parent.clipboard_clear()
self.parent.clipboard_append(val)
self.parent.update()
self.status.set(key + " '" + val + "' copied to clipboard")
except Exception as e:
pass
def do_find(self, event):
try:
self.on_find()
except Exception as e:
self.status.seterror(e)
class ElementListWidget(Frame):
def __init__(self, parent, label, columns, showError):
Frame.__init__(self, parent)
self.showError = showError
self.columnconfigure(0, weight = 1)
self.rowconfigure(1, weight = 1)
# Название таблицы
self.titleLabel = Label(self, text = label)
self.titleLabel.grid(column = 0, row = 0, sticky = W + E)
# Таблица значений
columns = ("Метка", "№") + columns
self.tree = Treeview(self, columns = columns, displaycolumns = columns,
selectmode = "browse")
self.tree.grid(column = 0, row = 1, sticky = W + N + E + S)
# Настраиваем внешний вид таблицы (первые колонки)
self.tree.column("#0", width = 0, stretch = 0) # Прячем колонку с иконкой
self.tree.column( columns[0], anchor = W, width = 150)
self.tree.heading(columns[0], anchor = W, text = columns[0])
self.tree.column( columns[1], anchor = E, width = 80)
self.tree.heading(columns[1], anchor = E, text = columns[1])
self.tree.bind("<<TreeviewSelect>>", self.onSelectionChanged)
# Панель с кнопками
self.buttonPanel = Frame(self)
self.buttonPanel.grid(column = 0, row = 2, sticky = W + E)
self.buttonPanel.columnconfigure(0, weight = 1)
self.buttonPanel.columnconfigure(3, minsize = emptySpaceSize, weight = 0)
self.buttonPanel.columnconfigure(6, minsize = emptySpaceSize, weight = 0)
self.buttonPanel.columnconfigure(9, weight = 1)
# Кнопки добавления/удаления элемента
self.buttonAdd = Button(self.buttonPanel, text = "+", width = 3,
command = self.onButtonAddClicked)
self.buttonAdd.grid(column = 1, row = 0)
self.buttonRemove = Button(self.buttonPanel, text = "-", width = 3, state = DISABLED,
command = self.onButtonRemoveClicked)
self.buttonRemove.grid(column = 2, row = 0)
# Кнопки перемещения элемента
self.buttonUp = Button(self.buttonPanel, text = "↑", width = 3, state = DISABLED,
command = self.onButtonUpClicked)
self.buttonUp.grid(column = 4, row = 0)
self.buttonDown = Button(self.buttonPanel, text = "↓", width = 3, state = DISABLED,
command = self.onButtonDownClicked)
self.buttonDown.grid(column = 5, row = 0)
# Кнопки применить/отменить (для выбранного элемента)
self.buttonCancel = Button(self.buttonPanel, text = "✗", width = 3,
command = self.updateSelectedFrame)
self.buttonCancel.grid(column = 7, row = 0)
self.buttonApply = Button(self.buttonPanel, text = "✓", width = 3,
command = self.onButtonApplyClicked)
self.buttonApply.grid(column = 8, row = 0)
# Редактирование выделенного элемента
self.i = StringVar()
self.label = (StringVar(), StringVar())
self.selectedFrame = Frame(self)
self.selectedFrame.grid(column = 0, row = 3, sticky = W + E)
# Номер
Label(self.selectedFrame, text = "№:") \
.grid(column = 0, row = 0)
Label(self.selectedFrame, textvariable = self.i, width = 3, justify = RIGHT) \
.grid(column = 1, row = 0)
# Пустое пространство
self.selectedFrame.columnconfigure(2, minsize = emptySpaceSize, weight = 0)
# Метка
Entry(self.selectedFrame, textvariable = self.label[0]) \
.grid(column = 3, row = 0, sticky = W + E)
Entry(self.selectedFrame, textvariable = self.label[1], bg = defaultValueBG) \
.grid(column = 4, row = 0, sticky = W + E)
# Виджет для элементов классов-потомков
self.detailFrame = Frame(self.selectedFrame)
self.detailFrame.grid(column = 3, row = 1, columnspan = 2, sticky = W + N + E + S)
self.selectedFrame.columnconfigure(3, weight = 1)
self.selectedFrame.columnconfigure(4, weight = 1)
self.selectedFrame.rowconfigure(1, weight = 1)
def onButtonUpClicked(self):
item = self.selectedItem()
if item is None: return
prev = self.tree.prev(item)
if prev != "":
parent, index = self.tree.parent(item), self.tree.index(item)
self.tree.move(item, parent, index - 1)
# Корректируем номера элементов
self.tree.set(item, "№", index - 1)
self.tree.set(prev, "№", index)
self.updateSelectedFrame(item)
def onButtonDownClicked(self):
item = self.selectedItem()
if item is None: return
next = self.tree.next(item)
if next != "":
parent, index = self.tree.parent(item), self.tree.index(item)
self.tree.move(item, parent, index + 1)
# Корректируем номера элементов
self.tree.set(item, "№", index + 1)
self.tree.set(next, "№", index)
self.updateSelectedFrame(item)
def onButtonAddClicked(self):
pass
def onButtonRemoveClicked(self):
item = self.selectedItem()
if item is None: return
next = self.tree.next(item)
self.tree.delete(item)
while next != "":
i = int(self.tree.set(next, "№"))
self.tree.set(next, "№", i - 1)
next = self.tree.next(next)
self.onSelectionChanged()
def onButtonApplyClicked(self, item = None):
if item is None: item = self.selectedItem()
if item is None: return None
label = self.label[0].get()
self.tree.set(item, "Метка", label)
return item
def onSelectionChanged(self, event = None):
item = self.selectedItem()
# Обновляем состояние кнопок
state = DISABLED if item is None else NORMAL
for x in (self.buttonRemove, self.buttonUp, self.buttonDown):
x["state"] = state
self.updateSelectedFrame(item)
def selectedItem(self):
selection = self.tree.selection()
return None if type(selection) == type("") else selection[0]
def clear(self):
for item in self.tree.get_children():
self.tree.delete(item)
def updateSelectedFrame(self, item = None, values = None):
if item is None: item = self.selectedItem()
values = None
if item is None:
i = ""
label = ""
else:
if values is None: values = self.tree.set(item)
i = values["№"]
label = values["Метка"]
self.i.set(i)
self.label[0].set(label)
return (item, values)
def addElement(self, values):
self.tree.insert(parent = "", index = END, values = values)
def setDefaultElement(self, label):
self.label[1].set(label)
def elementsCount(self):
return len(self.tree.get_children())
def elements(self, transform):
return [ transform(item) for item in self.tree.get_children() ]
class AnnotationGUI(BasicGUI, FileAnnotator):
def __init__(self, master=None):
BasicGUI.__init__(self, master=master)
FileAnnotator.__init__(self)
self.vert_panes = PanedWindow(master, bg='#BF98A0')
self.vert_panes.pack(fill=BOTH, expand=1)
# Left
style = ttk.Style()
style.configure('TButton', foreground='black', background='#B0D7FF')
self.onto_viewer = Treeview(self.vert_panes, selectmode='browse', style='TButton')
self.vert_panes.add(self.onto_viewer)
self.onto_viewer_scroll_bar = Scrollbar(self.vert_panes, orient='vertical', command=self.onto_viewer.yview)
self.vert_panes.add(self.onto_viewer_scroll_bar)
self.onto_viewer.configure(yscrollcommand=self.onto_viewer_scroll_bar.set)
self.onto_viewer.bind("<Double-1>", self.expand_onto_viewer)
# Right
self.horz_panes = PanedWindow(self.vert_panes, orient=VERTICAL, bg='#BF98A0')
self.vert_panes.add(self.horz_panes)
# Top
self.text_pad = ScrolledText(self.horz_panes, bg='#EAE8FF')
self.horz_panes.add(self.text_pad)
# Bottom
self.term_viewer = ScrolledText(self.horz_panes, bg='#B0D7FF')
self.horz_panes.add(self.term_viewer)
ontology_menu_commands = [('Load ontology from file', self.load_ontology_command)]
self.add_menu_to_main_menu('Ontology', ontology_menu_commands)
self.v = StringVar()
def load_ontology_command(self, file=None, onto_name=None, roots=None):
if file is None:
file = filedialog.askopenfile(parent=self.master, mode='rb', title='Select a file')
if file is not None:
if onto_name is None:
onto_name = simpledialog.askstring('Name', 'Enter a name for this ontology')
if roots is None:
roots = simpledialog.askstring('Roots', 'Enter the names of the roots for this ontology').split(',')
print('Loading {}'.format(file))
self.ontos[onto_name] = {'onto': obonet.read_obo(file), 'roots': roots}
self.display_onto(onto_name)
self.ontos[onto_name]['id_to_name'] = {id_: data['name']
for id_, data in self.ontos[onto_name]['onto'].nodes(data=True)}
self.ontos[onto_name]['name_to_id'] = {data['name']: id_
for id_, data in self.ontos[onto_name]['onto'].nodes(data=True)}
def display_term(self, term, onto_name):
term_data = self.ontos[onto_name]['onto'].node[self.ontos[onto_name]['name_to_id'][term]]
self.term_viewer.configure(state='normal')
self.term_viewer.delete('1.0', END)
for label, value in term_data.items():
self.term_viewer.insert(END, '{}:\n\t{}\n'.format(label, value))
self.term_viewer.configure(state='disabled')
def display_onto(self, onto_name):
name_id = self.onto_viewer.insert('', END, text=onto_name, value=onto_name)
for root in self.ontos[onto_name]['roots']:
self.onto_viewer.insert(name_id, END, text=root, value=onto_name)
def expand_onto_viewer(self, _):
iid = self.onto_viewer.selection()[0]
term = self.onto_viewer.item(iid, 'text')
onto_name = self.onto_viewer.item(iid, 'value')[0]
self.display_term(term, onto_name)
if self.onto_viewer.parent(iid) != '':
subterms = get_subterms(term, self.ontos[onto_name]['onto'],
self.ontos[onto_name]['id_to_name'],
self.ontos[onto_name]['name_to_id'])
for s in subterms:
self.onto_viewer.insert(iid, END, text=s, value=onto_name)
def annotate_text(self, _):
self.text_pad.tag_add()
def run(self, preload_annotation_file=None, preload_ontology=None):
self.vert_panes.pack()
self.master.state('zoomed')
self.master.configure(bg='black')
if len(preload_ontology) == 3:
self.load_ontology_command(file=preload_ontology['File'],
onto_name=preload_ontology['Name'], roots=preload_ontology['Roots'])
if len(preload_annotation_file) == 1:
self.open_command(file_name=preload_annotation_file['File'])
self.master.mainloop()
class ListOfData(Labelframe):
"""Contains list of student in database"""
def __init__(self, window, base, **kwargs):
Labelframe.__init__(self, window, **kwargs)
self.base = base
self.notebook = Notebook(self)
self.notebook.grid(row=0, column=0, padx=5, pady=5)
self.student = Frame(self.notebook)
self.student.grid(row=0, column=0)
self.student_list = Treeview(self.student,
height=24,
columns=("name", "pesel"),
displaycolumns="name")
self.student_list.heading('name', text="Nazwisko i imię", anchor='w')
self.student_list.column('name', width=240)
self.student_list['show'] = 'headings'
self.student_list.grid(row=0, column=0)
self.button = Button(self.student,
text="Usuń",
command=self.delete_from_student_list)
self.button.grid(row=1, column=0)
self.staff_meeting = Frame(self.notebook)
self.staff_meeting.grid(row=0, column=0)
self.table = Treeview(self.staff_meeting,
height=24,
columns=("name", "id", "student_id"),
displaycolumns="name")
self.table.heading('name', text='Zespoły', anchor='w')
self.table.column('name', width=235)
self.table.column('#0', stretch=0, width=10)
self.table.grid(row=0, column=0)
self.delete_staffmeeting = Button(
self.staff_meeting,
text="Usuń wpis",
command=self.delete_from_staffmeeting)
self.delete_staffmeeting.grid(row=1, column=0)
self.notebook.add(self.student, text="Dzieci")
self.notebook.add(self.staff_meeting, text="Zespoły")
def get_students(self):
return self.base.get_dict_of_students()
def get_pesel_from_name(self, name):
students = self.get_students()
for pesel in students:
if students[pesel] == name:
return pesel
def fill_student_list(self):
self.student_list.delete(*self.student_list.get_children())
if not self.get_students():
return
for student, pesel in zip(self.get_students().values(),
self.get_students().keys()):
self.student_list.insert("", 'end', values=(student, pesel))
def delete_from_student_list(self):
selected_item = self.student_list.selection()
pesel = str(self.student_list.item(selected_item)['values'][1])
if len(pesel) < 11:
pesel = "0" + pesel
self.base.delete_student(pesel)
self.fill_student_list()
self.fill_staffmeeting_list()
def fill_staffmeeting_list(self):
self.table.delete(*self.table.get_children())
staff_meeting = StaffMeeting.select()
meeting_in_table = {} # {value: iid}
for i in staff_meeting:
if i.date not in meeting_in_table.keys():
meeting_in_table[i.date] = self.table.insert("",
'end',
values=(i.date, ))
actual_iid = self.table.insert(
meeting_in_table[i.date],
'end',
values=(self.base.get_student_name(i.student), ))
self.table.set(actual_iid, column="id", value=i.id)
self.table.set(actual_iid,
column="student_id",
value=i.student)
else:
actual_iid = self.table.insert(
meeting_in_table[i.date],
'end',
values=(self.base.get_student_name(i.student), ))
self.table.set(actual_iid, column="id", value=i[0])
self.table.set(actual_iid, column="student_id", value=i[20])
for idd in meeting_in_table.values():
if not self.table.parent(idd):
self.table.item(idd, open=True)
def delete_from_staffmeeting(self):
selected_item = self.table.selection()
staffmeeting_id = self.table.item(selected_item)['values'][1]
StaffMeeting.get(StaffMeeting.id == staffmeeting_id).delete_instance()
self.fill_staffmeeting_list()
class Window:
def fillTree(self,path, parent, list):
for file in os.listdir(path):
abspath = os.path.join(path,file)
color = ""
treelist = None
for mini in list:
if abspath in mini:
color = 'red'
treelist = mini
else:
for lk in mini:
if abspath in lk:
color = 'purple'
child = None
if color == 'red':
child = self.tree.insert(parent,'end',text=file,open=False,tags=(abspath,'red',str(treelist)),)
elif color == 'purple':
child = self.tree.insert(parent,'end',text=file,open=False,tags=(abspath,'purple'))
else:
child = self.tree.insert(parent,'end',text=file,open=False,tags=(abspath,'white'))
if(os.path.isdir(abspath)):
self.tree.insert(child,'end',text='',open=False)
def __init__(self,list,dirlist):
self.root = Tk()
self.root.wm_title("Duplicate_Files")
self.min = None
self.list = list
self.root.geometry('600x600+0+0')
self.tree = Treeview(self.root ,height=15)
self.tree.pack(expand='yes',fill='both')
self.tree.heading('#0',text="files")
self.tree.tag_configure('red',foreground='red')
self.tree.tag_configure('purple',foreground='#cc00ff')
self.tree.bind("<Double-1>",self.onDoubleClick)
self.tree.bind("<<TreeviewOpen>>",self.onOpen)
self.tree.bind("<<TreeviewClose>>",self.onClose)
for path in dirlist:
branch = self.tree.insert('','end',text=path,open=True,tags=(path,'white'))
self.fillTree(path,branch,list)
self.root.mainloop()
def onDoubleClick(self,event):
item = self.tree.selection()[0]
print ("clicked" + str(self.tree.item(item,'tags')[0]))
if str(self.tree.item(item,'tags')[1]) == "red":
list_of_files = ast.literal_eval(str(self.tree.item(item,'tags')[2]))
if self.min != None:
if self.min.mini.winfo_exists():
self.min.mini.destroy()
self.min = MiniWindow(self.root,list_of_files)
def onOpen(self,event):
item = self.tree.selection()[0]
if self.tree.parent(item) != '':
if len(self.tree.get_children(item))>0:
self.tree.delete(self.tree.get_children(item))
abspath = str(self.tree.item(item,'tags')[0])
if(os.path.isdir(abspath)):
self.fillTree(abspath, item,self.list)
def onClose(self,event):
item = self.tree.selection()[0]
if self.tree.parent(item) != '':
if len(self.tree.get_children(item))>0:
self.tree.delete(self.tree.get_children(item))
