def MenuAssignments():
AssignmentsWindow = tk.Toplevel(window)
AssignmentsWindow.title("Replenisher Assignments")
AssignmentsWindow.geometry('800x500')
UserList = [
"User Selection",
"User1",
"User2",
"User3"
]
UserVariable = StringVar(AssignmentsWindow)
UserVariable.set(UserList[0]) # default value
UserOptionMenu = tk.OptionMenu(AssignmentsWindow, UserVariable, *UserList)
UserOptionMenu.pack()
TaskList = [
"Task Selection",
"Task1",
"Task2",
"Task3"
]
TaskVariable = StringVar(AssignmentsWindow)
TaskVariable.set(TaskList[0]) # default value
TaskOptionMenu = tk.OptionMenu(AssignmentsWindow, TaskVariable, *TaskList)
TaskOptionMenu.pack()
def AddUserTask():
tkMessageBox.showinfo('Add User and Task', "Added User: "******"; " + "Added Task: " + TaskVariable.get() )
AddUserTaskBT = tk.Button(AssignmentsWindow, text="Add User and Task", command=AddUserTask)
AddUserTaskBT.pack()
#Add a table
'''
RowNum = 2
ColNum = 2
for i in range(RowNum):
for j in range(ColNum):
b = tk.Entry(AssignmentsWindow, text="")
b.grid(row=i, column=j)
b.pack()
'''
#To use tkintertable
tframe = tk.Frame(AssignmentsWindow)
tframe.pack()
model = TableModel()
table = TableCanvas(tframe, model=model)
table.createTableFrame()
model = table.model
data = {'rec1': {'User': '******', 'Task': 'Task1', 'Status': 'Open', 'Rank': 1, 'Priority': 'High', 'Start Time': '05-19-2018 10:30', 'Finish Time': ''},
'rec2': {'User': '******', 'Task': 'Task2', 'Status': 'Open', 'Rank': 2, 'Priority': 'Low', 'Start Time': '05-19-2018 11:30', 'Finish Time': '05-19-2018 22:30'},
'rec3': {'User': '******', 'Task': 'Task3', 'Status': 'Open', 'Rank': 3, 'Priority': 'Low', 'Start Time': '05-19-2018 12:30', 'Finish Time': '05-19-2018 22:45'}
}
model.importDict(data) #Import from a dictionary to populate model
table.redrawTable()
AssignmentsWindow.mainloop()
def demo3(root):
frame = Frame(root)
frame.pack()
model = TableModel()
model.importDict(data)
table = TableCanvas(frame, model=model)
table.createTableFrame()
table.model.data['rec2']['col2'] = 50
table.redrawTable()
class Timetable(Frame):
def __init__(self, parent=None):
self.parent = parent
Frame.__init__(self)
self.main = self.master
self.main.geometry('800x500+0+0')
self.main.title('Sequences of Shifts')
f = Frame(self.main)
f.pack(fill=BOTH,expand=1)
self.table = TableCanvas(f, data=data, cellwidth=150, cellbackgr='#E3F6CE',read_only=True,rowselectedcolor='yellow',rowheaderwidth=100,showkeynamesinheader=True)
self.table.show()
return
def redraw(self):
self.table.redrawTable()
def MenuUser():
UserWindow = tk.Toplevel(window)
UserWindow.title("Add New User")
UserWindow.geometry('800x500')
UserList = [
"Add User"
]
UserVariable = StringVar(UserWindow)
UserVariable.set(UserList[0]) # default value
UserOptionMenu = tk.OptionMenu(UserWindow, UserVariable, *UserList)
UserOptionMenu.pack()
def AddUser():
tkMessageBox.showinfo('WLabs Replenisher', 'Successfully Add New User')
AddUserBT = tk.Button(UserWindow, text="Add User", command=AddUser)
AddUserBT.pack()
#To use tkintertable
tframe = tk.Frame(UserWindow)
tframe.pack()
model = TableModel()
table = TableCanvas(tframe, model=model)
table.createTableFrame()
model = table.model
data = {'rec1': {'ID': 'User1', 'First Name': 'Tom', 'Last Name': 'Cross' },
'rec2': {'ID': 'User2', 'First Name': 'Jim', 'Last Name': 'Wood' },
'rec3': {'ID': 'User3', 'First Name': 'Bryan', 'Last Name': 'Bush' }
}
model.importDict(data) #Import from a dictionary to populate model
table.redrawTable()
#Add New Row button
def AddRowButton():
table.addRow()
table.redrawTable()
AddRowBTN = tk.Button(UserWindow,text='Add New Row', command = AddRowButton)
AddRowBTN.place(relx=0.9, rely=0.15, anchor=tk.CENTER)
UserWindow.mainloop()
def MenuTask():
TaskWindow = tk.Toplevel(window)
TaskWindow.title("Add New Tasks")
TaskWindow.geometry('800x500')
TaskList = [
"Add Task"
]
TaskVariable = StringVar(TaskWindow)
TaskVariable.set(TaskList[0]) # default value
TaskOptionMenu = tk.OptionMenu(TaskWindow, TaskVariable, *TaskList)
TaskOptionMenu.pack()
def AddTask():
tkMessageBox.showinfo('WLabs Replenisher', 'Successfully Add New Task')
AddTaskBT = tk.Button(TaskWindow, text="Add Task", command=AddTask)
AddTaskBT.pack()
#To use tkintertable
tframe = tk.Frame(TaskWindow)
tframe.pack()
model = TableModel()
table = TableCanvas(tframe, model=model)
table.createTableFrame()
model = table.model
data = {'rec1': {'ID': 'Task1', 'Priority': 'High' },
'rec2': {'ID': 'Task2', 'Priority': 'Low' },
'rec3': {'ID': 'Task3', 'Priority': 'Low' }
}
model.importDict(data) #Import from a dictionary to populate model
table.redrawTable()
#Add New Row button
def AddRowButton():
table.addRow()
table.redrawTable()
AddRowBTN = tk.Button(TaskWindow,text='Add New Row', command = AddRowButton)
AddRowBTN.place(relx=0.9, rely=0.15, anchor=tk.CENTER)
TaskWindow.mainloop()
def submit(*value):
print('_____________________________________________________________')
model = TableModel()
# load data
data = load_data(name, value)
# import data to tablemodel
model.importDict(data)
# Create table for records preview
table = TableCanvas(recordsFrame,
name="tablica",
model=model,
width=420,
height=600,
cols=0,
rows=0,
cellwidth=50,
editable=False,
showkeynamesinheader=True,
reverseorder=0)
table.grid(row=0, sticky=W + N + S)
table.createTableFrame()
table.redrawTable()
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()
def openfile():
global table, time, x_angle, y_angle, day, month, year, root, embedFrame, recordsFrame, play
name = tkFileDialog.askopenfilename(initialdir=".",
title="Select file",
filetypes=(("Text File", "*.txt"),
("All Files", "*.*")))
if name == "":
# if file openning was cancelled then return
return
else:
try:
path = name.split('/')
# get date from file name
filename = path[len(path) - 1]
day = filename[6:8]
month = filename[4:6]
year = filename[2:4]
# create data
model = TableModel()
# load data
data = load_data(name)
# import data ti tablemodel
model.importDict(data)
except:
tkMessageBox.showerror("Error", "File reading failed!")
return
# If another file is open already then close it
if table != None:
closefile()
# Change App title to include currently open file
root.title('Smart Egg 3D Visualisation ver.1.1 - ' + filename)
# Create embed frame for pygame window
embedFrame = tk.Frame(root, width=700, height=600)
embedFrame.grid(row=0, column=0)
# Create embed frame for table
recordsFrame = tk.Frame(root, width=450, height=600)
recordsFrame.grid(row=0, column=1)
recordsFrame.pack_propagate(0)
# Create table for records preview
table = TableCanvas(recordsFrame,
name="tablica",
model=model,
width=420,
height=600,
cols=0,
rows=0,
cellwidth=50,
editable=False,
showkeynamesinheader=True,
reverseorder=0)
table.grid(row=0, sticky=W + N + S)
table.createTableFrame()
# arrange columns width and order
model.moveColumn(model.getColumnIndex('time'), 1)
model.moveColumn(model.getColumnIndex('x'), 2)
model.moveColumn(model.getColumnIndex('y'), 3)
model.moveColumn(model.getColumnIndex('z'), 4)
model.moveColumn(model.getColumnIndex('roll'), 5)
model.moveColumn(model.getColumnIndex('pitch'), 6)
model.columnwidths['time'] = 150
table.redrawTable()
# Initiate and embed pygame
os.environ['SDL_WINDOWID'] = str(embedFrame.winfo_id())
#os.environ['SDL_VIDEODRIVER'] = 'windib'
screen = pygame.display.set_mode(SCREEN_SIZE,
HWSURFACE | OPENGL | DOUBLEBUF)
resize(*SCREEN_SIZE)
pygame.init()
pygame.display.init()
#Bind keys and buttons events
root.bind('<ButtonRelease-1>', handle_click) #click release event
root.bind_all("<Up>", handle_arrow_keys) #press Up key event
root.bind_all("<Down>", handle_arrow_keys) #press Down key event
root.bind_all("<Left>", handle_arrow_keys) #press Left key event
root.bind_all("<Right>", handle_arrow_keys) #press Right key event
# Initiate OpenGL
init_opengl()
# Create OpenGL object
egg = Egg((0.7, 0.0, 0.0), (1, .95, .8))
# Load first element
values = get_record(0)
if values != None:
time = values[0] + ' ' + values[1]
x_angle = values[2]
y_angle = values[3]
root.update()
# loop control variable
play = True
while play:
drawXYZCoordinate()
# Draw XYZ axis labels
drawText3D(-1.2, -1.0, -2.4, 'x')
drawText3D(-2.2, -0.6, -2.4, 'y')
drawText3D(-2.2, -1.0, -2.0, 'z')
for event in pygame.event.get():
if event.type == KEYUP:
handle_arrow_keys(event.key)
glPushMatrix()
# rotate object
glRotate(float(x_angle), 0, 0, 1)
glRotate(float(y_angle), 1, 0, 0)
# render object and text
egg.render(pygame)
glPopMatrix()
drawText(0, 2, time)
# refresh screen
pygame.display.flip()
root.update()
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()
def fill_table(self):
# Update accumulated plans
yr_current = date.today().year
yr_accu = [0, 0]
yr_last_1_accu = [0, 0]
yr_last_2_accu = [0, 0]
for uni in self.university_list:
if yr_current in uni.plans:
yr_accu[Class_Science_Index] += uni.plans[yr_current][
Class_Science_Index]
yr_accu[Class_Art_Index] += uni.plans[yr_current][
Class_Art_Index]
uni.update_accumulated_plan(yr_current,
yr_accu[Class_Science_Index],
yr_accu[Class_Art_Index])
if (yr_current - 1) in uni.plans:
yr_last_1_accu[Class_Science_Index] += uni.plans[
yr_current - 1][Class_Science_Index]
yr_last_1_accu[Class_Art_Index] += uni.plans[
yr_current - 1][Class_Art_Index]
uni.update_accumulated_plan(
yr_current - 1, yr_last_1_accu[Class_Science_Index],
yr_last_1_accu[Class_Art_Index])
if (yr_current - 2) in uni.plans:
yr_last_2_accu[Class_Science_Index] += uni.plans[
yr_current - 2][Class_Science_Index]
yr_last_2_accu[Class_Art_Index] += uni.plans[
yr_current - 2][Class_Art_Index]
uni.update_accumulated_plan(
yr_current - 2, yr_last_2_accu[Class_Science_Index],
yr_last_2_accu[Class_Art_Index])
# Filter types for display
self.candidates = []
for uni in self.university_list:
if ((self.type_985_value.get() and uni.type_985)
or (self.type_211_value.get() and uni.type_211)
or (self.type_lead_uni_value.get() and uni.type_lead_uni)
or (self.type_lead_sub_value.get() and uni.type_lead_sub)
or (self.type_others_value.get() and uni.type_985 == 0
and uni.type_211 == 0 and uni.type_lead_uni == 0
and uni.type_lead_sub == 0)
or self.type_all_value.get()):
self.candidates.append(uni)
print "Side of candidates: ", len(self.candidates)
self.candidates.sort(key=lambda x: x.rank)
print "update display based on class and types"
data = {
'rec1': {
'col1': 99.88,
'col2': 108.79,
'label': 'rec1'
},
'rec2': {
'col1': 99.88,
'col2': 108.79,
'label': 'rec2'
}
}
model = TableModel(rows=20, columns=10)
table = TableCanvas(self.table_list, model=model)
table.pack(fill=Tk.BOTH, expand=True)
table.cellbackgr = "white"
table.selectedcolor = 'green'
table.createTableFrame()
model = table.model
model.importDict(
data) # can import from a dictionary to populate model
table.redrawTable()
'''rows = len(self.candidates) + 1
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()
