class SlideShow(Tk):
# inherit GUI framework extending tkinter
def __init__(self, msShowTimeBetweenSlides=1500):
# initialize tkinter super class
Tk.__init__(self)
# time each slide will be shown
self.showTime = msShowTimeBetweenSlides
# look for images in current working directory where this module lives
listOfSlides = [slide for slide in listdir() if slide.endswith('gif')]
# endlessly read in the slides so we can show them on the tkinter Label
self.iterableCycle = cycle((PhotoImage(file=slide), slide) for slide in listOfSlides)
# create tkinter Label widget which can also display images
self.slidesLabel = Label(self)
# create the Frame widget
self.slidesLabel.pack()
def slidesCallback(self):
# get next slide from iterable cycle
currentInstance, nameOfSlide = next(self.iterableCycle)
# assign next slide to Label widget
self.slidesLabel.config(image=currentInstance)
# update Window title with current slide
self.title(nameOfSlide)
# recursively repeat the Show
self.after(self.showTime, self.slidesCallback)
def set_label(self, name, text='', side='left', width=0):
if name not in self.labels:
label = Label(self, borderwidth=0, anchor='w')
label.pack(side=side, pady=0, padx=4)
self.labels[name] = label
else:
label = self.labels[name]
if width != 0:
label.config(width=width)
label.config(text=text)
def __init__(self,parent,anchor,relief):
"""
:param parent: fenetre root
:param anchor: anchor
:param relief: relief
"""
for i in range(1,DIMENSION+1):
label=Label(parent,text=i,anchor=anchor)
label.config(borderwidth=0,width=2,height=2,relief=relief,bg="bisque")
label.grid(row=i,column=3)
def __init__(self,parent,anchor,relief):
"""
:param parent: fenetre root
:param anchor: anchor
:param relief: relief
"""
col=4
for i in map(chr, range(97, 97+DIMENSION)):
label=Label(parent,text=i,anchor=anchor)
label.config(borderwidth=0,width=4,height=2,relief=relief,bg="bisque")
label.grid(row=11,column=col)
col+=1
class StatusBar(Frame):
def __init__(self, master):
Frame.__init__(self, master)
self.label = Label(self, borderwidth=1, relief=SUNKEN, anchor=E)
self.label.pack(fill=X)
def set(self, format, *args):
self.label.config(text=format % args)
self.label.update_idletasks()
def clear(self):
self.label.config(text="")
self.label.update_idletasks()
class Image_(Widget_):
def __init__(self, parent_frame, x, y):
Widget_.__init__(self, parent_frame, x, y)
self.label = Label(self.widget_frame)
self.label.pack()
self.label_bg, self.label_fg = None, None
#def get_(self):
# return self.picture
def get_info(self):
return self.label.cget('text')
def settings(self, **kwargs):
''' all setting changes '''
if 'label_bg' in kwargs:
self.label.config(bg=kwargs['label_bg'])
if 'label_fg' in kwargs:
self.label.config(fg=kwargs['label_fg'])
if 'image' in kwargs:
self.img_path = kwargs['image']
self.picture = Image.open(self.img_path)
self.image = ImageTk.PhotoImage(self.picture)
self.label.config(image=self.image)
if 'resize' in kwargs:
self.picture = self.picture.resize(kwargs['resize'], Image.ANTIALIAS)
self.image = ImageTk.PhotoImage(self.picture)
self.label.config(image=self.image)
return
class DatePicker(Frame):
def __init__(self, root, output_list):
super().__init__(root)
self.root = root
self.output_list = output_list
self.month = datetime.date.today().month
self.year = datetime.date.today().year
self.buttons = {}
for row in range(6):
for col in range(7):
b = Button(self)
self.buttons[(row, col)] = b
b.grid(row=row+1, column=col, sticky="EW")
Button(self, text="<",
command=lambda: self.change_month(-1)).grid(row=0, column=0)
Button(self, text=">",
command=lambda: self.change_month(1)).grid(row=0, column=6)
self.label = Label(self)
self.label.grid(row=0, column=1, columnspan=5)
self.change_month(0)
def change_month(self, delta):
m = self.month + delta - 1
self.month, self.year = m % 12 + 1, self.year + m // 12
self.label.config(text="{} {}".format(calendar.month_name[self.month],
self.year))
self.update_buttons()
def choose(self, day):
self.output_list[:] = [self.year, self.month, day]
self.root.destroy()
def set_day(self, button, day):
if day:
button.config(text=str(day), command=lambda: self.choose(day),
state=NORMAL)
else:
button.config(text="", command=None, state=DISABLED)
def update_buttons(self):
c = calendar.Calendar(firstweekday=6)
days = c.monthdayscalendar(self.year, self.month)
for row in range(6):
for col in range(7):
try:
day = days[row][col]
except IndexError:
day = 0
self.set_day(self.buttons[(row, col)], day)
class App:
def __init__(self, master):
frame = Frame(master)
frame.pack()
self.new_madlib_button = Button(frame, text="New Madlib", command=self.new_madlib)
self.new_madlib_button.pack(side=tkinter.LEFT)
self.quit_button = Button(frame, text="QUIT", fg="red", command=frame.quit)
self.quit_button.pack(side=tkinter.RIGHT)
self.label = Label(root, text=Madlib().get_madlib())
self.label.pack()
def new_madlib(self):
self.label.config(text=Madlib().get_madlib())
class Menu(Tk):
def __init__(self):
global FMagasin
Tk.__init__(self)
self.title('Donjon & Python')
self.magasin = Magasin.Magasin(self)
self.magasin.grid(row=0, column=0)
Button(self, text='Jouer', command=self.play, height=2, width=20).grid(row=1, column=1)
Button(self,text='Options', command=__main__.ouvrirOption, height=2, width=9).grid(row=1, column=2)
self.framePerso = LabelFrame(self, text='Selection du personnage', width=30)
self.framePerso.grid(row=0, column=1, columnspan=2)
self.OR = Label(self, background='Yellow', height=2, width=70)
self.OR.grid(row=1, column=0)
self.majOR()
self.remplirFramePerso()
def run(self):
Audio.playMusic('Rogue Legacy - Castle', -1)
self.majPerso()
self.mainloop()
Sauvegarde.sauvegarder(__main__.savePath)
def majPerso(self):
for i in range(3):
self.listeBox[i].maj()
def majOR(self):
self.OR.config(text="Pièce d'or : " + str(Magasin.OR))
def remplirFramePerso(self):
listePerso = GenerationPersonnage.genererPerso()
self.listeBox = []
for i in range(len(listePerso)):
self.listeBox.append(BoxPerso(self.framePerso, listePerso[i], i))
self.listeBox[i].pack()
def play(self):
if __main__.perso:
Sauvegarde.sauvegarder(__main__.savePath)
self.destroy()
__main__.motGraph = MoteurGraphique()
# try: #Les thread entrainent parfois des problèmes d'inconsistance dans pygame
__main__.motGraph.run()
__main__.motGraph = None
class Amel(LabelFrame):
def __init__(self, boss, nom, amelioration, maximum, prix, up, logo):
"""
amelioration (str) : Nom de l'amélioration du bouton
maximum (int) : Maximum de fois que l'on peut augmenter l'amélioration
prix (int) : Prix de l'amélioration par niveau
up (int) : Montant de point apporté par l'amélioration
"""
global imagesMag
self.amel = amelioration
self.max = maximum
self.prix = prix
self.up = up
LabelFrame.__init__(self, boss)
Label(self, image=imagesMag[logo]).pack(side=LEFT)
Label(self, text=nom, width=18).pack(side=LEFT)
self.button = Button(self, command=self.acheter, width = 6)
self.level = Label(self, width=5)
self.total = Label(self, width=11)
self.total.pack(side=RIGHT)
self.level.pack(side=RIGHT)
self.button.pack(side=RIGHT)
self.maj()
def maj(self):
global amel, stat
self.button.config(text=(str((amel[self.amel]+1)*self.prix) + ' PO'))
self.level.config(text=str(amel[self.amel]) + '/' + str(self.max))
self.total.config(text='Total : ' + str(stat[self.amel]))
def acheter(self):
global stat, OR, amel
if ((OR >= (amel[self.amel]+1)*self.prix) and (amel[self.amel] < self.max)):
OR -= (amel[self.amel]+1)*self.prix #A changer
stat[self.amel] += self.up
amel[self.amel] += 1
self.maj()
__main__.menu.majPerso()
__main__.menu.majOR()
class BoxPerso(LabelFrame):
def __init__(self, boss, personnage, numero):
LabelFrame.__init__(self, boss, text=personnage.type)
self.pv = Label(self)
self.pv.pack()
self.atk = Label(self)
self.atk.pack()
self.deff = Label(self)
self.deff.pack()
self.critChc = Label(self)
self.critChc.pack()
Button(self, text='Choisir', command=self.choisir).pack()
self.personnage = personnage
self.maj()
def maj(self):
statObjet = {}
statObjet['pv'] = 0
statObjet['dmg'] = 0
statObjet['deff'] = 0
statObjet['critDmg'] = 0
statObjet['critChc'] = 0
statObjet['multOr'] = 0
statObjet['mana'] = 0
if __main__.menu :
for typ in __main__.menu.magasin.listComboBox:
if typ.get() != '':
for stat in typ.listObjets[typ.get()].stat: #On récupère les stats des objets sélectionnés
statObjet[stat] += typ.listObjets[typ.get()].stat[stat]
self.personnage.majCarac(Magasin.stat['pv'] + statObjet['pv'],
Magasin.stat['atk'] + statObjet['dmg'],
Magasin.stat['deff'] + statObjet['deff'],
Magasin.stat['critDmg'] + statObjet['critDmg'],
Magasin.stat['critChc'] + statObjet['critChc'],
Magasin.stat['multOR'] + statObjet['multOr'],
Magasin.stat['mana'] + statObjet['mana'])
self.pv.config(text='Pv : ' + str(self.personnage.pv), width=30)
self.atk.config(text='Attaque : ' + str(self.personnage.atk))
self.deff.config(text='Armure : ' + str(self.personnage.deff))
self.critChc.config(text='Chance de critique : ' + str(self.personnage.critChc))
def choisir(self):
__main__.perso = self.personnage
class Optionmenu(Widget_):
def __init__(self, parent_frame, x, y):
Widget_.__init__(self, parent_frame, x, y)
self.label_width = 15
self.entry_width = 20
self.options = []
self.stringvar = StringVar()
self.label = Label(self.widget_frame, width=self.label_width, anchor=E)
self.combobox = ttk.Combobox(self.widget_frame,
textvariable=self.stringvar,
state='readonly'
)
self.label.pack(side=LEFT, padx=3)
self.combobox.pack(side=LEFT)
self.label_bg, self.label_fg, self.label_hover_bg, self.label_hover_fg = None, None, None, None
self.entry_bg, self.entry_fg, self.entry_hover_bg, self.entry_hover_fg = None, None, None, None
self.combobox_style = ttk.Style()
self.combobox_style.configure(
'TCombobox',
background='white',
selectbackground='white',
selectforeground='black',
borderwidth=0
)
self.combobox_style.map('TCombobox', fieldbackground=[])
def settings(self, **kwargs):
if 'label' in kwargs:
self.label.config(text=kwargs['label'])
if 'set_option' in kwargs:
self.stringvar.set(kwargs['set_option'])
if 'add_option' in kwargs:
if type(kwargs['add_option']) == list:
self.options.extend(kwargs['add_option'])
elif type(kwargs['add_option']) == str:
self.options.append(kwargs['add_option'])
self.combobox['values'] = tuple(self.options)
if 'font' in kwargs:
self.combobox.config(font=kwargs['font'])
if 'label_bg' in kwargs:
self.label_bg = kwargs['label_bg']
self.label.config(bg=self.label_bg)
if 'label_fg' in kwargs:
self.label_fg = kwargs['label_fg']
self.label.config(fg=self.label_fg)
pass
class PlotterWindow():
def __init__(self, master):
# Tkinter parts
self.master = master
self.master.title("Live Serial Plotter")
self.master.resizable(False, False) # Prevent resizing
# Serial parts
self.ser = None
self.IS_SERIAL_CONNECTED = False
self.serial_data = [[0 for i in range(MAXINPUTS)]
for i in range(NPOINTS)]
self.serial_plotline = []
# Figure
self.f1 = plt.figure(figsize=PLOTRATIO, dpi=PLOTDPI)
self.a1 = self.f1.add_subplot(111)
self.a1.grid()
self.a1.set_title("Serial Values")
self.a1.set_xticklabels([])
self.canvas1 = FigureCanvasTkAgg(self.f1, master)
self.canvas1.get_tk_widget().grid(row=0,
column=0,
columnspan=6,
pady=20)
# Labels
self.npointslabel = Label(master, text='# Points')
self.npointslabel.grid(row=1, column=0, sticky='W')
self.baudratelabel = Label(master, text="Baud Rate")
self.baudratelabel.grid(row=2, column=0, sticky='W')
self.portlabel = Label(master, text='Serial Port')
self.portlabel.grid(row=3, column=0, sticky='W')
self.serialconnectedstringvar = StringVar(master, value='Unconnected')
self.serialconnectedlabel = Label(
master, textvar=self.serialconnectedstringvar, fg='red', width=15)
self.serialconnectedlabel.grid(row=1, column=3)
self.numinputslabel = Label(master, text="# Inputs")
self.numinputslabel.grid(row=4, column=0, sticky='W')
self.currentvallabel = Label(master, text="Most recent:")
self.currentvallabel.grid(row=1, column=5)
self.currentvalstringvar = StringVar(master, value='None')
self.currentval = Label(master, textvar=self.currentvalstringvar)
self.currentval.grid(row=2, column=5)
self.packageindicator = StringVar(master, value='!')
self.packageindicatorlabel = Label(master,
textvar=self.packageindicator,
font=('times', 20, 'bold'))
self.packageindicatorlabel.grid(row=4, column=5)
self.packageindicator.set(".")
# OptionMenu lists
_npoints_list = [10, 25, 50, 75, 100, 250, 500, 750,
1000] # Desired points
npoints_list = [str(x) for x in _npoints_list
] # Converting each of these to a string
available_ports = FindAllSerialPorts()
if len(available_ports
) == 0: # If there are no available ports, print a warning
tprint("> Warning: no available ports!")
available_ports.append('None')
_baud_rates = [
110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600,
115200, 128000, 256000
]
baud_rates = [str(x) for x in _baud_rates]
input_num_options = [str(x) for x in range(1, MAXINPUTS + 1)]
plotmethods = ['Markers only', 'Line only',
'Both'] # Various ways to display the plotted values
# StringVars
self.npointsentrystr = StringVar(master, value="250")
self.baudrateentrystr = StringVar(master, value="115200")
self.portentrystr = StringVar(master, value=available_ports[-1])
self.plotmethodentrystr = StringVar(master, value=plotmethods[1])
self.numinputsentrystr = StringVar(master, value="1")
# Using OptionMenu instead:
self.plotmethodoptionmenu = OptionMenu(master, self.plotmethodentrystr,
*plotmethods)
self.plotmethodoptionmenu.grid(row=4, column=2)
self.npointsoptionmenu = OptionMenu(master, self.npointsentrystr,
*npoints_list)
self.npointsoptionmenu.grid(row=1, column=1, sticky='W')
self.baudrateoptionmenu = OptionMenu(master, self.baudrateentrystr,
*baud_rates)
self.baudrateoptionmenu.grid(row=2, column=1, sticky='W')
self.portoptionmenu = OptionMenu(master, self.portentrystr,
*available_ports)
self.portoptionmenu.width = 20
self.portoptionmenu.grid(row=3, column=1, sticky='W')
self.numinputsoptionmenu = OptionMenu(master, self.numinputsentrystr,
*input_num_options)
self.numinputsoptionmenu.grid(row=4, column=1, sticky='W')
# Buttons
self.show_x_axis = IntVar(master, value=0)
self.showxaxischeckbutton = Checkbutton(master,
text='Show y=0',
variable=self.show_x_axis,
onvalue=1,
offvalue=0)
self.showxaxischeckbutton.grid(row=1, column=2)
self.connectbutton = Button(master,
text='Connect',
command=self.ConnectToSerial)
self.connectbutton.grid(row=2, column=3)
self.disconnectbutton = Button(master,
text='Disconnect',
command=self.DisconnectFromSerial)
self.disconnectbutton.grid(row=3, column=3)
self.refreshserialbutton = Button(master,
text='Refresh Ports',
command=self.RefreshSerial)
self.refreshserialbutton.grid(row=3, column=2)
self.exportdatabutton = Button(master,
text='Export',
command=self.ExportData)
self.exportdatabutton.grid(row=4, column=3)
self.printrawdata = IntVar(master, value=0)
self.printrawbutton = Checkbutton(master,
text='Print raw data',
variable=self.printrawdata,
onvalue=1,
offvalue=0)
self.printrawbutton.grid(row=2, column=2)
self.requirebrackets = IntVar(master, value=1)
self.requirebracketsbutton = Checkbutton(master,
text='Require brackets',
variable=self.requirebrackets,
onvalue=1,
offvalue=0)
self.requirebracketsbutton.grid(row=3, column=5)
# =====================================================================
# =========================================================================
# Runs the main loop for Tk().
def mainloop(self):
self.master.mainloop()
return
# =========================================================================
# =========================================================================
# Connects GUI to a COM port based on the user selected port.
def ConnectToSerial(self):
try:
port = self.portentrystr.get()
baudrate = int(self.baudrateentrystr.get())
tprint("> Trying to connect to %s at %d" % (port, baudrate))
self.ser = serial.Serial(port, baudrate, timeout=0.1)
self.ser.flushInput()
except:
tprint("> Error")
self.ToggleSerialConnectedLabel(False)
return -1
tprint("> Success.")
self.IS_SERIAL_CONNECTED = True # Set GUI state
self.ToggleSerialConnectedLabel(True) # Show the state
self.GetSerialValue() # Begin the GetSerialValue() loop
return
# =========================================================================
# =========================================================================
# Disconnects from whatever serial port is currently active.
def DisconnectFromSerial(self):
if self.IS_SERIAL_CONNECTED: # Only do this if already connected.
self.ser.close()
self.ToggleSerialConnectedLabel(False)
self.IS_SERIAL_CONNECTED = False
return
# =========================================================================
# =========================================================================
# Refreshes the list of available serial ports on the option menu.
def RefreshSerial(self):
new_serial_list = FindAllSerialPorts()
tprint("> Refreshing serial port list")
if len(new_serial_list) == 0:
tprint("> No available serial ports.")
return
self.portentrystr.set(new_serial_list[-1]) # Set the variable to none
self.portoptionmenu['menu'].delete(0, 'end') # Delete the old list
for port in new_serial_list: # Refresh:
self.portoptionmenu['menu'].add_command(label=port,
command=_setit(
self.portentrystr,
port))
return
# =========================================================================
# =========================================================================
# Exports the data to a file associated with the current date and time.
def ExportData(self):
timestamp = datetime.datetime.now().strftime('%y%m%d_%H%M%S')
outfname = 'SessionLogs/SerialSessionLog_%s.csv' % (timestamp)
try:
hit_data_start = False
f = open(outfname, 'w')
for sd in self.serial_data:
# Check if we have data yet, don't start appending until that point
if not hit_data_start:
if not any(sd):
continue # Skip to the next data point if all values are zeros
else:
hit_data_start = True
wstr = ''
for d in sd:
wstr += '%f,' % (d)
wstr = wstr[:-1] + '\n'
f.write(wstr)
f.close()
tprint("> Successfully exported to %s" % (outfname))
except:
tprint("> Error: Unable to export data")
return
# =========================================================================
# =========================================================================
# Changes the "good data received" indicator.
def SetPackageIndicator(self, state):
if state == 'good':
self.packageindicator.set("!")
self.packageindicatorlabel.config(fg='green',
font=('times', 20, 'bold'))
else:
self.packageindicator.set('.')
self.packageindicatorlabel.config(fg='black',
font=('times', 20, 'bold'))
return
# =========================================================================
# =========================================================================
# Gets the most recent serial value from connection. IMPORTANT.
def GetSerialValue(self):
if not self.IS_SERIAL_CONNECTED:
tprint("> No connection")
return
try:
# Read data
rawdata = self.ser.readline().decode('utf8')
if rawdata != '':
self.currentvalstringvar.set(str(rawdata[:-1]))
self.ser.flushInput() # Clear this out to avoid garbage data
self.ser.flushOutput() # Clear this out to avoid garbage data
# Parse data
x_nonewline = rawdata[:-1] # Ignore the trailing newline
if self.printrawdata.get(): # Print the raw data, if desired
print(x_nonewline)
if self.requirebrackets.get():
if ">" in x_nonewline and "<" in x_nonewline:
x = x_nonewline[1:-2]
try:
npoints = int(self.npointsentrystr.get())
x_split = x.split(' ')
# Make sure that every data package is the same length, so it's not a sequence
senddata = []
for i in range(MAXINPUTS):
try:
senddata.append(float(x_split[i]))
except:
senddata.append(
self.serial_data[-1]
[i]) # Append the most recent value
self.serial_data.append(senddata)
self.serial_data = self.serial_data[1:]
self.serial_plotline = self.serial_data[-npoints:]
# Set the blinker indicator to green!
self.SetPackageIndicator('good')
self.master.after_idle(
self.Plotline) # Once everything's done, plot it!
except ValueError:
tprint(
"> Invalid serial value: Non-floating point detected: %s"
% (x))
else:
self.SetPackageIndicator('bad')
else:
x = x_nonewline
try:
npoints = int(self.npointsentrystr.get())
x_split = x.split(' ')
# Make sure that every data package is the same length, so it's not a sequence
senddata = []
for i in range(MAXINPUTS):
try:
senddata.append(float(x_split[i]))
except:
senddata.append(
self.serial_data[-1]
[i]) # Append the most recent value
self.serial_data.append(senddata)
self.serial_data = self.serial_data[1:]
self.serial_plotline = self.serial_data[-npoints:]
self.master.after_idle(self.Plotline)
except ValueError:
tprint(
"> Invalid serial value: Non-floating point detected: %s"
% (x))
except Exception as e:
tprint("> Error in GetSerialValue()", e)
self.master.after(
TIMEDELAY,
self.GetSerialValue) # Do it all again: Here's making it the loop
return
# =========================================================================
# =========================================================================
# Plots the data to the GUI's plot window.
def Plotline(self):
numpoints = int(self.npointsentrystr.get())
numinputs = int(self.numinputsentrystr.get())
if self.plotmethodentrystr.get() == 'Markers only':
plotmethod = '.'
elif self.plotmethodentrystr.get() == 'Line only':
plotmethod = '-'
else:
plotmethod = '.-'
self.a1.clear()
for i in range(numinputs): # Plot each line individually
plotline = [x[i] for x in self.serial_plotline]
self.a1.plot(plotline, plotmethod, label=str(i))
self.a1.grid()
if self.show_x_axis.get():
self.a1.set_ylim(0, 1.125 * np.amax(np.array(self.serial_data)))
# Plot formatting parameters
ticklabels = np.linspace(numpoints / 10, 0, 5)
self.a1.set(xticks=np.linspace(0, numpoints, 5),
xticklabels=ticklabels)
self.a1.set_xticklabels([])
self.a1.set_ylabel("Serial Value")
self.a1.legend(loc=3)
self.a1.set_title("Serial Values")
self.canvas1.draw() # Actually update the GUI's canvas object
return
# =========================================================================
# =========================================================================
# Swap out the string label indicating whether serial is connected.
def ToggleSerialConnectedLabel(self, connection):
if connection:
self.serialconnectedstringvar.set('Connected')
self.serialconnectedlabel.config(fg='green')
else:
self.serialconnectedstringvar.set('Unconnected')
self.serialconnectedlabel.config(fg='red')
return
orient='horizontal',
mode='indeterminate',
length=120)
pb.place(x=190, y=320)
pbTip = Hovertip(
pb,
'Please be kind and restart the program \nif the progress bar runs for a long time'
)
done_label = Label(window,
text="",
fg="green",
height=2,
anchor="e",
background='white')
done_label.config(font=("Arial", 14, 'bold'))
done_label.place(x=215, y=345)
window.mainloop()
'''
def cell_family_tree(cell):
global relatives
family = []
cell_data = cell_parser(cell)
birth_date = cell_data[11]
for next_cell in data[:-1]:
next_cell_data = cell_parser(next_cell)
if birth_date != 0:
if (cell_data[0][birth_date] == next_cell_data[0][birth_date]) and (
cell_data[1][birth_date] == next_cell_data[1][birth_date]):
family.append(list(data).index(next_cell))
class SYSTEMCLOCK(LabelFrame):
'''
Display para la hora del sistema
args, kwrds:
(master: contenedor, row: int, column: int, display_font: {}, text_font: {})
propiedades publicas:
display_font: La tipográfia de los digitos {font: nombre, size: int, type: normal | italic | bold}
text_font: La tipográfia de los textos {font: nombre, size: int, type: normal | italic | bold}
NOTA:
si en algun momento se decide cambiar alguna o ambas
debe ejecutarse el metodo update() inmediatamente despues.
propiedades protegidas:
_meridian: am | pm
currentTime: hora del sistema
metodos:
tictac(): Actualiza la hora.
update() : Actualiza el display.
'''
def __init__(self,
master,
row,
column,
display_font={},
text_font={},
textColor='white'):
super().__init__(master)
self.master = master
self.row = row
self.column = column
self.display_font = display_font
self.text_font = text_font
self.textColor = textColor
self.currentTime = StringVar()
#----------------- CLOCK GROUP -------------------
self.config(text='Reloj',
fg=self.textColor,
bg=self.master['bg'],
pady=7,
padx=4,
bd=2,
relief='ridge')
# realif styles --> flat, groove, raised, ridge, solid, or sunken
self.grid(row=self.row, column=self.column)
#----------------- CLOCK DISPLAY -------------------
self.__clockDisplay = Label(self)
self.__glass = PhotoImage(file=fd)
self.__clockDisplay.config(textvariable=self.currentTime,
pady=0,
padx=0,
bd=0,
fg=self.textColor,
image=self.__glass,
compound='center')
self.__clockDisplay.grid(row=1, column=0, padx=4, pady=4)
#------------ AM/PM -----------
self._meridian = StringVar()
self._meridian.set(time.strftime('%p').lower())
self.__meridianDisplay = Label(self)
self.__meridianDisplay.config(fg=self.textColor,
bg=self.master['bg'],
textvariable=self._meridian,
pady=0,
padx=0,
bd=0)
self.__meridianDisplay.grid(row=0, column=0, sticky='ne')
self.hide_show_separator = (lambda x: time.strftime('%I %M')
if x % 2 == 0 else time.strftime('%I:%M'))
self.update()
def tictac(self):
'''
Actualiza la hora
'''
self.seconds = int(time.strftime('%S'))
self.currentTime.set((self.hide_show_separator)(self.seconds))
self._meridian.set(time.strftime('%p').lower())
self.after(1000, self.tictac)
def update(self):
'''
Actualiza el Display
'''
self.config(font=(self.text_font['font'], self.text_font['size'],
self.text_font['type']))
self.__clockDisplay.config(font=(self.display_font['font'],
self.display_font['size'],
self.display_font['type']),
fg=self.textColor)
self.__meridianDisplay.config(font=(self.text_font['font'],
self.text_font['size'],
self.text_font['type']))
class SideFrame():
def __init__(self, parent=None, width=225, height=630, board=None):
self.__parent = parent
self.__width = width
self.__height = height
if (not parent == None):
self.__frame = Frame(parent, width=width, height=height)
elif (board == None):
self.parent = Tk()
self.__frame = Frame(self.parent, width=width, height=height)
else:
self.parent = board.getRoot()
self.__frame = Frame(self.parent, width=width, height=height)
self.__frame.grid(row=0, column=1)
if (board == None):
self.__board = Board(self.__parent)
else:
self.__board = board
self.__initCommandText(x=0, y=0, height=height / 2, width=width)
lblheight = int(height / 8)
self.__initPlayerLabel(x=(width - lblheight) / 2,
y=height / 14 + height / 2,
height=lblheight,
width=lblheight)
btnheight = int(height / 6)
self.__initPlayButton(x=(width - btnheight) / 2,
y=height / 7 + lblheight + height / 2,
height=btnheight,
width=btnheight)
def __initCommandText(self, x, y, height, width):
self.__commandText = Text(self.__frame,
fg="whitesmoke",
bg="gray12",
font=('Helvetica', 7),
borderwidth=1,
wrap=WORD)
self.__commandText.place(x=x, y=y, height=height, width=width)
self.__commandText.insert(INSERT, "Frame Initialized.")
self.__commandText.config(state=DISABLED)
scrollbar = Scrollbar(self.__commandText)
scrollbar.pack(side=RIGHT, fill=Y)
self.__commandText.config(yscrollcommand=scrollbar.set)
scrollbar.config(command=self.__commandText.yview)
def __initPlayerLabel(self, x, y, height, width):
self.__playerLabel = Label(self.__frame,
text="Turn: White.",
fg="dimgrey",
bg="whitesmoke",
borderwidth=1,
relief=RIDGE)
self.__playerLabel.place(x=x, y=y, height=height, width=width)
def __initPlayButton(self, x, y, height, width, text="Play", command=None):
if (command == None):
self.__playButton = Button(self.__frame,
text=str(text),
command=self.__isPushed)
self.__playButton.place(x=x, y=y, height=height, width=width)
else:
self.__playButton = Button(self.__frame,
text=str(text),
command=command)
self.__playButton.place(x=x, y=y, height=height, width=width)
def __isPushed(self):
movement = input("Enter your movement as a 4-digit number: ")
if (len(movement) == 4):
movement = int(movement)
xOld = int(movement / 1000)
yOld = int((movement / 100) % 10)
xNew = int((movement / 10) % 10)
yNew = int(movement % 10)
try:
isMoved = self.__board.movePiece(xOld, yOld, xNew, yNew)
if (isMoved):
move = "xOld = " + str(xOld) + " yOld " + str(
yOld) + " xNew " + str(xNew) + " yNew " + str(yNew)
print(move)
self.__printToCommandText(move)
if (self.__playerLabel.cget("bg") == "whitesmoke"):
self.__playerLabel.config(bg="dimgrey",
fg="whitesmoke",
text="Turn: Black.")
else:
self.__playerLabel.config(bg="whitesmoke",
fg="dimgrey",
text="Turn: White.")
except IllegalMovement as e:
print("not moved.")
self.__printToCommandText("not moved.")
print(e)
self.__printToCommandText(e)
except NotPlayersPiece as e:
print("not moved.")
self.__printToCommandText("not moved.")
print(e)
self.__printToCommandText(e)
except EmptyHeadTile as e:
print("not moved.")
self.__printToCommandText("not moved.")
print(e)
self.__printToCommandText(e)
elif (len(movement) == 3):
movement = int(movement)
x = int(movement / 100)
y = int((movement / 10) % 10)
typePromote = int(movement % 10)
try:
isMoved = False
isMoved = self.__board.promotePawnAt(x=x,
y=y,
typePromote=typePromote)
if (isMoved):
move = "x = " + str(x) + " y " + str(y) + " type " + str(
typePromote)
print(move)
self.__printToCommandText(move)
if (self.__playerLabel.cget("bg") == "whitesmoke"):
self.__playerLabel.config(bg="dimgrey",
fg="whitesmoke",
text="Turn: Black.")
else:
self.__playerLabel.config(bg="whitesmoke",
fg="dimgrey",
text="Turn: White.")
except NotPlayersPiece as e:
print("not moved.")
self.__printToCommandText("not moved.")
print(e)
self.__printToCommandText(e)
except EmptyHeadTile as e:
print("not moved.")
self.__printToCommandText("not moved.")
print(e)
self.__printToCommandText(e)
def __printToCommandText(self, string):
self.__commandText.config(state=NORMAL)
self.__commandText.insert(END, "\n" + str(string))
self.__commandText.config(state=DISABLED)
def _setBoard(self, board):
self.__board = board
def __del__(self):
del self.__width
del self.__height
del self.__commandText
del self.__playerLabel
del self.__playButton
del self.__frame
class App(Tk):
def __init__(self, *args, **kwargs):
'''
the ui stuff
'''
super().__init__(*args, **kwargs)
self.color = 'blue'
self.winfo_toplevel().title('Judgy Hexagon')
#Menu for a bit of documentation and help
self.menu = Menu(self)
self.menu.add_command(label='Change Color', command=self.change_color)
self.menu.add_command(label='Help', command=self.help)
self.menu.add_command(label='People', command=self.people)
self.config(menu=self.menu)
#the main canvas to show the hexagon
self.canvas = Canvas(self, height=566, width=800)
self.canvas.grid(row=1, column=1)
#frame to put all the sliders in
self.sf = Frame(self)
self.sf.grid(row=1, column=3)
#entries for the trait names (with default values)
self.sl1 = Entry(self.sf)
self.sl1.grid(row=0, column=0)
self.sl1.insert(END, 'IQ')
self.sl2 = Entry(self.sf, text='EQ')
self.sl2.grid(row=1, column=0)
self.sl2.insert(END, 'EQ')
self.sl3 = Entry(self.sf)
self.sl3.grid(row=2, column=0)
self.sl3.insert(END, 'Attractiveness')
self.sl4 = Entry(self.sf)
self.sl4.grid(row=3, column=0)
self.sl4.insert(END, 'Personality')
self.sl5 = Entry(self.sf)
self.sl5.grid(row=4, column=0)
self.sl5.insert(END, 'Athleticism')
self.sl6 = Entry(self.sf)
self.sl6.grid(row=5, column=0)
self.sl6.insert(END, 'Artisticness')
#sliders
self.t1scale = Scale(self.sf, from_=0, to=9, orient=HORIZONTAL)
self.t1scale.grid(column=1, row=0)
self.t2scale = Scale(self.sf, from_=0, to=9, orient=HORIZONTAL)
self.t2scale.grid(column=1, row=1)
self.t3scale = Scale(self.sf, from_=0, to=9, orient=HORIZONTAL)
self.t3scale.grid(column=1, row=2)
self.t4scale = Scale(self.sf, from_=0, to=9, orient=HORIZONTAL)
self.t4scale.grid(column=1, row=3)
self.t5scale = Scale(self.sf, from_=0, to=9, orient=HORIZONTAL)
self.t5scale.grid(column=1, row=4)
self.t6scale = Scale(self.sf, from_=0, to=9, orient=HORIZONTAL)
self.t6scale.grid(column=1, row=5)
#the labels to make clear which line is which trait
self.l1 = Label(self, text=self.sl1.get(),
font=('Calibri', 20))
self.l1.grid(row=1, column=2, sticky=E)
self.l2 = Label(self, text=self.sl2.get(),
font=('Calibri', 20))
self.l2.grid(row=1, column=1, sticky=SE)
self.l3 = Label(self, text=self.sl3.get(),
font=('Calibri', 20))
self.l3.grid(row=1, column=1, sticky=SW)
self.l4 = Label(self, text=self.sl4.get(),
font=('Calibri', 20))
self.l4.grid(row=1, column=0, sticky=W)
self.l5 = Label(self, text=self.sl5.get(),
font=('Calibri', 20))
self.l5.grid(row=1, column=1, sticky=NW)
self.l6 = Label(self, text=self.sl6.get(),
font=('Calibri', 20))
self.l6.grid(row=1, column=1, sticky=NE) #:)
#put the person's name in here
self.nameentry = Entry(self.sf)
self.nameentry.grid(row=7, column=1)
Label(self.sf, text='\n\nName of person\n\n').grid(row=7, column=0)
self.namelabel = Label(self, text='Name', font=('Calibri', 20), fg='red')
self.namelabel.grid(row=0, column=1)
#6 lists of points
self.listright = [(400+40*i, 200*2**0.5)
for i in range(10)]
self.listrightdown = [(400+20*i, 200*2**0.5+i*20*2**0.5)
for i in range(10)]
self.listleftdown = [(400-20*i, 200*2**0.5+i*20*2**0.5)
for i in range(10)]
self.listleft = [(400-40*i, 200*2**0.5)
for i in range(10)]
self.listleftup = [(400-20*i, 200*2**0.5-i*20*2**0.5)
for i in range(10)]
self.listrightup = [(400+20*i, 200*2**0.5-i*20*2**0.5)
for i in range(10)]
#Draw the 10 hexagons
for i in range(10):
self.canvas.create_polygon([self.listright[i][0],
self.listright[i][1],
self.listrightdown[i][0],
self.listrightdown[i][1],
self.listleftdown[i][0],
self.listleftdown[i][1],
self.listleft[i][0],
self.listleft[i][1],
self.listleftup[i][0],
self.listleftup[i][1],
self.listrightup[i][0],
self.listrightup[i][1],],
fill='', width=1, outline='black')
def change_color(self):
self.color = clr.askcolor(title='Choose a color for the shape')[1]
def help(self):
msg.showinfo(title='Help', message='''
How to use this app:
Move around the sliders and enter a name.
Type your 6 character traits in the 6 entries.
You can change the color of shape by clicking on the 'Change Color' menu option.
Then, take a snip of the part without the sliders.
Tutorial on judgy hexagons in real life:
First, draw like 8 nested hexagons.
Connect all the points with 6 lines.
Label each of the lines with a trait (should be the traits below).
For each of the traits, rank them from 1-8 and draw the point on the line.
The outer hexagons are higher.
Now, connect all 6 points, and color in the polygon made by them.''')
def people(self):
msg.showinfo(title='People', message='''
List of people related to this:
Ideas: Aileen Liang (probably more this person), Hanting Li
Python implementation: Owen Fei
Another app to check out: Owen Zhang''')
def judge(self, t1, t2, t3, t4, t5, t6):
'''
Draws the filled-in polygon in blue.
'''
#Get which point each level of trait is
t1 = self.listright[t1]
t2 = self.listrightdown[t2]
t3 = self.listleftdown[t3]
t4 = self.listleft[t4]
t5 = self.listleftup[t5]
t6 = self.listrightup[t6]
#REmove the last shape if possible
try:
self.canvas.delete(self.last_polygon)
except:
pass
#Draw the new polygon
self.last_polygon = self.canvas.create_polygon([t1[0],
t1[1],
t2[0],
t2[1],
t3[0],
t3[1],
t4[0],
t4[1],
t5[0],
t5[1],
t6[0],
t6[1],],
fill=self.color,
width=1,
outline=self.color)
self.canvas.update()
def main(self):
'''
Constantly draws the new polygon.
Constantly updates the name.
'''
while True:
#Update the name
self.namelabel.config(text=self.nameentry.get())
#Call judge() on the values of the sliders
self.judge(self.t1scale.get(),
self.t2scale.get(),
self.t3scale.get(),
self.t4scale.get(),
self.t5scale.get(),
self.t6scale.get())
#Updates the labels with trait names.
self.l1.config(text=self.sl1.get())
self.l2.config(text=self.sl2.get())
self.l3.config(text=self.sl3.get())
self.l4.config(text=self.sl4.get())
self.l5.config(text=self.sl5.get())
self.l6.config(text=self.sl6.get())
self.update()
class MyFirstGUI:
def __init__(self, master):
self.master = master
master.title("URBAN SOUND CLASSIFICATION---DHARMESH SINGH")
self.msg = "Load the sound and predict the class"
self.label = Label(master, text=self.msg)
self.label.pack(pady=10)
self.load_sound_button = Button(master,
text="Load",
command=self.load_sound,
bg="light green",
fg="black")
self.load_sound_button.pack(pady=10)
self.fileLabel = Label(master,
text="no file selected",
bg="white",
fg="black")
self.fileLabel.pack(pady=10)
self.play_sound_button = Button(master,
text="PLAY TO LISTEN",
command=self.play_sound,
bg="light green",
fg="black")
self.play_sound_button.pack(pady=10)
self.playLabel = Label(master, text="", bg="white", fg="black")
self.playLabel.pack(pady=10)
self.predict_button = Button(master,
text="Predict",
command=self.predict_class,
bg="yellow",
fg="black")
self.predict_button.pack(pady=10)
self.outlabel = Label(master, bg="white", fg="black")
self.outlabel.pack(pady=10)
self.close_button = Button(master,
text="Close",
command=master.quit,
bg="red",
fg="white")
self.close_button.pack(pady=10)
def load_sound(self):
root.filename = filedialog.askopenfilename(
initialdir=
"/PycharmProjects/NITtrichy/SOUND-CLASSFICATION/UrbanSound8K/audio",
title="Select file",
filetypes=(("wav files", "*.wav"), ("all files", "*.*")))
l = root.filename.split("/")
self.fileLabel["text"] = l[-1] + " is loaded"
def play_sound(self):
l = root.filename.split("/")
self.playLabel.config(text=l[-1] + " is played!!")
playsound(root.filename)
def predict_class(self):
features = extract_features(root.filename)
l = root.filename.split("/")
features = np.reshape(features, (1, 7, 7, 1))
res = class_model.predict_classes(features)
sound_class = get_class(res[0])
self.outlabel.config(text="CLASS: " + sound_class)
print("%s %d %s" % (l[-1], res[0], sound_class))
programRun(k, tr, ts)
oldk = k
oldtr = tr
oldtes = ts
elif (oldtes == ts) and (oldtr == tr):
PrRun(k)
oldK = k
label = Label(window,
text="K-Nearest Neighbour Classifier",
bg="black",
fg="white",
padx=5,
pady=5)
label.config(font=("Arial", 18))
label.pack(fill="x")
h1 = Frame(window)
label1 = Label(h1, text="Value of K", bg="red", fg="white", padx=10, pady=10)
# label1.config(font=("Arial",18))
label1.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
label1 = Label(h1,
text="Training Ratio",
bg="red",
fg="white",
padx=10,
pady=10)
# label1.config(font=("Arial",18))
label1.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
label1 = Label(h1,
'''
_BACKGROUNDCOLOR = "#c3fdff"
_BACKGROUNDCOLOR_VARIANT = '#5adbee'
'''
_BACKGROUNDCOLOR = "#E5DEF1"
_BACKGROUNDCOLOR_VARIANT = "#898590"
window = Tk()
window.title("Graph articulation points")
window.geometry("1280x900")
window["bg"] = _BACKGROUNDCOLOR
window.resizable(False, False)
title = Label(window ,text="Graph articulation points")
title.config(font=('Arial' , 27))
title["bg"] = _BACKGROUNDCOLOR
title.pack(padx = 20, pady = 20)
right_side_container = Frame(window)
class App:
def __init__(self, parent):
self.parent = parent
self.canvas = Canvas(parent, width=669, height=639 ,bg=_BACKGROUNDCOLOR)
self.canvas.pack(side='top',padx = 20, pady = 20)
self.sequence = [ImageTk.PhotoImage(img)
for img in ImageSequence.Iterator(
Image.open(
r'dfsanimation.gif'))]
class Gramaticas(Frame):
def __init__(self, master):
self.G = None
ttk.Frame.__init__(self, master)
#----MENU ----#
self.menu = Frame(self)
self.menu.grid(row=0, column=0, sticky='nsew', rowspan=2)
#--------Boton para cargar Gramatica ----#
btnCargar = Button(self.menu, text='Cargar gramatica')
btnCargar.config(command=lambda: self.cargarGram())
btnCargar.pack(fill='x')
#--------Tipo de gramatica ----#
self.gramType = StringVar(self.menu)
self.gramType.set('LL0')
olGramType = OptionMenu(self.menu, self.gramType, *{'LL0', 'LL1'})
olGramType.pack(fill='x')
#--------Analizar cadena ----#
lblAnalizar = Label(self.menu, text='Cadena a analizar')
lblAnalizar.pack(fill='x')
self.txtCadena = Entry(self.menu, width=4)
self.txtCadena.pack(fill='x')
self.btnAnalizar = Button(self.menu, text='Analizar cadena')
self.btnAnalizar.config(state='disabled',
command=lambda: self.analizar())
self.btnAnalizar.pack(fill='x')
#----INFO ----#
self.info = Frame(self, bg='white')
self.info.grid(row=0, column=1, sticky='nsew')
lblTituloGram = Label(self.info,
text='Informacion de la gramatica',
font=DEFAULTFONT,
justify='center',
bg='white')
lblTituloGram.grid(row=0)
self.lblinfoGram = Label(self.info,
text='',
justify='left',
font=DEFAULTFONT,
bg='white')
self.lblinfoGram.grid(row=1, column=0, sticky='nsew')
Label(self.info,
text='Analisis',
justify='left',
font=DEFAULTFONT,
bg='white').grid(row=0, column=2, sticky='nsew')
self.lblanalisis = Label(self.info,
text='',
justify='left',
font=DEFAULTFONT,
bg='white')
self.lblanalisis.grid(row=1, column=2, sticky='nsew')
def analizar(self):
print('Analizar')
if self.G:
print('Existe G')
if self.G.tipo == 'LL1':
print('Es LL1')
output = self.G.analyzeLL1(self.txtCadena.get())
print(output)
self.lblanalisis.config(text=output)
def cargarGram(self):
f = filedialog.askopenfilename(defaultextension='.txt',
initialdir=DEFAULTDIR)
if not len(f):
return
self.G = Gramatica.Gramatica(f, self.gramType.get())
if self.G.errorAlCrear != False:
messagebox.showinfo(
"Error al crear la gramatica",
"La gramatica no se puedo crear porque" + self.G.errorAlCrear)
self.G = None
return
self.btnAnalizar.config(state='normal')
self.lblinfoGram.config(text=str(self.G))
class View():
selected_piece_position = None
all_squares_to_be_highlighted = []
images = {}
board_color_1 = BOARD_COLOR_1
board_color_2 = BOARD_COLOR_2
highlight_color = HIGHLIGHT_COLOR
def __init__(self, parent, controller):
self.controller = controller
self.parent = parent
self.create_chess_base()
self.canvas.bind("<Button-1>", self.on_square_clicked)
self.start_new_game()
def reload_colors(self, color_1, color_2, highlight_color):
self.board_color_1 = color_1
self.board_color_2 = color_2
self.highlight_color = highlight_color
self.draw_board()
self.draw_all_pieces()
def on_preference_menu_clicked(self):
self.show_preferences_window()
def show_preferences_window(self):
preferenceswindow.PreferencesWindow(self)
def create_bottom_frame(self):
self.bottom_frame = Frame(self.parent, height=64)
self.info_label = Label(self.bottom_frame,
text=" White to Start the Game ")
self.info_label.pack(side=RIGHT, padx=8, pady=5)
self.bottom_frame.pack(fill="x", side="bottom")
def create_top_menu(self):
self.menu_bar = Menu(self.parent)
self.create_file_menu()
self.create_edit_menu()
self.create_about_menu()
def create_file_menu(self):
self.file_menu = Menu(self.menu_bar, tearoff=0)
self.file_menu.add_command(label="New Game",
command=self.on_new_game_menu_clicked)
self.menu_bar.add_cascade(label="File", menu=self.file_menu)
self.parent.config(menu=self.menu_bar)
def create_edit_menu(self):
self.edit_menu = Menu(self.menu_bar, tearoff=0)
self.edit_menu.add_command(label="Preferences",
command=self.on_preference_menu_clicked)
self.menu_bar.add_cascade(label="Edit", menu=self.edit_menu)
self.parent.config(menu=self.menu_bar)
def create_about_menu(self):
self.about_menu = Menu(self.menu_bar, tearoff=0)
self.about_menu.add_command(label="About",
command=self.on_about_menu_clicked)
self.menu_bar.add_cascade(label="About", menu=self.about_menu)
self.parent.config(menu=self.menu_bar)
def create_canvas(self):
canvas_width = NUMBER_OF_COLUMNS * DIMENSION_OF_EACH_SQUARE
canvas_height = NUMBER_OF_ROWS * DIMENSION_OF_EACH_SQUARE
self.canvas = Canvas(self.parent,
width=canvas_width,
height=canvas_height)
self.canvas.pack(padx=8, pady=8)
def create_chess_base(self):
self.create_top_menu()
self.create_canvas()
self.draw_board()
self.create_bottom_frame()
def start_new_game(self):
self.controller.reset_game_data()
self.controller.reset_to_initial_locations()
self.draw_all_pieces()
self.info_label.config(text=" White to Start the Game ")
def reset_board_state(self):
self.selected_piece_position = None
self.all_squares_to_be_highlighted = []
self.images = {}
def on_new_game_menu_clicked(self):
self.start_new_game()
def get_clicked_row_column(self, event):
col_size = row_size = DIMENSION_OF_EACH_SQUARE
clicked_column = event.x // col_size
clicked_row = 7 - (event.y // row_size)
return (clicked_row, clicked_column)
def on_square_clicked(self, event):
clicked_row, clicked_column = self.get_clicked_row_column(event)
position_of_click = self.controller.get_alphanumeric_position(
(clicked_row, clicked_column))
# on second click
if self.selected_piece_position:
self.shift(self.selected_piece_position, position_of_click)
self.selected_piece_position = None
self.update_highlight_list(position_of_click)
self.draw_board()
self.draw_all_pieces()
def shift(self, start_pos, end_pos):
selected_piece = self.controller.get_piece_at(start_pos)
piece_at_destination = self.controller.get_piece_at(end_pos)
if not piece_at_destination or piece_at_destination.color != selected_piece.color:
try:
self.controller.pre_move_validation(start_pos, end_pos)
except exceptions.ChessError as error:
self.info_label["text"] = error.__class__.__name__
else:
self.update_label(selected_piece, start_pos, end_pos)
def update_label(self, piece, start_pos, end_pos):
turn = ('white' if piece.color == 'black' else 'black')
self.info_label["text"] = '' + piece.color.capitalize() + " : " + \
start_pos + end_pos + ' ' + turn.capitalize() + '\'s turn'
def update_highlight_list(self, position):
self.all_squares_to_be_highlighted = None
try:
piece = self.controller.get_piece_at(position)
except:
piece = None
if piece and (piece.color == self.controller.player_turn()):
self.selected_piece_position = position
self.all_squares_to_be_highlighted = list(
map(
self.controller.get_numeric_notation,
self.controller.get_piece_at(position).moves_available(
position)))
def get_x_y_coordinate(self, row, col):
x = (col * DIMENSION_OF_EACH_SQUARE)
y = ((7 - row) * DIMENSION_OF_EACH_SQUARE)
return (x, y)
def draw_board(self):
current_color = self.board_color_2
for row in range(NUMBER_OF_ROWS):
current_color = self.get_alternate_color(current_color)
for col in range(NUMBER_OF_COLUMNS):
x1, y1 = self.get_x_y_coordinate(row, col)
x2, y2 = x1 + DIMENSION_OF_EACH_SQUARE, y1 + DIMENSION_OF_EACH_SQUARE
if (self.all_squares_to_be_highlighted
and (row, col) in self.all_squares_to_be_highlighted):
self.canvas.create_rectangle(x1,
y1,
x2,
y2,
fill=self.highlight_color)
else:
self.canvas.create_rectangle(x1,
y1,
x2,
y2,
fill=current_color)
current_color = self.get_alternate_color(current_color)
def get_alternate_color(self, current_color):
if current_color == self.board_color_2:
next_color = self.board_color_1
else:
next_color = self.board_color_2
return next_color
def calculate_piece_coordinate(self, row, col):
x0 = (col * DIMENSION_OF_EACH_SQUARE) + \
int(DIMENSION_OF_EACH_SQUARE / 2)
y0 = ((7 - row) * DIMENSION_OF_EACH_SQUARE) + \
int(DIMENSION_OF_EACH_SQUARE / 2)
return (x0, y0)
def draw_single_piece(self, position, piece):
x, y = self.controller.get_numeric_notation(position)
if piece:
filename = "../pieces_image/{}_{}.png".format(
piece.name.lower(), piece.color)
if filename not in self.images:
self.images[filename] = PhotoImage(file=filename)
x0, y0 = self.calculate_piece_coordinate(x, y)
self.canvas.create_image(x0,
y0,
image=self.images[filename],
tags=("occupied"),
anchor="c")
def draw_all_pieces(self):
self.canvas.delete("occupied")
for position, piece in self.controller.get_all_peices_on_chess_board():
self.draw_single_piece(position, piece)
def on_about_menu_clicked(self):
messagebox.showinfo(
"From the Book:",
"Tkinter GUI Application\n Development Blueprints")
class Setup:
def __init__(self):
log.info(f'{__name__} has been initialized.')
self.auth_win = None
self.progress = None
self.status_text = None
self.key_entry = None
self.okay_button = None
self.startup = Thread(target=self.startup_procedures,
daemon=True,
name='Authentication GUI').start()
# self.startup_procedures()
self.auth = API()
self.updater = Updater()
database.updater_finished = True
# self.update = Thread(target=Updater, daemon=True, name='Updater')
# self.update.start()
# self.update.join()
# sys.exit()
def startup_procedures(self, key=None):
self.auth_win = Tk()
self.auth_win.geometry("375x90")
self.auth_win.title(f"Firestone Bot v{current_version}")
self.auth_win.protocol("WM_DELETE_WINDOW", self.on_closing)
self.status_text = Label(self.auth_win,
text=database.launch_text.upper())
self.status_text.grid(column=0, row=0, padx=15, pady=5)
self.auth_win.grid_columnconfigure(0, weight=1)
rootWidth = self.auth_win.winfo_reqwidth()
rootHeight = self.auth_win.winfo_reqheight()
# Gets both half the screen width/height and window width/height
positionRight = int(self.auth_win.winfo_screenwidth() / 2 -
rootWidth / 2)
positionDown = int(self.auth_win.winfo_screenheight() / 2 -
rootHeight / 2)
self.auth_win.geometry("+{}+{}".format(positionRight, positionDown))
self.auth_win.resizable(0, 0)
# self.auth_win.attributes("-topmost", True)
self.progress = Progressbar(self.auth_win,
orient=HORIZONTAL,
length=300,
mode='determinate')
self.progress.grid(column=0, row=1, padx=15, pady=10)
# self.key_entry = Entry(self.auth_win)
# self.key_entry.grid(column=0, row=1, padx=15, pady=10)
# self.key_entry.grid_remove()
# self.okay_button = Button(self.auth_win, text='SUBMIT', command=self.submit_key)
# self.okay_button.grid(column=0, row=2, padx=15, pady=10, sticky='EW')
Thread(target=self.progress_updates,
daemon=True,
name='Progress Updater').start()
# self.auth_win.update_idletasks()
self.auth_win.update()
self.auth_win.mainloop()
def progress_updates(self):
while self.progress['value'] < 100 and database.launch_running:
# print('progress updater is running')
self.progress['value'] = database.launch_progress
self.status_text.config(text=database.launch_text.upper())
if database.updater_finished:
self.auth_win.withdraw()
self.auth_win.destroy()
sys.exit()
def submit_key(self):
pass
def on_closing(self):
database.launch_running = False
sys.exit()
class Collation:
def __init__(self, collation_tab, main_dir, root, my_os):
self.my_os = my_os
self.main_dir = main_dir
self.reg_font = ('Times', '12')
self.cx_frame = LabelFrame(collation_tab,
text='Collation Settings',
font=self.reg_font)
self.cx_frame.pack(fill=BOTH, expand=1)
self.total_wits = 0
Grid.rowconfigure(self.cx_frame, 0, weight=1)
Grid.rowconfigure(self.cx_frame, 1, weight=1)
Grid.rowconfigure(self.cx_frame, 2, weight=1)
Grid.rowconfigure(self.cx_frame, 3, weight=1)
Grid.rowconfigure(self.cx_frame, 4, weight=1)
Grid.rowconfigure(self.cx_frame, 5, weight=1)
# column 0
Grid.columnconfigure(self.cx_frame, 0, weight=1)
# row 0
self.add_wit_button = Button(self.cx_frame,
text='Add Witness',
font=self.reg_font,
width=20,
command=self.add_wit)
self.add_wit_button.grid(row=0, column=0, padx=20, pady=10)
# row 1
self.add_wit_entry = Entry(self.cx_frame, font=self.reg_font, width=22)
self.add_wit_entry.grid(row=1, column=0, pady=10, padx=20)
self.add_wit_entry.bind('<Return>', self.add_wit_on_enter)
# row 3
self.total_wits_label = Label(self.cx_frame,
font=self.reg_font,
width=20)
self.total_wits_label.grid(row=3, column=0, pady=20, padx=20)
# row 4
self.remove_wit_button = Button(self.cx_frame,
text='Remove Selected',
font=self.reg_font,
width=20,
command=self.get_wits_to_remove)
self.remove_wit_button.grid(row=4, column=0, pady=20, padx=20)
# row 5
self.launch_ce_button = Button(self.cx_frame,
text='Launch Collation Editor',
font=self.reg_font,
command=self.launch_ce)
self.launch_ce_button.grid(row=5,
column=0,
columnspan=3,
sticky=EW,
pady=20,
padx=20)
# column 1
Grid.columnconfigure(self.cx_frame, 1, weight=1)
# row 0
self.listbox_frame = Frame(self.cx_frame)
self.listbox_frame.grid(row=0, rowspan=5, column=1, sticky=NS, padx=20)
self.wit_listbox = Listbox(self.listbox_frame,
width=30,
selectmode=EXTENDED)
self.wit_listbox.pack(side=LEFT, fill=BOTH)
self.wit_scrollbar = Scrollbar(self.listbox_frame)
self.wit_listbox.config(yscrollcommand=self.wit_scrollbar.set)
self.wit_scrollbar.pack(side=RIGHT, fill=Y)
self.wit_scrollbar.config(command=self.wit_listbox.yview)
# column 2
Grid.columnconfigure(self.cx_frame, 2, weight=1)
self.basetext_label = Label(self.cx_frame,
text='Current Basetext:',
font=self.reg_font,
width=20)
self.basetext_label.grid(row=0, column=2, pady=20, padx=20)
self.basetext_current = Label(self.cx_frame,
text='------',
font=self.reg_font,
width=20)
self.basetext_current.grid(row=1, column=2)
self.change_basetext_button = Button(self.cx_frame,
text='Change Basetext',
font=self.reg_font,
width=20,
command=self.change_basetext)
self.change_basetext_button.grid(row=3, column=2, pady=20, padx=20)
self.basetext_entry = Entry(self.cx_frame,
font=self.reg_font,
width=22)
self.basetext_entry.grid(row=4, column=2, padx=20, pady=20)
self.basetext_entry.bind('<Return>', self.change_basetext_on_enter)
self.load_wit_listbox()
def load_wit_listbox(self):
with open(f'{self.main_dir}/py/settings.json', 'r') as settings_file:
self.settings_file = json.load(settings_file)
pass
self.ce_path = self.settings_file['CE_path']
self.config_path = f'{self.ce_path}/collation/data/project/default/config.json'
try:
with open(self.config_path, 'r') as config_file:
config_file = json.load(config_file)
pass
self.wit_listbox.delete(0, END)
for wit in config_file["witnesses"]:
self.wit_listbox.insert(END, wit)
self.total_wits = self.wit_listbox.size()
self.total_wits_label.config(
text=f'Total Witnesses: {self.total_wits}')
self.basetext_current.config(text=config_file['base_text'])
except:
self.wit_listbox.insert(END, 'Failed to load; set CE path')
def add_wit(self):
if self.add_wit_entry.get() == "":
messagebox.showinfo("Ruh-roh", "Witness entry cannot be blank")
else:
new_wit = self.add_wit_entry.get()
try:
with open(
f'{self.ce_path}/collation/data/project/default/config.json',
"r") as file:
config_file = json.load(file)
pass
config_file['witnesses'].append(new_wit)
with open(
f'{self.ce_path}/collation/data/project/default/config.json',
'w') as new_config:
json.dump(config_file, new_config, indent=4)
pass
with open(
f'{self.ce_path}/collation/data/project/default/config.json',
"r") as file:
config_file = json.load(file)
pass
self.wit_listbox.delete(0, END)
for wit in config_file["witnesses"]:
self.wit_listbox.insert(END, wit)
except:
messagebox.showinfo(
'Oops', 'Could not find the collation \
configuration file. \nMake sure that the Collation Editor directory is set\n\
by clicking "Settings"')
def get_wits_to_remove(self):
wits_to_remove = []
wit_indices = self.wit_listbox.curselection()
if wit_indices == ():
pass
else:
for index in wit_indices:
wits_to_remove.append(self.wit_listbox.get(index))
if wits_to_remove == ['Failed to load; set CE path']:
pass
else:
self.remove_wits(wits_to_remove)
def remove_wits(self, wits_to_remove):
with open(self.config_path, 'r') as settings_file:
settings_file = json.load(settings_file)
pass
for wit in wits_to_remove:
settings_file['witnesses'].remove(wit)
with open(self.config_path, 'w') as file:
json.dump(settings_file, file, indent=4)
pass
self.load_wit_listbox()
def change_basetext(self):
if self.wit_listbox.get(0) == 'Failed to load; set CE path':
messagebox.showerror('Uh-oh',
message='Failed to load;\
set CE path by clicking on the "Options" menu.')
elif self.basetext_entry.get() == '':
messagebox.showinfo(
'Forgetting something?',
message='Type in the basetext siglum under the\n\
"Change Basetext" button.')
else:
with open(self.config_path, 'r') as settings_file:
settings_file = json.load(settings_file)
pass
settings_file['base_text'] = self.basetext_entry.get()
with open(self.config_path, 'w') as file:
json.dump(settings_file, file, indent=4)
self.basetext_current.config(text=settings_file["base_text"])
def launch_ce(self):
if self.wit_listbox.get(0) == 'Failed to load; set CE path':
messagebox.showerror('Uh-oh',
message='Failed to load;\
set CE path by clicking on the "Options" menu.')
os.chdir(self.ce_path)
if self.my_os == "Windows":
os.startfile("startup.bat")
try:
subprocess.call(
'start firefox "http://localhost:8080/collation"',
shell=True)
except:
messagebox.showerror(
'Issue',
message='Could not open Firefox--it is installed?\n\
It is the recommended browser for the Collation Editor.\n\
If Firefox is installed, then you might be able to\n\
open the Collation Editor by manually going to\n\
http://localhost:8080/collation')
elif self.my_os != "Windows":
os.startfile("startup.sh")
try:
subprocess.call(
'start firefox "http://localhost:8080/collation"',
shell=True)
except:
messagebox.showerror(
'Issue',
message='Could not open Firefox--it is installed?\n\
It is the recommended browser for the Collation Editor.\n\
If Firefox is installed, then you might be able to\n\
open the Collation Editor by manually going to\n\
http://localhost:8080/collation')
os.chdir(self.main_dir)
def add_wit_on_enter(self, event):
self.add_wit()
def change_basetext_on_enter(self, event):
self.change_basetext()
class EvernoteDumpFrame(Frame):
def __init__(self, master: EvernoteDump):
super().__init__(master)
self.master = master
self.pack(fill="both")
self.open_button = Button(
text='Choose Evernote Export File(s) (.enex)',
command=self.open_file_picker)
self.open_button.pack(fill='x', padx=10, pady=10)
self.export_files_list = Listbox(height=4)
self.export_files_list.insert(0, "No files selected.")
self.export_files_list.pack(fill='x', padx=10, pady=10)
self.preserve = IntVar()
self.preserve_names = Checkbutton(
text='Preserve file names for attachments if found',
variable=self.preserve,
command=self.toggle_preserve)
self.preserve_names.pack(anchor='nw', padx=10, pady=10)
self.export_dir_button = Button(text='Choose Export Directory',
command=self.open_directory_picker)
self.export_dir_button.pack(fill='x', padx=10, pady=10)
self.export_dir_label = Label(text="Please select an export directory")
self.export_dir_label.pack(fill='x', padx=10, pady=10)
self.run_button = Button(text='Start Evernote Conversion to Markdown',
state=DISABLED,
command=self.run)
self.run_button.pack(fill='x', padx=10, pady=10)
self.log_box = scrolledtext.ScrolledText()
self.log_box.pack(fill='x', padx=10, pady=10)
def check(self):
if len(self.master.settings.files
) > 0 and self.master.settings.export_path != '':
self.run_button.config(state=NORMAL)
else:
self.run_button.config(state=DISABLED)
def open_directory_picker(self):
self.master.settings.path = filedialog.askdirectory()
self.export_dir_label.config(text=f"{self.master.settings.path}")
self.check()
def open_file_picker(self):
self.master.settings.enex = filedialog.askopenfilenames()
self.export_files_list.delete(0, END)
for file in self.master.settings.enex:
self.export_files_list.insert(0, file)
self.check()
def run(self):
self.run_button.config(state=DISABLED)
def print_callback(print_text: str):
self.log_box.insert(END, f"{print_text}\n")
self.log_box.see(END)
threading.Thread(target=run_parse,
args=(self.master.settings, print_callback)).start()
def toggle_preserve(self):
self.master.settings.p = bool(self.preserve)
def callback(event):
with cond:
print("OK")
cond.notifyAll()
def callback2(event):
with cond:
print("OK")
c1 = threading.Thread(name='c1',
target=generateNumber,
args=(
lbl,
cond,
))
c1.start()
lbl = Label(root, text="", width=30)
lbl.grid(row=1, column=0)
lbl.config(text='change the value')
btn = Button(root, text="OK")
btn.grid(row=2, column=0)
btn.bind("<Button-1>", callback)
btn2 = Button(root, text="Start")
btn2.grid(row=3, column=0)
btn2.bind("<Button-1>", callback2)
root.mainloop()
# generateNumber(t)
class _Property(Frame):
def __init__(self, _master_: Frame, _name_: str, _value_, _type_: str):
super().__init__(master=_master_,
width=700,
height=35,
bg='darkgray')
self.master = _master_
self._name = lang[_name_]
self._value = 'gen_true' if _value_ is True else 'gen_false' if _value_ is False else _value_
self._type = _type_
self._container: Optional[Frame] = None
self._name_label: Optional[Label] = None
self._value_field: Optional[Label, Frame] = None
self._value_list: List[Item] = list()
self._input_field: Optional[Widget] = None
self._change: Optional[Button] = None
self._list_end = 0
self._items = list()
pass
def build(self, _position_):
self.place(in_=self.master, x=20, y=_position_ + 25)
self.update()
self._container = Frame(master=self,
bg='darkgray',
borderwidth=1,
relief="solid",
width=600)
self._name_label = Label(master=self.master,
text=self._name,
bg='darkgray')
if self._type.startswith(('view', 'text', 'int', 'bool')):
if self._value in lang:
self._value: Union[str, Code] = lang[self._value]
pass
self._value_field = Label(master=self,
text=self._value,
bg='darkgray',
wraplength=565,
justify=LEFT)
if self._type.endswith('_'):
subs = self._type.split('_', 1)
self._change = Button(master=self, text=lang['mp_change'])
self._change.place(in_=self,
anchor=E,
rely=0.5,
relx=1,
width=80)
pass
elif self._type.startswith(('list', 'single')):
self._value_field = Frame(master=self,
bg='darkgray',
width=565,
height=25)
self._value_field.place(in_=self, y=7, x=13)
self._value_field.update()
for code in self._value:
self._items.append(Item(self._value_field, code))
pos_x = 0
pos_y = 0
for item in self._items:
item.place(in_=self._value_field, x=pos_x, y=pos_y)
item.update()
pos_x += item.winfo_width() + 5
if pos_x > self._value_field.winfo_width() - 20:
item.place_forget()
pos_y += 25
pos_x = 0
item.place(in_=self._value_field, x=pos_x, y=pos_y)
pos_x += item.winfo_width() + 5
pass
pass
self._value_field.config(height=25 + pos_y)
# _position_ += pos_y
self._value_field.place_forget()
pass
elif self._type.startswith('select'):
text = lang[self._value] if self._value is not None else ''
self._value_field = Label(master=self,
text=text,
bg='darkgray',
wraplength=365)
pass
if not self._type.startswith('view'):
self._change = Button(master=self, text=lang['mp_change'])
self._change.place(in_=self,
anchor=E,
rely=0.5,
relx=1,
width=80)
pass
self._container.place(in_=self, relheight=1)
self._name_label.place(in_=self, y=-15, x=5)
self._value_field.place(in_=self, y=7, x=13)
self._value_field.update()
height = self._value_field.winfo_height() + 14
self.config(height=height)
return height + 25 + _position_
def bind_button(self, _code_: Code, _value_):
def create_popup(_event_):
if self._type.startswith('text'):
TkEditorTextPopup(_code_,
self._type[self._type.find('_') + 1:],
_value_)
pass
elif self._type.startswith('int'):
TkEditorIntPopup(_code_,
self._type[self._type.find('_') + 1:],
_value_)
pass
elif self._type.startswith('bool'):
TkEditorBoolPopup(_code_,
self._type[self._type.find('_') + 1:],
_value_)
pass
elif self._type.startswith('single'):
TkEditorSinglePopup(_code_,
self._type[self._type.find('_') + 1:],
_value_)
pass
elif self._type.startswith('list'):
TkEditorMultiPopup(_code_,
self._type[self._type.find('_') + 1:],
_value_)
pass
elif self._type.startswith('select'):
TkEditorSelectPopup(_code_,
self._type[self._type.find('_') + 1:],
_value_, self._name)
pass
pass
if self._change is not None:
self._change.bind("<Button-1>", create_popup)
pass
pass
def resize(self, _width_: int):
pass
pass
def ask_config(self, root):
root.update()
self.conf_window = Toplevel()
w = root.winfo_width()
h = root.winfo_height()
x = root.winfo_x()
y = root.winfo_y()
x = x + (w / 4)
y = y + (h / 4)
self.conf_window.geometry('+%d+%d' % (x, y))
self.conf_window.wm_title('Configuration')
self.conf_window.config(bg='black')
frame = Frame(self.conf_window, bg='black')
frame.pack(fill=BOTH, expand=True)
Frame(frame, width=1, bd=1, relief=SUNKEN)
Frame(frame, width=1, bd=1, relief=SUNKEN)
fr_config = Frame(frame,
bg='black',
borderwidth=1,
highlightbackground='white',
relief=FLAT)
fr_config.grid(row=0, column=0, padx=5, pady=5, sticky=W + E)
fr_conf = Frame(frame,
bg='black',
borderwidth=1,
highlightcolor='gray40',
bd=0,
highlightbackground='gray40',
highlightthickness=1,
relief=SOLID)
fr_conf.grid(row=1, column=0, rowspan=2, padx=5, pady=5)
fr_bt = Frame(frame,
bg='black',
borderwidth=1,
highlightbackground='white')
fr_bt.grid(row=0, column=1, rowspan=2, padx=1, pady=5, sticky=N)
bt_apply = Button(fr_bt,
text='Apply',
width=6,
command=self.apply_conf)
bt_apply.grid(row=1, column=1, sticky=N + E, pady=2, padx=1)
bt_apply.config(relief=FLAT,
bg='gray20',
fg='white',
borderwidth=0,
highlightthickness=0)
bt_cancel = Button(fr_bt,
text='Cancel',
width=6,
command=self.close_window)
bt_cancel.grid(row=2, column=1, sticky=S + E, pady=2, padx=1)
bt_cancel.config(relief=FLAT,
bg='gray20',
fg='white',
borderwidth=0,
highlightthickness=0)
conf_values = self.get_values()
image = Image.open(conf_values['icon'])
image = image.resize((50, 50), Image.ANTIALIAS)
image = ImageTk.PhotoImage(image)
lbl_img = Label(fr_config, image=image)
lbl_img.grid(row=0, column=0, rowspan=2, padx=5, pady=5, sticky=W)
lbl_username = Label(fr_config,
text=conf_values['username'],
bg='black',
fg='red')
lbl_username.grid(row=0, column=1, padx=5, pady=5, sticky=W)
server_port = conf_values['server'] + ':' + conf_values['port']
lbl_server = Label(fr_config, text=server_port, bg='black', fg='red')
lbl_server.grid(row=1, column=1, padx=5, pady=5)
lbl_server = Label(fr_conf, text='Server:', fg='white', bg='black')
lbl_server.grid(row=1, column=0, padx=5, pady=5, sticky=E)
self.server = StringVar()
txt_server = Entry(fr_conf, textvariable=self.server)
self.server.set(conf_values['server'])
txt_server.grid(row=1, column=1, padx=5)
txt_server.config(bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0,
insertbackground='white')
lbl_port = Label(fr_conf, text='Port:', fg='white', bg='black')
lbl_port.grid(row=2, column=0, padx=5, pady=5, sticky=E)
self.port = StringVar()
txt_port = Entry(fr_conf, width=5, textvariable=self.port)
self.port.set(conf_values['port'])
txt_port.grid(row=2, column=1, padx=5, sticky=W)
txt_port.config(bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0,
insertbackground='white')
lbl_username = Label(fr_conf,
text='Default username:'******'white',
bg='black')
lbl_username.grid(row=3, column=0, padx=5, pady=5, sticky=E)
self.username = StringVar()
txt_user = Entry(fr_conf, textvariable=self.username)
self.username.set(conf_values['username'])
txt_user.grid(row=3, column=1, padx=5)
txt_user.config(bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0,
insertbackground='white')
lbl_image = Label(fr_conf, text='Image:', bg='black')
lbl_image.grid(row=4, column=0, padx=5, pady=5, sticky=E)
lbl_image.config(bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0)
bt_choose = Button(fr_conf,
text='Choose',
width=6,
height=1,
command=self.change_icon)
bt_choose.grid(row=4, column=1, sticky=W, pady=2, padx=5)
bt_choose.config(relief=FLAT,
bg='gray20',
fg='white',
borderwidth=0,
highlightthickness=0)
self.conf_window.resizable(False, False)
self.conf_window.transient(root)
self.conf_window.grab_set()
self.conf_window.focus_set()
root.wait_window(self.conf_window)
return (self.get_values())
class MainWindow(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.pack(fill=BOTH, expand=1)
#basic settings
self.basicSettings = GuiBasicSettings(self); self.basicSettings.pack()
self.basicSettings.setCallback( lambda: _thread.start_new_thread(self.generateFile, ()) )
#separatr
self._generatorSepFrm = Frame(self, bg="#000000", height=2)
self._generatorSepFrm.pack(fill=X, expand=1, pady=20)
# generator description
genDescStr = "Here you choose how the Binary file is generated\n"
genDescStr = genDescStr + " * Random: creates an random image\n"
genDescStr = genDescStr + " * Counter: create a pattern like 112233 or 111122223333"
self._generatorDescLbl = Label(self, text=genDescStr, justify=LEFT)
self._generatorDescLbl.pack(ipadx=10)
#generator select frames
self._generatorSelectFrm = Frame(self)
self._generatorSelectFrm.pack(pady=10)
#generators
self._generatorFrm = Frame(self, relief=SUNKEN, bd=2)
self._generatorFrm.pack(fill=X, expand=1, padx=20)
self.generatorFrames = ( GuiGenerateRandom(self._generatorFrm),
GuiGenerateCount(self._generatorFrm)
)
for i in self.generatorFrames:
i.pack_forget()
#generator select frames (self.generatorFrames)
self._generatorSelect = GuiGeneratorSelect(self._generatorSelectFrm, self.generatorFrames)
#error output
self._infoFrm = Frame(self, relief=SUNKEN, bd=2)
self._infoFrm.pack(fill=X, expand=1, pady=10)
self._infoLbl = Label(self, bg="#000000", text="nothing to do", fg="#00FF00")
self._infoLbl.pack(fill=X, expand=1, padx=0)
self._infoColorNormal = "#00FF00"
self._infoColorErr = "#FF0000"
def generateFile(self):
print("generate")
#firstly disable start button
self.basicSettings.enableButton(False)
fileName = self.basicSettings.getFileName()
fileSize = 0
blockSize = 512
currGeneratorGui = self._generatorSelect.getCurrGeneratorGui()
print(type(currGeneratorGui))
currGenerator = currGeneratorGui.getGeneratorFunction()
specSettings = currGeneratorGui.getSettings()
#cast filesize
try:
fileSize = self.basicSettings.getFileSize()
if fileSize < 1:
raise Exception("")
except:
self._infoLbl.config(fg=self._infoColorErr, text="file size is invalid")
return
#open file
try:
currFile = open(fileName, "wb")
except:
self._infoLbl.config(fg=self._infoColorErr, text="cannot create file")
return
def progress(aFileSize, aWritten, aText):
progr = str(int((aWritten/aFileSize)*100))+"%"
return aText+": "+progr
try:
buff = b""
bytesWritten = 0
for i in currGenerator(fileSize, specSettings):
buff += i
bytesWritten += 1
if len(buff) > blockSize:
currFile.write(buff)
buff = b""
self._infoLbl.config(fg=self._infoColorNormal, text=progress(fileSize, bytesWritten, fileName))
if len(buff) > 0:
currFile.write(buff)
buff = None
self._infoLbl.config(fg=self._infoColorNormal, text=progress(fileSize, bytesWritten, fileName))
except Exception as exc:
raise
finally:
currFile.close()
self.basicSettings.enableButton(True) #Enable Button
class Tab(ABC):
def __init__(self, view, tab_control):
self.view = view
self.bandas_estandar_repository = RepositoryProvider.provide_bandas_estandar_repository(
)
self.tab_frame = tab_control.agregar_tab(self, self.titulo_tab)
self.construir_tab()
@abstractmethod
def obtener_bandas(self):
pass
def construir_tab(self):
self.construir_frame_titulo()
self.construir_frame_grafica()
self.construir_frame_medicion()
def construir_frame_titulo(self):
self.frame_titulo_grafica = Frame(self.tab_frame)
self.frame_titulo_grafica.config(width=400,
borderwidth=2,
relief="groove")
self.frame_titulo_grafica.grid(row=0,
column=0,
sticky="nsew",
padx=10,
pady=(15, 0))
self.label_titulo_grafica = Label(self.frame_titulo_grafica)
self.label_titulo_grafica.config(
text="Nivel de respuesta impulsional - Curva de decaimiento",
bg="#0c005a")
self.label_titulo_grafica.pack(fill="both", expand="True")
def construir_frame_grafica(self):
self.frame_grafica = Frame(self.tab_frame)
self.frame_grafica.grid(row=1, column=0, padx=10, pady=10)
self.frame_label_grafica = Frame(self.frame_grafica)
self.frame_label_grafica.config(width=600, height=400)
self.frame_label_grafica.pack_propagate(False)
self.frame_label_grafica.grid(row=0, column=0)
self.label_grafica = Label(self.frame_label_grafica)
self.label_grafica.config(borderwidth=2, relief="groove", bg="#5893d4")
self.label_grafica.pack(expand="True", fill="both")
self.frame_toolbar = Frame(self.frame_grafica)
self.frame_toolbar.config(width=400, height=40, borderwidth=2)
self.frame_toolbar.pack_propagate(False)
self.frame_toolbar.grid(row=1, column=0, sticky="nsew")
self.construir_plot()
def construir_plot(self):
self.figura = Figure(figsize=(6, 4), dpi=100)
self.figura.patch.set_facecolor("#becbff")
self.sistema_ejes = self.figura.add_subplot(1, 1, 1)
self.sistema_ejes.set_facecolor("#dee1ec")
self.limpiar_ejes()
self.canvas = FigureCanvasTkAgg(self.figura, master=self.label_grafica)
self.canvas.get_tk_widget().pack(side=BOTTOM, fill=BOTH, expand=True)
toolbar = NavigationToolbar2Tk(self.canvas, self.frame_toolbar)
toolbar.update()
def limpiar_ejes(self):
self.sistema_ejes.cla()
self.sistema_ejes.set_xlabel('Tiempo (s)')
self.sistema_ejes.set_ylabel('Nivel (dB)')
self.sistema_ejes.set_xlim(left=0, auto=True)
self.sistema_ejes.set_ylim(bottom=-120, top=0, auto=True)
def construir_frame_medicion(self):
self.frame_medicion = Frame(self.tab_frame)
self.frame_medicion.grid(row=0, column=1, rowspan=2, sticky="nsew")
self.construir_frame_bandas()
def construir_frame_bandas(self):
self.construir_seleccion_banda()
self.construir_frame_rts()
def construir_seleccion_banda(self):
self.frame_titulo_bandas = Label(self.frame_medicion)
self.frame_titulo_bandas.config(borderwidth=2, relief="groove")
self.frame_titulo_bandas.grid(row=0,
column=0,
sticky="nsew",
padx=10,
pady=(15, 0))
self.label_titulo_bandas_octava = Label(self.frame_titulo_bandas)
self.label_titulo_bandas_octava.config(text=self.titulo_bandas_text,
bg="#0c005a")
self.label_titulo_bandas_octava.pack(ipadx=10,
expand="True",
fill="both")
self.frame_medicion_bandas = Frame(self.frame_medicion)
self.frame_medicion_bandas.grid(row=1,
column=0,
sticky="nsew",
padx=10,
pady=(20, 0))
bandas_estandar = self.obtener_bandas()
self.banda_seleccionada = StringVar()
self.banda_seleccionada.set(bandas_estandar[0])
self.combobox_banda = OptionMenu(self.frame_medicion_bandas,
self.banda_seleccionada,
*bandas_estandar)
self.combobox_banda.config(relief="groove",
borderwidth=0,
bg="#5893d4",
activebackground="#0060ca",
width=20)
self.combobox_banda['menu'].config(bg="#5893d4",
activebackground="#0060ca")
self.combobox_banda.grid(row=0, column=0, padx=10)
self.ponderacion_A_checked = BooleanVar(False)
self.checkbutton_ponderacion_A = Checkbutton(
self.frame_medicion_bandas)
self.checkbutton_ponderacion_A.config(
text="Ponderación A",
variable=self.ponderacion_A_checked,
selectcolor="#5e0606")
self.checkbutton_ponderacion_A.grid(row=0, column=1, padx=20)
self.boton_calcular = Button(self.frame_medicion_bandas)
self.boton_calcular.config(text="Calcular",
command=self.view.on_calcular,
bg="#5e0606",
width=20)
self.boton_calcular.grid(row=0, column=2, padx=10)
def construir_frame_rts(self):
self.frame_rts = Frame(self.frame_medicion)
self.frame_rts.config(borderwidth=2, relief='ridge')
self.frame_rts.grid(row=4, column=0, padx=10, pady=(15, 0))
self.frame_titulo_rts = Label(self.frame_rts)
self.frame_titulo_rts.config(borderwidth=2, relief="groove")
self.frame_titulo_rts.grid(row=0,
column=0,
sticky="nsew",
padx=10,
pady=10,
columnspan=2)
self.label_titulo_rts = Label(self.frame_titulo_rts)
self.label_titulo_rts.config(text="Tiempos de reverberación",
bg="#0c005a")
self.label_titulo_rts.pack(ipadx=10, expand="True", fill="both")
self.frame_titulo_linealidad = Label(self.frame_rts)
self.frame_titulo_linealidad.config(borderwidth=2, relief="groove")
self.frame_titulo_linealidad.grid(row=0,
column=2,
sticky="nsew",
padx=10,
pady=10,
columnspan=4)
self.label_titulo_linealidad = Label(self.frame_titulo_linealidad)
self.label_titulo_linealidad.config(text="Parámetros de linealidad",
bg="#0c005a")
self.label_titulo_linealidad.pack(ipadx=10, expand="True", fill="both")
self.construir_frame_edt()
self.construir_frame_t20()
self.construir_frame_t30()
self.construir_frame_curvatura()
self.construir_frame_progressbar()
def construir_frame_edt(self):
self.frame_edt = Frame(self.frame_rts)
self.frame_edt.grid(row=1, column=0, pady=(0, 10), columnspan=2)
self.label_edt = Label(self.frame_edt)
self.label_edt.config(text="EDT",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_edt.grid(row=0, column=0, padx=(0, 10), pady=10)
self.edt_var = StringVar()
self.label_res_edt = Label(self.frame_edt)
self.label_res_edt.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
textvariable=self.edt_var,
fg="black")
self.label_res_edt.grid(row=0, column=1, padx=(10, 0), pady=10)
self.frame_linealidad_edt = Frame(self.frame_rts)
self.frame_linealidad_edt.grid(row=1,
column=2,
pady=(0, 10),
columnspan=4)
self.label_r_edt = Label(self.frame_linealidad_edt)
self.label_r_edt.config(text="r",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_r_edt.grid(row=0, column=0, padx=10, pady=10)
self.r_edt_var = StringVar()
self.label_res_r_edt = Label(self.frame_linealidad_edt)
self.label_res_r_edt.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
textvariable=self.r_edt_var,
fg="black")
self.label_res_r_edt.grid(row=0, column=1, padx=10, pady=10)
self.label_xi_edt = Label(self.frame_linealidad_edt)
self.label_xi_edt.config(text="ξ",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_xi_edt.grid(row=0, column=2, padx=10, pady=10)
self.xi_edt_var = StringVar()
self.label_res_xi_edt = Label(self.frame_linealidad_edt)
self.label_res_xi_edt.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
fg="black",
textvariable=self.xi_edt_var)
self.label_res_xi_edt.grid(row=0, column=3, padx=10, pady=10)
def construir_frame_t20(self):
self.frame_t20 = Frame(self.frame_rts)
self.frame_t20.grid(row=2, column=0, pady=(0, 10), columnspan=2)
self.label_t20 = Label(self.frame_t20)
self.label_t20.config(text="T20",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_t20.grid(row=0, column=0, padx=(0, 10), pady=10, sticky='w')
self.t20_var = StringVar()
self.label_res_t20 = Label(self.frame_t20)
self.label_res_t20.config(relief="sunken",
borderwidth=2,
bg="#becbff",
width=10,
textvariable=self.t20_var,
fg='black')
self.label_res_t20.grid(row=0,
column=1,
padx=(10, 0),
pady=10,
sticky='e')
self.frame_linealidad_t20 = Frame(self.frame_rts)
self.frame_linealidad_t20.grid(row=2,
column=2,
pady=(0, 10),
columnspan=4)
self.label_r_t20 = Label(self.frame_linealidad_t20)
self.label_r_t20.config(text="r",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_r_t20.grid(row=0, column=2, padx=10, pady=10)
self.r_t20_var = StringVar()
self.label_res_r_t20 = Label(self.frame_linealidad_t20)
self.label_res_r_t20.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
textvariable=self.r_t20_var,
fg='black')
self.label_res_r_t20.grid(row=0, column=3, padx=10, pady=10)
self.label_xi_t20 = Label(self.frame_linealidad_t20)
self.label_xi_t20.config(text="ξ",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_xi_t20.grid(row=0, column=4, padx=10, pady=10)
self.xi_t20_var = StringVar()
self.label_res_xi_t20 = Label(self.frame_linealidad_t20)
self.label_res_xi_t20.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
fg='black',
textvariable=self.xi_t20_var)
self.label_res_xi_t20.grid(row=0, column=5, padx=10, pady=10)
def construir_frame_t30(self):
self.frame_t30 = Frame(self.frame_rts)
self.frame_t30.grid(row=3, column=0, pady=(0, 10), columnspan=2)
self.label_t30 = Label(self.frame_t30)
self.label_t30.config(text="T30",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_t30.grid(row=0, column=0, padx=(0, 10), pady=10, sticky='w')
self.t30_var = StringVar()
self.label_res_t30 = Label(self.frame_t30)
self.label_res_t30.config(relief="sunken",
borderwidth=2,
bg="#becbff",
width=10,
textvariable=self.t30_var,
fg='black')
self.label_res_t30.grid(row=0,
column=1,
padx=(10, 0),
pady=10,
sticky='e')
self.frame_linealidad_t30 = Frame(self.frame_rts)
self.frame_linealidad_t30.grid(row=3,
column=2,
pady=(0, 10),
columnspan=4)
self.label_r_t30 = Label(self.frame_linealidad_t30)
self.label_r_t30.config(text="r",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_r_t30.grid(row=0, column=2, padx=10, pady=10)
self.r_t30_var = StringVar()
self.label_res_r_t30 = Label(self.frame_linealidad_t30)
self.label_res_r_t30.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
textvariable=self.r_t30_var,
fg='black')
self.label_res_r_t30.grid(row=0, column=3, padx=10, pady=10)
self.label_xi_t30 = Label(self.frame_linealidad_t30)
self.label_xi_t30.config(text="ξ",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_xi_t30.grid(row=0, column=4, padx=10, pady=10)
self.xi_t30_var = StringVar()
self.label_res_xi_t30 = Label(self.frame_linealidad_t30)
self.label_res_xi_t30.config(relief="sunken",
bg="#becbff",
borderwidth=2,
width=10,
fg='black',
textvariable=self.xi_t30_var)
self.label_res_xi_t30.grid(row=0, column=5, padx=10, pady=10)
def construir_frame_curvatura(self):
self.frame_curvatura = Frame(self.frame_rts)
self.frame_curvatura.grid(row=4,
column=2,
pady=(0, 10),
columnspan=4,
sticky='e')
self.label_curvatura = Label(self.frame_curvatura)
self.label_curvatura.config(text="C",
bg="#5893d4",
borderwidth=2,
relief="groove",
width=4)
self.label_curvatura.grid(row=0,
column=0,
padx=(0, 10),
pady=10,
sticky='w')
self.curvatura_var = StringVar()
self.label_res_curvatura = Label(self.frame_curvatura)
self.label_res_curvatura.config(relief="sunken",
borderwidth=2,
bg="#becbff",
width=10,
textvariable=self.curvatura_var,
fg='black')
self.label_res_curvatura.grid(row=0, column=1, padx=10, pady=10)
def get_frecuencia_central_banda_seleccionada(self):
return float(self.banda_seleccionada.get())
def get_tipo(self):
return self.tipo
def verificar_ponderacion_A(self):
return self.ponderacion_A_checked.get()
def desactivar(self):
self.combobox_banda.config(state=DISABLED)
self.checkbutton_ponderacion_A.config(state=DISABLED)
self.boton_calcular.config(state=DISABLED)
def activar(self):
self.combobox_banda.config(state=NORMAL)
self.checkbutton_ponderacion_A.config(state=NORMAL)
self.boton_calcular.config(state=NORMAL)
def graficar(self, nivel_respuesta_impulsional, curva_decaimiento):
dominio_temporal_ri = nivel_respuesta_impulsional.get_dominio_temporal(
)
valores_ri = nivel_respuesta_impulsional.get_valores()
dominio_temporal_cd = curva_decaimiento.get_dominio_temporal()
valores_cd = curva_decaimiento.get_valores()
self.limpiar_ejes()
self.sistema_ejes.plot(dominio_temporal_ri,
valores_ri,
color='#0000ff',
linewidth=0.5,
label='Nivel respuesta impulsional')
self.sistema_ejes.plot(dominio_temporal_cd,
valores_cd,
color="#ff0000",
linewidth=1,
label='Curva de decaimiento')
self.sistema_ejes.legend()
self.canvas.draw()
def mostrar_tiempos_de_reverberacion(self, edt, t20, t30):
self.edt_var.set(str(round(edt, 4)) + "seg")
self.t20_var.set(str(round(t20, 4)) + "seg")
self.t30_var.set(str(round(t30, 4)) + "seg")
def mostrar_parametros_de_linealidad(self, edt, t20, t30, curvatura):
self.r_edt_var.set(round(edt.get_coef_correlacion(), 4))
self.xi_edt_var.set(str(round(edt.get_xi(), 4)) + "‰")
self.r_t20_var.set(round(t20.get_coef_correlacion(), 4))
self.xi_t20_var.set(str(round(t20.get_xi(), 4)) + "‰")
self.r_t30_var.set(round(t30.get_coef_correlacion(), 4))
self.xi_t30_var.set(str(round(t30.get_xi(), 4)) + "‰")
self.curvatura_var.set(str(round(curvatura, 4)) + "%")
def construir_frame_progressbar(self):
self.pb_frame = Frame(self.frame_medicion)
self.pb_frame.config(padx=20, pady=20)
self.frame_calculando = Frame(self.pb_frame)
self.frame_calculando.grid(row=0, column=0, pady=10)
self.label_calculando = Label(self.frame_calculando)
self.label_calculando.config(text="Calculando")
self.label_calculando.pack(expand="True", fill="both")
self.progressbar = Progressbar(self.pb_frame)
self.progressbar.config(mode="indeterminate", length=250)
self.progressbar.grid(row=1, column=0, pady=10)
def activar_progressbar(self):
self.pb_frame.grid(row=5, column=0)
self.progressbar.start(10)
def desactivar_progressbar(self):
self.progressbar.stop()
self.pb_frame.grid_remove()
def redibujar_canvas(self):
self.canvas.draw()
self.canvas.get_tk_widget().pack()
def ocultar_grafica(self):
self.canvas.get_tk_widget().pack_forget()
class InitScreen:
def __init__(self, master):
self.funcs = {}
self.master = master
self.controller = InitScreenController(master)
self.master.title('parent')
self.master.geometry('640x480+200+150')
self.set_param_init()
self.frame.pack()
self.master.mainloop()
def set_param_init(self):
self.frame = Frame(width=400, height=300, bd=2)
self.frame.grid_bbox(2, 4 + default_fields_count)
self._buttons_init()
self.entrys = {}
_vcmd = self.frame.register(self._validate)
count = 0
for block_name, block in default_params.items():
Label(self.frame,
text=_convert(block_name),
background="#999",
justify=LEFT).grid(
row=count,
column=1
)
count += 1
for name, _default in block.items():
default, func = _default
Label(self.frame,
text=_convert(name),
justify=LEFT).grid(
row=count,
column=1
)
# self.entrys[_convert(name)] = ""
sv = StringVar(
value=default_params[block_name][name][0])
e = Entry(self.frame)
self.entrys[name] = sv
self.funcs[e] = func
e.config(validate='key',
vcmd=(_vcmd, "%P", "%W"),
textvariable=sv)
e.grid(row=count,
column=2)
count += 1
Label(self.frame,
text="Количество существ:",
justify=LEFT).grid(
row=count,
column=1
)
self.creature_count = \
Label(self.frame,
text='0',
justify=LEFT)
self.creature_count.grid(
row=count,
column=2
)
def _buttons_init(self):
self.load_button = Button(self.frame,
text='Загрузить',
command=self.load_button_press)
self.load_button.grid(row=4 + default_fields_count,
column=1)
self.start_button = Button(self.frame,
text='Старт',
command=self.start_button_press)
self.start_button.grid(row=4 + default_fields_count,
column=2)
self.master.protocol('WM_DELETE_WINDOW',
self.exit)
def _validate(self, P, W):
e = self.frame.nametowidget(W)
func = self.funcs[e]
try:
func(P)
except ValueError:
return False
else:
return True
def _collect_params(self):
params = deepcopy(default_params)
for block in params.values():
for key in block:
func = block[key][1]
block[key] = func(self.entrys[key].get())
return params
def start_button_press(self):
params = self._collect_params()
if self.controller.model:
self.game_screen = GameScreen(self.master, params, model=self.controller.model)
else:
self.game_screen = GameScreen(self.master, params)
self.frame.forget()
def load_button_press(self):
self.controller.load_button_press()
model = self.controller.model
self.creature_count.config(text=str(len(model.creatures)))
for block in model.params.values():
for k, v in block.items():
if k == "in_layers":
v = ", ".join([str(x) for x in v])
self.entrys[k].set(v)
def exit(self):
exit()
Listbox,
Radiobutton,
Scale,
Spinbox,
Text,
Tk,
)
# Creating a new window and configurations
window = Tk()
window.title("Widget Examples")
window.minsize(width=500, height=500)
# Labels
label = Label(text="This is old text")
label.config(text="This is new text")
label.pack()
# Buttons
def action():
print("Do something")
# calls action() when pressed
button = Button(text="Click Me", command=action)
button.pack()
# Entries
entry = Entry(width=30)
# Add some text to begin with
class Tk_Nosy(object):
"""This class is the tkinter GUI object"""
# make a collection of python interpreters to choose from
pythonInterpreterCollection = None # will be PyInterpsOnSys object
# extra python interpreters can run nosetests concurrently to main window
# concurrent_versionL contains tuples = (PI, Popup)
concurrent_versionL = [] # additional running python interpreters
def __init__(self, master):
self.dirname = os.path.abspath(os.curdir)
self.initComplete = 0
self.master = master
self.x, self.y, self.w, self.h = -1, -1, -1, -1
# bind master to <Configure> in order to handle any resizing, etc.
# postpone self.master.bind("<Configure>", self.Master_Configure)
self.master.bind('<Enter>', self.bindConfigure)
self.menuBar = Menu(master, relief="raised", bd=2)
self.menuBar.add("command",
label="Change_Dir",
command=self.menu_Directory_Change_Dir)
disp_Choices = Menu(self.menuBar, tearoff=0)
self.display_test_details = StringVar()
self.display_test_details.set('N')
disp_Choices.add_checkbutton(label='Display Test Details',
variable=self.display_test_details,
onvalue='Y',
offvalue='N')
self.display_watched_files = StringVar()
self.display_watched_files.set('N')
disp_Choices.add_checkbutton(label='Show Watched Files',
variable=self.display_watched_files,
onvalue='Y',
offvalue='N')
self.menuBar.add("cascade", label="Display", menu=disp_Choices)
py_choices = Menu(self.menuBar, tearoff=0)
py_choices.add("command",
label="Change Python Version",
command=self.changePythonVersion)
py_choices.add("command",
label="Find New Python Interpreter",
command=self.findNewPythonInterpreter)
py_choices.add("command",
label="Launch Another Python Interpreter",
command=self.launchAnotherPythonInterpreter)
self.menuBar.add("cascade", label="Python", menu=py_choices)
#top_Snippet = Menu(self.menuBar, tearoff=0)
self.menuBar.add("command", label="Run", command=self.menu_Run)
self.display_test_details.trace("w", self.rerun_tests)
self.display_watched_files.trace("w", self.rerun_tests)
master.config(menu=self.menuBar)
# make a Status Bar
self.statusMessage = StringVar()
self.statusMessage.set(self.dirname)
self.statusbar = Label(self.master,
textvariable=self.statusMessage,
bd=1,
relief=SUNKEN)
self.statusbar.pack(anchor=SW, fill=X, side=BOTTOM)
self.statusbar_bg = self.statusbar.cget('bg') # save bg for restore
self.arial_12_bold_font = tkinter.font.Font(family="Arial",
size=12,
weight=tkinter.font.BOLD)
self.arial_12_font = tkinter.font.Font(family="Arial", size=12)
self.statusbar.config(font=self.arial_12_bold_font)
frame = Frame(master)
frame.pack(anchor=NE, fill=BOTH, side=TOP)
self.Pass_Fail_Button = Button(frame,
text="Pass/Fail Will Be Shown Here",
image="",
width="15",
background="green",
anchor=W,
justify=LEFT,
padx=2)
self.Pass_Fail_Button.pack(anchor=NE, fill=X, side=TOP)
self.Pass_Fail_Button.bind("<ButtonRelease-1>",
self.Pass_Fail_Button_Click)
self.master.title("tk_nosy")
self.oscillator = 1 # animates character on title
self.oscillator_B = 0 # used to return statusbar to statusbar_bg
self.lbframe = Frame(frame)
self.lbframe.pack(anchor=SE, side=LEFT, fill=BOTH, expand=1)
scrollbar = Scrollbar(self.lbframe, orient=VERTICAL)
self.Text_1 = Text(self.lbframe,
width="80",
height="24",
yscrollcommand=scrollbar.set)
scrollbar.config(command=self.Text_1.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.Text_1.pack(side=LEFT, fill=BOTH, expand=1)
self.master.resizable(1, 1) # Linux may not respect this
self.numNosyCalls = 0
self.need_to_pick_dir = 1
print('sys.argv =', sys.argv)
if len(sys.argv) > 1:
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
print("Try Dir =", sys.argv[1])
try:
dirname = os.path.abspath(sys.argv[1])
self.try_change_to_new_dir(dirname)
except Exception:
pass # let Alarm force dir selection
else:
try:
if os.path.isdir(os.path.join(self.dirname, 'tests')):
self.try_change_to_new_dir(self.dirname)
except Exception:
pass # let Alarm force dir selection
print(LICENSE)
self.defaultPyInterp = None # need to identify default python interpreter
if Tk_Nosy.pythonInterpreterCollection == None:
Tk_Nosy.pythonInterpreterCollection = PyInterpsOnSys()
self.defaultPyInterp = Tk_Nosy.pythonInterpreterCollection.get_PI_obj_by_py_path(
sys.executable)
#print( Tk_Nosy.pythonInterpreterCollection )
self.Alarm()
def try_change_to_new_dir(self, dirname):
"""A legal abspath will switch to dirname."""
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
if dirname:
try:
dirname = os.path.abspath(dirname)
except:
return # let Alarm force dir selection
else:
return
self.dirname = dirname
print('Selected dirname =', dirname)
fileD.clear()
os.chdir(self.dirname)
self.reset_statusbar_bg()
self.need_to_pick_dir = 0
#with open(NOSY_USER_DATA_FILE, 'w') as text_file:
# text_file.write( self.dirname )
self.numNosyCalls = 0
def reset_statusbar_bg(self):
"""Return status bar to default state"""
self.statusbar.config(bg=self.statusbar_bg)
self.statusMessage.set(self.dirname)
def set_statusbar_bg(self, c):
"""Set status bar to show new color and message"""
self.statusbar.config(bg=c)
self.oscillator_B = 1 # will return to initial color after a few cycles
def menu_Directory_Change_Dir(self):
"""Menu selection to set directory in which to run nosetests"""
dirname = self.AskDirectory(title='Choose Directory For Nose Tests',
initialdir=".")
if dirname:
self.try_change_to_new_dir(dirname)
# >>>>>>insert any user code below this comment for section "menu_Directory_Change_Dir"
# replace, delete, or comment-out the following
print("called menu_Directory_Change_Dir")
def menu_Run(self):
"""User initiates a nosetests run, not file change detection."""
print("called menu_Run")
self.callNosy()
def rerun_tests(self, *args):
self.menu_Run()
def callNosy(self):
"""Run nosetests and display results"""
self.numNosyCalls += 1
runL = [(self.defaultPyInterp, self)]
for PI, Popup in Tk_Nosy.concurrent_versionL:
runL.append((PI, Popup))
for PI, tkwindow in runL:
tkwindow.Text_1.delete(1.0, END)
# turn indicator button gray while running the tests
tkwindow.Pass_Fail_Button.config(background="#999999",
text='TESTING...',
font=self.arial_12_bold_font)
self.master.update()
self.master.update_idletasks()
for PI, tkwindow in runL:
self.run_tkwin_nosetests(PI, tkwindow)
self.master.winfo_toplevel().wm_geometry("")
def run_tkwin_nosetests(self, PI, tkwindow):
"""Run nosetests for main python interpreter and any concurrent
python interpreters.
Update GUI to show results.
"""
if PI.nose_version == None:
# if nose was not installed last time we checked, check again
PI.nose_version, err_msg = get_nose_version_info(PI.full_path)
if PI.nose_version == None:
print("\a") # make beep
s = 'Can not verify nose for:\nPython ' + PI.name()
tkwindow.Pass_Fail_Button.config(background='orange',
text=s,
font=self.arial_12_bold_font)
s = 'Please verify nose installed for:\n'+str(PI) +\
'\n\n' + err_msg+\
'\n\nFor install instructions see:\n'+\
'https://nose.readthedocs.org/en/latest/'
tkwindow.Text_1.insert(END, s)
ShowError(title='Can not verify nose', message=s)
return
# pylint: disable=W0201
passedAllTests, numPassed, numFailed, numErrors, numSkipped, outputTextL = \
run_nosetests(self.numNosyCalls, PI, display_test_details=self.display_test_details.get())
max_len_s = 42
num_lines = 1
for s in outputTextL:
tkwindow.Text_1.insert(END, s)
sL = s.split('\n')
for ss in sL:
max_len_s = max(max_len_s, len(ss))
num_lines += 1
if self.numNosyCalls % 2:
myFont = self.arial_12_bold_font
else:
myFont = self.arial_12_font
if passedAllTests:
s = 'PASSED'
if numPassed > 1:
s = 'PASSED ALL %i TESTS' % numPassed
elif numPassed == 1:
s = 'PASSED ONE TEST'
bg = "#00ff00"
if numSkipped == 1:
s = 'passed with 1 SKIP'
bg = "#00cc00"
elif numSkipped > 1:
s = 'passed with %i SKIPS' % numSkipped
bg = "#00cc00"
elif numPassed == 0:
s = 'No Tests Found'
bg = "#ff8000"
tkwindow.Pass_Fail_Button.config(background=bg,
text=s,
font=myFont)
#self.master.geometry('200x50')
else:
s = 'FAILED %i, ERRORS %i, SKIP %i, PASSED %i' % (
numFailed, numErrors, numSkipped, numPassed)
tkwindow.Pass_Fail_Button.config(background="#ff0000",
text=s,
font=myFont)
#self.master.geometry('516x385')
# Show list of files being watched.
#self.Text_1.insert(END, '_'*40+'\n')
tkwindow.Text_1.insert(END,
'WATCHED *.py FILES'.center(40, '_') + '\n')
tkwindow.Text_1.insert(END, '%s%s..\n\n' % (self.dirname, os.path.sep))
num_lines += 3
len_dirname = len(self.dirname)
if self.display_watched_files.get() == 'Y':
keyL = list(fileD.keys())
keyL.sort()
lastdir = ''
for key in keyL:
dn = os.path.dirname(key)
if dn != lastdir:
tkwindow.Text_1.insert(END, '..' + dn[len_dirname:] + '\n')
max_len_s = max(max_len_s, len(dn) + 1)
lastdir = dn
num_lines += 1
s = ' ' + os.path.basename(key)
tkwindow.Text_1.insert(END, s + '\n')
max_len_s = max(max_len_s, len(s) + 1)
num_lines += 1
else:
num_lines += 1
tkwindow.Text_1.insert(END,
' %i files watched.\n' % len(fileD))
tkwindow.Text_1.config(width=max_len_s)
tkwindow.Text_1.config(height=min(40, num_lines))
def bindConfigure(self, event):
"""Part of goofy main window setup in tkinter."""
# tkinter requires arguments, but I don't use them
# pylint: disable=W0613
if not self.initComplete:
self.master.bind("<Configure>", self.Master_Configure)
self.initComplete = 1
def change_python_exe(self, full_path):
"""Allow nosetests to be run under any available python version """
PI = Tk_Nosy.pythonInterpreterCollection.add_interp(full_path)
if PI:
self.defaultPyInterp = PI
def findNewPythonInterpreter(self):
"""Find a new python interpreter, one that is not already in
the PyInterpsOnSys object (pythonInterpreterCollection).
"""
if Tk_Nosy.pythonInterpreterCollection == None:
print('pythonInterpreterCollection NOT yet initialized')
self.statusMessage.set('Interpreter Collection NOT initialized')
self.set_statusbar_bg('#FF9999')
return
print('Open File')
filetypes = [('python executable', 'py*'), ('Any File', '*.*')]
pathopen = tkFileDialog.askopenfilename(
parent=self.master,
title='Select Python Executable',
filetypes=filetypes,
initialdir=self.defaultPyInterp.full_path)
if pathopen:
self.change_python_exe(pathopen)
self.menu_Run()
def kill_popup_window(self, popup_name):
"""Close a popup window running another versions of python interpreter"""
for itup, tup in enumerate(Tk_Nosy.concurrent_versionL):
PI, Popup = tup
s = '%s %s' % (PI.exe_name, PI.version_str)
if popup_name == s:
Tk_Nosy.concurrent_versionL.pop(itup)
return True # removed popup from list
return False # no popup found
def launchAnotherPythonInterpreter(self):
"""Launch a pop-up window that concurrently runs another python version"""
removeNameL = [self.defaultPyInterp.name()]
for PI, Popup in Tk_Nosy.concurrent_versionL:
removeNameL.append(PI.name())
piL = Tk_Nosy.pythonInterpreterCollection.get_PI_list(
removeNameL=removeNameL)
if len(piL) == 0:
print('All identified python interpreters in use.')
else:
print([pi.name() for pi in piL])
rbL = [PI.name() for PI in piL]
dialog = Select_Py_Version(self.master,
"Launch Another Python Version",
dialogOptions={'rbL': rbL})
if dialog.result:
PI = Tk_Nosy.pythonInterpreterCollection.get_PI_obj_by_name(
dialog.result['selection'])
s = '%s %s' % (PI.exe_name, PI.version_str)
Popup = SatelliteWindow(self, self.master, s)
Tk_Nosy.concurrent_versionL.append((PI, Popup))
self.menu_Run()
def changePythonVersion(self):
"""Change to a different python version.
If the PyInterpsOnSys object (pythonInterpreterCollection) has been
initialized, select from its list.
Otherwise find the python interpreter executable
(ex. python.exe or python)
"""
if (Tk_Nosy.pythonInterpreterCollection == None) or \
(Tk_Nosy.pythonInterpreterCollection.num_terps() == 0):
# If there is no list of available python interpreters, look for python file
print('Open File')
filetypes = [('python executable', 'py*'), ('Any File', '*.*')]
pathopen = tkFileDialog.askopenfilename(
parent=self.master,
title='Select Python Executable',
filetypes=filetypes,
initialdir=self.defaultPyInterp.full_path)
if pathopen:
self.change_python_exe(pathopen)
self.menu_Run()
else:
rbL = [
PI.name() for PI in Tk_Nosy.pythonInterpreterCollection.interpL
]
dialog = Select_Py_Version(self.master,
"Select Python Version",
dialogOptions={'rbL': rbL})
if dialog.result:
PI = Tk_Nosy.pythonInterpreterCollection.get_PI_obj_by_name(
dialog.result['selection'])
pathopen = PI.full_path
self.change_python_exe(pathopen)
self.menu_Run()
# return a string containing directory name
def AskDirectory(self, title='Choose Directory', initialdir="."):
"""Run pop-up menu for user to select directory."""
# This is not an error
# pylint: disable=E1101
if sys.version_info < (3, ):
dirname = tkFileDialog.askdirectory(parent=self.master,
initialdir=initialdir,
title=title)
else:
dirname = tkFileDialog.askdirectory(parent=self.master,
initialdir=initialdir,
title=title)
return dirname # <-- string
def Master_Configure(self, event):
"""Part of tkinter main window initialization"""
if event.widget != self.master:
if self.w != -1:
return
x = int(self.master.winfo_x())
y = int(self.master.winfo_y())
w = int(self.master.winfo_width())
h = int(self.master.winfo_height())
if (self.x, self.y, self.w, self.h) == (-1, -1, -1, -1):
self.x, self.y, self.w, self.h = x, y, w, h
if self.w != w or self.h != h:
#print "Master reconfigured... make resize adjustments"
self.w = w
self.h = h
# pylint: disable=W0613
def Pass_Fail_Button_Click(self, event):
"""Routine for user clicking Pass/Fail Button"""
print('Arranging Windows by User Request')
num_popups = len(Tk_Nosy.concurrent_versionL)
DX = 50
DY = 70
x = 10
y = 10 + num_popups * DY
self.master.geometry('+%i+%i' % (x, y))
for PI, Popup in Tk_Nosy.concurrent_versionL:
x += DX
y -= DY
Popup.geometry('+%i+%i' % (x, y))
# alarm function is called after specified number of milliseconds
def SetAlarm(self, milliseconds=1000):
"""Reinitialize tkinter alarm mechanism as well as update seconds
counter in main window title bar.
"""
self.master.after(milliseconds, self.Alarm)
self.oscillator += 1
if self.oscillator > 5:
self.oscillator = 0
if self.oscillator_B > 0:
self.oscillator_B += 1
if self.oscillator_B > 5:
self.oscillator_B = 0
self.reset_statusbar_bg()
pad = '|' * self.oscillator
s = '%s (v%s)' % (self.defaultPyInterp.exe_name,
self.defaultPyInterp.version_str)
self.master.title('%i) %s ' % (self.numNosyCalls, s + pad))
for PI, Popup in Tk_Nosy.concurrent_versionL:
s = '%s (v%s)' % (PI.exe_name, PI.version_str)
Popup.title('%i) %s ' % (self.numNosyCalls, s + pad))
def Alarm(self):
"""Look for changed files every second, then reset alarm"""
if self.need_to_pick_dir:
dirname = self.AskDirectory(
title='Choose Directory For Nose Tests', initialdir=".")
self.try_change_to_new_dir(dirname)
#first call to numberOfChangedFiles will be > 0 if any .py files are found
elif numberOfChangedFiles(self.dirname) > 0: # or self.numNosyCalls==0
self.callNosy()
self.SetAlarm()
class Client:
NUMBER_BUTTONS = 5
PADX = 5
PADY = 7
RTP_BUFFER_SIZE = 15 * 1024
RTSP_BUFFER_SIZE = 256
def __init__(self, root, serverAddr, serverPort, rtpPort, fileName):
self.master = root
self.serverAddr = serverAddr
self.serverPort = int(serverPort)
self.rtpPort = int(rtpPort)
self.fileName = fileName
self.sessionId = None
self.state = State.INIT
self.setup_connection()
self.init_ui()
self.timeline = 0
self.total_size = 0
self.count_sended = 0 #server will send this value
self.length_sended = 0 #server will send this value
self.type = RequestType.SETUP
self.event = None
self.cseq = 0
self.start = 0
self.begin_pause = 0
self.pause_time = 0
self.is_pausing = False
self.receive_frame = []
self.loss = 0
self.has_play = False
self.send_rtsp_request(
RequestType.SETUP) #send request Setup when init
def init_ui(self):
self.draw_frame()
self.draw_statitics()
self.draw_buttons()
# self.draw_describe()
# def draw_describe(self):
# self.describe = Label(self.master)
# self.describe.pack(fill=X)
def draw_frame(self):
self.label_video = Label(self.master)
self.label_video.pack(fill=BOTH, expand=True)
self.frame_button = Frame(self.master)
self.frame_button.pack(fill=X, side=BOTTOM)
for i in range(Client.NUMBER_BUTTONS):
self.frame_button.columnconfigure(i, weight=1)
def draw_statitics(self):
# if sended != 0:
self.statitics = Label(self.master)
self.statitics.pack(fill=X)
def draw_buttons(self):
#self.btn_setup = Button(self.frame_button, text = 'Setup', command = self.click_setup)
self.btn_play = Button(self.frame_button,
text='Play',
command=self.click_play)
self.btn_pause = Button(self.frame_button,
text='Pause',
command=self.click_pause)
#self.btn_teardown = Button(self.frame_button, text = 'Teardown', command = self.click_teardown)
self.btn_describe = Button(self.frame_button,
text='Describe',
command=self.click_describe)
self.btn_stop = Button(self.frame_button,
text='Stop',
command=self.click_stop)
#self.btn_setup.grid(row = 0, column = 1, sticky = 'EW', padx = Client.PADX, pady = Client.PADY)
self.btn_play.grid(row=0,
column=1,
sticky='EW',
padx=Client.PADX,
pady=Client.PADY)
self.btn_pause.grid(row=0,
column=2,
sticky='EW',
padx=Client.PADX,
pady=Client.PADY)
#self.btn_teardown.grid(row = 0, column = 4, sticky = 'EW', padx = Client.PADX, pady = Client.PADY)
self.btn_describe.grid(row=0,
column=0,
sticky='EW',
padx=Client.PADX,
pady=Client.PADY)
self.btn_stop.grid(row=0,
column=3,
sticky='EW',
padx=Client.PADX,
pady=Client.PADY)
def click_describe(self):
if self.rtsp_socket:
self.type = RequestType.DESCRIBE
self.send_rtsp_request(RequestType.DESCRIBE)
def click_setup(self):
if self.state == State.INIT:
self.type = RequestType.SETUP
self.send_rtsp_request(RequestType.SETUP)
def click_play(self):
if self.state == State.INIT:
yesno = askyesno('Connection Over Time',
'Do you want to reconnect?') # Yes / No
if yesno == True:
self.send_rtsp_request(RequestType.SETUP)
if self.state == State.READY:
self.type = RequestType.PLAY
self.has_play = True
self.send_rtsp_request(RequestType.PLAY)
def click_pause(self):
if self.state == State.PLAYING:
self.type = RequestType.PAUSE
self.send_rtsp_request(RequestType.PAUSE)
def click_teardown(self):
if self.state == State.READY or self.state == State.PLAYING:
self.type = RequestType.TEARDOWN
self.send_rtsp_request(RequestType.TEARDOWN)
def click_stop(self):
if self.state != State.INIT and self.has_play:
self.type = RequestType.STOP
self.send_rtsp_request(RequestType.STOP)
def setup_connection(self):
self.rtsp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.rtsp_socket.connect((self.serverAddr, self.serverPort))
self.client_host = self.rtsp_socket.getsockname()[0]
def send_rtsp_request(self, requestType):
self.last_requesttype = requestType
if self.rtsp_socket is None:
self.setup_connection()
if requestType == RequestType.DESCRIBE:
if self.event:
if not self.event.is_alive():
self.event.start()
else:
self.event = threading.Thread(target=self.process_rtsp_request)
self.event.start()
self.cseq = self.cseq + 1
request = "DESCRIBE " + str(self.fileName) + " RTSP/1.0"+ "\n"+\
"CSeq: " + str(self.cseq) +"\n"+\
'Port: '+str(self.serverPort) + ' IP: '+ str(self.serverAddr)
elif requestType == RequestType.SETUP:
self.event = threading.Thread(target=self.process_rtsp_request)
if not self.event.is_alive():
self.event.start()
self.cseq = self.cseq + 1
request = f'SETUP {self.fileName} RTSP/1.0\nCSeq: {self.cseq} \nTransport: RTP/UDP; client_port= {self.rtpPort}'
elif requestType == RequestType.PLAY:
self.cseq += 1
request = f'PLAY {self.fileName} RTSP/1.0\nCseq: {self.cseq}\nSession: {self.sessionId}'
elif requestType == RequestType.PAUSE:
self.cseq += 1
request = f'PAUSE {self.fileName} RTSP/1.0\nCseq: {self.cseq}\nSession: {self.sessionId}'
elif requestType == RequestType.TEARDOWN:
self.cseq += 1
request = f'TEARDOWN {self.fileName} RTSP/1.0\nCseq: {self.cseq}\nSession: {self.sessionId}'
elif requestType == RequestType.STOP:
self.cseq += 1
request = f'STOP {self.fileName} RTSP/1.0\nCseq: {self.cseq}\nSession: {self.sessionId}'
self.rtsp_socket.send(request.encode())
def open_rtp_port(self):
self.rtp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.rtp_socket.settimeout(.5)
try:
self.rtp_socket.bind((self.client_host, self.rtpPort))
except socket.timeout:
showerror('error', '[TIME_OUT] failed for opening rtp port')
print('[LOG] Rtp port is opened successfully')
def process_rtsp_request(self):
while True:
data = self.rtsp_socket.recv(Client.RTSP_BUFFER_SIZE).decode()
if data:
if self.type == RequestType.DESCRIBE:
print(data)
showinfo("Describe Infomation", data)
# self.describe['text'] = '*****Describe Info*****\n' + data
else:
request = data.split('\n')
print(request)
seqNum = int(request[1].split()[1])
if seqNum == self.cseq:
sessionId = int(request[-1].split()[1])
if self.sessionId is None:
self.sessionId = sessionId
status_code = int(request[0].split()[1])
if self.sessionId == sessionId and status_code == 200:
if self.last_requesttype == RequestType.SETUP:
self.open_rtp_port()
self.state = State.READY
elif self.last_requesttype == RequestType.PLAY:
threading.Thread(
target=self.receive_rtp_packet).start()
self.state = State.PLAYING
elif self.last_requesttype == RequestType.PAUSE:
self.state = State.READY
elif self.last_requesttype == RequestType.STOP:
self.state = State.READY
self.total_size = 0
self.timeline = 0
self.receive_frame = []
self.is_pausing = True
self.begin_pause = time.time()
t = threading.Thread(
target=self.count_not_request_time,
args=())
t.start()
elif self.last_requesttype == RequestType.TEARDOWN:
#self.describe['text'] = ''
self.state = State.INIT
self.display_cancel()
self.reset()
self.has_play = False
break
def receive_rtp_packet(self):
if self.start == 0:
self.start = time.time()
while True:
try:
data, clientAddr = self.rtp_socket.recvfrom(
Client.RTP_BUFFER_SIZE)
if data:
header, payload = RtpPacket.decode(data)
now = time.time()
frame_nbr = header[2] * 256 + header[3]
self.receive_frame.append(frame_nbr)
if frame_nbr < max(self.receive_frame):
self.loss += 1
if self.is_pausing:
self.is_pausing = False
self.pause_time += now - self.begin_pause
self.timeline = (now - self.start) - self.pause_time
self.total_size += len(payload)
text = '\tSTATISTICS'
text += '\nLoss rate = {:.2f}%'.format(
self.loss / len(self.receive_frame) * 100)
text += '\nVideo data rate = {:.2f} (bps)'.format(
self.total_size / self.timeline)
text += f'\nNumber of frames = {len(self.receive_frame)}'
self.statitics.config(text=text, justify='left')
image = Image.open(io.BytesIO(payload))
imagetk = ImageTk.PhotoImage(image=image)
self.label_video.configure(image=imagetk)
self.label_video.image = imagetk
except:
if self.last_requesttype == RequestType.PAUSE:
print('[LOG]', 'Video is paused')
self.begin_pause = time.time()
self.is_pausing = True
elif self.state == State.PLAYING:
showinfo('info', 'The video is ended')
# Clear frame being displayed
self.label_video.image = None
self.statitics.config(text="")
self.state = State.READY
self.receive_frame = []
break
def reset(self):
self.rtp_socket.close()
self.rtsp_socket.shutdown(socket.SHUT_RDWR)
self.rtsp_socket.close()
self.rtp_socket = self.rtsp_socket = None
self.sessionId = None
self.timeline = 0
self.statitics.config(text="")
self.state = State.INIT
# self.loss = 0
self.receive_frame = []
def display_cancel(self):
showinfo('info', 'The video is cancelled')
# Clear frame being displayed
self.label_video.image = None
def count_not_request_time(self):
count = 0
while self.state == State.READY:
print(str(9 - count) + 's left to disconnect') #count time :))
time.sleep(1)
count += 1
if count >= 10:
print('Disconnect!')
self.last_requesttype = RequestType.TEARDOWN
self.send_rtsp_request(RequestType.TEARDOWN)
break
root.destroy()
# ===== Widgets ===== #
# 1. Header
frm_header = Frame(master=root)
frm_header.configure(background='#212529')
frm_header.pack()
# 1.1 Dice number
frm_dice_num = Frame(master=frm_header, pady=10)
frm_dice_num.configure(background='#212529')
frm_dice_num.pack()
lbl_dice_num = Label(master=frm_dice_num, text='Number of dice (1-3)', padx=15)
lbl_dice_num.config(font=('Comic Sans MS', 13))
lbl_dice_num.configure(background='#212529', foreground='#fff')
lbl_dice_num.pack(side='left')
register = root.register(validation)
ent_dice_num = Entry(master=frm_dice_num,
width=5,
justify='center',
relief='groove',
borderwidth=2)
ent_dice_num.config(font=('Comic Sans MS', 11))
ent_dice_num.configure(background='#212529', foreground='#fff')
ent_dice_num.pack(side='right')
ent_dice_num.insert(0, 1)
ent_dice_num.config(validate='key', validatecommand=(register, '%S'))
class Tk_Nosy(object):
"""This class is the tkinter GUI object"""
# make a collection of python interpreters to choose from
pythonInterpreterCollection = None # will be PyInterpsOnSys object
# extra python interpreters can run nosetests concurrently to main window
# concurrent_versionL contains tuples = (PI, Popup)
concurrent_versionL = [] # additional running python interpreters
def __init__(self, master):
self.dirname = os.path.abspath( os.curdir )
self.initComplete = 0
self.master = master
self.x, self.y, self.w, self.h = -1,-1,-1,-1
# bind master to <Configure> in order to handle any resizing, etc.
# postpone self.master.bind("<Configure>", self.Master_Configure)
self.master.bind('<Enter>', self.bindConfigure)
self.menuBar = Menu(master, relief = "raised", bd=2)
self.menuBar.add("command", label = "Change_Dir", command = self.menu_Directory_Change_Dir)
disp_Choices = Menu(self.menuBar, tearoff=0)
self.display_test_details = StringVar()
self.display_test_details.set('N')
disp_Choices.add_checkbutton(label='Display Test Details', variable=self.display_test_details, onvalue='Y', offvalue='N')
self.display_watched_files = StringVar()
self.display_watched_files.set('N')
disp_Choices.add_checkbutton(label='Show Watched Files', variable=self.display_watched_files, onvalue='Y', offvalue='N')
self.menuBar.add("cascade", label="Display", menu=disp_Choices)
py_choices = Menu(self.menuBar, tearoff=0)
py_choices.add("command", label = "Change Python Version",
command = self.changePythonVersion)
py_choices.add("command", label = "Find New Python Interpreter",
command = self.findNewPythonInterpreter)
py_choices.add("command", label = "Launch Another Python Interpreter",
command = self.launchAnotherPythonInterpreter)
self.menuBar.add("cascade", label="Python", menu=py_choices)
#top_Snippet = Menu(self.menuBar, tearoff=0)
self.menuBar.add("command", label = "Run", command = self.menu_Run)
self.display_test_details.trace("w", self.rerun_tests)
self.display_watched_files.trace("w", self.rerun_tests)
master.config(menu=self.menuBar)
# make a Status Bar
self.statusMessage = StringVar()
self.statusMessage.set(self.dirname)
self.statusbar = Label(self.master, textvariable=self.statusMessage,
bd=1, relief=SUNKEN)
self.statusbar.pack(anchor=SW, fill=X, side=BOTTOM)
self.statusbar_bg = self.statusbar.cget('bg') # save bg for restore
self.arial_12_bold_font = tkinter.font.Font(family="Arial", size=12,
weight=tkinter.font.BOLD)
self.arial_12_font = tkinter.font.Font(family="Arial", size=12)
self.statusbar.config( font=self.arial_12_bold_font )
frame = Frame(master)
frame.pack(anchor=NE, fill=BOTH, side=TOP)
self.Pass_Fail_Button = Button(frame,text="Pass/Fail Will Be Shown Here",
image="", width="15", background="green",
anchor=W, justify=LEFT, padx=2)
self.Pass_Fail_Button.pack(anchor=NE, fill=X, side=TOP)
self.Pass_Fail_Button.bind("<ButtonRelease-1>", self.Pass_Fail_Button_Click)
self.master.title("tk_nosy")
self.oscillator = 1 # animates character on title
self.oscillator_B = 0 # used to return statusbar to statusbar_bg
self.lbframe = Frame( frame )
self.lbframe.pack(anchor=SE, side=LEFT, fill=BOTH, expand=1)
scrollbar = Scrollbar(self.lbframe, orient=VERTICAL)
self.Text_1 = Text(self.lbframe, width="80", height="24",
yscrollcommand=scrollbar.set)
scrollbar.config(command=self.Text_1.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.Text_1.pack(side=LEFT, fill=BOTH, expand=1)
self.master.resizable(1,1) # Linux may not respect this
self.numNosyCalls = 0
self.need_to_pick_dir = 1
print('sys.argv =',sys.argv)
if len(sys.argv)>1:
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
print( "Try Dir =",sys.argv[1] )
try:
dirname = os.path.abspath( sys.argv[1] )
self.try_change_to_new_dir( dirname )
except Exception:
pass # let Alarm force dir selection
else:
try:
if os.path.isdir(os.path.join( self.dirname, 'tests' )):
self.try_change_to_new_dir( self.dirname )
except Exception:
pass # let Alarm force dir selection
print(LICENSE)
self.defaultPyInterp = None # need to identify default python interpreter
if Tk_Nosy.pythonInterpreterCollection == None:
Tk_Nosy.pythonInterpreterCollection = PyInterpsOnSys()
self.defaultPyInterp = Tk_Nosy.pythonInterpreterCollection.get_PI_obj_by_py_path( sys.executable )
#print( Tk_Nosy.pythonInterpreterCollection )
self.Alarm()
def try_change_to_new_dir(self, dirname):
"""A legal abspath will switch to dirname."""
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
if dirname:
try:
dirname = os.path.abspath( dirname )
except:
return # let Alarm force dir selection
else:
return
self.dirname = dirname
print('Selected dirname =',dirname)
fileD.clear()
os.chdir( self.dirname )
self.reset_statusbar_bg()
self.need_to_pick_dir = 0
#with open(NOSY_USER_DATA_FILE, 'w') as text_file:
# text_file.write( self.dirname )
self.numNosyCalls = 0
def reset_statusbar_bg(self):
"""Return status bar to default state"""
self.statusbar.config(bg=self.statusbar_bg)
self.statusMessage.set(self.dirname)
def set_statusbar_bg(self, c):
"""Set status bar to show new color and message"""
self.statusbar.config(bg=c)
self.oscillator_B = 1 # will return to initial color after a few cycles
def menu_Directory_Change_Dir(self):
"""Menu selection to set directory in which to run nosetests"""
dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".")
if dirname:
self.try_change_to_new_dir( dirname )
# >>>>>>insert any user code below this comment for section "menu_Directory_Change_Dir"
# replace, delete, or comment-out the following
print("called menu_Directory_Change_Dir")
def menu_Run(self):
"""User initiates a nosetests run, not file change detection."""
print("called menu_Run")
self.callNosy()
def rerun_tests(self,*args):
self.menu_Run()
def callNosy(self):
"""Run nosetests and display results"""
self.numNosyCalls += 1
runL = [(self.defaultPyInterp, self)]
for PI,Popup in Tk_Nosy.concurrent_versionL:
runL.append( (PI, Popup) )
for PI, tkwindow in runL:
tkwindow.Text_1.delete(1.0, END)
# turn indicator button gray while running the tests
tkwindow.Pass_Fail_Button.config(background="#999999",
text='TESTING...',
font=self.arial_12_bold_font)
self.master.update()
self.master.update_idletasks()
for PI, tkwindow in runL:
self.run_tkwin_nosetests( PI, tkwindow)
self.master.winfo_toplevel().wm_geometry("")
def run_tkwin_nosetests(self, PI, tkwindow):
"""Run nosetests for main python interpreter and any concurrent
python interpreters.
Update GUI to show results.
"""
if PI.nose_version == None:
# if nose was not installed last time we checked, check again
PI.nose_version, err_msg = get_nose_version_info( PI.full_path )
if PI.nose_version == None:
print( "\a" ) # make beep
s = 'Can not verify nose for:\nPython ' + PI.name()
tkwindow.Pass_Fail_Button.config(background='orange',
text=s,
font=self.arial_12_bold_font)
s = 'Please verify nose installed for:\n'+str(PI) +\
'\n\n' + err_msg+\
'\n\nFor install instructions see:\n'+\
'https://nose.readthedocs.org/en/latest/'
tkwindow.Text_1.insert(END, s )
ShowError(title='Can not verify nose', message=s)
return
# pylint: disable=W0201
passedAllTests, numPassed, numFailed, numErrors, numSkipped, outputTextL = \
run_nosetests(self.numNosyCalls, PI, display_test_details=self.display_test_details.get())
max_len_s = 42
num_lines = 1
for s in outputTextL:
tkwindow.Text_1.insert(END, s)
sL = s.split('\n')
for ss in sL:
max_len_s = max(max_len_s, len(ss))
num_lines += 1
if self.numNosyCalls % 2:
myFont = self.arial_12_bold_font
else:
myFont = self.arial_12_font
if passedAllTests:
s = 'PASSED'
if numPassed > 1:
s = 'PASSED ALL %i TESTS'%numPassed
elif numPassed == 1:
s = 'PASSED ONE TEST'
bg="#00ff00"
if numSkipped==1:
s = 'passed with 1 SKIP'
bg = "#00cc00"
elif numSkipped > 1:
s = 'passed with %i SKIPS'%numSkipped
bg = "#00cc00"
elif numPassed==0:
s = 'No Tests Found'
bg="#ff8000"
tkwindow.Pass_Fail_Button.config(background=bg, text=s, font=myFont)
#self.master.geometry('200x50')
else:
s = 'FAILED %i, ERRORS %i, SKIP %i, PASSED %i'%(numFailed,
numErrors, numSkipped, numPassed)
tkwindow.Pass_Fail_Button.config(background="#ff0000", text=s, font=myFont)
#self.master.geometry('516x385')
# Show list of files being watched.
#self.Text_1.insert(END, '_'*40+'\n')
tkwindow.Text_1.insert(END, 'WATCHED *.py FILES'.center(40,'_') + '\n' )
tkwindow.Text_1.insert(END, '%s%s..\n\n'%(self.dirname,os.path.sep) )
num_lines += 3
len_dirname = len( self.dirname )
if self.display_watched_files.get()=='Y':
keyL = list(fileD.keys())
keyL.sort()
lastdir = ''
for key in keyL:
dn = os.path.dirname( key )
if dn != lastdir:
tkwindow.Text_1.insert(END, '..'+dn[len_dirname:] + '\n')
max_len_s = max(max_len_s, len(dn)+1)
lastdir = dn
num_lines += 1
s = ' ' +os.path.basename( key )
tkwindow.Text_1.insert(END, s + '\n')
max_len_s = max(max_len_s, len(s)+1)
num_lines += 1
else:
num_lines += 1
tkwindow.Text_1.insert(END, ' %i files watched.\n'%len(fileD))
tkwindow.Text_1.config(width=max_len_s)
tkwindow.Text_1.config(height=min(40, num_lines))
def bindConfigure(self, event):
"""Part of goofy main window setup in tkinter."""
# tkinter requires arguments, but I don't use them
# pylint: disable=W0613
if not self.initComplete:
self.master.bind("<Configure>", self.Master_Configure)
self.initComplete = 1
def change_python_exe(self, full_path ):
"""Allow nosetests to be run under any available python version """
PI = Tk_Nosy.pythonInterpreterCollection.add_interp( full_path )
if PI:
self.defaultPyInterp = PI
def findNewPythonInterpreter(self):
"""Find a new python interpreter, one that is not already in
the PyInterpsOnSys object (pythonInterpreterCollection).
"""
if Tk_Nosy.pythonInterpreterCollection == None:
print( 'pythonInterpreterCollection NOT yet initialized' )
self.statusMessage.set('Interpreter Collection NOT initialized')
self.set_statusbar_bg( '#FF9999' )
return
print('Open File')
filetypes = [
('python executable','py*'),
('Any File','*.*')]
pathopen = tkFileDialog.askopenfilename(parent=self.master,
title='Select Python Executable',
filetypes=filetypes,
initialdir=self.defaultPyInterp.full_path)
if pathopen:
self.change_python_exe( pathopen )
self.menu_Run()
def kill_popup_window(self, popup_name):
"""Close a popup window running another verions of python interpreter"""
for itup, tup in enumerate(Tk_Nosy.concurrent_versionL):
PI, Popup = tup
s = '%s %s' % (PI.exe_name, PI.version_str)
if popup_name == s:
Tk_Nosy.concurrent_versionL.pop( itup )
return True # removed popup from list
return False # no popup found
def launchAnotherPythonInterpreter(self):
"""Launch a pop-up window that concurrently runs another python version"""
removeNameL=[self.defaultPyInterp.name()]
for PI,Popup in Tk_Nosy.concurrent_versionL:
removeNameL.append( PI.name() )
piL = Tk_Nosy.pythonInterpreterCollection.get_PI_list( removeNameL=removeNameL )
if len(piL)==0:
print( 'All identified python interpreters in use.' )
else:
print( [pi.name() for pi in piL] )
rbL = [PI.name() for PI in piL]
dialog = Select_Py_Version(self.master, "Launch Another Python Version",
dialogOptions={'rbL':rbL})
if dialog.result:
PI = Tk_Nosy.pythonInterpreterCollection.get_PI_obj_by_name(
dialog.result['selection'])
s = '%s %s' % (PI.exe_name, PI.version_str)
Popup = SatelliteWindow(self, self.master, s)
Tk_Nosy.concurrent_versionL.append( (PI, Popup) )
self.menu_Run()
def changePythonVersion(self):
"""Change to a different python version.
If the PyInterpsOnSys object (pythonInterpreterCollection) has been
initialized, select from its list.
Otherwise find the python interpreter executable
(ex. python.exe or python)
"""
if (Tk_Nosy.pythonInterpreterCollection == None) or \
(Tk_Nosy.pythonInterpreterCollection.num_terps() == 0):
# If there is no list of available python interpreters, look for python file
print('Open File')
filetypes = [
('python executable','py*'),
('Any File','*.*')]
pathopen = tkFileDialog.askopenfilename(parent=self.master,
title='Select Python Executable',
filetypes=filetypes,
initialdir=self.defaultPyInterp.full_path)
if pathopen:
self.change_python_exe( pathopen )
self.menu_Run()
else:
rbL = [PI.name() for PI in Tk_Nosy.pythonInterpreterCollection.interpL]
dialog = Select_Py_Version(self.master, "Select Python Version",
dialogOptions={'rbL':rbL})
if dialog.result:
PI = Tk_Nosy.pythonInterpreterCollection.get_PI_obj_by_name(
dialog.result['selection'] )
pathopen = PI.full_path
self.change_python_exe( pathopen )
self.menu_Run()
# return a string containing directory name
def AskDirectory(self, title='Choose Directory', initialdir="."):
"""Run pop-up menu for user to select directory."""
# This is not an error
# pylint: disable=E1101
if sys.version_info < (3,):
dirname = tkFileDialog.askdirectory(parent=self.master,
initialdir=initialdir,title=title)
else:
dirname = tkFileDialog.askdirectory(parent=self.master,
initialdir=initialdir,title=title)
return dirname # <-- string
def Master_Configure(self, event):
"""Part of tkinter main window initialization"""
if event.widget != self.master:
if self.w != -1:
return
x = int(self.master.winfo_x())
y = int(self.master.winfo_y())
w = int(self.master.winfo_width())
h = int(self.master.winfo_height())
if (self.x, self.y, self.w, self.h) == (-1,-1,-1,-1):
self.x, self.y, self.w, self.h = x,y,w,h
if self.w!=w or self.h!=h:
#print "Master reconfigured... make resize adjustments"
self.w=w
self.h=h
# pylint: disable=W0613
def Pass_Fail_Button_Click(self, event):
"""Routine for user clicking Pass/Fail Button"""
print('Arranging Windows by User Request')
num_popups = len(Tk_Nosy.concurrent_versionL)
DX = 50
DY = 70
x = 10
y = 10 + num_popups * DY
self.master.geometry( '+%i+%i'%(x,y))
for PI,Popup in Tk_Nosy.concurrent_versionL:
x += DX
y -= DY
Popup.geometry( '+%i+%i'%(x,y))
# alarm function is called after specified number of milliseconds
def SetAlarm(self, milliseconds=1000):
"""Reinitialize tkinter alarm mechanism as well as update seconds
counter in main window title bar.
"""
self.master.after( milliseconds, self.Alarm )
self.oscillator += 1
if self.oscillator > 5:
self.oscillator = 0
if self.oscillator_B>0:
self.oscillator_B += 1
if self.oscillator_B>5:
self.oscillator_B = 0
self.reset_statusbar_bg()
pad = '|'*self.oscillator
s = '%s (v%s)'%(self.defaultPyInterp.exe_name, self.defaultPyInterp.version_str)
self.master.title('%i) %s '%(self.numNosyCalls , s + pad ))
for PI,Popup in Tk_Nosy.concurrent_versionL:
s = '%s (v%s)'%(PI.exe_name, PI.version_str)
Popup.title( '%i) %s '%(self.numNosyCalls , s + pad ) )
def Alarm(self):
"""Look for changed files every second, then reset alarm"""
if self.need_to_pick_dir:
dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".")
self.try_change_to_new_dir( dirname )
#first call to numberOfChangedFiles will be > 0 if any .py files are found
elif numberOfChangedFiles( self.dirname ) > 0: # or self.numNosyCalls==0
self.callNosy()
self.SetAlarm()
class DistanceFuncFrame(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.isCalcDistanceMode = BooleanVar()
self.isCriticalShortest = BooleanVar()
self.cbCalcDistance = Checkbutton(
self,
variable=self.isCalcDistanceMode,
text="calculate distance mode",
command=self.on_calc_distance_mode_clicked)
self.cbCriticalShortest = Checkbutton(self,
variable=self.isCriticalShortest,
text="critical")
self.cbCalcDistance.deselect()
self.cbCriticalShortest.deselect()
self.lblStartPos = Label(self)
self.lblEndPos = Label(self)
self.lblDistance = Label(self)
self.firstPosRow = INVALID_ROW
self.firstPosCol = INVALID_COL
Label(self).pack(expand=1)
Label(self).pack(expand=1)
self.cbCalcDistance.pack(expand=1)
self.cbCriticalShortest.pack(expand=1)
self.lblStartPos.pack(expand=1)
self.lblEndPos.pack(expand=1)
self.lblDistance.pack(expand=1)
evtDispatcher.register(EvtIds.EVT_FIRST_POSITION_SELECTED,
self.handle_first_position_selected)
evtDispatcher.register(EvtIds.EVT_SECOND_POSITION_SELECTED,
self.handle_second_position_selected)
evtDispatcher.register(EvtIds.EVT_SHORTEST_DISTANCE_CALCULATED,
self.handle_shortest_distance_calculated)
def handle_first_position_selected(self, content):
if content is None or content["row"] is None or content["col"] is None:
return
self.lblEndPos.config(text="")
self.lblDistance.config(text="")
self.lblStartPos.config(text="POS1: (%d, %d)" %
(content["col"], content["row"]))
self.firstPosRow = content["row"]
self.firstPosCol = content["col"]
def handle_second_position_selected(self, content):
if content is None or content["row"] is None or content["col"] is None:
return
self.lblEndPos.config(text="POS2: (%d, %d)" %
(content["col"], content["row"]))
self.lblDistance.config(text="calculating...")
self.update()
evtDispatcher.dispatch(
EvtIds.EVT_INFORM_CALC_DISTANCE, {
"row1": self.firstPosRow,
"col1": self.firstPosCol,
"row2": content["row"],
"col2": content["col"],
"isCriticalShortest": self.isCriticalShortest.get()
})
def handle_shortest_distance_calculated(self, content):
if content is None or content["distance"] is None: return
if content["distance"] == UNREACH_DISTANCE:
self.lblDistance.config(text="UNREACHABLE")
return
res = "Shortest Distance: %d" % content["distance"]
if not self.isCriticalShortest.get():
res = "Possible Shortest Distance: %d" % content["distance"]
self.lblDistance.config(text=res)
def on_calc_distance_mode_clicked(self):
if not self.isCalcDistanceMode.get():
self.clean()
self.cbCriticalShortest.deselect()
evtDispatcher.dispatch(EvtIds.EVT_SET_CALC_DISTANCE_MODE,
{"mode": self.isCalcDistanceMode.get()})
def clean(self):
self.lblStartPos.config(text="")
self.lblEndPos.config(text="")
self.lblDistance.config(text="")
class SatelliteWindow( Toplevel ):
"""
SatelliteWindow is used to display nosetests results of concurrently run
python interpreters.
"""
def cleanupOnQuit(self):
"""When closing popup, do a little clean up."""
# I'm not sure that transient windows need this, but I'm trying to be careful
self.MainWin.focus_set()
if self.main_gui.kill_popup_window( self.statusMessage.get() ):
self.destroy()
self.main_gui.statusMessage.set('Closed: ' + self.statusMessage.get())
else:
self.main_gui.statusMessage.set('ERROR Closing: ' + self.statusMessage.get())
self.main_gui.set_statusbar_bg( '#FF9999' )
def __init__(self, main_gui, MainWin, mytitle, dx=30, dy=30):
"""Initialize popup"""
Toplevel.__init__(self, MainWin)
self.title(mytitle)
x = MainWin.winfo_x()
if x<10:
x=10
y = MainWin.winfo_y()
if y<10:
y=10
# position over to the upper right
self.geometry( '+%i+%i'%(x+dx,y+dy))
self.config( highlightcolor='#FF99FF', highlightbackground='#FF99FF',
highlightthickness=2, borderwidth=10 )
#===========
# make a Status Bar
self.statusMessage = StringVar()
self.statusMessage.set(mytitle)
self.statusbar = Label(self, textvariable=self.statusMessage, bd=1, relief=SUNKEN)
self.statusbar.pack(anchor=SW, fill=X, side=BOTTOM)
self.statusbar_bg = self.statusbar.cget('bg') # save bg for restore
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
self.statusbar.config( font=myFont )
frame = Frame(self)
frame.pack(anchor=NE, fill=BOTH, side=TOP)
self.Pass_Fail_Button = Button(frame,text="Pass/Fail Will Be Shown Here",
image="", width="15", background="green",
anchor=W, justify=LEFT, padx=2)
self.Pass_Fail_Button.pack(anchor=NE, fill=X, side=TOP)
self.Pass_Fail_Button.bind("<ButtonRelease-1>", self.Pass_Fail_Button_Click)
#self.title('%s %s.%s.%s '%(python_exe_name, python_major, python_minor, python_micro))
self.oscillator = 1 # animates character on title
self.oscillator_B = 0 # used to return statusbar to statusbar_bg
self.lbframe = Frame( frame )
self.lbframe.pack(anchor=SE, side=LEFT, fill=BOTH, expand=1)
scrollbar = Scrollbar(self.lbframe, orient=VERTICAL)
self.Text_1 = Text(self.lbframe, width="80", height="24", yscrollcommand=scrollbar.set)
scrollbar.config(command=self.Text_1.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.Text_1.pack(side=LEFT, fill=BOTH, expand=1)
self.resizable(1,1) # Linux may not respect this
#===========
self.MainWin = MainWin
self.main_gui = main_gui
# only main window can close this window
self.protocol('WM_DELETE_WINDOW', self.cleanupOnQuit)
def Pass_Fail_Button_Click(self, event):
"""Place-holder routine for user clicking Pass/Fail Button"""
self.main_gui.Pass_Fail_Button_Click( event )
def reset_statusbar_bg(self):
"""Return status bar to default state"""
self.statusbar.config(bg=self.statusbar_bg)
def set_statusbar_bg(self, c):
"""Set status bar to show new color and message"""
self.statusbar.config(bg=c)
self.oscillator_B = 1 # will return to initial color after a few cycles
class LivePlots:
def __init__(self, master, controller):
#Font
LARGE_FONT = ("Verdana", 12)
self.x_max_lim = 20
#Set root component
self.master = master
self.master.title("Live Plot of Power bands")
#Set label
self.label1 = Label(self.master,
text="Workload detector",
font=LARGE_FONT,
width=30,
height=5)
self.label1.pack(pady=10, padx=10)
self.label1.config(bg="#fff000000")
# #Set init button
# self.button1 = Button(self.master, text="Start Animation", command=self.stop_start_animation)
# self.button1.pack()
#Create matplotlib graph
self.figure = plt.Figure(figsize=(6, 5), dpi=100)
self.ax = self.figure.add_subplot(111)
self.graph = FigureCanvasTkAgg(self.figure, self.master)
self.graph.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH)
self.ax.set_title('Live Plot')
self.ax.set_ylim(-0.3, 1.3)
self.ax.set_xlim(0, self.x_max_lim)
#Create data line
self.line = Line2D([0, 1, 2, 3, 4, 5], [1, 2, 4, 5, 6, 8])
self.line.set_linestyle('--')
self.line.set_marker('*')
self.line.set_markersize(2)
self.line.set_color('red')
self.line2 = Line2D([0, 1, 2, 3, 4, 5], [1, 2, 4, 5, 6, 8])
self.line2.set_linestyle('--')
self.line2.set_marker('*')
self.line2.set_markersize(2.0)
self.line2.set_color('blue')
self.ax.add_line(self.line)
self.ax.add_line(self.line2)
#Create animation logic and animation
self.logic = LivePlotLogic(controller,
axe=self.ax,
line=[self.line, self.line2],
maxt=self.x_max_lim,
workload_label=self.label1)
self.ani = animation.FuncAnimation(self.figure,
func=self.logic.update_animation,
frames=self.logic.check_data_queue,
init_func=self.logic.init_animation,
interval=10,
blit=True)
self.animationRunning = True
def stop_start_animation(self):
if self.animationRunning:
self.ani.event_source.stop()
self.animationRunning = False
else:
self.ani.event_source.start()
self.animationRunning = True
class Gui:
def __init__(self, root):
self.root = root
self.path = StringVar()
self.outpath = StringVar()
self.file_dir = ''
self.save_dir = ''
Label(self.root, text="").grid(row=0, column=0)
Label(self.root, text="原始文件:").grid(row=1, column=0)
Entry(self.root, textvariable=self.path, width=40).grid(row=1,
column=1)
Button(self.root, text="打开", command=self.selectPath).grid(row=1,
column=3)
Label(self.root, text="保存文件:").grid(row=2, column=0)
Entry(self.root, textvariable=self.outpath, width=40).grid(row=2,
column=1)
Button(self.root, text="保存",
command=self.select_outPath).grid(row=2, column=3)
self.lb = Label(self.root, text='欢迎 !')
self.lb.grid(row=3, column=1)
self.bt = Button(self.root, text="生成报告", command=self.run)
self.bt.grid(row=4, column=1)
self.write_ok = False
self.err = False
def selectPath(self):
self.file_dir = askdirectory()
self.save_dir = self.file_dir
self.path.set(self.file_dir)
self.outpath.set(self.file_dir)
self.err = False
# print(self.path)
# print(self.file_dir)
# print(self.save_dir)
def select_outPath(self):
self.save_dir = askdirectory()
self.outpath.set(self.save_dir)
def run(self):
self.lb.config(text="运行...")
th = threading.Thread(target=self.write)
th2 = threading.Thread(target=self.ui)
# th2.setDaemon(True)
th.start()
th2.start()
# for t in [th,th2]:
# t.join()
def ui(self):
if not self.write_ok:
self.bt.config(state='disabled')
# print(0)
while not self.write_ok:
time.sleep(6)
print(1)
self.bt.config(state='normal')
if not self.err:
self.lb.config(text="完成！")
def write(self):
self.write_ok = False
try:
# self.lb.config(text="running...")
doc = docx.Document() # 新建文档
doc.styles['Normal'].font.name = u'Times New Roman'
# doc.styles['Normal']._element.rPr.rFonts.set(qn('w:eastAsia'), u'宋体')
p = doc.add_paragraph('')
# p.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
r = p.add_run('荧光定量 PCR 检测报告')
print(self.file_dir)
doc.save(self.file_dir + r'/1.docx')
# self.lb.config(text="finished")
self.write_ok = True
# print('ok')
except Exception as e:
print(e)
self.err = True
self.lb.config(text="路径或文件错误！")
self.write_ok = True
class main_menu:
def __init__(self, root):
self.master = root
root.title("APA")
root.resizable(False, False)
root.geometry('320x160')
root.configure(background='#2B2B2B')
vname = root.register(self.name_entry)
self.label = Label(root,
text="APA FORMATTER",
bg='#4D4D4D',
fg='grey',
font='ariel 16 bold').place(
x=0,
y=0,
width=320,
height=40,
)
self.name = Label(root,
text='Name: ',
bg='#2B2B2B',
fg='white',
font='bold 10').place(x=10, y=60)
self.name = Entry(root,
validate="key",
validatecommand=(vname, '%P'),
bg='#2B2B2B',
fg='yellow',
font='bold 10')
self.name.place(x=100, y=60)
self.path = os.path.dirname(os.path.abspath(__file__))
self.dir = Label(root,
text='Directory:',
bg='#2B2B2B',
fg='white',
font='bold 10').place(x=10, y=90)
self.dir = Label(
root,
text=self.path,
bg='#2B2B2B',
fg='#F9F0D9',
font='bold 10',
)
self.dir.place(x=100, y=91)
self.browsebtn = Button(
text='BROWSE',
relief=RIDGE,
state=NORMAL,
bg='#2B2B2B',
fg='white',
font='bold 10',
command=lambda: [(APA_main_menu.select_path())])
self.browsebtn.place(x=65, y=125, width=80, height=30)
self.startbtn = Button(text='START',
relief=RIDGE,
state=DISABLED,
bg='#2B2B2B',
fg='white',
font='bold 10',
command=lambda: [(APA_main_menu.CLOSE(root),
APA_main_menu.START())])
self.startbtn.place(x=175, y=125, width=80, height=30)
def select_path(self):
self.path = filedialog.askdirectory()
if self.path == '':
self.path = os.path.dirname(os.path.abspath(__file__))
self.dir.config(text=self.path)
self.startbtn.config(state=NORMAL)
def CLOSE(self, root):
root.destroy()
def START(self):
from APA.GUI import GUI
def name_entry(self, name):
try:
self.name = name + '.docx'
if self.name != '':
main_menu.name = self.name
self.startbtn.config(state=NORMAL)
return True
else:
self.startbtn.config(state=DISABLED)
main_menu.name = ''
return True
except:
self.startbtn.config(state=DISABLED)
self.name = None
return False
class Button_(Widget_):
def __init__(self, parent_frame, x, y):
Widget_.__init__(self, parent_frame, x, y)
self.label_bg, self.label_fg = 'grey', 'white'
self.hover_bg, self.hover_fg = None, None
self.label = Label(self.widget_frame, bg=self.label_bg, fg=self.label_fg)
self.label.grid(row=0, column=1, ipadx=5, ipady=10)
def get_info(self):
return self.label.cget('text')
def set_hover(self):
def set_hover_bg(event):
self.label.config(bg=self.hover_bg, fg=self.hover_fg)
self.img.config(bg=self.hover_bg, fg=self.hover_fg)
def remove_hover_bg(event):
self.label.config(bg=self.label_bg, fg=self.label_fg)
self.img.config(bg=self.label_bg, fg=self.label_fg)
if hasattr(self, 'img'):
self.widget_frame.bind('<Enter>', set_hover_bg)
self.widget_frame.bind('<Leave>', remove_hover_bg)
else:
self.widget_frame.bind('<Enter>', lambda event: self.label.config(bg=self.hover_bg, fg=self.hover_fg))
self.widget_frame.bind('<Leave>', lambda event: self.label.config(bg=self.label_bg, fg=self.label_fg))
def settings(self, **kwargs):
''' all setting changes '''
if 'label_bg' in kwargs:
self.label_bg = kwargs['label_bg']
self.label.config(bg=self.label_bg)
if 'label_fg' in kwargs:
self.label_fg = kwargs['label_fg']
self.label.config(fg=self.label_fg)
if 'text' in kwargs:
self.label.config(text=kwargs['text'])
if 'font' in kwargs:
self.label.config(font=kwargs['font'])
if 'hover_bg' in kwargs:
self.hover_bg = kwargs['hover_bg']
self.hover_fg = self.label_fg if self.hover_fg == None else self.hover_fg
self.set_hover()
if 'hover_fg' in kwargs:
self.hover_fg = kwargs['hover_fg']
self.hover_bg = self.label_bg if self.hover_bg == None else self.hover_bg
self.set_hover()
if 'command' in kwargs:
self.command = kwargs['command']
self.label.bind('<Button-1>', lambda event: self.command())
if hasattr(self, 'img'):
self.img.bind('<Button-1>', lambda event: self.command())
if 'image' in kwargs:
self.img_path = kwargs['image']
self.picture = Image.open(self.img_path)
self.image = ImageTk.PhotoImage(self.picture)
self.img = Label(self.widget_frame, bg=self.label_bg, fg=self.label_fg)
self.img.grid(row=0, column=0, ipadx=5, ipady=5, columnspan=2, sticky=W)
self.img.config(image=self.image)
self.set_hover()
if hasattr(self, 'command'):
self.img.bind('<Button-1>', lambda event: self.command())
if 'image_resize' in kwargs:
self.picture = self.picture.resize(kwargs['image_resize'], Image.ANTIALIAS)
self.image = ImageTk.PhotoImage(self.picture)
self.img.config(image=self.image)
return
def estudianteControl(self, id=0):
mat = StringVar()
cedula = StringVar()
nom = StringVar()
apellido = StringVar()
self._imgfile = "profileIcon.png"
sex = StringVar()
idcarrera = StringVar()
idprovincia = StringVar()
filewin = Toplevel(self._master)
Label(filewin, text="Cecula").place(x=10, y=30)
Label(filewin, text="Nombre").place(x=10, y=60)
Label(filewin, text="Apellido").place(x=10, y=90)
Label(filewin, text="Sexo").place(x=10, y=120)
Label(filewin, text="Matricula").place(x=10, y=150)
Label(filewin, text="Carrera").place(x=10, y=180)
Label(filewin, text="Provincia").place(x=10, y=210)
canvas = Canvas(filewin, width=300, height=300).place(x=310, y=60)
img = ImageTk.PhotoImage(Image.open(self._imgfile))
photoLabel = Label(filewin, image=img)
photoLabel.place(x=320, y=60)
TxtBoxCedula = Entry(filewin, width=20,
textvariable=cedula).place(x=100, y=30)
TxtBoxNombre = Entry(filewin, width=20, textvariable=nom).place(x=100,
y=60)
TxtBoxApellido = Entry(filewin, width=20,
textvariable=apellido).place(x=100, y=90)
TxtBoxSexo = Entry(filewin, width=20, textvariable=sex).place(x=100,
y=120)
TxtBoxMatricula = Entry(filewin, width=20,
textvariable=mat).place(x=100, y=150)
CbBoxCarrera = ttk.Combobox(
filewin,
state='readonly',
textvariable=idcarrera,
values=self.get_dataCombo('CARRERA')).place(x=100, y=180)
CbBoxProvincia = ttk.Combobox(
filewin,
state='readonly',
textvariable=idprovincia,
values=self.get_dataCombo('PROVINCIA')).place(x=100, y=210)
botonInsertar = Button(filewin,
text="Insertar",
width=14,
command=lambda: self.insert_estudiante([
mat.get(),
nom.get(),
apellido.get(),
cedula.get(), self._imgfile,
sex.get(),
idprovincia.get(),
idcarrera.get()
])).place(x=10, y=240)
botonConsultar = Button(
filewin,
text="Consultar",
width=10,
command=lambda: self.estudianteDesdeApi(cedula.get(
), [nom, apellido, sex], photoLabel)).place(x=300, y=30)
#botonModificar=Button(filewin, text = "Modificar", width= 14,).place(x=120, y=120)
#botonBorrar=Button(filewin, text = "Borrar", width= 14, command= lambda:self.greet()).place(x=60, y=160)
if id != 0:
data = self._database.consultarById("ESTUDIANTE", "ID_ESTUDIANTE",
id)
print(data[0])
mat.set(data[1])
nom.set(data[2])
apellido.set(data[3])
cedula.set(data[4])
self._imgfile = data[5]
raw_data = urllib.request.urlopen(self._imgfile).read()
img = Image.open(io.BytesIO(raw_data))
photo = ImageTk.PhotoImage(img)
photoLabel.config(image=photo)
photoLabel.photo = photo
sex.set(data[6])
idprovincia.set(data[7])
idcarrera.set(data[8])
#end condition
filewin.geometry("450x280")
filewin.mainloop()
from tkinter import Tk, Frame, Label, PhotoImage
# Creacion de Raíz, Frame y Label
root = Tk()
frame = Frame(root, width = "500", height = "400")
label1 = Label(frame, text = "Hola Mundo!!")
# Configurando Raiz
root.iconbitmap("Img\\aprobar.ico")
root.title("Uso Label")
img = PhotoImage(file = "Img\\EnConstruccion.png")
# Configurando Label
label1.config(bg = "White", image = img)
label1.place(x = 100, y = 200)
""" Sintaxis alterna:
Label(frame, text = "Hola").place(x = 100, y = 200)
"""
# Configurando el Frame
frame.config(bg = "White")
frame.pack(fill = "both", expand = "True")
root.mainloop()
class App(object):
def __init__(self, master):
self.master = master
self.network = network.ChatClient(self)
self.conf = Configuration()
conf_values = self.conf.get_values()
self.create_window(master, conf_values)
self.debug = False
def config_window(self):
conf_values = self.conf.ask_config(self.master)
self.username.set(conf_values['username'])
self.server.set(conf_values['server'])
self.port.set(conf_values['port'])
image = Image.open(conf_values['icon']).resize((40, 40),
Image.ANTIALIAS)
self.image = ImageTk.PhotoImage(image)
self.lbl_image.configure(image=self.image)
def open_connection(self):
server = self.server.get()
port = self.port.get()
username = self.username.get()
self.network.open_connection(server, int(port), username)
self.disable_connect_button()
self.disable_conf_button()
self.disable_conf_info()
self.enable_message_textbox()
def close_connection(self):
self.clear_user_list()
self.enable_connect_button()
self.enable_conf_button()
self.enable_conf_info()
self.disable_message_textbox()
self.disable_features()
def send_message(self, dummy=''):
'''The dummy parameter ignores the parameter that automatically is
added when the RETURN is pressed to send a message.'''
username = self.network.username
msg = self.txt_msg.get()
self.txt_msg.delete(0, 'end')
if not msg.strip():
return
self.network.send_message(msg)
self.write_message(username, msg, True)
def write_message(self, sender, message, own=False):
sender_format = 'username' if own else 'sender'
self.bt_send.config(state=DISABLED)
now = datetime.now()
timestamp = now.strftime('%H:%M:%S')
self.txt_chat.config(state=NORMAL)
self.txt_chat.insert(END, ' ' + str(sender) + '\n', sender_format)
self.txt_chat.insert(END, message + ' \n', 'message')
self.txt_chat.insert(END, timestamp + ' \n', 'timestamp')
self.txt_chat.insert(END, '\n\n', 'newline')
self.txt_chat.see(END)
self.txt_chat.config(state=DISABLED)
self.txt_chat.focus()
def write_own_file(self, username, file_name):
now = datetime.now()
format = now.strftime('%H:%M:%S')
self.txt_chat.config(state=NORMAL)
self.txt_chat.insert(END, ' ' + username + '\n', 'username')
self.txt_chat.insert(END, 'File sent: ' + file_name + '\n', 'file')
self.txt_chat.insert(END, format + ' \n', 'timestamp')
self.txt_chat.insert(END, '\n\n', 'newline')
self.txt_chat.see(END)
self.txt_chat.config(state=DISABLED)
def write_file(self, sender, file_name, code):
now = datetime.now()
format = now.strftime('%H:%M:%S')
self.txt_chat.config(state=NORMAL)
self.txt_chat.insert(END, ' ' + sender + '\n', 'sender')
button = Button(self.txt_chat, text='Download', cursor='hand2')
button.configure(
command=(lambda b=button, c=code: self.ask_file(b, c)))
button.config(relief=FLAT,
bg='gray13',
fg='white',
borderwidth=1,
highlightthickness=0)
self.txt_chat.insert(END, ' ' + file_name + ' ', 'file')
self.txt_chat.window_create(INSERT, align=CENTER, window=button)
self.txt_chat.insert(END, ' \n', 'message')
self.txt_chat.insert(END, format + ' \n', 'timestamp')
self.txt_chat.insert(END, '\n\n', 'newline')
self.txt_chat.see(END)
self.txt_chat.config(state=DISABLED)
def ask_file(self, button, code):
self.network.ask_file(code)
def file_received(self, data):
with open(self.file_name, 'wb') as fh:
fh.write(data)
def enable_send(self, event):
self.bt_send.config(state=ACTIVE)
def disable_send(self, event):
self.bt_send.config(state=DISABLED)
def add_user_to_list(self, username):
self.lb_users.insert(END, ' ' + username)
def clear_user_list(self):
self.lb_users.delete(0, 'end')
def enable_features(self, features):
color = 'green' if features['FILE'] else 'red'
self.lbl_file['text'] = 'FILE'
self.lbl_file.config(fg=color)
if features['FILE']:
self.bt_file.config(state=NORMAL)
color = 'green' if features['CEN'] else 'red'
self.lbl_cen['text'] = 'CEN'
self.lbl_cen.config(fg=color)
color = 'green' if features['NOP'] else 'red'
self.lbl_nop['text'] = 'NOP'
self.lbl_nop.config(fg=color)
color = 'green' if features['TLS'] else 'red'
self.lbl_tls['text'] = 'TLS'
self.lbl_tls.config(fg=color)
if features['TLS']:
self.lbl_tls.bind('<Button-1>', self.request_tls)
def request_tls(self, event):
self.network.ask_tls()
def send_file(self):
file_name = filedialog.askopenfilename(title='Select file')
if file_name:
self.network.send_file(file_name)
def sizeof_fmt(self, num):
for unit in ['B', 'KiB', 'MiB', 'GiB']:
if num < 1024.0:
return "{:.2f} {}".format(num, unit)
num /= 1024.0
return "{:.2f} {}" % (num, 'TiB')
def get_file_confirmation(self, num_bytes):
threshold = 2**20 # 1 MiB
if num_bytes > threshold:
size = self.sizeof_fmt(num_bytes)
question = 'The file size is {}. Are you sure you want to '
question += 'download it?'
confirmed = messagebox.askyesno('Download confirmation',
question.format(size))
if num_bytes <= threshold or confirmed:
file_name = filedialog.asksaveasfilename(title='Select file')
if file_name:
self.file_name = file_name
return True
return False
def set_tls(self):
self.lbl_tls.config(fg='yellow')
self.lbl_tls.unbind('<Button-1>')
def disable_features(self):
self.lbl_file.config(bg='black', fg='black')
self.lbl_cen.config(bg='black', fg='black')
self.lbl_nop.config(bg='black', fg='black')
self.lbl_tls.config(bg='black', fg='black')
def set_nop(self):
self.lbl_nop.config(fg='yellow')
self.master.after(2000, self.unset_nop)
def unset_nop(self):
self.lbl_nop.config(fg='green')
def print_debug(self, info):
self.debug_info.set(info)
if self.debug:
self.lbl_debug.config(fg='green')
self.master.after(2000, self.reset_debug_color)
def print_debug_info(self, info):
original = self.debug_info.get()
self.debug_info.set(original + ' [' + info + ']')
def print_info(self, info):
self.info.set(info)
self.master.after(2000, self.delete_info)
def delete_info(self):
self.info.set('')
def reset_debug_color(self):
self.lbl_debug.config(fg='white')
def toggle_debug(self):
if self.debug:
self.lbl_debug.config(background='black', fg='black')
else:
self.lbl_debug.config(background='gray13', fg='white')
self.debug = not self.debug
def close(self):
self.network.finish()
def disable_conf_info(self):
self.lbl_username.config(fg='green')
self.txt_username.config(state=DISABLED)
self.lbl_server.config(fg='green')
self.txt_server.config(state=DISABLED)
self.lbl_port.config(fg='green')
self.txt_port.config(state=DISABLED)
def enable_conf_info(self):
self.lbl_username.config(fg='red')
self.txt_username.config(state=NORMAL)
self.lbl_server.config(fg='red')
self.txt_server.config(state=NORMAL)
self.lbl_port.config(fg='red')
self.txt_port.config(state=NORMAL)
def disable_connect_button(self):
self.bt_connect.config(state=DISABLED)
def enable_connect_button(self):
self.bt_connect.config(state=NORMAL)
def disable_conf_button(self):
self.bt_config.config(state=DISABLED)
def enable_conf_button(self):
self.bt_config.config(state=NORMAL)
def disable_message_textbox(self):
self.txt_msg.config(state=DISABLED)
def enable_message_textbox(self):
self.txt_msg.config(state=NORMAL)
def key_pressed(self, event):
msg = self.txt_msg.get()
# The pressed key is not appended to msg yet,
# but can be found in event.char.
# If a control key is pressed event.char is empty.
# '\x08' is the backspace character.
if len(msg) == 0 and event.char and event.char != '\x08':
self.network.send_typing()
def create_window(self, master, conf):
master.geometry('700x500')
frame = Frame(master)
frame.config(bg='black')
master.title('SZA-SAR')
frame.pack(fill=BOTH, expand=True)
fr_config = Frame(frame,
bg='black',
borderwidth=1,
highlightbackground='white',
relief=FLAT)
fr_config.grid(row=0, column=0, padx=5, pady=1, sticky=W + E)
image = Image.open(conf['icon']).resize((40, 40), Image.ANTIALIAS)
self.image = ImageTk.PhotoImage(image)
self.lbl_image = Label(fr_config, image=self.image)
self.lbl_image.grid(row=0,
column=0,
rowspan=3,
padx=5,
pady=5,
sticky=W)
self.username = StringVar()
self.server = StringVar()
self.port = StringVar()
self.lbl_username = Label(fr_config, text='User', bg='black', fg='red')
self.lbl_username.grid(row=0, column=1, padx=5, pady=1, sticky=W)
self.lbl_server = Label(fr_config, text='Server', bg='black', fg='red')
self.lbl_server.grid(row=1, column=1, padx=5, pady=1, sticky=W)
self.lbl_port = Label(fr_config, text='Port', bg='black', fg='red')
self.lbl_port.grid(row=2, column=1, padx=5, pady=1, sticky=W)
self.txt_username = Entry(fr_config,
textvariable=self.username,
bg='black',
fg='red',
width=10)
self.txt_username.grid(row=0, column=2, padx=5, pady=1, sticky=W)
self.txt_server = Entry(fr_config,
textvariable=self.server,
bg='black',
fg='red',
width=10)
self.txt_server.grid(row=1, column=2, padx=5, pady=1, sticky=W)
self.txt_port = Entry(fr_config,
textvariable=self.port,
bg='black',
fg='red',
width=10)
self.txt_port.grid(row=2, column=2, padx=5, pady=1, sticky=W)
self.username.set(conf['username'])
self.server.set(conf['server'])
self.port.set(conf['port'])
frame.columnconfigure(1, weight=1)
frame.rowconfigure(1, weight=1)
fr_features = Frame(frame)
fr_features.config(bg='black')
fr_features.grid(row=4,
column=0,
columnspan=1,
sticky=W + E,
pady=2,
padx=5)
self.lbl_file = Label(fr_features, font='Helvetica 9 bold')
self.lbl_cen = Label(fr_features, font='Helvetica 9 bold')
self.lbl_nop = Label(fr_features, font='Helvetica 9 bold')
self.lbl_tls = Label(fr_features, font='Helvetica 9 bold')
self.lbl_file.grid(row=0,
column=0,
columnspan=1,
sticky=W + E,
pady=2,
padx=5)
self.lbl_file.config(bg='black', fg='white')
self.lbl_cen.grid(row=0,
column=1,
columnspan=1,
sticky=W + E,
pady=2,
padx=5)
self.lbl_cen.config(bg='black', fg='white')
self.lbl_nop.grid(row=0,
column=2,
columnspan=1,
sticky=W + E,
pady=2,
padx=5)
self.lbl_nop.config(bg='black', fg='white')
self.lbl_tls.grid(row=0,
column=3,
columnspan=1,
sticky=W + E,
pady=2,
padx=5)
self.lbl_tls.config(bg='black', fg='white')
fr_info = Frame(frame, bg='black', borderwidth=1, relief=FLAT)
fr_info.grid(row=0,
column=1,
columnspan=2,
padx=5,
pady=1,
sticky=W + E)
self.info = StringVar()
self.lbl_info = Label(fr_info,
textvariable=self.info,
width=80,
anchor='w')
self.lbl_info.grid(row=0, column=0, pady=2, padx=5)
self.lbl_info.config(background='gray13', fg='white')
self.debug_info = StringVar()
self.lbl_debug = Label(fr_info,
textvariable=self.debug_info,
width=80,
anchor='w')
self.lbl_debug.grid(row=1, column=0, sticky=W + E, pady=2, padx=5)
self.lbl_debug.config(background='black', fg='black')
fr_buttons = Frame(frame,
bg='black',
borderwidth=1,
background='black',
relief=FLAT)
fr_buttons.grid(row=0,
column=3,
columnspan=1,
padx=5,
pady=1,
sticky=W + E)
self.bt_connect = Button(fr_buttons,
text='Connect',
width=5,
command=self.open_connection)
self.bt_connect.grid(row=0, column=0, sticky=E, pady=2, padx=5)
self.bt_connect.config(relief=FLAT,
bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0)
self.bt_config = Button(fr_buttons,
text='Conf',
width=5,
command=self.config_window)
self.bt_config.grid(row=1, column=0, sticky=W + E, pady=2, padx=5)
self.bt_config.config(relief=FLAT,
bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0)
self.bt_debug = Button(fr_buttons,
text='Debug',
width=5,
command=self.toggle_debug)
self.bt_debug.grid(row=0, column=1, sticky=E, pady=2, padx=0)
self.bt_debug.config(relief=FLAT,
bg='gray13',
activeforeground='white',
fg='white',
borderwidth=0,
highlightthickness=0)
self.bt_close = Button(fr_buttons,
text='Close',
width=5,
command=self.close)
self.bt_close.grid(row=1, column=1, sticky=W + E, pady=2, padx=0)
self.bt_close.config(relief=FLAT,
bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0)
self.lb_users = Listbox(frame)
self.lb_users.grid(row=1,
column=0,
rowspan=3,
pady=5,
padx=5,
sticky=S + N + E + W)
self.lb_users.config(bg='gray18',
borderwidth=1,
highlightbackground='gray15',
highlightthickness=1,
fg='white',
relief='solid')
self.txt_chat = scrolledtext.ScrolledText(frame)
self.txt_chat.grid(row=1,
column=1,
columnspan=3,
rowspan=3,
pady=5,
padx=5,
sticky=E + W + S + N)
self.txt_chat.config(bg='gray18',
borderwidth=0,
highlightbackground='gray15',
highlightthickness=1,
relief='solid',
padx=10,
pady=5,
font=('', 10))
self.txt_chat.vbar.config(troughcolor='black', bg='gray18')
self.txt_chat.tag_config('sender',
background='gray30',
foreground='brown1',
justify=RIGHT,
font=('Bold', 10))
self.txt_chat.tag_config('username',
background='gray30',
foreground='olive drab',
justify=LEFT,
font=('Bold', 10))
self.txt_chat.tag_config('timestamp',
background='gray30',
foreground='black',
justify=RIGHT,
font=('Bold', 8))
self.txt_chat.tag_config('message',
background='gray30',
foreground='white',
justify=RIGHT,
font=('Bold', 10))
self.txt_chat.tag_config('file',
background='red4',
foreground='white',
justify=RIGHT,
font=('Bold', 10))
self.txt_chat.tag_config('newline',
background='gray18',
foreground='gray18',
justify=RIGHT,
font=('Bold', 4))
self.txt_chat.config(state=DISABLED)
self.txt_msg = Entry(frame)
self.txt_msg.grid(row=4,
column=1,
rowspan=1,
columnspan=1,
sticky=E + W + S + N,
padx=5,
pady=2)
self.txt_msg.config(bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0,
insertbackground='white',
state=DISABLED)
self.txt_msg.bind('<Key>', self.key_pressed)
self.txt_msg.bind('<FocusIn>', self.enable_send)
self.txt_msg.bind('<FocusOut>', self.disable_send)
self.txt_msg.bind('<Return>', self.send_message)
fr_buttons_send = Frame(frame,
bg='black',
borderwidth=1,
background='black',
relief=FLAT)
fr_buttons_send.grid(row=4,
column=2,
columnspan=2,
padx=5,
pady=1,
sticky=W + E)
self.bt_send = Button(fr_buttons_send,
text='Send',
width=5,
command=self.send_message)
self.bt_send.grid(row=0, column=0, sticky=E + W, pady=0, padx=5)
self.bt_send.config(relief=FLAT,
bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0,
state=DISABLED)
self.bt_file = Button(fr_buttons_send,
text='File',
width=5,
command=self.send_file)
self.bt_file.grid(row=0, column=1, sticky=E + W, pady=0, padx=0)
self.bt_file.config(relief=FLAT,
bg='gray13',
fg='white',
borderwidth=0,
highlightthickness=0,
state=DISABLED)
master.protocol('WM_DELETE_WINDOW', self.close)
class GUI:
def __init__(self, master):
self.valves = self.get_valves()
self.master = master
self.master.configure(bg='sky blue')
self.password = '******'
self.momentary = Momentary(self.master, self.valves)
self.edit = Edit(self.master, self.valves)
self.summary = Summary(self.master, self.valves)
self.preferences = Preferences(self.master, self.valves)
self.run_screen = RunScreen(self.master, self.valves)
self.header = self.make_header(self.master)
self.home = self.home_page(self.master)
self.frame = self.home
def make_header(self, master):
header = Frame(master, bg='sky blue')
self.label = StringVar()
self.label.set('NONE')
self.start_label = StringVar()
self.start_label.set('START')
self.lock_label = StringVar()
self.lock_label.set('LOCKED')
self.title = Label(header, textvariable=self.label, pady=20, font=('Lucida Console', 50))
self.title.config(bg='sky blue', fg='RoyalBlue4')
self.run_image = PhotoImage(file="img/animate.png").subsample(x=5, y=5)
self.run_button = Button(header, image=self.run_image, command=self.run, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.start_button = Button(header, textvariable=self.start_label, font=('Lucida Console', 30), command=self.start_stop, height=5)
self.start_button.config(bg='brown3', activebackground='brown4', fg='white', activeforeground='white', width=10, border=5)
self.save_image = PhotoImage(file="img/save.png").subsample(x=5, y=5)
self.save_button = Button(header, image=self.save_image, command=self.save, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.save_button.config(state='disabled')
self.reset_image = PhotoImage(file="img/reset.png").subsample(x=5, y=5)
self.reset_button = Button(header, image=self.reset_image, command=self.reset, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.home_image = PhotoImage(file="img/home.png").subsample(x=5, y=5)
self.home_button = Button(header, image=self.home_image, command=self.to_home, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.locked_image = PhotoImage(file="img/lock.png").subsample(x=5, y=5)
self.unlocked_image = PhotoImage(file="img/unlock.png").subsample(x=5, y=5)
self.lock_button = Button(header, image=self.locked_image, command=self.lock, bg='SkyBlue4', activebackground='midnight blue', border=5, textvariable=self.lock_label)
return header
def home_page(self, master):
frame = Frame(master)
frame.grid(row=0, column=0)
image = PhotoImage(file="img/guido.gif")
bg = Label(frame, image=image)
bg.image = image
bg.grid(row=0, column=0, rowspan=4, columnspan=2)
index = 0
while index < 3:
frame.grid_columnconfigure(index, minsize=200)
frame.grid_rowconfigure(index, minsize=80)
index += 1
summary_button = HomeButton(frame, self.to_summary, 'img/summary.png')
summary_button.grid(row=0, column=0, sticky='w')
edit_button = HomeButton(frame, self.to_edit, 'img/edit.png')
edit_button.grid(row=0, column=1, sticky='e')
momentary_button = HomeButton(frame, self.to_momentary, 'img/momentary.png')
momentary_button.grid(row=1, column=0, sticky='w')
preferences_button = HomeButton(frame, self.to_pref, 'img/preferences.png')
preferences_button.grid(row=1, column=1, sticky='e')
music = HomeButton(frame, self.to_summary, 'img/music.png')
music.grid(row=2, column=0, sticky='w')
info = HomeButton(frame, self.to_summary, 'img/info.png')
info.grid(row=2, column=1, sticky='e')
return frame
# CSV file input
def get_valves(self):
valves = [Valve('VALVE 1', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 2', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 3', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 4', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 5', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 6', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 7', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 8', 'DEFAULT', 'Action A', 'Action B', [0, 0])]
file = open('data.csv', 'rt', newline='')
try:
reader = csv.reader(file, lineterminator='\n')
index = 0
for row in reader:
if index == 0:
index += 1
continue
else:
run = int(row[4])
delay = int(row[5])
interval = [run, delay]
valves[index - 1] = Valve(row[0], row[1], row[2], row[3], interval)
index += 1
finally:
file.close()
return valves
def lock(self):
if self.lock_label.get() == 'LOCKED':
window = Toplevel()
window.geometry('318x550')
self.keypad = Keypad(window, self, self.password)
else:
self.save_button.config(state='disabled')
self.edit.lock()
self.preferences.lock()
self.lock_label.set('LOCKED')
self.lock_button.config(image=self.locked_image)
def save(self):
self.save_pref()
self.save_edit()
def save_edit(self):
file = open('data.csv', 'w')
interval = self.edit.get_intervals()
try:
writer = csv.writer(file, lineterminator='\n')
writer.writerow(('Name', 'Setting', 'Action A', 'Action B', 'Runtime', 'Delaytime'))
index = 0
for i in self.valves:
i.set_interval([interval[index].get(), interval[index + 8].get()])
valve_interval = i.get_interval()
if self.edit.plusInterval[index].cget('state') == 'disabled' and self.edit.motor[index].cget('state') != 'disabled':
i.set_setting('MOTOR')
writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), 0, 0))
elif interval[index].get() is 0:
i.set_setting('INACTIVE')
writer.writerow((i.get_name().get(), i.get_setting(), 'NONE', 'NONE', 0, 0))
else:
i.set_setting('DEFAULT')
writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), valve_interval[0], valve_interval[1]))
index += 1
finally:
file.close()
# must fix
def save_pref(self):
index = 0
for i in self.valves:
num = index * 3
if self.preferences.entry_field[num].get():
i.set_name(self.preferences.entry_field[num].get())
self.preferences.entry_field[num].delete(0, 'end')
if self.preferences.entry_field[num + 1].get():
i.set_action_a(self.preferences.entry_field[num + 1].get())
self.preferences.entry_field[num + 1].delete(0, 'end')
if self.preferences.entry_field[num + 2].get():
i.set_action_b(self.preferences.entry_field[num + 2].get())
self.preferences.entry_field[num + 2].delete(0, 'end')
index += 1
def start_stop(self):
if self.start_label.get() == 'START':
self.start_label.set('STOP')
self.master.update()
self.run_screen.run_all(True)
self.home_button.config(state='disabled')
else:
self.start_label.set('START')
self.run_screen.run_all(False)
self.home_button.config(state='normal')
def run(self):
self.summary.grid_remove()
self.run_button.pack_forget()
self.run_screen.make_frame()
self.frame = self.run_screen
self.frame.grid(row=0, column=0)
self.header.grid(row=0, column=1)
self.label.set('RUN')
self.title.pack(side='top')
self.start_button.pack()
self.home_button.pack(side='bottom')
def to_home(self):
self.momentary.end_all()
self.momentary.delete_frame()
self.lock_button.pack_forget()
self.run_button.pack_forget()
self.save_button.pack_forget()
self.reset_button.pack_forget()
self.home_button.pack_forget()
self.start_button.pack_forget()
self.preferences.grid_remove()
self.frame.grid_remove()
self.header.grid_remove()
self.frame = self.home
self.frame.grid(row=0, column=0)
def to_summary(self):
self.frame.grid_remove()
self.label.set('SUMMARY')
self.home_button.pack(side='right')
self.run_button.pack(side='right')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.title.pack(side='left')
self.summary = Summary(self.master, self.valves)
self.frame = self.summary
self.frame.grid(row=1, column=0)
def to_edit(self):
self.frame.grid_remove()
self.label.set('EDIT PROGRAM')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.home_button.pack(side='right')
self.save_button.pack(side='right')
self.lock_button.pack(side='right')
self.reset_button.pack(side='right')
self.title.pack(side='left')
self.frame = self.edit
self.frame.grid(row=1, column=0)
def to_momentary(self):
self.frame.grid_forget()
self.label.set('MOMENTARY')
self.header.grid(row=0, column=0, columnspan=12, sticky='ew')
self.title.pack(side='left')
self.home_button.pack(side='right')
self.momentary.make_frame()
def to_pref(self):
self.frame.grid_remove()
self.label.set('PREFERENCES')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.home_button.pack(side='right')
self.save_button.pack(side='right')
self.lock_button.pack(side='right')
self.reset_button.pack(side='right')
self.title.pack(side='left')
self.frame = self.preferences
self.frame.grid(row=1, column=0)
def reset(self):
self.master.quit()
def access_granted(self):
self.lock_label.set('UNLOCKED')
self.lock_button.config(image=self.unlocked_image)
self.save_button.config(state='normal')
index = 0
while index < 8:
self.edit.minusInterval[index].config(state='normal')
self.edit.minusDelay[index].config(state='normal')
self.edit.plusInterval[index].config(state='normal')
self.edit.plusDelay[index].config(state='normal')
self.edit.motor[index].config(state='normal')
self.edit.adv[index].config(state='normal')
index += 1
for each in self.preferences.entry_field:
each.config(state='normal')
self.edit.set_seconds()
self.save_button.config(state='normal')
from tkinter import Tk, Label, Button
root = Tk()
root.title("MY GRAPHICS")
msg = Label(root, text="WELCOME TO SRET")
msg.config(font=("Cloister Black", 50, "underline", "italic", "bold"))
msg.pack()
msg_button = Button(root, text="EXIT", command=root.destroy)
msg_button.config(font=("Cloister Black", 18, "underline", "bold"))
def ask():
print("WELCOME TO PYTHON CLASS")
msg_button1 = Button(root, text="SIGN UP ", command=ask)
msg_button1.config(font=("Notre Dame", 18, "underline", "bold"))
msg_button1.pack()
msg_button.pack()
root.mainloop()
class PyZilla(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title('PyZilla')
self.padding = 5
self.pack(fill=BOTH, expand=1)
# Create a menubar
mnuMenu = Menu(self.parent)
self.parent.config(menu=mnuMenu)
# Create menubar
mnuFileMenu = Menu(mnuMenu)
# Add File menu items
mnuFileMenu.add_command(label='Open', command=self.onBtnOpenFile)
mnuFileMenu.add_command(label='Exit', command=self.quit)
# Add File menu items to File menu
mnuMenu.add_cascade(label='File', menu=mnuFileMenu)
# Create frame for all the widgets
frame = Frame(self)
frame.pack(anchor=N, fill=BOTH)
# Create file open dialog
btnOpenFile = Button(frame, text="Load file", command=self.onBtnOpenFile)
btnOpenFile.pack(side=RIGHT, pady=self.padding)
# Create filename label
self.lblFilename = Label(frame, text='No filename chosen...')
self.lblFilename.pack(side=LEFT, pady=self.padding, padx=self.padding)
# Create the text widget for the results
self.txtResults = Text(self)
self.txtResults.pack(fill=BOTH, expand=1, pady=self.padding, padx=self.padding)
def onBtnOpenFile(self):
ftypes = [('XML files', '*.xml'), ('All Files', '*')]
filename = filedialog.askopenfilename(initialdir='~', title='Choose the file', filetypes=ftypes)
# If a file was selected
if filename != '':
self.lblFilename.config(text=filename)
text = self.decode(filename)
self.txtResults.insert(END, text)
def decode(self, filename):
# Parse the sitemanager.xml file
doc = parse(filename)
text = ''
# Loop over Server keys
for server in doc.getElementsByTagName('Server'):
for pword in server.getElementsByTagName('Host'):
text += 'Host: %s\n' % pword.firstChild.nodeValue
for pword in server.getElementsByTagName('Pass'):
# base64 decode the password before printing
text += 'Password: %s\n\n' % base64.b64decode(pword.firstChild.nodeValue)
return text
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title("EGUANA")
self.style = ttk.Style()
self.style.theme_use("alt")
self.photoName = "eguana.gif"
self.frame = Frame(self, relief=FLAT, borderwidth=10,bg='#FADC46')
self.frame.pack(fill=BOTH, expand=True)
self.pack(fill=BOTH, expand=True)
self.setupMenuBar()
self.setupTopBar()
def setupMenuBar(self):
self.menubar = EguanaMenu(self.parent,self)
self.parent.config(menu=self.menubar)
def setupTopBar(self):
self.openButton3D = Button(self.frame,text="Select Directory for 3D EMA",relief=RAISED,command=self.askDirectory)
self.openButton3D.grid(row=0,column=0, sticky=N+S+E+W,padx=2,pady =2)
self.openButton2D = Button(self.frame,text="Select Directory for 2D EMA",relief=RAISED,command=self.askDirectory);
self.openButton2D.grid(row=2,column=2, sticky=N+S+E+W,padx=2,pady =2)
self.p1Button = Button(self.frame,text="Placeholder",relief=RAISED)
self.p1Button.grid(row=0,column=1, sticky=N+S+E+W,padx=2,pady =2)
self.p2Button = Button(self.frame,text="Placeholder",relief=RAISED)
self.p2Button.grid(row=0,column=2, sticky=N+S+E+W,padx=2,pady =2)
self.p3Button = Button(self.frame,text="Placeholder",relief=RAISED)
self.p3Button.grid(row=1,column=0, sticky=N+S+E+W,padx=2,pady =2)
self.p4Button = Button(self.frame,text="Placeholder",relief=RAISED)
self.p4Button.grid(row=1,column=2, sticky=N+S+E+W,padx=2,pady =2)
self.p5Button = Button(self.frame,text="Placeholder",relief=RAISED)
self.p5Button.grid(row=2,column=0, sticky=N+S+E+W,padx=2,pady =2)
self.p6Button = Button(self.frame,text="Placeholder",relief=RAISED)
self.p6Button.grid(row=2,column=1, sticky=N+S+E+W,padx=2,pady =2)
self.openButton3D.bind('<Motion>',self.cursorPosition)
self.openButton2D.bind('<Motion>',self.cursorPosition)
self.photo = PhotoImage(file="eguana.gif")
self.photo = self.photo.subsample(2);
self.photo_label = Label(self.frame,image=self.photo,borderwidth=0,highlightthickness=0)
self.photo_label.configure(bg='#FADC46')
self.photo_label.grid(row=1,column=1, sticky=N+S+E+W,padx=2,pady =2)
self.photo_label.image = self.photo
self.frame.columnconfigure(0, weight=1)
self.frame.columnconfigure(1, weight=1)
self.frame.columnconfigure(2, weight=1)
self.frame.rowconfigure(0, weight=1)
self.frame.rowconfigure(1, weight=1)
self.frame.rowconfigure(2, weight=1)
def askDirectory(self):
dirStr = filedialog.askdirectory()
if len(dirStr):
self.openButton3D.destroy()
self.openButton2D.destroy()
self.p1Button.destroy()
self.p2Button.destroy()
self.p3Button.destroy()
self.p4Button.destroy()
self.p5Button.destroy()
self.p6Button.destroy()
self.menubar.entryconfigure('Filter', state = 'active')
self.photo_label.destroy()
dirStr = 'Input Path : '+dirStr
self.frame.grid_forget()
self.infoFrame = Frame(self.frame, relief=FLAT, bg='#FADC46')
self.infoFrame.grid(row=0,column=0,columnspan=3, sticky=N+S+E+W,padx=2,pady =2)
self.directoryLabel = Label(self.infoFrame, text="No project currently selected",relief=FLAT)
self.directoryLabel.grid(row=0,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.directoryLabel.config(text=dirStr)
self.outputDirButton = Button(self.infoFrame,text="No output directory selected. Click to select an output directory ",relief=RAISED,fg='red',command=self.askOutputDirectory)
self.outputDirButton.grid(row=1,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton = Button(self.infoFrame,text="No filter selected. Click to select a filter",relief=RAISED,fg='red',command=self.selectFilter)
self.filterButton.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.trialLabel = Label(self.infoFrame,text="Trial Number",relief=FLAT,justify=RIGHT,anchor=E)
self.trialLabel.grid(row=3,column=0, sticky=N+S+E+W,padx=2,pady =2)
vcmd = (self.master.register(self.validate),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
self.trialEntry = Entry(self.infoFrame,validate = 'key', validatecommand = vcmd)
self.trialEntry.grid(row=3,column=1, sticky=N+S+E+W,padx=2,pady =2)
self.infoFrame.columnconfigure(0, weight=1)
self.infoFrame.columnconfigure(1, weight=1)
self.infoFrame.rowconfigure(0, weight=1)
self.infoFrame.rowconfigure(1, weight=1)
self.infoFrame.rowconfigure(2, weight=1)
self.infoFrame.rowconfigure(3, weight=1)
self.showPlotTools()
def validate(self, action, index, value_if_allowed,
prior_value, text, validation_type, trigger_type, widget_name):
if len(value_if_allowed)==0 :
return True
if text in '0123456789.-+ ':
try:
float(value_if_allowed)
return True
except ValueError:
return False
else:
return False
def askOutputDirectory(self):
dirStr = filedialog.askdirectory()
if len(dirStr):
dirStr = 'Output Path : '+dirStr
self.outputDirButton.destroy()
self.outputDirLabel = Label(self.infoFrame, relief=FLAT)
self.outputDirLabel.grid(row=1,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.outputDirLabel.config(text=dirStr)
def showPlotTools(self):
f2= Frame(self.frame, relief=FLAT,bg='#FADC46')
f2.grid(row=1,column=0,rowspan=2,columnspan=3,sticky=N+S+E+W,padx=10,pady =10)
b1 = Button(f2,text='3D K',relief=RAISED,command= lambda:self.plotButtonPressed(1))
b1.grid(row=0, column=0,sticky=N+S+E+W,padx=5,pady =5)
b2 = Button(f2,text='3D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(2))
b2.grid(row=0, column=1,sticky=N+S+E+W,padx=5,pady =5)
b3 = Button(f2,text='3D DP',relief=RAISED,command=lambda:self.plotButtonPressed(3))
b3.grid(row=0, column=2,sticky=N+S+E+W,padx=5,pady =5)
b4 = Button(f2,text='2D K',relief=RAISED,command=lambda:self.plotButtonPressed(4))
b4.grid(row=1, column=0,sticky=N+S+E+W,padx=5,pady =5)
b5 = Button(f2,text='2D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(5))
b5.grid(row=1, column=1,sticky=N+S+E+W,padx=5,pady =5)
b6 = Button(f2,text='2D DP',relief=RAISED,command=lambda:self.plotButtonPressed(6))
b6.grid(row=1, column=2,sticky=N+S+E+W,padx=5,pady =5)
f2.columnconfigure(0, weight=1)
f2.columnconfigure(1, weight=1)
f2.columnconfigure(2, weight=1)
f2.rowconfigure(0, weight=1)
f2.rowconfigure(1, weight=1)
def plotButtonPressed(self,number):
trialNum = self.trialEntry.get()
try:
trialNum = float(trialNum)
if trialNum < 16 and trialNum > 0:
self.plotFigure(number)
return True
else:
messagebox.showerror(
"Trial Number Error",
"The trial number is out of range"
)
return False
except ValueError:
messagebox.showerror(
"Trial Number Error",
"Error with the trial number"
)
return False
def plotFigure(self,number):
m = CoilNumDialog(self.frame)
if m.isSet():
print(m.getValues())
def selectFilter(self):
self.top = FilterPopup(self);
def speech3DButtonPressed(self):
self.menubar.filterSelected(0)
self.top.destroy()
if hasattr(self, 'filterLabel'):
self.filterLabel.config(text="Filter : speech3D")
else:
self.filterLabel = Label(self.infoFrame, text="Filter : speech3D",relief=FLAT)
self.filterLabel.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton.destroy()
def speech2DButtonPressed(self):
self.menubar.filterSelected(1)
self.top.destroy()
if hasattr(self, 'filterLabel'):
self.filterLabel.config(text="Filter : speech2D")
else:
self.filterLabel = Label(self.infoFrame, text="Filter : speech2D ",relief=FLAT)
self.filterLabel.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton.destroy()
def swallow3DButtonPressed(self):
self.menubar.filterSelected(2)
self.top.destroy()
if hasattr(self, 'filterLabel'):
self.filterLabel.config(text="Filter : swallow3D")
else:
self.filterLabel = Label(self.infoFrame, text="Filter : swallow3D ",relief=FLAT)
self.filterLabel.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton.destroy()
def swallow2DButtonPressed(self):
self.menubar.filterSelected(3)
self.top.destroy()
if hasattr(self, 'filterLabel'):
self.filterLabel.config(text="Filter : swallow2D")
else:
self.filterLabel = Label(self.infoFrame, text="Filter : swallow2D ",relief=FLAT)
self.filterLabel.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton.destroy()
def changeImage(self):
self.photo = PhotoImage(file=self.photoName)
self.photo = self.photo.subsample(2);
self.photo_label.image = self.photo
self.photo_label.config(image=self.photo)
def cursorPosition(self,event):
if event.widget == self.openButton3D:
if self.photoName == "eguana2.gif":
self.photoName = "eguana.gif"
self.changeImage()
elif event.widget == self.openButton2D:
if self.photoName == "eguana.gif":
self.photoName = "eguana2.gif"
self.changeImage()
class MainForm(Tk, Observer):
""" Defines a form object based from Tk in tkinter. """
def __init__(self):
""" Initializes the control object and controls of the form. """
Tk.__init__(self)
Observer.__init__(self)
self.ctrl_anon = None
self.resizable(0, 0)
self._reset_controls()
# Center window
width = 800
height = 500
scr_width = self.winfo_screenwidth()
scr_height = self.winfo_screenheight()
# Calculate dimensions
x = (scr_width/2) - (width/2)
y = (scr_height/2) - (height/2)
# Set window dimensions
geo = str(width) + "x" + str(height) + "+" + str(x)[:-2] + "+" + str(y)[:-2]
self.geometry(geo)
def _reset_controls(self):
""" Resets the controls on the form. """
image = ImageTk.PhotoImage(file="bg.png")
# Initialize controls
self.lbl_bg = Label(self, image=image)
self.lbl_dir = Label(self, bg="white", fg="#668FA7", font=("Courier", 14))
self.lbl_anon = Label(self, bg="white", fg="#668FA7", font=("Courier", 14))
self.lbl_id = Label(self, bg="white", fg="#668FA7", font=("Courier", 14))
self.btn_dir_select = Button(self, text="Select data folder", command=self._btn_dir_press)
self.btn_id = Button(self, text="Identify data", command=self._btn_id_press)
self.btn_anon = Button(self, text="Anonymize data", command=self._btn_anon_press)
self.tb_study = Entry(self, bg="#668FA7", fg="white")
self.prg_id = Progressbar(self, orient="horizontal", length=200, mode="determinate")
self.prg_anon = Progressbar(self, orient="horizontal", length=200, mode="determinate")
# Place controls
self.lbl_bg.place(x=0, y=0, relwidth=1, relheight=1)
self.lbl_anon.place(x=400, y=400)
self.lbl_id.place(x=400, y=325)
self.btn_dir_select.place(x=250, y=250)
self.btn_id.place(x=250, y=325)
self.btn_anon.place(x=250, y=400)
self.tb_study.place(x=250, y=175)
self.prg_id.place(x=410, y=290)
self.prg_anon.place(x=410, y=370)
# Other formatting
self.lbl_bg.image = image
self.btn_id['state'] = "disabled"
self.btn_anon['state'] = "disabled"
self.prg_id['maximum'] = 100
self.prg_anon['maximum'] = 100
def _btn_dir_press(self):
""" Allows user to select their data folder. """
self.ctrl_anon.reset()
dir = filedialog.askdirectory(initialdir='.')
if len(dir) > 0:
self.lbl_dir.config(text=dir)
self.btn_id['state'] = "active"
self.btn_anon['state'] = "disabled"
else:
self.btn_id['state'] = "disabled"
self.btn_anon['state'] = "disabled"
def _btn_id_press(self):
""" Calls the controller to identify data set. """
self.ctrl_anon.identify(self.lbl_dir['text'])
self.btn_anon['state'] = "active"
def _btn_anon_press(self):
""" Calls the controller to anonymize the data set. """
if len(self.tb_study.get()) == 0:
self.lbl_anon.config(text="Please enter a study name..")
elif not self.tb_study.get().isalnum():
self.lbl_anon.config(text="Please enter a valid study name..")
else:
self.ctrl_anon.anonymize(self.tb_study.get(), self.lbl_dir['text'])
def notify(self):
""" Updates the progress of the anonymization and identification processes. """
self.prg_id['value'] = self.ctrl_anon.id_progress
if self.prg_id['value'] == 100:
self.lbl_id.config(text="Identification compelete")
elif self.prg_id['value'] > 0:
self.lbl_id.config(text="Identification in progress..")
self.prg_anon['value'] = self.ctrl_anon.anon_progress
if self.prg_anon['value'] == 100:
self.lbl_anon.config(text="Anonymization compelete")
elif self.prg_anon['value'] > 0:
self.lbl_anon.config(text="Anonymization in progress..")
def add_controller(self, control_anon):
""" Adds a control anonymizer object to this gui. """
self.ctrl_anon = control_anon
self.ctrl_anon.subscribe(self)
class Textbox(Widget_):
def __init__(self, parent_frame, x, y):
Widget_.__init__(self, parent_frame, x, y)
self.label_width = 15
self.entry_width = 20
self.stringvar = StringVar()
self.label = Label(self.widget_frame, width=self.label_width, anchor=E)
self.entry = Entry(self.widget_frame, width=self.entry_width, textvariable=self.stringvar, relief=FLAT)
self.label.pack(side=LEFT, padx=3)
self.entry.pack(side=LEFT)
self.label_bg, self.label_fg, self.label_hover_bg, self.label_hover_fg = None, None, None, None
self.entry_bg, self.entry_fg, self.entry_focus_bg, self.entry_focus_fg = '#FFFFFF', None, '#D0F2ED', None
self.widget_frame.bind('<FocusIn>', lambda event: self.entry.config(bg=self.entry_focus_bg))
self.widget_frame.bind('<FocusOut>', lambda event: self.entry.config(bg=self.entry_bg))
#def get_(self):
# return self.entry.get()
def get_info(self):
return self.label.cget('text'), self.entry.get()
def settings(self, **kwargs):
if 'label' in kwargs:
self.label.config(text=kwargs['label'])
if 'entry_state' in kwargs:
self.entry_state = kwargs['entry_state']
self.entry.config(state=self.entry_state)
if 'entry' in kwargs:
if hasattr(self, 'entry_state') and self.entry_state == DISABLED:
self.entry.config(state=NORMAL)
self.stringvar.set(kwargs['entry'])
if hasattr(self, 'entry_state') and self.entry_state == DISABLED:
self.entry.config(state=DISABLED)
if 'label_bg' in kwargs:
self.label_bg = kwargs['label_bg']
self.label.config(bg=self.label_bg)
if 'label_fg' in kwargs:
self.label_fg = kwargs['label_fg']
self.label.config(fg=self.label_fg)
def set_input_restriction(self, string):
def OnValidate(d, i, P, s, S, v, V, W, string):
if d == 0:
return True
accepted_inputs = string.split(',')
if 'int' in accepted_inputs and S.isdigit():
return True
if 'lower' in accepted_inputs:
S = S.lower()
return True
if 'upper' in accepted_inputs:
S = S.upper()
return True
return False
self.vcmd = self.widget_frame.register(OnValidate), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W', string
self.entry.config(validate="all", validatecommand=self.vcmd)
return
pass
class _Tk_Nosy(object):
"""This class is the tkinter GUI object"""
def __init__(self, master):
self.dirname = os.path.abspath( os.curdir )
self.initComplete = 0
self.master = master
self.x, self.y, self.w, self.h = -1,-1,-1,-1
# bind master to <Configure> in order to handle any resizing, etc.
# postpone self.master.bind("<Configure>", self.Master_Configure)
self.master.bind('<Enter>', self.bindConfigure)
self.menuBar = Menu(master, relief = "raised", bd=2)
top_Directory = Menu(self.menuBar, tearoff=0)
top_Directory.add("command", label = "Change Dir", command = self.menu_Directory_Change_Dir)
self.menuBar.add("cascade", label="Directory", menu=top_Directory)
#top_Snippet = Menu(self.menuBar, tearoff=0)
self.menuBar.add("command", label = "Run", command = self.menu_Run)
master.config(menu=self.menuBar)
# make a Status Bar
self.statusMessage = StringVar()
self.statusMessage.set(self.dirname)
self.statusbar = Label(self.master, textvariable=self.statusMessage, bd=1, relief=SUNKEN)
self.statusbar.pack(anchor=SW, fill=X, side=BOTTOM)
self.statusbar_bg = self.statusbar.cget('bg') # save bg for restore
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
self.statusbar.config( font=myFont )
frame = Frame(master)
frame.pack(anchor=NE, fill=BOTH, side=TOP)
self.Pass_Fail_Button = Button(frame,text="Pass/Fail Will Be Shown Here",
image="", width="15", background="green",
anchor=W, justify=LEFT, padx=2)
self.Pass_Fail_Button.pack(anchor=NE, fill=X, side=TOP)
self.Pass_Fail_Button.bind("<ButtonRelease-1>", self.Pass_Fail_Button_Click)
#self.master.title("tk_nosy")
self.master.title('Python %s.%s.%s '%sys.version_info[:3])
self.oscillator = 1 # animates character on title
self.oscillator_B = 0 # used to return statusbar to statusbar_bg
self.lbframe = Frame( frame )
self.lbframe.pack(anchor=SE, side=LEFT, fill=BOTH, expand=1)
scrollbar = Scrollbar(self.lbframe, orient=VERTICAL)
self.Text_1 = Text(self.lbframe, width="80", height="24", yscrollcommand=scrollbar.set)
scrollbar.config(command=self.Text_1.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.Text_1.pack(side=LEFT, fill=BOTH, expand=1)
self.master.resizable(1,1) # Linux may not respect this
self.numNosyCalls = 0
self.need_to_pick_dir = 1
if len(sys.argv)>1:
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
try:
dirname = os.path.abspath( sys.argv[1] )
self.try_change_to_new_dir( dirname )
except:
pass # let Alarm force dir selection
else:
try:
if os.path.isdir(os.path.join( self.dirname, 'tests' )):
self.try_change_to_new_dir( self.dirname )
except:
pass # let Alarm force dir selection
print(LICENSE)
self.Alarm()
def try_change_to_new_dir(self, dirname):
"""A legal abspath will switch to dirname."""
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
if dirname:
try:
dirname = os.path.abspath( dirname )
except:
return # let Alarm force dir selection
else:
return
self.dirname = dirname
print('Selected dirname =',dirname)
fileD.clear()
os.chdir( self.dirname )
self.reset_statusbar_bg()
self.need_to_pick_dir = 0
#with open(NOSY_USER_DATA_FILE, 'w') as text_file:
# text_file.write( self.dirname )
self.numNosyCalls = 0
def reset_statusbar_bg(self):
"""Return status bar to default state"""
self.statusbar.config(bg=self.statusbar_bg)
self.statusMessage.set(self.dirname)
def set_statusbar_bg(self, c):
"""Set status bar to show new color and message"""
self.statusbar.config(bg=c)
self.oscillator_B = 1 # will return to initial color after a few cycles
def menu_Directory_Change_Dir(self):
"""Menu selection to set directory in which to run nosetests"""
dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".")
if dirname:
self.try_change_to_new_dir( dirname )
# >>>>>>insert any user code below this comment for section "menu_Directory_Change_Dir"
# replace, delete, or comment-out the following
print("called menu_Directory_Change_Dir")
def menu_Run(self):
"""User initiates a nosetests run, not file change detection."""
print("called menu_Run")
self.callNosy()
def callNosy(self):
"""Run nosetests and display results"""
self.numNosyCalls += 1
self.Text_1.delete(1.0, END)
# turn indicator button gray while running the tests
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
self.Pass_Fail_Button.config(background="#999999", text='TESTING...', font=myFont)
self.master.update()
self.master.update_idletasks()
# pylint: disable=W0201
self.passedAllTests, numPassed, numFailed, numErrors, numSkipped, outputTextL = \
run_nosetests(self.numNosyCalls)
max_len_s = 42
num_lines = 1
for s in outputTextL:
self.Text_1.insert(END, s)
sL = s.split('\n')
for ss in sL:
max_len_s = max(max_len_s, len(ss))
num_lines += 1
if self.numNosyCalls % 2:
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
else:
myFont = tkinter.font.Font(family="Arial", size=12)
if self.passedAllTests:
s = 'PASSED'
if numPassed > 1:
s = 'PASSED ALL %i TESTS'%numPassed
elif numPassed == 1:
s = 'PASSED ONE TEST'
bg="#00ff00"
if numSkipped==1:
s = 'passed with 1 SKIP'
bg = "#00cc00"
elif numSkipped > 1:
s = 'passed with %i SKIPS'%numSkipped
bg = "#00cc00"
elif numPassed==0:
s = 'No Tests Found'
bg="#ff8000"
self.Pass_Fail_Button.config(background=bg, text=s, font=myFont)
#self.master.geometry('200x50')
else:
s = 'FAILED %i, ERRORS %i, SKIP %i, PASSED %i'%(numFailed,
numErrors, numSkipped, numPassed)
self.Pass_Fail_Button.config(background="#ff0000", text=s, font=myFont)
#self.master.geometry('516x385')
# Show list of files being watched.
#self.Text_1.insert(END, '_'*40+'\n')
self.Text_1.insert(END, 'WATCHED *.py FILES'.center(40,'_') + '\n' )
self.Text_1.insert(END, '%s%s..\n\n'%(self.dirname,os.path.sep) )
num_lines += 3
len_dirname = len( self.dirname )
keyL = list(fileD.keys())
keyL.sort()
lastdir = ''
for key in keyL:
dn = os.path.dirname( key )
if dn != lastdir:
self.Text_1.insert(END, '..'+dn[len_dirname:] + '\n')
max_len_s = max(max_len_s, len(dn)+1)
lastdir = dn
num_lines += 1
s = ' ' +os.path.basename( key )
self.Text_1.insert(END, s + '\n')
max_len_s = max(max_len_s, len(s)+1)
num_lines += 1
self.Text_1.config(width=max_len_s)
self.Text_1.config(height=min(40, num_lines))
self.master.winfo_toplevel().wm_geometry("")
def bindConfigure(self, event):
"""Part of goofy main window setup in tkinter."""
# tkinter requires arguments, but I don't use them
# pylint: disable=W0613
if not self.initComplete:
self.master.bind("<Configure>", self.Master_Configure)
self.initComplete = 1
# return a string containing directory name
def AskDirectory(self, title='Choose Directory', initialdir="."):
"""Run pop-up menu for user to select directory."""
# This is not an error
# pylint: disable=E1101
if sys.version_info < (3,):
dirname = tkFileDialog.askdirectory(parent=self.master,
initialdir=initialdir,title=title)
else:
dirname = tkinter.filedialog.askdirectory(parent=self.master,
initialdir=initialdir,title=title)
return dirname # <-- string
def Master_Configure(self, event):
"""Part of tkinter main window initialization"""
if event.widget != self.master:
if self.w != -1:
return
x = int(self.master.winfo_x())
y = int(self.master.winfo_y())
w = int(self.master.winfo_width())
h = int(self.master.winfo_height())
if (self.x, self.y, self.w, self.h) == (-1,-1,-1,-1):
self.x, self.y, self.w, self.h = x,y,w,h
if self.w!=w or self.h!=h:
#print "Master reconfigured... make resize adjustments"
self.w=w
self.h=h
def Pass_Fail_Button_Click(self, event):
"""Place-holder routine for user clicking Pass/Fail Button"""
pass
# alarm function is called after specified number of milliseconds
def SetAlarm(self, milliseconds=1000):
"""Reinitialize tkinter alarm mechanism as well as update seconds
counter in main window title bar.
"""
self.master.after( milliseconds, self.Alarm )
self.oscillator += 1
if self.oscillator > 5:
self.oscillator = 0
if self.oscillator_B>0:
self.oscillator_B += 1
if self.oscillator_B>5:
self.oscillator_B = 0
self.reset_statusbar_bg()
pad = '|'*self.oscillator
#self.master.title("%i) tk_nosy "%self.numNosyCalls + pad )
s = '%s.%s.%s '%sys.version_info[:3]
self.master.title('%i) Python %s '%(self.numNosyCalls , s + pad ))
def Alarm(self):
"""Look for changed files every second, then reset alarm"""
if self.need_to_pick_dir:
dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".")
self.try_change_to_new_dir( dirname )
#first call to numberOfChangedFiles will be > 0 if any .py files are found
elif numberOfChangedFiles( self.dirname ) > 0: # or self.numNosyCalls==0
self.callNosy()
self.SetAlarm()
def __init__(self, master, valves):
Frame.__init__(self, master, bg='sky blue', width=1366, height=768)
self.master = master
self.canvas = Canvas(self, height=630, width=1320, bg='sky blue')
self.frame = Frame(self.canvas, bg='sky blue')
self.scrollbar = Scrollbar(self, orient='vertical', command=self.canvas.yview)
self.scrollbar.configure(activebackground='DarkRed', background='red', width=40)
self.canvas.configure(yscrollcommand=self.scrollbar.set, scrollregion=[0, 0, 1366, 800])
self.scrollbar.pack(side='right', fill='y')
self.canvas.pack(side='left')
self.canvas.create_window((0, 0), window=self.frame, anchor='nw')
self.valves = valves
self.frame.config(bg='sky blue')
index = 0
while index < 10:
self.frame.grid_rowconfigure(index, minsize=80)
self.frame.grid_columnconfigure(index, minsize=30)
index += 1
self.frame.grid_columnconfigure(3, minsize=130)
self.frame.grid_columnconfigure(6, minsize=130)
interval = Label(self.frame, text='RUN', width=6, font=('Lucida Console', 30))
interval.grid(row=0, column=2)
interval.config(bg='sky blue', fg='RoyalBlue4')
delay = Label(self.frame, text='DELAY', width=6, font=('Lucida Console', 30))
delay.grid(row=0, column=5)
delay.config(bg='sky blue', fg='RoyalBlue4')
self.seconds = [IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar()]
for each in self.seconds:
each.set(0)
self.set_seconds()
self.valve_label = [Label(self.frame, textvariable=self.valves[0].get_name()),
Label(self.frame, textvariable=self.valves[1].get_name()),
Label(self.frame, textvariable=self.valves[2].get_name()),
Label(self.frame, textvariable=self.valves[3].get_name()),
Label(self.frame, textvariable=self.valves[4].get_name()),
Label(self.frame, textvariable=self.valves[5].get_name()),
Label(self.frame, textvariable=self.valves[6].get_name()),
Label(self.frame, textvariable=self.valves[7].get_name())
]
row = 1
for each in self.valve_label:
each.grid(row=row, column=0)
each.config(width=8, font=('Lucida Console', 30), bg='sky blue', fg='RoyalBlue4')
row += 1
self.minus_image = PhotoImage(file="img/minus.png").subsample(x=5, y=5)
self.minusInterval = [Button(self.frame, image=self.minus_image, command=lambda: self.subtract(0)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(1)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(2)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(3)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(4)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(5)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(6)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(7)),
]
row = 1
for each in self.minusInterval:
each.grid(row=row, column=1)
each.config(bg='SkyBlue4', activebackground='midnight blue', fg='white')
row += 1
self.labelInterval = [Label(self.frame, textvariable=self.seconds[0]),
Label(self.frame, textvariable=self.seconds[1]),
Label(self.frame, textvariable=self.seconds[2]),
Label(self.frame, textvariable=self.seconds[3]),
Label(self.frame, textvariable=self.seconds[4]),
Label(self.frame, textvariable=self.seconds[5]),
Label(self.frame, textvariable=self.seconds[6]),
Label(self.frame, textvariable=self.seconds[7])]
row = 1
for each in self.labelInterval:
each.grid(row=row, column=2)
each.config(width=4, font=('Lucida Console', 30), bg='sky blue', fg='RoyalBlue4')
row += 1
self.plus_image = PhotoImage(file="img/plus.png").subsample(x=5, y=5)
self.plusInterval = [Button(self.frame, image=self.plus_image, command=lambda: self.add(0)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(1)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(2)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(3)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(4)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(5)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(6)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(7)),
]
row = 1
for each in self.plusInterval:
each.grid(row=row, column=3)
each.config(bg='SkyBlue4', activebackground='midnight blue', fg='white')
row += 1
self.minusDelay = [Button(self.frame, image=self.minus_image, command=lambda: self.subtract(8)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(9)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(10)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(11)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(12)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(13)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(14)),
Button(self.frame, image=self.minus_image, command=lambda: self.subtract(15)),
]
row = 1
for each in self.minusDelay:
each.grid(row=row, column=4)
each.config(bg='SkyBlue4', activebackground='midnight blue', fg='white')
each.config()
row += 1
self.labelDelay = [Label(self.frame, textvariable=self.seconds[8]),
Label(self.frame, textvariable=self.seconds[9]),
Label(self.frame, textvariable=self.seconds[10]),
Label(self.frame, textvariable=self.seconds[11]),
Label(self.frame, textvariable=self.seconds[12]),
Label(self.frame, textvariable=self.seconds[13]),
Label(self.frame, textvariable=self.seconds[14]),
Label(self.frame, textvariable=self.seconds[15])]
row = 1
for each in self.labelDelay:
each.grid(row=row, column=5)
each.config(width=4, font=('Lucida Console', 30), bg='sky blue', fg='RoyalBlue4')
row += 1
self.plusDelay = [Button(self.frame, image=self.plus_image, command=lambda: self.add(8)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(9)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(10)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(11)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(12)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(13)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(14)),
Button(self.frame, image=self.plus_image, command=lambda: self.add(15)),
]
row = 1
for each in self.plusDelay:
each.grid(row=row, column=6)
each.config(bg='SkyBlue4', activebackground='midnight blue')
each.config()
row += 1
self.motor_image = PhotoImage(file="img/motor.png").subsample(x=5, y=5)
self.motor = [Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(0)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(1)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(2)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(3)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(4)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(5)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(6)),
Button(self.frame, text='MOTOR', image=self.motor_image, command=lambda: self.motor_on(7))]
row = 1
for each in self.motor:
each.grid(row=row, column=7)
each.config(bg='SkyBlue4', activebackground='midnight blue', fg='white')
each.config()
row += 1
self.adv_image = PhotoImage(file="img/options.png").subsample(x=5, y=5)
self.adv = [Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(0)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(1)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(2)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(3)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(4)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(5)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(6)),
Button(self.frame, image=self.adv_image, command=lambda: self.motor_on(7)),
]
row = 1
for each in self.adv:
each.grid(row=row, column=8)
each.config(bg='SkyBlue4', activebackground='midnight blue', fg='white')
row += 1
self.set_seconds()
self.lock()
class rmap():
_var = [1]
_nc = 0
_nr = 0
_r = 0
_c = 0
_size = 0
_w = 0
_d = 0
_NoneUpdate = False
_Nonelabel = False
_Nonegettext = False
_field = []
_endPoint = (0,0)
_robot = '' # рисунок Робота (синее кольцо)
_park = ''
_canvas = ''
sleep = 0.5
_task = ''
_solve = ''
_test = ''
_res = ''
_bum = 0
m = []
m.append('task1')
m.append('task2')
m.append('task3')
m.append('task4')
m.append('task5')
m.append('task6')
m.append('task7')
m.append('task8')
m.append('task9')
m.append('task10')
m.append('task11')
m.append('task12')
m.append('task13')
class _v: # будет содержать изображение текста и квадратиков закраски и меток. Чтобы можно было "поднимать изображение"
text = ''
label = ''
color = ''
class _Tcell():
color = ''
text = ''
label = '' # color
wUp = False
wLeft = False
v = ''
def help(self):
""" Вывести список команд Робота
Примеры использования по команде r.help_full()
"""
print("""
Пояснение по каждой команде: print команда.__doc__
Например:
print r.color.__doc__
---=: Команды перемещения :=---
r.rt() # Вправо
r.lt() # Влево
r.dn() # Вниз
r.up() # Вверх
r.jumpTo(r,c) # Прыжок в точку. Без особых указаний в задачах не использовать
-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=
---=: Команды изменения среды :=---
r.pt([цвет]) # Закрасить указанным цветом. По умолчанию зеленым
r.sw(направление) # Установить стену с указанной стороны
r.settext(тест) # Вписать в клетку текст
-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=
---=: Команды обратной связи :=---
r.cl() # Каким цветом закрашена клетка? r.color()
r.label() # Какого цвета метка в клетке?
r.gettext() # Какой текст в клетке?
r.getCoords() # Где Робот?
r.getCoordR() # В какой строке Робот?
r.getCoordС() # В каком столбце Робот?
r.fu() # Сверху свободно?
r.fd() # Снизу свободно?
r.fr() # Справа свободно?
r.fl() # Слева свободно?
r.wu() # Сверху стена?
r.wd() # Снизу стена?
r.wr() # Справа стена?
r.wl() # Слева стена?
r.isPark # Робот на парковке?
-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=
---=: Дополнительно :=---
r.sleep = 0.4 # Установить размер задержки после каждого хода. Меньше значение - быстрее Робот.
r._NoneUpdate = False # Отключить прорисовку поля
r._NoneUpdate = True # Включить прорисовку поля
r.demo() # Показать, что нужно сделать в текущей задаче
r.demoAll() # Показать все задачи (с решениями, по очереди)
r.randcolor() # Генерировать случайный цвет
-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=
""")
def help_full(self):
""" Примеры. Для получения списка команд r.help()
Примеры использования по команде r.help_full()
Больше информации по каждой команде: print команда.__doc__
Например:
print r.color.__doc__
"""
print("""
Не реализовано в данной версии.
Если нужно - пишите на [email protected] или на сайте progras.ru
""")
def demo(self):
"""Показать выполнение задачи
Пример использования:
#-------------------
r.demo()
#-------------------
Для уcкорения использовать r.sleep = 0.01
В задании 10-3(4/5) можно отключить обновление экрана
#-------------------
r._NoneUpdate = True
r.demo()
r._NoneUpdate = False
#-------------------
"""
global r
r = self
exec(self._solve)
def demoAll(self):
"""Показать выполнение всех заданий в автоматическом режиме
Пример использования:
#-------------------
r.demoAll()
#-------------------
Для того, чтобы Робот двигался быстрее, используйте
#-------------------
r.sleep = 0
r.demoAll()
#-------------------
"""
global r
r = self
for x in r.m:
r.lm(x)
print(x)
r.demo()
r.pause()
def __init__(self):
self._w = 4 # толщина стен
self._d = 4 # на столько меньше клетки закраска (с каждой стороны)
self.sleep = 0.5 # замедление
self._font_size = self._size // 2
self._tk = Tk()
self._tk.geometry('+0+0')
x = (self._tk.winfo_screenwidth() - self._tk.winfo_reqwidth()) / 3
y = (self._tk.winfo_screenheight() - self._tk.winfo_reqheight()) / 4
self._tk.wm_geometry("+%d+%d" % (x, y))
self._tk.title('Robot-hobot')
self._canvas = Canvas(self._tk, width=(self._size*(self._nc+1)), height=(self._size*(self._nr+1)), bg="gray")
buttons = Frame(self._tk)
self.task = Label (self._tk, justify = 'left')
self.res = Label (self._tk, justify = 'left')
self._but_start = Button(buttons,text = 'start',width=10,height=1)
self._but_start.bind('<ButtonRelease-1>',self.but1)
self._but_demo = Button(buttons,text = 'demo',width=10,height=1)
self._but_demo.bind('<ButtonRelease-1>',self.but_demo)
self._but_reload = Button(buttons,text = 'reload',width=10,height=1)
self._but_reload.bind('<ButtonRelease-1>',self.but_reload)
self._but_load_next = Button(buttons,text = 'load next',width=10,height=1)
self._but_load_next.bind('<ButtonRelease-1>',self.but_load_next)
buttons.grid(row=0, column=0, sticky = "w")
self._canvas.grid(row=1, column=0, sticky = "e")
self._but_start.pack(side = "left")
self._but_demo.pack(side = "left")
self._but_reload.pack(side = "left")
self._but_load_next.pack(side = "left")
self.task.grid(row=3, column=0, sticky = "w")
self.res.grid(row=4, column=0, sticky = "w")
## self.loadmap()
def but_load_next(self,event):
print ("load next")
index = self.m.index(self._cur_map)
if index < len(self.m)-1:
self.lm(self.m[index+1])
else:
self.lm(self.m[0])
def but_demo(self,event):
print ("demo")
self.demo()
def but1(self,event):
print ('start')
#self.lm(self._cur_map)
self.solve_task()
def but_reload(self,event):
print ("reload")
self.lm(self._cur_map)
def clear (self):
"Очистка данных (без перерисовки)"
self._canvas.delete('all')
self._field = []
self._park = []
self._Nonelabel = False
self._NoneisPark = False
self._Nonesettext = False
self._test = ''
self._res = ''
self._bum = 0
for r in range(1,self._nr+2):
row = []
for c in range(1,self._nc+2):
row.append (self._Tcell())
self._field.append(row)
for r in range (1,self._nr):
for c in range(1,self._nc):
self._field[r][c].text = ''
self._field[r][c].color = ''
self._field[r][c].label = ''
self._field[r][c].wUp = False
self._field[r][c].wLeft = False
self._field[r][c].v = self._v()
for c in range (1,self._nc):
self._field[1][c].wUp = True
self._field[self._nr][c].wUp = True
for r in range (1,self._nr):
self._field[r][1].wLeft = True
self._field[r][self._nc].wLeft = True
self._solve = ''
self._r = 1
self._c = 1
def _paintMap(self):
"Перерисовка по имеющимся данным"
remc = self._c
remr = self._r
size = self._size
sleep = self.sleep
self.sleep = 0
self._bg = [self._canvas.create_rectangle(1,1,(size*(self._nc+1)), (size*(self._nr+1)), fill="gray")]
# создать поле
for r in range (1, self._nr+1):
self._bg.append(self._canvas.create_line(size,r*size,self._nc*size,r*size))
if r < self._nr: self._canvas.create_text(size/2,r*size+size/2,text=r)
for c in range (1, self._nc+1):
self._bg.append(self._canvas.create_line(c*size,size,c*size,self._nr*size))
if c < self._nc: self._bg.append(self._canvas.create_text(c*size+size/2,size/2,text=c))
# клетки и номера столбцов и строк
for r in range (1,self._nr):
for c in range(1,self._nc):
self._r = r
self._c = c
if self._field[r][c].wUp: # стена сверху
self.setWall('up')
if self._field[r][c].wLeft: # стена слева
self.setWall('left')
if self._field[r][c].color != '' : # закраска
self.paint(self._field[r][c].color)
if self._field[r][c].label != '' : # метка0000
d = self._d
x1 = self._size*(c)
x2 = self._size*(c+1)
y1 = self._size*(r)
y2 = self._size*(r+1)
self._canvas.delete(self._field[r][c].v.label)
self._field[r][c].v.label = self._canvas.create_rectangle(x1+d,y1+d,x2-d,y2-d, width = d-1, outline = self._field[r][c].label)
self._canvas.lift(self._robot)
self.settext(self._field[r][c].text) # текст
for self._c in range (1,self._nc):
if self._field[self._nr][self._c].wUp: # стена сверху
self.setWall('down')
for self._r in range (1,self._nr):
if self._field[self._r][self._nc].wLeft: # стена слева
self.setWall('right')
r = self._endPoint[0]
c = self._endPoint[1]
self._canvas.delete(self._park)
if r > 0 and c > 0:
self._park = self._canvas.create_oval (c*size+6,r*size+6, c*size+size-6,r*size+size-6, width = 3, outline = 'yellow')
# конечная точка
self.jumpTo((remr,remc))
self._task = '\n'+self._task
self.task.config(text = self._task)
self.res.config()
self._update()
self.sleep = sleep
#self.pause()
def _update(self):
"Обновить canvas"
if not self._NoneUpdate:
self._canvas.update()
time.sleep(self.sleep)
def start(self,fun):
self.solve_task = fun
self._tk.mainloop()
##Робот
def pause(self,t=1):
"""Приостановка выполнения программы. Пауза в секундах.
#-------------------
r.pause() # пауза в одну секунду
#-------------------
r.pause(2) # пауза две секунды
#-------------------
"""
time.sleep(t)
def left(self, a = 1):
"""Шаг влево
#-------------------
r.left()
#-------------------
r.lt()
#-------------------
r.lt(3)
#-------------------
"""
if a == 1:
if self.freeLeft():
self._c -= 1
self._canvas.move(self._robot,-self._size*a,0)
self._update()
else:
self._stop()
else :
for z in range(0,a):
self.left()
def right(self, a = 1):
""" Шаг вправо
#-------------------
r.right()
#-------------------
r.rt()
#-------------------
r.rt(5)
#-------------------
"""
if a == 1:
if self.freeRight():
self._c += 1
self._canvas.move(self._robot,self._size*a,0)
self._update()
else:
self._stop()
else :
for z in range(0,a):
self.right()
def up(self, a = 1):
"""Шаг вверх
#-------------------
r.up()
#-------------------
r.up(3)
#-------------------
"""
if a == 1:
if self.freeUp():
self._r -= 1
self._canvas.move(self._robot,0,-self._size*a)
self._update()
else:
self._stop()
else :
for z in range(0,a):
self.up()
def down(self, a = 1):
""" Шаг вниз
#-------------------
r.down()
#-------------------
r.dn()
#-------------------
r.dn(4)
#-------------------
"""
if a == 1:
if self.freeDown():
self._r += 1
self._canvas.move(self._robot,0,self._size*a)
self._update()
else:
self._stop()
else :
for z in range(0,a):
self.down()
def jumpTo(self,coord=(1,1)):
"""Прыжок в клетку с указанными координами. Через стены.
#-------------------
r.jumpTo((2,3)) # Робот окажется в третьем столбце второй строки
#-------------------
"""
r = coord[0]
c = coord[1]
if ( 0 < r < self._nc) and (0 < c < self._nc):
self._r = r
self._c = c
size = self._size
self._canvas.coords(self._robot, c*size+4,r*size+4, c*size+size-4,r*size+size-4)
self._canvas.lift(self._robot)
self._update()
else:
print("Попытка переместиться за пределы поля. Отказано.")
def paint (self, color = 'green'):
""" Закрасить текущую клетку выбранным цветом. Если цвет не указан, то зеленым
#-------------------
r.paint() # Закрасит текущую клетку зеленым цветом
#-------------------
r.pt() # Закрасит текущую клетку зеленым цветом
#-------------------
r.pt('red') # Закрасит текущую клетку красным цветом
#-------------------
r.pt(r.randcolor()) # Закрасит текущую клетку случайным цветом
#-------------------
r.pt(r.label()) # Закрасит текущую клетку цветом метки в этой клетке
#-------------------
"""
d = self._d+1
self._field[self._r][self._c].color = color
x1 = self._size*(self._c)
x2 = self._size*(self._c+1)
y1 = self._size*(self._r)
y2 = self._size*(self._r+1)
self._canvas.delete(self._field[self._r][self._c].v.color)
self._field[self._r][self._c].v.color = self._canvas.create_rectangle(x1+d,y1+d,x2-d,y2-d, width = 0, fill = color)
self._canvas.lift(self._field[self._r][self._c].v.text)
self._canvas.lift(self._robot)
self._canvas.lift(self._park)
self._update()
def setWall (self, target):
""" Установить стену с указанной стороны
#-------------------
r.sw('up') # Установить стену сверху
#-------------------
r.sw('left') # Установить стену слева
#-------------------
r.sw('down') # Установить стену снизу
#-------------------
r.sw('right') # Установить стену справа
#-------------------
"""
size = self._size
w = self._w
if target == 'up':
r = self._r
c = self._c
x1 = size*(c)-1
x2 = size*(c+1)+1
y1 = size*(r)
y2 = size*(r+1)
self._field[r][c].wUp = True
self._canvas.create_line(x1,y1,x2,y1, width = w)
elif target == 'left':
r = self._r
c = self._c
x1 = size*(c)
x2 = size*(c+1)
y1 = size*(r)-1
y2 = size*(r+1)+1
self._field[r][c].wLeft = True
self._canvas.create_line(x1,y1,x1,y2, width = w)
elif target == 'down':
r = self._r+1
c = self._c
x1 = size*(c)-1
x2 = size*(c+1)+1
y1 = size*(r)
y2 = size*(r+1)
self._field[r][c].wDown = True
self._canvas.create_line(x1,y1,x2,y1, width = w)
elif target == 'right':
r = self._r
c = self._c+1
x1 = size*(c)
x2 = size*(c+1)
y1 = size*(r)-1
y2 = size*(r+1)+1
self._field[r][c].wRight = True
self._canvas.create_line(x1,y1,x1,y2, width = 4)
self._update()
def wallUp (self):
""" Возвращает истину, если сверху есть стена
#-------------------
if r.wallUp(): r.pt() # Закрасить, если сверху стена
#-------------------
if r.wu(): r.pt() # Закрасить, если сверху стена
#-------------------
if r.wu():
r.pt() # Закрасить, если сверху стена
r.rt() # Перейти вправо
#-------------------
while r.wu(): # Идти вправо, пока сверху есть стена
r.rt()
"""
return self._field[self._r][self._c].wUp
def wallDown (self):
""" Возвращает истину, если снизу есть стена
#-------------------
if r.wallDown(): r.pt() # Закрасить, если снизу стена
#-------------------
if r.wd(): r.pt() # Закрасить, если снизу стена
#-------------------
if r.wd():
r.pt() # Закрасить, если снизу стена
r.rt() # Перейти вправо
#-------------------
while r.wd(): # Идти вправо, пока снизу есть стена
r.rt()
"""
return self._field[self._r+1][self._c].wUp
def wallLeft (self):
""" Возвращает истину, если слева есть стена
#-------------------
if r.wallLeft(): r.pt() # Закрасить, если слева стена
#-------------------
if r.wl(): r.pt() # Закрасить, если слева стена
#-------------------
if r.wl():
r.pt() # Закрасить, если слева стена
r.dn() # Перейти вниз
#-------------------
while r.wl(): # Идти вниз, пока слева есть стена
r.dn()
"""
return self._field[self._r][self._c].wLeft
def wallRight (self):
""" Возвращает истину, если справа есть стена
#-------------------
if r.wallRight(): r.pt() # Закрасить, если справа стена
#-------------------
if r.wr(): r.pt() # Закрасить, если справа стена
#-------------------
if r.wr():
r.pt() # Закрасить, если справа стена
r.dn() # Перейти вниз
#-------------------
while r.wr(): # Идти вниз, пока справа есть стена
r.dn()
"""
return self._field[self._r][self._c+1].wLeft
def freeUp (self):
""" Возвращает истину, если сверху свободно (нет стены)
#-------------------
if r.freeUp(): r.pt() # Закрасить, если сверху свободно
#-------------------
if r.fu(): r.up() # Шагнуть вверх, если сверху свободно
#-------------------
if r.fu():
r.up() # Шагнуть вверх
r.pt() # Закрасить
r.dn() # Перейти вниз
#-------------------
while r.fu(): # Идти вверх, пока сверху свободно
r.up()
"""
return not self._field[self._r][self._c].wUp
def freeDown (self):
""" Возвращает истину, если снизу свободно (нет стены)
#-------------------
if r.freeDown(): r.pt() # Закрасить, если снизу свободно
#-------------------
if r.fd(): r.dn() # Шагнуть вверх, если снизу свободно
#-------------------
if r.fd():
r.dn() # Шагнуть снизу
r.pt() # Закрасить
r.up() # Перейти вверх
#-------------------
while r.fd(): # Идти вниз, пока снизу свободно
r.dn()
"""
return not self._field[self._r+1][self._c].wUp
def freeLeft (self):
""" Возвращает истину, если слева свободно (нет стены)
#-------------------
if r.freeLeft(): r.pt() # Закрасить, если слева свободно
#-------------------
if r.fl(): r.lt() # Шагнуть влево, если слева свободно
#-------------------
if r.fl():
r.lt() # Шагнуть влево
r.pt() # Закрасить
r.rt() # Перейти вправо
#-------------------
while r.fl(): # Идти влево, пока слева свободно
r.lt()
"""
return not self._field[self._r][self._c].wLeft
def freeRight (self):
""" Возвращает истину, если снизу свободно (нет стены)
#-------------------
if r.freeDown(): r.pt() # Закрасить, если снизу свободно
#-------------------
if r.fd(): r.dn() # Шагнуть вверх, если снизу свободно
#-------------------
if r.fd():
r.dn() # Шагнуть снизу
r.pt() # Закрасить
r.up() # Перейти вверх
#-------------------
while r.fd(): # Идти вниз, пока снизу свободно
r.dn()
"""
return not self._field[self._r][self._c+1].wLeft
def getCoords(self):
" Возвращает координаты в виде (row,column)"
return (self._r,self._c)
def getCoordR(self):
" Возвращает номер строки, в которой находиться Робот"
return self._r
def getCoordC(self):
" Возвращает номер столбца, в которой находиться Робот"
return self._c
def isPark (self):
" Возвращает истину, если Робот находиться на парковке"
if self._NoneisPark: self.null()
else: return self._endPoint == self.getCoords()
def color (self):
""" Возвращает цвет, которым закрашена клетка
Можно использовать для проверки, закрашена ли клетка:
#-------------------
# Закрасить, если сверху закрашено
r.up()
if r.color():
r.dn()
r.pt()
else:
r.dn()
#-------------------
if r.color() == 'red': r.rt() # Вправо, если закрашено красным
#-------------------
"""
return self._field[self._r][self._c].color
def randcolor (self):
""" Возвращает случайный цвет
#-------------------
r.pt(r.randcolor()) # Закрасить случайным цветом
#-------------------
# Закрасить соседнюю клетку тем же цветом, что и текущая
x = r.color()
r.rt()
r.pt(x)
#-------------------
"""
cr = rnd(1,255,10)
cg = rnd(1,255,10)
cb = rnd(1,255,10)
color = "#%02X%02X%02X" %(cr,cg,cb)
return str(color)
def label (self):
""" Возвращает цвет метки текущей клетки
#-------------------
if r.label() == 'red': r.pt('red') # Закрасить клетку красным, если метка красная
#-------------------
"""
if self._Nonelabel: self.null()
else: return self._field[self._r][self._c].label
def gettext(self):
""" Возвращает текст, записанный в ячейке.
#-------------------
if r.gettext() != '': r.rt() # Перейти вправо, если в ячейке есть какой-нибудь текст
#-------------------
if r.gettext() == '3': r.rt() # Перейти вправо, если в ячейке записано 3
#-------------------
n = r.gettext()
if n: r.rt(n) # Перейти вправо на количество шагов, указанное в клетке
#-------------------
"""
if self._Nonegettext: self.null()
else: return self._field[self._r][self._c].text
def settext(self,text):
""" Записать текст в клетку
#-------------------
r.settext(3)
#-------------------
"""
self._field[self._r][self._c].text = text
d = 1
x1 = self._size*(self._c)
x2 = self._size*(self._c+1)
y1 = self._size*(self._r)
y2 = self._size*(self._r+1)
self._canvas.delete(self._field[self._r][self._c].v.text)
self._field[self._r][self._c].v.text = self._canvas.create_text(self._c*self._size+self._size/2,self._r*self._size+self._size/2,text =
self._field[self._r][self._c].text, font = ('Helvetica', self._font_size,'bold'))
self._update()
def _stop (self):
print ("Bum!")
self._bum = 1
self._canvas.delete(self._robot)
x = self._c
y = self._r
self._robot = self._canvas.create_oval(
x*self._size+2*self._d,y*self._size+2*self._d,
x*self._size+self._size-2*self._d,y*self._size+self._size-2*self._d,
fill = '#FF0000')
def null (self, *args):
print('Эта команда запрещена к использованию в данной задаче. Ищите другой способ')
return ''
def loadmap(self,mn=m[0],variant=0):
""" Загрузить карту (задачу)
#-------------------
r.loadmap('task10-5')
#-------------------
r.lm('task10-5') # Загрузить задачу по названию
#-------------------
r.lm(r.m[5]) # Загрузить задачу по номеру
#-------------------
# Вывести полный список названий и номеров заданий
for x in r.m:
print r.m.index(x),x
#-------------------
"""
self._tk.title(mn)
self._cur_map = mn
self._NoneUpdate = False
self._endPoint = (0, 0)
# self._NoneUpdate = True
if mn == 'task1':
self._nc = 7
self._nr = 5
self._size = 30
self.clear()
self._r = 3
self._c = 2
self._solve = ''
self._endPoint = (3,5)
self._task = 'Необходимо перевести Робота по лабиринту\n' \
' из начального положения в конечное.\n'
self._field[2][2].wUp = True
self._field[2][3].wUp = True
self._field[2][4].wUp = True
self._field[2][5].wUp = True
self._field[4][2].wUp = True
self._field[4][3].wUp = True
self._field[4][4].wUp = True
self._field[4][5].wUp = True
self._field[2][4].wLeft = True
self._field[3][3].wLeft = True
self._field[3][5].wLeft = True
##--------------------------------------------------------------------------------------------
elif mn == 'task2':
self._nc = 16
self._nr = 4
self._size = 30
self.clear()
self._r = 3
self._c = 1
self._solve = ''
self._task = 'Составьте программу рисования узора.\n'
##--------------------------------------------------------------------------------------------
elif mn == 'task3':
self._nc = 10
self._nr = 5
self._size = 30
self.clear()
self._r = 2
self._c = 1
self._endPoint = (2,9)
self._solve = ''
self._task = 'Необходимо провести Робота вдоль коридора\n' \
' из начального положения в конечное,\n' \
' заглядывая в каждый боковой коридор.'
for i in range(2, 9):
self._field[2][i].wUp = True
if i%2 == 0:
self._field[3][i].wUp = True
else:
self._field[4][i].wUp = True
if i < 8:
self._field[3][i+1].wLeft = True
##--------------------------------------------------------------------------------------------
elif mn == 'task4':
self._nc = 8
self._nr = 12
self._size = 30
self.clear()
self._r = rnd(1, self._nr)
self._c = rnd(1, self._nc)
for i in range(0, 5):
for j in range(0, 3):
self._field[6+2*j-i][2+i].label = 'red'
self._solve = ''
self._task = 'Составьте программу закрашивания\n' \
' клеток поля, отмеченных звездочкой.\n'
##--------------------------------------------------------------------------------------------
elif mn == 'task5':
self._nc = 11
self._nr = 10
self._r = 1
self._c = 1
self._size = 30
self.clear()
self._solve = ''
self._task = 'Составьте программу рисования узора.'
##--------------------------------------------------------------------------------------------
##--------------------------------------------------------------------------------------------
elif mn == 'task6':
self._nc = 25
self._nr = 25
self._r = 1
self._c = 1
self._size = 20
self.clear()
self._solve = ''
self._task = 'Составьте программу рисования фигуры в виде буквы "Т".\n' \
' Вертикальные и горизонтальные размеры пользователь вводит\n' \
' с клавиатуры. Ввод данных можно осуществлять любым способом.\n'
##-------------------------------------------------------------------------------------------------------
elif mn == 'task7':
self._nc = 16
self._nr = 11
self._size = 25
self.clear()
self._r = rnd(1, self._nr)
self._c = rnd(1, self._nc)
self._field[3][2].wUp = True
self._field[2][9].wUp = True
self._field[3][12].wUp = True
self._field[6][12].wUp = True
self._field[7][3].wUp = True
self._field[7][9].wUp = True
self._field[8][6].wUp = True
self._field[9][2].wUp = True
self._field[9][11].wUp = True
for i in range(0, 4):
self._field[4][5+i].wUp = True
self._field[5][5+i].wUp = True
self._solve = ''
self._task = 'Где-то в поле Робота находится горизонтальный коридор шириной в одну клетку\n' \
' неизвестной длины. Робот из верхнего левого угла поля должен дойти до\n' \
' коридора и закрасить клетки внутри него, как указано в задании. По полю\n' \
' Робота в произвольном порядке располагаются стены, но расстояние \n' \
'между ними больше одной клетки.\n'
##--------------------------------------------------------------------------------------------
elif mn == 'task8':
self._nc = 16
self._nr = 11
self._size = 25
self.clear()
self._r = rnd(1, self._nr)
self._c = rnd(1, self._nc)
self._field[2][6].wLeft = True
self._field[3][6].wLeft = True
self._field[5][6].wLeft = True
self._field[6][6].wLeft = True
self._field[7][6].wLeft = True
self._field[8][6].wLeft = True
self._solve = ''
self._task = 'Где-то в поле Робота находится вертикальная стена с отверстием в одну клетку,\n' \
' размеры которой неизвестны. Робот из произвольной клетки должен дойти до\n' \
' стены и закрасить клетки как показано в задании.\n'
##--------------------------------------------------------------------------------------------
elif mn == 'task9':
self._nc = 20
self._nr = 20
self._size = 25
self.clear()
self._r = rnd(1, self._nr)
self._c = rnd(1, self._nc)
c = rnd(2,16)
r = rnd(2,16)
w = rnd(3,8)
h = rnd(3,8)
if c + w >= self._nc: w = self._nc-c
if r + h >= self._nc: h = self._nr-r
for rcount in range(0,h):
for ccount in range(0,w):
self._field[r + rcount][c+ccount].label = 'green'
self._solve = ''
self._task = 'На поле находится квадрат из закрашенных клеток. Вычислить и вывести на экран площадь квадрата.\n'
##--------------------------------------------------------------------------------------------
elif mn == 'task10':
self._nc = 15
self._nr = 11
self._size = 30
self.clear()
self._r = 2
self._c = 1
self._field[2][1].wUp = True
self._field[2][2].wUp = True
self._field[2][4].wUp = True
self._field[2][5].wUp = True
self._field[2][6].wUp = True
self._field[2][8].wUp = True
self._field[2][9].wUp = True
self._field[2][11].wUp = True
self._field[2][12].wUp = True
self._field[2][13].wLeft = True
self._field[3][1].wUp = True
self._field[3][2].wUp = True
self._field[3][3].wUp = True
self._field[3][4].wUp = True
self._field[3][6].wUp = True
self._field[3][7].wUp = True
self._field[3][8].wUp = True
self._field[3][10].wUp = True
self._field[3][11].wUp = True
self._field[3][12].wLeft = True
self._field[4][3].wLeft = True
self._field[4][3].wUp = True
self._field[4][4].wUp = True
self._field[4][5].wUp = True
self._field[4][6].wUp = True
self._field[4][8].wUp = True
self._field[4][9].wUp = True
self._field[4][10].wUp = True
self._field[4][11].wUp = True
self._field[4][13].wLeft = True
self._field[5][3].wLeft = True
self._field[5][4].wLeft = True
self._field[5][4].wUp = True
self._field[5][6].wUp = True
self._field[5][7].wUp = True
self._field[5][8].wUp = True
self._field[5][10].wUp = True
self._field[5][11].wUp = True
self._field[5][12].wUp = True
self._field[6][3].wLeft = True
self._field[6][4].wUp = True
self._field[6][5].wLeft = True
self._field[7][3].wUp = True
self._field[7][4].wLeft = True
self._field[7][6].wUp = True
self._field[7][7].wLeft = True
self._field[8][4].wUp = True
self._field[8][5].wUp = True
self._field[8][6].wLeft = True
self._field[8][7].wUp = True
self._field[8][8].wLeft = True
self._field[9][6].wUp = True
self._field[9][7].wLeft = True
self._field[9][8].wUp = True
self._field[9][9].wUp = True
self._field[9][10].wLeft = True
self._field[10][7].wUp = True
self._field[10][9].wLeft = True
self._field[10][10].wLeft = True
self._endPoint = (10,1)
self._solve = """
"""
self._task = 'Необходимо провести Робота по коридору шириной в одну клетку из начального положения до конца коридора, \n' \
'закрашивая при этом все клетки коридора, которые имеют выход. Выходы размером в одну клетку располагаются \n' \
'произвольно по всей длине коридора. Коридор заканчивается тупиком. Коридор имеет два горизонтальных и \n' \
'диагональный участки. Пример коридора показан на рисунке.\n'
elif mn == 'task11':
self._nc = 15
self._nr = 11
self._size = 30
self.clear()
self._r = rnd(1, self._nr)
self._c = rnd(1, self._nc)
for i in range(1,self._nr):
for j in range(1,self._nc):
self._field[i][j].text = str(rnd(0, 10))
self._task = 'На поле 10х15 каждой в каждой клетке записана цифра (от 0 до 9).\n Закрасить квадрат 2х2 с наименьшей суммой значений клеток.'
elif mn == 'task12':
self._nc = 15
self._nr = 6
self._size = 30
self.clear()
self._r = 2
self._c = 13
self._field[2][2].wUp = True
self._field[2][3].wLeft = True
self._field[3][3].wLeft = True
self._field[4][3].wLeft = True
self._field[5][3].wUp = True
self._field[5][4].wUp = True
self._field[4][5].wLeft = True
self._field[3][5].wLeft = True
self._field[2][5].wLeft = True
self._field[2][5].wUp = True
self._field[2][6].wLeft = True
self._field[3][6].wLeft = True
self._field[4][6].wLeft = True
self._field[5][6].wUp = True
self._field[5][7].wUp = True
self._field[5][8].wUp = True
self._field[4][9].wLeft = True
self._field[3][9].wLeft = True
self._field[2][9].wLeft = True
self._field[2][9].wUp = True
self._field[2][10].wUp = True
self._field[2][11].wLeft = True
self._field[3][11].wLeft = True
self._field[4][11].wLeft = True
self._field[5][11].wUp = True
self._field[4][12].wLeft = True
self._field[3][12].wLeft = True
self._field[2][12].wLeft = True
self._field[2][12].wUp = True
self._field[2][13].wUp = True
self._task = 'Робот движется вдоль стены, профиль которой показан на рисунке,\n' \
' от начального положения до конца стены. Необходимо закрасить\n' \
' все внутренние углы стены, как показано на примере. Размеры стены\n могут быть произвольны.'
elif mn == 'task13':
self._nc = 20
self._nr = 20
self._size = 25
self.clear()
self._r = rnd(self._nr/2, self._nr)
self._c = rnd(self._nc/2, self._nc)
col = rnd(2, self._nc/2)
row = rnd(4, self._nr/2)
height = rnd(4, self._nr-4)
if row + height >= self._nr:
height = self._nr - row-1
for i in range(row, row+height):
self._field[i][col].wLeft = True
##--------------------------------------------------------------------------------------------
##--------------------------------------------------------------------------------------------
# сделать прямое управление с демонстрацией датчиков и возможностей
# при запуске робота создавать task.py и справочник :)
# сделать робота без клеток !!!
##--------------------------------------------------------------------------------------------
##--------------------------------------------------------------------------------------------
else:
print(mn)
self._task = "Нет задачи с таким номером"
self._test = '-'
self._canvas.config(
width=(self._size*(self._nc+1)),
height=(self._size*(self._nr+1)))
x = y = 1
d = self._d
d = 6
self._robot = self._canvas.create_oval(
x*self._size+d,y*self._size+d,
x*self._size+self._size-d,y*self._size+self._size-d,
outline = '#4400FF', width = 3)
self._paintMap()
lm = loadmap
lt = left
rt = right
dn = down
pt = paint
sw = setWall
wu = wallUp
wd = wallDown
wl = wallLeft
wr = wallRight
fu = freeUp
fd = freeDown
fl = freeLeft
fr = freeRight
cl = color
class EguanaGUI(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
# if not EguanaInit.eguana_root_dir_exists():
# EguanaInit.create_eguana_root_dir()
def initUI(self):
self.parent.title("EGUANA")
self.style = ttk.Style()
self.style.theme_use("alt")
self.photoName = "eguana.gif"
self.frame = Frame(self, relief=FLAT, borderwidth=10,bg='#FADC46')
self.frame.pack(fill=BOTH, expand=True)
self.pack(fill=BOTH, expand=True)
self.setupMenuBar()
self.setupTopBar()
def setupMenuBar(self):
self.menubar = EguanaMenu(self.parent,self)
self.parent.config(menu=self.menubar)
def setupTopBar(self):
self.supportedDevices = []
for fileName in [name for name in os.listdir('./machineConfig') if os.path.isfile('./machineConfig/' + name) and not name == 'eguanaMachineConfig.py' and name.endswith('.py')]:
# try:{
components = fileName.split('.')
fileName = components[0]
className = fileName[0].upper() + fileName[1:]
try:
module = __import__("machineConfig."+fileName,fromlist=["machineConfig."])
classVar = getattr(module,className)
except:
continue
self.supportedDevices.append(classVar())
# except:
# pass
self.selectMachineFrame = Frame(self.frame,relief=FLAT,bg='#FADC46')
self.selectMachineFrame.pack(fill=BOTH,expand=True)
self.setupSelectMachineButtons()
def setupSelectMachineButtons(self):
numDevices = len(self.supportedDevices)
numColumns = 3
numRows = math.ceil((numDevices+1)/3)
self.photo = PhotoImage(file="eguana.gif")
self.photo = self.photo.subsample(2);
self.photo_label = Label(self.selectMachineFrame,image=self.photo,borderwidth=0,highlightthickness=0)
self.photo_label.configure(bg='#FADC46')
self.photo_label.grid(row=int(numRows/2),column=1, sticky=N+S+E+W,padx=2,pady =2)
self.photo_label.image = self.photo
index = 0
for i in range(numRows):
for j in range(numColumns):
if not(j == 1 and i == int(numRows/2)) and (index < numDevices):
device = self.supportedDevices[index]
b = Button(self.selectMachineFrame,text=device.name,relief=RAISED, command=lambda device=device :self.machineButtonPressed(device))
b.grid(row=i,column=j, sticky=N+S+E+W,padx=2,pady =2)
index += 1
for i in range(numRows):
self.selectMachineFrame.rowconfigure(i,weight=1)
for i in range(numColumns):
self.selectMachineFrame.columnconfigure(i,weight=1)
def machineButtonPressed(self,inputDevice):
dirStr = filedialog.askdirectory()
if len(dirStr) and inputDevice.isDirectoryValid(dirStr):
inputDevice.setDirPath(dirStr)
EguanaModel().machine = inputDevice
self.selectMachineFrame.destroy()
self.menubar.inputSelected()
self.photo_label.destroy()
dirStr = 'Input Path : '+dirStr
self.selectPlotFrame = Frame(self.frame, relief=FLAT,bg='#FADC46')
self.selectPlotFrame.pack(fill=BOTH,expand=True)
self.selectPlotFrame.rowconfigure(0,weight=1)
self.selectPlotFrame.rowconfigure(1,weight=2)
self.selectPlotFrame.columnconfigure(0,weight=1)
self.infoFrame = Frame(self.selectPlotFrame, relief=FLAT, bg='#FADC46')
self.infoFrame.grid(row=0,column=0, sticky=N+S+E+W,padx=2,pady =2)
self.machineNameLabel = Label(self.infoFrame, text=inputDevice.name,relief=FLAT)
self.machineNameLabel.grid(row=0,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.directoryLabel = Label(self.infoFrame, text="No project currently selected",relief=FLAT)
self.directoryLabel.grid(row=1,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.directoryLabel.config(text=dirStr)
self.outputDirButton = Button(self.infoFrame,text="No output directory selected. Click to select an output directory ",relief=RAISED,fg='red',command=self.askOutputDirectory)
self.outputDirButton.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton = Button(self.infoFrame,text="No filter selected. Click to select a filter",relief=RAISED,fg='red',command=self.selectFilter)
self.filterButton.grid(row=3,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.trialLabel = Label(self.infoFrame,text="Trial Number",relief=FLAT,justify=RIGHT,anchor=E)
self.trialLabel.grid(row=4,column=0, sticky=N+S+E+W,padx=2,pady =2)
vcmd = (self.master.register(self.validate),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
self.trialEntry = Entry(self.infoFrame,validate = 'key', validatecommand = vcmd)
self.trialEntry.grid(row=4,column=1, sticky=N+S+E+W,padx=2,pady =2)
self.infoFrame.columnconfigure(0, weight=1)
self.infoFrame.columnconfigure(1, weight=1)
self.infoFrame.rowconfigure(0, weight=1)
self.infoFrame.rowconfigure(1, weight=10)
self.infoFrame.rowconfigure(2, weight=10)
self.infoFrame.rowconfigure(3, weight=10)
self.infoFrame.rowconfigure(4, weight=10)
self.showPlotTools()
def validate(self, action, index, value_if_allowed,
prior_value, text, validation_type, trigger_type, widget_name):
if len(value_if_allowed)==0 :
return True
if text in '0123456789.-+ ':
try:
float(value_if_allowed)
return True
except ValueError:
return False
else:
return False
def askOutputDirectory(self):
dirStr = filedialog.askdirectory()
if len(dirStr):
dirStr = 'Output Path : '+dirStr
self.outputDirButton.config(text=dirStr)
def showPlotTools(self):
f2= Frame(self.selectPlotFrame, relief=FLAT,bg='#FADC46')
f2.grid(row=1,column=0,sticky=N+S+E+W,padx=10,pady =10)
b1 = Button(f2,text='3D K',relief=RAISED,command= lambda:self.plotButtonPressed(1))
b1.grid(row=0, column=0,sticky=N+S+E+W,padx=5,pady =5)
b2 = Button(f2,text='3D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(2))
b2.grid(row=0, column=1,sticky=N+S+E+W,padx=5,pady =5)
b3 = Button(f2,text='3D DP',relief=RAISED,command=lambda:self.plotButtonPressed(3))
b3.grid(row=0, column=2,sticky=N+S+E+W,padx=5,pady =5)
b4 = Button(f2,text='2D K',relief=RAISED,command=lambda:self.plotButtonPressed(4))
b4.grid(row=1, column=0,sticky=N+S+E+W,padx=5,pady =5)
b5 = Button(f2,text='2D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(5))
b5.grid(row=1, column=1,sticky=N+S+E+W,padx=5,pady =5)
b6 = Button(f2,text='2D DP',relief=RAISED,command=lambda:self.plotButtonPressed(6))
b6.grid(row=1, column=2,sticky=N+S+E+W,padx=5,pady =5)
b1.config(state=EguanaModel().machine.plot3DKButtonState)
b2.config(state=EguanaModel().machine.plot3DDstButtonState)
b3.config(state=EguanaModel().machine.plot3DDpButtonState)
b4.config(state=EguanaModel().machine.plot2DKButtonState)
b5.config(state=EguanaModel().machine.plot2DDstButtonState)
b6.config(state=EguanaModel().machine.plot2DDpButtonState)
f2.columnconfigure(0, weight=1)
f2.columnconfigure(1, weight=1)
f2.columnconfigure(2, weight=1)
f2.rowconfigure(0, weight=1)
f2.rowconfigure(1, weight=1)
def plotButtonPressed(self,number):
trialNum = self.trialEntry.get()
try:
trialNum = int(trialNum)
print(EguanaModel().machine.ifTrialExists(trialNum))
if EguanaModel().machine.ifTrialExists(trialNum):
self.plotFigure(number)
return True
else:
messagebox.showerror(
"Trial Number Error",
"The trial doesn't exist"
)
return False
except ValueError:
messagebox.showerror(
"Trial Number Error",
"Error with the trial number"
)
return False
def plotFigure(self,number):
m = CoilNumDialog(self.frame)
if m.isSet():
print(m.getValues())
EguanaModel().machine.getDataForTrialNumber(number)
def selectFilter(self):
ffPopup = FilterFunctionPopup(self)
if ffPopup.selectedFilter is not None:
EguanaModel().filterFunction = ffPopup.selectedFilter
ftPopup = FilterTypePopup(self,ffPopup.selectedFilter)
if (ftPopup.selectedHeadFilterType is not None) and (ftPopup.selectedHeadFilterType is not None):
self.menubar.setSelectedFilters(ffPopup.selectedFilter,ftPopup.selectedHeadFilterType,ftPopup.selectedJawFilterType)
EguanaModel().filterTypeHead = ftPopup.selectedHeadFilterType
EguanaModel().filterTypeJaw = ftPopup.selectedJawFilterType
EguanaModel().filterFunction = ffPopup.selectedFilter
buttonText = '{} - Jaw Filter : {} - Head Filter {}'.format(ffPopup.selectedFilter.name,ftPopup.selectedJawFilterType.name, ftPopup.selectedHeadFilterType.name)
self.filterButton.config(text=buttonText)
def updateSelectedFilters(self,ffName,ftHeadName,ftJawName):
buttonText = '{} - Jaw Filter : {} - Head Filter {}'.format(ffName,ftHeadName,ftJawName)
self.filterButton.config(text=buttonText)
def changeImage(self):
self.photo = PhotoImage(file=self.photoName)
self.photo = self.photo.subsample(2);
self.photo_label.image = self.photo
self.photo_label.config(image=self.photo)
def cursorPosition(self,event):
if event.widget == self.openButton3D:
if self.photoName == "eguana2.gif":
self.photoName = "eguana.gif"
self.changeImage()
elif event.widget == self.openButton2D:
if self.photoName == "eguana.gif":
self.photoName = "eguana2.gif"
self.changeImage()
class Visualize:
def __init__(self, solution):
self.solution = solution
self.time = 0
self.full = solution.full
self.shiftRight = 20
self.shiftDown = 20
self.separation = 90
self.scale = 60
self.textVShift = 10
self.root = Tk()
self.canvas = Canvas(self.root)
self.canvas.pack(fill=BOTH, expand=YES)
self.root.bind("<KeyRelease>", self.key_released)
self.timeLabel = Label(self.root, text='time_lavel')
self.timeLabel.pack(side=RIGHT)
self.setup()
self.draw()
if self.full:
mainloop()
def key_released(self, event):
if event.char == 'j':
if self.time < self.solution.maxt:
self.time = self.time + 1
self.draw()
elif event.char == 'k':
if self.time > 0:
self.time = self.time - 1
self.draw()
elif event.char == 'q':
self.root.quit()
def getBBox(self, v):
return (self.shiftRight + self.separation*v[0],
self.shiftDown + self.separation*v[1],
self.shiftRight + self.separation*v[0] + self.scale,
self.shiftDown + self.separation*v[1] + self.scale)
def getCenter(self, v):
return (self.shiftRight + self.separation*v[0] + self.scale / 2,
self.shiftDown + self.separation*v[1] + self.scale / 2)
def getStatusPos(self, v):
(x,y) = self.getCenter(v)
return (x,y - self.textVShift)
def getDecisionPos(self, v):
(x,y) = self.getCenter(v)
return (x,y + self.textVShift)
def getEdgePos(self, e):
v0 = self.getCenter(e[0])
v1 = self.getCenter(e[1])
if v0[0] == v1[0]:
if v0[1] < v1[1]:
return (v0[0], v0[1] + self.scale / 2), (v1[0], v1[1] - self.scale / 2)
else:
return (v0[0], v0[1] - self.scale / 2), (v1[0], v1[1] + self.scale / 2)
elif v0[1] == v1[1]:
if v0[0] < v1[0]:
return (v0[0] + self.scale / 2, v0[1]), (v1[0] - self.scale / 2, v1[1])
else:
return (v0[0] - self.scale / 2, v0[1]), (v1[0] + self.scale / 2, v1[1])
return v0, v1
def setup(self):
self.nodeStatus = {}
self.nodeDecision = {}
for v in self.solution.nodes:
self.canvas.create_oval(self.getBBox(v))
self.nodeStatus[v] = self.canvas.create_text(self.getStatusPos(v), text="asfs")
self.nodeDecision[v] = self.canvas.create_text(self.getDecisionPos(v), text="fs")
self.edges = {}
for e in self.solution.edges:
self.canvas.create_line(self.getEdgePos(e), fill='gray')
self.edges[e] = self.canvas.create_line(self.getEdgePos(e), arrow='last',
state=HIDDEN)
def draw(self):
# quick reference
nstat = self.solution.nstat
command = self.solution.command
self.timeLabel.config(text = '%r' % self.time)
t = self.time
for v in self.solution.nodes:
self.canvas.itemconfig(self.nodeStatus[v], text=nstat[v,self.time])
self.canvas.itemconfig(self.nodeDecision[v], text=command[v,self.time])
if not self.full:
return
occu = self.solution.occu
for e in self.solution.edges:
state = HIDDEN
if occu[e,t] == 1:
state = NORMAL
self.canvas.itemconfig(self.edges[e], state=state)
def initUI(self):
#top frame using all the remaining space
innerTopFrame = Frame(self, background="black")
innerTopFrame.pack(fill=BOTH, expand=1)
#CLOSE Label
innerBottomLeftFrame = Frame(self, background="black")
innerBottomLeftFrame.place(x=0, width=self.wRoot/2,
y=self.hRoot-200, height=200)
closeLabel = Label(innerBottomLeftFrame, bg="black", fg="black",
text="CLOSE", font=("Comic Sans MS", 48, "bold"))
innerBottomLeftFrame.bind("<Enter>", lambda f: closeLabel.config(fg="white"))
innerBottomLeftFrame.bind("<Leave>", lambda f: closeLabel.config(fg="black"))
innerBottomLeftFrame.bind("<Button-1>", lambda f: self.root.quit())
closeLabel.bind("<Button-1>", lambda f: self.root.quit())
closeLabel.pack(fill=BOTH)
#SHUT DOWN Label
innerBottomRightFrame = Frame(self, background="black")
innerBottomRightFrame.place(x=self.wRoot/2, width=self.wRoot/2,
y=self.hRoot-200, height=200)
shutdownLabel = Label(innerBottomRightFrame, bg="black", fg="black",
text="SHUT DOWN", font=("Comic Sans MS", 48, "bold"))
innerBottomRightFrame.bind("<Enter>", lambda f: shutdownLabel.config(fg="white"))
innerBottomRightFrame.bind("<Leave>", lambda f: shutdownLabel.config(fg="black"))
innerBottomRightFrame.bind("<Button-1>", self.shutdown)
shutdownLabel.bind("<Button-1>", self.shutdown)
shutdownLabel.pack(fill=BOTH)
#design the FullScreenApp
self.pack(fill=BOTH, expand=1)
class Remove_Machine_Modal(Modal):
def __init__(self, parent=None, title="Remove Machine"):
Modal.__init__(self, parent, title, geometry="500x85" if system() == "Windows" else "395x70")
def initialize(self):
self.label = Label(self, font=("TkTextFont", 13), width=36)
self.label.grid(row=0, column=0, padx=10, columnspan=2)
cancel_button = Button(self, text="Cancel", width=20, command=self.cancel)
self.bind("<Escape>", self.cancel)
cancel_button.grid(row=1, column=0, pady=10, padx=5, sticky="W")
ok_button = Button(self, text="OK", width=20, command=self.ok)
self.bind("<Return>", self.ok)
ok_button.grid(row=1, column=1, pady=10, sticky="E")
def ok(self, event=None):
self.remove = True
self.destroy()
def cancel(self, event=None):
self.remove = False
self.destroy()
def show(self, machine_name):
self.label.config(text="Remove " + machine_name + "?")
Modal.show(self)
return self.remove
def __makeWidgets(self):
Label(self, text="Welcome to PyMath 0.3!\n", justify="center").pack()
Label(self, text="Use the tabs to navigate between PyMath's different functions.", justify="center").pack()
l = Label(self, text="About/Help", fg="blue", padx=10, pady=10)
l.pack(side=BOTTOM, anchor=SE)
l.config(cursor="hand2")
l.bind("<Button-1>", self.showabout)
class TkTimerCore(TimerCore):
def __init__(self, *args, title, font_size, **kwargs):
def close_handler(event):
self.close()
def clicked_handler(event):
self.interact()
self.master = Tk()
self.master.wm_title(title)
self.master.bind('<Destroy>', close_handler)
self.label = Label(self.master, font='Sans {}'.format(int(font_size)))
self.label.pack(expand=True)
self.control = Toplevel()
self.control.wm_title(title + ' (control)')
self.control.minsize(150, 150)
self.control.bind('<Destroy>', close_handler)
self.button = Button(self.control, text='Start/Pause')
self.button.bind('<ButtonRelease>', clicked_handler)
self.button.pack(expand=True)
self.timeout_running = False
super().__init__(*args, **kwargs)
def start_timeout(self):
assert self.timeout_running is False
def timeout_call():
if self.timeout_running:
self.update()
self.master.after(25, timeout_call)
self.timeout_running = True
timeout_call()
def stop_timeout(self):
assert self.timeout_running is True
self.timeout_running = False
def mainloop(self):
return self.master.mainloop()
def shutdown(self):
self.master.quit()
def set_label_text(self, text, finished=False):
self.label.config(text=text)
if finished:
self.label.config(fg='red')
