def init_chipseq_gui(self):
self.clear()
logo = Label(self, image=self.logoimage)
logo.grid(row=0, column=0)
note = Notebook(self)
main = Frame(note)
motif_scan = Frame(note)
topkmer = Frame(note)
kmer_query = Frame(note)
note.add(main, text="Chip-Seq Main")
note.add(motif_scan, text="Motif Scan")
note.add(topkmer, text='Top kmer')
note.add(kmer_query, text='Kmer query')
self.init_chipseq_gui_tabmain(main)
self.init_motifscan_guitab(motif_scan)
self.init_topkmer_guitab(topkmer)
self.init_kmerquery_guitab(kmer_query)
note.grid(row=1, column=0)
self.master.grid_columnconfigure(0, weight=1)
self.master.grid_rowconfigure(0, weight=1)
self.master.grid_rowconfigure(1, weight=5)
def init_window(self):
self.parent.title("SupMold: SpringCalc")
self.grid(column=0, row=0, sticky="nwse")
mainFrame = Frame(self, relief='raised', borderwidth=1)
mainFrame.grid(column=0, row=0, sticky='nsew')
closeButton = Button(mainFrame, text='Cerrar', command=self.appQuit)
closeButton.grid(column=0, row=3, padx=5, pady=5)
nb = Notebook(mainFrame)
tab1 = Frame(nb)
tab2 = Frame(nb)
tab3 = Frame(nb)
nb.add(tab1, text="Compresión")
nb.add(tab2, text="Extensión")
nb.add(tab3, text="Torsión")
nb.grid(column=0, row=1, sticky='nsew', padx=5, pady=5)
msg = consoleFrame(mainFrame, 'Mensages')
dataB = resource_path('wires.db')
if not os.path.isfile(dataB):
self.centerWindow()
messagebox.showerror(
"ERROR", "Base de datos {} inaccesible. "
"Favor verificar permisos de lectura o "
"ubicación de la misma".format(dataB))
return
self.sub1 = subWindow(tab1, Spring(database=dataB))
self.sub1.init_widgets()
self.sub2 = subWindow2(tab2, eSpring(database=dataB))
self.sub2.init_widgets()
self.sub3 = subWindow3(tab3, tSpring(database=dataB))
self.sub3.init_widgets()
self.centerWindow()
nb.bind("<<NotebookTabChanged>>", self.tabChangedEvent)
def setupSelectedModuleConfig(self, selectedModuleFileName):
groupDesctiptionNotebook = Notebook(self)
groupDesctiptionNotebook.grid(row=3, column=0, columnspan=4, sticky=E + W)
groupNameList = jsonHelper.getAllGroups()
groupDescriptionFrameList = []
for groupName in groupNameList:
groupDescriptionFrame = GroupDescriptionCheckboxFrame(groupDesctiptionNotebook, groupName)
modulesForGroupList = jsonHelper.getModuleListForGroup(groupName)
isEnabled = selectedModuleFileName in modulesForGroupList
groupDescriptionFrame.enableCheckButtonInt.set(isEnabled)
groupDescriptionFrameList.append(groupDescriptionFrame)
groupDescriptionFrame.pack(fill=BOTH, expand=True)
groupDesctiptionNotebook.add(groupDescriptionFrame, text=groupName)
Button(
self,
text="Apply & Close",
relief=RAISED,
command=lambda: self.applyModuleButtonPressed(selectedModuleFileName, groupDescriptionFrameList),
).grid(row=4, column=1, columnspan=1, sticky=S + E)
def machineLoadButtonPressed(self, loadButton):
filePath = filedialog.askopenfilename(filetypes=[('Python file','*.py')])
if filePath != '':
components = filePath.split('/')
fileName = components[-1]
if os.path.isfile(os.getcwd()+'/machineConfig/'+fileName) == False:
# [isValid, errorString] = MachineConfigTest(filePath).runTests() //TODO
isValid = 1
if isValid:
loadButton.config(text=filePath)
groupDesctiptionNotebook = Notebook(self)
groupDesctiptionNotebook.grid(row=2, column=0, columnspan=4, sticky=E+W)
tabNameList = jsonHelper.getAllGroups()
groupDescriptionFrameList = [];
for tabName in tabNameList:
groupDescriptionFrame = GroupDescriptionCheckboxFrame(groupDesctiptionNotebook, tabName)
groupDescriptionFrameList.append(groupDescriptionFrame)
groupDescriptionFrame.pack(fill=BOTH, expand=True)
groupDesctiptionNotebook.add(groupDescriptionFrame, text=tabName)
Button(self, text='Apply & Close', relief=RAISED, command=lambda: self.applyMachineButtonPressed(filePath, groupDescriptionFrameList)).grid(row=3,column=1,columnspan=1,sticky=S+E)
else:
messagebox.showinfo("Error", errorString)
else:
messagebox.showinfo("Error", "File already exists in machineConfig directory: " + fileName)
def __init__(self,fen):
tkinter.Frame.__init__(self,bg = "#%02x%02x%02x" % (71,86,82))
self.grid()
#Header
self.title = tkinter.Label(self, text="Le-Mayzeur", fg="white", font=("bauhaus 93",22), bg = "#%02x%02x%02x" % (71,86,82))
self.title.grid(row=0, column = 0)
#Body
onglet=Notebook(self, width=380, height=380)
self.convert=tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
self.iso=tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
self.shutdown=tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
self.bootable=tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
onglet.add(self.iso,text='ISO file')
onglet.add(self.convert,text='Convert')
onglet.add(self.shutdown, text="Shutdown")
onglet.add(self.bootable,text='Boot drive')
onglet.grid(row=2, column=0)
#Links --. inherit classes
Convert.__init__(self)
Shutd.__init__(self,fen)
IsoFile.__init__(self,fen)
Bootable.__init__(self)
#footer
self.footer = tkinter.Label(fen, width=480, bg="#%02x%02x%02x" % (71,86,82))
self.footer.place(x=0,y=447)
self.footer = tkinter.Label(fen, text="*****@*****.**", fg="white", bg="#%02x%02x%02x" % (71,86,82))
self.footer.place(x=130,y=447)
def main():
"""Main function of the program."""
main = tk.Tk()
# Add Title
main.title("Space Craft Creator")
# Disable Resizing
main.resizable(False, False)
data = Data()
spacecraft = Spacecraft(data)
notebook = Notebook(main)
spacecraft_tab = spacecraft.make_tab(notebook)
notebook.add(spacecraft_tab, text="Spacecraft")
for key, subsystem in spacecraft.subsections.items():
notebook.add(subsystem.make_tab(notebook), text=key)
notebook.add(spacecraft.sizes.make_tab(notebook), text="Sizes")
notebook.add(spacecraft.velocities.make_tab(notebook),
text="Velocity Profiles")
notebook.grid(column=0, row=0)
notebook.enable_traversal()
button = Button(main, text="Caclulate", command=spacecraft.calculate)
button.grid(column=0, row=1)
main.mainloop()
def __initialize_gui__(self):
notebook = Notebook(self.window)
notebook.grid(row=0, column=0, rowspan=14, columnspan=4, sticky=EW)
gmail_frame, nalanda_frame = Frame(notebook), Frame(notebook)
notebook.add(gmail_frame, text='Gmail')
notebook.add(nalanda_frame, text='Nalanda')
# GMAIL
Label(gmail_frame, text='Username:'******'W')
Label(gmail_frame, text='Password:'******'W')
Entry(gmail_frame, textvariable=self.username_variable, bd=5, relief=SUNKEN, width=30)\
.grid(row=0, columnspan=3, column=1)
Entry(gmail_frame, textvariable=self.password_variable, show='*', bd=5, relief=SUNKEN, width=30)\
.grid(row=1, columnspan=3, column=1)
self.submit_gmail_button = Button(gmail_frame, text='Submit', bd=5, relief=RAISED, width=10)
self.submit_gmail_button.grid(row=10, sticky=E, columnspan=4)
self.captcha_image = Label(gmail_frame, bd=5, relief=RAISED)
self.captcha_entry = Entry(gmail_frame, textvariable=self.captcha_variable, bd=5, relief=SUNKEN)
self.captcha_button = Button(gmail_frame, text='[R]', bd=2, relief=RAISED)
# NALANDA
Label(nalanda_frame, text='Username:'******'W')
Label(nalanda_frame, text='Password:'******'W')
Entry(nalanda_frame, textvariable=self.username_variable, bd=5, relief=SUNKEN, width=30) \
.grid(row=0, columnspan=3, column=1)
Entry(nalanda_frame, textvariable=self.password_variable, show='*', bd=5, relief=SUNKEN, width=30) \
.grid(row=1, columnspan=3, column=1)
self.submit_nalanda_button = Button(nalanda_frame, text='Submit', bd=5, relief=RAISED, width=10)
self.submit_nalanda_button.grid(row=10, sticky=E, columnspan=4)
# Attach the status bar
self.busy_status.grid(row=15, column=3, sticky=EW)
self.status_bar.grid(row=15, column=0, columnspan=3, sticky=EW)
self.update_status('Enter Nalanda Login Details.')
self.window.title('Authentication Window')
def notebook_init(self):
self.style.element_create('close', 'image', 'img_close',
('active', 'pressed', '!disabled', 'img_close_pressed'),
('active', '!disabled', 'img_close_mouse_over'))
self.style.layout('NotebookBtn', [('Notebook.client', {'sticky': 'nsew'})])
self.style.layout('NotebookBtn.Tab', [
('Notebook.tab', {'sticky': 'nsew', 'children': [
('Notebook.padding', {'side': 'top', 'sticky': 'nsew', 'children': [
('Notebook.focus', {'side': 'top', 'sticky': 'nsew', 'children': [
('Notebook.label', {'side': 'left', 'sticky': 'nsew'}),
('Notebook.close', {'side': 'right', 'sticky': 'nsew'})
]})
]})
]})
])
self.style.configure('NotebookBtn.Tab', padding=2, image='tab_doc')
self.style.map('NotebookBtn.Tab', background=[('selected', '#f0f0f0')])
self.root.bind_class('TNotebook', '<ButtonPress-1>', self.tab_btn_press, True)
self.root.bind_class('TNotebook', '<ButtonRelease-1>', self.tab_btn_release)
tabs = Notebook(self.root, style='NotebookBtn')
tabs.grid(column=0, row=1, sticky='nsew')
tabs.columnconfigure(0, weight=1)
tabs.rowconfigure(0, weight=1)
return tabs
def setupSelectedFilterType(self, selectedFilterFileName, filterType):
groupDesctiptionNotebook = Notebook(self)
groupDesctiptionNotebook.grid(row=3, column=0, columnspan=4, sticky=E + W)
groupNameList = jsonHelper.getAllGroups()
groupDescriptionFrameList = []
for groupName in groupNameList:
groupDescriptionFrame = GroupDescriptionCheckboxFrame(groupDesctiptionNotebook, groupName)
# get selected filters for groupname
selectedFilterList = []
if filterType == "Head":
selectedFilterList = jsonHelper.getHeadFiltersListForGroup(groupName)
else:
selectedFilterList = jsonHelper.getJawFiltersListForGroup(groupName)
isEnabled = selectedFilterFileName in selectedFilterList
groupDescriptionFrame.enableCheckButtonInt.set(isEnabled)
groupDescriptionFrameList.append(groupDescriptionFrame)
groupDescriptionFrame.pack(fill=BOTH, expand=True)
groupDesctiptionNotebook.add(groupDescriptionFrame, text=groupName)
Button(
self,
text="Apply & Close",
relief=RAISED,
command=lambda: self.applyFilterTypeButtonPressed(
selectedFilterFileName, groupDescriptionFrameList, filterType
),
).grid(row=4, column=1, columnspan=1, sticky=S + E)
def __initView(self):
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
tabControl = Notebook(self)
tabControl.grid(row=0, column=0, sticky='NSWE')
#################################################################################################
self.playsByWeekdayFrame = Frame(tabControl)
self.playsByWeekdayFrame.grid_columnconfigure(0, weight=1)
self.playsByWeekdayFrame.grid_rowconfigure(0, weight=1)
tabControl.add(self.playsByWeekdayFrame, text=PLAYS_BY_WEEKDAY)
#################################################################################################
self.playsByHourFrame = Frame(tabControl)
self.playsByHourFrame.grid_columnconfigure(0, weight=1)
self.playsByHourFrame.grid_rowconfigure(0, weight=1)
tabControl.add(self.playsByHourFrame, text=PLAYS_BY_HOUR)
#################################################################################################
self.topMusicUsageInAlbumFrame = Frame(tabControl)
self.topMusicUsageInAlbumFrame.grid_columnconfigure(0, weight=1)
self.topMusicUsageInAlbumFrame.grid_rowconfigure(0, weight=1)
tabControl.add(self.topMusicUsageInAlbumFrame, text=TOP_MUSIC_USAGE_IN_ALBUMS)
def init_selexseq_gui(self):
self.clear()
row_gen = NumGenerator()
logo = Label(self, image=self.logoimage)
logo.grid_columnconfigure(0, weight=1)
logo.grid(row=row_gen.get())
note = Notebook(self)
main = Frame(note)
motif_scan = Frame(note)
topkmer = Frame(note)
kmer_query = Frame(note)
note.add(main, text="SELEX-SEQ Main")
note.add(motif_scan, text="Motif Scan")
note.add(topkmer, text='Top kmer')
note.add(kmer_query, text='Kmer query')
self.init_selexseq_gui_tabmain_step0(main)
self.init_motifscan_guitab(motif_scan)
self.init_topkmer_guitab(topkmer)
self.init_kmerquery_guitab(kmer_query)
note.grid(row=row_gen.get(), column=0)
# self.columnconfigure(0,weight=1)
self.master.grid_columnconfigure(0, weight=1)
self.master.grid_rowconfigure(0, weight=1)
self.master.grid_rowconfigure(1, weight=5)
def _add_notebook_to_frame_grid(
cls,
frame_and_name: FrameAndName,
row: int,
column: int,
sticky: GridPositionEnum = GridPositionEnum.NONE) -> Notebook:
cls._debug(f'Add Notebook Grid Row [{row}] Column [{column}]')
notebook = Notebook(frame_and_name.frame)
notebook.grid(row=row, column=column, sticky=sticky.value)
return notebook
class SQLiteReader(Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.master.option_add('*tearOff', False)
self.master.title('SQLite Reader')
self.master.geometry('800x400+10+10')
self.grid(column=0, row=0, sticky=(N, W, E, S))
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(0, weight=1)
self.create_menu()
self.create_widget()
self.tabs = []
def create_widget(self):
self.tab_parent = Notebook(self)
self.tab_parent.grid(column=0, row=0, sticky=(N, W, S, E))
def create_menu(self):
self._menu = Menu(self.master)
self.master.config(menu=self._menu)
self.file_menu = Menu(self._menu)
self.file_menu.add_command(label='Open', command=self.open_database)
self.file_menu.add_command(label='Query', command=self.run_query, state='disabled')
self._menu.add_cascade(label='File', menu=self.file_menu)
self._menu.add_command(label='Reload', command=self.reload_current_table, state='disabled')
self._menu.add_command(label='Exit', command=self.master.destroy)
def open_database(self, new_folder=True):
for item in self.tab_parent.winfo_children():
item.destroy()
if new_folder:
self.file_name = filedialog.askopenfilename()
self.db = SQLiteConnector(self.file_name)
for idx, table in enumerate(self.db.tables):
new_tab = SQLTableFrame(self.tab_parent, table, self.db)
self.tab_parent.add(new_tab, text=table)
self.tab_query = SQLTableFrameQuery(self.tab_parent)
self.tab_parent.add(self.tab_query, text='queries')
self._menu.entryconfig('Reload', state='normal')
self.file_menu.entryconfig('Query', state='normal')
def reload_current_table(self):
if hasattr(self, 'query_window'):
self.query_window.destroy()
self.open_database(new_folder=False)
def run_query(self):
self.tab_parent.select(self.tab_query)
self.query_window = SQLQueryWindow(self.master, db=self.db, query_tab=self.tab_query)
class MainWindow:
def __init__(self):
self.adb = adb.bridge
config.global_config = load_config()
twocaptcha.key = config.global_config.twocaptchaKey
haoi.userstr = config.global_config.haoiUser
haoi.rebate = config.global_config.haoiRebate
self.window = Tk()
self.size = config.global_config.screenSize
self.window.title('Rise Of Kingdom Bot (v{})'.format(version))
self.window.geometry('{}x{}'.format(self.size[0], self.size[1]))
self.window.resizable(0, 0)
self.curr_frame = None
self.last_frame = None
self.setting_frame = None
self.notebook = Notebook(self.window, height=self.size[1] - 80)
# device = self.adb.get_device('127.0.0.1', 5585)
# mf = SelectedDeviceFrame(self.notebook, device, width=size[0], height=size[1])
# self.curr_frame = mf
# self.main_frame_list.append(mf)
# mf.grid(row=0, column=0, sticky=N + W)
# mf.grid_propagate(False)
main_frame = Frame(self.notebook,
width=self.size[0],
height=self.size[1])
dlf = DeviceListFrame(self.notebook,
main_frame,
width=self.size[0],
height=self.size[1])
sf = SettingFrame(self.notebook,
width=self.size[0],
height=self.size[1])
self.setting_frame = sf
sf.grid(row=0, column=0, sticky=N + W)
sf.grid_propagate(False)
self.notebook.add(dlf, text='Device List')
self.notebook.add(main_frame, text='Display Device')
self.notebook.add(sf, text='Setting')
self.notebook.grid(row=0, column=0, sticky=N + W, pady=(10, 0))
bf = BottomFrame(self.window, width=self.size[0], height=self.size[1])
bf.grid(row=1, column=0, sticky=N + W, padx=10, pady=(10, 0))
def run(self):
self.window.mainloop()
def filterTypeLoadButtonPressed(self, filePath,filterType):
groupDesctiptionNotebook = Notebook(self)
groupDesctiptionNotebook.grid(row=2, column=0, columnspan=4, sticky=E+W)
tabNameList = jsonHelper.getAllGroups()
groupDescriptionFrameList = [];
for tabName in tabNameList:
groupDescriptionFrame = GroupDescriptionCheckboxFrame(groupDesctiptionNotebook, tabName)
groupDescriptionFrameList.append(groupDescriptionFrame)
groupDescriptionFrame.pack(fill=BOTH, expand=True)
groupDesctiptionNotebook.add(groupDescriptionFrame, text=tabName)
Button(self, text='Apply & Close',relief=RAISED,command=lambda:self.applyFilterTypeButtonPressed(filePath, groupDescriptionFrameList, filterType)).grid(row=3,column=1,columnspan=1,sticky=S+E)
class baseInterface(Tk):
def __init__(self):
Tk.__init__(self)
self._controller = ArduinoController()
self._controller.nbLeds = 21
self._controller.clear()
self._notebook = Notebook(self)
self._notebook.grid(sticky=(E, W))
self.__modules = {}
self.__defaultSpeed = 60
self._updateSpeed = self.__defaultSpeed
self.protocol("WM_DELETE_WINDOW", self._handleClose)
self.__update()
def setSpeed(self, speed):
if 5 <= speed <= 500:
self._updateSpeed = speed
else:
self._updateSpeed = self.__defaultSpeed
def getSpeed(self):
return self._updateSpeed
def resetSpeed(self):
self._updateSpeed = self.__defaultSpeed
def registerModule(self, name, obj):
self.__modules[name] = obj(self)
self.__modules[name].linkController(self._controller)
self._notebook.add(self.__modules[name].mainFrame, text=name)
def _handleClose(self):
self._controller.clear()
self._controller.send()
self._controller.destroy()
self.destroy()
def _getCurrentTabName(self):
return self._notebook.tab(self._notebook.select(), "text")
def __update(self):
if len(self.__modules) > 0:
self.__modules[self._getCurrentTabName()].update()
self.after(self._updateSpeed, self.__update)
class EditSettingsPopup(object):
def __init__(self, overview, master):
self.top = Toplevel(master)
self.top.title("Settings")
self.master = master
self.overview = overview
self.nb = Notebook(self.top, width=500, height=330)
self.nb_t1 = Frame(self.top)
self.nb_t2 = Frame(self.top)
ex = [x.name for x in Exchange]
#general tab
self.t1_exchange = Combobox(self.nb_t1, values=ex, width=20)
#replace with old val
self.t1_exchange.set(ex[0])
Label(self.nb_t1, text="Default exchange:").grid(row=0,
column=0,
sticky="NEWS")
self.t1_exchange.grid(row=0, column=2, columnspan=1)
Label(self.nb_t1, text="Update interval(sec):").grid(row=1,
column=0,
sticky="NEWS")
self.t1_interval_var = StringVar()
self.t1_interval = Spinbox(self.nb_t1,
textvariable=self.t1_interval_var,
values=(3, 5, 10, 15, 30, 60, 120, 300),
width=20)
##replace with old val---set after making spinbox
self.t1_interval_var.set("15")
self.t1_interval.grid(row=1, column=2, columnspan=1)
self.nb.add(self.nb_t1, text="General")
self.nb.add(self.nb_t2, text="Sounds")
self.nb.grid(row=0, column=0, columnspan=3, rowspan=3, sticky="NEWS")
##center after packing
center(self.top, master)
def cleanup(self):
self.top.destroy()
def init_selexseq_gui(self):
self.clear()
self.logoimage = PhotoImage(file="GUIgraphics/logo.png")
self.logo = Label(self, image=self.logoimage)
self.logo.place(relx=0.5, rely=0.1, anchor="n")
note = Notebook()
self.notebook = note
main = Frame(note)
masker = Frame(note)
note.add(main, text = "SELEX-SEQ Main")
note.add(masker, text = "Masker")
self.init_selexseq_gui_tabmain_step0(main)
note.grid_rowconfigure(0, weight=1)
note.grid_columnconfigure(0, weight=1)
note.grid(row=0,column=0, sticky=N, pady=(250, 10))
class Controller(Tk):
"""
Controller Class:
- Serves as a hub for every page contained in the UI, allows for the flow of information between
pages
- Acts as the container for ContactsPage, and AddContactsPage by making use of ttk.Notebook
=== Public Attributes ===
notebook: Widget containing tabs; each page is assigned a tab, and can be navigated to easily
frames: Dictionary of all pages; allows for access of information across pages
e.g. If I wanted to call a method from a separate class:
self.controller.frames[<name of page>].<method I want to call>()
=== Methods ===
None
"""
def __init__(self, *args, **kwargs):
Tk.__init__(self, *args, **kwargs)
self.resizable(False, False)
self.geometry("300x400")
self.title("Contact Manager")
self.iconbitmap("project/src/Phone.ico")
for i in range(5):
self.rowconfigure(i, weight=1)
self.columnconfigure(i, weight=1)
self.frames = {}
self.notebook = Notebook(self)
self.notebook.grid(row=0, column=0, columnspan=5, rowspan=5, sticky=N + S + E + W)
for page in [ContactsPage, AddContactPage]:
frame = page(self.notebook, self)
self.notebook.add(frame, text=frame.page_name)
self.frames[frame.page_name] = frame
def hide(self):
self.withdraw()
def show(self):
self.deiconify()
def initUI(self):
self.master.title("Client Modbus TCP")
self.pack(fill=BOTH, expand=True)
self.columnconfigure(1, weight=1)
self.columnconfigure(3, pad=7)
self.rowconfigure(3, weight=1)
self.rowconfigure(5, pad=7)
lbl = Label(self, text="Informatii")
lbl.grid(sticky=W, pady=4, padx=5)
n = Notebook(self)
f3 = Frame(n)
f4 = Frame(n)
f5 = Frame(n)
f6 = Frame(n)
f7 = Frame(n)
f8 = Frame(n)
n.add(f3, text='Input Registers')
n.add(f4, text='Hold Registers')
n.add(f5, text='Internet connection')
n.add(f6, text='Start connection')
n.add(f7, text='Memory')
n.add(f8, text='CPU')
n.grid(row=1, column=0, columnspan=2, rowspan=4, padx=5, sticky=E + W + S + N)
client = Client()
#client.pornire_conexiune()
button3 = Button(f3, text="Input Register", command=lambda: print("Input register este ", client.read_input_registers(0x00, 0x01, 0x00, 0x02)))
button4 = Button(f4, text="Hold Register", command=lambda: print("Holding register este ", client.read_holding_registers(0x00, 0x01, 0x00, 0x03)))
button5 = Button(f5, text="Internet", command=lambda: client.is_internet())
button6 = Button(f6, text="Pornire Conexiune", command=lambda: client.pornire_conexiune())
button7 = Button(f7, text="Memorie", command=lambda: print(client.memorie_procent()))
button8 = Button(f8, text="CPU", command=lambda: print(client.cpu_procent()))
# Asezarea butoanelor in fiecare frame
button3.grid(row=4, column=3, padx=5)
button4.grid(row=4, column=3, padx=5)
button5.grid(row=4, column=3, padx=5)
button6.grid(row=4, column=3, padx=5)
button7.grid(row=4, column=3, padx=5)
button8.grid(row=4, column=3, padx=5)
def __init__(self, fen):
tkinter.Frame.__init__(self, bg="#%02x%02x%02x" % (71, 86, 82))
self.grid()
#Header
self.title = tkinter.Label(self,
text="Le-Mayzeur",
fg="white",
font=("bauhaus 93", 22),
bg="#%02x%02x%02x" % (71, 86, 82))
self.title.grid(row=0, column=0)
#Body
onglet = Notebook(self, width=380, height=380)
self.convert = tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
self.iso = tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
self.shutdown = tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
self.bootable = tkinter.ttk.Panedwindow(orient=tkinter.VERTICAL)
onglet.add(self.iso, text='ISO file')
onglet.add(self.convert, text='Convert')
onglet.add(self.shutdown, text="Shutdown")
onglet.add(self.bootable, text='Boot drive')
onglet.grid(row=2, column=0)
#Links --. inherit classes
Convert.__init__(self)
Shutd.__init__(self, fen)
IsoFile.__init__(self, fen)
Bootable.__init__(self)
#footer
self.footer = tkinter.Label(fen,
width=480,
bg="#%02x%02x%02x" % (71, 86, 82))
self.footer.place(x=0, y=447)
self.footer = tkinter.Label(fen,
text="*****@*****.**",
fg="white",
bg="#%02x%02x%02x" % (71, 86, 82))
self.footer.place(x=130, y=447)
class BetsApp:
def __init__(self):
self.win = Tk()
self.win.title("Bets App")
self.win.resizable(0, 0)
# shared matches instance
self.matches = MatchesObservable()
# create tabs container
self.tabs = Notebook(self.win)
self.tabs.grid(column=0, row=0, padx=PAD_X, pady=PAD_Y, sticky=EW)
# create tabs
self.matches_tab = MatchesTabFrame(self.win, self.tabs, self.matches)
self.scenarios_tab = ScenariosTabFrame(self.win, self.tabs, self.matches)
self.stats_tab = StatsTabFrame(self.win, self.tabs)
# create menus
self.menu_bar = MenuBar(self.win, self.matches)
def __init__(self, master):
#initiate master title
self.master = master
self.master.title(config.options["project title"])
self.records_per_page = config.options["records_per_page"]
self.fieldnames = []
for fieldname in Record._meta.sorted_field_names:
if not fieldname == "id":
self.fieldnames.append(fieldname)
self.tab1 = Frame(Notebook)
self.tab2 = Frame(Notebook)
Notebook.add(self.tab1, text="list view")
Notebook.add(self.tab2, text="data entry")
Notebook.grid(row=0, column=0)
self.create_db_tables()
self.draw_list_page()
self.populate_list_items()
self.draw_footer()
self.draw_data_entry_form()
def main():
"""main"""
root = theme().addColor()
root.title('Notebook Test Program')
###########################################################################
### guiBlox: Create Widgets
###########################################################################
note = Notebook(root)
tab1 = Frame(note)
tab2 = Frame(note)
tab3 = Frame(note)
note.add(tab1, text="Tab1")
note.add(tab2, text="Tab2")
note.add(tab3, text="Tab3")
###########################################################################
### guiBlox: Place Widgets
###########################################################################
note.grid(row=0, column=0, sticky="nsew")
root.mainloop()
class GeneratorWindow:
def __init__(self, parent, model):
self.model = model
self.parent = parent
self.window = Toplevel(parent.window)
self.window.title('Generator')
self.window.geometry('600x400')
self.window.transient(master=parent.window)
self.tabs = Notebook(self.window)
self.ioctl_frame = Frame(self.tabs)
self.write_frame = Frame(self.tabs)
self.mmap_frame = Frame(self.tabs)
self.tabs.add(self.ioctl_frame, text='ioctl')
self.tabs.add(self.write_frame, text='write')
self.tabs.add(self.mmap_frame, text='mmap')
self.window.rowconfigure(0, weight=1)
self.window.columnconfigure(0, weight=1)
self.tabs.grid(sticky=tk.NW + tk.S + tk.E)
self.window.grab_set()
def destroy(self):
self.window.grab_release()
self.window.destroy()
def create_widgets(self):
'''
Crea todos los componentes de la ventana principal
'''
#### TABS ####
tabController = Notebook(self.root)
tabController.grid(column=0, row=0)
self.frameInicio = Frame(tabController, padding=(10, 10))
tabController.add(self.frameInicio, text="Inicio")
self.frameCursantes = Frame(tabController, padding=(10, 10))
tabController.add(self.frameCursantes, text="Alumnos")
self.frameDocentes = Frame(tabController, padding=(10, 10))
tabController.add(self.frameDocentes, text="Docentes")
self.frameCursos = Frame(tabController, padding=(10, 10))
tabController.add(self.frameCursos, text="Cursos")
lbl_curso = Label(self.frameInicio,
text="Seleccione el curso:",
width=35)
lbl_curso.grid(row=0, column=0, columnspan=35, padx=(400, 0))
self.id_curso = StringVar()
self.cb_curso = Combobox(self.frameInicio,
textvariable=self.id_curso,
width=20,
state="readonly")
self.cb_curso.grid(row=1, column=0, columnspan=20, padx=(400, 0))
self.cb_curso.bind("<<ComboboxSelected>>", self.selection_changed)
self.create_tab_alumnos()
self.create_tab_cursos()
self.create_tab_docentes()
self.update_tablas()
class GraphicalApp(tk.Frame):
"""Interface graphique du jeu."""
def __init__(self, dispatcher):
self.dispatcher = dispatcher
self.master = None
self.treeview = None
self.chats = {
} # contient des listes [id, treeview, entry, bouton, messageCpt]
self.progress = None
self.previousAngles = {}
self.initializeGraphicalApp()
self.dispatcher.setGraphicalApp(self)
self.mainloop()
def initializeGraphicalApp(self):
"""Initialise l'interface graphique."""
self.master = tk.Tk()
self.master.title("To the conquest of the dragon balls !")
super().__init__(self.master)
self.master.resizable(False, False)
self.createWidgets()
self.setUpBindingEvent()
self.master.protocol("WM_DELETE_WINDOW", self.closeWindow)
msg = "Welcome space travelers !\n\n"
msg += "A brand new race has been created. "
msg += "You may ask yourself : \"Why should i participate ?\" "
msg += "Well because the reward is worth it, it's nothing more than the seven dragon balls !\n"
msg += "Suddenly fell more excited right ?!\n"
msg += "But watch out, you are not the only one interested...\n\n"
msg += "In order to move your vehicle, use your keyboard's directional arrows.\n"
msg += "You can also drop a bomb with the \"B\" button.\n\n"
msg += "Good luck !"
messagebox.showinfo(title="Welcome !", message=msg)
def createWidgets(self):
"""Crée tous les widgets de l'interface."""
tk.Label(self.master, text="Your pseudo",
font="-weight bold").grid(row=0, column=0, sticky=tk.W)
self.pseudoEntry = tk.Entry(self.master)
self.pseudoEntry.grid(row=0, column=1, sticky=tk.EW)
self.pseudoEntry.focus_set()
tk.Label(self.master, text="Status : ",
font="-weight bold").grid(row=1, column=0, sticky=tk.W)
self.statusLabel = tk.Label(self.master, text="Not yet connected...")
self.statusLabel.grid(row=1, column=1, sticky=tk.W)
self.progress = Progressbar(self.master,
orient=tk.HORIZONTAL,
mode='indeterminate')
self.progress.grid(row=1, column=2)
self.exitButton = tk.Button(self.master)
self.exitButton["text"] = "Exit"
self.exitButton["state"] = tk.DISABLED
self.exitButton["bg"] = "#FF0A2D"
self.exitButton["activebackground"] = "#FF415C"
self.exitButton["fg"] = "#FFFFFF"
self.exitButton["activeforeground"] = "#FFFFFF"
self.exitButton["relief"] = tk.FLAT
self.exitButton["bd"] = 0
self.exitButton["command"] = lambda: self.dispatcher.onExitClicked()
self.exitButton.grid(row=2, column=1, sticky=tk.EW)
self.connectionButton = tk.Button(self.master)
self.connectionButton["text"] = "Connect to the server"
self.connectionButton["bg"] = "#1296EC"
self.connectionButton["activebackground"] = "#33A5EF"
self.connectionButton["fg"] = "#FFFFFF"
self.connectionButton["activeforeground"] = "#FFFFFF"
self.connectionButton["relief"] = tk.FLAT
self.connectionButton["bd"] = 0
self.connectionButton["command"] = lambda: self.onConnectionClicked(
self.connectionButton)
self.connectionButton.grid(row=2, column=0, sticky=tk.EW)
self.createScoreTable()
self.createSpaceEnvironment()
self.notebook = Notebook(self.master)
self.notebook.grid(row=5,
column=3,
columnspan=2,
rowspan=3,
sticky=tk.NSEW)
self.createChat("Public", enable=False)
def setUpBindingEvent(self):
"""Met en place tous les événement permettant eu joueur de contrôler son pod."""
# Les code de mise à jour du joueur doivent être exécutés dans un autre thread.
# Dans le cas contraire, il y a un interblocage entre le thread de
# l'interface graphique (celui-ci), et celui qui met à jour périodiquement les position des joueurs.
self.master.bind('<Left>', self.dispatcher.antiClockEvent)
self.master.bind('<Right>', self.dispatcher.clockEvent)
self.master.bind('<Up>', self.dispatcher.thrustEvent)
self.master.bind('b', self.dispatcher.putBomb)
def createSpaceEnvironment(self):
"""Crée un décor spatial."""
self.canvasLock = Lock()
self.canvas = tk.Canvas(self.master,
width=dat.ARENA_L * 2,
height=dat.ARENA_H * 2,
bg="black")
self.canvas.grid(row=5,
column=0,
columnspan=3,
rowspan=5,
pady=(10, 0))
# Ajoute 200 étoiles
for __ in range(0, 200):
self.drawRandomStar()
def drawRandomStar(self):
"""Dessine une étoile à une position aléatoire."""
maxX = int(self.canvas["width"])
maxY = int(self.canvas["height"])
x = random.randint(0, maxX)
y = random.randint(0, maxY)
self.canvas.create_oval(x, y, x + 5, y + 5, fill="white")
def createScoreTable(self):
"""Crée le tableau des scores."""
tk.Label(self.master, text="Scores",
font="-weight bold").grid(row=3, column=0, columnspan=2)
tv = Treeview(self.master, height=3)
tv['columns'] = ('Score', "Bomb")
tv.heading("#0", text='User', anchor=tk.W)
tv.heading('Bomb', text='Bombs available', anchor=tk.W)
tv.column('Bomb', anchor=tk.W, width=100)
tv.heading('Score', text='Score', anchor=tk.W)
tv.column('Score', anchor=tk.W, width=100)
tv.grid(row=4, column=0, columnspan=3, sticky=tk.EW)
self.treeview = tv
def increaseBombOf(self, player):
"""Incrémente le nombre de bombe que possède un joueur dans le tableau d'affichage.
Arguments:
player - Le pseudo du joueur pour lequel on doit incrémenter son nombre de bombe.
"""
for i in self.treeview.get_children():
item = self.treeview.item(i)
# Nous sommes bien sur l'item du joueur qui nous interesse
if item["text"] == player:
oldValue = item['values']
oldValue[1] += 1
self.treeview.item(i, values=oldValue)
break
def decreaseBombOf(self, player):
"""Décrémente le nombre de bombe que possède un joueur dans le tableau d'affichage.
Arguments:
player - Le pseudo du joueur pour lequel on doit décrémenter son nombre de bombe.
"""
for i in self.treeview.get_children():
item = self.treeview.item(i)
# Nous sommes bien sur l'item du joueur qui nous interesse
if item["text"] == player:
oldValue = item['values']
oldValue[1] -= 1
self.treeview.item(i, values=oldValue)
break
def setBombOf(self, player, nbBomb):
"""Met à jour le nombre de bombe que possède un joueur dans le tableau d'affichage.
Arguments:
player - Le pseudo du joueur pour lequel on doit mettre à jour son nombre de bombe.
nbBomb - Le nouveau nombre de bombe du joueur.
"""
for i in self.treeview.get_children():
item = self.treeview.item(i)
# Nous sommes bien sur l'item du joueur qui nous interesse
if item["text"] == player:
oldValue = item['values']
oldValue[1] = nbBomb
self.treeview.item(i, values=oldValue)
break
def createChat(self, nom, enable=True):
"""Créer un nouveau chat pour un joueur donné.
Arguments:
nom - Le nom du joueur avec lequel l'utilisateur pourra parler avec ce chat
Keyword Arguments:
enable -- Est-ce que le chat doit être activer par défaut. (default: {True})
"""
frame = tk.Frame(self.notebook)
self.notebook.add(frame, text=nom)
chat = Treeview(frame, height=15)
chat['columns'] = ('Date')
chat.heading("#0", text='Messages', anchor=tk.W)
chat.heading('Date', text='Date', anchor=tk.W)
chat.column('Date', anchor=tk.W, width=150)
chat.grid(row=0, column=0, columnspan=2, rowspan=3, sticky=tk.NSEW)
chat.tag_configure('even', background='#DAE5F4')
chat.tag_configure('odd', background='#B8D1F3')
chat.tag_configure('from_me', font=("Helvetica", 10, "bold"))
chat.tag_configure('not_from_me', font=("Helvetica", 10))
messageEntry = tk.Entry(frame)
messageEntry.grid(row=4, column=0, sticky=tk.S)
messageButton = tk.Button(frame)
messageButton["text"] = "Envoyer"
if not enable:
messageButton["state"] = tk.DISABLED
messageButton["bg"] = "#1296EC"
messageButton["activebackground"] = "#33A5EF"
messageButton["fg"] = "#FFFFFF"
messageButton["activeforeground"] = "#FFFFFF"
messageButton["relief"] = tk.FLAT
messageButton["bd"] = 0
messageButton["command"] = lambda: self.sendMessage(nom, messageEntry)
messageButton.grid(row=4, column=1, sticky=tk.S)
self.chats[nom] = [frame, chat, messageEntry, messageButton, 0]
def deleteChat(self, name):
"""Supprime un chat permmetant de communiquer avec un joueur donnée.
Arguments:
name -- Le nom du joueur pour lequel on doit supprimer le chat.
"""
self.notebook.forget(self.chats[name][0])
def sendMessage(self, target, entry):
"""Signale au dispatcher la volonté de l'utilisateur d'envoyer un message.
Arguments:
target -- La cible à laquelle le joueur souhaite envoyer le message.
entry -- L'entry source sur laquelle l'utilisateur a saisi son message.
"""
message = entry.get()
if message == "":
messagebox.showerror(title="Empty message",
message="You cannot send an empty message")
else:
self.dispatcher.sendMessage(target, message)
entry.delete(0, tk.END)
def addMessage(self, chatName, message, fromMe=False):
"""Ajout un message à un chat.
Arguments:
chatName -- Le nom du chat.
message -- Le message.
Keyword Arguments:
fromMe -- Indique si le message vient de l'utilisateur de l'application cliente. (default: {False})
"""
currentDate = strftime("%d/%m/%Y-%H:%M:%S", gmtime())
fromMeTag = 'from_me' if fromMe else 'not_from_me'
odd_even_tag = 'even' if (self.chats[chatName][4] % 2) == 0 else 'odd'
self.chats[chatName][1].insert('',
'end',
text=message,
values=currentDate,
tags=(odd_even_tag, fromMeTag))
self.chats[chatName][4] += 1
def addScoreToTable(self, user, score):
""" Ajoute un nouveau score au tableau des scores.
Si le joueur est déjà présent, met à jour sa ligne.
Arguments:
user -- Un pseudo.
score -- Un score.
"""
edited = False
for i in self.treeview.get_children():
item = self.treeview.item(i)
# Nous sommes bien sur l'item du joueur qui nous interesse
if item["text"] == user:
oldValue = item['values']
oldValue[0] = score
self.treeview.item(i, values=oldValue)
edited = True
break
if not edited:
self.treeview.insert('',
'end',
text=str(user),
values=(str(score), "0"))
def createGraphicalPlayer(self, playerX, playerY):
"""Crée un joueur à une position spécifique.
Arguments:
playerX -- La coordonnée X du joueur.
playerY -- La coordonnée Y du joueur.
Returns:
tuple -- Un tuple contenant le tag du joueur dans le canvas et ses images.
"""
convertedPos = self.convertPosition(playerX, playerY)
playerImage = Image.open('images/pod_sprite_50.png')
podPicture = ImageTk.PhotoImage(playerImage)
self.canvasLock.acquire()
tagPlayer = self.canvas.create_image(convertedPos[0],
convertedPos[1],
image=podPicture)
self.canvasLock.release()
return (tagPlayer, playerImage, podPicture)
def createGraphicalOpponent(self, playerX, playerY):
"""Crée un adversaire à une position spécifique.
Arguments:
playerX -- La coordonnée X de l'adversaire.
playerY -- La coordonnée Y de l'adversaire.
Returns:
tuple -- Un tuple contenant le tag de l'adversaire dans le canvas et ses images.
"""
convertedPos = self.convertPosition(playerX, playerY)
opponentImage = Image.open('images/pod2_sprite_50.png')
podPicture = ImageTk.PhotoImage(opponentImage)
self.canvasLock.acquire()
tagOpponent = self.canvas.create_image(convertedPos[0],
convertedPos[1],
image=podPicture)
self.canvasLock.release()
return (tagOpponent, opponentImage, podPicture)
def createGraphicalObstacle(self, obstacleX, obstacleY):
"""Crée un obstacle à une position spécifique.
Arguments:
obstacleX -- La coordonnée X de l'obstacle.
obstacleY -- La coordonnée Y de l'obstacle.
Returns:
tuple -- Un tuple contenant le tag de l'obstacle dans le canvas et sa photoImage.
"""
convertedPos = self.convertPosition(obstacleX, obstacleY)
obstacleImage = Image.open('images/obstacles/asteroid_sprite_55.png')
obstaclePicture = ImageTk.PhotoImage(obstacleImage)
self.canvasLock.acquire()
tagOstacle = self.canvas.create_image(convertedPos[0],
convertedPos[1],
image=obstaclePicture)
self.canvasLock.release()
return (tagOstacle, obstaclePicture)
def createGraphicalGenkidma(self, genkidamaX, genkidamaY):
"""Crée un genkidama à une position spécifique.
Arguments:
genkidamaX -- La coordonnée X du genkidama.
genkidamaY -- La coordonnée Y du genkidama.
Returns:
tuple -- Un tuple contenant le tag du genkidama dans le canvas et sa photoImage.
"""
convertedPos = self.convertPosition(genkidamaX, genkidamaY)
genkidamaImage = Image.open('images/bombs/spirit_bomb_35.png')
genkidamaPicture = ImageTk.PhotoImage(genkidamaImage)
self.canvasLock.acquire()
tagGenkidama = self.canvas.create_image(convertedPos[0],
convertedPos[1],
image=genkidamaPicture)
self.canvasLock.release()
return (tagGenkidama, genkidamaPicture)
def deleteGraphicalGenkidma(self, genkidamaX, genkidamaY):
"""Enlève un genkidama situé à une position spécifique.
Arguments:
genkidamaX -- La coordonnée X du genkidama.
genkidamaY -- La coordonnée Y du genkidama.
Returns:
tuple -- Un tuple contenant le tag du genkidama dans le canvas et sa photoImage.
"""
convertedPos = self.convertPosition(genkidamaX, genkidamaY)
self.canvasLock.acquire()
tagGenki = self.canvas.find_closest(convertedPos[0], convertedPos[1])
self.canvas.delete(tagGenki)
self.canvasLock.release()
def onConnectionClicked(self, button):
"""Handler du clique sur le bouton de connexion
Arguments:
button -- Le bouton source.
"""
pseudo = self.pseudoEntry.get()
if pseudo == "":
msg = "No pseudo given. You have to give a pseudo in order to connect to the server."
messagebox.showerror(title="No pseudo", message=msg)
else:
success = self.dispatcher.onConnectionClicked(pseudo)
if success:
button["state"] = tk.DISABLED
self.exitButton["state"] = tk.NORMAL
self.chats["Public"][3]["state"] = tk.NORMAL
self.statusLabel["text"] = "Connection succeed !"
self.pseudoEntry.delete(0, tk.END)
else:
msg = "Connection to the server failed.\nMake sure the server is running."
messagebox.showerror(title="Connection failed", message=msg)
def closeWindow(self):
"""Handler de la fermeture de la fenêtre.
Signale au dispatcher que l'utilisateur souhaite quitter l'application et ferme l'interface.
"""
self.dispatcher.onCloseWindow()
# Il se peut qu'un thread soit bloqué en attente d'une réponse du thread de l'interface
# En exécutant un update, on va le débloquer
self.master.update()
self.master.destroy()
def updateUIPlayer(self, player):
"""Met à jour la position et l'angle de rotation d'un joueur.
Arguments:
player -- Le joueur.
"""
self.canvasLock.acquire()
if player.getPseudo(
) not in self.previousAngles or self.previousAngles[
player.getPseudo()] != player.getAngle():
self.rotatePlayer(player)
self.updatePlayer(player)
self.canvasLock.release()
def updatePlayer(self, player):
"""Met à jour la position d'un joueur.
Arguments:
player -- Le joueur.
"""
convertedPos = self.convertPosition(player.getPositionX(),
player.getPositionY())
self.canvas.coords(player.getCanvasTagId(),
(convertedPos[0], convertedPos[1]))
def rotatePlayer(self, player):
"""Met à jour l'angle de rotation d'un joueur.
Arguments:
player -- Le joueur.
"""
self.previousAngles[player.getPseudo()] = player.getAngle()
self.canvas.delete(player.getCanvasTagId())
podPicture = ImageTk.PhotoImage(player.getImage().rotate(
player.getAngle()))
convertedPos = self.convertPosition(player.getPositionX(),
player.getPositionY())
newId = self.canvas.create_image(convertedPos[0],
convertedPos[1],
image=podPicture)
player.setCanvasTagId(newId)
player.setPhotoImage(podPicture)
def convertPosition(self, x, y):
"""Convertie des coordonnées pour qu'elle soit utilisable par le canvas.
Arguments:
x -- La coordonnée X.
y -- La coordonnée Y.
Returns:
tuple(x, y) -- Un tuple contenant les positions converties.
"""
newX = x + dat.ARENA_L
newY = y + dat.ARENA_H
return (newX, newY)
def showDeniedMessage(self):
"""Affiche un message indiquant à l'utilisateur que sa tentative de connexion à été refusée."""
msg = "The server refused the connection.\nYou may try again with an other pseudo"
messagebox.showerror(title="Connection refused", message=msg)
self.statusLabel["text"] = "Pseudo already used..."
self.connectionButton["state"] = tk.NORMAL
def showWaitingMessage(self):
"""Met à jour le label de status pour indiquer à l'utilisateur d'attendre le début de la partie."""
print("Waiting")
self.statusLabel["text"] = "Waiting for game to start..."
self.progress.start(10)
def showStartMessage(self):
"""Met à jour le label de status pour indiquer à l'utilisateur que la partie à commencé."""
print("Good game")
self.statusLabel["text"] = "Good game !"
self.progress.stop()
def showWinner(self, winnerName, iWin):
"""Affiche une fenêtre avec le nom du gagnant.
Arguments:
winnerName -- Le nom du gagnant.
iWin -- Indique si le gagnant est le joueur actuel.
"""
msg = ""
if iWin:
msg = "Congratulation you have won !"
else:
msg = winnerName + " has won !"
messagebox.showinfo(title="We have a winner !", message=msg)
def showObjectif(self, objectifX, objectifY, objectifNumber):
"""Ajoute un objectif (une dragon ball).
Arguments:
objectifX -- La coordonnée X de l'objectif.
objectifY -- La coordonnée Y de l'objectif.
objectifNumber -- Le numéro de l'objectif (utiliser pour choisir quelle dragon ball utiliser).
Returns:
tuple(idTag, photoImage) -- Un tuple contenant le tag de l'objectif et son image.
"""
converted = self.convertPosition(objectifX, objectifY)
newImage = Image.open('images/dragon_ball/ball_' +
str(objectifNumber) + ".png")
newPhotoImage = ImageTk.PhotoImage(newImage)
self.canvasLock.acquire()
tagImage = self.canvas.create_image(converted[0],
converted[1],
image=newPhotoImage)
self.canvasLock.release()
return (tagImage, newPhotoImage)
def reset(self):
"""Remet à zéro l'application graphique."""
self.resetScores()
for (_, chat) in self.chats.items():
self.notebook.forget(chat[0])
self.chats = {}
# On ajoute de nouveau le chat public
self.createChat("Public", enable=True)
def resetScores(self):
"""Remet à zéro le tableau des scores."""
self.progress.stop()
for i in self.treeview.get_children():
self.treeview.delete(i)
def removeOpponent(self, opponentName):
"""Supprime un adversaire dde l'interface graphique.
Arguments:
opponentName -- Le nom de l'adversaire.
"""
for child in self.treeview.get_children():
item = self.treeview.item(child)
if (item["text"]) == opponentName:
self.treeview.delete(child)
if opponentName in self.chats:
del self.chats[opponentName]
def deleteFromCanvas(self, tag):
"""Supprime un élément du canavas identifié par son tag.
Arguments:
tag -- Le tag de l'élément à supprimer.
"""
self.canvas.delete(tag)
def showElement(self, tag):
self.canvas.itemconfigure(tag, state='normal')
def hideElement(self, tag):
self.canvas.itemconfigure(tag, state='hidden')
def change_language(self):
language = RUSSIAN_LANGUAGE if get_language(
) == UKRAINIAN_LANGUAGE else UKRAINIAN_LANGUAGE
set_language(language)
self.destroy_and_rebuild()
self.update_table_data()
def destroy_and_rebuild(self):
for child in self.winfo_children():
child.destroy()
self.set_widgets()
self.grid_widgets()
async def async_generator(generator):
for item in generator:
yield item
if __name__ == '__main__':
Base.metadata.create_all(engine)
root = tk.Tk()
note = Notebook(root)
tab1 = Application(note)
tab2 = tk.Frame(note)
note.add(tab1, text='Main app')
note.add(tab2, text='Additional tab')
note.grid()
root.mainloop()
class Config(Toplevel):
def __init__(self, master):
Toplevel.__init__(self, master, class_=APP_NAME)
self.title(_("Settings"))
self.grab_set()
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=1)
self.rowconfigure(0, weight=1)
self.resizable(True, True)
self.minsize(470, 574)
style = Style(self)
self._bg = style.lookup('TFrame', 'background')
self.notebook = Notebook(self)
self._validate = self.register(self._validate_entry_nb)
self.img_color = PhotoImage(master=self, file=IM_COLOR)
self.lang = StringVar(self,
LANGUAGES[CONFIG.get("General", "language")])
self.gui = StringVar(self,
CONFIG.get("General", "trayicon").capitalize())
self._init_general()
self._init_widget()
self.notebook.grid(sticky='ewsn', row=0, column=0, columnspan=2)
Button(self, text=_('Ok'), command=self.ok).grid(row=1,
column=0,
sticky='e',
padx=4,
pady=10)
Button(self, text=_('Cancel'), command=self.destroy).grid(row=1,
column=1,
sticky='w',
padx=4,
pady=10)
def _init_general(self):
frame_general = Frame(self)
self.notebook.add(frame_general, text=_("General"))
# --- Language
Label(frame_general, text=_("Language")).grid(row=0,
column=0,
padx=8,
pady=4,
sticky="e")
menu_lang = Menu(frame_general, tearoff=False, background=self._bg)
mb = Menubutton(frame_general, menu=menu_lang, textvariable=self.lang)
mb.grid(row=0, column=1, padx=8, pady=4, sticky="w")
for lang in LANGUAGES:
language = LANGUAGES[lang]
menu_lang.add_radiobutton(label=language,
value=language,
variable=self.lang,
command=self.translate)
# --- gui toolkit
Label(frame_general,
text=_("GUI Toolkit for the system tray icon")).grid(row=2,
column=0,
padx=8,
pady=4,
sticky="e")
menu_gui = Menu(frame_general, tearoff=False, background=self._bg)
Menubutton(frame_general,
menu=menu_gui,
width=9,
textvariable=self.gui).grid(row=2,
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)
# --- Update delay
Label(frame_general,
text=_("Feed update delay (min)")).grid(row=4,
column=0,
padx=8,
pady=4,
sticky="e")
self.entry_delay = Entry(frame_general,
width=10,
justify='center',
validate='key',
validatecommand=(self._validate, '%P'))
self.entry_delay.grid(row=4, column=1, padx=8, pady=4, sticky='w')
self.entry_delay.insert(
0,
CONFIG.getint('General', 'update_delay') // 60000)
# --- image loading timeout
Label(frame_general,
text=_("Image loading timeout (s)")).grid(row=5,
column=0,
padx=8,
pady=4,
sticky="e")
self.entry_timeout = Entry(frame_general,
width=10,
justify='center',
validate='key',
validatecommand=(self._validate, '%P'))
self.entry_timeout.grid(row=5, column=1, padx=8, pady=4, sticky='w')
self.entry_timeout.insert(
0, CONFIG.getint('General', 'img_timeout', fallback=10))
# --- Notifications
self.notifications = Checkbutton(frame_general,
text=_("Activate notifications"))
self.notifications.grid(row=6,
column=0,
padx=8,
pady=4,
columnspan=2,
sticky='w')
if CONFIG.getboolean('General', 'notifications', fallback=True):
self.notifications.state(('selected', '!alternate'))
else:
self.notifications.state(('!selected', '!alternate'))
# --- Confirm remove feed
self.confirm_feed_rem = Checkbutton(
frame_general,
text=_("Show confirmation dialog before removing feed"))
self.confirm_feed_rem.grid(row=7,
column=0,
padx=8,
pady=4,
columnspan=2,
sticky='w')
if CONFIG.getboolean('General', 'confirm_feed_remove', fallback=True):
self.confirm_feed_rem.state(('selected', '!alternate'))
else:
self.confirm_feed_rem.state(('!selected', '!alternate'))
# --- Confirm remove cat
self.confirm_cat_rem = Checkbutton(
frame_general,
text=_("Show confirmation dialog before removing category"))
self.confirm_cat_rem.grid(row=8,
column=0,
padx=8,
pady=4,
columnspan=2,
sticky='w')
if CONFIG.getboolean('General', 'confirm_cat_remove', fallback=True):
self.confirm_cat_rem.state(('selected', '!alternate'))
else:
self.confirm_cat_rem.state(('!selected', '!alternate'))
# --- Confirm update
self.confirm_update = Checkbutton(
frame_general, text=_("Check for updates on start-up"))
self.confirm_update.grid(row=9,
column=0,
padx=8,
pady=4,
columnspan=2,
sticky='w')
if CONFIG.getboolean('General', 'check_update', fallback=True):
self.confirm_update.state(('selected', '!alternate'))
else:
self.confirm_update.state(('!selected', '!alternate'))
# --- Splash supported
self.splash_support = Checkbutton(
frame_general,
text=_("Check this box if the widgets disappear when you click"))
self.splash_support.grid(row=10,
column=0,
padx=8,
pady=4,
columnspan=2,
sticky='w')
if not CONFIG.getboolean('General', 'splash_supported', fallback=True):
self.splash_support.state(('selected', '!alternate'))
else:
self.splash_support.state(('!selected', '!alternate'))
def _init_widget(self):
frame_widget = Frame(self)
self.notebook.add(frame_widget, text=_('Widget'))
# --- font
frame_font = Frame(frame_widget)
self.title_font = FontFrame(frame_font,
CONFIG.get("Widget", "font_title"), True)
self.text_font = FontFrame(frame_font, CONFIG.get("Widget", "font"))
frame_font.columnconfigure(1, weight=1)
Label(frame_font, text=_('Title')).grid(row=0,
column=0,
sticky='nw',
padx=4,
pady=4)
self.title_font.grid(row=0, column=1)
Separator(frame_font, orient='horizontal').grid(row=1,
columnspan=2,
sticky='ew',
padx=4,
pady=4)
Label(frame_font, text=_('Text')).grid(row=2,
column=0,
sticky='nw',
padx=4,
pady=4)
self.text_font.grid(row=2, column=1)
# --- opacity
self.opacity_frame = OpacityFrame(frame_widget,
CONFIG.get("Widget", "alpha"))
# --- colors
frame_color = Frame(frame_widget)
frame_color.columnconfigure(1, weight=1)
frame_color.columnconfigure(3, weight=1)
self.color_bg = ColorFrame(frame_color,
CONFIG.get("Widget", "background"),
_('Background color'))
self.color_fg = ColorFrame(frame_color,
CONFIG.get("Widget", "foreground"),
_('Foreground color'))
self.color_feed_bg = ColorFrame(
frame_color, CONFIG.get("Widget", "feed_background"),
_('Background color'))
self.color_feed_fg = ColorFrame(
frame_color, CONFIG.get("Widget", "feed_foreground"),
_('Foreground color'))
self.color_link = ColorFrame(frame_color,
CONFIG.get("Widget", "link_color"),
_('Link color'))
Label(frame_color, text=_('General')).grid(row=0,
column=0,
sticky='w',
padx=4,
pady=2)
self.color_bg.grid(row=0, column=1, sticky='e', padx=4, pady=2)
self.color_fg.grid(row=1, column=1, sticky='e', padx=4, pady=2)
Separator(frame_color, orient='horizontal').grid(row=2,
columnspan=4,
sticky='ew',
padx=4,
pady=4)
Label(frame_color, text=_('Feed entry')).grid(row=3,
column=0,
sticky='w',
padx=4,
pady=2)
self.color_feed_bg.grid(row=3, column=1, sticky='e', padx=4, pady=2)
self.color_feed_fg.grid(row=4, column=1, sticky='e', padx=4, pady=2)
self.color_link.grid(row=5, column=1, sticky='e', padx=4, pady=2)
# --- pack
Label(frame_widget,
text=_('Font'),
font='TkDefaultFont 9 bold',
anchor='w').pack(padx=4, fill='x')
frame_font.pack(fill='x', padx=14)
Separator(frame_widget, orient='horizontal').pack(fill='x', pady=6)
self.opacity_frame.pack(padx=(4, 10), fill='x')
Separator(frame_widget, orient='horizontal').pack(fill='x', pady=6)
Label(frame_widget,
text=_('Colors'),
font='TkDefaultFont 9 bold',
anchor='w').pack(padx=4, fill='x')
frame_color.pack(fill='x', padx=14)
def display_label(self, value):
self.opacity_label.configure(text=" {val} %".format(
val=int(float(value))))
def translate(self):
showinfo(
"Information",
_("The language setting will take effect after restarting the application"
),
parent=self)
@staticmethod
def _config_size(variable, font):
size = variable.get()
if size:
font.configure(size=size)
@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 change_gui(self):
showinfo(
"Information",
_("The GUI Toolkit setting will take effect after restarting the application"
),
parent=self)
def ok(self):
# --- general
CONFIG.set("General", "language", REV_LANGUAGES[self.lang.get()])
CONFIG.set("General", "trayicon", self.gui.get().lower())
CONFIG.set("General", "update_delay",
"%i" % (int(self.entry_delay.get()) * 60000))
CONFIG.set("General", "img_timeout",
"%i" % (int(self.entry_timeout.get())))
CONFIG.set('General', 'confirm_feed_remove',
str(self.confirm_feed_rem.instate(('selected', ))))
CONFIG.set('General', 'confirm_cat_remove',
str(self.confirm_cat_rem.instate(('selected', ))))
CONFIG.set('General', 'check_update',
str(self.confirm_update.instate(('selected', ))))
CONFIG.set('General', 'splash_supported',
str(not self.splash_support.instate(('selected', ))))
CONFIG.set('General', 'notifications',
str(self.notifications.instate(('selected', ))))
# --- widget
CONFIG.set("Widget", "alpha", "%i" % self.opacity_frame.get_opacity())
font_title_dic = self.title_font.get_font()
font_title_dic[
'underline'] = 'underline' if font_title_dic['underline'] else ''
font_title_dic['family'] = font_title_dic['family'].replace(' ', '\ ')
CONFIG.set(
"Widget", "font_title",
"{family} {size} {weight} {slant} {underline}".format(
**font_title_dic))
font_text_dic = self.text_font.get_font()
font_text_dic['family'] = font_text_dic['family'].replace(' ', '\ ')
CONFIG.set("Widget", "font", "{family} {size}".format(**font_text_dic))
CONFIG.set("Widget", "foreground", self.color_fg.get_color())
CONFIG.set("Widget", "background", self.color_bg.get_color())
CONFIG.set("Widget", "feed_foreground", self.color_feed_fg.get_color())
CONFIG.set("Widget", "feed_background", self.color_feed_bg.get_color())
CONFIG.set("Widget", "link_color", self.color_link.get_color())
self.destroy()
########
# Test code
if __name__ == "__main__":
from DnDReferenceBook.src.dbase_manager import DatabaseManager
from simple_location import SimpleLocationView
from tkinter.ttk import Notebook
root = Tk()
dbm = DatabaseManager("../data/dnd_ref_book.db")
dbm.reset("../src/tables.sql", "../src/real.sql")
locList = dbm.get_location_list()
nb = Notebook(root)
lv = LocationView(nb)
nb.add(lv, text="Default")
for location in locList:
temp = LocationView(nb, dbm.get_location(location["name"]))
nb.add(temp, text=location["name"])
nb.grid(row=0, column=0, sticky=N + W + E + S)
top = Toplevel(root)
slv = SimpleLocationView(top)
slv.grid(row=0, column=0, sticky=W + E)
for i in range(len(locList)):
temp = SimpleLocationView(top,
dbm.get_simple_location(locList[i]["name"]))
temp.grid(row=i + 1, column=0, sticky=W + E)
root.mainloop()
width=tc1.winfo_reqwidth())
def on_click(event):
clicked_tab = nb1.tk.call(nb1._w, "identify", "tab", event.x, event.y)
if clicked_tab == 0:
clicked_tab = 'one'
if clicked_tab == 1:
clicked_tab = 'two'
if clicked_tab == 2:
clicked_tab = 'three'
lbl1['text'] = 'Tab '+clicked_tab+' was clicked'
nb1 = Notebook(root, style='green.TNotebook')
nb1.bind("<<NotebookTabChanged>>", tab_changed)
nb1.grid(row=0, column=0)
nb1.enable_traversal()
lbl1 = Label(root, text='ready')
lbl1.grid(row=5, column=0)
nb1.bind('<Button-1>', on_click)
# first page
page1 = Frame(root, background='red', height=70*mult)
enabler = Button(page1, text='Enable Tab two\n Test it out',
command=lambda: nb1.tab(1, state='normal'))
enabler.pack(ipadx=5, ipady=5)
nb1.add(page1, text='one', underline=0, padding=2)
class Application(Frame):
def __init__(self, master):
Frame.__init__(self, master)
self.lastdir = os.getcwd()
self.op_sys = platform.platform()
#Check for path to FEBio executable
try:
if "windows" in self.op_sys.lower():
home = os.getenv("HOMEPATH")
else:
home = os.getenv("HOME")
fid = open(os.path.join(home, ".pyCellAnalystFEA.pth"), "r")
self._FEBIO_BIN = os.path.abspath(fid.readline())
fid.close()
try:
p = subprocess.Popen(self._FEBIO_BIN)
p.terminate()
except:
self.getFEBioLocation("File indicated as the FEBio executable is incorrect. Please reselect.", home)
except:
self.getFEBioLocation("Please select the FEBio executable file.", home)
self.notebook = Notebook(self)
self.tab1 = Frame(self.notebook)
self.tab2 = Frame(self.notebook)
self.notebook.add(self.tab1, text="Analysis")
self.notebook.add(self.tab2, text="Material Model")
self.notebook.grid(row=0, column=0, sticky=NW)
self.pickles = []
self.data = {}
self.vtkMeshes = {}
self.volumes = {}
self.outputs = OrderedDict(
[("Effective Strain (von Mises)", IntVar(value=1)),
("Maximum Compressive Strain", IntVar(value=1)),
("Maximum Tensile Strain", IntVar(value=1)),
("Maximum Shear Strain", IntVar(value=1)),
("Volumetric Strain", IntVar(value=1)),
("Effective Stress (von Mises)", IntVar(value=0)),
("Maximum Compressive Stress", IntVar(value=0)),
("Maximum Tensile Stress", IntVar(value=0)),
("Maximum Shear Stress", IntVar(value=0)),
("Pressure", IntVar(value=0))])
self.analysis = OrderedDict(
[("Generate Histograms", IntVar(value=1)),
("Tukey Boxplots", IntVar(value=1)),
("Calculate Differences", IntVar(value=1)),
("Convert to VTK", IntVar(value=1))])
self.groundSubstance = IntVar(value=1)
self.groundSubstances = ('neoHookean',
'Mooney-Rivlin',
'Transversely Isotropic')
self.tensileNetwork = IntVar(value=1)
self.tensileNetworks = ('None',
'Continuous Fibre Distribution')
self.compressiveNetwork = IntVar(value=1)
self.groundParameters = [
OrderedDict([("Young's Modulus", DoubleVar(value=1.0e-9)),
("Poisson's Ratio", DoubleVar(value=0.1))]),
OrderedDict([("C_1", DoubleVar(value=2.3e-10)),
("C_2", DoubleVar(value=0.0)),
("Bulk Modulus", DoubleVar(value=4.17e-10))]),
OrderedDict([
("Young's Modulus (radial)", DoubleVar(value=1.45e-6)),
("Young's Modulus (tangential)", DoubleVar(value=1.0e-9)),
("Poisson's Ratio (radial:tangential)", DoubleVar(value=0.4)),
("Poisson's Ratio (tangential:radial)", DoubleVar(value=0.0)),
("Shear Modulus (radial planes)", DoubleVar(value=5.0e-10))])]
self.tensileParameters = [
None,
OrderedDict([("ksi1", DoubleVar(value=1.0e-7)),
("ksi2=ksi3", DoubleVar(value=1.45e-6)),
("beta1", DoubleVar(value=2.0)),
("beta2=beta3", DoubleVar(value=2.0)),
("Distance Cutoff [0, 1]", DoubleVar(value=0.5)),
("Cutoff Grade (0, 1]", DoubleVar(value=0.1))])]
self.results = {"Effective Strain (von Mises)": {},
"Maximum Compressive Strain": {},
"Maximum Tensile Strain": {},
"Maximum Shear Strain": {},
"Volumetric Strain": {},
"Effective Stress (von Mises)": {},
"Maximum Compressive Stress": {},
"Maximum Tensile Stress": {},
"Maximum Shear Stress": {},
"Pressure": {},
"Displacement": {}}
self.histograms = {"Effective Strain (von Mises)": {},
"Maximum Compressive Strain": {},
"Maximum Tensile Strain": {},
"Maximum Shear Strain": {},
"Volumetric Strain": {},
"Effective Stress (von Mises)": {},
"Maximum Compressive Stress": {},
"Maximum Tensile Stress": {},
"Maximum Shear Stress": {},
"Pressure": {}}
self.boxwhiskers = {"Effective Strain (von Mises)": {},
"Maximum Compressive Strain": {},
"Maximum Tensile Strain": {},
"Maximum Shear Strain": {},
"Volumetric Strain": {},
"Effective Stress (von Mises)": {},
"Maximum Compressive Stress": {},
"Maximum Tensile Stress": {},
"Maximum Shear Stress": {},
"Pressure": {}}
self.differences = {"Effective Strain (von Mises)": {},
"Maximum Compressive Strain": {},
"Maximum Tensile Strain": {},
"Maximum Shear Strain": {},
"Volumetric Strain": {},
"Effective Stress (von Mises)": {},
"Maximum Compressive Stress": {},
"Maximum Tensile Stress": {},
"Maximum Shear Stress": {},
"Pressure": {}}
self.grid()
self.createWidgetsTab1()
self.createWidgetsTab2()
def getFEBioLocation(self, msg, home):
filename = tkinter.filedialog.askopenfilename(
parent=root, initialdir=home,
title=msg)
if filename:
try:
p = subprocess.Popen(filename)
p.terminate()
self._FEBIO_BIN = filename
fid = open(os.path.join(home, ".pyCellAnalystFEA.pth"), "wt")
fid.write(self._FEBIO_BIN)
fid.close()
except:
self.getFEBioLocation("Incorrect FEBio executable file was selected. Please reselect.", home)
else:
raise SystemExit("You must indicate the location of the FEBio executable. Exiting...")
def createWidgetsTab1(self):
#pickles to load
self.pickleFrame = LabelFrame(
self.tab1, text="Pickles from which to generate models")
self.pickleFrame.grid(row=0, column=0,
columnspan=3, rowspan=2,
padx=5, pady=5, sticky=NW)
self.buttonAddFile = Button(
self.pickleFrame, text="Add", bg='green', command=self.addPickle)
self.buttonAddFile.grid(row=0, column=0, padx=5, pady=5, sticky=E + W)
self.buttonRemoveFile = Button(
self.pickleFrame,
text="Remove", bg='red', command=self.removePickle)
self.buttonRemoveFile.grid(row=1, column=0,
padx=5, pady=5, sticky=E + W)
self.listPickles = Listbox(self.pickleFrame,
width=80, selectmode=MULTIPLE)
self.listPickles.grid(row=0, column=1,
columnspan=2, rowspan=2,
padx=5, pady=5, sticky=E + W)
#outputs
self.outputsFrame = LabelFrame(self.tab1, text="Outputs")
self.outputsFrame.grid(row=2, column=0,
rowspan=4, columnspan=2,
padx=5, pady=5, sticky=NW)
for i, t in enumerate(self.outputs.keys()):
if i < 5:
Checkbutton(self.outputsFrame, text=t,
variable=self.outputs[t]).grid(row=i, column=0,
padx=5, pady=5,
sticky=NW)
else:
Checkbutton(self.outputsFrame, text=t,
variable=self.outputs[t]).grid(row=i - 5, column=1,
padx=5, pady=5,
sticky=NW)
#analysis settings
self.analysisSettingsFrame = LabelFrame(self.tab1,
text="Analysis Options")
self.analysisSettingsFrame.grid(row=2, column=2,
padx=5, pady=5, sticky=E + W)
for i, t in enumerate(self.analysis.keys()):
Checkbutton(self.analysisSettingsFrame, text=t,
variable=self.analysis[t]).grid(row=i, column=2,
padx=5, pady=5,
sticky=NW)
#run analysis
self.buttonExecute = Button(self.tab1, bg='green',
font=('Helvetica', '20', 'bold'),
text='Perform Simulation',
command=self.performFEA)
self.buttonExecute.grid(row=7, column=0, columnspan=3,
padx=5, pady=5, sticky=E + W)
self.buttonAnalyze = Button(self.tab1, bg='blue',
font=('Helvetica', '20', 'bold'),
text='Analyze Results',
command=self.analyzeResults)
self.buttonAnalyze.grid(row=8, column=0, columnspan=3,
padx=5, pady=5, sticky=E + W)
def createWidgetsTab2(self):
self.groundSubstanceFrame = LabelFrame(self.tab2,
text="Ground Substance")
self.groundSubstanceFrame.grid(
row=0, column=0, padx=5, pady=5, sticky=NW)
self.tensileFibreNetworkFrame = LabelFrame(
self.tab2, text="Tensile Fibres")
self.tensileFibreNetworkFrame.grid(
row=0, column=1, padx=5, pady=5, sticky=NW)
self.compressiveFibreNetworkFrame = LabelFrame(
self.tab2, text="Compressive Fibres")
self.compressiveFibreNetworkFrame.grid(
row=0, column=3, padx=5, pady=5, sticky=NW)
# Ground substance
for i, t in enumerate(self.groundSubstances):
Radiobutton(self.groundSubstanceFrame,
text=t,
indicatoron=0,
padx=5,
width=20,
command=self.populateGroundSubstance,
variable=self.groundSubstance,
value=i + 1).pack(anchor=NW)
self.groundSubstanceSettingsFrame = LabelFrame(
self.tab2, text="Ground Substance Parameters")
self.groundSubstanceSettingsFrame.grid(
row=1, column=0, padx=5, pady=5, sticky=NW)
for i, (t, v) in enumerate(
self.groundParameters[self.groundSubstance.get() - 1].items()):
Label(self.groundSubstanceSettingsFrame, text=t).grid(row=i,
column=0,
sticky=NW)
Entry(self.groundSubstanceSettingsFrame,
textvariable=v,
width=10).grid(row=i, column=1, sticky=NW)
# Tensile Network
for i, t in enumerate(self.tensileNetworks):
Radiobutton(self.tensileFibreNetworkFrame,
text=t,
indicatoron=0,
padx=5,
width=25,
command=self.populateTensileNetwork,
variable=self.tensileNetwork,
value=i + 1).pack(anchor=NW)
self.tensileNetworkSettingsFrame = LabelFrame(
self.tab2, text="Tensile Network Parameters")
self.tensileNetworkSettingsFrame.grid(
row=1, column=1, padx=5, pady=5, sticky=NW)
if self.tensileNetwork.get() == 1:
Label(self.tensileNetworkSettingsFrame,
text="No tensile network will be modeled").grid(row=0,
column=0,
sticky=NW)
else:
for i, (t, v) in enumerate(
self.tensileParameters[self.tensileNetwork.get() - 1].items()):
Label(self.tensileNetworkSettingsFrame, text=t).grid(row=i,
column=0,
sticky=NW)
Entry(self.tensileNetworkSettingsFrame, textvariable=v,
width=10).grid(row=i, column=1, sticky=NW)
def populateGroundSubstance(self):
for child in self.groundSubstanceSettingsFrame.grid_slaves():
child.destroy()
for i, (t, v) in enumerate(
self.groundParameters[self.groundSubstance.get() - 1].items()):
Label(self.groundSubstanceSettingsFrame, text=t).grid(row=i,
column=0,
sticky=NW)
Entry(self.groundSubstanceSettingsFrame,
textvariable=v,
width=10).grid(row=i, column=1, sticky=NW)
def populateTensileNetwork(self):
for child in self.tensileNetworkSettingsFrame.grid_slaves():
child.destroy()
if self.tensileNetwork.get() == 1:
Label(self.tensileNetworkSettingsFrame,
text="No tensile network will be modeled").grid(row=0,
column=0,
sticky=NW)
else:
for i, (t, v) in enumerate(
self.tensileParameters[self.tensileNetwork.get() - 1].items()):
Label(self.tensileNetworkSettingsFrame, text=t).grid(row=i,
column=0,
sticky=NW)
Entry(
self.tensileNetworkSettingsFrame, textvariable=v,
width=10).grid(row=i, column=1, sticky=NW)
Button(
self.tensileNetworkSettingsFrame, text='Plot', width=10,
command=self.plotWeight).grid(row=i + 1, column=0, sticky=NW)
def plotWeight(self):
f = Figure()
a = f.add_subplot(111)
x = np.arange(0.0, 1.0, 0.01)
d = self.tensileParameters[1][
"Distance Cutoff [0, 1]"].get()
k = self.tensileParameters[1][
"Cutoff Grade (0, 1]"].get()
if k <= 0:
k = 0.01
print(("Cutoff Grade must be greater than zero"
" Using a value of 0.01."))
s = 0.5 * (1 - np.tanh(old_div((x - d), k)))
a.plot(x, s)
a.set_xlabel("Normalized distance from object surface")
a.set_ylabel("Tensile Network Weight")
canvas = FigureCanvasTkAgg(f,
master=self.tensileNetworkSettingsFrame)
canvas.show()
(cols, rows) = self.tensileNetworkSettingsFrame.grid_size()
slaves = self.tensileNetworkSettingsFrame.grid_slaves()
if rows == 7:
canvas.get_tk_widget().grid(row=rows + 1, column=0,
columnspan=2, sticky=NW)
else:
slaves[0].destroy()
canvas.get_tk_widget().grid(rows=rows, column=0,
columnspan=2, sticky=NW)
def addPickle(self):
filenames = tkinter.filedialog.askopenfilenames(
parent=root, initialdir=self.lastdir,
title="Please choose pickle file(s) for analysis.")
filenames = root.tk.splitlist(filenames)
for f in filenames:
if '.pkl' in f:
self.listPickles.insert(END, f)
self.pickles.append(f)
else:
print(("WARNING - {:s} does not contain the .pkl extension."
" Ignoring this file."))
def removePickle(self):
index = self.listPickles.curselection()
if index:
for i in index[::-1]:
self.listPickles.delete(i)
del self.pickles[i]
def performFEA(self):
for filename in self.pickles:
fid = open(filename, 'rb')
self.data[filename] = pickle.load(fid)
fid.close()
mesh = febio.MeshDef()
# would be good to vectorize these
for i, e in enumerate(self.data[filename]['elements']):
mesh.elements.append(['tet4', i + 1] + e)
for i, n in enumerate(self.data[filename]['nodes']):
mesh.nodes.append([i + 1] + n)
mesh.addElementSet(setname='cell',
eids=list(range(1, len(mesh.elements) + 1)))
modelname = filename.replace('.pkl', '.feb')
model = febio.Model(modelfile=modelname,
steps=[{'Displace': 'solid'}])
#lookup table for proper FEBio keyword vs GUI text
keywords = {
"neoHookean": "neo-Hookean",
"Young's Modulus": "E",
"Poisson's Ratio": "v",
"Mooney-Rivlin": "Mooney-Rivlin",
"C_1": "c1",
"C_2": "c2",
"Bulk Modulus": "k",
"Transversely Isotropic": "orthotropic elastic",
"Young's Modulus (radial)": "E1",
"Young's Modulus (tangential)": ["E2", "E3"],
"Poisson's Ratio (radial:tangential)": "v12",
"Poisson's Ratio (tangential:radial)": ["v23", "v31"],
"Shear Modulus (radial planes)": ["G12", "G23", "G31"],
"Continuous Fibre Distribution":
"ellipsoidal fiber distribution"}
#Ground Substance
gtype = keywords[
self.groundSubstances[self.groundSubstance.get() - 1]]
gattributes = {}
for (k, v) in list(self.groundParameters[
self.groundSubstance.get() - 1].items()):
# transversely isotropic case
if isinstance(keywords[k], list):
for a in keywords[k]:
# G12 = E2 / (2 * (1 + v12))
if a == "G12":
gattributes[a] = str(
old_div(float(gattributes["E2"]),
(2.0 * (1 + float(gattributes["v12"])))))
else:
gattributes[a] = str(v.get())
# any other case
else:
gattributes[keywords[k]] = str(v.get())
if self.tensileNetwork.get() == 1:
mat = febio.MatDef(matid=1, mname='cell',
mtype=gtype, elsets='cell',
attributes=gattributes)
model.addMaterial(mat)
model.addGeometry(mesh=mesh, mats=[mat])
#With a tensile network
else:
self.makeVTK(filename)
self.findLocalCsys(filename)
ind = self.tensileNetwork.get() - 1
ttype = keywords[self.tensileNetworks[ind]]
ksi = [self.tensileParameters[ind][k].get()
for k in ("ksi1", "ksi2=ksi3", "ksi2=ksi3")]
beta = [self.tensileParameters[ind][k].get()
for k in ("beta1", "beta2=beta3", "beta2=beta3")]
mats = []
I1n2 = np.eye(3)[0:2, :]
distances = numpy_support.vtk_to_numpy(
self.vtkMeshes[filename].GetCellData().GetArray(
"Signed Distances"))
maxd = np.max(np.abs(distances))
for i, e in enumerate(self.data[filename]['elements']):
normal = self.vtkMeshes[filename].GetCellData().GetArray(
"LevelSet Normals").GetTuple3(i)
# cross with both e1 and e2 to ensure linearly independent
crossed = np.cross(normal, I1n2)
norms = np.linalg.norm(crossed, axis=1)
# get the index of the maximum norm; so never zero
ind2 = np.argmax(norms)
b = old_div(crossed[ind, :], norms[ind2])
normal = list(map(str, list(normal)))
b = list(map(str, list(b)))
d = self.tensileParameters[ind]["Distance Cutoff [0, 1]"].get()
k = self.tensileParameters[ind]["Cutoff Grade (0, 1]"].get()
x = old_div(np.abs(distances[i]), maxd)
w = 0.5 * (1 - np.tanh(old_div((x - d), k)))
if w < 0.05:
w = 0.05
tmp_ksi = [w * v for v in ksi]
tattributes = {"ksi":
",".join(map(str, tmp_ksi)),
"beta": ",".join(map(str, beta))}
mesh.addElementSet(setname='e{:d}'.format(i + 1),
eids=[i + 1])
mats.append(febio.MatDef(
matid=i + 1, mname='cell', mtype="solid mixture",
elsets='e{:d}'.format(i + 1), attributes={
'mat_axis':
['vector', ','.join(normal), ','.join(b)]}))
mats[-1].addBlock(branch=1, btype='solid', mtype=gtype,
attributes=gattributes)
mats[-1].addBlock(branch=1, btype='solid', mtype=ttype,
attributes=tattributes)
model.addMaterial(mats[-1])
model.addGeometry(mesh=mesh, mats=mats)
ctrl = febio.Control()
ctrl.setAttributes({'title': 'cell', 'max_ups': '0'})
model.addControl(ctrl, step=0)
boundary = febio.Boundary(steps=1)
for i, bc in enumerate(self.data[filename]['boundary conditions']):
boundary.addPrescribed(
step=0, nodeid=self.data[filename]['surfaces'][i],
dof='x', lc='1', scale=str(bc[0]))
boundary.addPrescribed(
step=0, nodeid=self.data[filename]['surfaces'][i],
dof='y', lc='1', scale=str(bc[1]))
boundary.addPrescribed(
step=0, nodeid=self.data[filename]['surfaces'][i],
dof='z', lc='1', scale=str(bc[2]))
model.addBoundary(boundary=boundary)
model.addLoadCurve(lc='1', lctype='linear', points=[0, 0, 1, 1])
model.writeModel()
subprocess.call(self._FEBIO_BIN + " -i " + modelname, shell=True)
def analyzeResults(self):
self.matched = [] # for paired comparisons
for i, f in enumerate(self.pickles):
s = f.split(os.sep)[-1]
if not(fnmatch.filter(
itertools.chain.from_iterable(self.matched), "*" + s)):
self.matched.append(fnmatch.filter(self.pickles, "*" + s))
plotname = f.replace('.pkl', '.xplt')
print("\n... Analyzing results for {:s}".format(plotname))
results = febio.FebPlt(plotname)
stress = np.zeros((len(self.data[f]['elements']), 3, 3), float)
strain = np.copy(stress)
#material element volumes
mvolumes = np.zeros(len(self.data[f]['elements']), float)
#spatial element volumes
svolumes = np.copy(mvolumes)
nnodes = len(list(results.NodeData.keys()))
displacement = np.zeros((nnodes, 3))
for j, n in enumerate(self.data[f]['nodes']):
tmp = results.NodeData[j + 1]['displacement'][-1, :]
displacement[j, :] = [tmp[0], tmp[1], tmp[2]]
pstress = []
pstressdir = []
pstrain = []
pstraindir = []
for j, e in enumerate(self.data[f]['elements']):
tmp = results.ElementData[j + 1]['stress'][-1, :]
stress[j, :, :] = [[tmp[0], tmp[3], tmp[5]],
[tmp[3], tmp[1], tmp[4]],
[tmp[5], tmp[4], tmp[2]]]
#material coordinates
X = np.zeros((4, 3), float)
#spatial coordinates
x = np.zeros((4, 3), float)
for k in range(4):
X[k, :] = self.data[f]['nodes'][e[k] - 1]
x[k, :] = (X[k, :] +
results.NodeData[e[k]]['displacement'][-1, :])
#set up tangent space
W = np.zeros((6, 3), float)
w = np.zeros((6, 3), float)
for k, c in enumerate(
[(0, 1), (0, 2), (0, 3), (1, 3), (2, 3), (1, 2)]):
W[k, :] = X[c[1], :] - X[c[0], :]
w[k, :] = x[c[1], :] - x[c[0], :]
dX = np.zeros((6, 6), float)
ds = np.zeros((6, 1), float)
for k in range(6):
for l in range(3):
dX[k, l] = 2 * W[k, l] ** 2
dX[k, 3] = 4 * W[k, 0] * W[k, 1]
dX[k, 4] = 4 * W[k, 1] * W[k, 2]
dX[k, 5] = 4 * W[k, 0] * W[k, 2]
ds[k, 0] = (np.linalg.norm(w[k, :]) ** 2 -
np.linalg.norm(W[k, :]) ** 2)
#solve for strain
E = np.linalg.solve(dX, ds)
#get volumes
mvolumes[j] = old_div(np.abs(
np.dot(W[0, :], np.cross(W[1, :], W[2, :]))), 6.0)
svolumes[j] = old_div(np.abs(
np.dot(w[0, :], np.cross(w[1, :], w[2, :]))), 6.0)
strain[j, :, :] = [[E[0], E[3], E[5]],
[E[3], E[1], E[4]],
[E[5], E[4], E[2]]]
#eigenvalues and eigenvectors of stress and strain tensors
#eigenvectors are normalized
eigstrain, eigstraindir = np.linalg.eigh(strain[j, :, :])
order = np.argsort(eigstrain)
eigstrain = eigstrain[order]
eigstraindir /= np.linalg.norm(eigstraindir, axis=0, keepdims=True)
eigstraindir = eigstraindir[:, order]
pstrain.append(eigstrain)
pstraindir.append(eigstraindir)
eigstress, eigstressdir = np.linalg.eigh(stress[j, :, :])
order = np.argsort(eigstress)
eigstress = eigstress[order]
eigstressdir /= np.linalg.norm(eigstressdir, axis=0, keepdims=True)
eigstressdir = eigstressdir[:, order]
pstress.append(eigstress)
pstressdir.append(eigstressdir)
pstress = np.array(pstress)
pstressdir = np.array(pstressdir)
pstrain = np.array(pstrain)
pstraindir = np.array(pstraindir)
#save reference volumes
self.volumes.update({f: mvolumes})
self.results['Effective Strain (von Mises)'].update(
{f: np.sqrt(old_div(((pstrain[:, 2] - pstrain[:, 1]) ** 2 +
(pstrain[:, 1] - pstrain[:, 0]) ** 2 +
(pstrain[:, 2] - pstrain[:, 0]) ** 2),
2.0))})
self.results['Maximum Compressive Strain'].update(
{f: np.outer(pstrain[:, 0], [1 , 1, 1]) * pstraindir[:, :, 0]})
self.results['Maximum Tensile Strain'].update(
{f: np.outer(pstrain[:, 2], [1, 1, 1]) * pstraindir[:, :, 2]})
self.results['Maximum Shear Strain'].update(
{f: 0.5 * (pstrain[:, 2] - pstrain[:, 0])})
self.results['Volumetric Strain'].update(
{f: old_div(svolumes, mvolumes) - 1.0})
self.results['Effective Stress (von Mises)'].update(
{f: np.sqrt(old_div(((pstress[:, 2] - pstress[:, 1]) ** 2 +
(pstress[:, 1] - pstress[:, 0]) ** 2 +
(pstress[:, 2] - pstress[:, 0]) ** 2), 2.0))})
self.results['Maximum Compressive Stress'].update(
{f: np.outer(pstress[:, 0], [1 , 1, 1]) * pstressdir[:, :, 0]})
self.results['Maximum Tensile Stress'].update(
{f: np.outer(pstress[:, 2], [1, 1, 1]) * pstressdir[:, :, 2]})
self.results['Maximum Shear Stress'].update(
{f: 0.5 * (pstress[:, 2] - pstress[:, 0])})
self.results['Pressure'].update(
{f: old_div(np.sum(pstress, axis=1), 3.0)})
self.results['Displacement'].update({f: displacement})
for i, k in enumerate(self.outputs.keys()):
if self.outputs[k].get():
for m in self.matched:
weights = old_div(self.volumes[m[0]], np.sum(self.volumes[m[0]]))
for j, f in enumerate(m):
if len(self.results[k][f].shape) > 1:
dat = np.ravel(np.linalg.norm(self.results[k][f], axis=1))
else:
dat = np.ravel(self.results[k][f])
if self.analysis['Generate Histograms'].get():
IQR = np.subtract(*np.percentile(dat, [75, 25]))
nbins = (int(old_div(np.ptp(dat),
(2 * IQR * dat.size ** (old_div(-1., 3.))))))
h = histogram(dat, numbins=nbins, weights=weights)
bins = np.linspace(h[1], h[1] + h[2] * nbins,
nbins, endpoint=False)
self.histograms[k][f] = {'bins': bins,
'heights': h[0],
'width': h[2]}
if self.analysis['Tukey Boxplots'].get():
quantiles = np.zeros(3, float)
for n, q in enumerate([0.25, 0.5, 0.75]):
quantiles[n] = quantile_1D(dat, weights, q)
self.boxwhiskers[k][f] = {'quantiles': quantiles,
'data': dat}
if self.analysis['Calculate Differences'].get():
for c in itertools.combinations(m, 2):
if len(self.results[k][c[0]].shape) > 1:
dat1 = np.ravel(np.linalg.norm(self.results[k][c[0]], axis=1))
dat2 = np.ravel(np.linalg.norm(self.results[k][c[1]], axis=1))
else:
dat1 = np.ravel(self.results[k][c[0]])
dat2 = np.ravel(self.results[k][c[1]])
difference = dat2 - dat1
wrms = np.sqrt(np.average(difference ** 2,
weights=weights))
self.differences[k][c[1] + "MINUS" + c[0]] = {
'difference': difference, 'weighted RMS': wrms}
self.saveResults()
print("... ... Analysis Complete")
def saveResults(self):
top_dir = self.pickles[0].rsplit(os.sep, 2)[0]
ts = datetime.datetime.fromtimestamp(
time.time()).strftime("%Y-%m-%d_%H-%M-%S")
output_dir = os.sep.join([top_dir, "FEA_analysis_" + ts])
os.mkdir(output_dir)
for output in list(self.histograms.keys()):
if self.histograms[output] and self.analysis["Generate Histograms"].get():
try:
os.mkdir(os.sep.join([output_dir, "histograms"]))
except:
pass
for m in self.matched:
fig = Figure()
FigureCanvasTkAgg(fig, self)
ax = fig.add_subplot(111)
#fig.set_size_inches(2.5, 2.5)
for f in m:
trunc_name = f.rsplit(os.sep, 2)
ax.bar(self.histograms[output][f]['bins'],
self.histograms[output][f]['heights'],
self.histograms[output][f]['width'],
label=trunc_name[1])
object_name = trunc_name[2].replace("cellFEA", "Cell ")
object_name = object_name.replace(".pkl", "")
ax.set_title(output + ' ' + object_name)
cell_directory = os.path.join(output_dir, "histograms", object_name.replace(" ", "_"))
try:
os.mkdir(cell_directory)
except:
pass
fig.savefig(
os.path.join(cell_directory,
output.replace(" ", "_") + ".svg"), bbox_inches='tight')
fig.clear()
del fig
for output in list(self.boxwhiskers.keys()):
if self.boxwhiskers[output] and self.analysis["Tukey Boxplots"].get():
try:
os.mkdir(os.path.join(output_dir, "boxplots"))
except:
pass
for m in self.matched:
fig = Figure()
FigureCanvasTkAgg(fig, self)
ax = fig.add_subplot(111)
x = []
q = []
labels = []
for f in m:
trunc_name = f.rsplit(os.sep, 2)
x.append(self.boxwhiskers[output][f]['data'])
q.append(self.boxwhiskers[output][f]['quantiles'])
labels.append(trunc_name[1])
q = np.array(q)
a = ax.boxplot(x)
object_name = trunc_name[2].replace("cellFEA", "Cell ")
object_name = object_name.replace(".pkl", "")
for i in range(q.shape[0]):
a['medians'][i].set_ydata(q[i, 1])
a['boxes'][i]._xy[[0, 1, 4], 1] = q[i, 0]
a['boxes'][i]._xy[[2, 3], 1] = q[i, 2]
iqr = q[i, 2] - q[i, 0]
y = x[i]
top = np.max(y[y < q[i, 2] + 1.5 * iqr])
bottom = np.min(y[y > q[i, 0] - 1.5 * iqr])
a['whiskers'][2 * i].set_ydata(
np.array([q[i, 0], bottom]))
a['whiskers'][2 * i + 1].set_ydata(
np.array([q[i, 2], top]))
a['caps'][2 * i].set_ydata(np.array([bottom, bottom]))
a['caps'][2 * i + 1].set_ydata(np.array([top, top]))
low_fliers = y[y < bottom]
high_fliers = y[y > top]
fliers = np.concatenate((low_fliers, high_fliers))
a['fliers'][2 * i].set_ydata(fliers)
a['fliers'][2 * i].set_xdata([i + 1] * fliers.size)
object_name = trunc_name[2].replace("cellFEA", "Cell ")
object_name = object_name.replace(".pkl", "")
ax.set_title(object_name)
ax.set_ylabel(output)
ax.set_xticklabels(labels, rotation=45)
cell_directory = os.path.join(output_dir, "boxplots",
object_name.replace(" ", "_"))
try:
os.mkdir(cell_directory)
except:
pass
fig.savefig(
os.path.join(cell_directory,
output.replace(" ", "_") + ".svg"), bbox_inches="tight")
fig.clear()
del fig
for output in list(self.differences.keys()):
if self.differences[output] and self.analysis["Calculate Differences"].get():
try:
os.mkdir(os.sep.join([output_dir, "paired_differences"]))
except:
pass
for m in self.matched:
labels = []
for f in m:
trunc_name = f.rsplit(os.sep, 2)
labels.append(trunc_name[1])
N = len(m)
grid = np.zeros((N, N), float)
combos = list(itertools.combinations(m, 2))
enum_combos = list(itertools.combinations(list(range(N)), 2))
for c, e in zip(combos, enum_combos):
grid[e[0], e[1]] = (self.differences[output]
["".join([c[1], 'MINUS', c[0]])]
['weighted RMS'])
grid[e[1], e[0]] = grid[e[0], e[1]]
fig = Figure()
FigureCanvasTkAgg(fig, self)
ax = fig.add_subplot(111)
high = np.max(np.ravel(grid))
low = np.min(np.ravel(grid))
if abs(low - high) < 1e-3:
high += 0.001
heatmap = ax.pcolormesh(
grid, cmap=cm.Blues, edgecolors='black',
vmin=low, vmax=high)
ax.set_xticks(np.arange(N) + 0.5, minor=False)
ax.set_yticks(np.arange(N) + 0.5, minor=False)
ax.invert_yaxis()
ax.xaxis.tick_top()
ax.set_xticklabels(labels, minor=False)
ax.set_yticklabels(labels, minor=False)
fig.colorbar(heatmap)
object_name = trunc_name[2].replace("cellFEA", "Cell ")
object_name = object_name.replace(".pkl", "")
ax.set_title(object_name, y=1.08)
cell_directory = os.path.join(
output_dir, "paired_differences",
object_name.replace(" ", "_"))
try:
os.mkdir(cell_directory)
except:
pass
fig.savefig(
os.path.join(cell_directory, output.replace(
" ", "_") + ".svg"), bbox_inches="tight")
fig.clear()
del fig
if self.analysis['Convert to VTK'].get():
try:
os.mkdir(os.path.join(output_dir, "vtk"))
except:
pass
for m in self.matched:
try:
self.vtkMeshes[m[0]]
except:
self.makeVTK(m[0])
for output in list(self.outputs.keys()):
if self.outputs[output].get():
for f in m:
trunc_name = f.rsplit(os.sep, 2)
vtkArray = numpy_support.numpy_to_vtk(
np.ravel(self.results[output][f]).astype('f'),
deep=True, array_type=vtk.VTK_FLOAT)
shape = self.results[output][f].shape
if len(shape) == 2:
vtkArray.SetNumberOfComponents(shape[1])
elif len(shape) == 1:
vtkArray.SetNumberOfComponents(1)
else:
print(("WARNING: {:s} has rank {:d}".format(f, len(shape))))
continue
vtkArray.SetName(trunc_name[1] + ' ' + output)
self.vtkMeshes[m[0]].GetCellData().AddArray(
vtkArray)
for f in m:
arr = numpy_support.numpy_to_vtk(np.ravel(self.results['Displacement'][f]).astype('f'),
deep=True, array_type=vtk.VTK_FLOAT)
arr.SetName(trunc_name[1] + ' ' + 'Displacement')
arr.SetNumberOfComponents(3)
self.vtkMeshes[m[0]].GetPointData().AddArray(arr)
object_name = trunc_name[2].replace("cellFEA", "Cell")
object_name = object_name.replace(".pkl", ".vtu")
idWriter = vtk.vtkXMLUnstructuredGridWriter()
idWriter.SetFileName(os.path.join(output_dir, 'vtk', object_name))
idWriter.SetInputData(self.vtkMeshes[m[0]])
idWriter.Write()
def makeVTK(self, filename):
nelements = len(self.data[filename]['elements'])
n = np.array(self.data[filename]['nodes'])
arr = numpy_support.numpy_to_vtk(
n.ravel(), deep=True, array_type=vtk.VTK_DOUBLE)
arr.SetNumberOfComponents(3)
tetraPoints = vtk.vtkPoints()
tetraPoints.SetData(arr)
vtkMesh = vtk.vtkUnstructuredGrid()
vtkMesh.Allocate(nelements, nelements)
vtkMesh.SetPoints(tetraPoints)
e = np.array(self.data[filename]['elements'], np.uint32) - 1
e = np.hstack((np.ones((e.shape[0], 1), np.uint32) * 4, e))
arr = numpy_support.numpy_to_vtk(e.ravel(), deep=True,
array_type=vtk.VTK_ID_TYPE)
tet = vtk.vtkCellArray()
tet.SetCells(old_div(e.size, 5), arr)
vtkMesh.SetCells(10, tet)
centroids = (n[e[:, 1]] + n[e[:, 2]] + n[e[:, 3]] + n[e[:, 4]])
centroids /= 4.0
arr = numpy_support.numpy_to_vtk(
centroids.ravel(), deep=True, array_type=vtk.VTK_FLOAT)
arr.SetName("Centroids")
arr.SetNumberOfComponents(3)
vtkMesh.GetCellData().AddArray(arr)
self.vtkMeshes[filename] = vtkMesh
def findLocalCsys(self, filename):
poly = vtk.vtkGeometryFilter()
poly.SetInputData(self.vtkMeshes[filename])
poly.Update()
distanceFilter = vtk.vtkImplicitPolyDataDistance()
distanceFilter.SetInput(poly.GetOutput())
gradients = vtk.vtkFloatArray()
gradients.SetNumberOfComponents(3)
gradients.SetName("LevelSet Normals")
distances = vtk.vtkFloatArray()
distances.SetNumberOfComponents(1)
distances.SetName("Signed Distances")
N = self.vtkMeshes[filename].GetCellData().GetArray(
"Centroids").GetNumberOfTuples()
for i in range(N):
g = np.zeros(3, np.float32)
p = self.vtkMeshes[filename].GetCellData().GetArray(
"Centroids").GetTuple3(i)
d = distanceFilter.EvaluateFunction(p)
distanceFilter.EvaluateGradient(p, g)
g = old_div(np.array(g), np.linalg.norm(np.array(g)))
gradients.InsertNextTuple(g)
distances.InsertNextValue(d)
self.vtkMeshes[filename].GetCellData().AddArray(gradients)
self.vtkMeshes[filename].GetCellData().AddArray(distances)
class Statistics(Page):
"""This class provides the statistics view, in table and graphical form"""
def __init__(self, mainUI):
super().__init__(mainUI)
self.columnconfigure(0, weight=1)
self.back_button = Button(self,
text="< Back",
command=lambda: self.go_to("Welcome")())
self.back_button.grid(row=1, padx=(10, 0), pady=(10, 5), sticky="w")
self.choose_date_label = Label(self,
text="View statistics from event on: ")
self.choose_date_label.grid(row=1, column=1)
self.date_to_view = StringVar(name="date")
self.choose_date_menu = OptionMenu(self, self.date_to_view,
*StatsData.available_dates())
self.date_to_view.set(StatsData.available_dates()[0])
self.choose_date_menu.grid(row=1, column=2)
self.date_to_view.trace("w", self.update_ui)
# hide border
# https://groups.google.com/forum/#!topic/comp.lang.tcl/8a6e4tfWJvo
s = Style(self)
s.configure('flat.TNotebook', borderwidth=0)
self.tabbed_section = Notebook(self, style="flat.TNotebook")
# # FIXME: padding
self.tabbed_section.grid(row=2, columnspan="3", padx=20, sticky="n")
#
self.button = Button(self,
text="Export event statistics as CSV",
command=self.csv_export)
self.button.grid(row=3, columnspan="3", pady=10, sticky="n")
self.update_ui()
def update_ui(self, *args):
new_date = StatsData.dates[self.date_to_view.get()]
for tab in self.tabbed_section.tabs():
self.tabbed_section.forget(tab)
for package in StatsData.packages_for_date(new_date):
test_tab = PackageView(self.tabbed_section, new_date, package)
self.tabbed_section.add(test_tab, text=package)
def csv_export(self):
date = StatsData.dates[self.date_to_view.get()]
file_path = filedialog.asksaveasfilename(filetypes=(("CSV", ".csv"), ),
initialfile=date)
# code taken from https://docs.python.org/3/library/csv.html
if file_path:
with open(file_path, 'w', newline='') as csvfile:
csvwriter = csv.writer(csvfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
csvwriter.writerow(("package name", "quiz", "question id",
"question text", "total times shown",
"successful answers", "skips", "abandons"))
for package in StatsData.packages_for_date(date):
for quiz in StatsData.quizzes_for_package(package, date):
for q in StatsData.get_data(date, package, quiz):
csvwriter.writerow(
(q.package_name, q.quiz, q.q_id, q.text,
total_times_shown(q), q.successes, q.skips,
q.abandons))
class ExplorerProGui(BanyanBase):
"""
The Pimoroni Explorer-Pro For Raspberry Pi Demo Station GUI
"""
def __init__(self, **kwargs):
"""
Build the main screen as a notebook.
"""
# initialize the parent class
super(ExplorerProGui, self).__init__(
back_plane_ip_address=kwargs['back_plane_ip_address'],
subscriber_port=kwargs['subscriber_port'],
publisher_port=kwargs['publisher_port'],
process_name=kwargs['process_name'])
self.set_subscriber_topic('report_from_hardware')
self.main = Tk()
self.main.title('Demo Station For Explorer-Pro HAT')
# gives weight to the cells in the grid
rows = 0
while rows < 50:
self.main.rowconfigure(rows, weight=1)
self.main.columnconfigure(rows, weight=1)
rows += 1
# Defines and places the notebook widget
self.nb = Notebook(self.main, padding=20, height=300, width=800)
self.nb.grid(row=1, column=0, columnspan=50, rowspan=49, sticky='NESW')
# create the analog inputs tab
self.analog_inputs_tab = Frame(self.nb, padding=[130, 20])
self.nb.add(self.analog_inputs_tab, text='Analog Inputs')
# create an instance of the AnalogInputs class
self.analog_inputs = AnalogInputs(self.analog_inputs_tab, self)
# create the digital inputs tab
self.digital_inputs_tab = Frame(self.nb, padding=[130, 20])
self.nb.add(self.digital_inputs_tab, text='Digital Inputs')
# create an instance of the DigitalInputs class
# to populate and control Signal inputs
self.digital_inputs = DigitalInputs(self.digital_inputs_tab, self)
# create the touch tab
self.touch_tab = Frame(self.nb, padding=10)
self.nb.add(self.touch_tab, text='Touch Inputs')
self.touch_inputs = TouchInputs(self.touch_tab, self)
# create the digital outputs tab
self.digital_outputs_tab = Frame(self.nb, padding=10)
self.nb.add(self.digital_outputs_tab, text='Digital Outputs')
# create an instance of the DigitalOutputs class
# to populate and control digital outputs
self.digital_outputs = DigitalOutputs(self.digital_outputs_tab, self)
# create the LED digital outputs tab
self.led_digital_outputs_tab = Frame(self.nb, padding=10)
self.nb.add(self.led_digital_outputs_tab, text='LED Digital Outputs')
# create an instance of the DigitalOutputs class
# to populate and control digital outputs
self.led_digital_outputs = LedDigitalOutputs(self.led_digital_outputs_tab, self)
# create the pwm output tab
self.pwm_output_tab = Frame(self.nb, padding=10)
self.nb.add(self.pwm_output_tab, text='PWM Outputs')
self.pwm_output = PwmOutputs(self.pwm_output_tab, self)
# create the LED PWM output tab
self.led_pwm_output_tab = Frame(self.nb, padding=10)
self.nb.add(self.led_pwm_output_tab, text='LED PWM Outputs')
self.led_pwm_output = LedPwmOutputs(self.led_pwm_output_tab, self)
# create the dc motors tab
self.motors_tab = Frame(self.nb, padding=10)
self.nb.add(self.motors_tab, text='DC Motors')
self.dc_motors = DcMotors(self.motors_tab, self)
l = Label(self.main,
text='Copyright (c) 2019 Alan Yorinks All Rights Reserved.')
l.config(font="Helvetica 8 ")
l.grid(row=48, column=0, padx=[505, 0])
self.main.after(5, self.get_message)
try:
self.main.mainloop()
except KeyboardInterrupt:
self.on_closing()
def notebook_tab_selection(self):
print(self.nb.tab(self.nb.select(), "text"))
print(self.nb.index(self.nb.select()))
# noinspection DuplicatedCode
def get_message(self):
"""
This method is called from the tkevent loop "after" method.
It will poll for new zeromq messages within the tkinter event loop.
"""
try:
data = self.subscriber.recv_multipart(zmq.NOBLOCK)
self.incoming_message_processing(data[0].decode(),
msgpack.unpackb(data[1],
raw=False))
self.main.after(1, self.get_message)
except zmq.error.Again:
try:
self.main.after(1, self.get_message)
except KeyboardInterrupt:
self.main.destroy()
self.publisher.close()
self.subscriber.close()
self.context.term()
sys.exit(0)
except KeyboardInterrupt:
self.main.destroy()
self.publisher.close()
self.subscriber.close()
self.context.term()
sys.exit(0)
def incoming_message_processing(self, topic, payload):
"""
This method processes the incoming pin state change
messages for GPIO pins set as inputs.
:param topic:
:param payload:
Typical report: {'report': 'digital_input', 'pin': pin,
'value': level, 'timestamp': time.time()}
"""
# if the pin currently input active, process the state change
pin = payload['pin'] - 1
value = payload['value']
timestamp = payload['timestamp']
report_type = payload['report']
if report_type == 'analog_input':
if 0 <= pin <= 3:
self.analog_inputs.set_input_value(pin, value)
self.analog_inputs.set_time_stamp_value(pin, timestamp)
else:
raise RuntimeError('analog pin out of range: ', pin)
elif report_type == 'digital_input':
if 0 <= pin <= 3:
self.digital_inputs.set_input_value(pin, value)
self.digital_inputs.set_time_stamp_value(pin, timestamp)
else:
raise RuntimeError('digital pin out of range')
elif report_type == 'touch':
if 0 <= pin <= 8:
self.touch_inputs.set_input_value(pin, value)
self.touch_inputs.set_time_stamp_value(pin, timestamp)
else:
raise RuntimeError('touch pin out of range')
else:
raise RuntimeError('Unknown report type: ', payload['report'])
def on_closing(self):
"""
Destroy the window
"""
self.clean_up()
self.main.destroy()
class SEMWPConfig(Frame):
def build_classtree(self):
for child in self.classtree.get_children(): # get rid of existing entries in class tree
self.classtree.delete(child) # before building a new one
def insert_subclasses(c, p):
for sc in self.rdfschema.sub_classes(c, recurse=False):
parent = self.classtree.insert(p, 'end',
text=self.rdfschema.resource_label(sc),
open=True, iid=sc,
tags=('include'))
if (self.rdfschema.sub_classes(sc, recurse=False) != []):
insert_subclasses(sc, parent)
for c in self.rdfschema.top_classes():
parent = self.classtree.insert('', 'end',
text=self.rdfschema.resource_label(c),
open=True, iid=c,
tags=('include'))
if (self.rdfschema.sub_classes(c, recurse=False) != []):
insert_subclasses(c, parent)
def open_rdfs(self):
self.rdfsFileName.set(askopenfilename(filetypes=[("ttl","*.ttl")]))
self.rdfschema = SemWP(fname=self.rdfsFileName.get())
if self.rdfschema.name is not None:
self.rdfsName.set(self.rdfschema.name)
else:
self.rdfsName.set('unnamed RDF Schema')
self.build_classtree()
self.saverdfs_btn.config(command=self.save_rdfs, state=NORMAL)
if self.templateFileName.get() is not '':
self.write_btn.config(command=self.write, state=NORMAL)
def open_template(self):
self.templateFileName.set(askopenfilename(filetypes=[("txt","*.txt")]))
with open(self.templateFileName.get()) as infile:
self.template_txt.delete('1.0', END)
self.template_txt.insert(END, infile.read())
if self.template_txt.get('1.0') == '':
raise Exception('%r does not seem to be a valid template'
% self.templateFileName.get())
else:
self.savetemplate_btn.config(command=self.save_template, state=NORMAL)
if self.rdfsName.get() is not '':
self.write_btn.config(command=self.write, state=NORMAL)
def write(self):
self.rdfschema.write_all_metafiles(self.template_txt.get('1.0', END))
def save_template(self):
self.templateFileName.set(asksaveasfilename(filetypes=[("txt","*.txt")]))
with open(self.templateFileName.get(), 'w') as outfile:
if outfile is None:
return
else:
outfile.write(self.template_txt.get('1.0', END) )
def save_rdfs(self):
oldFileName = self.rdfsFileName.get()
self.rdfsFileName.set(asksaveasfilename(filetypes=[("ttl","*.ttl")]))
if self.rdfsFileName.get() is '':
self.rdfsFileName.set(oldFileName)
return
else:
self.rdfschema.g.serialize(self.rdfsFileName.get(), format='turtle')
def set_property_flag(self, p:URIRef):
include = []
plabel = self.rdfschema.resource_label(p, lang='en')
for key in self.propcheckboxes[plabel].vals.keys():
if self.propcheckboxes[plabel].vals[key].get() == 1:
include.append(key)
self.rdfschema.set_pinclude_flags(p, include)
def update_propertyinfo(self):
# Display list of properties for the item currently selected in the classtree iff
# that item is selected to have a custom post type created for it; then,
# create a checkbox for each property of displayed classes which determines what
# type of metadata box is created for that property (if any).
item = self.classtree.focus()
itemref = URIRef(item)
for child in self.propertiesframe.interior.winfo_children():
child.destroy()
showpropertyinfo = False
for inflag in self.rdfschema.g.objects(subject=itemref, predicate=semwp_ns.include):
if inflag == Literal('True'): # sets showpropertyinfo if post type is to be
showpropertyinfo = True # created for class
if showpropertyinfo:
pcount = 0 # property count, used to set grid row of checkbox
self.propcheckboxes = dict()
for p in self.rdfschema.properties(itemref):
proplabel = self.rdfschema.resource_label(p, lang='en')
heading = proplabel + '. Range includes: '
flags=self.rdfschema.get_pinclude_flags(p)
names=['text']
for c in self.rdfschema.g.objects(p, schema.rangeIncludes):
try:
rangelabel = self.rdfschema.resource_label(c, lang='en')
except:
rangelabel = "missing class?" #some sort of dialog should go here
heading = heading +' '+ rangelabel
if c == schema.Text:
names.append('long text')
if flags == []:
self.rdfschema.set_pinclude_flags(p, incl=['text'])
else:
names.append(rangelabel)
if flags == []:
self.rdfschema.set_pinclude_flags(p, incl=[rangelabel])
Label(self.propertiesframe.interior, text=heading, padding='3 0 0 0'
).grid(row=2*pcount, column=0, columnspan=10, sticky=NW)
Label(self.propertiesframe.interior, text='Include as:', padding='32 0 0 9'
).grid(row=2*pcount+1, column=0, sticky=NW)
self.propcheckboxes[proplabel] = CheckbuttonGroup(
self.propertiesframe.interior, names,
command=lambda prop=p: self.set_property_flag(prop),
side=LEFT)
self.propcheckboxes[proplabel].grid(row=2*pcount+1, column=1, sticky=NW)
for name in self.rdfschema.get_pinclude_flags(p):
self.propcheckboxes[proplabel].vals[name].set(1)
pcount += 1
def update_classinfo(self, event):
item = self.classtree.focus()
itemref = URIRef(item)
self.className.set(self.rdfschema.resource_label(itemref, lang='en'))
self.classDescrTxt.configure(state = NORMAL)
self.classDescrTxt.delete('1.0', END)
self.classDescrTxt.insert(END, self.rdfschema.resource_comment(itemref, lang='en'))
self.classDescrTxt.configure(state = DISABLED)
# the following deals with setting the includeclass flag which determines whether
# the class if greyed out or not, setting the includeclass int variable which
# determines the check button state, based on the include property of the class in
# the graph. If the include property is not present for the class it is set to
# 'include' and the flag & checkbutton set accordingly.
count = 0
for o in self.rdfschema.g.objects(itemref, semwp_ns.include):
if o == Literal('False'):
self.includeclass.set(0)
count = 1
# self.includeclassflag.set('was '+o.toPython())
self.classtree.item(itemref, tags=('notinclude'))
self.classtree.tag_configure('notinclude', foreground='gray')
elif o == Literal('True'):
self.includeclass.set(1)
count = 1
# self.includeclassflag.set('was '+o.toPython())
self.classtree.item(itemref, tags=('include'))
self.classtree.tag_configure('include', foreground='black')
if count == 0:
self.rdfschema.set_include_true(itemref)
self.includeclass.set(1)
# self.includeclassflag.set('count 0 set to true')
self.classtree.item(itemref, tags=('include'))
self.classtree.tag_configure('include', foreground='black')
self.update_propertyinfo()
def set_classtree_include(self, i: URIRef, s: str):
if s == 'include':
self.classtree.item(i, tags=('include'))
self.classtree.tag_configure('include', foreground='black')
parent = self.classtree.parent(i)
if parent is not '':
self.set_classtree_include(parent, 'include')
elif s == 'notinclude':
self.classtree.item(i, tags=('notinclude'))
self.classtree.tag_configure('notinclude', foreground='gray')
for child in self.classtree.get_children(i):
self.set_classtree_include(child, 'notinclude')
def include_class(self):
item = self.classtree.focus()
itemref = URIRef(item)
if self.includeclass.get() == 1:
self.rdfschema.set_include_true(itemref)
self.set_classtree_include(itemref, 'include')
elif self.includeclass.get() == 0:
self.rdfschema.set_include_false(itemref)
self.set_classtree_include(itemref, 'notinclude')
# for o in self.rdfschema.g.objects(itemref, semwp_ns.include):
# self.includeclassflag.set(o.toPython())
self.update_propertyinfo()
def create_rdfs_frame(self, master:Notebook):
rdfsframe = Frame(master, padding = '3 3 3 3', width=600, height=400)
Label(rdfsframe, text='RDFS Name:', padding='3 3 3 3').grid(row=0, column=0, padx=3, pady=3)
rdfsNameLbl = Label(rdfsframe, textvariable=self.rdfsName,
background='#bbb', relief=SUNKEN, padding='3 0 3 3')
rdfsNameLbl.grid(row=0, column=1, columnspan=3, sticky=EW, padx=3, pady=6)
self.classtree.heading(column='#0', text='ClassTree')
ysb = Scrollbar(rdfsframe, orient='vertical', command=self.classtree.yview)
xsb = Scrollbar(rdfsframe, orient='horizontal', command=self.classtree.xview)
self.classtree.configure(yscrollcommand=ysb.set)
self.classtree.configure(xscrollcommand=xsb.set)
self.classtree.bind('<<TreeviewSelect>>', self.update_classinfo)
self.classtree.grid(row=1, column=0, columnspan=2, in_=rdfsframe, sticky=NSEW)
self.classtree.lift(rdfsframe)
self.classtree.tag_configure('include', foreground='black')
self.classtree.tag_configure('notinclude', foreground='gray')
ysb.grid(row=1, column=2, sticky=(NS))
xsb.grid(row=2, column=0, columnspan=2, sticky=(EW))
classinfoframe = Frame(rdfsframe, width=300, height=400)
classinfoframe.grid(row=1, column=3, padx=3, pady=3, sticky=(NSEW))
Label(classinfoframe, text='Class Name:',
font='bold', padding='3 3 3 3').grid(row=1, column=0, sticky=NW)
classNameLbl = Label(classinfoframe, textvariable=self.className,
background='#bbb', relief=SUNKEN, padding='3 3 3 3',
font='bold', width=25)
classNameLbl.grid(row=1, column=1, sticky=EW)
Label(classinfoframe, text='Description:',
font='bold', padding='3 3 3 3').grid(row=2, column=0, sticky=NW)
self.classDescrTxt.grid(row=2, column=1, in_=classinfoframe, sticky=EW)
self.classDescrTxt.lift(classinfoframe)
include_chk = Checkbutton(classinfoframe,
text='include this class',
variable=self.includeclass,
command=self.include_class)
include_chk.grid(row=3, column=1, sticky=E)
Label(classinfoframe, text='Properties:',
font='bold', padding='3 3 3 3').grid(row=5, column=0, sticky=NW)
self.propertiesframe.grid(in_ = classinfoframe, row=5, column=1, sticky=(N+E+S+W))
self.propertiesframe.lift(classinfoframe)
classinfoframe.rowconfigure(5, weight=1)
classinfoframe.columnconfigure(1, weight=1)
rdfsframe.columnconfigure(1, weight=1)
rdfsframe.columnconfigure(3, weight=3)
rdfsframe.rowconfigure(1, weight=1)
master.add(rdfsframe, text='RDFS')
def create_status_bar(self, master):
statbar = Frame(master, padding = '3 3 3 3')
statbar.grid(column=0, row=2, sticky=(EW, S))
Label(statbar, text='RDFS File:', padding='0 3 0 3').grid(row=0, column=0, sticky=SE)
rdfsFileNameLbl = Label(statbar, textvariable=self.rdfsFileName,
background='#bbb', relief=SUNKEN, padding='3 3 3 3')
rdfsFileNameLbl.grid(column=1, row=0, sticky=(EW))
Label(statbar, text='Template file:', padding='0 3 0 3').grid(row=1, column=0, sticky=SE)
templateFileNameLbl = Label(statbar, textvariable=self.templateFileName,
background='#bbb', relief=SUNKEN, padding='3 3 3 3')
templateFileNameLbl.grid(column=1, row=1, sticky=(EW))
statbar.columnconfigure(1, weight=1)
for child in statbar.winfo_children():
child.grid_configure(padx=3, pady=3)
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
# the following stringvars & widgets reference values used by
# several functions. Declared here for clarity,
# packed in relevant frame when frame is created
# and values set when available.
self.rdfs_btn = Button(master, text="Open\nRDFS",
command=self.open_rdfs)
self.template_btn = Button(master, text="Open\nTemplate",
command=self.open_template)
self.write_btn = Button(master, text="Write\nPHP",
command='', state=DISABLED)
self.savetemplate_btn = Button(master, text="Save\nTemplate",
command='', state=DISABLED)
self.saverdfs_btn = Button(master, text="Save\nRDFS",
command='', state=DISABLED)
btnlst = [self.rdfs_btn, self.template_btn, self.savetemplate_btn, self.saverdfs_btn, self.write_btn]
ButtonBar(master, btnlst, 3, padding='3 3 0 0'
).grid(column=0,row=0, sticky=(N, W))
self.classtree = Treeview(master)
self.rdfsFileName = StringVar()
self.rdfsName = StringVar()
self.templateFileName = StringVar()
self.className = StringVar()
self.classDescrTxt = Text(master,
background='#bbb',
relief=SUNKEN,
wrap=WORD,
height=4,
width=60,
state = DISABLED)
self.propertiesframe = VerticalScrolledFrame(master,
relief=SUNKEN)
# the (variable) widgets in this will have info
# about properties of the selected class
self.includeclass = IntVar()
self.includeclass.set(1)
# self.includeclassflag = StringVar()
# self.includepropsflags=dict()
self.ntbk = Notebook(master, padding='6 12 6 12')
self.create_rdfs_frame(self.ntbk)
self.template_txt = TextPage(self.ntbk, 'Template',
background='#fff',
relief=SUNKEN,
wrap = NONE,
width = 40,
height = 40)
self.ntbk.grid(column=0, row=1, sticky=NSEW)
self.master.columnconfigure(0, weight=1)
self.master.rowconfigure(1, weight=1)
self.create_status_bar(master)
class GuiMain:
def __init__(self):
"""
Main Gui Entrance
"""
tkinter.Tk.report_callback_exception = self.throw
# Main window
self.destroyed = False
LoggerGui.info("Initializing GUI")
self.main_window = tkinter.Tk()
self.main_window.wm_title("DRC Sim Server")
icon = tkinter.PhotoImage(data=Resource("image/icon.gif").resource)
self.main_window.tk.call("wm", "iconphoto", self.main_window, icon)
self.main_window.protocol("WM_DELETE_WINDOW", self.on_closing)
self.main_window.resizable(False, False)
# Notebook
self.tab_id = None
self.notebook = Notebook(self.main_window, width=600, height=300)
self.notebook.grid(column=0, row=0)
self.notebook.bind("<<NotebookTabChanged>>", self.on_tab_changed)
# Run Server Frame
self.frame_run_server = FrameRunServer(self.notebook)
self.notebook.add(self.frame_run_server, text="Run Server")
# Get Key Frame
self.frame_get_key = FrameGetKey(self.notebook)
self.notebook.add(self.frame_get_key, text="Get Key")
# Log Frame
self.frame_log = FrameLog(self.notebook)
self.notebook.add(self.frame_log, text="Log")
# About Frame
self.frame_about = FrameAbout(self.notebook)
self.notebook.add(self.frame_about, text="About")
@staticmethod
def throw(*args):
"""
Throw exceptions from Tkinter
:param args: arguments
:return: None
"""
for arg in args:
if isinstance(arg, Exception):
LoggerGui.throw(arg)
def after(self):
"""
Empty loop to catch KeyboardInterrupt
:return: None
"""
self.main_window.after(1000, self.after)
def start(self):
"""
Start the main window loop
:return:
"""
LoggerGui.info("Opening GUI")
self.after()
self.main_window.mainloop()
LoggerGui.info("GUI Closed")
def stop(self):
"""
Convenience function to call on_closing()
:return: None
"""
self.on_closing()
def on_closing(self):
"""
Close the main window and current tab
:return: None
"""
if self.destroyed:
return
self.destroyed = True
LoggerGui.info("Closing GUI")
if self.tab_id in self.notebook.children:
self.notebook.children[self.tab_id].deactivate()
try:
self.main_window.destroy()
except Exception as e:
LoggerGui.exception(e)
# noinspection PyUnusedLocal
def on_tab_changed(self, event):
"""
Close the previous tab and initialize a new one
:param event: tab event
:return: None
"""
tab_id = self.notebook.select()
tab_index = self.notebook.index(tab_id)
tab_name = self.notebook.tab(tab_index, "text")
LoggerGui.debug("Notebook tab changed to \"%s\" with id %d", tab_name,
tab_index)
self.tab_id = tab_id.split(".")[len(
tab_id.split(".")) - 1] # Parse notebook/tab id to only tab id
if self.notebook.children[self.tab_id].kill_other_tabs():
for tab in self.notebook.children:
if tab != self.tab_id:
self.notebook.children[tab].deactivate()
self.notebook.children[self.tab_id].activate()
Button(top, text="Edit", command=student_update).grid(row=5, column=0)
Button(top, text="Close", command=top.destroy).grid(row=6, column=0)
root = Tk()
note = Notebook()
s_insert = Frame()
s_search = Frame()
g_insert = Frame()
note.add(s_insert, text="Insert")
note.add(s_search, text="search")
note.add(g_insert, text="GradeInsert")
note.grid(row=0, column=0)
Label(s_insert, text='name').grid(row=0, column=0)
name = StringVar()
Entry(s_insert, textvariable=name).grid(row=0, column=1)
Label(s_insert, text='family').grid(row=1, column=0)
family = StringVar()
Entry(s_insert, textvariable=family).grid(row=1, column=1)
Label(s_insert, text='B Date').grid(row=2, column=0)
birth = StringVar()
Entry(s_insert, textvariable=birth).grid(row=2, column=1)
Label(s_insert, text='N. ID').grid(row=3, column=0)
n_id = StringVar()
n_id.trace("w", length)
class Window:
def __init__(self):
# window
self.window = tk.Tk()
self.window.title('ROZLICZENIE MEDIÓW - NA STOKU')
self.window.geometry("2585x1200")
# frame
self.frame_1 = Frame(self.window, width=500, height=500)
self.frame_1.grid(row=0, column=0)
self.frame_2 = Frame(self.window, width=500, height=500)
self.frame_2.grid(row=1, column=0)
# table layout
self.tablayout = Notebook(self.frame_1)
self.tablayout_liczniki = Notebook(self.frame_2)
self.media()
self.start()
self.window.mainloop()
# obsługa bazy danych
# self.conn = sqlite3.connect("water.db")
# self.cursor = self.conn.cursor()
def media(self):
self.woda()
self.gaz()
self.prad()
self.tablayout.grid()
def woda(self):
# tab_WODA
tab_woda = Frame(self.tablayout)
tab_woda.grid()
self.tablayout.add(tab_woda, text="WODA")
tab_stan_licznikow = Frame(self.tablayout_liczniki)
tab_stan_licznikow.grid()
self.tablayout_liczniki.add(tab_stan_licznikow, text="STAN LICZNIKÓW")
# self.stan_licznikow_woda(tab_woda)
def prad(self):
# tab_PRĄD
tab_prad = Frame(self.tablayout)
tab_prad.grid()
for row in range(5):
for column in range(8):
label2 = Label(tab_prad,
text='Row: ' + str(row) + "Column: " +
str(column))
label2.grid(row=row, column=column)
self.tablayout.add(tab_prad, text="PRĄD")
def gaz(self):
# tab_GAZ
tab_gaz = Frame(self.tablayout)
tab_gaz.grid()
for row in range(5):
for column in range(6):
label3 = Label(tab_gaz,
text='Row: ' + str(row) + "Column: " +
str(column))
label3.grid(row=row, column=column)
self.tablayout.add(tab_gaz, text="GAZ")
def stan_licznikow_woda(self, tab_woda):
connection = sqlite3.connect('water.db')
cursor = connection.execute('select * from water')
names = [description[0] for description in cursor.description]
n = 0
for name in names:
name = tk.Label(tab_woda,
text=name,
padx=10,
pady=10,
relief='raised',
border='1',
borderwidth=1)
name.grid(row=4, column=0 + n, padx=5)
n += 1
def start(self):
database_creator.payments_database()
database_creator.water_invoice_database()
database_creator.water_database()
