class Table:
'''
Excel-like table in tkinter gui
'''
def __init__(self, master, columns):
# default params
self.params = {
'cellwidth': 110,
'precision': 6,
}
self.data = []
self.model = TableModel()
self.columns = columns
for column in columns:
self.model.addColumn(colname=column)
self.table = TableCanvas(parent=master, model=self.model, cellwidth=self.params['cellwidth'], read_only=True)
self.table.setSelectedRow(-1)
self.table.show()
self.n_rows = 0
def set_params(self, params):
assert params.keys() == self.params.keys()
self.params = params
self.table.cellwidth = self.params['cellwidth']
self.refresh()
def get_params(self):
return self.params.copy()
def _process_val(self, val):
if val is None:
return 'N/A'
elif isinstance(val, bool):
if val == True: return 'True'
else: return 'False'
elif isinstance(val, float):
if np.isnan(val): return 'N/A'
else: return round(val, self.params['precision'])
else:
return str(val)
def transform_data(self, data_list):
'''
'''
new_data_list = []
for data in data_list:
data = np.array(data, dtype=str)
if len(data.shape) == 1:
data = np.expand_dims(data, axis=1)
assert len(data.shape) == 2
new_data_list.append(data)
return np.hstack(new_data_list)
def load(self, data, transform=False):
'''
'''
if transform:
data = self.transform_data(data)
if len(data) > self.n_rows:
self.model.autoAddRows(len(data) - self.n_rows)
self.data.extend([[None for _ in self.columns] for _ in range(len(data) - self.n_rows)])
elif len(data) < self.n_rows:
self.model.deleteRows(rowlist=range(len(data), self.n_rows))
del self.data[len(data):]
self.n_rows = len(data)
for row in range(self.n_rows):
row_data = data[row]
for j, col in enumerate(self.columns):
self.model.data[row][col] = self._process_val(row_data[j])
self.data[row][self.columns.index(col)] = row_data[j]
self.table.redrawTable()
def insert(self, columns, data, transform=False):
'''
Insert data into bottom of the table
'''
if transform:
data = self.transform_data(data)
old_n_rows = self.n_rows
if len(data) > 0:
self.model.autoAddRows(len(data))
self.data.extend([[None for _ in self.columns] for _ in data])
self.n_rows = old_n_rows + len(data)
if columns is None: columns = self.columns
for i, row in enumerate(range(old_n_rows, self.n_rows)):
row_data = data[i]
for j, col in enumerate(columns):
self.model.data[row][col] = self._process_val(row_data[j])
self.data[row][self.columns.index(col)] = row_data[j]
self.table.redrawTable()
def update(self, columns, data, rowids=None, transform=False):
'''
Update rows of the table (TODO: support single rowid)
'''
if transform:
data = self.transform_data(data)
if rowids is None:
rowids = list(range(len(data)))
new_n_rows = len(data)
if new_n_rows > self.n_rows:
self.model.autoAddRows(new_n_rows - self.n_rows)
self.n_rows = new_n_rows
if columns is None: columns = self.columns
assert len(data) == len(rowids)
for i, row in enumerate(rowids):
row_data = data[i]
for j, col in enumerate(columns):
self.model.data[row][col] = self._process_val(row_data[j])
self.data[row][self.columns.index(col)] = row_data[j]
self.table.redrawTable()
def refresh(self):
'''
'''
for row in range(self.n_rows):
for j, col in enumerate(self.columns):
self.model.data[row][col] = self._process_val(self.data[row][j])
self.table.redrawTable()
def get(self, row, column):
'''
Get the cell value
'''
return self.table.model.data[row][column]
def get_column(self, column):
'''
Get values of a column
'''
return [self.get(row, column) for row in range(self.n_rows)]
def export_csv(self):
'''
Export table content to a csv file
'''
self.table.exportTable()
class GUI:
def __init__(self, database_connection):
self.database_connection = database_connection
self.rowNumber = -1
self.rows = {}
self.X = ""
self.H = 'No'
self.B = 'No'
self.root = tk.Tk()
self.root.title('')
canvas = tk.Canvas(self.root, height=600, width=1500)
canvas.pack()
self.frame = tk.Frame(self.root)
self.frame.place(relx=0, rely=0, relwidth=0.5, relheight=1)
self.tframe = tk.Frame(self.root)
self.tframe.place(relx=0.5, rely=0.0, relwidth=0.5, relheight=0.5)
# table build
self.table = TableCanvas(self.tframe,
rows=2,
cols=4,
cellwidth=175,
state="readonly")
self.table_value = TableCanvas(self.frame,
rows=2,
cols=6,
cellwidth=117,
state="readonly")
self.table_value.show()
self.table.bind('<ButtonRelease-1>',
self.clicked) # Bind the click release event
self.table.model.columnlabels['1'] = "VerifiedDate"
self.table.model.columnlabels['2'] = "Program"
self.table.model.columnlabels['3'] = "OrdPhysician"
self.table.model.columnlabels['4'] = "BandQ"
self.table.show()
self.table_value.model.columnlabels['1'] = "Total Protein"
self.table_value.model.columnlabels['2'] = "Albumin"
self.table_value.model.columnlabels['3'] = "Alpha1"
self.table_value.model.columnlabels['4'] = "Alpha2"
self.table_value.model.columnlabels['5'] = "Beta"
self.table_value.model.columnlabels['6'] = "Gamma"
self.hframe = tk.Frame(self.root)
self.hframe.place(relx=0.5, rely=0.5, relwidth=0.5, relheight=0.57)
self.History = tk.Label(
self.frame,
text='Does this patient have a previous history?',
font=15)
self.History.place(relx=0.13, rely=0.22, relwidth=0.8, relheight=0.1)
self.var1 = tk.IntVar()
self.var1.set('no')
self.button_Y_H = tk.Radiobutton(self.frame,
text="Yes",
font=8,
variable=self.var1,
value='yes',
command=self.HY)
self.button_N_H = tk.Radiobutton(self.frame,
text="No",
font=8,
variable=self.var1,
value='no',
command=self.HN)
self.button_Y_H.place(relx=0.35,
rely=0.35,
relwidth=0.10,
relheight=0.05)
self.button_N_H.place(relx=0.55,
rely=0.35,
relwidth=0.10,
relheight=0.05)
self.Band = tk.Label(
self.frame,
text='Is there a band present in the current study?',
font=15)
self.Band.place(relx=0.13, rely=0.42, relwidth=0.8, relheight=0.1)
self.var2 = tk.IntVar()
self.var2.set('no')
self.button_Y_B = tk.Radiobutton(self.frame,
text="Yes",
font=8,
variable=self.var2,
value='yes',
command=self.BY)
self.button_N_B = tk.Radiobutton(self.frame,
text="No",
font=8,
variable=self.var2,
value='no',
command=self.BN)
self.button_Y_B.place(relx=0.35,
rely=0.53,
relwidth=0.10,
relheight=0.05)
self.button_N_B.place(relx=0.55,
rely=0.53,
relwidth=0.10,
relheight=0.05)
self.comment = tk.Text(self.frame, height=30, width=10)
self.comment.place(relx=0.13, rely=0.60, relwidth=0.8, relheight=0.35)
self.button_next = tk.Button(self.frame,
text="Next",
font=8,
command=self.next_row)
self.button_next.place(relx=0.9,
rely=0.22,
relwidth=0.1,
relheight=0.1)
self.button_prev = tk.Button(self.frame,
text="Previous",
font=8,
command=self.prev_row)
self.button_prev.place(relx=0.06,
rely=0.22,
relwidth=0.1,
relheight=0.1)
self.button_close = tk.Button(self.frame,
text="Close",
font=8,
command=self.close)
self.button_close.place(relx=0.473,
rely=0.95,
relwidth=0.07,
relheight=0.05)
self.button_pickday = tk.Button(self.frame,
text="Pick Day",
font=8,
command=self.pickDate)
self.button_pickday.place(relx=0.4,
rely=0.15,
relwidth=0.1,
relheight=0.05)
self.history_comment = tk.Text(self.hframe, height=30, width=10)
self.history_comment.place(relx=0.1,
rely=0.1,
relwidth=0.8,
relheight=0.6)
self.attending = tk.Label(self.hframe, text='', font=15)
self.attending.place(relx=0.125,
rely=0.75,
relwidth=0.8,
relheight=0.1)
self.date_label = tk.Label(self.frame, text='', font=15)
self.date_label.place(relx=0.5,
rely=0.15,
relwidth=0.16,
relheight=0.05)
# TODO default date to today's date
default_date = '09-08-2016'
self.update_date(default_date)
def update_date(self, new_date):
self.rows = database_connection.get_rows_for_date(new_date)
self.date_label.config(text=new_date)
self.rowNumber = 0
self.resetTK()
def close(self):
self.root.destroy()
def next_row(self):
if self.rowNumber == len(self.rows) - 1:
return
self.rowNumber = self.rowNumber + 1
self.thisRowData = self.rows[self.rowNumber]
self.var1.set('no')
self.var2.set('no')
self.H = 'No'
self.B = 'No'
self.updateTK()
def prev_row(self):
if self.rowNumber == 0:
return
self.rowNumber = self.rowNumber - 1
self.thisRowData = self.rows[self.rowNumber]
self.var1.set('no')
self.var2.set('no')
self.H = 'No'
self.B = 'No'
self.updateTK()
def resetTK(self):
self.rowNumber = -1
self.thisRowData = None
self.next_row()
self.updateTK()
def pickDate(self):
calendarPopupFrame = tk.Toplevel()
calendarObject = Calendar(calendarPopupFrame, self)
def HY(self):
self.H = 'Yes'
self.updateTK()
def HN(self):
self.H = 'No'
self.updateTK()
def BY(self):
self.B = 'Yes'
self.updateTK()
def BN(self):
self.B = 'No'
self.updateTK()
def clicked(self, event): # Click event callback function.
self.updateHistoryComment()
def updateHistoryComment(self):
currentPatientHistoryRecord = self.getCurrentPatientHistoryRecord()
if currentPatientHistoryRecord is None:
return
self.attending.config(
text=currentPatientHistoryRecord.signout_pathologist)
self.history_comment.delete('1.0', tk.END)
self.history_comment.insert(
tk.END, str(currentPatientHistoryRecord.interpretation))
self.table.redrawTable()
def getCurrentPatientHistoryRecord(self):
currentTableRecord = self.table.get_currentRecord()
for ph in self.patient_history:
if currentTableRecord['1'] == ph.get_formatted_verified_time() and \
currentTableRecord['2'] == ph.get_program_description() and \
currentTableRecord['3'] == ph.ordering_provider and \
currentTableRecord['4'] == ph.band_concentration:
return ph
return None
def updateTK(self):
# update button text
self.History.config(text='Case ' + str(self.thisRowData.seq) +
': Does ' + self.thisRowData.patientName +
' have a previous history?')
# update history comment and attending
self.attending.config(text='')
self.history_comment.delete('1.0', tk.END)
self.history_comment.insert(tk.END, str(''))
self.table_value.model.setValueAt(self.thisRowData.pt, 0, 0)
self.table_value.model.setValueAt(self.thisRowData.getAbsAlbuminText(),
0, 1)
self.table_value.model.setValueAt(self.thisRowData.getAbsAlpha1Text(),
0, 2)
self.table_value.model.setValueAt(self.thisRowData.getAbsAlpha2Text(),
0, 3)
self.table_value.model.setValueAt(self.thisRowData.getAbsBetaText(), 0,
4)
self.table_value.model.setValueAt(self.thisRowData.getAbsGammaText(),
0, 5)
self.table_value.model.setValueAt(
str(self.thisRowData.getRelAlbuminText()), 1, 1)
self.table_value.model.setValueAt(
str(self.thisRowData.getRelAlpha1Text()), 1, 2)
self.table_value.model.setValueAt(
str(self.thisRowData.getRelAlpha2Text()), 1, 3)
self.table_value.model.setValueAt(
str(self.thisRowData.getRelBetaText()), 1, 4)
self.table_value.model.setValueAt(
str(self.thisRowData.getRelGammaText()), 1, 5)
self.table_value.redrawTable()
# update suggested comment
new_comment = ""
try:
new_comment = CommentInterpreter.CM(self.thisRowData, self.H,
self.B)
except:
new_comment = "An error occurred when trying to create the comment"
self.comment.delete('1.0', tk.END)
self.comment.insert(tk.END, str(new_comment))
# update historical table
self.table.model.deleteRows()
self.table.clearSelected()
self.table.redrawTable()
if self.thisRowData.mrn is None:
return
self.patient_history = database_connection.get_history(
str(self.thisRowData.mrn))
# add a row for each new history element
for ph in self.patient_history:
new_row_index = self.table.model.addRow() - 1
self.table.model.setValueAt(ph.verified_time.strftime("%Y-%m-%d"),
new_row_index, 0)
self.table.model.setValueAt(ph.get_program_description(),
new_row_index, 1)
self.table.model.setValueAt(ph.ordering_provider, new_row_index, 2)
self.table.model.setValueAt(ph.band_concentration, new_row_index,
3)
self.table.setSelectedRow(0)
self.updateHistoryComment()
def mainloop(self):
self.root.mainloop()
class EventMaker(tk.Frame):
def __init__(self, section_name, master=None, model_name=None, **options):
"""
Frames parameter section inquiries as listed in cEvents.ModelEvents
:param section_name: STR of section name - must be one of: "bce", "..."
:param master: tk.Frame-master
:param options: relief, ...
"""
Frame.__init__(self, master, **options)
if not model_name:
self.mbce = cTFmodel.Hy2OptModel("default")
else:
self.mbce = cTFmodel.Hy2OptModel(model_name)
self.mbce.overwrite_defaults(section_name)
self.sn = section_name
self.number_of_events = 1
self.del_event_var = tk.StringVar()
self.bg_color = self.mbce.bce_bg_colors[self.sn]
self.config(width=ww, height=int(20 * self.mbce.default_dicts[self.sn].keys().__len__()), bg=self.bg_color)
tk.Label(self, text=self.mbce.bce_name_dict[self.sn].upper()).grid(sticky=tk.W, row=0, column=0, columnspan=3, padx=xd, pady=yd)
usr_msg, fg_col = self.chk_model()
self.l_model_check = tk.Label(self, fg=fg_col, width=85, text=usr_msg)
self.l_model_check.grid(sticky=tk.W, row=1, column=0, columnspan=3, padx=xd, pady=yd)
self.par_objects = {"Events": self.mbce.event_file}
if os.path.isfile(dir2tf + "models/" + self.mbce.event_file[0]):
self.mbce.events = fGl.dict_nested_read_from_file(dir2tf + "models/" + self.mbce.event_file[0])
self.table_frame = Frame(self, width=700)
self.table_frame.grid(sticky=tk.EW, row=2, rowspan=2, column=0, columnspan=3, padx=xd, pady=yd)
self.table = TableCanvas(self.table_frame, data=self.mbce.events)
if model_name and self.mbce.events:
self.table.show()
tk.Button(self, text="Add event", command=lambda: self.add_row()).grid(sticky=tk.EW, row=2, column=3, padx=xd, pady=yd)
tk.Button(self, text="Delete event\n(row) No:", command=lambda: self.del_row()).grid(sticky=tk.EW, row=3, column=3, padx=xd, pady=yd)
tk.Entry(self, width=3, textvariable=self.del_event_var).grid(sticky=tk.EW, row=3, column=4, padx=xd, pady=yd)
self.make_up()
def add_row(self):
self.number_of_events += 1
self.table.addRow(self.number_of_events)
def del_row(self):
self.number_of_events -= 1
try:
del_row = int(self.del_event_var.get()) - 1
self.table.setSelectedRow(del_row)
self.table.deleteRow()
except:
showinfo("INFO", "The event number must be a positive integer of a present row number.", parent=self)
return -1
if self.number_of_events < 1:
showinfo("WARNING", "Define at least one event!", parent=self)
def chk_model(self):
if not (self.mbce.name == "default"):
msg0 = "Define inlet flows (for Name-fields of 2d_sa_MODEL_QT_R.shp)\nand outlet WSEs (for Name-fields of 2d_bc_MODEL_HT.shp).\n"
self.mbce.get_boundary_sa_names()
self.mbce.get_boundary_bc_names()
msg1 = str("Identified inlet names: " + ", ".join(self.mbce.bc_dict['sa']))
msg2 = str("\nIdentified outlet names: " + ", ".join(self.mbce.bc_dict['bc']))
return msg0 + msg1 + msg2, "forest green"
else:
msg0 = "NOT AVAILABLE\n\nDefine and select a model.\n"
msg1 = "Event definitions require the prior definition of a mode with a 2d_sa_MODEL_QT_R.shp file (Geometry Tab)."
return msg0 + msg1, "red3"
def make_up(self):
for wid in self.winfo_children():
try:
wid.configure(bg=self.bg_color)
except:
pass
def save_event_file(self):
self.mbce.events = {} # reset events dictionary
for row in range(1, self.table.rows+1):
self.mbce.events.update({row: {}})
for col in self.table.model.columnNames:
try:
self.mbce.events[row].update({col: self.table.model.data[row][col]})
except:
print("Setting %s to 0.0 (no value defined)" % str(col))
self.mbce.events[row].update({col: 0.0})
fGl.dict_nested_write2file(self.mbce.events, dir2tf + "models/" + self.mbce.event_file[0])
def startWindow():
StartWindow = tk.Tk()
StartWindow.title(programTitle)
StartWindow.tk.call('wm', 'iconphoto', StartWindow._w, tk.PhotoImage(file=programIcon))
AuxLabel1 = tk.Label(StartWindow,
text=None)
StartLabel = tk.Label(StartWindow,
text="Main menu",
font="Calibri 14")
MainPacientLabel = tk.Label(StartWindow,
text="The pacient is " + pacientName,
font="Calibri 10")
TableFrameStart = tk.Frame(StartWindow)
#tabela = tk.Label(StartWindow,
# text="A tabela fica aqui!",
# bg="gray")
#grafico = tk.Label(StartWindow,
# text="O grafico fica aqui!",
# bg="gray")
AuxLabel1.pack(side=tk.TOP, pady=5)
StartLabel.pack(side=tk.TOP, padx=100, pady=10)
MainPacientLabel.pack(side=tk.TOP)
#tabela.pack(side=tk.LEFT, padx=25, pady=25, ipadx=200, ipady=200)
TableFrameStart.pack(side=tk.LEFT)
#grafico.pack(side=tk.RIGHT, padx=25, pady=25, ipadx=200, ipady=200)
data = {
'r1': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r2': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r3': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r4': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r5': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r6': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r7': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r8': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r9': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r10': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r11': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0},
'r12': {'Time': 0, 'Voltage': 0, 'Current': 0, 'Impedance': 0}
}
TableModelStart = TableModel()
TableStart = TableCanvas(TableFrameStart,
model=TableModelStart,
cellwidth=120,
columnheight=40,
editable=False
)
TableModelStart.importDict(data)
TableStart.setSelectedRow(-1)
TableStart.show()
#Changing values
TableModelStart.setValueAt(5, 0, 0)
TableStart.redrawTable()
#Ploting a graph in the interface
a.plot(vectorx,vectory)
a.set_xlabel('X axis')
a.set_ylabel('Y axis')
canvas = FigureCanvasTkAgg(f, master= StartWindow)
canvas.draw()
canvas.get_tk_widget().pack(side = tk.RIGHT, expand = False, ipadx=2, ipady=2, padx=25, pady=25)
#Calls the function to pdate the graph
ani = animation.FuncAnimation(f, animate, interval=100, blit=False)
StartWindow.mainloop()
