def __init__(self, parent, *args, **kwargs):
tk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
#navigation frame ------------------------------------------------------
navbar = tk.Frame(borderwidth=3, background="white").pack(side="left")
Label(navbar, text="Select Term").pack(side="top")
TERMS = [
("F16"),
("S17"),
("F17"),
]
self.term = tk.StringVar()
self.term.set("F16")
for text in TERMS:
b = tk.Radiobutton(navbar,
text=text,
bg="light blue",
value=text,
variable=self.term,
command=self.updateStatus)
b.pack(side="top")
b.radiobutton = self.term
periodW = tk.Frame(borderwidth=3).pack(side="right")
Label(periodW, text="Select Period").pack(side="left")
self.period = tk.IntVar()
self.period.set(3)
for periodVal in range(1, 9):
p = tk.Radiobutton(periodW,
text=periodVal,
bg="light blue",
value=periodVal,
variable=self.period,
command=self.updateStatus)
p.pack(side="left")
p.radiobutton = self.period
#Games __________________________________________________________________________________________________________
gamesW = tk.Frame()
gamesW.pack(side="top")
Label(gamesW, text="Select Game").pack(side="top")
#listbox widget to select game
self.game = tk.StringVar()
self.game.set("Protobot")
self.gameListBox = tk.Listbox(gamesW, height=4, selectmode="SINGLE")
self.gameListBox.pack(side="top")
self.gameListBox.bind("<Double-Button-1>", self.OnDouble)
#populate list box
try:
conn = sqlite3.connect('./RoboMatch.db')
curs = conn.cursor()
for row in curs.execute("SELECT game FROM games ORDER BY gameid"):
self.gameListBox.insert(tk.END, row)
conn.close()
except DatabaseError:
print("teams reading exception")
e = sys.exc_info()[0]
print(">Error: %s</p>" % e)
pass
#Frame for listing students -----------------------------------------------------------------------------------
studentsW = tk.Frame()
studentsW.pack(side="right")
Label(studentsW, text="Students").pack(side="top")
student = tk.StringVar()
self.studentsListBox = tk.Listbox(studentsW,
height=4,
selectmode="SINGLE")
self.studentsListBox.pack(side="left")
#studentsListBox.bind("<Double-Button-1>", self.OnDouble)
#populate list box
try:
conn = sqlite3.connect('./RoboMatch.db')
curs = conn.cursor()
curs.execute(
'SELECT * FROM students WHERE term = ? AND period = ?',
(self.term.get(), self.period.get()))
all_rows = curs.fetchall()
#print (all_rows)
self.studentsListBox.delete(0, tk.END)
for row in all_rows:
self.studentsListBox.insert(tk.END, row)
conn.close()
except DatabaseError:
print("students reading exception")
e = sys.exc_info()[0]
print(">Error: %s</p>" % e)
pass
#Frame for teams -------------------------------------------------------------------
teamW = tk.Frame()
teamW.pack()
Label(text="Teams").pack(side="right")
team = tk.StringVar()
self.teamsListBox = tk.Listbox(teamW, height=12, selectmode="SINGLE")
self.teamsListBox.pack(side="left")
#studentsListBox.bind("<Double-Button-1>", self.OnDouble)
#populate list box
try:
conn = sqlite3.connect('./RoboMatch.db')
curs = conn.cursor()
#print('SELECT * FROM teams WHERE term = ? AND period = ?', (self.term.get(), self.period.get()))
#curs.execute('SELECT * FROM teams WHERE term = ? AND period = ?', (self.term.get(), self.period.get()))
curs.execute('SELECT * FROM teams')
all_rows = curs.fetchall()
print("teams data")
print(all_rows)
self.teamsListBox.delete(0, tk.END)
for row in all_rows:
self.teamsListBox.insert(tk.END, row)
conn.close()
except DatabaseError:
print("teams reading exception")
e = sys.exc_info()[0]
print(">Error: %s</p>" % e)
pass
#Frame for matches
matchW = tk.Frame()
matchW.pack()
Label(text="Matches").pack(side="right")
master = tk.Frame()
master.pack()
def __init__(self, parent):
self.parent = parent
Tk.Toplevel.__init__(self)
self.wm_title('FFT (%d,%d) Settings' % self.parent.FigWrap.pos)
self.parent = parent
frm = ttk.Frame(self)
frm.pack(fill=Tk.BOTH, expand=True)
self.protocol('WM_DELETE_WINDOW', self.OnClosing)
self.bind('<Return>', self.TxtEnter)
# Create the OptionMenu to chooses the Chart Type:
self.ctypevar = Tk.StringVar(self)
self.ctypevar.set(self.parent.chartType) # default value
self.ctypevar.trace('w', self.ctypeChanged)
ttk.Label(frm, text="Choose Chart Type:").grid(row=0, column=0)
ctypeChooser = ttk.OptionMenu(frm, self.ctypevar,
self.parent.chartType,
*tuple(self.parent.ChartTypes))
ctypeChooser.grid(row=0, column=1, sticky=Tk.W + Tk.E)
# the Radiobox Control to choose the Field Type
self.FFTList = ['FFT_Bz', 'FFT_perp_in_plane', 'FFT_Ex', 'Chi']
self.FFTTypeVar = Tk.IntVar()
self.FFTTypeVar.set(self.parent.GetPlotParam('FFT_type'))
ttk.Label(frm, text='Choose FFT Plot:').grid(row=2, sticky=Tk.W)
for i in range(len(self.FFTList)):
ttk.Radiobutton(frm,
text=self.FFTList[i],
variable=self.FFTTypeVar,
command=self.RadioFFT,
value=i).grid(row=3 + i, sticky=Tk.W)
# Now the field lim
self.setZminVar = Tk.IntVar()
self.setZminVar.set(self.parent.GetPlotParam('set_y_min'))
self.setZminVar.trace('w', self.setZminChanged)
self.setZmaxVar = Tk.IntVar()
self.setZmaxVar.set(self.parent.GetPlotParam('set_y_max'))
self.setZmaxVar.trace('w', self.setZmaxChanged)
self.Zmin = Tk.StringVar()
self.Zmin.set(str(self.parent.GetPlotParam('y_min')))
self.Zmax = Tk.StringVar()
self.Zmax.set(str(self.parent.GetPlotParam('y_max')))
cb = ttk.Checkbutton(frm, text='Set y min', variable=self.setZminVar)
cb.grid(row=3, column=2, sticky=Tk.W)
self.ZminEnter = ttk.Entry(frm, textvariable=self.Zmin, width=7)
self.ZminEnter.grid(row=3, column=3)
cb = ttk.Checkbutton(frm, text='Set y max', variable=self.setZmaxVar)
cb.grid(row=4, column=2, sticky=Tk.W)
self.ZmaxEnter = ttk.Entry(frm, textvariable=self.Zmax, width=7)
self.ZmaxEnter.grid(row=4, column=3)
# Now whether or not the x and y axes should be in logspace
self.xLogVar = Tk.IntVar()
self.xLogVar.set(self.parent.GetPlotParam('xLog'))
self.xLogVar.trace('w', self.xLogChanged)
self.yLogVar = Tk.IntVar()
self.yLogVar.set(self.parent.GetPlotParam('yLog'))
self.yLogVar.trace('w', self.yLogChanged)
cb = ttk.Checkbutton(frm,
text='k-axis logscale',
variable=self.xLogVar)
cb.grid(row=7, column=0, sticky=Tk.W)
cb = ttk.Checkbutton(frm,
text='y-axis logscale',
variable=self.yLogVar)
cb.grid(row=8, column=0, sticky=Tk.W)
def __init__(self, master):
# Graphical User Interface ----------------------------------------------
self.s = ttk.Style()
self.s.configure('TLabel', foreground='Black', background='white')
self.s.configure('TButton', foreground='black', background='white')
self.s.configure('about.TLabel',
forground='black',
background='#f2d211')
self.s.configure('TEntry', foreground='Blue')
self.s.configure('TCheckbutton',
foreground='black',
background='white')
self.s.configure('TMenubutton',
background='white',
foreground='black',
width=25)
self.s.configure('TLabelframe', foreground='black', background='white')
self.s.configure('TFrame', background='white')
# Window properties -----------------------------------------------------
self.master = master
master.wm_title("LSFR for Python")
master.resizable(0, 0)
# -----------------------------------------------------------------------
# Variables -------------------------------------------------------------
self.option = tk.StringVar(master) # default fit type
self.option.set(fitsTypes[0]) # default fit type
self.directoryString = tk.StringVar(master)
self.fileNameString = tk.StringVar(master)
self.numberOfPointsString = tk.StringVar(master)
self.gridLineCheckCmd = tk.IntVar() # Gridline check command
self.gridLineCheckCmd.set(1)
self.residualsCheckCmd = tk.IntVar() # resiuduals check command
self.residualsCheckCmd.set(1)
self.parametersCheckCmd = tk.IntVar() # parametres check command
self.parametersCheckCmd.set(1)
self.xMinAutoCheckCmd = tk.IntVar() # X min check command
self.xMinAutoCheckCmd.set(1)
self.xMaxAutoCheckCmd = tk.IntVar() # X max check command
self.xMaxAutoCheckCmd.set(1)
self.yMinAutoCheckCmd = tk.IntVar() # Y min check command
self.yMinAutoCheckCmd.set(1)
self.yMaxAutoCheckCmd = tk.IntVar() # Y max check command
self.yMaxAutoCheckCmd.set(1)
# -----------------------------------------------------------------------
# Frames ----------------------------------------------------------------
self.frame0 = tk.Frame(master, bd=2, bg='white')
self.frame1 = tk.LabelFrame(master,
text=" Plot Options ",
background='white')
self.xAxisLimits = tk.LabelFrame(self.frame1,
text=" X-Axis Limits ",
bg='white')
self.yAxisLimits = tk.LabelFrame(self.frame1,
text=" Y-Axis Limits ",
background='white')
self.frame2 = tk.LabelFrame(master,
text=" Data Options ",
background='white')
self.frame3 = tk.LabelFrame(master,
text=" File Preview ",
background='white')
self.frame4 = ttk.Frame(master)
# -----------------------------------------------------------------------
# Frame grid positions --------------------------------------------------
self.frame0.grid(row=0, columnspan=2, sticky='NSEW')
self.frame1.grid(row=1,
columnspan=2,
sticky='NSEW',
padx=5,
pady=5,
ipadx=5,
ipady=15)
self.xAxisLimits.grid(row=0,
column=3,
padx=5,
pady=5,
ipadx=5,
ipady=5,
sticky='E')
self.yAxisLimits.grid(row=1,
rowspan=3,
column=3,
padx=5,
pady=5,
ipadx=5,
ipady=5)
self.frame2.grid(row=2,
rowspan=3,
column=0,
sticky='NESW',
padx=5,
pady=5,
ipadx=1,
ipady=5)
self.frame3.grid(row=2,
rowspan=5,
column=1,
sticky='NESW',
padx=5,
pady=5,
ipadx=0,
ipady=5)
self.frame4.grid(row=6,
column=0,
sticky='NESW',
padx=5,
pady=5,
ipadx=0,
ipady=5)
# -----------------------------------------------------------------------
# Frame 0 widgets ------------------------------------------------------
self.about = ttk.Button(self.frame0, text=" About LSFR ")
self.about.bind("<Button-1>", self.aboutLSFR)
# -----------------------------------------------------------------------
# Frame 0 widgets positions --------------------------------------------
self.about.grid(row=0, padx=7)
# -----------------------------------------------------------------------
# Frame 1 widgets ------------------------------------------------------
self.fitType = ttk.Label(self.frame1, text="Fit type: ")
self.plotTitle = ttk.Label(self.frame1, text="Plot title: ")
self.xLabel = ttk.Label(self.frame1, text="X-axis label: ")
self.yLabel = ttk.Label(self.frame1, text="Y-axis label: ")
self.fitTypeChoice = ttk.OptionMenu(self.frame1, self.option, '',
fitsTypes[0], fitsTypes[1],
fitsTypes[2])
self.plotTitleEntry = ttk.Entry(self.frame1)
self.xLabelEntry = ttk.Entry(self.frame1)
self.yLabelEntry = ttk.Entry(self.frame1)
self.plotTitleEntry.insert(0, string='Plot of my Data')
self.xLabelEntry.insert(0, string='Abscissa')
self.yLabelEntry.insert(0, string='Ordinate')
self.gridLinesCheck = ttk.Checkbutton(self.frame1,
text='Grid lines',
variable=self.gridLineCheckCmd,
onvalue=1,
offvalue=0)
self.residualsCheck = ttk.Checkbutton(self.frame1,
text='Show residual plot',
variable=self.residualsCheckCmd,
onvalue=1,
offvalue=0)
self.showParametersCheck = ttk.Checkbutton(
self.frame1,
text='Show fitted Parameters',
variable=self.parametersCheckCmd,
onvalue=1,
offvalue=0)
self.frame1Spacer = ttk.Label(
self.frame1,
text=" ")
# -----------------------------------------------------------------------
# Frame 1 widgets positions --------------------------------------------
self.fitType.grid(row=0, column=0, pady=30, sticky='E')
self.fitTypeChoice.grid(row=0, column=1, sticky='EW')
self.plotTitle.grid(row=1, column=0, sticky='E')
self.plotTitleEntry.grid(row=1, column=1, sticky='W')
self.xLabel.grid(row=2, column=0, sticky='E')
self.xLabelEntry.grid(row=2, column=1, sticky='W')
self.yLabel.grid(row=3, column=0, sticky='E')
self.yLabelEntry.grid(row=3, column=1, sticky='W')
self.gridLinesCheck.grid(row=4, column=1, sticky='W')
self.residualsCheck.grid(row=5, column=1, sticky='W')
self.showParametersCheck.grid(row=6, column=1, sticky='W')
self.frame1Spacer.grid(row=0, column=2)
# -----------------------------------------------------------------------
# X-Axis Limit widgets -------------------------------------------------
self.xMin = ttk.Label(self.xAxisLimits, text='Min')
self.xMinEntry = ttk.Entry(self.xAxisLimits, width=7, state='disabled')
self.xMinAutoCheck = ttk.Checkbutton(self.xAxisLimits,
variable=self.xMinAutoCheckCmd,
onvalue=1,
offvalue=0,
command=self.disablexMinEntry,
text='Auto')
self.xMax = ttk.Label(self.xAxisLimits, text='Max')
self.xMaxEntry = ttk.Entry(self.xAxisLimits, width=7, state='disabled')
self.xMaxAutoCheck = ttk.Checkbutton(self.xAxisLimits,
variable=self.xMaxAutoCheckCmd,
onvalue=1,
offvalue=0,
command=self.disablexMaxEntry,
text='Auto')
# -----------------------------------------------------------------------
# X-Axis Limit widgets positions ----------------------------------------
self.xMin.grid(row=0, column=0, sticky='E', pady=5)
self.xMinEntry.grid(row=0, column=1, sticky='W', pady=5)
self.xMinAutoCheck.grid(row=0, column=2, padx=1, ipadx=1, pady=5)
self.xMax.grid(row=1, column=0, sticky='E', pady=5)
self.xMaxEntry.grid(row=1, column=1, sticky='W', pady=5)
self.xMaxAutoCheck.grid(row=1, column=2, padx=1, ipadx=1, pady=5)
# -----------------------------------------------------------------------
# Y-Axis Limit widgets -------------------------------------------------
self.yMin = ttk.Label(self.yAxisLimits, text='Min')
self.yMinEntry = ttk.Entry(self.yAxisLimits, width=7, state='disable')
self.yMinAutoCheck = ttk.Checkbutton(self.yAxisLimits,
variable=self.yMinAutoCheckCmd,
onvalue=1,
offvalue=0,
command=self.disableyMinEntry,
text="Auto")
self.yMax = ttk.Label(self.yAxisLimits, text='Max')
self.yMaxEntry = ttk.Entry(self.yAxisLimits, width=7, state='disable')
self.yMaxAutoCheck = ttk.Checkbutton(self.yAxisLimits,
variable=self.yMaxAutoCheckCmd,
onvalue=1,
offvalue=0,
command=self.disableyMaxEntry,
text="Auto")
# -----------------------------------------------------------------------
# Y-Axis Limit widgets positions ----------------------------------------
self.yMin.grid(row=0, column=0, pady=5)
self.yMinEntry.grid(row=0, column=1, pady=5)
self.yMinAutoCheck.grid(row=0, column=2, padx=1, ipadx=1, pady=5)
self.yMax.grid(row=1, column=0, pady=5)
self.yMaxEntry.grid(row=1, column=1, pady=5)
self.yMaxAutoCheck.grid(row=1, column=2, padx=1, ipadx=1, pady=5)
# -----------------------------------------------------------------------
# Frame 2 widgets ------------------------------------------------------
self.loadData = ttk.Button(self.frame2,
text=" Load new data... ",
command=self.openfile)
self.directory = ttk.Label(self.frame2, text="Working directory: ")
self.directoryDisplay = ttk.Entry(self.frame2, width=27)
self.directoryDisplay.insert(0, string='(no directory selected)')
self.directoryDisplay.configure(state='readonly')
self.numberOfPoints = ttk.Label(self.frame2,
text="Number of data points: ")
self.numberOfPointsDisplay = ttk.Label(self.frame2, text="0")
# -----------------------------------------------------------------------
# Frame 2 widgets positions --------------------------------------------
self.directory.grid(row=0, column=0, sticky='E', padx=5, pady=1)
self.directoryDisplay.grid(row=0,
column=1,
sticky='WE',
padx=1,
pady=1)
self.numberOfPoints.grid(row=1, column=0, sticky='E', padx=5, pady=1)
self.numberOfPointsDisplay.grid(row=1,
column=1,
sticky='W',
padx=5,
pady=1)
self.loadData.grid(row=2,
column=0,
sticky='NESW',
padx=5,
pady=1,
columnspan=2)
# -----------------------------------------------------------------------
# Frame 3 widgets ------------------------------------------------------
self.filePreview = tk.Listbox(self.frame3, borderwidth=0, width=40)
self.filePreview.insert(1, '(no file loaded)')
self.filePreview.configure(state='disable')
# -----------------------------------------------------------------------
# Frame 3 widgets positions --------------------------------------------
self.filePreview.pack(fill='both')
# -----------------------------------------------------------------------
# Frame 4 widgets ------------------------------------------------------
self.exit = ttk.Button(self.frame4,
text=' Exit ',
command=self.destroy,
width=4)
self.plot = ttk.Button(self.frame4,
text=" Plot ",
command=self.plot,
width=6)
self.help = ttk.Button(self.frame4,
text=" Help ",
command=self.helpwindow,
width=4)
# -----------------------------------------------------------------------
# Frame 4 widgets positions --------------------------------------------
self.exit.grid(row=0,
column=0,
sticky='EW',
padx=30,
pady=5,
ipadx=5,
ipady=5)
self.plot.grid(row=0,
column=1,
sticky='EW',
padx=30,
pady=5,
ipadx=5,
ipady=5)
self.help.grid(row=0,
column=2,
sticky='EW',
padx=30,
pady=5,
ipadx=5,
ipady=5)
button_login.place(x=75,y=165)
button_message.place(x=75,y=172)
message_popup.place(x=10,y=197)
login_popup.place(x=10,y=197)
filter_title_frame.place(x=5,y=5)
filter_title_label.place(x=110,y=3)
region_label.place(x=5,y=70)
region_entry.place(x=5,y=95)
button_filter.place(x=5,y=190)
filter_popup.place(x=320,y=195)
button_start_process.place(x=160,y=14)
check_button_invisible.place(x=50,y=11)
industry_dropdown.place(x=270,y=70)
for choice in x:
choice=choice.replace("\n","")
choices[choice] = tk.IntVar(value=0)
menu.add_checkbutton(label=choice, variable=choices[choice], onvalue=1, offvalue=0, command=save_industries)
current_companies_label.place(x=5,y=130)
current_companies_entry.place(x=5,y=155)
schools_label.place(x=245,y=130)
schools_entry.place(x=245,y=155)
title_label.place(x=280,y=8)
title_label2.place(x=750,y=1)
# title_label3.place(x=660,y=30)
# title_label3.bind("<Button-1>", lambda e: callback("http://instagram.com/sshakirzargar"))
facebook_button.place(x=750,y=25)
facebook_button.bind("<Button-1>", lambda e: callback("http://facebook.com/sshakirshakeel"))
insta_button.place(x=790,y=25)
insta_button.bind("<Button-1>", lambda e: callback("http://instagram.com/sshakirzargar"))
github_button.place(x=830,y=25)
github_button.bind("<Button-1>", lambda e: callback("http://github.com/shakirshakeelzargar"))
def __init__(self, master, **kwargs):
global x, var, rc
rc = '^[a-zA-Z0-9.?,+-;:&`~"/*<>\'\n\t|\(\)\}\{\[\]\$@!#%=^_ ]+$'
x = Convert()
var = tk.IntVar()
l1 = tk.Label(text="Select a task",
font=("Helvetica", 30, "bold"),
activeforeground="black",
fg="black",
bg="yellow")
l1.place(x=140, y=100)
l2 = tk.Label(text="Message:",
font=("Helvetica", 20, "bold"),
activeforeground="black",
fg="black",
bg="yellow")
l2.place(x=140, y=400)
textBox1 = tk.Text(height=5,
width=80,
relief="sunken",
bd=5,
font=("Helvetica", 15))
textBox1.configure(state='disabled')
textBox1.place(x=340, y=400)
textBox2 = tk.Text(height=3,
width=80,
relief="sunken",
bd=5,
font=("Helvetica", 15))
textBox2.configure(state='disabled')
textBox2.place(x=340, y=230)
action = tk.Button(root,
bd=5,
activeforeground="#ffffff",
activebackground="violet",
fg="white",
bg="#ed91af",
width=12,
height=1,
font=("verdana", 15, 'bold'))
btn1 = tk.Button(root,
text="Encode",
bd=5,
activebackground="#ed91af",
bg="#ed91af",
font=("verdana", 20),
command=lambda: self.task(1, textBox1, action))
btn1.place(x=550, y=100)
btn2 = tk.Button(root,
text="Decode",
bd=5,
activebackground="#ed91af",
bg="#ed91af",
font=("verdana", 20),
command=lambda: self.task(2, textBox1, action))
btn2.place(x=1050, y=100)
btn3 = tk.Button(root,
text="Select Image",
bd=5,
activeforeground="#ffffff",
activebackground="violet",
fg="white",
bg="#ed91af",
width=12,
height=1,
font=("verdana", 12, 'bold'),
command=lambda: self.open_img(textBox2))
btn3.place(x=140, y=250)
btn4 = tk.Button(
root,
text="Back",
bd=5,
activeforeground="#ffffff",
activebackground="violet",
fg="white",
bg="#ed91af",
width=12,
height=1,
font=("verdana", 12, 'bold'),
command=lambda: self.back(l1, l2, textBox1, textBox2, btn1, btn2,
btn3, btn4, action))
btn4.place(x=140, y=628)
if (DebugRelaySet):
print("Button number ", thisButtonIndex)
RelaySettings = RelayActionsForButton[thisButtonIndex]
for i in range(len(RelayList)):
thisRelay = RelayList[i]
thisRelay.set(RelaySettings[i])
if (DebugRelaySet):
print("Setting relay", i, "to", RelaySettings[i])
#Here is where we set up the layout for the screen
win = tk.Tk()
#win.geometry("200x200")
win.title("WB1FJ Antenna Switcher")
CurrentButton = tk.IntVar()
tk.Label(win, text="Configuration:").grid(row=0, columnspan=2, sticky=tk.W)
#Here are 2 checkboxes for preamps that are overrides of the standard values for a confiruration.
#For example, you can turn on the preamp while in the local repeater configuration.
tk.Label(win, text="Preamp Override:").grid(row=8, column=0, sticky=tk.E)
tk.Label(
win,
text=
"________________________________________________________________________________"
).grid(row=7, column=0, columnspan=2)
P70Value = tk.IntVar()
Preamp70Button = tk.Checkbutton(win,
text="70Cm",
def main(self):
Frame = ttk.LabelFrame(self, text='Dialogue')
Frame.pack(expand=1, fill='both')
# creating the entry boxes
self.vcmd = (self.register (self.validator ) , '%P' , '%d')
self.vcmd2 = (self.register (self.validator3 ) , '%P' , '%d')
self.txt1 = tk.Label(Frame, text='Music Id:')
self.txt1.place(relx=0.01, rely=0.05)
self.txt2 = tk.Label(Frame, text='Artist Id:')
self.txt2.place(relx=0.01, rely=0.15)
self.id1 = tk.Entry(Frame, width=26, state='disabled',validate = 'key' , validatecommand = self.vcmd2)
self.id1.place(relx=0.15, rely=0.05)
self.id2 = tk.Entry(Frame, width=26, validate = 'key' , validatecommand = self.vcmd, state='disabled')
self.id2.place(relx= 0.15, rely=0.15)
# creating the dropdown menu for the metrics
#tk.Label(Frame, text='Metric:').place(relx=0.58, rely=0.154)
OPTIONS = ['Cosine','Euclidean','Jaccard','manhattan','pearson']
self.metric = tk.StringVar()
self.metric.set(OPTIONS[2]) # default value
option = tk.OptionMenu(Frame,self.metric, *OPTIONS)
option.configure(width=13)
option.place(relx= 0.59, rely=0.14)
# creating the radiobuttons for choosing the similarites you want to check, either between music id or artists id or artist and music
Frame2 = tk.Frame(Frame)
Frame2.place(relx=0.01, rely=0.25)
tk.Label(Frame, text='Similarites Between').place(relx=0.01, rely=0.25)
self.sim_choosen = tk.IntVar()
similarities_opt = [('Musics', 1),('Artists', 2),("Artist & Musics",3)]
for similarity, val in similarities_opt:
tk.Radiobutton(Frame2,
text=similarity,
variable=self.sim_choosen,command=self.getter
,value=val).pack(side='left', pady=20)
# creating the spinbox that would indicate how many no of similarities do want to see..
# this would only work if you are trying to only show the n similarity to an artist or music
tk.Label(Frame, text='N:').place(relx=0.58, rely=0.05)
self.N = tk.Spinbox ( Frame , from_ = 0 , to = 100 , width = 15, state='disabled')
self.N.place(relx= 0.61, rely =0.05)
# creating the calculate button
button = tk.Button(Frame, text='Calculate Similarity', width=16, command = lambda: [f () for f in [self.validator2]])
button.place(relx = 0.50, rely=0.30)
# creating the evalution button
self.eval_button = tk.Button(Frame, text='Evaluation', width=10, state='disabled', command=self.evaluate)
self.eval_button.place(relx = 0.80, rely=0.30)
# progress bar
self.progress_Bar = ttk.Progressbar(Frame, orient='horizontal', length=495, mode='determinate')
self.progress_Bar.place(relx=0.00, rely=0.53)
self.tips = tk.Label(Frame, text='Tips!!')
self.tips.place(relx = 0.45, rely=0.44)
# result panel
tk.Label(Frame, text='Results').place(relx = 0.01, rely=0.62)
tk.Label(Frame, text='Similarity Score:').place(relx=0.03, rely=0.72)
self.Score = tk.Label(Frame, text='')
self.Score.place(relx=0.25, rely=0.72)
# creating the text area for displaying results
Frame2 = tk.Frame(Frame)
Frame2.place(relx=0.50, rely=0.62)
h = tk.Scrollbar(Frame2, orient = 'horizontal')
h.pack(side ='bottom', fill = 'x')
v = tk.Scrollbar(Frame2)
v.pack(side = 'right', fill = 'y')
self.t = tk.Text(Frame2, width = 33, height = 7.4,xscrollcommand = h.set,
yscrollcommand = v.set, state='disabled')
self.t.pack(side='top')
h.config(command=self.t.xview)
v.config(command=self.t.yview)
def __init__(self, master=None, histfile=HISTFILE, **kw):
BaseWidget.__init__(self, master, 'History', **kw)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
self._search_count = tk.IntVar(self)
current_session = CONFIG.getboolean('History', 'current_session', fallback=False)
self._current_session = tk.BooleanVar(self, current_session)
# --- menu
self.menu = tk.Menu(self)
self.menu.add_checkbutton(label='Current session only',
image='img_menu_dummy_cb',
selectimage='img_selected',
indicatoron=False,
compound='left',
command=self._current_session_toggle,
variable=self._current_session)
self.menu.add_command(label='Find',
command=self.find,
image='img_menu_dummy',
compound='left')
syh = AutoHideScrollbar(self, orient='vertical')
self.history = History(self, HISTFILE, current_session,
yscrollcommand=syh.set,
relief='flat', borderwidth=0, highlightthickness=0)
syh.configure(command=self.history.yview)
# --- search bar
self._highlighted = ''
self.frame_search = ttk.Frame(self, padding=2)
self.frame_search.columnconfigure(1, weight=1)
self.entry_search = ttk.Entry(self.frame_search)
self.entry_search.bind('<Return>', self.search)
self.entry_search.bind('<Escape>', lambda e: self.frame_search.grid_remove())
search_buttons = ttk.Frame(self.frame_search)
ttk.Button(search_buttons, style='Up.TButton', padding=0,
command=lambda: self.search(backwards=True)).pack(side='left', padx=2, pady=4)
ttk.Button(search_buttons, style='Down.TButton', padding=0,
command=self.search).pack(side='left', padx=2, pady=4)
self.case_sensitive = ttk.Checkbutton(search_buttons, text='aA')
self.case_sensitive.state(['selected', '!alternate'])
self.case_sensitive.pack(side='left', padx=2, pady=4)
self.regexp = ttk.Checkbutton(search_buttons, text='regexp')
self.regexp.state(['!selected', '!alternate'])
self.regexp.pack(side='left', padx=2, pady=4)
self.full_word = ttk.Checkbutton(search_buttons, text='[-]')
self.full_word.state(['!selected', '!alternate'])
self.full_word.pack(side='left', padx=2, pady=4)
self._highlight_btn = ttk.Checkbutton(search_buttons, image='img_highlight',
padding=0, style='toggle.TButton',
command=self.highlight_all)
self._highlight_btn.pack(side='left', padx=2, pady=4)
frame_find = ttk.Frame(self.frame_search)
ttk.Button(frame_find, padding=0,
command=lambda: self.frame_search.grid_remove(),
style='close.TButton').pack(side='left')
ttk.Label(frame_find, text='Find:').pack(side='right')
frame_find.grid(row=1, column=0, padx=2, pady=4, sticky='ew')
self.entry_search.grid(row=1, column=1, sticky='ew', pady=4, padx=2)
search_buttons.grid(row=1, column=2, sticky='w')
self.bind('<Control-f>', self.find)
self.history.bind('<Control-f>', self.find)
# --- placement
syh.grid(row=0, column=1, sticky='ns')
self.history.grid(row=0, column=0, sticky='nswe')
self.frame_search.grid(row=1, columnspan=2, sticky='we')
self.frame_search.grid_remove()
self.update_style = self.history.update_style
import tkinter as tk
from tkinter import messagebox
form = tk.Tk()
form.title('Alt Kümelerle Sayı Tahmin Oyunu')
form.geometry('1200x600')
form.minsize(1200, 600)
form.maxsize(1200, 600)
x1 = tk.IntVar()
x1.set(0)
x2 = tk.IntVar()
x2.set(0)
x3 = tk.IntVar()
x3.set(0)
x4 = tk.IntVar()
x4.set(0)
x5 = tk.IntVar()
x5.set(0)
x6 = tk.IntVar()
x6.set(0)
x7 = tk.IntVar()
x7.set(0)
def basla():
sonuc = set()
if x1.get() == 1:
def __init__(self, *args, **kw):
super().__init__()
self.configure(background='black')
self.overrideredirect(True)
self.width, self.height = 200, 100
self.p_x, self.p_y = 100, 130
self.isShow = True # 是否隐藏
self.wm_attributes("-alpha", 0.55) # 透明度
# self.wm_attributes("-toolwindow", True) # 置为工具窗口
self.wm_attributes("-topmost", True) # 永远处于顶层
self.bind('<B1-Motion>', self._on_move)
self.bind('<ButtonPress-1>', self._on_tap) # 设置窗口最大化大小
self.bind('<Double-Button-1>', self.quit)
self.bind('<Button-4>', self.zoom_up)
self.bind('<Button-5>', self.zoom_down)
self.resizable(width=False, height=True) # 设置窗口宽度不可变，高度可变
self.canvas = None
self.geometry("%sx%s+%s+%s" % (1, 1, 1, 1))
self.cancel = False #是否取消
# 缩放比例
self.zoom, self.zoom = 1.0, 1.0
#
self.screenWidth = self.winfo_screenwidth()
self.screenHeight = self.winfo_screenheight()
# 变量X和Y用来记录鼠标左键按下的位置
self.X = tk.IntVar(value=0)
self.Y = tk.IntVar(value=0)
filename = 'all.gif'
im = ImageGrab.grab()
im = ImageEnhance.Brightness(im).enhance(0.9)
im.save(filename)
im.close()
time.sleep(0.1)
# 创建顶级组件容器
self.top = tk.Toplevel(self,
width=self.screenWidth,
height=self.screenHeight)
# 不显示最大化、最小化按钮
self.top.overrideredirect(True)
self.topcanvas = tk.Canvas(self.top,
bg='white',
width=self.screenWidth,
height=self.screenHeight)
# 绑定鼠标事件
def onEscPressd(event):
print('top - esc')
self.cancel = True
self.top.destroy()
# self.quit(0)
# exit()
# self.topcanvas.bind('<Escape>', onEscPressd)
self.topcanvas.bind('<Button-2>', onEscPressd)
# 鼠标左键按下的位置
def onLeftButtonDown(event):
# pdb.set_trace()
self.X.set(event.x)
self.Y.set(event.y)
# 开始截图
self.sel = True
self.topcanvas.bind('<Button-1>', onLeftButtonDown)
# 鼠标左键移动，显示选取的区域
def onLeftButtonMove(event):
# pdb.set_trace()
global lastDraw, r, c
try:
# 删除刚画完的图形，要不然鼠标移动的时候是黑乎乎的一片矩形
self.topcanvas.delete(lastDraw)
self.topcanvas.delete(r)
self.topcanvas.delete(c)
except Exception as e:
pass
# 没有点击左键时绘制十字线
r = self.topcanvas.create_line(0,
event.y,
self.screenWidth,
event.y,
fill='white')
c = self.topcanvas.create_line(event.x,
0,
event.x,
self.screenHeight,
fill='white')
if not self.sel:
# print(event.x, event.y, self.screenWidth, self.screenHeight)
pass
else:
lastDraw = self.topcanvas.create_rectangle(self.X.get(),
self.Y.get(),
event.x,
event.y,
outline='orange')
# print(event.x, event.y, self.screenWidth, self.screenWidth)
self.topcanvas.bind('<B1-Motion>', onLeftButtonMove)
def onMouseMove(event):
# 不点击时的鼠标移动，绘制十字线
global r, c
try:
# 删除刚画完的图形，要不然鼠标移动的时候是黑乎乎的一片矩形
self.topcanvas.delete(r)
self.topcanvas.delete(c)
except Exception as e:
pass
# 没有点击左键时绘制十字线
r = self.topcanvas.create_line(0,
event.y,
self.screenWidth,
event.y,
fill='white')
c = self.topcanvas.create_line(event.x,
0,
event.x,
self.screenHeight,
fill='white')
self.topcanvas.bind('<Motion>', onMouseMove)
# 获取鼠标左键抬起的位置，保存区域截图
def onLeftButtonUp(event):
try:
self.topcanvas.delete(lastDraw)
except Exception as e:
pass
time.sleep(0.1)
# 考虑鼠标左键从右下方按下而从左上方抬起的截图
left, right = sorted([self.X.get(), event.x])
top, bottom = sorted([self.Y.get(), event.y])
self.position = (left, top + 1, right, bottom)
print(self.position)
self.p_x, self.p_y = left + 2, top + 2
self.width, self.height = right - left - 1, bottom - top - 1
self.pic = ImageGrab.grab((left + 1, top + 1, right, bottom))
# 关闭顶级容器
self.top.destroy()
# 弹出保存截图对话框
# fileName = tk.filedialog.asksaveasfilename(title='保存截图',
# filetypes=[('image','*.jpg *.png')])
if self.pic:
self.pic.save("cut.gif")
self.topcanvas.bind('<ButtonRelease-1>', onLeftButtonUp)
self.topcanvas.pack(fill=tk.BOTH, expand=tk.YES)
# 显示全屏截图，在全屏截图上进行区域截图
self.image = tk.PhotoImage(file=filename)
self.topcanvas.create_image(self.screenWidth // 2,
self.screenHeight // 2,
image=self.image)
self.topcanvas.pack()
self.wait_window(self.top)
if self.cancel:
print('self.cancel')
self.quit(0)
# super().quit()
# exit()
self.run()
self.geometry("%sx%s" % (self.width, self.height))
self.geometry("+%s+%s" % (self.p_x, self.p_y))
self.refresh_data()
self.mainloop()
def __init__(self, parent):
self.parent = parent
self.regex = tkinter.StringVar()
self.text = tkinter.StringVar()
self.ignore_case = tkinter.IntVar()
self.dotall = tkinter.IntVar()
self.regex.trace('w', self.updateRE)
self.text.trace('w', self.updateRE)
self.dotall.trace('w', self.updateRE)
self.ignore_case.trace('w', self.updateRE)
main_frame = tkinter.Frame(self.parent)
regex_label = tkinter.Label(main_frame, text='Regex', underline=0)
regex_entry = tkinter.Entry(main_frame, textvariable=self.regex)
text_label = tkinter.Label(main_frame, text='Text', underline=0)
text_entry = tkinter.Entry(main_frame, textvariable=self.text)
ignore_case_checkbox = tkinter.Checkbutton(main_frame,
text='Ignore case',
variable=self.ignore_case)
dotall_checkbox = tkinter.Checkbutton(main_frame,
text='Dotall',
variable=self.dotall)
regex_label.grid(row=0, column=0, padx=2, pady=2, sticky=tkinter.W)
regex_entry.grid(row=0,
column=2,
columnspan=4,
padx=2,
pady=2,
sticky=tkinter.EW)
text_label.grid(row=1, column=0, padx=2, pady=2, sticky=tkinter.W)
text_entry.grid(row=1,
column=2,
columnspan=4,
padx=2,
pady=2,
sticky=tkinter.EW)
ignore_case_checkbox.grid(row=2, column=2, sticky=tkinter.EW)
dotall_checkbox.grid(row=2, column=4, sticky=tkinter.EW)
self.group_matches = []
self.group_names = []
for i in range(10):
group_label = tkinter.Label(main_frame, text='Group {}'.format(i))
group_name = tkinter.Label(main_frame, text='')
group_match = tkinter.Entry(main_frame)
group_label.grid(row=3 + i,
column=0,
padx=2,
pady=2,
sticky=tkinter.W)
group_name.grid(row=3 + i,
column=1,
padx=2,
pady=2,
sticky=tkinter.W)
group_match.grid(row=3 + i,
column=2,
columnspan=3,
padx=2,
pady=2,
sticky=tkinter.EW)
self.group_names.append(group_name)
self.group_matches.append(group_match)
self.status_label = tkinter.Label(main_frame,
text='',
anchor=tkinter.W)
self.status_label.grid(row=13,
column=0,
columnspan=4,
sticky=tkinter.EW)
main_frame.grid(row=0, column=0, sticky=tkinter.NSEW)
main_frame.columnconfigure(0, weight=0)
main_frame.columnconfigure(2, weight=999)
main_frame.rowconfigure(1, weight=999)
for i in range(1, 13):
main_frame.rowconfigure(i, weight=1)
window = main_frame.winfo_toplevel()
window.columnconfigure(0, weight=1)
window.rowconfigure(0, weight=1)
self.parent.geometry("{0}x{1}+{2}+{3}".format(360, 480, 0, 50))
self.parent.title("Regex")
import tkinter as tk
root = tk.Tk()
v = tk.IntVar()
v.set(1)
languages = [("Python", 1), ("perl", 2), ("Java", 3), ("C++", 4), ("C", 5)]
def ShowChoice():
print(v.get())
tk.Label(root,
text="""Choose your favourite programming language:""",
justify=tk.LEFT,
padx=20).pack()
for val, language in enumerate(languages):
tk.Radiobutton(root,
text=language,
padx=20,
variable=v,
command=ShowChoice,
value=val).pack(anchor=tk.W)
root.mainloop()
root = tkinter.Tk()
root.title("CMS")
lblId = tkinter.Label(root, text="ID", width=12)
lblId.grid(row=0, column=0, columnspan=2)
lblName = tkinter.Label(root, text="Name", width=12)
lblName.grid(row=1, column=0, columnspan=2)
lblAge = tkinter.Label(root, text="Age", width=12)
lblAge.grid(row=2, column=0, columnspan=2)
lblMob = tkinter.Label(root, text="Mobile No", width=12)
lblMob.grid(row=3, column=0, columnspan=2)
varID = tkinter.IntVar()
txtId = tkinter.Entry(root, text="ID", width=12, textvariable=varID)
txtId.grid(row=0, column=2, columnspan=2)
varName = tkinter.StringVar()
txtName = tkinter.Entry(root, text="Name", width=12, textvariable=varName)
txtName.grid(row=1, column=2, columnspan=2)
varAge = tkinter.IntVar()
txtAge = tkinter.Entry(root, text="Age", width=12, textvariable=varAge)
txtAge.grid(row=2, column=2, columnspan=2)
varMob = tkinter.StringVar()
txtMob = tkinter.Entry(root, text="Mobile No", width=12, textvariable=varMob)
txtMob.grid(row=3, column=2, columnspan=2)
add = tkinter.Button(
fileFrame,
text="Add",
command=lambda Lb=Lb: Lb.insert(
'end',
tkFileDialog.askopenfilename(title="Select file",
filetypes=(("txt files", "*.txt"),
("all files", "*.*")))))
add.pack(side='left')
rem = tkinter.Button(fileFrame,
text="Remove",
command=lambda Lb=Lb: Lb.delete('anchor'))
rem.pack()
show = tkinter.IntVar()
save = tkinter.IntVar()
tkinter.Checkbutton(m, text='Display in Window',
variable=show).grid(column=0, row=1, sticky='w')
tkinter.Checkbutton(m, text='Save as File:', variable=save).grid(row=2,
column=0,
sticky='w')
location = tkinter.Entry(m)
location.grid(row=2, column=1)
orderlabel = tkinter.Label(m, text='Order')
orderlabel.grid(row=4, column=0)
order = tkinter.Entry(m)
order.grid(row=4, column=1)
def loop(): #GUI
global tcpClicSock, BtnIP, led_status, BtnVIN, l_VIN, TestMode #The value of tcpClicSock changes in the function loop(),would also changes in global so the other functions could use it.
while True:
root = tk.Tk() #Define a window named root
root.title('Adeept') #Main window title
root.geometry(
'917x630') #Main window size, middle of the English letter x.
root.config(bg=color_bg) #Set the background color of root window
var_spd = tk.StringVar() #Speed value saved in a StringVar
var_spd.set(
1
) #Set a default speed,but change it would not change the default speed value in the car,you need to click button'Set' to send the value to the car
var_x_scan = tk.IntVar() #Scan range value saved in a IntVar
var_x_scan.set(2) #Set a default scan value
# logo =tk.PhotoImage(file = 'logo.png') #Define the picture of logo,but only supports '.png' and '.gif'
# l_logo=tk.Label(root,image = logo,bg=color_bg) #Set a label to show the logo picture
# l_logo.place(x=30,y=13) #Place the Label in a right position
BtnC1 = tk.Button(root,
width=15,
text='Camera Middle',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnC1.place(x=785, y=10)
E_C1 = tk.Entry(root,
show=None,
width=16,
bg="#37474F",
fg='#eceff1',
exportselection=0,
justify='center')
E_C1.place(x=785, y=45) #Define a Entry and put it in position
BtnC2 = tk.Button(root,
width=15,
text='Ultrasonic Middle',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnC2.place(x=785, y=100)
E_C2 = tk.Entry(root,
show=None,
width=16,
bg="#37474F",
fg='#eceff1',
exportselection=0,
justify='center')
E_C2.place(x=785, y=135) #Define a Entry and put it in position
BtnM1 = tk.Button(root,
width=15,
text='Motor A Speed',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnM1.place(x=785, y=190)
E_M1 = tk.Entry(root,
show=None,
width=16,
bg="#37474F",
fg='#eceff1',
exportselection=0,
justify='center')
E_M1.place(x=785, y=225) #Define a Entry and put it in position
BtnM2 = tk.Button(root,
width=15,
text='Motor B Speed',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnM2.place(x=785, y=280)
E_M2 = tk.Entry(root,
show=None,
width=16,
bg="#37474F",
fg='#eceff1',
exportselection=0,
justify='center')
E_M2.place(x=785, y=315) #Define a Entry and put it in position
BtnT1 = tk.Button(root,
width=15,
text='Look Up Max',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnT1.place(x=785, y=370)
E_T1 = tk.Entry(root,
show=None,
width=16,
bg="#37474F",
fg='#eceff1',
exportselection=0,
justify='center')
E_T1.place(x=785, y=405) #Define a Entry and put it in position
BtnT2 = tk.Button(root,
width=15,
text='Look Down Max',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnT2.place(x=785, y=460)
E_T2 = tk.Entry(root,
show=None,
width=16,
bg="#37474F",
fg='#eceff1',
exportselection=0,
justify='center')
E_T2.place(x=785, y=495) #Define a Entry and put it in position
BtnLED = tk.Button(root,
width=15,
text='Lights ON',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnLED.place(x=300, y=420)
BtnOCV = tk.Button(root,
width=15,
text='OpenCV',
fg=color_text,
bg=color_btn,
relief='ridge',
command=call_opencv)
BtnOCV.place(x=30, y=420)
BtnFL = tk.Button(root,
width=15,
text='Find Line',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnFL.place(x=165, y=420)
BtnSR3 = tk.Button(root,
width=15,
text='Sphinx SR',
fg=color_text,
bg=color_btn,
relief='ridge',
command=call_SR3)
BtnSR3.place(x=300, y=495)
E_C1.insert(0, 'Default:425')
E_C2.insert(0, 'Default:425')
E_M1.insert(0, 'Default:100')
E_M2.insert(0, 'Default:100')
E_T1.insert(0, 'Default:662')
E_T2.insert(0, 'Default:295')
can_scan = tk.Canvas(root,
bg=color_can,
height=250,
width=320,
highlightthickness=0) #define a canvas
can_scan.place(x=440, y=330) #Place the canvas
line = can_scan.create_line(0, 62, 320, 62,
fill='darkgray') #Draw a line on canvas
line = can_scan.create_line(0, 124, 320, 124,
fill='darkgray') #Draw a line on canvas
line = can_scan.create_line(0, 186, 320, 186,
fill='darkgray') #Draw a line on canvas
line = can_scan.create_line(160, 0, 160, 250,
fill='darkgray') #Draw a line on canvas
line = can_scan.create_line(80, 0, 80, 250,
fill='darkgray') #Draw a line on canvas
line = can_scan.create_line(240, 0, 240, 250,
fill='darkgray') #Draw a line on canvas
x_range = var_x_scan.get()
can_tex_11 = can_scan.create_text(
(27, 178), text='%sm' % round(
(x_range / 4), 2), fill='#aeea00') #Create a text on canvas
can_tex_12 = can_scan.create_text(
(27, 116), text='%sm' % round(
(x_range / 2), 2), fill='#aeea00') #Create a text on canvas
can_tex_13 = can_scan.create_text(
(27, 54), text='%sm' % round(
(x_range * 0.75), 2), fill='#aeea00') #Create a text on canvas
def spd_set(): #Call this function for speed adjustment
tcpClicSock.send(('spdset:%s' % var_spd.get()).encode(
)) #Get a speed value from IntVar and send it to the car
l_ip_2.config(
text='Speed:%s' %
var_spd.get()) #Put the speed value on the speed status label
def EC1_set(event): #Call this function for speed adjustment
tcpClicSock.send(('EC1set:%s' % E_C1.get()).encode(
)) #Get a speed value from IntVar and send it to the car
def EC2_set(event): #Call this function for speed adjustment
tcpClicSock.send(('EC2set:%s' % E_C2.get()).encode(
)) #Get a speed value from IntVar and send it to the car
def EM1_set(event): #Call this function for speed adjustment
tcpClicSock.send(('EM1set:%s' % E_M1.get()).encode(
)) #Get a speed value from IntVar and send it to the car
def EM2_set(event): #Call this function for speed adjustment
tcpClicSock.send(('EM2set:%s' % E_M2.get()).encode(
)) #Get a speed value from IntVar and send it to the car
def ET1_set(event): #Call this function for speed adjustment
tcpClicSock.send(('LUMset:%s' % E_T1.get()).encode(
)) #Get a speed value from IntVar and send it to the car
def ET2_set(event): #Call this function for speed adjustment
tcpClicSock.send(('LDMset:%s' % E_T2.get()).encode(
)) #Get a speed value from IntVar and send it to the car
def connect(event): #Call this function to connect with the server
if ip_stu == 1:
sc = thread.Thread(
target=socket_connect) #Define a thread for connection
sc.setDaemon(
True
) #'True' means it is a front thread,it would close when the mainloop() closes
sc.start() #Thread starts
def connect_2(): #Call this function to connect with the server
if ip_stu == 1:
sc = thread.Thread(
target=socket_connect) #Define a thread for connection
sc.setDaemon(
True
) #'True' means it is a front thread,it would close when the mainloop() closes
sc.start() #Thread starts
def socket_connect(): #Call this function to connect with the server
global ADDR, tcpClicSock, BUFSIZ, ip_stu, ipaddr
ip_adr = E1.get() #Get the IP address from Entry
if ip_adr == '': #If no input IP address in Entry,import a default IP
ip_adr = num_import('IP:')
l_ip_4.config(text='Connecting')
l_ip_4.config(bg='#FF8F00')
l_ip_5.config(text='Default:%s' % ip_adr)
pass
SERVER_IP = ip_adr
SERVER_PORT = 10223 #Define port serial
BUFSIZ = 1024 #Define buffer size
ADDR = (SERVER_IP, SERVER_PORT)
tcpClicSock = socket(AF_INET,
SOCK_STREAM) #Set connection value for socket
for i in range(1, 6): #Try 5 times if disconnected
try:
if ip_stu == 1:
print("Connecting to server @ %s:%d..." %
(SERVER_IP, SERVER_PORT))
print("Connecting")
tcpClicSock.connect(ADDR) #Connection with the server
print("Connected")
l_ip_5.config(text='IP:%s' % ip_adr)
l_ip_4.config(text='Connected')
l_ip_4.config(bg='#558B2F')
replace_num('IP:', ip_adr)
E1.config(state='disabled') #Disable the Entry
Btn14.config(state='disabled') #Disable the Entry
ip_stu = 0 #'0' means connected
at = thread.Thread(
target=code_receive
) #Define a thread for data receiving
at.setDaemon(
True
) #'True' means it is a front thread,it would close when the mainloop() closes
at.start() #Thread starts
SR_threading = thread.Thread(
target=voice_command_thread
) #Define a thread for ultrasonic tracking
SR_threading.setDaemon(
True
) #'True' means it is a front thread,it would close when the mainloop() closes
SR_threading.start() #Thread starts
video_thread = thread.Thread(
target=video_show
) #Define a thread for data receiving
video_thread.setDaemon(
True
) #'True' means it is a front thread,it would close when the mainloop() closes
print('Video Connected')
video_thread.start() #Thread starts
ipaddr = tcpClicSock.getsockname()[0]
break
else:
break
except Exception:
print("Cannot connecting to server,try it latter!")
l_ip_4.config(text='Try %d/5 time(s)' % i)
l_ip_4.config(bg='#EF6C00')
print('Try %d/5 time(s)' % i)
ip_stu = 1
time.sleep(1)
continue
if ip_stu == 1:
l_ip_4.config(text='Disconnected')
l_ip_4.config(bg='#F44336')
def code_receive(): #A function for data receiving
global led_status, ipcon, findline_status, auto_status, opencv_status, speech_status, TestMode
while True:
code_car = tcpClicSock.recv(
BUFSIZ) #Listening,and save the data in 'code_car'
l_ip.config(text=code_car) #Put the data on the label
#print(code_car)
if not code_car:
continue
elif 'SET' in str(code_car):
print('set get')
set_list = code_car.decode()
set_list = set_list.split()
s1, s2, s3, s4, s5, s6 = set_list[1:]
E_C1.delete(0, 50)
E_C2.delete(0, 50)
E_M1.delete(0, 50)
E_M2.delete(0, 50)
E_T1.delete(0, 50)
E_T2.delete(0, 50)
E_C1.insert(0, '%d' % int(s1))
E_C2.insert(0, '%d' % int(s2))
E_M1.insert(0, '%d' % int(s3))
E_M2.insert(0, '%d' % int(s4))
E_T1.insert(0, '%d' % int(s5))
E_T2.insert(0, '%d' % int(s6))
elif 'list' in str(code_car): #Scan result receiving start
dis_list = []
f_list = []
list_str = code_car.decode()
while True: #Save scan result in dis_list
code_car = tcpClicSock.recv(BUFSIZ)
if 'finished' in str(code_car):
break
list_str += code_car.decode()
l_ip.config(text='Scanning')
dis_list = list_str.split() #Save the data as a list
l_ip.config(text='Finished')
for i in range(
0, len(dis_list)
): #Translate the String-type value in the list to Float-type
try:
new_f = float(dis_list[i])
f_list.append(new_f)
except:
continue
dis_list = f_list
#can_scan.delete(line)
#can_scan.delete(point_scan)
can_scan_1 = tk.Canvas(
root,
bg=color_can,
height=250,
width=320,
highlightthickness=0) #define a canvas
can_scan_1.place(x=440, y=330) #Place the canvas
line = can_scan_1.create_line(
0, 62, 320, 62,
fill='darkgray') #Draw a line on canvas
line = can_scan_1.create_line(
0, 124, 320, 124,
fill='darkgray') #Draw a line on canvas
line = can_scan_1.create_line(
0, 186, 320, 186,
fill='darkgray') #Draw a line on canvas
line = can_scan_1.create_line(
160, 0, 160, 250,
fill='darkgray') #Draw a line on canvas
line = can_scan_1.create_line(
80, 0, 80, 250,
fill='darkgray') #Draw a line on canvas
line = can_scan_1.create_line(
240, 0, 240, 250,
fill='darkgray') #Draw a line on canvas
x_range = var_x_scan.get(
) #Get the value of scan range from IntVar
for i in range(0, len(dis_list)
): #Scale the result to the size as canvas
try:
len_dis_1 = int((dis_list[i] / x_range) *
250) #600 is the height of canvas
pos = int((i / len(dis_list)) *
320) #740 is the width of canvas
pos_ra = int(
((i / len(dis_list)) * 140) +
20) #Scale the direction range to (20-160)
len_dis = int(len_dis_1 *
(math.sin(math.radians(pos_ra)))
) #len_dis is the height of the line
x0_l, y0_l, x1_l, y1_l = pos, (
250 - len_dis), pos, (250 - len_dis
) #The position of line
x0, y0, x1, y1 = (pos +
3), (250 - len_dis +
3), (pos - 3), (
250 - len_dis - 3
) #The position of arc
if pos <= 160: #Scale the whole picture to a shape of sector
pos = 160 - abs(
int(len_dis_1 *
(math.cos(math.radians(pos_ra)))))
x1_l = (x1_l -
math.cos(math.radians(pos_ra)) * 130)
else:
pos = abs(
int(len_dis_1 * (math.cos(
math.radians(pos_ra))))) + 160
x1_l = x1_l + abs(
math.cos(math.radians(pos_ra)) * 130)
y1_l = y1_l - abs(
math.sin(math.radians(pos_ra)) *
130) #Orientation of line
line = can_scan_1.create_line(
pos, y0_l, x1_l, y1_l,
fill=color_line) #Draw a line on canvas
point_scan = can_scan_1.create_oval(
(pos + 3),
y0, (pos - 3),
y1,
fill=color_oval,
outline=color_oval) #Draw a arc on canvas
except:
pass
can_tex_11 = can_scan_1.create_text(
(27, 178),
text='%sm' % round((x_range / 4), 2),
fill='#aeea00') #Create a text on canvas
can_tex_12 = can_scan_1.create_text(
(27, 116),
text='%sm' % round((x_range / 2), 2),
fill='#aeea00') #Create a text on canvas
can_tex_13 = can_scan_1.create_text(
(27, 54),
text='%sm' % round((x_range * 0.75), 2),
fill='#aeea00') #Create a text on canvas
elif '1' in str(code_car): #Translate the code to text
l_ip.config(
text='Moving Forward') #Put the text on the label
elif '2' in str(code_car): #Translate the code to text
l_ip.config(
text='Moving Backward') #Put the text on the label
elif '3' in str(code_car): #Translate the code to text
l_ip.config(
text='Turning Left') #Put the text on the label
elif '4' in str(code_car): #Translate the code to text
l_ip.config(
text='Turning Right') #Put the text on the label
elif '5' in str(code_car): #Translate the code to text
l_ip.config(text='Look Up') #Put the text on the label
elif '6' in str(code_car): #Translate the code to text
l_ip.config(text='Look Down') #Put the text on the label
elif '7' in str(code_car): #Translate the code to text
l_ip.config(text='Look Left') #Put the text on the label
elif '8' in str(code_car): #Translate the code to text
l_ip.config(text='Look Right') #Put the text on the label
elif '9' in str(code_car): #Translate the code to text
l_ip.config(text='Stop') #Put the text on the label
elif '0' in str(code_car): #Translate the code to text
l_ip.config(
text='Follow Mode On') #Put the text on the label
Btn5.config(text='Following', fg='#0277BD', bg='#BBDEFB')
auto_status = 1
elif 'findline' in str(code_car): #Translate the code to text
BtnFL.config(text='Finding', fg='#0277BD', bg='#BBDEFB')
l_ip.config(text='Find Line')
findline_status = 1
elif 'lightsON' in str(code_car): #Translate the code to text
BtnLED.config(text='Lights ON', fg='#0277BD', bg='#BBDEFB')
led_status = 1
l_ip.config(text='Lights On') #Put the text on the label
elif 'lightsOFF' in str(code_car): #Translate the code to text
BtnLED.config(text='Lights OFF',
fg=color_text,
bg=color_btn)
led_status = 0
l_ip.config(text='Lights OFF') #Put the text on the label
elif 'oncvon' in str(code_car):
if TestMode == 0:
BtnOCV.config(text='OpenCV ON',
fg='#0277BD',
bg='#BBDEFB')
BtnFL.config(text='Find Line',
fg=color_text,
bg=color_btn)
l_ip.config(text='OpenCV ON')
opencv_status = 1
elif 'auto_status_off' in str(code_car):
if TestMode == 0:
BtnSR3.config(fg=color_text,
bg=color_btn,
state='normal')
BtnOCV.config(text='OpenCV',
fg=color_text,
bg=color_btn,
state='normal')
BtnFL.config(text='Find Line', fg=color_text, bg=color_btn)
Btn5.config(text='Follow',
fg=color_text,
bg=color_btn,
state='normal')
findline_status = 0
speech_status = 0
opencv_status = 0
auto_status = 0
elif 'voice_3' in str(code_car):
BtnSR3.config(fg='#0277BD', bg='#BBDEFB')
#BtnSR1.config(state='disabled')
#BtnSR2.config(state='disabled')
l_ip.config(text='Sphinx SR') #Put the text on the label
speech_status = 1
elif 'TestVersion' in str(code_car):
TestMode = 1
BtnSR3.config(fg='#FFFFFF', bg='#F44336')
BtnOCV.config(fg='#FFFFFF', bg='#F44336')
s1 = tk.Scale(
root,
label=" < Slow Speed Adjustment Fast >",
from_=0.4,
to=1,
orient=tk.HORIZONTAL,
length=400,
showvalue=0.1,
tickinterval=0.1,
resolution=0.2,
variable=var_spd,
fg=color_text,
bg=color_bg,
highlightthickness=0)
s1.place(x=200, y=100) #Define a Scale and put it in position
s3 = tk.Scale(root,
label="< Near Scan Range Adjustment(Meter(s)) Far >",
from_=1,
to=5,
orient=tk.HORIZONTAL,
length=300,
showvalue=1,
tickinterval=1,
resolution=1,
variable=var_x_scan,
fg=color_text,
bg=color_bg,
highlightthickness=0)
s3.place(x=30, y=320)
l_ip = tk.Label(root,
width=18,
text='Status',
fg=color_text,
bg=color_btn)
l_ip.place(x=30, y=110) #Define a Label and put it in position
l_ip_2 = tk.Label(root,
width=18,
text='Speed:%s' % (var_spd.get()),
fg=color_text,
bg=color_btn)
l_ip_2.place(x=30, y=145) #Define a Label and put it in position
l_ip_4 = tk.Label(root,
width=18,
text='Disconnected',
fg=color_text,
bg='#F44336')
l_ip_4.place(x=637, y=110) #Define a Label and put it in position
l_ip_5 = tk.Label(root,
width=18,
text='Use default IP',
fg=color_text,
bg=color_btn)
l_ip_5.place(x=637, y=145) #Define a Label and put it in position
l_inter = tk.Label(
root,
width=45,
text=
'< Car Adjustment Camera Adjustment>\nW:Move Forward Look Up:I\nS:Move Backward Look Down:K\nA:Turn Left Turn Left:J\nD:Turn Right Turn Right:L\nZ:Auto Mode On Look Forward:H\nC:Auto Mode Off Ultrasdonic Scan:X',
fg='#212121',
bg='#90a4ae')
l_inter.place(x=240, y=180) #Define a Label and put it in position
E1 = tk.Entry(root, show=None, width=16, bg="#37474F", fg='#eceff1')
E1.place(x=170, y=40) #Define a Entry and put it in position
l_ip_3 = tk.Label(root,
width=10,
text='IP Address:',
fg=color_text,
bg='#000000')
l_ip_3.place(x=165, y=15) #Define a Label and put it in position
Btn14 = tk.Button(root,
width=8,
text='Connect',
fg=color_text,
bg=color_btn,
command=connect_2,
relief='ridge')
Btn14.place(x=300, y=35) #Define a Button and put it in position
BtnVIN = tk.Button(root,
width=15,
text='Voice Input',
fg=color_text,
bg=color_btn,
relief='ridge')
BtnVIN.place(x=30, y=495)
l_VIN = tk.Label(root,
width=16,
text='Voice commands',
fg=color_text,
bg=color_btn)
l_VIN.place(x=30, y=465)
#Define buttons and put these in position
Btn0 = tk.Button(root,
width=8,
text='Forward',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn1 = tk.Button(root,
width=8,
text='Backward',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn2 = tk.Button(root,
width=8,
text='Left',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn3 = tk.Button(root,
width=8,
text='Right',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn4 = tk.Button(root,
width=8,
text='Stop',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn5 = tk.Button(root,
width=8,
text='Follow',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn6 = tk.Button(root,
width=8,
text='Left',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn7 = tk.Button(root,
width=8,
text='Right',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn8 = tk.Button(root,
width=8,
text='Down',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn9 = tk.Button(root,
width=8,
text='Up',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn10 = tk.Button(root,
width=8,
text='Home',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn11 = tk.Button(root,
width=8,
text='Exit',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn12 = tk.Button(root,
width=8,
text='Set',
command=spd_set,
fg=color_text,
bg=color_btn,
relief='ridge')
Btn13 = tk.Button(root,
width=8,
height=3,
text='Scan',
fg=color_text,
bg=color_btn,
relief='ridge')
Btn0.place(x=100, y=195)
Btn1.place(x=100, y=230)
Btn2.place(x=30, y=230)
Btn3.place(x=170, y=230)
Btn4.place(x=170, y=275)
Btn5.place(x=30, y=275)
Btn6.place(x=565, y=230)
Btn7.place(x=705, y=230)
Btn8.place(x=635, y=265)
Btn9.place(x=635, y=195)
Btn10.place(x=635, y=230)
Btn11.place(x=705, y=10)
Btn12.place(x=535, y=107)
Btn13.place(x=350, y=330)
# Bind the buttons with the corresponding callback function
Btn0.bind('<ButtonPress-1>', call_forward)
Btn1.bind('<ButtonPress-1>', call_back)
Btn2.bind('<ButtonPress-1>', click_call_Left)
Btn3.bind('<ButtonPress-1>', click_call_Right)
Btn4.bind('<ButtonPress-1>', call_Stop)
Btn5.bind('<ButtonPress-1>', call_auto)
Btn6.bind('<ButtonPress-1>', call_look_left)
Btn7.bind('<ButtonPress-1>', call_look_right)
Btn8.bind('<ButtonPress-1>', call_look_down)
Btn9.bind('<ButtonPress-1>', call_look_up)
Btn10.bind('<ButtonPress-1>', call_ahead)
Btn11.bind('<ButtonPress-1>', call_exit)
Btn13.bind('<ButtonPress-1>', scan)
Btn0.bind('<ButtonRelease-1>', call_stop)
Btn1.bind('<ButtonRelease-1>', call_stop)
Btn2.bind('<ButtonRelease-1>', call_stop)
Btn3.bind('<ButtonRelease-1>', call_stop)
Btn4.bind('<ButtonRelease-1>', call_stop)
BtnC1.bind('<ButtonPress-1>', EC1_set)
BtnC2.bind('<ButtonPress-1>', EC2_set)
BtnM1.bind('<ButtonPress-1>', EM1_set)
BtnM2.bind('<ButtonPress-1>', EM2_set)
BtnT1.bind('<ButtonPress-1>', ET1_set)
BtnT2.bind('<ButtonPress-1>', ET2_set)
BtnFL.bind('<ButtonPress-1>', find_line)
BtnVIN.bind('<ButtonPress-1>', voice_command)
BtnLED.bind('<ButtonPress-1>', lights_ON)
# Bind the keys with the corresponding callback function
root.bind('<KeyPress-w>', call_forward)
root.bind('<KeyPress-a>', call_Left)
root.bind('<KeyPress-d>', call_Right)
root.bind('<KeyPress-s>', call_back)
# When these keys is released,call the function call_stop()
root.bind('<KeyRelease-w>', call_stop)
root.bind('<KeyRelease-a>', call_stop_2)
root.bind('<KeyRelease-d>', call_stop_2)
root.bind('<KeyRelease-s>', call_stop)
root.bind('<KeyRelease-f>', lights_ON)
root.bind('<KeyRelease-e>', find_line)
root.bind('<KeyRelease-q>', voice_command)
# Press these keyss to call the corresponding function()
root.bind('<KeyPress-c>', call_Stop)
root.bind('<KeyPress-z>', call_auto)
root.bind('<KeyPress-j>', call_look_left)
root.bind('<KeyPress-l>', call_look_right)
root.bind('<KeyPress-h>', call_ahead)
root.bind('<KeyPress-k>', call_look_down)
root.bind('<KeyPress-i>', call_look_up)
root.bind('<KeyPress-x>', scan)
root.bind('<Return>', connect)
root.bind('<Shift_L>', call_stop)
global stat
if stat == 0: # Ensure the mainloop runs only once
root.mainloop() # Run the mainloop()
stat = 1 # Change the value to '1' so the mainloop() would not run again.
def __init__(self,
parent=None,
frameTitle="Test Signal Configurator",
winItemObject=None,
itemSet=None,
geometry="300x400+600+300",
*arg,
**kw):
super(WindowConfigTestSignal,
self).__init__(parent=parent,
frameTitle=frameTitle,
winItemObject=winItemObject,
itemSet=itemSet,
geometry=geometry,
*arg,
**kw)
self.frameElementValue = ttk.Frame(self.top)
self.frameElementValue.pack(side=tk.TOP, fill=tk.X, expand=False)
frameSampling = ttk.Frame(self.top)
frameSampling.pack(side=tk.TOP, fill=tk.X, expand=False)
sampling_label = ttk.Label(frameSampling,
text="Sample rate:",
width=15)
sampling_label.pack(side=tk.LEFT, padx=2, pady=2)
self.varSampleRate = tk.DoubleVar()
self.varSampleRate.set(100.0)
sampling_entry = ttk.Entry(frameSampling,
width=10,
textvariable=self.varSampleRate)
sampling_entry.pack(side=tk.LEFT,
fill=tk.X,
expand=False,
padx=2,
pady=2)
frameSampleLength = ttk.Frame(self.top)
frameSampleLength.pack(side=tk.TOP, fill=tk.X, expand=False)
sampleLength_label = ttk.Label(frameSampleLength,
text="Sample length:",
width=15)
sampleLength_label.pack(side=tk.LEFT, padx=2, pady=2)
self.varSampleLength = tk.DoubleVar()
self.varSampleLength.set(4.0 * np.pi)
sampleLength_entry = ttk.Entry(frameSampleLength,
width=10,
textvariable=self.varSampleLength)
sampleLength_entry.pack(side=tk.LEFT,
fill=tk.X,
expand=False,
padx=2,
pady=2)
framePerсentNoise = tk.Frame(self.top)
framePerсentNoise.pack(side=tk.TOP, fill=tk.X, expand=False)
perсentNoise_label = ttk.Label(framePerсentNoise,
text="Perсent noise:",
width=15)
perсentNoise_label.pack(side=tk.LEFT, padx=2, pady=2)
self.varPerсentNoise = tk.DoubleVar()
self.varPerсentNoise.set(0.0)
perсentNoise_entry = ttk.Entry(framePerсentNoise,
width=10,
textvariable=self.varPerсentNoise)
perсentNoise_entry.pack(side=tk.LEFT,
fill=tk.X,
expand=False,
padx=2,
pady=2)
frameElementCount = ttk.Frame(self.top)
frameElementCount.pack(side=tk.TOP, fill=tk.X, expand=False)
elementCount_label = ttk.Label(frameElementCount,
text="Element count:",
width=15)
elementCount_label.pack(side=tk.LEFT, padx=2, pady=2)
self.varElementCount = tk.IntVar()
self.varElementCount.set(1)
elementCount_entry = ttk.Entry(frameElementCount,
width=10,
textvariable=self.varElementCount)
elementCount_entry.pack(side=tk.LEFT,
fill=tk.X,
expand=False,
padx=2,
pady=2)
elementCount_button = ttk.Button(frameElementCount,
text="Create",
command=self.onCreateElements)
elementCount_button.pack(side=tk.RIGHT,
fill=tk.X,
expand=False,
padx=2,
pady=2)
def create_widgets(self):
tabControl = ttk.Notebook(self.win) # Create Tab Control
tab1 = ttk.Frame(tabControl) # Create a tab
tabControl.add(tab1, text='Tab 1') # Add the tab
tab2 = ttk.Frame(tabControl) # Add a second tab
tabControl.add(tab2, text='Tab 2') # Make second tab visible
tabControl.pack(expand=1, fill="both") # Pack to make visible
# LabelFrame using tab1 as the parent
mighty = ttk.LabelFrame(tab1, text=' Mighty Python ')
mighty.grid(column=0, row=0, padx=8, pady=4)
# Modify adding a Label using mighty as the parent instead of win
a_label = ttk.Label(mighty, text="Enter a name:")
a_label.grid(column=0, row=0, sticky='W')
# Adding a Textbox Entry widget
self.name = tk.StringVar()
self.name_entered = ttk.Entry(mighty, width=24, textvariable=self.name)
self.name_entered.grid(column=0, row=1, sticky='W')
# Adding a Button
self.action = ttk.Button(mighty, text="Click Me!", command=self.click_me)
self.action.grid(column=2, row=1)
ttk.Label(mighty, text="Choose a number:").grid(column=1, row=0)
number = tk.StringVar()
self.number_chosen = ttk.Combobox(mighty, width=14, textvariable=number, state='readonly')
self.number_chosen['values'] = (1, 2, 4, 42, 100)
self.number_chosen.grid(column=1, row=1)
self.number_chosen.current(0)
# Adding a Spinbox widget
self.spin = Spinbox(mighty, values=(1, 2, 4, 42, 100), width=5, bd=9, command=self._spin) # using range
self.spin.grid(column=0, row=2, sticky='W') # align left
# Using a scrolled Text control
scrol_w = 40; scrol_h = 10 # increase sizes
self.scrol = scrolledtext.ScrolledText(mighty, width=scrol_w, height=scrol_h, wrap=tk.WORD)
self.scrol.grid(column=0, row=3, sticky='WE', columnspan=3)
for child in mighty.winfo_children(): # add spacing to align widgets within tabs
child.grid_configure(padx=4, pady=2)
#=====================================================================================
# Tab Control 2 ----------------------------------------------------------------------
self.mighty2 = ttk.LabelFrame(tab2, text=' The Snake ')
self.mighty2.grid(column=0, row=0, padx=8, pady=4)
# Creating three checkbuttons
chVarDis = tk.IntVar()
check1 = tk.Checkbutton(self.mighty2, text="Disabled", variable=chVarDis, state='disabled')
check1.select()
check1.grid(column=0, row=0, sticky=tk.W)
chVarUn = tk.IntVar()
check2 = tk.Checkbutton(self.mighty2, text="UnChecked", variable=chVarUn)
check2.deselect()
check2.grid(column=1, row=0, sticky=tk.W)
chVarEn = tk.IntVar()
check3 = tk.Checkbutton(self.mighty2, text="Enabled", variable=chVarEn)
check3.deselect()
check3.grid(column=2, row=0, sticky=tk.W)
# trace the state of the two checkbuttons
chVarUn.trace('w', lambda unused0, unused1, unused2 : self.checkCallback())
chVarEn.trace('w', lambda unused0, unused1, unused2 : self.checkCallback())
# First, we change our Radiobutton global variables into a list
colors = ["Blue", "Gold", "Red"]
# create three Radiobuttons using one variable
self.radVar = tk.IntVar()
# Next we are selecting a non-existing index value for radVar
self.radVar.set(99)
# Now we are creating all three Radiobutton widgets within one loop
for col in range(3):
curRad = tk.Radiobutton(self.mighty2, text=colors[col], variable=self.radVar,
value=col, command=self.radCall)
curRad.grid(column=col, row=1, sticky=tk.W) # row=6
# And now adding tooltips
ToolTip(curRad, 'This is a Radiobutton control')
# Add a Progressbar to Tab 2
self.progress_bar = ttk.Progressbar(tab2, orient='horizontal', length=286, mode='determinate')
self.progress_bar.grid(column=0, row=3, pady=2)
# Create a container to hold buttons
buttons_frame = ttk.LabelFrame(self.mighty2, text=' ProgressBar ')
buttons_frame.grid(column=0, row=2, sticky='W', columnspan=2)
# Add Buttons for Progressbar commands
ttk.Button(buttons_frame, text=" Run Progressbar ", command=self.run_progressbar).grid(column=0, row=0, sticky='W')
ttk.Button(buttons_frame, text=" Start Progressbar ", command=self.start_progressbar).grid(column=0, row=1, sticky='W')
ttk.Button(buttons_frame, text=" Stop immediately ", command=self.stop_progressbar).grid(column=0, row=2, sticky='W')
ttk.Button(buttons_frame, text=" Stop after second ", command=self.progressbar_stop_after).grid(column=0, row=3, sticky='W')
for child in buttons_frame.winfo_children():
child.grid_configure(padx=2, pady=2)
for child in self.mighty2.winfo_children():
child.grid_configure(padx=8, pady=2)
# Creating a Menu Bar
menu_bar = Menu(self.win)
self.win.config(menu=menu_bar)
# Add menu items
file_menu = Menu(menu_bar, tearoff=0)
file_menu.add_command(label="New")
file_menu.add_separator()
file_menu.add_command(label="Exit", command=self._quit)
menu_bar.add_cascade(label="File", menu=file_menu)
# Display a Message Box
def _msgBox():
msg.showinfo('Python Message Info Box', 'A Python GUI created using tkinter:\nThe year is 2019.')
# Add another Menu to the Menu Bar and an item
help_menu = Menu(menu_bar, tearoff=0)
help_menu.add_command(label="About", command=_msgBox) # display messagebox when clicked
menu_bar.add_cascade(label="Help", menu=help_menu)
# Change the main windows icon
self.win.iconbitmap('pyc.ico')
# It is not necessary to create a tk.StringVar()
# strData = tk.StringVar()
strData = self.spin.get()
# call function
self.usingGlobal()
self.name_entered.focus()
# Add Tooltips -----------------------------------------------------
# Add a Tooltip to the Spinbox
ToolTip(self.spin, 'This is a Spinbox control')
# Add Tooltips to more widgets
ToolTip(self.name_entered, 'This is an Entry control')
ToolTip(self.action, 'This is a Button control')
ToolTip(self.scrol, 'This is a ScrolledText control')
def openSettings():
def saveSettings(): #todo add validity checks for variables
ser.write(b"$0=" + str(stepPulseMicro.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$1=" + str(stepIdleDelay.get()).encode() + b"\r")
getGrblResponse()
stepMask = stepInvertX.get()
stepMask = stepMask | (stepInvertY.get() << 1)
stepMask = stepMask | (stepInvertZ.get() << 2)
ser.write(b"$2=" + str(stepMask).encode() + b"\r")
getGrblResponse()
dirMask = directionInvertX.get()
dirMask = dirMask | (directionInvertY.get() << 1)
dirMask = dirMask | (directionInvertZ.get() << 2)
ser.write(b"$3=" + str(dirMask).encode() + b"\r")
getGrblResponse()
ser.write(b"$4=" + str(stepEnableInvert.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$5=" + str(limitPinsInvert.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$6=" + str(probePinInvert.get()).encode() + b"\r")
getGrblResponse()
if str(statusMask.get()) == "Wpos":
ser.write(b"$10=0\r")
elif str(statusMask.get()) == "Mpos":
ser.write(b"$10=1\r")
else:
ser.write(b"$10=2\r")
ser.write(b"$11=" + str(junctionDeviation.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$12=" + str(arcTolerance.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$13=" + str(reportInches.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$20=" + str(softLimits.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$21=" + str(hardLimits.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$22=" + str(homingCycle.get()).encode() + b"\r")
getGrblResponse()
homingInvertMask = homingInvertX.get()
homingInvertMask = homingInvertMask | (homingInvertY.get() << 1)
homingInvertMask = homingInvertMask | (homingInvertZ.get() << 2)
ser.write(b"$23=" + str(homingInvertMask).encode() + b"\r")
getGrblResponse()
ser.write(b"$24=" + str(homingFeed.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$25=" + str(homingSeek.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$26=" + str(homingDebounce.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$27=" + str(homingPulloff.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$30=" + str(maxSpindleSpeed.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$31=" + str(minSpindleSpeed.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$32=" + str(laserMode.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$100=" + str(xStepsMm.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$101=" + str(yStepsMm.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$102=" + str(zStepsMm.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$110=" + str(xMaxRate.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$111=" + str(yMaxRate.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$112=" + str(zMaxRate.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$120=" + str(xAccl.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$121=" + str(yAccl.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$122=" + str(zAccl.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$130=" + str(xMaxTravel.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$131=" + str(yMaxTravel.get()).encode() + b"\r")
getGrblResponse()
ser.write(b"$132=" + str(zMaxTravel.get()).encode() + b"\r")
getGrblResponse()
settingsWindow.destroy()
settingsWindow = tk.Toplevel(window)
settingsWindow.grab_set()
getConfig()
#Step pulse microseconds
stepPulseMicro = tk.StringVar()
stepPulseMicro.set(str(s0))
stepPulseMicroLabel = tk.Label(settingsWindow, text="Step pulse Microseconds: ")
stepPulseMicroLabel.grid(row=0, column=0)
stepPulseMicroEntry = tk.Entry(settingsWindow, textvariable=stepPulseMicro)
stepPulseMicroEntry.grid(row=0,column=1)
#step idle delay
stepIdleDelay = tk.StringVar()
stepIdleDelay.set(str(s1))
stepIdleDelayLabel = tk.Label(settingsWindow, text="Step idle delay Milliseconds: ")
stepIdleDelayLabel.grid(row=1, column=0)
stepIdleDelayEntry = tk.Entry(settingsWindow, textvariable=stepIdleDelay)
stepIdleDelayEntry.grid(row=1,column=1)
#step invert port
stepInvertX = tk.BooleanVar()
stepInvertY = tk.BooleanVar()
stepInvertZ = tk.BooleanVar()
stepInvertX.set(s2 & 1)
stepInvertY.set(s2 & 2)
stepInvertZ.set(s2 & 4)
tk.Label(settingsWindow, text="Step port invert:").grid(row=2, column=0)
tk.Checkbutton(settingsWindow, text="X", variable=stepInvertX).grid(row=2, column=1)
tk.Checkbutton(settingsWindow, text="Y", variable=stepInvertY).grid(row=2, column=2)
tk.Checkbutton(settingsWindow, text="Z", variable=stepInvertZ).grid(row=2, column=3)
#direction invert port
directionInvertX = tk.BooleanVar()
directionInvertY = tk.BooleanVar()
directionInvertZ = tk.BooleanVar()
directionInvertX.set(s3 & 1)
directionInvertY.set(s3 & 2)
directionInvertZ.set(s3 & 4)
tk.Label(settingsWindow, text="Direction port invert:").grid(row=3, column=0)
tk.Checkbutton(settingsWindow, text="X", variable=directionInvertX).grid(row=3, column=1)
tk.Checkbutton(settingsWindow, text="Y", variable=directionInvertY).grid(row=3, column=2)
tk.Checkbutton(settingsWindow, text="Z", variable=directionInvertZ).grid(row=3, column=3)
#step enable invert
stepEnableInvert = tk.IntVar()
stepEnableInvert.set(s4 & 1)
tk.Label(settingsWindow, text="Step enable invert:").grid(row=4, column=0)
tk.Checkbutton(settingsWindow, variable=stepEnableInvert).grid(row=4, column=1)
#limit pins invert
limitPinsInvert = tk.IntVar()
limitPinsInvert.set(s5 & 1)
tk.Label(settingsWindow, text="Limit pins invert:").grid(row=5, column=0)
tk.Checkbutton(settingsWindow, variable=limitPinsInvert).grid(row=5, column=1)
#probe pin invert
probePinInvert = tk.IntVar()
probePinInvert.set(s6 & 1)
tk.Label(settingsWindow, text="Probe pin invert:").grid(row=6, column=0)
tk.Checkbutton(settingsWindow, variable=probePinInvert).grid(row=6, column=1)
#status report mask
statusOpts = ["Wpos","Mpos","Buf"]
statusMask = tk.StringVar()
statusMask.set(statusOpts[s10])
tk.OptionMenu(settingsWindow, statusMask, *statusOpts).grid(row=7,column=0)
#junction deviation mm
junctionDeviation = tk.StringVar()
junctionDeviation.set(str(s11))
junctionDeviationLabel = tk.Label(settingsWindow, text="Juntion deviation mm: ")
junctionDeviationLabel.grid(row=8, column=0)
junctionDeviationEntry = tk.Entry(settingsWindow, textvariable=junctionDeviation)
junctionDeviationEntry.grid(row=8,column=1)
#arc tolerance mm
arcTolerance = tk.StringVar()
arcTolerance.set(str(s12))
arcToleranceLabel = tk.Label(settingsWindow, text="Arc tolerance mm: ")
arcToleranceLabel.grid(row=9, column=0)
arcToleranceEntry = tk.Entry(settingsWindow, textvariable=arcTolerance)
arcToleranceEntry.grid(row=9,column=1)
#report inches
reportInches = tk.IntVar()
reportInches.set(s13 & 1)
tk.Label(settingsWindow, text="Report inches:").grid(row=10, column=0)
tk.Checkbutton(settingsWindow, variable=reportInches).grid(row=10, column=1)
#soft limits
softLimits = tk.IntVar()
softLimits.set(s20 & 1)
tk.Label(settingsWindow, text="Soft limits:").grid(row=11, column=0)
tk.Checkbutton(settingsWindow, variable=softLimits).grid(row=11, column=1)
#hard limits
hardLimits = tk.IntVar()
hardLimits.set(s21 & 1)
tk.Label(settingsWindow, text="Hard limits:").grid(row=12, column=0)
tk.Checkbutton(settingsWindow, variable=hardLimits).grid(row=12, column=1)
#homing cycle
homingCycle = tk.IntVar()
homingCycle.set(s22 & 1)
tk.Label(settingsWindow, text="Homing cycle:").grid(row=13, column=0)
tk.Checkbutton(settingsWindow, variable=homingCycle).grid(row=13, column=1)
#Homing dir invert
homingInvertX = tk.BooleanVar()
homingInvertY = tk.BooleanVar()
homingInvertZ = tk.BooleanVar()
homingInvertX.set(s23 & 1)
homingInvertY.set(s23 & 2)
homingInvertZ.set(s23 & 4)
tk.Label(settingsWindow, text="Homing direction invert:").grid(row=14, column=0)
tk.Checkbutton(settingsWindow, text="X", variable=homingInvertX).grid(row=14, column=1)
tk.Checkbutton(settingsWindow, text="Y", variable=homingInvertY).grid(row=14, column=2)
tk.Checkbutton(settingsWindow, text="Z", variable=homingInvertZ).grid(row=14, column=3)
#homing feed mm
homingFeed = tk.StringVar()
homingFeed.set(str(s24))
homingFeedLabel = tk.Label(settingsWindow, text="Homing feed mm/min: ")
homingFeedLabel.grid(row=15, column=0)
homingFeedEntry = tk.Entry(settingsWindow, textvariable=homingFeed)
homingFeedEntry.grid(row=15,column=1)
#homing seek mm
homingSeek = tk.StringVar()
homingSeek.set(str(s25))
homingSeekLabel = tk.Label(settingsWindow, text="Homing seek mm/min: ")
homingSeekLabel.grid(row=16, column=0)
homingSeekEntry = tk.Entry(settingsWindow, textvariable=homingSeek)
homingSeekEntry.grid(row=16,column=1)
#homing debounce milli
homingDebounce = tk.StringVar()
homingDebounce.set(str(s26))
homingDebounceLabel = tk.Label(settingsWindow, text="Homing debounce milliseconds: ")
homingDebounceLabel.grid(row=17, column=0)
homingDebounceEntry = tk.Entry(settingsWindow, textvariable=homingDebounce)
homingDebounceEntry.grid(row=17,column=1)
#homing pulloff mm
homingPulloff = tk.StringVar()
homingPulloff.set(str(s27))
homingPulloffLabel = tk.Label(settingsWindow, text="Homing pulloff mm: ")
homingPulloffLabel.grid(row=18, column=0)
homingPulloffEntry = tk.Entry(settingsWindow, textvariable=homingPulloff)
homingPulloffEntry.grid(row=18,column=1)
#max spindle speed RPM
maxSpindleSpeed = tk.StringVar()
maxSpindleSpeed.set(str(s30))
maxSpindleSpeedLabel = tk.Label(settingsWindow, text="Max spindle speed RPM: ")
maxSpindleSpeedLabel.grid(row=19, column=0)
maxSpindleSpeedEntry = tk.Entry(settingsWindow, textvariable=maxSpindleSpeed)
maxSpindleSpeedEntry.grid(row=19,column=1)
#min spindle speed RPM
minSpindleSpeed = tk.StringVar()
minSpindleSpeed.set(str(s31))
minSpindleSpeedLabel = tk.Label(settingsWindow, text="Min spindle speed RPM: ")
minSpindleSpeedLabel.grid(row=0, column=5)
minSpindleSpeedEntry = tk.Entry(settingsWindow, textvariable=minSpindleSpeed)
minSpindleSpeedEntry.grid(row=0,column=6)
#laser mode
laserMode = tk.IntVar()
laserMode.set(s32 & 1)
tk.Label(settingsWindow, text="Laser mode:").grid(row=13, column=5)
tk.Checkbutton(settingsWindow, variable=laserMode).grid(row=13, column=6)
#x steps per mm
xStepsMm = tk.StringVar()
xStepsMm.set(str(s100))
xStepsMmLabel = tk.Label(settingsWindow, text="X steps per mm: ")
xStepsMmLabel.grid(row=1, column=5)
xStepsMmEntry = tk.Entry(settingsWindow, textvariable=xStepsMm)
xStepsMmEntry.grid(row=1,column=6)
#y steps per mm
yStepsMm = tk.StringVar()
yStepsMm.set(str(s101))
yStepsMmLabel = tk.Label(settingsWindow, text="Y steps per mm: ")
yStepsMmLabel.grid(row=2, column=5)
yStepsMmEntry = tk.Entry(settingsWindow, textvariable=yStepsMm)
yStepsMmEntry.grid(row=2,column=6)
#z steps per mm
zStepsMm = tk.StringVar()
zStepsMm.set(str(s102))
zStepsMmLabel = tk.Label(settingsWindow, text="Z steps per mm: ")
zStepsMmLabel.grid(row=3, column=5)
zStepsMmEntry = tk.Entry(settingsWindow, textvariable=zStepsMm)
zStepsMmEntry.grid(row=3,column=6)
#x max rate mm/min
xMaxRate = tk.StringVar()
xMaxRate.set(str(s110))
xMaxRateLabel = tk.Label(settingsWindow, text="X max rate mm/min: ")
xMaxRateLabel.grid(row=4, column=5)
xMaxRateEntry = tk.Entry(settingsWindow, textvariable=xMaxRate)
xMaxRateEntry.grid(row=4,column=6)
#y max rate
yMaxRate = tk.StringVar()
yMaxRate.set(str(s111))
yMaxRateLabel = tk.Label(settingsWindow, text="Y max rate mm/min: ")
yMaxRateLabel.grid(row=5, column=5)
yMaxRateEntry = tk.Entry(settingsWindow, textvariable=yMaxRate)
yMaxRateEntry.grid(row=5,column=6)
#z max rate
zMaxRate = tk.StringVar()
zMaxRate.set(str(s112))
zMaxRateLabel = tk.Label(settingsWindow, text="Z max rate mm/min: ")
zMaxRateLabel.grid(row=6, column=5)
zMaxRateEntry = tk.Entry(settingsWindow, textvariable=zMaxRate)
zMaxRateEntry.grid(row=6,column=6)
#x accl mm/sec2
xAccl = tk.StringVar()
xAccl.set(str(s120))
xAcclLabel = tk.Label(settingsWindow, text="X acceleration mm/sec^2: ")
xAcclLabel.grid(row=7, column=5)
xAcclEntry = tk.Entry(settingsWindow, textvariable=xAccl)
xAcclEntry.grid(row=7,column=6)
#y accl mm/sec2
yAccl = tk.StringVar()
yAccl.set(str(s121))
yAcclLabel = tk.Label(settingsWindow, text="Y acceleration mm/sec^2: ")
yAcclLabel.grid(row=8, column=5)
yAcclEntry= tk.Entry(settingsWindow, textvariable=yAccl)
yAcclEntry.grid(row=8,column=6)
#z accl mm/sec2
zAccl = tk.StringVar()
zAccl.set(str(s122))
zAcclLabel = tk.Label(settingsWindow, text="Z acceleration mm/sec^2: ")
zAcclLabel.grid(row=9, column=5)
zAcclEntry = tk.Entry(settingsWindow, textvariable=zAccl)
zAcclEntry.grid(row=9,column=6)
#x max travel
xMaxTravel = tk.StringVar()
xMaxTravel.set(str(s130))
xMaxTravelLabel = tk.Label(settingsWindow, text="X max travel mm: ")
xMaxTravelLabel.grid(row=10, column=5)
xMaxTravelEntry = tk.Entry(settingsWindow, textvariable=xMaxTravel)
xMaxTravelEntry.grid(row=10,column=6)
#y max travel
yMaxTravel = tk.StringVar()
yMaxTravel.set(str(s131))
yMaxTravelLabel = tk.Label(settingsWindow, text="Y max travel mm: ")
yMaxTravelLabel.grid(row=11, column=5)
yMaxTravelEntry = tk.Entry(settingsWindow, textvariable=yMaxTravel)
yMaxTravelEntry.grid(row=11,column=6)
#z max travel
zMaxTravel = tk.StringVar()
zMaxTravel.set(str(s132))
zMaxTravelLabel = tk.Label(settingsWindow, text="Z max travel mm: ")
zMaxTravelLabel.grid(row=12, column=5)
zMaxTravelEntry = tk.Entry(settingsWindow, textvariable=zMaxTravel)
zMaxTravelEntry.grid(row=12,column=6)
tk.Button(settingsWindow, text="Save settings", command=saveSettings).grid(row=50,column=1)
def __init__(self, master):
#Main Window
self.master = master
master.title("ASX Data Analysis")
master.geometry("1280x960")
master.pack_propagate(False)
master.resizable(0, 0)
self.tabBook = ttk.Notebook(master)
self.tabBook.place(relheight=1, relwidth=1)
#Tab for Details
#Frame for Input fields and buttons
self.inputFrame = ttk.LabelFrame(self.tabBook, text="User Input")
self.inputFrame.place(width=1280)
self.tabBook.add(self.inputFrame, text="Details")
#Lables
tk.Label(self.inputFrame, text="ASX ticker", width=20,
anchor="w").grid(row=0, column=1)
self.tickerEntry = tk.Entry(self.inputFrame, width=20)
self.tickerEntry.grid(row=0, column=0)
#Buttons
ttk.Button(self.inputFrame,
text='Show Data for listing',
width=20,
command=self.printDetails).grid(row=2, column=0)
ttk.Button(self.inputFrame,
text='Refresh Daily Data',
width=20,
command=self.getDailyDetails).grid(row=3, column=0)
ttk.Button(self.inputFrame,
text='Quit',
width=10,
command=self.master.destroy).place(relx=0.9)
ttk.Button(self.inputFrame,
text='Update Database',
width=18,
command=self.confirm).place(relx=0.9, rely=0.03)
# Frame for Treeview (info)
self.infoFrame = ttk.LabelFrame(self.tabBook, text="Stock Summary")
self.infoFrame.place(height=370, width=640, rely=0.12)
#Treeview widget
self.infoTv = Tvwidget(frame=self.infoFrame,
columns=("Item", "Value"),
relheight=1,
relwidth=1)
#Frame for Estimates (calculations)
self.estimateFrame = ttk.LabelFrame(self.tabBook,
text="Estimated forward values")
self.estimateFrame.place(height=370, width=640, rely=0.12, relx=0.5)
#Calc button
ttk.Button(self.estimateFrame,
text='Calculate Estimates',
width=20,
command=self.runEstimate).grid(row=0, column=2)
#Entry fields
self.ebitdaEntry = Calcinput(self.estimateFrame,
text="EBITDA ($M)",
row=0,
col=0)
self.sharesOutstandingEntry = Calcinput(self.estimateFrame,
text="Shares Outstanding (M)",
row=1,
col=0)
self.longDebtEntry = Calcinput(self.estimateFrame,
text="L/T Debt ($M)",
row=2,
col=0)
self.cashEntry = Calcinput(self.estimateFrame,
text="Cash on hand ($M)",
row=3,
col=0)
self.percentEbitdaEntry = Calcinput(self.estimateFrame,
text="% EBITDA",
row=4,
col=0)
tk.Label(self.estimateFrame, width=20).grid(row=5, column=0)
#Calculated values
self.medianPriceCalc = Calcoutput(self.estimateFrame,
text="Median Price",
row=6,
col=0,
width=20)
self.averagePriceCalc = Calcoutput(self.estimateFrame,
text="Average Price",
row=7,
col=0,
width=20)
self.minPriceCalc = Calcoutput(self.estimateFrame,
text="Min Price",
row=8,
col=0,
width=20)
self.maxPriceCalc = Calcoutput(self.estimateFrame,
text="Max Price",
row=9,
col=0,
width=20)
self.divPaidCalc = Calcoutput(self.estimateFrame,
text="Dividends Paid ($M)",
row=10,
col=0,
width=20)
self.medianYieldCalc = Calcoutput(self.estimateFrame,
text="Median Yield",
row=11,
col=0,
width=20)
self.averageYieldCalc = Calcoutput(self.estimateFrame,
text="Average Yield",
row=12,
col=0,
width=20)
self.minYieldCalc = Calcoutput(self.estimateFrame,
text="Minimum Yield",
row=13,
col=0,
width=20)
self.maxYieldCalc = Calcoutput(self.estimateFrame,
text="Maximum Yield",
row=14,
col=0,
width=20)
self.assessedDivCalc = Calcoutput(self.estimateFrame,
text="Assessed Dividend",
row=15,
col=0,
width=20)
#stats values
tk.Label(self.estimateFrame, width=10,
text="Cash Yield %").grid(row=5, column=3)
tk.Label(self.estimateFrame, width=10,
text="EV Multiple").grid(row=5, column=4)
self.medianValueCalc = Statoutput(self.estimateFrame,
text="Median Value",
row=6,
col=2,
width=10)
self.meanValueCalc = Statoutput(self.estimateFrame,
text="Mean Value",
row=7,
col=2,
width=10)
self.stdValueCalc = Statoutput(self.estimateFrame,
text="Std. Dev.",
row=8,
col=2,
width=10)
self.minValueCalc = Statoutput(self.estimateFrame,
text="Min. value",
row=9,
col=2,
width=10)
self.maxValueCalc = Statoutput(self.estimateFrame,
text="Max. value",
row=10,
col=2,
width=10)
#Frame for KPIs (Selected info from database)
self.keyPerformanceFrame = ttk.LabelFrame(
self.tabBook, text="Key Performance Indicators")
self.keyPerformanceFrame.place(height=165, width=1280, rely=0.5)
#Treeview widget
self.keyPerformanceTv = Tvwidget(frame=self.keyPerformanceFrame,
columns=tvcolumns,
relheight=1,
relwidth=1,
firstColWidth=250,
colWidth=100)
#Frame for Details (Extended info from database)
self.detailsFrame = ttk.LabelFrame(self.tabBook,
text="Historical Performance")
self.detailsFrame.place(height=300, width=1280, rely=0.67)
#Treeview widget
self.detailTv = Tvwidget(frame=self.detailsFrame,
columns=tvcolumns,
relheight=1,
relwidth=1,
firstColWidth=250,
colWidth=100)
#Tab for Trend Plots
self.trendsFrame = ttk.LabelFrame(self.tabBook, text="Plots")
self.trendsFrame.place(relheight=1, relwidth=1)
self.tabBook.add(self.trendsFrame, text="Plots")
ttk.Button(self.trendsFrame,
text='Plot Stock Price',
width=20,
command=self.plotTrends).grid(row=1, column=0)
ttk.Button(self.trendsFrame,
text='Quit',
width=10,
command=self.master.destroy).place(relx=0.9)
#Tab for Screening Tool
self.screenFrame = ttk.LabelFrame(self.tabBook, text="Screening Tool")
self.screenFrame.place(relheight=1, relwidth=1)
self.tabBook.add(self.screenFrame, text="Screening Tool")
tk.Label(self.screenFrame, width=20).grid(row=12, column=0)
ttk.Button(self.screenFrame,
text='Search',
width=20,
command=self.screen).grid(row=13, column=0)
ttk.Button(self.screenFrame,
text='Quit',
width=10,
command=self.master.destroy).place(relx=0.9)
self.search = tk.IntVar()
self.search.set(1)
tk.Radiobutton(self.screenFrame,
text="Most recent year only",
variable=self.search,
value=1,
anchor="w",
width=20).grid(row=13, column=3)
tk.Radiobutton(self.screenFrame,
text="Average from 2010",
variable=self.search,
value=2,
anchor="w",
width=20).grid(row=14, column=3)
self.sectors = [
"All", "All", "Automobiles & Components", "Banks", "Capital Goods",
"Class Pend", "Commerical & Professional Services",
"Consumer Durables & Apparel", "Consumer Services",
"Diversified Financials", "Energy", "Food & Staples Retailing",
"Food, Beverage & Tobacco", "Health Care Equipment & Services",
"Household & Personal Products", "Insurance", "Materials",
"Media & Entertainment", "Not Applic",
"Pharmaceuticals, Biotechnology & Life Sciences", "Real Estate",
"Retailing", "Semiconductors & Semiconductor Equipment",
"Software & Services", "Technology Hardware & Equipment",
"Telecommunication Services", "Transportation", "Utilities"
]
self.sector = tk.StringVar(self.screenFrame)
self.sector.set("All")
tk.Label(self.screenFrame,
text="Sector/Industry",
width=20,
anchor="w").grid(row=13, column=6)
self.optionmenu = ttk.OptionMenu(self.screenFrame, self.sector,
*self.sectors)
self.optionmenu.grid(row=14, column=6)
self.optionmenu.config(width=20)
#Entry fields for screening tool
self.marketCapCriteria = Criteriawidget(self.screenFrame,
"Market Capital ($M)", 0, 0)
self.sharesOutstandingCriteria = Criteriawidget(
self.screenFrame, "Shares Outstanding (mil)", 4, 0)
self.shortDebtCriteria = Criteriawidget(self.screenFrame,
"Short-term debt ($M)", 8, 0)
self.dividendsCriteria = Criteriawidget(self.screenFrame,
"Dividends (¢)", 0, 3)
self.dividendYieldCriteria = Criteriawidget(self.screenFrame,
"Dividend yield (%)", 4, 3)
self.ebitdaCriteria = Criteriawidget(self.screenFrame, "EBITDA ($M)",
8, 3)
self.cashYieldCriteria = Criteriawidget(self.screenFrame,
"Cash yield (%)", 0, 6)
self.cashCriteria = Criteriawidget(self.screenFrame,
"Cash on hand ($M)", 4, 6)
self.longDebtCriteria = Criteriawidget(self.screenFrame,
"Long-term debt ($M)", 8, 6)
self.bookValueCriteria = Criteriawidget(self.screenFrame,
"Book value ($)", 0, 9)
self.evMultipleCriteria = Criteriawidget(self.screenFrame,
"EV Multiple", 4, 9)
self.returnCapitalCriteria = Criteriawidget(self.screenFrame,
"Return on capital (%)", 8,
9)
self.priceEarningsCriteria = Criteriawidget(self.screenFrame,
"Price/Earnings (%)", 0,
12)
self.profitMarginCriteria = Criteriawidget(self.screenFrame,
"Profit Margin(%)", 4, 12)
self.netDebtEbitdaRatioCriteria = Criteriawidget(
self.screenFrame, "Net debt : EBITDA (ratio)", 8, 12)
#Screening tool output frame
self.screenOutput = ttk.LabelFrame(self.screenFrame,
text="Search Results")
self.screenOutput.place(height=650, width=1280, rely=0.29)
#Screening tool Output treeview
columns = ("Name", "Ticker", "Sector", "EV Multiple", "Cash yield (%)",
"Net debt : EBITDA (ratio)", "Market capital ($M)",
"Dividends (c)", "Dividend yield (%)", "Book value ($)",
"Price / Earnings (%)", "Shares Outstanding (mil)",
"Cash on hand ($M)", "Profit margin (%)",
"Short-term debt ($M)", "EBITDA ($M)",
"Return on capital (%)", "Long-term debt ($M)")
self.screenTv = Tvwidget(self.screenOutput, 1, 1, columns, 250, 150)
def __init__(self):
window = tk.Tk()
window.title("Arduino GUI Demo")
self.ardState = False # is arduino open or not
# a frame contains COM's information, and start/stop button
frame_COMinf = tk.Frame(window)
frame_COMinf.grid(row=1, column=1)
labelCOM = tk.Label(frame_COMinf, text="Port: ")
self.COM = tk.StringVar(value="COM3")
ertryCOM = tk.Entry(frame_COMinf, textvariable=self.COM)
labelCOM.grid(row=1, column=1, padx=5, pady=3)
ertryCOM.grid(row=1, column=2, padx=5, pady=3)
labelBaudrate = tk.Label(frame_COMinf, text="Baudrate: ")
self.Baudrate = tk.IntVar(value=9600)
ertryBaudrate = tk.Entry(frame_COMinf, textvariable=self.Baudrate)
labelBaudrate.grid(row=1, column=3, padx=5, pady=3)
ertryBaudrate.grid(row=1, column=4, padx=5, pady=3)
labelParity = tk.Label(frame_COMinf, text="Parity: ")
self.Parity = tk.StringVar(value="NONE")
comboParity = ttk.Combobox(frame_COMinf,
width=17,
textvariable=self.Parity)
comboParity["values"] = ("NONE", "ODD", "EVEN", "MARK", "SPACE")
comboParity["state"] = "readonly"
labelParity.grid(row=2, column=1, padx=5, pady=3)
comboParity.grid(row=2, column=2, padx=5, pady=3)
labelStopbits = tk.Label(frame_COMinf, text="Stopbits: ")
self.Stopbits = tk.StringVar(value="1")
comboStopbits = ttk.Combobox(frame_COMinf,
width=17,
textvariable=self.Stopbits)
comboStopbits["values"] = ("1", "1.5", "2")
comboStopbits["state"] = "readonly"
labelStopbits.grid(row=2, column=3, padx=5, pady=3)
comboStopbits.grid(row=2, column=4, padx=5, pady=3)
self.buttonSS = tk.Button(frame_COMinf,
text="Start",
command=self.processButtonSS)
self.buttonSS.grid(row=3, column=4, padx=5, pady=3, sticky=tk.E)
# serial object
self.ser = serial.Serial()
# serial read threading
self.ReadardThread = threading.Thread(target=self.Readard)
self.ReadardThread.start()
frameRecv = tk.Frame(window)
frameRecv.grid(row=2, column=1)
labelOutText = tk.Label(frameRecv, text="Received Data:")
labelOutText.grid(row=1, column=1, padx=3, pady=2, sticky=tk.W)
frameRecvSon = tk.Frame(frameRecv)
frameRecvSon.grid(row=2, column=1)
scrollbarRecv = tk.Scrollbar(frameRecvSon)
scrollbarRecv.pack(side=tk.RIGHT, fill=tk.Y)
self.OutputText = tk.Text(frameRecvSon,
wrap=tk.WORD,
width=60,
height=20,
yscrollcommand=scrollbarRecv.set)
self.OutputText.pack()
frameTrans = tk.Frame(window)
frameTrans.grid(row=3, column=1)
labelInText1 = tk.Label(frameTrans, text="RPM:")
labelInText1.grid(row=1, column=1, padx=0, pady=2, sticky=tk.W)
frameTransSon1 = tk.Frame(frameTrans)
frameTransSon1.grid(row=2, column=1)
self.InputText1 = tk.Text(frameTransSon1,
wrap=tk.WORD,
width=56,
height=1)
self.InputText1.pack()
self.buttonSend = tk.Button(frameTrans,
text="Send",
command=self.processButtonSend1)
self.buttonSend.grid(row=2, column=2, padx=3, pady=2, sticky=tk.E)
labelInText2 = tk.Label(frameTrans, text="Temperature (C):")
labelInText2.grid(row=3, column=1, padx=0, pady=2, sticky=tk.W)
frameTransSon2 = tk.Frame(frameTrans)
frameTransSon2.grid(row=4, column=1)
self.InputText2 = tk.Text(frameTransSon2,
wrap=tk.WORD,
width=56,
height=1)
self.InputText2.pack()
self.buttonSend = tk.Button(frameTrans,
text="Send",
command=self.processButtonSend2)
self.buttonSend.grid(row=4, column=2, padx=3, pady=2, sticky=tk.E)
labelInText3 = tk.Label(frameTrans, text="pH:")
labelInText3.grid(row=5, column=1, padx=0, pady=2, sticky=tk.W)
frameTransSon3 = tk.Frame(frameTrans)
frameTransSon3.grid(row=6, column=1)
self.InputText3 = tk.Text(frameTransSon3,
wrap=tk.WORD,
width=56,
height=1)
self.InputText3.pack()
self.buttonSend = tk.Button(frameTrans,
text="Send",
command=self.processButtonSend3)
self.buttonSend.grid(row=6, column=2, padx=3, pady=2, sticky=tk.E)
window.mainloop()
def __init__(self, id, root, menu, todo, matrix, data=None):
if data == None:
self.name = tk.StringVar(value=id)
self.urgency = tk.IntVar(value=len(task_names))
self.importance = tk.IntVar(value=len(task_names))
else:
self.name = tk.StringVar(value=data[0])
self.urgency = tk.IntVar(value=data[1])
self.importance = tk.IntVar(value=data[2])
self.unitM = tk.Label(matrix,
textvariable=self.name,
font='Times 10 bold',
height=2,
width=8,
wraplength=62)
self.unitU = tk.Frame(todo)
self.unitI = tk.Frame(todo)
self.unitU.grid(row=self.urgency.get() + 1, column=1)
self.unitI.grid(row=self.importance.get() + 1, column=2)
self.itemU = tk.Entry(self.unitU, textvariable=self.name)
self.increaseU = tk.Button(self.unitU,
text='Raise',
command=functools.partial(
self.increase_urgency, self.unitU,
self.urgency))
self.decreaseU = tk.Button(self.unitU,
text='Lower',
command=functools.partial(
self.decrease_urgency, self.unitU,
self.urgency))
self.deleteU = tk.Button(self.unitU,
text='Delete',
command=functools.partial(
self.delete_task, self.unitU, self.unitI,
self.unitM))
self.itemU.grid(row=1, column=1, columnspan=3)
self.increaseU.grid(row=2, column=1)
self.decreaseU.grid(row=2, column=2)
self.deleteU.grid(row=2, column=3)
self.itemI = tk.Entry(self.unitI, textvariable=self.name)
self.increaseI = tk.Button(self.unitI,
text='Raise',
command=functools.partial(
self.increase_importance, self.unitI,
self.importance))
self.decreaseI = tk.Button(self.unitI,
text='Lower',
command=functools.partial(
self.decrease_importance, self.unitI,
self.importance))
self.deleteI = tk.Button(self.unitI,
text='Delete',
command=functools.partial(
self.delete_task, self.unitU, self.unitI,
self.unitM))
self.itemI.grid(row=1, column=1, columnspan=3)
self.increaseI.grid(row=2, column=1)
self.decreaseI.grid(row=2, column=2)
self.deleteI.grid(row=2, column=3)
# Adding a Button
action = ttk.Button(win, text="Click Me!", command=click_me)
action.grid(column=2, row=1) # <= change column to 2
# Creating three checkbuttons
ttk.Label(win, text="Choose a number:").grid(column=1, row=0)
number = tk.StringVar()
number_chosen = ttk.Combobox(win,
width=12,
textvariable=number,
state='readonly')
number_chosen['values'] = (1, 2, 4, 42, 100)
number_chosen.grid(column=1, row=1)
number_chosen.current(0)
chVarDis = tk.IntVar()
check1 = tk.Checkbutton(win,
text="Disabled",
variable=chVarDis,
state='disabled')
check1.select()
check1.grid(column=0, row=4, sticky=tk.W)
chVarUn = tk.IntVar()
check2 = tk.Checkbutton(win, text="UnChecked", variable=chVarUn)
check2.deselect()
check2.grid(column=1, row=4, sticky=tk.W)
chVarEn = tk.IntVar()
check3 = tk.Checkbutton(win, text="Enabled", variable=chVarEn)
check3.deselect()
#Menú superior
menubar = tk.Menu(root)
menubar.add_cascade(
label="Nota",
command=Nota,
)
def Validar(char):
return char in "0123456789."
validatecommand = root.register(Validar)
Nombres = tk.StringVar()
Capturas = tk.IntVar()
label = tk.Label(root,
text="Reconocimiento Facial",
font=("times new roman", 20),
fg="white",
bg="maroon",
height=2).grid(row=0,
rowspan=2,
columnspan=2,
sticky=N + E + W + S,
padx=5,
pady=5)
label = tk.Label(root,
text="Nombre:",
output.place(x=250, y=68, anchor='center')
# The modulo equation button
def modulo():
try:
moduloNum = (firstNumber.get()) % (secondNumber.get())
output = Label(master, text=moduloNum, width=20)
output.place(x=250, y=68, anchor='center')
except ZeroDivisionError:
output = Label(master, text='You can not modulo by 0', width=20)
output.place(x=250, y=68, anchor='center')
# Creates the Entry boxes for the numbers
firstNumber = tk.IntVar()
firstNum = ttk.Entry(master, width=12, textvariable=firstNumber)
firstNum.grid(column=2, row=0)
secondNumber = tk.IntVar()
secondNum = ttk.Entry(master, width=12, textvariable=secondNumber)
secondNum.grid(column=4, row=0)
# Adds a button to the master
add = ttk.Button(master, text='+', command=add)
add.grid(column=1, row=8)
# Adds a subtraction button
subtract = ttk.Button(master, text='-', command=subtract)
subtract.grid(column=2, row=8)
def __init__(self, master, **kwargs):
global x, var
x = Morse()
var = tk.IntVar()
l1 = tk.Label(text="Select a task",
font=("Helvetica", 30, "bold"),
activeforeground="black",
fg="black",
bg="yellow")
l1.place(x=140, y=100)
l2 = tk.Label(text="Message:",
font=("Helvetica", 20, "bold"),
activeforeground="black",
fg="black",
bg="yellow")
l2.place(x=140, y=230)
l3 = tk.Label(text="Morse code:",
font=("Helvetica", 20, "bold"),
activeforeground="black",
fg="black",
bg="yellow")
l3.place(x=140, y=400)
textBox1 = tk.Text(height=5,
width=80,
relief="sunken",
bd=5,
font=("Helvetica", 15))
textBox1.configure(state='disabled')
textBox1.place(x=340, y=400)
textBox2 = tk.Text(height=3,
width=80,
relief="sunken",
bd=5,
font=("Helvetica", 15))
textBox2.configure(state='disabled')
textBox2.place(x=340, y=230)
action = tk.Button(root,
bd=5,
activeforeground="#ffffff",
activebackground="violet",
fg="white",
bg="#ed91af",
width=12,
height=1,
font=("verdana", 15, 'bold'))
btn1 = tk.Button(
root,
text="Encode",
bd=5,
activebackground="#ed91af",
bg="#ed91af",
font=("verdana", 20),
command=lambda: self.task(1, textBox1, textBox2, action))
btn1.place(x=550, y=100)
btn2 = tk.Button(
root,
text="Decode",
bd=5,
activebackground="#ed91af",
bg="#ed91af",
font=("verdana", 20),
command=lambda: self.task(2, textBox1, textBox2, action))
btn2.place(x=1050, y=100)
btn4 = tk.Button(
root,
text="Back",
bd=5,
activeforeground="#ffffff",
activebackground="violet",
fg="white",
bg="#ed91af",
width=12,
height=1,
font=("verdana", 12, 'bold'),
command=lambda: self.back(l1, l2, l3, textBox1, textBox2, btn1,
btn2, action, btn4))
btn4.place(x=140, y=628)
import tkinter as tk
string_variable = tk.StringVar()
int_variable = tk.IntVar()
float_var = tk.DoubleVar()
bool_variable = tk.BooleanVar()
# Getting and Setting
string_variable.set('Hi')
string_variable.get()
# Tracing
def r_observer(*args):
print("Reading")
def w_observer(*args):
print("Writing")
# r_observer will be called when string_variable is read
r_obsid = string_variable.trace("r", r_observer)
# w_observer will be called when string_variable is set
w_obsid = string_variable.trace('w', w_observer)
def __init__(self, parent):
tk.Frame.__init__(self, parent)
self.config(borderwidth=2, relief=tk.RAISED, background=COLORS.fr_read)
self.grid(row=2, column=0, columnspan=8, sticky='EW')
#
# Get Element symbols and characteristic wavelength from DISCUS
nwave, self.symbols, self.wavelengths = get_wave()
#
# Get Fourier settings from DISCUS
corners, increment, radiation, bElement, wvle, ener, adp, ano, \
percent, lot_type, lot_num, lot_dim, lot_per \
= suite.discus_get_fourier()
for i in range(4):
for j in range(3):
corners[i, j] = round_rbn(corners[i, j], 5)
wvle = round_rbn(wvle, 5)
ener = round_rbn(ener, 5)
#
# Determine if an element was given for its characteristic radiation
Element = bElement.decode()
ElementNumber = -1
for i in range(nwave):
if Element == self.symbols[i]:
ElementNumber = i
break
self.ll_h = tk.StringVar()
self.ll_k = tk.StringVar()
self.ll_l = tk.StringVar()
self.lr_h = tk.StringVar()
self.lr_k = tk.StringVar()
self.lr_l = tk.StringVar()
self.ul_h = tk.StringVar()
self.ul_k = tk.StringVar()
self.ul_l = tk.StringVar()
self.tl_h = tk.StringVar()
self.tl_k = tk.StringVar()
self.tl_l = tk.StringVar()
self.ll_h.set(str(corners[0, 0]))
self.ll_k.set(str(corners[0, 1]))
self.ll_l.set(str(corners[0, 2]))
self.lr_h.set(str(corners[1, 0]))
self.lr_k.set(str(corners[1, 1]))
self.lr_l.set(str(corners[1, 2]))
self.ul_h.set(str(corners[2, 0]))
self.ul_k.set(str(corners[2, 1]))
self.ul_l.set(str(corners[2, 2]))
self.tl_h.set(str(corners[3, 0]))
self.tl_k.set(str(corners[3, 1]))
self.tl_l.set(str(corners[3, 2]))
self.caption = ttk.Label(self,
text='Single crystal Fourier calculations')
self.label_h = ttk.Label(self, text='H', anchor='center')
self.label_k = ttk.Label(self, text='K', anchor='center')
self.label_l = ttk.Label(self, text='L', anchor='center')
self.label_ll = ttk.Label(self, text='Lower left')
self.label_lr = ttk.Label(self, text='Lower right')
self.label_ul = ttk.Label(self, text='Upper left')
self.label_tl = ttk.Label(self, text='Top left')
self.entry_ll_h = ttk.Entry(self,
textvariable=self.ll_h,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_ll_k = ttk.Entry(self,
textvariable=self.ll_k,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_ll_l = ttk.Entry(self,
textvariable=self.ll_l,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_lr_h = ttk.Entry(self,
textvariable=self.lr_h,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_lr_k = ttk.Entry(self,
textvariable=self.lr_k,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_lr_l = ttk.Entry(self,
textvariable=self.lr_l,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_ul_h = ttk.Entry(self,
textvariable=self.ul_h,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_ul_k = ttk.Entry(self,
textvariable=self.ul_k,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_ul_l = ttk.Entry(self,
textvariable=self.ul_l,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_tl_h = ttk.Entry(self,
textvariable=self.tl_h,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_tl_k = ttk.Entry(self,
textvariable=self.tl_k,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.entry_tl_l = ttk.Entry(self,
textvariable=self.tl_l,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
#
self.label_np = ttk.Label(self, text='Points along axis:')
self.label_np_a = ttk.Label(self, text='Abscissa')
self.label_np_o = ttk.Label(self, text='Ordinate')
self.label_np_t = ttk.Label(self, text='Top axis')
self.np_aa = tk.StringVar()
self.np_oo = tk.StringVar()
self.np_tt = tk.StringVar()
self.np_aa.set(str(increment[0]))
self.np_oo.set(str(increment[1]))
self.np_tt.set(str(increment[2]))
self.np_a = tk.Spinbox(self,
from_=1,
to=1001,
width=8,
justify='right',
textvariable=self.np_aa,
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.np_o = tk.Spinbox(self,
from_=1,
to=1001,
width=8,
justify='right',
textvariable=self.np_oo,
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.np_t = tk.Spinbox(self,
from_=1,
to=1001,
width=8,
justify='right',
textvariable=self.np_tt,
background=COLORS.en_back,
foreground=COLORS.en_fore)
#
discus_rad_menu(self, nwave, radiation, wvle, ener, ElementNumber, adp,
ano, 1, 4)
#
#
self.Aver = tk.StringVar()
self.Aver.set(percent)
self.LabelAver =ttk.Label(self, \
text='Subtract scattering by average structure sampled at')
self.EntryAver = ttk.Entry(self,
textvariable=self.Aver,
width=8,
justify='right',
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.LabelAverPer = ttk.Label(self, text='%')
#
#
self.lot_use = tk.IntVar()
if lot_type == 0:
self.lot_use.set(0)
else:
self.lot_use.set(1)
self.label_lot = ttk.Label(self, text='Lots:')
self.check_lot = ttk.Checkbutton(self,
text='Use',
variable=self.lot_use)
self.check_lot.bind('<ButtonRelease-1>', self.lot_event)
#
self.label_lotshape = ttk.Label(self, text='Lot Shape:')
self.lot_shape = tk.Listbox(self,
height=2,
width=10,
selectbackground=COLORS.en_back,
selectforeground=COLORS.en_fore,
selectmode=tk.SINGLE)
self.lot_shape.configure(exportselection=False)
self.lot_shape.insert(1, 'Box')
self.lot_shape.insert(2, 'Ellipsoid')
if lot_type == 1 or lot_type == 0:
self.lot_shape.selection_set(0)
elif lot_type == 2:
self.lot_shape.selection_set(1)
#
self.label_lotnum = ttk.Label(self, text='Lot Number:')
self.lotnn = tk.StringVar()
self.lotnn.set(str(lot_num))
self.lotn = tk.Spinbox(self,
from_=1,
to=1001,
width=6,
justify='right',
textvariable=self.lotnn,
background=COLORS.en_back,
foreground=COLORS.en_fore)
#
self.label_lotdimx = ttk.Label(self, text='Lot Size X:')
self.label_lotdimy = ttk.Label(self, text='Lot Size Y:')
self.label_lotdimz = ttk.Label(self, text='Lot Size Z:')
self.lotxx = tk.StringVar()
self.lotxx.set(str(lot_dim[0]))
self.lotyy = tk.StringVar()
self.lotyy.set(str(lot_dim[1]))
self.lotzz = tk.StringVar()
self.lotzz.set(str(lot_dim[2]))
self.lotx = tk.Spinbox(self,
from_=1,
to=1001,
width=6,
justify='right',
textvariable=self.lotxx,
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.loty = tk.Spinbox(self,
from_=1,
to=1001,
width=6,
justify='right',
textvariable=self.lotyy,
background=COLORS.en_back,
foreground=COLORS.en_fore)
self.lotz = tk.Spinbox(self,
from_=1,
to=1001,
width=6,
justify='right',
textvariable=self.lotzz,
background=COLORS.en_back,
foreground=COLORS.en_fore)
#
self.label_lot_per = ttk.Label(self, text='Lots:')
self.lot_per = tk.IntVar()
if lot_per == 0:
self.lot_per.set(0)
else:
self.lot_per.set(1)
self.check_lot_per = tk.Checkbutton(self,
text='Periodic',
variable=self.lot_per)
self.lot_menu(self.lot_use.get())
#
#
self.acc = ttk.Button(
self,
text='Run',
command=lambda: self.calc_fourier(
parent, corners, increment, radiation, wvle, ener, adp, ano,
percent, lot_type, lot_num, lot_dim, lot_per))
#
#
self.show = ttk.Button(
self,
text='Show',
command=lambda: self.show_fourier(
parent, corners, increment, radiation, wvle, ener, adp, ano,
percent, lot_type, lot_num, lot_dim, lot_per))
#
#
create_exit_button(
self, 'discus', 11, 8, self.exit_command,
(parent, corners, increment, radiation, wvle, ener, adp, ano,
percent, lot_type, lot_num, lot_dim, lot_per))
#
#
self.CExplain = tk.Canvas(self,
bg=COLORS.fr_read,
height=200,
width=400)
self.CExplain.create_text(20,
20,
text='Calculates an arbitrary line, ',
anchor=tk.W)
self.CExplain.create_text(20,
35,
text='plane or voxel in reciprocal ',
anchor=tk.W)
self.CExplain.create_text(20,
50,
text='space. The corners are the ',
anchor=tk.W)
self.CExplain.create_text(20,
65,
text='lower left, lower right...',
anchor=tk.W)
self.CExplain.create_text(20,
80,
text='Points include the corners as ',
anchor=tk.W)
self.CExplain.create_text(20,
95,
text='shown in the schematic drawing.',
anchor=tk.W)
self.CExplain.create_line(400, 120, 600, 160, width=4)
self.CExplain.create_line(400, 120, 400, 20, width=4)
self.CExplain.create_line(400, 120, 500, 60, width=4)
self.CExplain.create_oval(400 - 5,
120 - 5,
400 + 5,
120 + 5,
fill='black')
self.CExplain.create_oval(467 - 5,
133 - 5,
467 + 5,
133 + 5,
fill='black')
self.CExplain.create_oval(533 - 5,
147 - 5,
533 + 5,
147 + 5,
fill='black')
self.CExplain.create_oval(600 - 5,
160 - 5,
600 + 5,
160 + 5,
fill='black')
self.CExplain.create_oval(400 - 5,
70 - 5,
400 + 5,
70 + 5,
fill='black')
self.CExplain.create_oval(400 - 5,
20 - 5,
400 + 5,
20 + 5,
fill='black')
self.CExplain.create_oval(500 - 5,
60 - 5,
500 + 5,
60 + 5,
fill='black')
self.CExplain.create_text(390, 120, text='Lower left', anchor=tk.E)
self.CExplain.create_text(600,
180,
text='Lower right',
anchor=tk.CENTER)
self.CExplain.create_text(390, 20, text='Upper left', anchor=tk.E)
self.CExplain.create_text(510, 60, text='Top left', anchor=tk.W)
self.CExplain.create_text(500,
160,
text='Points along abscissa = 4',
anchor=tk.E)
self.CExplain.create_text(390,
70,
text='Points along ordinate = 3',
anchor=tk.E)
#
## # If an Element name was given, make this active
## if ElementNumber > -1:
## self.ele.configure(state='normal')
## self.entry_wvle.configure(state='disabled')
## self.entry_ener.configure(state='disabled')
## self.rad_type.set(2)
## else:
## self.ele.configure(state='disabled')
## self.entry_wvle.configure(state='normal')
## self.entry_ener.configure(state='disabled')
## self.rad_type.set(0)
self.caption.grid(row=0, column=0, columnspan=8, pady=(10, 10))
self.label_h.grid(row=1, column=1, sticky='EW')
self.label_k.grid(row=1, column=2, sticky='EW')
self.label_l.grid(row=1, column=3, sticky='EW')
self.label_ll.grid(row=2, column=0, sticky='EW')
self.label_lr.grid(row=3, column=0, sticky='EW')
self.label_ul.grid(row=4, column=0, sticky='EW')
self.label_tl.grid(row=5, column=0, sticky='EW')
self.entry_ll_h.grid(row=2, column=1, sticky='EW')
self.entry_ll_k.grid(row=2, column=2, sticky='EW')
self.entry_ll_l.grid(row=2, column=3, sticky='EW')
self.entry_lr_h.grid(row=3, column=1, sticky='EW')
self.entry_lr_k.grid(row=3, column=2, sticky='EW')
self.entry_lr_l.grid(row=3, column=3, sticky='EW')
self.entry_ul_h.grid(row=4, column=1, sticky='EW')
self.entry_ul_k.grid(row=4, column=2, sticky='EW')
self.entry_ul_l.grid(row=4, column=3, sticky='EW')
self.entry_tl_h.grid(row=5, column=1, sticky='EW')
self.entry_tl_k.grid(row=5, column=2, sticky='EW')
self.entry_tl_l.grid(row=5, column=3, sticky='EW')
self.label_np.grid(row=6,
column=0,
pady=(5, 0),
columnspan=2,
sticky='EW')
self.label_np_a.grid(row=7, column=0, sticky='EW')
self.label_np_o.grid(row=8, column=0, sticky='EW')
self.label_np_t.grid(row=9, column=0, sticky='EW')
self.np_a.grid(row=7, column=1, columnspan=1, sticky='EW')
self.np_o.grid(row=8, column=1, columnspan=1, sticky='EW')
self.np_t.grid(row=9, column=1, columnspan=1, sticky='EW')
#
self.LabelAver.grid(row=6, column=3, columnspan=7, sticky='EW')
self.EntryAver.grid(row=6, column=7, sticky='EW')
self.LabelAverPer.grid(row=6, column=8, sticky='W')
self.label_lot.grid(row=7, column=4, sticky='EW')
self.check_lot.grid(row=7, column=5, sticky='EW')
self.label_lotshape.grid(row=9, column=3, sticky='EW')
self.lot_shape.grid(row=9, column=4, rowspan=2, sticky='EW')
self.label_lotnum.grid(row=11, column=3, sticky='EW')
self.lotn.grid(row=11, column=4, sticky='EW')
self.label_lotdimx.grid(row=9, column=5, sticky='EW')
self.label_lotdimy.grid(row=10, column=5, sticky='EW')
self.label_lotdimz.grid(row=11, column=5, sticky='EW')
self.lotx.grid(row=9, column=6, sticky='EW')
self.loty.grid(row=10, column=6, sticky='EW')
self.lotz.grid(row=11, column=6, sticky='EW')
self.label_lot_per.grid(row=8, column=4, sticky='EW')
self.check_lot_per.grid(row=8, column=5, sticky='EW')
self.show.grid(row=9, column=8)
self.acc.grid(row=10, column=8)
self.CExplain.grid(row=12, column=0, columnspan=9, sticky='EW')
#
line = 'fourier'
suite.suite_learn(line)
def __init__(self, parent):
tk.Frame.__init__(self, parent)
self.window = parent
self.prompt1 = tk.Label(self, text="Enter the albedo:", anchor="w")
self.prompt1.grid(row=0, column=0)
self.entryAlbedo = tk.Entry(self)
self.entryAlbedo.grid(row=0, column=1)
self.entryAlbedo.delete(0, "end")
self.entryAlbedo.insert(0, str(self.albedo))
self.prompt2 = tk.Label(self,
text="Enter Daily Avg SW Radiation:",
anchor="w")
self.prompt2.grid(row=1, column=0)
self.entrySW = tk.Entry(self)
self.entrySW.grid(row=1, column=1)
self.entrySW.delete(0, "end")
self.entrySW.insert(0, str(self.Q_prime))
self.prompt3 = tk.Label(self,
text="Enter Daily Avg LW Radiation:",
anchor="w")
self.prompt3.grid(row=2, column=0)
self.entryLW = tk.Entry(self)
self.entryLW.grid(row=2, column=1)
self.entryLW.delete(0, "end")
self.entryLW.insert(0, str(self.l_star))
self.prompt2b = tk.Label(self,
text="Enter Daily Variation SW Radiation:",
anchor="w")
self.prompt2b.grid(row=1, column=2)
self.entrySW_var = tk.Entry(self)
self.entrySW_var.grid(row=1, column=3)
self.entrySW_var.delete(0, "end")
self.entrySW_var.insert(0, str(self.Q_prime_var))
self.prompt3b = tk.Label(self,
text="Enter Daily Variation LW Radiation:",
anchor="w")
self.prompt3b.grid(row=2, column=2)
self.entryLW_var = tk.Entry(self)
self.entryLW_var.grid(row=2, column=3)
self.entryLW_var.delete(0, "end")
self.entryLW_var.insert(0, str(self.l_star_var))
self.prompt4 = tk.Label(self,
text="Enter Avg 2m air temp:",
anchor="w")
self.prompt4.grid(row=3, column=0)
self.entryAir = tk.Entry(self)
self.entryAir.grid(row=3, column=1)
self.entryAir.delete(0, "end")
self.entryAir.insert(0, str(self.T_air))
self.prompt4b = tk.Label(self,
text="Enter daily variation 2m air temp:",
anchor="w")
self.prompt4b.grid(row=3, column=2)
self.entryAir_var = tk.Entry(self)
self.entryAir_var.grid(row=3, column=3)
self.entryAir_var.delete(0, "end")
self.entryAir_var.insert(0, str(self.T_air_var))
self.prompt4c = tk.Label(self,
text="Enter Avg 2m Rel Humidity:",
anchor="w")
self.prompt4c.grid(row=4, column=0)
self.entryRH = tk.Entry(self)
self.entryRH.grid(row=4, column=1)
self.entryRH.delete(0, "end")
self.entryRH.insert(0, str(self.RH))
self.prompt4d = tk.Label(self,
text="Daily variation 2m Rel Humidity:",
anchor="w")
self.prompt4d.grid(row=4, column=2)
self.entryRH_var = tk.Entry(self)
self.entryRH_var.grid(row=4, column=3)
self.entryRH_var.delete(0, "end")
self.entryRH_var.insert(0, str(self.RH_var))
self.prompt5 = tk.Label(self,
text="Enter Debris Thickness:",
anchor="w")
self.prompt5.grid(row=5, column=0)
self.entryDebris = tk.Entry(self)
self.entryDebris.grid(row=5, column=1)
self.entryDebris.delete(0, "end")
self.entryDebris.insert(0, str(self.depth))
# self.prompt10 = tk.Label(self, text="Overwrite .csv files?", anchor="w")
# self.prompt10.grid(row=6,column=2)
self.chekvar = tk.IntVar()
self.entryover = tk.Checkbutton(self,
text='Overwrite .csv files?',
variable=self.chekvar)
self.entryover.grid(row=6, column=3)
self.prompt5 = tk.Label(self, text="Enter 2m Wind Speed:", anchor="w")
self.prompt5.grid(row=6, column=0)
self.entryWind = tk.Entry(self)
self.entryWind.grid(row=6, column=1)
self.entryWind.delete(0, "end")
self.entryWind.insert(0, str(self.u_wind))
self.prompt6 = tk.Label(self,
text="Enter Thermal Conductivity (W/m-K):",
anchor="w")
self.prompt6.grid(row=7, column=0)
self.entryKdeb = tk.Entry(self)
self.entryKdeb.grid(row=7, column=1)
self.entryKdeb.delete(0, "end")
self.entryKdeb.insert(0, str(self.k_deb))
self.prompt7 = tk.Label(self,
text="Enter Total Time (Days):",
anchor="w")
self.prompt7.grid(row=8, column=0)
self.entryTime = tk.Entry(self)
self.entryTime.grid(row=8, column=1)
self.entryTime.delete(0, "end")
self.entryTime.insert(0, str(np.round(self.max_time) / 86400.))
self.prompt8 = tk.Label(self,
text="Enter Plot Frequency (hours):",
anchor="w")
self.prompt8.grid(row=8, column=2)
self.entryFreq = tk.Entry(self)
self.entryFreq.grid(row=8, column=3)
self.entryFreq.delete(0, "end")
self.entryFreq.insert(0, str(self.plot_frequency))
self.prompt9 = tk.Label(self,
text="Enter Begin Measurement (days):",
anchor="w")
self.prompt9.grid(row=9, column=0)
self.entryPlotStart = tk.Entry(self)
self.entryPlotStart.grid(row=9, column=1)
self.entryPlotStart.delete(0, "end")
self.entryPlotStart.insert(0, str(np.round(self.meas_begin) / 86400.))
self.str = tk.StringVar()
self.str.set("START")
self.submit = tk.Button(self, text="Submit", command=self.calculate)
self.submit.grid(row=9, column=2)
self.output = tk.Label(self, textvariable=self.str)
self.output.grid(row=9, column=3)
Therm.canvas = FigureCanvasTkAgg(Therm.fig, master=self.window)
Therm.canvas.get_tk_widget().pack(side="bottom")
def main():
"""
Add widgets to the GUI one by one.
If screen height <1000 pixels (e.g. laptop screens) -> left & right layout
If screen height >=1000 pixels (e.g. PC screens) -> top & bottom layout
tk and ttk widgets used:
Canvas, Message, Frame, Label, Scale, Radiobutton, Combobox and Button
Parameters
----------
None
Returns
-------
None
"""
root = tk.Tk()
root.title('pyRiverBed')
root.resizable(0, 0)
canvas = tk.Canvas(root)
if root.winfo_screenheight() < 1051:
canvas.pack(side='left', padx=20)
else:
canvas.pack(side='top', padx=20)
####### MODE SELECTOR
msg = tk.Message(
canvas,
text='MODE SELECTOR',
bg='wheat',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Mode',
width=7,
font='System 10',
anchor='e').pack(side='left')
modvar = tk.IntVar()
mod = tk.Radiobutton(
row,
text='1=Generate Kinoshita Curve from equation',
width=43,
font='System 10',
anchor='sw',
variable=modvar,
value=1)
mod.select()
mod.pack()
mod = tk.Radiobutton(
row,
text='2=Read your own centerline from file',
width=43,
font='System 10',
anchor='sw',
variable=modvar,
value=2)
mod.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='File name',
width=10,
font='System 10',
anchor='c').pack(side='left')
fnamevar = tk.StringVar()
fname = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=fnamevar)
fname.set('mycenterline.txt')
fname.pack()
row = tk.Frame(canvas)
row.pack(side='top')
if platform.system() == 'Darwin':
w1, w2 = 15, 120
else:
w1, w2 = 20, 135
tk.Label(
row,
text='Level of smoothing ',
width=w1,
font='System 10',
anchor='e').pack(side='left')
smoothvar = tk.IntVar()
scale = tk.Scale(row,
from_=0,
to=100,
orient='horizontal',
width=8,
sliderlength=10,
font='System 8',
tickinterval=25,
length=w2,
variable=smoothvar)
scale.set(20)
scale.pack()
if platform.system() == 'Darwin':
row = tk.Frame(canvas)
row.pack(side='top',pady=5)
####### KINOSHITA PARAMETERS
msg = tk.Message(
canvas,
text='KINOSHITA PARAMETERS (ONLY WORK IF MODE=1)',
bg='light cyan',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Number of bends (unit: /)',
width=42,
font='System 10',
anchor='w').pack(side='left')
nbendvar = tk.IntVar()
nbend = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=nbendvar)
nbend['values'] = ('1', '2', '3', '4', '5', '10')
nbend.set('3')
nbend.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Arc wavelength (unit: m)',
width=42,
font='System 10',
anchor='w').pack(side='left')
lamdvar = tk.DoubleVar()
lamd = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=lamdvar)
lamd['values'] = ('1', '2', '5', '10', '20', '50', '100')
lamd.set('10')
lamd.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Max angular amplitude (unit: deg)',
width=42,
font='System 10',
anchor='w').pack(side='left')
thetavar = tk.DoubleVar()
thetau = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=thetavar)
thetau['values'] = ('30', '45', '60', '90', '110')
thetau.set('110')
thetau.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Skewness coeff. (unit: /)',
width=42,
font='System 10',
anchor='w').pack(side='left')
skewvar = tk.DoubleVar()
skew = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=skewvar)
skew['values'] = ('0', '0.005', '0.01', '0.02', '0.03')
skew.set('0.03125')
skew.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Flatness coeff. (unit: /)',
width=42,
font='System 10',
anchor='w').pack(side='left')
flatvar = tk.DoubleVar()
flat = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=flatvar)
flat['values'] = ('0', '0.005', '0.01', '0.02', '0.03')
flat.set('0.00520833')
flat.pack()
####### CHANNEL PARAMETERS
msg = tk.Message(
canvas,
text='CHANNEL PARAMETERS',
bg='light cyan',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Channel width (unit: m)',
width=42,
font='System 10',
anchor='w').pack(side='left')
widvar = tk.DoubleVar()
wid = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=widvar)
wid.set('0.6')
wid.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Water depth (unit: m)',
width=42,
font='System 10',
anchor='w').pack(side='left')
depvar = tk.DoubleVar()
dep = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=depvar)
dep.set('0.15')
dep.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Channel slope (unit: /)',
width=42,
font='System 10',
anchor='w').pack(side='left')
slovar = tk.DoubleVar()
slo = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=slovar)
slo['values'] = ('0', '1e-3', '5e-4', '1e-4')
slo.set('0')
slo.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Transverse slope corrector (unit: /)',
width=42,
font='System 10',
anchor='w').pack(side='left')
stvar = tk.DoubleVar()
st = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=stvar)
st['values'] = ('0.5', '0.6', '0.7', '0.8', '0.9', '1')
st.set('1')
st.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Streamwise resolution (unit: m)',
width=42,
font='System 10',
anchor='w').pack(side='left')
dsvar = tk.DoubleVar()
ds = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=dsvar)
ds.set('0.03')
ds.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='(Grid size of centerline)',
width=55,
font='System 10',
anchor='w').pack(side='left')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Transverse resolution (unit: /)',
width=42,
font='System 10',
anchor='w').pack(side='left')
noffsvar = tk.IntVar()
noffs = ttk.Combobox(
row,
font='System 10',
width=18,
textvariable=noffsvar)
noffs['values'] = ('5', '8', '10', '20')
noffs.set('10')
noffs.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='(Number of polyline offsets at each side of centerline)',
width=55,
font='System 10',
anchor='w').pack(side='left')
canvas = tk.Canvas(root)
if root.winfo_screenheight() < 1051:
canvas.pack(side='left', padx=20)
else:
canvas.pack(side='top', padx=20)
####### PHASE LAG
msg = tk.Message(
canvas,
text='CURVATURE PHASE LAG PARAMETERS',
bg='light cyan',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Curvature phase lag',
width=19,
font='System 10',
anchor='c').pack(side='left')
if platform.system() == 'Darwin':
w = 8
else:
w = 4
lagmodvar = tk.IntVar()
lagmod = tk.Radiobutton(
row,
text='Off',
width=w,
font='System 10',
anchor='sw',
variable=lagmodvar,
value=0)
lagmod.pack(side='left')
lagmod = tk.Radiobutton(
row,
text='On',
width=w,
font='System 10',
anchor='sw',
variable=lagmodvar,
value=1)
lagmod.select()
lagmod.pack(side='left')
tk.Label(
row,
text='Lag strength (unit: /)',
width=19,
font='System 10',
anchor='w').pack(side='left')
lagstrthvar = tk.DoubleVar()
lagstrth = ttk.Combobox(
row,
font='System 10',
width=3,
textvariable=lagstrthvar)
lagstrth['values'] = ('2', '3', '4', '5', '6')
lagstrth.set('4')
lagstrth.pack(side='left')
####### OUTPUT
msg = tk.Message(
canvas,
text='FILE OUTPUT',
bg='light cyan',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
if platform.system() == 'Darwin':
w = 10
else:
w = 7
tk.Label(
row,
text='Save riverbed topography file (.xyz)?',
width=42,
font='System 10',
anchor='w').pack(side='left')
xyzvar = tk.IntVar()
xyz = tk.Radiobutton(
row,
text='Yes',
width=w,
font='System 10',
anchor='sw',
variable=xyzvar,
value=1)
xyz.pack(side='left')
xyz.select()
xyz = tk.Radiobutton(
row,
text='No',
width=w,
font='System 10',
anchor='sw',
variable=xyzvar,
value=0)
xyz.pack(side='left')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Save river bankline file (.i2s)?',
width=42,
font='System 10',
anchor='w').pack(side='left')
bdvar = tk.IntVar()
bd = tk.Radiobutton(
row,
text='Yes',
width=w,
font='System 10',
anchor='sw',
variable=bdvar,
value=1)
bd.pack(side='left')
bd.select()
bd = tk.Radiobutton(
row,
text='No',
width=w,
font='System 10',
anchor='sw',
variable=bdvar,
value=0)
bd.pack(side='left')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Save FEM mesh & BC files (.t3s, .dat, .cli, .bc2)?',
width=42,
font='System 10',
anchor='w').pack(side='left')
meshvar = tk.IntVar()
mesh = tk.Radiobutton(
row,
text='Yes',
width=w,
font='System 10',
anchor='sw',
variable=meshvar,
value=1)
mesh.pack(side='left')
mesh.select()
mesh = tk.Radiobutton(
row,
text='No',
width=w,
font='System 10',
anchor='sw',
variable=meshvar,
value=0)
mesh.pack(side='left')
####### FLIP
msg = tk.Message(
canvas,
text='FLIP',
bg='light cyan',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Flip in streamwise direction?',
width=42,
font='System 10',
anchor='w').pack(side='left')
flpstrmvar = tk.IntVar()
flpstrm = tk.Radiobutton(
row,
text='Yes',
width=w,
font='System 10',
anchor='sw',
variable=flpstrmvar,
value=1)
flpstrm.pack(side='left')
flpstrm = tk.Radiobutton(
row,
text='No',
width=w,
font='System 10',
anchor='sw',
variable=flpstrmvar,
value=0)
flpstrm.pack(side='left')
flpstrm.select()
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Flip in transverse direction?',
width=42,
font='System 10',
anchor='w').pack(side='left')
flptranvar = tk.IntVar()
flptran = tk.Radiobutton(
row,
text='Yes',
width=w,
font='System 10',
anchor='sw',
variable=flptranvar,
value=1)
flptran.pack(side='left')
flptran.select()
flptran = tk.Radiobutton(
row,
text='No',
width=w,
font='System 10',
anchor='sw',
variable=flptranvar,
value=0)
flptran.pack(side='left')
####### MIGRATION
msg = tk.Message(
canvas,
text='MEANDER MIGRATION PARAMETERS',
bg='light cyan',
font='System 11 bold',
width=500,
relief='raised')
msg.pack()
row = tk.Frame(canvas)
row.pack(side='top')
if platform.system() == 'Darwin':
w = 8
else:
w = 4
tk.Label(
row,
text='Meander migration',
width=17,
font='System 10',
anchor='c').pack(side='left')
migvar = tk.IntVar()
mig = tk.Radiobutton(
row,
text='Off',
width=w,
font='System 10',
anchor='sw',
variable=migvar,
value=0)
mig.select()
mig.pack(side='left')
mig = tk.Radiobutton(
row,
text='On',
width=w,
font='System 10',
anchor='sw',
variable=migvar,
value=1)
mig.pack(side='left')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Ub0 (unit: /)',
width=15,
font='System 10',
anchor='w').pack(side='left')
ub0var = tk.DoubleVar()
ub0 = ttk.Combobox(
row,
font='System 10',
width=12,
textvariable=ub0var)
ub0.set('0')
ub0.pack(side='left')
c0var = tk.DoubleVar()
c0 = ttk.Combobox(
row,
font='System 10',
width=12,
textvariable=c0var)
c0.set('0')
c0.pack(side='right')
tk.Label(
row,
text=' C0 (unit: /)',
width=15,
font='System 10',
anchor='w').pack(side='right')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Cf0 (unit: /)',
width=15,
font='System 10',
anchor='w').pack(side='left')
cf0var = tk.DoubleVar()
cf0 = ttk.Combobox(
row,
font='System 10',
width=12,
textvariable=cf0var)
cf0['values'] = ('0.01', '0.02', '0.03')
cf0.set('0.01')
cf0.pack(side='left')
fr0var = tk.DoubleVar()
fr0 = ttk.Combobox(
row,
font='System 10',
width=12,
textvariable=fr0var)
fr0['values'] = ('0.1', '0.2', '0.3', '0.4', '0.5')
fr0.set('0.1')
fr0.pack(side='right')
tk.Label(
row,
text=' Fr0 (unit: /)',
width=15,
font='System 10',
anchor='w').pack(side='right')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='\u0394t (unit: s)',
width=15,
font='System 10',
anchor='w').pack(side='left')
dtvar = tk.DoubleVar()
dt = ttk.Combobox(
row,
font='System 10',
width=12,
textvariable=dtvar)
dt['values'] = ('60', '3600', '86400')
dt.set('86400')
dt.pack(side='left')
e0var = tk.DoubleVar()
e0 = ttk.Combobox(
row,
font='System 10',
width=12,
textvariable=e0var)
e0['values'] = ('1e-5', '1e-6', '1e-7', '1e-8')
e0.set('1e-7')
e0.pack(side='right')
tk.Label(
row,
text=' E0 (unit: /)',
width=15,
font='System 10',
anchor='w').pack(side='right')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Listing printout period',
width=20,
font='System 10',
anchor='w').pack(side='left')
Lprintvar = tk.IntVar()
Lprint = ttk.Combobox(
row,
font='System 10',
width=7,
textvariable=Lprintvar)
Lprint.set('50')
Lprint.pack(side='left')
tstepsvar = tk.IntVar()
tsteps = ttk.Combobox(
row,
font='System 10',
width=7,
textvariable=tstepsvar)
tsteps.set('10000')
tsteps.pack(side='right')
tk.Label(
row,
text=' # of time steps',
width=20,
font='System 10',
anchor='w').pack(side='right')
row = tk.Frame(canvas)
row.pack(side='top')
tk.Label(
row,
text='Graphic printout period',
width=20,
font='System 10',
anchor='w').pack(side='left')
gprintvar = tk.IntVar()
gprint = ttk.Combobox(
row,
font='System 10',
width=7,
textvariable=gprintvar)
gprint.set('100')
gprint.pack(side='left')
fpsvar = tk.IntVar()
fps = ttk.Combobox(
row,
font='System 10',
width=7,
textvariable=fpsvar)
fps['values'] = ('20', '24', '30', '60')
fps.set('24')
fps.pack(side='right')
tk.Label(
row,
text=' FPS of GIF',
width=20,
font='System 10',
anchor='w').pack(side='right')
######## BUTTONS
row = tk.Frame(canvas)
row.pack(side='top',pady=3)
row = tk.Frame(canvas)
row.pack(side='top')
def gen():
entries = [modvar.get(), nbendvar.get(), lamdvar.get(),
thetavar.get(), skewvar.get(), flatvar.get(),
widvar.get(), depvar.get(), slovar.get(),
dsvar.get(), noffsvar.get(), lagmodvar.get(),
lagstrthvar.get(), xyzvar.get(),
bdvar.get(), meshvar.get(), flpstrmvar.get(),
flptranvar.get(), migvar.get(), ub0var.get(),
c0var.get(), cf0var.get(), fr0var.get(),
dtvar.get(), e0var.get(), Lprintvar.get(),
tstepsvar.get(), gprintvar.get(), fpsvar.get(),
smoothvar.get(), stvar.get()]
with open('steering.txt', 'w') as f:
entries_str = str(entries)
f.write(fnamevar.get() + '\n')
f.write(entries_str.replace(', ', '\n')[1:-1] + '\n')
messagebox.showinfo(
message='The steering file \'steering.txt\' has been generated',
icon='info')
tk.Button(
row,
text='Generate steering file',
font='System 11 bold',
command=gen,
padx=6,
pady=1).pack(side='left',padx=6,pady=1)
def run():
if messagebox.showinfo(
message='pyRiverBed will run',
icon='info') == 'ok':
pyriverbed.main()
tk.Button(
row,
text='Run pyRiverBed',
font='System 11 bold',
command=run,
padx=6,
pady=1).pack(side='left',padx=6,pady=1)
def clean():
if messagebox.askyesno(
message='Existing *.jpg, *.pdf, *,gif, *.xyz, *.i2s, *.t3s, *.dat, *.cli and *.bc2 files will be deleted',
icon='warning'):
extList = ['*.jpg', '*.pdf', '*.gif', '*.xyz', '*.i2s', '*.t3s', '*.dat', '*.cli', '*.bc2']
n_file_removed = 0
file_names = ''
for ext in extList:
for f in glob(ext):
remove(f)
n_file_removed += 1
file_names += f + '\n'
if n_file_removed != 0:
messagebox.showinfo(
message = str(n_file_removed) + ' files deleted:\n' + file_names,
icon='info')
else:
messagebox.showinfo(
message='Nothing to delete',
icon='info')
tk.Button(
row,
text='Clean',
font='System 11 bold',
command=clean,
padx=10,
pady=1).pack(side='left',padx=6,pady=1)
def q():
if messagebox.askyesno(
message='Quit?',
icon='warning'):
root.destroy()
tk.Button(
row,
text='Quit',
font='System 11 bold',
command=q,
padx=10,
pady=1).pack(side='left',padx=6,pady=1)
row = tk.Frame(canvas)
row.pack(side='top')
def open_github():
webbrowser.open('https://github.com/ZhiLiHydro/pyRiverBed')
tk.Label(
row,
text='visit',
width=5,
font='System 10',
anchor='e').pack(side='left')
urlok = True
try:
u = request.urlopen('https://github.githubassets.com/images/modules/logos_page/GitHub-Logo.png')
except error.URLError:
urlok = False
if urlok:
icon = u.read()
u.close()
icon = tk.PhotoImage(data=encodebytes(icon)).subsample(15, 15)
tk.Button(
row,
font='System 11 bold',
command=open_github,
width=60,
height=25,
image=icon).pack(side='left')
else:
tk.Button(
row,
text='GitHub',
font='System 11 bold',
command=open_github,
padx=15,
pady=1).pack(side='left',padx=3,pady=1)
tk.Label(
row,
text='for README',
width=10,
font='System 10',
anchor='w').pack(side='left')
root.mainloop()
try:
rmtree('__pycache__')
except OSError:
pass
tool_bar = ttk.Label(main_application)
tool_bar.pack(side=tk.TOP, fill=tk.X)
##font box
font_tuple = tk.font.families()
font_family = tk.StringVar()
font_box = ttk.Combobox(tool_bar,
width=30,
textvariable=font_family,
state='readonly')
font_box['values'] = font_tuple
font_box.current(font_tuple.index('Arial'))
font_box.grid(row=0, column=0, padx=5)
##size box
size_var = tk.IntVar()
font_size = ttk.Combobox(tool_bar,
width=14,
textvariable=size_var,
state='readonly')
font_size['values'] = tuple(range(8, 80, 2))
font_size.current(4)
font_size.grid(row=0, column=1, padx=5)
##bold button
bold_icon = tk.PhotoImage(file='icons2/bold.png')
bold_btn = ttk.Button(tool_bar, image=bold_icon)
bold_btn.grid(row=0, column=2, padx=5)
##italic button
italic_icon = tk.PhotoImage(file='icons2/italic.png')
