def real_time_prediction():
import Tkinter as tk
from Tkinter import StringVar
from keras.models import load_model, model_from_yaml
from PIL import ImageTk, Image
model = load_model('eyeobserver.h5')
data = {}
# model = model_from_yaml('eyeobserver.model')
# model.load_weights('eyeobserver.h5')
size = config['image_dimension']
cap = cv2.VideoCapture(0)
root = tk.Tk()
root.bind('<Escape>', lambda e: root.quit())
ptext = StringVar()
ftext = StringVar()
ptext.set("hi")
lmain = tk.Label(root)
p = tk.Label(root, text=ptext)
finalprediction = tk.Label(root, text=ftext)
p.grid(row=0, column=0)
finalprediction.grid(row=1, column=0)
lmain.grid(row=3, column=0)
def showImage():
if not showImage.freeze:
_, img = cap.read()
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGBA)
img = img[:,:,:3]
img = cv2.resize(img, config['image_dimension'])
showImage.image = img
imgtk = ImageTk.PhotoImage(
image=Image.fromarray(img).resize((1280, 720), Image.BICUBIC))
lmain.imgtk = imgtk
lmain.configure(image=imgtk)
prediction = model.predict(
showImage.image[None,:,:,:].transpose(0, 3, 1, 2) / 255)
pstr = ("No eye likelihood: {0}\n"
"Not looking likelihood: {1}\n"
"Looking likelihood: {2}").format(prediction[0,0],
prediction[0,1],
prediction[0,2])
answer = ""
a = np.argmax(prediction[0])
if a == 0:
answer = "There isn't an eye here"
if a == 1:
answer = "The eye is not looking"
if a == 2:
answer = "The eye is looking"
p.configure(text=pstr)
finalprediction.configure(text=answer)
lmain.after(10, showImage)
showImage.freeze = False
showImage.image = None
showImage.counter = 0
tk.Button(root, text='Save noeye', command=
lambda: saveImage(Image.fromarray(showImage.image), 0)).grid(
row=0, column=1)
tk.Button(root, text='Save nosee', command=
lambda: saveImage(Image.fromarray(showImage.image), 1)).grid(
row=1, column=1)
tk.Button(root, text='Save see', command=
lambda: saveImage(Image.fromarray(showImage.image), 2)).grid(
row=2, column=1)
def freeze(e):
showImage.freeze = not showImage.freeze
def saveImage(img, category):
dirname = 'eyesDataSet/'
if category == 0:
dirname += 'noeye/'
if category == 1:
dirname += 'nosee/'
if category == 2:
dirname += 'see/'
dirname += 'images/'
from os import listdir
from os.path import isdir, join
files = [f for f in listdir(dirname) if not isdir(join(dirname, f))]
name = str(len(files)) + '.png'
# img.save(join(dirname, name))
if not 'x' in data:
img = np.array(img)
images = img.transpose(2, 0, 1).astype('float32') / 255
data['x'] = images[None, :, :, :]
data['y'] = np.zeros((1, 3))
data['y'][0,category] = 1
else:
img = np.array(img)
fixed_image = img.transpose(2, 0, 1).astype('float32') / 255
fixed_image = fixed_image[None, :, :, :]
l = np.zeros((1, 3))
l[0,category] = 1
data['y'] = np.concatenate((data['y'], l), axis=0)
data['x'] = np.concatenate((data['x'], fixed_image), axis=0)
data['training'] = False
def nonstopTrain():
data['training'] = True
while data['training']:
train(None)
def startTrain(e):
import threading
t = threading.Thread(target=nonstopTrain)
t.daemon = True
t.start()
def stopTrain(e):
data['training'] = False
def train(e):
if not 'x' in data:
return
model.fit(data['x'], data['y'], nb_epoch=1)
root.bind('p', freeze)
root.bind('t', train)
root.bind('r', startTrain)
root.bind('s', stopTrain)
showImage()
root.mainloop()
#activity 3
from Tkinter import Tk, Label, Entry, Button, StringVar
my_app = Tk(className='Figure Of Geometry')
L1 = Label(my_app, text='Figure Of Geometry', font=('Arial', 24))
L1.grid(row=0, column=0)
L2 = Label(
my_app,
text='Sphare, dimensions three, examples: ball, meatball, and others')
L2.grid(row=1, column=0)
L3 = Label(my_app, text='Radius: ')
L3.grid(row=2, column=0)
str3 = StringVar()
E1 = Entry(my_app, textvariable=str1)
E1.grid(row=2, column=1)
L5 = Label(my_app, text='result = ')
L5.grid(row=3, column=0)
L6 = Label(my_app, text='0')
L6.grid(row=3, column=1)
def area():
s = float(str1.get())
result = 4 * 3.14 * (s * s)
L6.config(text=result)
def screen(self):
self.sv = StringVar()
self.sv.set(self.value)
self.label = Label(frame, textvariable=self.sv, font=("arial", 40))
self.label.grid(row=self.place, column=1)
root.update()
def setUI(self):
self.parent.title("ServoGui")
self.pack(fill=BOTH, expand=1)
self.comPort = StringVar(self)
self.laststrm = StringVar(self)
settingFrame = Frame(self, borderwidth=1, relief=RAISED)
settingFrame.pack(fill=Y, side=LEFT)
Label(settingFrame, width=50, text="Port Settings", bg="green", fg="black").pack(fill=X)
ports = self.getComPorts()
w = apply(OptionMenu, (settingFrame, self.comPort) + tuple(ports))
w.pack(fill=X)
BaudFrame = Frame(settingFrame)
BaudFrame.pack(fill=X)
Label(BaudFrame, text="Baud:").pack(side=LEFT)
self.baud_entry = Entry(BaudFrame,
width=15,
validate="focusout",
validatecommand=self.baudValidate)
self.baud_entry.pack(side=LEFT, expand=True)
self.baud_entry.insert(0, "115200")
Button(settingFrame, text="Open Port", command=self.openPort). pack(fill=X)
Button(settingFrame, text="Close Port", command=self.closePort). pack(fill=X)
StreamFrame = Frame(settingFrame)
StreamFrame.pack()
self.btnStartStream = Button(StreamFrame,
text="Start Stream",
command=self.startStream,
state=DISABLED)
self.btnStopStream = Button(StreamFrame,
text="Stop Stream",
command=self.stopStream,
state=DISABLED)
self.btnGetConfig = Button(StreamFrame,
text="Get Config",
command=self.getConfig,
state=DISABLED)
self.btnStartStream.pack(side=LEFT)
self.btnStopStream.pack(side=LEFT)
self.btnGetConfig.pack(side=LEFT)
self.queue = Queue.Queue()
self.writequeue = Queue.Queue()
Label(settingFrame, width=50, text="Drive Settings", bg="green", fg="black").pack(fill=X)
DriveSettingsFrame = Frame(settingFrame, relief=SUNKEN)
DriveSettingsFrame.pack(fill=X)
driveSettingsFrames = []
self.driveSettingsEntries = []
for drivesetting in drivesettings:
driveSettingsFrames.append(Frame(DriveSettingsFrame))
driveSettingsFrames[-1].pack(fill=X)
Label(driveSettingsFrames[-1], text=drivesetting).pack(side=LEFT)
self.driveSettingsEntries.append(Entry(driveSettingsFrames[-1]))
self.driveSettingsEntries[-1].pack(side=RIGHT)
Button(DriveSettingsFrame, text="Send to drive", command=self.sendConfig).pack(fill=X)
Button(DriveSettingsFrame, text="Save config in drive", command=self.saveConfig).pack(fill=X)
Label(settingFrame, width=50, textvariable=self.laststrm, bg="green", fg="black").pack(fill=X)
# MatplotLib stuff
f = Figure(figsize=(5, 4), dpi=100)
self.a = f.add_subplot(411)
self.a.set_title("Requested and actual position")
self.b = f.add_subplot(412)
self.b.set_title("Error")
self.c = f.add_subplot(413)
self.c.set_title("Current meas ADC value")
self.d = f.add_subplot(414)
self.d.set_title("HALL")
self.canvas = FigureCanvasTkAgg(f, master=self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg(self.canvas, self)
toolbar.update()
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
self.hall = []
self.encoder_count = []
self.pos_error = []
self.requested_position = []
self.requested_delta = []
self.adc_value = []
self.pid_output = []
self.a.set_autoscaley_on(True)
self.encoder_line, = self.a.plot([], [])
self.error_line, = self.d.plot([], [])
self.reqpos_line, = self.a.plot([], [])
self.ADC_line, = self.c.plot([], [])
self.hall_line, = self.d.plot([], [])
self.pwm_line, = self.b.plot([], [])
self.updateCanvas()
def initGUI(self):
#create root window
self.rootWindow = Tk()
self.statusText = StringVar(value=self.statusStr)
self.setStatusStr("Simulation not yet started")
self.rootWindow.wm_title(self.titleText)
self.rootWindow.protocol('WM_DELETE_WINDOW', self.quitGUI)
self.rootWindow.geometry('550x700')
self.rootWindow.columnconfigure(0, weight=1)
self.rootWindow.rowconfigure(0, weight=1)
self.frameSim = Frame(self.rootWindow)
self.frameSim.pack(expand=YES, fill=BOTH, padx=5, pady=5, side=TOP)
self.status = Label(self.rootWindow,
width=40,
height=3,
relief=SUNKEN,
bd=1,
textvariable=self.statusText)
self.status.pack(side=TOP, fill=X, padx=1, pady=1, expand=NO)
self.runPauseString = StringVar()
self.runPauseString.set("Run")
self.buttonRun = Button(self.frameSim,
width=30,
height=2,
textvariable=self.runPauseString,
command=self.runEvent)
self.buttonRun.pack(side=TOP, padx=5, pady=5)
self.showHelp(
self.buttonRun,
"Runs the simulation (or pauses the running simulation)")
self.buttonStep = Button(self.frameSim,
width=30,
height=2,
text="Step Once",
command=self.stepOnce)
self.buttonStep.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonStep, "Steps the simulation only once")
self.buttonReset = Button(self.frameSim,
width=30,
height=2,
text="Reset",
command=self.resetModel)
self.buttonReset.pack(side=TOP, padx=5, pady=5)
self.showHelp(self.buttonReset, "Resets the simulation")
for param in self.model.params:
var_text = self.param_gui_names.get(param, param)
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1 + var_text.count('\n'),
text=var_text,
anchor=W,
takefocus=0)
lab.pack(side='left')
ent = Entry(can, width=11)
val = getattr(self.model, param)
if isinstance(val, bool):
val = int(val) # Show 0/1 which can convert back to bool
ent.insert(0, str(val))
ent.pack(side='left')
can.pack(side='top')
self.param_entries[param] = ent
if self.param_entries:
self.buttonSaveParameters = Button(
self.frameSim,
width=50,
height=1,
command=self.saveParametersCmd,
text="Save parameters to the running model",
state=DISABLED)
self.showHelp(
self.buttonSaveParameters, "Saves the parameter values.\n" +
"Not all values may take effect on a running model\n" +
"A model reset might be required.")
self.buttonSaveParameters.pack(side='top', padx=5, pady=5)
self.buttonSaveParametersAndReset = Button(
self.frameSim,
width=50,
height=1,
command=self.saveParametersAndResetCmd,
text="Save parameters to the model and reset the model")
self.showHelp(
self.buttonSaveParametersAndReset,
"Saves the given parameter values and resets the model")
self.buttonSaveParametersAndReset.pack(side='top', padx=5, pady=5)
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1,
text="Step size ",
justify=LEFT,
anchor=W,
takefocus=0)
lab.pack(side='left')
self.stepScale = Scale(can,
from_=1,
to=500,
resolution=1,
command=self.changeStepSize,
orient=HORIZONTAL,
width=25,
length=150)
self.stepScale.set(self.stepSize)
self.showHelp(
self.stepScale,
"Skips model redraw during every [n] simulation steps\n" +
"Results in a faster model run.")
self.stepScale.pack(side='left')
can.pack(side='top')
can = Canvas(self.frameSim)
lab = Label(can,
width=25,
height=1,
text="Step visualization delay in ms ",
justify=LEFT,
anchor=W,
takefocus=0)
lab.pack(side='left')
self.stepDelay = Scale(can,
from_=0,
to=max(2000, self.timeInterval),
resolution=10,
command=self.changeStepDelay,
orient=HORIZONTAL,
width=25,
length=150)
self.stepDelay.set(self.timeInterval)
self.showHelp(
self.stepDelay, "The visualization of each step is " +
"delays by the given number of " + "milliseconds.")
self.stepDelay.pack(side='left')
can.pack(side='top')
def createWidgets(self):
self.__config = ConfigParser.ConfigParser()
self.__config.set(self.DEFAULT_SECTION, 'input', '~/input.jpg')
self.__config.set(self.DEFAULT_SECTION, 'inverted', '0')
self.__config.set(self.DEFAULT_SECTION, 'output', '~/output.svg')
self.__config.set(self.DEFAULT_SECTION, 'preamble',
'G17 G21 G90 G64 P0.1 S4500 M3 M8')
self.__config.set(self.DEFAULT_SECTION, 'size', '256')
self.__config.set(self.DEFAULT_SECTION, 'scale', '1')
self.__config.set(self.DEFAULT_SECTION, 'width', '152.4')
self.__config.set(self.DEFAULT_SECTION, 'height', '101.6')
self.__config.set(self.DEFAULT_SECTION, 'columns', '3')
self.__config.set(self.DEFAULT_SECTION, 'rows', '2')
self.__config.set(self.DEFAULT_SECTION, 'margin', '10.0')
self.__config.set(self.DEFAULT_SECTION, 'thickness', '6.35')
self.__config.set(self.DEFAULT_SECTION, 'tool_diameter', '3.175')
self.__config.read(os.path.expanduser('~/.py-art.cfg'))
self.EntryFrame = Frame(self, bd=5)
self.EntryFrame.grid(row=0, column=1)
i = 0
Label(self.EntryFrame, text='Engrave an image\n').grid(row=i,
column=0,
columnspan=2)
i += 1
Label(self.EntryFrame, text='Input file').grid(row=i,
column=0,
sticky=E)
self.InputVar = StringVar()
self.InputVar.set(self.__config.get(self.DEFAULT_SECTION, 'input'))
Entry(self.EntryFrame, textvariable=self.InputVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Size').grid(row=i, column=0, sticky=E)
self.SizeVar = IntVar()
self.SizeVar.set(self.__config.get(self.DEFAULT_SECTION, 'size'))
Entry(self.EntryFrame, textvariable=self.SizeVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Scale').grid(row=i, column=0, sticky=E)
self.ScaleVar = IntVar()
self.ScaleVar.set(self.__config.get(self.DEFAULT_SECTION, 'scale'))
Entry(self.EntryFrame, textvariable=self.ScaleVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Rows').grid(row=i, column=0, sticky=E)
self.RowsVar = IntVar()
self.RowsVar.set(self.__config.get(self.DEFAULT_SECTION, 'rows'))
Entry(self.EntryFrame, textvariable=self.RowsVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Columns').grid(row=i, column=0, sticky=E)
self.ColumnsVar = IntVar()
self.ColumnsVar.set(self.__config.get(self.DEFAULT_SECTION, 'columns'))
Entry(self.EntryFrame, textvariable=self.ColumnsVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Image effects').grid(row=i,
column=0,
sticky=E)
self.InvertedVar = IntVar()
self.InvertedVar.set(
self.__config.getint(self.DEFAULT_SECTION, 'inverted'))
Checkbutton(self.EntryFrame,
text='Inverted',
variable=self.InvertedVar).grid(row=i, column=1, sticky=W)
if IN_AXIS:
i += 1
Label(self.EntryFrame, text='Preamble').grid(row=i,
column=0,
sticky=E)
self.PreambleVar = StringVar()
self.PreambleVar.set(
self.__config.get(self.DEFAULT_SECTION, 'preamble'))
Entry(self.EntryFrame, textvariable=self.PreambleVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Width').grid(row=i,
column=0,
sticky=E)
self.WidthVar = DoubleVar()
self.WidthVar.set(self.__config.get(self.DEFAULT_SECTION, 'width'))
Entry(self.EntryFrame, textvariable=self.WidthVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Height').grid(row=i,
column=0,
sticky=E)
self.HeightVar = DoubleVar()
self.HeightVar.set(
self.__config.get(self.DEFAULT_SECTION, 'height'))
Entry(self.EntryFrame, textvariable=self.HeightVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Margin').grid(row=i,
column=0,
sticky=E)
self.MarginVar = DoubleVar()
self.MarginVar.set(
self.__config.get(self.DEFAULT_SECTION, 'margin'))
Entry(self.EntryFrame, textvariable=self.MarginVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Tool diameter').grid(row=i,
column=0,
sticky=E)
self.ToolDiameterVar = DoubleVar()
self.ToolDiameterVar.set(
self.__config.get(self.DEFAULT_SECTION, 'tool_diameter'))
Entry(self.EntryFrame, textvariable=self.ToolDiameterVar,
width=50).grid(row=i, column=1)
i += 1
Label(self.EntryFrame, text='Thickness').grid(row=i,
column=0,
sticky=E)
self.ThicknessVar = DoubleVar()
self.ThicknessVar.set(
self.__config.get(self.DEFAULT_SECTION, 'thickness'))
Entry(self.EntryFrame, textvariable=self.ThicknessVar,
width=50).grid(row=i, column=1)
i += 1
Button(self.EntryFrame,
text='Trace boundary in AXIS and Quit',
command=self.WriteBoundaryTraceToAxis).grid(row=i,
column=1,
sticky=E)
i += 1
Button(self.EntryFrame,
text='Engrave in AXIS and Quit',
command=self.WriteEngravingToAxis).grid(row=i,
column=1,
sticky=E)
i += 1
Button(self.EntryFrame,
text='Cut boundary in AXIS and Quit',
command=self.WriteBoundaryCutToAxis).grid(row=i,
column=1,
sticky=E)
else:
i += 1
Label(self.EntryFrame, text='Output file').grid(row=i,
column=0,
sticky=E)
self.OutputVar = StringVar()
self.OutputVar.set(
self.__config.get(self.DEFAULT_SECTION, 'output'))
Entry(self.EntryFrame, textvariable=self.OutputVar,
width=50).grid(row=i, column=1)
i += 1
Button(self.EntryFrame,
text='Write to SVG and Quit',
command=self.WriteToSvg).grid(row=i, column=1, sticky=E)
def set_Tk_var():
global gtp_x
gtp_x = StringVar()
global gtp_y
gtp_y = StringVar()
global gtp_z
gtp_z = StringVar()
global velocity
velocity = StringVar()
global step_x
step_x = StringVar()
global step_z
step_z = StringVar()
global step_y
step_y = StringVar()
global radio_resolution
radio_resolution = StringVar()
global path_x
path_x = StringVar()
global path_y
path_y = StringVar()
global path_z
path_z = StringVar()
global path_min
path_min = StringVar()
global path_max
path_max = StringVar()
global constant_amps
constant_amps = StringVar()
global constant_duration
constant_duration = StringVar()
global square_amp
square_amp = StringVar()
global square_duration
square_duration = StringVar()
global square_duty
square_duty = StringVar()
global square_freq
square_freq = StringVar()
global sin_freq
sin_freq = StringVar()
global sin_amplitude
sin_amplitude = StringVar()
global sin_offset
sin_offset = StringVar()
global sin_duration
sin_duration = StringVar()
global ramping_amp
ramping_amp = StringVar()
global ramping_rise
ramping_rise = StringVar()
global ramping_steady
ramping_steady = StringVar()
global ramping_rest
ramping_rest = StringVar()
global ramping_duration
ramping_duration = StringVar()
global status_pos_v
status_pos_v = StringVar()
global status_vel_v
status_vel_v = StringVar()
global status_res_v
status_res_v = StringVar()
global status_magfield_v
status_magfield_v = StringVar()
global status_relpos_v
status_relpos_v = StringVar()
global status_abspos_v
status_abspos_v = StringVar()
global radio_pos_mode
radio_pos_mode = StringVar()
global status_current_v
status_current_v = StringVar()
global status_wave_v
status_wave_v = StringVar()
global status_duration_v
status_duration_v = StringVar()
def __init__(self,
master,
file_mask,
default_file,
edit_height=None,
user_onChange=None,
rename_on_edit=0,
font=None,
coloring=True,
allowNone=False,
highlighter=None,
directory='.'):
'''
file_mask: file mask (e.g. "*.foo") or list of file masks (e.g. ["*.foo", "*.abl"])
'''
self.master = master
self.directory = directory
self.user_onChange = user_onChange
Frame.__init__(self, master)
row = 0
self.unmodified = True
self.allowNone = allowNone
self.file_extension = ""
if type(file_mask) != list:
file_mask = [file_mask]
if "." in file_mask[0]:
self.file_extension = file_mask[0][file_mask[0].rfind('.'):]
# read filenames
self.file_mask = file_mask
self.updateList()
# filename frame
self.list_frame = Frame(self)
self.list_frame.grid(row=row, column=0, sticky="WE")
self.list_frame.columnconfigure(0, weight=1)
# create list
self.picked_name = StringVar(self)
self.makelist()
# refresh button
self.refresh_button = Button(self.list_frame,
text='<- refresh',
command=self.refresh,
height=1)
self.refresh_button.grid(row=0, column=1, sticky='E')
# save button
self.save_button = Button(self.list_frame,
text="save",
command=self.save,
height=1)
self.save_button.grid(row=0, column=2, sticky="E")
# editor
row += 1
if coloring:
self.editor = SyntaxHighlightingText(self,
self.onEdit,
highlighter=highlighter)
else:
self.editor = ScrolledText2(self, self.onEdit)
if font != None:
self.editor.configure(font=font)
if edit_height is not None:
self.editor.configure(height=edit_height)
self.editor.grid(row=row, column=0, sticky="NEWS")
self.rowconfigure(row, weight=1)
self.columnconfigure(0, weight=1)
# option to change filename on edit
row += 1
self.options_frame = Frame(self)
self.options_frame.grid(row=row, column=0, sticky=W)
self.rename_on_edit = IntVar()
self.cb = Checkbutton(self.options_frame,
text="rename on edit",
variable=self.rename_on_edit)
self.cb.pack(side=LEFT)
self.cb.configure(command=self.onChangeRename)
self.rename_on_edit.set(rename_on_edit)
# filename frame
row += 1
self.filename_frame = Frame(self)
self.filename_frame.grid(row=row, column=0, sticky="WE")
self.filename_frame.columnconfigure(0, weight=1)
# save as filename
self.save_name = StringVar(self)
self.save_edit = Entry(self.filename_frame,
textvariable=self.save_name)
self.save_edit.grid(row=0, column=0, sticky="WE")
self.save_name.trace("w", self.onSaveChange)
# pick default if applicableButton
self.select(default_file)
self.row = row
def init_streaming_panel(self, frame):
self.streamPanel = ttk.Frame(master=frame)
self.streamPanel.pack(anchor='w')
ttk.Frame(master=self.streamPanel, width=150).grid(column=0,
row=0,
rowspan=2)
# Bluetooth connect button
self.btn_connect = ttk.Button(master=self.streamPanel, text='Connect')
self.btn_connect.grid(column=1, row=0, rowspan=2)
ttk.Frame(master=self.streamPanel, width=50).grid(row=0,
rowspan=2,
column=2)
# Battery-level indication
self.battIndication1 = ttk.Label(master=self.streamPanel,
text=' -',
width=12)
self.battIndication2 = ttk.Label(master=self.streamPanel,
text=' -',
width=12)
self.battIndication1.grid(row=0, column=3)
self.battIndication2.grid(row=1, column=3)
# Headset labels
ttk.Label(master=self.streamPanel,
text='Headset 1: ',
background=self.colors[0]).grid(row=0, column=4)
ttk.Label(master=self.streamPanel,
text='Headset 2: ',
background=self.colors[1]).grid(row=1, column=4)
ttk.Frame(master=self.streamPanel, width=10).grid(row=0,
rowspan=2,
column=5)
# filenames for data recording
self._filename_vars = []
self._filename_vars.append(tk.StringVar(value='filename1'))
self._filename_vars.append(tk.StringVar(value='filename2'))
ttk.Label(master=self.streamPanel, text='Save File 1: ').grid(row=0,
column=6)
ttk.Entry(master=self.streamPanel,
textvariable=self._filename_vars[0]).grid(row=0, column=7)
ttk.Label(master=self.streamPanel, text='Save File 2: ').grid(row=1,
column=6)
ttk.Entry(master=self.streamPanel,
textvariable=self._filename_vars[1]).grid(row=1, column=7)
ttk.Frame(master=self.streamPanel, width=50).grid(row=0,
rowspan=2,
column=8)
# Start/Stop streaming button
self.b_toggle_streaming = ttk.Button(master=self.streamPanel,
text='Start Streaming')
self.b_toggle_streaming.grid(row=0, column=9)
self.b_toggle_streaming.config(state='disabled')
# Start/Stop recording button
self.b_toggle_recording = ttk.Button(master=self.streamPanel,
text='Start Recording')
self.b_toggle_recording.grid(row=1, column=9)
self.b_toggle_recording.config(state='disabled')
ttk.Frame(master=self.streamPanel, width=20).grid(row=0,
rowspan=2,
column=10)
self.stream_counter_value = StringVar(value='-')
self.stream_counter = ttk.Label(master=self.streamPanel,
textvariable=self.stream_counter_value,
width=3)
self.stream_counter.grid(row=0, column=11, sticky='e')
self.rec_counter_value = StringVar(value='-')
self.rec_counter = ttk.Label(master=self.streamPanel,
textvariable=self.rec_counter_value,
width=3)
self.rec_counter.grid(row=1, column=11, sticky='e')
ttk.Frame(master=self.streamPanel, width=50).grid(row=0,
rowspan=2,
column=12)
if True:
# TODO: Perform this with pointing-device i.s.o. buttons
# Start kiss button
self.b_start_kiss = ttk.Button(master=self.streamPanel,
text='Start kiss')
self.b_start_kiss.grid(row=0, column=13, sticky='we')
self.b_start_kiss.config(state='disabled')
# Stop kiss button
self.b_stop_kiss = ttk.Button(master=self.streamPanel,
text='Stop kiss')
self.b_stop_kiss.grid(row=0, column=14, sticky='we')
self.b_stop_kiss.config(state='disabled')
# Point of interest button
self.b_poi = ttk.Button(master=self.streamPanel,
text='Point of interest')
self.b_poi.grid(row=1, column=13, columnspan=2, sticky='we')
self.b_poi.config(state='disabled')
ttk.Frame(master=self.streamPanel, width=50).grid(column=15, rowspan=2)
self.statusText = ttk.Label(master=self.streamPanel, text="Idle")
self.statusText.grid(row=0, column=16, rowspan=2)
self.rb_stream.invoke()
popup.after(2500,lambda:popup.destroy())
def choose_file():
file_name_1 = filedialog.askopenfilename()
if file_name_1 != '':
path.set(file_name_1)
file_name.set(file_name_1)
elif path.get() == '':
no_click()
else:
return
root = tk.Tk(className="冲突检测")
sheet_name = 1
center_window(root, 750, 100)
file_select_label = ttk.Label(root, text="待检测文档：")
file_select_label.grid(column=1, row=0)
path = StringVar()
file_name = StringVar()
duibiao_file_path = ttk.Entry(root, textvariable=path, width=50, state=['readonly'])
duibiao_file_path.grid(column=2, row=0)
choose_file_action = ttk.Button(root,text="浏览", width=10, command=choose_file)
choose_file_action.grid(column=3, row=0)
check_action = ttk.Button(root,text="检测", width=10, command=check_output)
check_action.grid(column=2, row=1)
for child in root.winfo_children():
child.grid(padx=5, pady=5)
root.mainloop()
def __init__(self,
master,
dir='.',
filesettings=None,
defaultname='*unknown{}',
importhook=None,
deletehook=None,
projecthook=None,
filecontenthook=None,
selectfilehook=None,
fileslisthook=None,
updatehook=None,
onchangehook=None):
self.master = master
Frame.__init__(self, master)
self._dirty = False
self._dirty_file_name = ''
self._editor_dirty = False
self.dir = dir
self.fsettings = filesettings
self.defaultname = defaultname
# hooks
self.import_hook = importhook
self.delete_hook = deletehook
self.save_project_hook = projecthook
self.filecontent_hook = filecontenthook
self.update_hook = updatehook
self.select_file_hook = selectfilehook
self.files_list_hook = fileslisthook
self.onchange_hook = onchangehook
Frame.__init__(self, master)
row = 0
self.columnconfigure(1, weight=2)
self.selected_file = StringVar(master)
files = []
self.file_buffer = {}
self.file_reload = True
if len(files) == 0: files.append("")
self.list_files = apply(OptionMenu,
(self, self.selected_file) + tuple(files))
self.list_files.grid(row=row, column=1, sticky="NWE")
self.selected_file.trace("w", self.select_file)
# new file
self.btn_newfile = Button(self, text='New', command=self.new_file)
self.btn_newfile.grid(row=row, column=2, sticky="E")
# import file
self.btn_importfile = Button(self,
text='Import',
command=self.import_file)
self.btn_importfile.grid(row=row, column=3, sticky="E")
# delete file
self.btn_delfile = Button(self,
text='Delete',
command=self.delete_file)
self.btn_delfile.grid(row=row, column=4, sticky="E")
# save button
self.btn_update_file = Button(self,
text='Save',
command=self.save_file)
self.btn_update_file.grid(row=row, column=6, sticky="E")
# save as.. button
self.btn_saveas_file = Button(self,
text='Save as...',
command=self.saveas_file)
self.btn_saveas_file.grid(row=row, column=7, sticky="E")
# editor
row += 1
self.editor = SyntaxHighlightingText(
self, change_hook=self.onchange_filecontent)
self.editor.grid(row=row, column=1, columnspan=7, sticky="NWES")
self.rowconfigure(row, weight=1)
def __init__(self, parent, options):
if options == None:
options = {}
DefaultOptions = {
'colorspace': 'RGB',
'K': 2,
'km_init': 'first',
'verbose': False,
'single_thr': 0.6,
'metric': 'basic',
'max_iter': 50
}
for op in DefaultOptions:
if not op in options:
options[op] = DefaultOptions[op]
self.options = options
self.K_ant = 0
self.num_im = -1
Frame.__init__(self, parent)
self.parent = parent
self.parent.title("TAGGING")
self.F1 = Frame(parent, width=150, borderwidth=2, relief=GROOVE)
self.F2 = Frame(parent, width=150, borderwidth=2, relief=GROOVE)
self.F3 = Frame(parent)
self.F4 = Frame(parent, borderwidth=2, relief=GROOVE)
self.F5 = Frame(parent, borderwidth=2, relief=GROOVE)
self.F1.pack(side=LEFT, fill=Y, pady=4, padx=4)
self.F2.pack(side=LEFT, fill=Y, pady=4)
self.F3.pack(side=TOP, expand=True, fill=BOTH, pady=4, padx=4)
self.F4.pack(side=TOP, fill=BOTH, expand=0, padx=4)
self.F5.pack(side=BOTTOM, fill=BOTH, expand=0, pady=4, padx=4)
self.F1.pack_propagate(0)
self.F2.pack_propagate(0)
self.F3.pack_propagate(0)
lbl = Label(self.F1, text="Groundtruth")
lbl.grid(row=0, sticky=W)
Frame(self.F1, borderwidth=1, relief=GROOVE, height=2).grid(row=1,
sticky=W)
lbl = Label(self.F2, text="Detected")
lbl.grid(row=0, sticky=W, columnspan=2)
Frame(self.F2, borderwidth=1, relief=GROOVE,
height=2).grid(row=1, sticky=W, columnspan=2)
self.filename = Button(self.F3,
text="filename",
command=self.ChooseFile)
self.filename.pack(side=TOP, expand=0)
# #matplotlib setup
# plt.ion()
self.figure = plt.figure(figsize=(2, 2), frameon=False)
self.axes = self.figure.add_subplot(111)
self.Canvas = FigureCanvasTkAgg(self.figure, master=self.F3)
# self.Canvas.show()
self.Canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
plt.axis('off')
b = Button(self.F4, text=" <<<10 ", command=self.PreviousFast)
b.pack(side=LEFT, padx=(20, 2), pady=3)
b = Button(self.F4, text=" <<1 ", command=self.Previous)
b.pack(side=LEFT, pady=3)
self.im_name = Button(self.F4,
text="image",
bd=0,
command=self.Results)
self.im_name.pack(side=LEFT, expand=True)
b = Button(self.F4, text=" 1>> ", command=self.Next)
b.pack(side=LEFT)
b = Button(self.F4, text=" 10>>> ", command=self.NextFast)
b.pack(side=LEFT, padx=(2, 20))
F51 = Frame(self.F5)
F52 = Frame(self.F5)
F53 = Frame(self.F5)
F51.pack(fill=BOTH, expand=1, side=LEFT)
Frame(self.F5, borderwidth=1, relief=GROOVE, width=2).pack(side=LEFT,
fill=Y)
F52.pack(fill=BOTH, expand=1, side=LEFT)
Frame(self.F5, borderwidth=1, relief=GROOVE, width=2).pack(side=LEFT,
fill=Y)
F53.pack(fill=BOTH, expand=1, side=LEFT)
Label(F51, text="Color space").pack()
Frame(F51, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
Label(F52, text="K-Means").pack()
Frame(F52, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
Label(F53, text="Labelling").pack()
Frame(F53, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
self.ColorMode = StringVar()
self.ColorMode.set(self.options[COLORSSPACE['key']])
for text, mode in COLORSSPACE['options_gui']:
b = Radiobutton(F51,
text=text,
variable=self.ColorMode,
value=mode,
command=self.Results)
b.pack(anchor=W)
Frame(F51, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
Label(F51, text="Grouping", padx=20).pack()
Frame(F51, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
self.Group = BooleanVar()
self.Group.set(True)
b = Checkbutton(F51,
text='Group same label colors',
variable=self.Group,
command=self.Results)
b.pack(anchor=W)
F521 = Frame(F52)
F522 = Frame(F52)
F521.pack(fill=BOTH)
F522.pack(fill=BOTH)
# F523 = Frame(F52)
# F523.pack(fill=BOTH)
self.K = StringVar()
self.K.set(self.options['K'])
# f = Frame(F52)
# f.pack(side=TOP, fill=BOTH, expand=0)
Label(F521, text="K : ").pack(side=LEFT)
Entry(F521, textvariable=self.K, width=3,
justify=CENTER).pack(side=LEFT, padx=4)
# Label(F52, text="Init", padx=20).pack(anchor=W)
# Frame(F521,borderwidth=1,relief=GROOVE,width=2).pack(side=RIGHT, fill=Y, padx=2)
self.Fitting = StringVar()
self.Fitting.set(self.options[FITTING['key']])
# f = Frame(F52)
# f.pack(side=RIGHT, fill=BOTH, expand=0)
for text, mode in FITTING['options_gui']:
b = Radiobutton(F521,
text=text,
variable=self.Fitting,
value=mode,
command=self.Results)
b.pack(anchor=W, padx=4)
Frame(F522, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
Label(F522, text="Centroid Init", padx=20).pack()
Frame(F522, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
# IM = [('First points','first'),('Randomize', 'random'),('Distribtued','distributed'),('Other','Other')]
self.KMInit = StringVar()
self.KMInit.set(self.options[CENTROIDSINIT['key']])
for text, mode in CENTROIDSINIT['options_gui']:
b = Radiobutton(F522,
text=text,
variable=self.KMInit,
value=mode,
command=self.Results)
b.pack(anchor=W)
self.Thr = StringVar()
self.Thr.set(self.options['single_thr'])
f = Frame(F53)
f.pack(side=TOP, fill=BOTH, expand=0)
Label(f, text="single\nbasic >\ncolor", justify=LEFT).pack(side=LEFT)
Entry(f, textvariable=self.Thr, width=4,
justify=CENTER).pack(side=LEFT)
# self.Synonymous = BooleanVar()
# self.Synonymous.set(self.options['synonyms'])
# b = Checkbutton(F53, text='Synonymous', variable=self.Synonymous, command=self.Results)
# b.pack(anchor=W)
Frame(F53, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
Label(F53, text="Similarity Metric", padx=2).pack()
Frame(F53, borderwidth=1, relief=GROOVE, height=2).pack(fill=X)
self.Metric = StringVar()
self.Metric.set(self.options[SIMILARITY['key']])
for text, mode in SIMILARITY['options_gui']:
b = Radiobutton(F53,
text=text,
variable=self.Metric,
value=mode,
command=self.Results)
b.pack(anchor=W)
def __init__(self):
#
root = Tk()
defaultFont = tkFont.Font(family="Libertine", size=9, weight="normal")
default_font = tkFont.nametofont("TkDefaultFont")
default_font.configure(family="Libertine", size=9, weight="normal")
_style = Style()
logging.debug(_style.theme_names())
_style.theme_use('default')
root.option_add("*Font", defaultFont)
root.option_add("*TkFixedFont", defaultFont)
root.title("Carnet d'adresses")
root.geometry('604x857+838+100')
carnet_support.set_Tk_var()
self.value_liste = ['Toutes', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z']
self.fenetre = Carnet_d_adresses(root)
carnet_support.init(root, self.fenetre)
self.dict_champs = {'Nom': self.fenetre.Entry2,
'Prénom': self.fenetre.Entry3,
'Adresse1': self.fenetre.Entry4,
'Adresse2': self.fenetre.Entry6,
'CodePostal': self.fenetre.Entry5,
'Ville': self.fenetre.Entry1}
self.nom_fichier = environ['HOME'] + '/.carnet/Carnet_d_adresses.xml'
#
try:
_fichier = open(self.nom_fichier, 'r')
except:
_fichier = open(self.nom_fichier, 'w')
_fichier.write('<?xml version="1.0" encoding="UTF-8"?>\n<Carnet/>')
_fichier.close()
_fichier = open(self.nom_fichier, 'r')
self.carnet = ElementTree.parse(_fichier,
parser=ElementTree.XMLParser(encoding="utf-8"))
_fichier.close()
self.liste = self.carnet.getroot()
self.liste[:] = sorted(self.liste, key=self.clef)
#
_fichier_vide = open("./Carnet_d_adresses_vide.xml")
self.modele = ElementTree.parse(_fichier_vide,
parser=ElementTree.XMLParser(encoding="utf-8")).getroot()
_fichier_vide.close()
#
# configuration des éléments...
# onglet Détails
self.civilite = [StringVar(), StringVar(), StringVar(),
StringVar(), StringVar(), StringVar()]
#
self.fenetre.TButton6.config(command=lambda: self.chercher(0))
self.fenetre.TButton1.config(command=lambda: self.effacer(1))
self.fenetre.TButton2.config(command=lambda: self.effacer(2))
self.fenetre.TButton3.config(command=lambda: self.effacer(3))
self.fenetre.TButton4.config(command=lambda: self.effacer(4))
self.fenetre.TButton5.config(command=lambda: self.effacer(5))
self.fenetre.TButton14.config(command=lambda: self.effacer(6))
self.fenetre.TButton13.config(command=lambda: self.effacer(7))
self.fenetre.TButton7.config(command=self.tout_effacer)
self.fenetre.Button11.config(command=lambda: self.ajouter(ElementTree.Element('rien')))
self.fenetre.Button12.config(command=lambda: self.supprimer_tel(ElementTree.Element('rien')))
self.fenetre.Button1.config(command=lambda: self.enregistrer(0))
self.fenetre.Button2.config(command=lambda: self.enregistrer(2))
self.fenetre.Button2.configure(state=tk.DISABLED)
self.fenetre.Button3.config(command=lambda: self.supprimer(0))
self.fenetre.Button3.configure(state=tk.DISABLED)
self.fenetre.TCheckbutton1.configure(variable=self.civilite[0],
command=lambda: self.changer_civilite(0))
self.fenetre.TCheckbutton2.configure(variable=self.civilite[1],
command=lambda: self.changer_civilite(1))
self.fenetre.TCheckbutton3.configure(variable=self.civilite[2],
command=lambda: self.changer_civilite(2))
self.fenetre.TCheckbutton4.configure(variable=self.civilite[3],
command=lambda: self.changer_civilite(3))
self.fenetre.TCheckbutton5.configure(variable=self.civilite[4],
command=lambda: self.changer_civilite(4))
self.fenetre.TCheckbutton6.configure(variable=self.civilite[5],
command=lambda: self.changer_civilite(5))
self.fenetre.Button9.config(command=lambda: self.imprimer(1))
# onglet Liste
self.fenetre.Canvas1.create_rectangle(0, 0, 423, 278, fill='White')
self.timbre = PhotoImage(file="./timbre_pie_xii.gif")
self.fenetre.Canvas1.create_image(335, 10, image=self.timbre, anchor='nw')
self.fenetre.Canvas1.image = self.timbre
self.fenetre.Canvas2.create_rectangle(0, 0, 423, 278, fill='White')
self.fenetre.Canvas2.create_image(335, 10, image=self.timbre, anchor='nw')
self.fenetre.TButton10.config(command=lambda: self.imprimer(1))
self.fenetre.TButton11.config(command=lambda: self.imprimer(2))
# selection de la lettre
self.fenetre.TCombobox1.configure(values=self.value_liste)
self.fenetre.TCombobox1.current(0)
self.fenetre.TCombobox1.bind('<<ComboboxSelected>>',
lambda e: self.lettre_selection(self.fenetre.TCombobox1))
self.lettre_selection(self.fenetre.TCombobox1)
# selection d'une personne
self.fenetre.TButton8.config(command=lambda: self.personne_selection(1))
self.fenetre.TButton12.config(command=lambda: self.personne_selection(2))
self.fenetre.TButton9.config(command=lambda: self.personne_deselection(1))
self.fenetre.TButton15.config(command=lambda: self.personne_deselection(2))
self.fenetre.Scrolledlistbox1.bind('<<ListboxSelect>>', lambda e: self.selection(e))
self.fenetre.Scrolledlistbox2.bind('<<ListboxSelect>>', lambda e: self.selection(e))
#
self.fenetre.Text1.configure(foreground="grey")
self.fenetre.Text1.tag_configure("NOIR", foreground="black")
#
root.mainloop()
##
##def tampil_pesan():
## showinfo("pesan", "hello world")
##
##B = Button(my_app, text = "Hello", command = tampil_pesan)
##B.grid(row = 2, column=1)
##my_app.mainloop()
##===========================================================
from Tkinter import Tk, Label, Entry, Button, StringVar
from tkMessageBox import showinfo
my_app = Tk(className='Access to widget properti')
L1 = Label(my_app, text="Nama Mahasiswa")
L1.grid(row=0, column=0)
str1 = StringVar()
E1 = Entry(my_app, textvariable=str1)
E1.grid(row=0, column=1)
L2 = Label(my_app, text="umur")
L2.grid(row=1, column=0)
str2 = StringVar(value=0)
E2 = Entry(my_app, textvariable=str2)
E2.grid(row=1, column=1)
def info():
"""Take data in Entry E1 anf E2, and show with messagebox"""
_info = str1.get() + "berumur" + str2.get() + "tahun"
showinfo("pesan", _info)
def __init__(self,
master=None,
year=None,
month=None,
firstweekday=calendar.MONDAY,
locale=None,
activebackground='#b1dcfb',
activeforeground='black',
selectbackground='#003eff',
selectforeground='white',
command=None,
borderwidth=1,
relief="solid",
on_click_month_button=None):
"""
WIDGET OPTIONS
locale, firstweekday, year, month, selectbackground,
selectforeground, activebackground, activeforeground,
command, borderwidth, relief, on_click_month_button
"""
if year is None:
year = self.datetime.now().year
if month is None:
month = self.datetime.now().month
self._selected_date = None
self._sel_bg = selectbackground
self._sel_fg = selectforeground
self._act_bg = activebackground
self._act_fg = activeforeground
self.on_click_month_button = on_click_month_button
self._selection_is_visible = False
self._command = command
ttk.Frame.__init__(self,
master,
borderwidth=borderwidth,
relief=relief)
self.bind("<FocusIn>",
lambda event: self.event_generate('<<DatePickerFocusIn>>'))
self.bind("<FocusOut>",
lambda event: self.event_generate('<<DatePickerFocusOut>>'))
self._cal = get_calendar(locale, firstweekday)
# custom ttk styles
style = ttk.Style()
style.layout('L.TButton', ([('Button.focus', {
'children': [('Button.leftarrow', None)]
})]))
style.layout('R.TButton', ([('Button.focus', {
'children': [('Button.rightarrow', None)]
})]))
self._font = tkFont.Font()
self._header_var = StringVar()
# header frame and its widgets
hframe = ttk.Frame(self)
lbtn = ttk.Button(hframe,
style='L.TButton',
command=self._on_press_left_button)
lbtn.pack(side=LEFT)
self._header = ttk.Label(hframe,
width=15,
anchor=CENTER,
textvariable=self._header_var)
self._header.pack(side=LEFT, padx=12)
rbtn = ttk.Button(hframe,
style='R.TButton',
command=self._on_press_right_button)
rbtn.pack(side=LEFT)
hframe.grid(columnspan=7, pady=4)
self._day_labels = {}
days_of_the_week = self._cal.formatweekheader(3).split()
for i, day_of_the_week in enumerate(days_of_the_week):
Tkinter.Label(self, text=day_of_the_week,
background='grey90').grid(row=1,
column=i,
sticky=N + E + W + S)
for i in range(6):
for j in range(7):
self._day_labels[i,
j] = label = Tkinter.Label(self,
background="white")
label.grid(row=i + 2, column=j, sticky=N + E + W + S)
label.bind(
"<Enter>", lambda event: event.widget.configure(
background=self._act_bg, foreground=self._act_fg))
label.bind(
"<Leave>",
lambda event: event.widget.configure(background="white"))
label.bind("<1>", self._pressed)
# adjust its columns width
font = tkFont.Font()
maxwidth = max(font.measure(text) for text in days_of_the_week)
for i in range(7):
self.grid_columnconfigure(i, minsize=maxwidth, weight=1)
self._year = None
self._month = None
# insert dates in the currently empty calendar
self._build_calendar(year, month)
def initialize(self):
#layout manager
self.grid()
#champ de texte (entrer)
self.lframe = LabelFrame(self, text="Nom du noeud", padx=50, pady=20)
self.lframe.grid(column=0, row=0, sticky='EW')
self.lframeService = LabelFrame(self,
text="Nom du service",
padx=50,
pady=20)
self.lframeService.grid(column=1, row=0, sticky='EW')
self.valueNode = StringVar()
#self.valueNode.set("Noeud")
self.entrerNode = Tkinter.Entry(self.lframe,
fg='grey',
textvariable=self.valueNode)
self.entrerNode.pack()
self.valueService = StringVar()
#self.valueService.set("Noeud")
self.entrerService = Tkinter.Entry(self.lframeService,
fg='grey',
textvariable=self.valueService)
self.entrerService.pack()
self.buttonNode = Tkinter.Button(self.lframe,
text="Ok",
command=self.btn)
self.buttonNode.pack()
self.buttonService = Tkinter.Button(self.lframeService,
text="Ok",
command=self.btn)
self.buttonService.pack()
self.outputServices = Tkinter.Text(self)
self.outputServices.grid(column=1, row=1)
self.outputNode = Tkinter.Text(self)
self.outputNode.grid(column=0, row=1)
self.start = Tkinter.Button(self, text="Start", command=self.start)
self.start.grid(column=0, row=2)
self.start = Tkinter.Button(self, text="Reset", command=self.reset)
self.start.grid(column=2, row=0)
self.stop = Tkinter.Button(self, text="Stop", command=self.stop)
self.stop.grid(column=1, row=2)
self.status = Tkinter.Button(self, text="Status", command=self.status)
self.status.grid(column=2, row=2)
self.valueConfig = StringVar()
self.entrerConfig = Tkinter.Entry(self,
fg='grey',
textvariable=self.valueConfig)
self.entrerConfig.grid(column=0, row=3)
self.config = Tkinter.Button(self,
text="Start config",
command=self.startConfig)
self.config.grid(column=1, row=3)
#self.label = Tkinter.Label(self,anchor="center",text = 'Nom du noeud :',fg="black",bg="white")
#self.label.grid(column=0,row=0,columnspan=2,sticky='EW')
#redimensionnement auto
self.grid_columnconfigure(0, weight=1)
self.geometry("800x600+300+0")
from Tkinter import Tk, Button, Frame, Label, StringVar
from mundial import resultados_por_grupo
from torneos import ordenar_equipos, calcular_puntos, calcular_diferencia
w = Tk() # ventana principal
fb = Frame(w) # panel de botones
ft = Frame(w) # panel con la tabla
fb.pack() # empaquetar el primer panel
ft.pack() # empaquetar el segundo panel
v = StringVar()
etiqueta = Label(ft, textvariable=v, fg='maroon')
etiqueta.grid(row=0, column=0)
for j, cabecera in enumerate(['Equipo', 'Pts', 'Dif'], 1):
etiqueta = Label(ft, text=cabecera, fg='navy', anchor='-wee'[j])
etiqueta.grid(row=0, column=j)
filas = []
for i in range(1, 5):
celdas = {
'n': Label(ft, width=2, text=i),
'eq': Label(ft, width=16, anchor='w'),
'pts': Label(ft, width=3, anchor='e'),
'dif': Label(ft, width=3, anchor='e'),
}
for j, col in enumerate(['n', 'eq', 'pts', 'dif']):
celdas[col].grid(row=i, column=j)
filas.append(celdas)
loginbutt.place(relx=0.6, x=1, y=54, anchor=NE)
noacclabl.bind("<Button-1>", lambda e: no_acc())
image = Label(root, text="")
userlabel = Label(root, text="")
ranklabel = Label(root, text="")
promlabel = Label(root, text="")
promotera = Label(root, text="")
oldrankal = Label(root, text="")
skine = Entry(root)
skinl = Label(root, text="Type a username")
skinb = Button(root, text="Search", command=search_user)
seluse = Entry(root)
reason = Entry(root)
promby = Label(root, text="")
value = StringVar()
sellab = Label(root, text='Select Rank')
selusr = Label(root, text='Username')
promot = Label(root, text='Promoter')
relabl = Label(root, text='Reason')
value = StringVar()
yes = Button(root, text="Done", command=insert_new)
box = ttk.Combobox(root, textvariable=value, state='readonly')
namelabel = Label(root, text="Username:"******"Arial 9 bold")
lastpromo = Label(root, text="Last Promo:", font="Arial 9 bold")
currerank = Label(root, text="Current Rank:", font="Arial 9 bold")
promoterl = Label(root, text="Promoter:", font="Arial 9 bold")
oldrankla = Label(root, text="Old Rank:", font="Arial 9 bold")
manentry = Entry(root)
manlabel = Label(root, text="Type a username")
resbutto = Button(root, text="Restrict")
def salvar():
fichero = tkFileDialog.asksaveasfilename()
f = open(fichero, "w")
f.write(contenido.get(1.0, END))
f.close()
if __name__ == '__main__':
ventana = Tk()
ventana.title("Editor tonto de textos")
t = Label(ventana)
t.grid(row=0, column=2, sticky=W + E, columnspan=2)
nombreFichero = StringVar()
t["textvariable"] = nombreFichero
botonLoad = Button(ventana, text="Load", command=cargar)
botonLoad.grid(row=0, column=0, sticky=W)
botonSave = Button(ventana, text="Save", command=salvar)
botonSave.grid(row=0, column=1, sticky=W)
contenido = ScrolledText(ventana)
contenido.grid(row=1, columnspan=3, sticky=W + E + N + S)
ventana.grid_columnconfigure(2, weight=1)
ventana.grid_rowconfigure(1, weight=1)
ventana.mainloop()
def init_vars(self):
self.numpages = StringVar(self.master)
self.numpages.set('1')
self.pagenum = StringVar(self.master)
self.pagenum.set('%u' % (app.mw.document.active_page + 1))
def __init__(self, cfg, doit):
""" create the GUI panel widgets
cfg -- parameter values (input and output)
doit -- method to call to run simulations
"""
# gather the basic parameters
self.cfg = cfg
self.doit = doit
self.root = Tk()
self.root.title('Data Reliability Model')
t = Frame(self.root, bd=2 * self.BORDER)
# w.iconbitmap(default='inktank.ico') # ? windows only ?
# left stack (DISK)
f = Frame(t, bd=self.BORDER, relief=RIDGE)
r = 1
Label(f, text="Disk Type").grid(row=r)
self.disk_type = StringVar(f)
self.disk_type.set(self.diskTypes[0])
OptionMenu(f, self.disk_type, *self.diskTypes,
command=self.diskchoice).grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Size (GiB)").grid(row=r)
self.disk_size = Entry(f, width=self.long_wid)
self.disk_size.delete(0, END)
self.disk_size.insert(0, self.long_fmt % (cfg.disk_size / GiB))
self.disk_size.grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Primary FITs").grid(row=r)
self.disk_fit = Entry(f, width=self.long_wid)
self.disk_fit.grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Secondary FITs").grid(row=r)
self.disk_fit2 = Entry(f, width=self.long_wid)
self.disk_fit2.grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="NRE rate").grid(row=r)
self.disk_nre = Spinbox(f, width=self.long_wid, values=self.nre_rates)
self.disk_nre.grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
while r < self.ROWS:
Label(f).grid(row=r)
r += 1
Button(f, text="RELIABILITY", command=self.do_disk).grid(row=r)
f.grid(column=1, row=1)
self.diskchoice(self.diskTypes[0]) # set default disk type
# second stack (RAID)
f = Frame(t, bd=self.BORDER, relief=RIDGE)
r = 1
Label(f, text="RAID Type").grid(row=r)
self.raid_type = StringVar(f)
self.raid_type.set("RAID-1")
OptionMenu(f, self.raid_type, *self.raidTypes,
command=self.raidchoice).grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Replace (hours)").grid(row=r)
self.raid_rplc = Spinbox(f, width=self.short_wid,
values=self.replace_times)
self.raid_rplc.grid(row=r + 1)
self.raid_rplc.delete(0, END)
self.raid_rplc.insert(0, "%d" % cfg.raid_replace)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Rebuild (MiB/s)").grid(row=r)
self.raid_speed = Spinbox(f, width=self.med_wid,
values=self.rebuild_speeds)
self.raid_speed.grid(row=r + 1)
self.raid_speed.delete(0, END)
self.raid_speed.insert(0, "%d" % (cfg.raid_recover / MiB))
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Volumes").grid(row=r)
self.raid_vols = Spinbox(f, from_=1, to=10, width=self.short_wid)
self.raid_vols.grid(row=r + 1)
Label(f).grid(row=r + 2)
self.raidchoice("RAID-1") # set default number of volumes
r += 3
while r < self.ROWS:
Label(f).grid(row=r)
r += 1
Button(f, text="RELIABILITY", command=self.do_raid).grid(row=r)
f.grid(column=2, row=1)
# third stack (RADOS)
f = Frame(t, bd=self.BORDER, relief=RIDGE)
r = 1
Label(f, text="RADOS copies").grid(row=r)
self.rados_cpys = Spinbox(f, values=(1, 2, 3, 4, 5, 6),
width=self.short_wid)
self.rados_cpys.grid(row=r + 1)
self.rados_cpys.delete(0, END)
self.rados_cpys.insert(0, "%d" % cfg.rados_copies)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Mark-out (min)").grid(row=r)
self.rados_down = Spinbox(f, values=self.markout_times,
width=self.short_wid)
self.rados_down.grid(row=r + 1)
self.rados_down.delete(0, END)
self.rados_down.insert(0, "%d" % (cfg.rados_markout * 60))
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Recovery (MiB/s)").grid(row=r)
self.rados_speed = Spinbox(f, width=self.med_wid,
values=self.rebuild_speeds)
self.rados_speed.grid(row=r + 1)
self.rados_speed.delete(0, END)
self.rados_speed.insert(0, "%d" % (cfg.rados_recover / MiB))
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Space Usage (%)").grid(row=r)
self.rados_fullness = Spinbox(f, values=self.fullness,
width=self.med_wid)
self.rados_fullness.grid(row=r + 1)
self.rados_fullness.delete(0, END)
self.rados_fullness.insert(0, "%d" % (cfg.rados_fullness * 100))
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Declustering (pg)").grid(row=r)
self.rados_pgs = Entry(f, width=self.med_wid)
self.rados_pgs.delete(0, END)
self.rados_pgs.insert(0, self.med_fmt % cfg.rados_decluster)
self.rados_pgs.grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Stripe Length").grid(row=r)
self.stripe_length = Entry(f, width=self.med_wid)
self.stripe_length.delete(0, END)
self.stripe_length.insert(0, self.med_fmt % cfg.stripe_length)
self.stripe_length.grid(row=r + 1)
Label(f).grid(row=r + 2)
r += 3
while r < self.ROWS:
Label(f).grid(row=r)
r += 1
Button(f, text="RELIABILITY", command=self.do_rados).grid(row=r)
f.grid(column=3, row=1)
# fourth stack (remote site)
r = 1
f = Frame(t, bd=self.BORDER, relief=RIDGE)
Label(f, text="RADOS Sites").grid(row=r)
self.site_num = Spinbox(f, values=self.site_count,
width=self.short_wid)
self.site_num.grid(row=r + 1)
self.site_num.delete(0, END)
self.site_num.insert(0, "%d" % cfg.remote_sites)
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Rep Latency (s)").grid(row=r)
self.remote_latency = Spinbox(f, values=self.async_latencies,
width=self.long_wid)
self.remote_latency.grid(row=r + 1)
self.remote_latency.delete(0, END)
self.remote_latency.insert(0, "%d" % (cfg.remote_latency * 60 * 60))
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Recovery (MiB/s)").grid(row=r)
self.remote_speed = Spinbox(f, values=self.remote_speeds,
width=self.med_wid)
self.remote_speed.grid(row=r + 1)
self.remote_speed.delete(0, END)
self.remote_speed.insert(0, "%d" % (cfg.remote_recover / MiB))
Label(f).grid(row=r + 2)
r += 3
Label(f, text="Disaster (years)").grid(row=r)
self.remote_fail = Spinbox(f, values=self.site_destroy,
width=self.long_wid)
self.remote_fail.grid(row=r + 1)
self.remote_fail.delete(0, END)
self.remote_fail.insert(0, "1000")
# FIX - get this from cfg ... but translate from FITS
Label(f).grid(column=2, row=r + 2)
r += 3
Label(f, text="Site Recover (days)").grid(row=r)
self.remote_avail = Spinbox(f, values=self.site_recover,
width=self.long_wid)
self.remote_avail.grid(row=r + 1)
self.remote_avail.delete(0, END)
self.remote_avail.insert(0, "30")
# FIX - get this from cfg ... but translate from FITS
Label(f).grid(row=r + 2)
r += 3
while r < self.ROWS:
Label(f).grid(row=r)
r += 1
Button(f, text="RELIABILITY", command=self.do_sites).grid(row=r)
f.grid(column=4, row=1)
# and the control panel
r = 2
c = 1
Label(t).grid(column=c, row=r)
Label(t, text="NRE model").grid(column=c, row=r + 1)
self.nre_model = StringVar(t)
self.nre_model.set(self.cfg.nre_model)
OptionMenu(t, self.nre_model, *self.nreTypes).grid(column=c, row=r + 2)
c = 2
Label(t).grid(column=c, row=r)
Label(t, text="Period (years)").grid(column=c, row=r + 1)
self.period = Spinbox(t, from_=1, to=10, width=self.short_wid)
self.period.grid(column=c, row=r + 2)
c = 3
Label(t).grid(column=c, row=r)
Label(t, text="Object size").grid(column=c, row=r + 1)
# generate object sizes dynamically from parameters
os = self.min_obj_size
while os <= self.max_obj_size:
if os < MB:
s = "%dKB" % (os / KB)
elif os < GB:
s = "%dMB" % (os / MB)
elif os < TB:
s = "%dGB" % (os / GB)
else:
s = "%dTB" % (os / TB)
self.object_sizes.append(s)
os *= self.step_obj_size
self.obj_size = Spinbox(t, values=self.object_sizes,
width=self.long_wid)
self.obj_size.grid(column=c, row=r + 2)
self.obj_size.delete(0, END)
self.obj_size.insert(0, self.object_sizes[0])
c = 4
Label(t).grid(column=c, row=r)
Label(t, text="Verbosity").grid(column=c, row=r + 1)
self.verbosity = StringVar(t)
self.verbosity.set(cfg.verbose)
OptionMenu(t, self.verbosity, *self.verbosities).grid(column=c,
row=r + 2)
# and then finalize everything
t.grid()
def build_dlg(self):
root = TFrame(self.top, style='FlatFrame', borderwidth=10)
root.pack(side=TOP, fill=BOTH, expand=1)
top = TFrame(root, style='FlatFrame', borderwidth=5)
top.pack(side=TOP, fill=X, expand=1)
label = TLabel(top, text=_("Insert:") + " ", style='FlatLabel')
label.pack(side=LEFT)
self.numpages_spin = TSpinbox(top,
var=1,
vartype=0,
textvariable=self.numpages,
min=1,
max=1000,
step=1,
width=6,
command=self.ok)
self.numpages_spin.pack(side=LEFT)
label = TLabel(top, text=" " + _("page(s)"), style='FlatLabel')
label.pack(side=LEFT)
middle = TFrame(root, style='FlatFrame', borderwidth=5)
middle.pack(side=TOP, fill=X, expand=1)
rbframe = TFrame(middle, style='FlatFrame', borderwidth=5)
rbframe.pack(side=LEFT)
self.var_reference = StringVar(self.master)
if self.is_before:
self.var_reference.set('before')
else:
self.var_reference.set('after')
radio = UpdatedRadiobutton(rbframe,
value='before',
text=_("Before") + " ",
variable=self.var_reference)
radio.pack(side=TOP, anchor=W)
radio = UpdatedRadiobutton(rbframe,
value='after',
text=_("After") + " ",
variable=self.var_reference)
radio.pack(side=TOP, anchor=W)
label = TLabel(middle,
text=" " + _("page No.:") + " ",
style='FlatLabel')
label.pack(side=LEFT)
self.pagenum_spin = TSpinbox(middle,
var=app.mw.document.active_page + 1,
vartype=0,
textvariable=self.pagenum,
min=1,
max=len(app.mw.document.pages),
step=1,
width=6,
command=self.ok)
self.pagenum_spin.pack(side=LEFT)
if len(app.mw.document.pages) == 1:
self.pagenum_spin.set_state('disabled')
bottom = TFrame(root, style='FlatFrame', borderwidth=5)
bottom.pack(side=BOTTOM, fill=X, expand=1)
cancel = TButton(bottom, text=_("Cancel"), command=self.cancel)
cancel.pack(side=RIGHT)
label = TLabel(bottom, text=' ', style='FlatLabel')
label.pack(side=RIGHT)
ok = TButton(bottom, text=_("OK"), command=self.ok)
ok.pack(side=RIGHT)
self.focus_widget = ok
self.top.bind('<Escape>', self.cancel)
self.top.protocol('WM_DELETE_WINDOW', self.cancel)
self.top.resizable(width=0, height=0)
def setup_gui(self):
# set up the gui
# root is the Tkinter root widget
self.root.title("Remote Monitor for Pi Presents")
# self.root.configure(background='grey')
self.root.resizable(False, False)
# define response to main window closing
self.root.protocol("WM_DELETE_WINDOW", self.app_exit)
# bind some display fields
self.desc = StringVar()
self.filename = StringVar()
self.display_show = StringVar()
self.results = StringVar()
self.status = StringVar()
# define menu
menubar = Menu(self.root)
osc_configmenu = Menu(menubar, tearoff=0, bg="grey", fg="black")
menubar.add_cascade(label='Options', menu=osc_configmenu)
osc_configmenu.add_command(label='Edit', command=self.e_edit_osc)
helpmenu = Menu(menubar, tearoff=0, bg="grey", fg="black")
menubar.add_cascade(label='Help', menu=helpmenu)
helpmenu.add_command(label='Help', command=self.show_help)
helpmenu.add_command(label='About', command=self.about)
self.root.config(menu=menubar)
# info frame
info_frame = Frame(self.root, padx=5, pady=5)
info_frame.pack(side=TOP, fill=BOTH, expand=1)
info_name = Label(info_frame,
text="Slave Unit's Name: " +
self.osc_config.this_unit_name,
font="arial 12 bold")
info_name.pack(side=TOP)
info_this_address = Label(info_frame,
textvariable=self.desc,
font="arial 12 bold")
info_this_address.pack(side=TOP)
# status_frame
status_frame = Frame(self.root, padx=5, pady=5)
status_frame.pack(side=TOP, fill=BOTH, expand=1)
status_label = Label(status_frame,
text="Status:",
font="arial 12 bold")
status_label.pack(side=LEFT)
scrollbar = Scrollbar(status_frame, orient=VERTICAL)
self.status_display = Text(status_frame,
height=20,
yscrollcommand=scrollbar.set)
scrollbar.config(command=self.status_display.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.status_display.pack(side=LEFT, fill=BOTH, expand=1)
def drawWindow():
def LoadData():
ToDoList.delete(0, END)
InProgressList.delete(0, END)
DoneList.delete(0, END)
for Row in Db.SelectData("todo"):
ToDoList.insert(END, Row[1])
for Row in Db.SelectData("inprogress"):
InProgressList.insert(END, Row[1])
for Row in Db.SelectData("done"):
DoneList.insert(END, Row[1])
def Add(_List):
if _List == s_List[0] and ToDoEntry.get() != "":
Db.InsertData(_Table="todo", _Task=ToDoEntry.get())
ToDoEntry.delete(0, END)
elif _List == s_List[1] and InProgressEntry.get() != "":
Db.InsertData(_Table="inprogress", _Task=InProgressEntry.get())
InProgressEntry.delete(0, END)
elif _List == s_List[2] and DoneEntry.get() != "":
Db.InsertData(_Table="done", _Task=DoneEntry.get())
DoneEntry.delete(0, END)
LoadData()
def Delete(_List):
if _List == s_List[0]:
Db.DeleteDataByTask(_Table="todo", _Task=ToDoList.get(ACTIVE))
elif _List == s_List[1]:
Db.DeleteDataByTask(_Table="inprogress",
_Task=InProgressList.get(ACTIVE))
elif _List == s_List[2]:
Db.DeleteDataByTask(_Table="done", _Task=DoneList.get(ACTIVE))
LoadData()
def MoveForward(_List):
if _List == s_List[1] and ToDoList.get(ACTIVE) != "":
Db.InsertData(_Table="inprogress", _Task=ToDoList.get(ACTIVE))
Db.DeleteDataByTask(_Table="todo", _Task=ToDoList.get(ACTIVE))
InProgressList.focus()
elif _List == s_List[2] and InProgressList.get(ACTIVE) != "":
Db.InsertData(_Table="done", _Task=InProgressList.get(ACTIVE))
Db.DeleteDataByTask(_Table="inprogress",
_Task=InProgressList.get(ACTIVE))
DoneList.focus()
elif _List == s_List[3] and DoneList.get(ACTIVE) != "":
Db.InsertData(_Table="archives", _Task=DoneList.get(ACTIVE))
Db.DeleteDataByTask(_Table="done", _Task=DoneList.get(ACTIVE))
LoadData()
def MoveBackward(_List):
if _List == s_List[0] and InProgressList.get(ACTIVE) != "":
Db.InsertData(_Table="todo", _Task=InProgressList.get(ACTIVE))
Db.DeleteDataByTask(_Table="inprogress",
_Task=InProgressList.get(ACTIVE))
ToDoList.focus()
elif _List == s_List[1] and DoneList.get(ACTIVE) != "":
Db.InsertData(_Table="inprogress", _Task=DoneList.get(ACTIVE))
Db.DeleteDataByTask(_Table="done", _Task=DoneList.get(ACTIVE))
InProgressList.focus()
LoadData()
def FocusDown(_List):
if _List == s_List[0] and ToDoList.get(ACTIVE) == ToDoList.get(END):
ToDoEntry.focus()
ToDoEntry.delete(0, END)
elif _List == s_List[1] and InProgressList.get(
ACTIVE) == InProgressList.get(END):
InProgressEntry.focus()
InProgressEntry.delete(0, END)
elif _List == s_List[2] and DoneList.get(ACTIVE) == DoneList.get(END):
DoneEntry.focus()
DoneEntry.delete(0, END)
def FocusUp(_List):
if _List == s_List[0]:
ToDoList.focus()
ToDoEntry.delete(0, END)
elif _List == s_List[1]:
InProgressList.focus()
InProgressEntry.delete(0, END)
elif _List == s_List[2]:
DoneList.focus()
DoneEntry.delete(0, END)
# / ----------------------------------------------------------------------------------------------------------------
def _AddToToDo(_Self=0):
Add(s_List[0])
def _AddToProgress(_Self=0):
Add(s_List[1])
def _AddToDone(_Self=0):
Add(s_List[2])
def _DeleteToDo(_Self=0):
Delete(s_List[0])
def _DeleteInProgress(_Self=0):
Delete(s_List[1])
def _DeleteDone(_Self=0):
Delete(s_List[2])
def _MoveToInProgress(_Self=0):
MoveForward(s_List[1])
def _MoveToDone(_Self=0):
MoveForward(s_List[2])
def _MoveToArchives(_Self=0):
MoveForward(s_List[3])
def _BackToToDo(_Self=0):
MoveBackward(s_List[0])
def _BackToInProgress(_Self=0):
MoveBackward(s_List[1])
def _FocusDownToDo(_Self=0):
FocusDown(s_List[0])
def _FocusDownInProgress(_Self=0):
FocusDown(s_List[1])
def _FocusDownDone(_Self=0):
FocusDown(s_List[2])
def _FocusUpToDo(_Self=0):
FocusUp(s_List[0])
def _FocusUpInProgress(_Self=0):
FocusUp(s_List[1])
def _FocusUpDone(_Self=0):
FocusUp(s_List[2])
def _FocusList(_List):
if _List == s_List[0]:
ToDoList.focus()
elif _List == s_List[1]:
InProgressList.focus()
elif _List == s_List[2]:
DoneList.focus()
def _FocusTodo(_Self=0):
_FocusList(s_List[0])
def _FocusInProgress(_Self=0):
_FocusList(s_List[1])
def _FocusDone(_Self=0):
_FocusList(s_List[2])
def _FocusEntry(_Self=0):
ToDoEntry.focus()
def _ExportToCsv(_Self=0):
File = open("kanban_export.csv", "w")
for Row in ToDoList.get(0, END):
File.write(str(Row) + ";to_do\n")
for Row in InProgressList.get(0, END):
File.write(str(Row) + ";in_progress\n")
for Row in DoneList.get(0, END):
File.write(str(Row) + ";done\n")
File.close()
# / ----------------------------------------------------------------------------------------------------------------
Widget = TkComponents.CTkComponents("LIGHT")
# / ----------------------------------------------------------------------------------------------------------------
Window = Tk()
Window.title("Kanban (tkinter)")
Window.minsize(width=1200, height=600)
# / ----------------------------------------------------------------------------------------------------------------
# / Projects
ProjectFrame = Widget.GetFrame(Window)
ProjectFrame.pack(side=TOP, fill=X)
Option = StringVar()
Option.set("General Tasks")
ProjectMenu = OptionMenu(ProjectFrame, Option, "General Tasks", "Others")
ProjectMenu.configure(bg=Color.s_LightGrey)
ProjectMenu.pack(side=LEFT)
CreateProjectButton = Widget.GetButton(ProjectFrame, "Create Project")
CreateProjectButton.pack(side=RIGHT, padx=10)
DeleteProjectButton = Widget.GetButton(ProjectFrame, "Delete Project")
DeleteProjectButton.pack(side=RIGHT)
# / To Do
ToDoFrame = Widget.GetLabelFrame(Window, _Text="To Do")
ToDoFrame.pack(side=LEFT, fill=BOTH, expand=1)
ToDoList = Widget.GetList(ToDoFrame)
ToDoList.pack(fill=BOTH, expand=1, padx=5, pady=10)
ToDoList.bind("<BackSpace>", _DeleteToDo)
ToDoList.bind("<Delete>", _DeleteToDo)
ToDoList.bind("<Command-Right>", _MoveToInProgress)
ToDoList.bind("<Right>", _FocusInProgress)
# ToDoList.bind("<Down>", _FocusDownToDo)
ToDoButton = Widget.GetButton(ToDoFrame,
_Text="In Progress",
_Command=lambda: MoveForward(s_List[1]))
ToDoButton.pack(side=BOTTOM, fill=X)
ToDoEntry = Widget.GetEntry(ToDoFrame)
ToDoEntry.pack(side=BOTTOM, fill=X)
ToDoEntry.bind("<Return>", _AddToToDo)
# ToDoEntry.bind("<Up>", _FocusUpToDo)
# / In Progress
InProgressFrame = Widget.GetLabelFrame(Window, _Text="In Progress")
InProgressFrame.pack(side=LEFT, fill=BOTH, expand=1)
InProgressList = Widget.GetList(InProgressFrame)
InProgressList.pack(fill=BOTH, expand=1, padx=5, pady=10)
InProgressList.bind("<BackSpace>", _DeleteInProgress)
InProgressList.bind("<Delete>", _DeleteInProgress)
InProgressList.bind("<Command-Right>", _MoveToDone)
InProgressList.bind("<Command-Left>", _BackToToDo)
InProgressList.bind("<Right>", _FocusDone)
InProgressList.bind("<Left>", _FocusTodo)
# InProgressList.bind("<Down>", _FocusDownInProgress)
InProgressButton = Widget.GetButton(
InProgressFrame, _Text="Done", _Command=lambda: MoveForward(s_List[2]))
InProgressButton.pack(side=BOTTOM, fill=X)
InProgressEntry = Widget.GetEntry(InProgressFrame)
InProgressEntry.pack(side=BOTTOM, fill=X)
InProgressEntry.bind("<Return>", _AddToProgress)
# InProgressEntry.bind("<Up>", _FocusUpInProgress)
# / Done
DoneFrame = Widget.GetLabelFrame(Window, _Text="Done")
DoneFrame.pack(side=LEFT, fill=BOTH, expand=1)
DoneList = Widget.GetList(DoneFrame)
DoneList.pack(fill=BOTH, expand=1, padx=5, pady=10)
DoneList.bind("<BackSpace>", _DeleteDone)
DoneList.bind("<Delete>", _DeleteDone)
DoneList.bind("<Command-Right>", _MoveToArchives)
DoneList.bind("<Command-Left>", _BackToInProgress)
DoneList.bind("<Left>", _FocusInProgress)
# DoneList.bind("<Down>", _FocusDownDone)
DoneButton = Widget.GetButton(DoneFrame,
_Text="Archive",
_Command=lambda: MoveForward(s_List[3]))
DoneButton.pack(side=BOTTOM, fill=X)
DoneEntry = Widget.GetEntry(DoneFrame)
DoneEntry.pack(side=BOTTOM, fill=X)
DoneEntry.bind("<Return>", _AddToDone)
# DoneEntry.bind("<Up>", _FocusUpDone)
# / ----------------------------------------------------------------------------------------------------------------
LoadData()
Window.bind("<Command-e>", _ExportToCsv)
Window.bind("<Command-i>", _FocusEntry)
Window.mainloop()
def __init__(self,
master,
list_of_items=None,
autocomplete_function=None,
listbox_width=None,
listbox_height=7,
ignorecase_match=False,
startswith_match=True,
vscrollbar=True,
hscrollbar=True,
**kwargs):
if hasattr(self, "autocomplete_function"):
if autocomplete_function is not None:
raise ValueError(
"Combobox_Autocomplete subclass has 'autocomplete_function' implemented"
)
else:
if autocomplete_function is not None:
self.autocomplete_function = autocomplete_function
else:
if list_of_items is None:
raise ValueError(
"If not guiven complete function, list_of_items can't be 'None'"
)
if ignorecase_match:
if startswith_match:
def matches_function(entry_data, item):
return item.startswith(entry_data)
else:
def matches_function(entry_data, item):
return item in entry_data
self.autocomplete_function = lambda entry_data: [
item for item in self.list_of_items
if matches_function(entry_data, item)
]
else:
if startswith_match:
def matches_function(escaped_entry_data, item):
if re.match(escaped_entry_data, item,
re.IGNORECASE):
return True
else:
return False
else:
def matches_function(escaped_entry_data, item):
if re.search(escaped_entry_data, item,
re.IGNORECASE):
return True
else:
return False
def autocomplete_function(entry_data):
escaped_entry_data = re.escape(entry_data)
return [
item for item in self.list_of_items
if matches_function(escaped_entry_data, item)
]
self.autocomplete_function = autocomplete_function
self._listbox_height = int(listbox_height)
self._listbox_width = listbox_width
self.list_of_items = list_of_items
self._use_vscrollbar = vscrollbar
self._use_hscrollbar = hscrollbar
kwargs.setdefault("background", "white")
if "textvariable" in kwargs:
self._entry_var = kwargs["textvariable"]
else:
self._entry_var = kwargs["textvariable"] = StringVar()
Entry.__init__(self, master, **kwargs)
self._trace_id = self._entry_var.trace('w', self._on_change_entry_var)
self._listbox = None
self.bind("<Tab>", self._on_tab)
self.bind("<Up>", self._previous)
self.bind("<Down>", self._next)
self.bind('<Control-n>', self._next)
self.bind('<Control-p>', self._previous)
self.bind("<Return>", self._update_entry_from_listbox)
self.bind("<Escape>", lambda event: self.unpost_listbox())
def init_gui(self):
"""init helper"""
#setting up frames
top_frame = Frame(self.root)
mid_frame = Frame(self.root)
radio_frame = Frame(self.root)
res_frame = Frame(self.root)
msg_frame = Frame(self.root)
check_frame = Frame(self.root)
history_frame = Frame(self.root)
btn_frame = Frame(self.root)
rating_frame = Frame(self.root)
top_frame.pack(side=TOP, fill=X)
mid_frame.pack(side=TOP, fill=X)
history_frame.pack(side=TOP, fill=BOTH, expand=True)
radio_frame.pack(side=TOP, fill=BOTH, expand=True)
rating_frame.pack(side=TOP, fill=BOTH, expand=True)
res_frame.pack(side=TOP, fill=BOTH, expand=True)
check_frame.pack(side=TOP, fill=BOTH, expand=True)
msg_frame.pack(side=TOP, fill=BOTH, expand=True)
btn_frame.pack(side=TOP, fill=X)
# Binding F5 application-wide to run lint
self.root.bind('<F5>', self.run_lint)
#Message ListBox
rightscrollbar = Scrollbar(msg_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.lb_messages = Listbox(msg_frame,
yscrollcommand=rightscrollbar.set,
xscrollcommand=bottomscrollbar.set,
bg="white")
self.lb_messages.bind("<Double-Button-1>", self.show_sourcefile)
self.lb_messages.pack(expand=True, fill=BOTH)
rightscrollbar.config(command=self.lb_messages.yview)
bottomscrollbar.config(command=self.lb_messages.xview)
#History ListBoxes
rightscrollbar2 = Scrollbar(history_frame)
rightscrollbar2.pack(side=RIGHT, fill=Y)
bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL)
bottomscrollbar2.pack(side=BOTTOM, fill=X)
self.showhistory = Listbox(history_frame,
yscrollcommand=rightscrollbar2.set,
xscrollcommand=bottomscrollbar2.set,
bg="white")
self.showhistory.pack(expand=True, fill=BOTH)
rightscrollbar2.config(command=self.showhistory.yview)
bottomscrollbar2.config(command=self.showhistory.xview)
self.showhistory.bind('<Double-Button-1>', self.select_recent_file)
self.set_history_window()
#status bar
self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W)
self.status.pack(side=BOTTOM, fill=X)
#labelbl_ratingls
lbl_rating_label = Label(rating_frame, text='Rating:')
lbl_rating_label.pack(side=LEFT)
lbl_rating = Label(rating_frame, textvariable=self.rating)
lbl_rating.pack(side=LEFT)
Label(mid_frame, text='Recently Used:').pack(side=LEFT)
Label(top_frame, text='Module or package').pack(side=LEFT)
#file textbox
self.txt_module = Entry(top_frame, background='white')
self.txt_module.bind('<Return>', self.run_lint)
self.txt_module.pack(side=LEFT, expand=True, fill=X)
#results box
rightscrollbar = Scrollbar(res_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.results = Listbox(res_frame,
yscrollcommand=rightscrollbar.set,
xscrollcommand=bottomscrollbar.set,
bg="white", font="Courier")
self.results.pack(expand=True, fill=BOTH, side=BOTTOM)
rightscrollbar.config(command=self.results.yview)
bottomscrollbar.config(command=self.results.xview)
#buttons
Button(top_frame, text='Open', command=self.file_open).pack(side=LEFT)
Button(top_frame, text='Open Package',
command=(lambda: self.file_open(package=True))).pack(side=LEFT)
self.btnRun = Button(top_frame, text='Run', command=self.run_lint)
self.btnRun.pack(side=LEFT)
Button(btn_frame, text='Quit', command=self.quit).pack(side=BOTTOM)
#radio buttons
self.information_box = IntVar()
self.convention_box = IntVar()
self.refactor_box = IntVar()
self.warning_box = IntVar()
self.error_box = IntVar()
self.fatal_box = IntVar()
i = Checkbutton(check_frame, text="Information", fg=COLORS['(I)'],
variable=self.information_box, command=self.refresh_msg_window)
c = Checkbutton(check_frame, text="Convention", fg=COLORS['(C)'],
variable=self.convention_box, command=self.refresh_msg_window)
r = Checkbutton(check_frame, text="Refactor", fg=COLORS['(R)'],
variable=self.refactor_box, command=self.refresh_msg_window)
w = Checkbutton(check_frame, text="Warning", fg=COLORS['(W)'],
variable=self.warning_box, command=self.refresh_msg_window)
e = Checkbutton(check_frame, text="Error", fg=COLORS['(E)'],
variable=self.error_box, command=self.refresh_msg_window)
f = Checkbutton(check_frame, text="Fatal", fg=COLORS['(F)'],
variable=self.fatal_box, command=self.refresh_msg_window)
i.select()
c.select()
r.select()
w.select()
e.select()
f.select()
i.pack(side=LEFT)
c.pack(side=LEFT)
r.pack(side=LEFT)
w.pack(side=LEFT)
e.pack(side=LEFT)
f.pack(side=LEFT)
#check boxes
self.box = StringVar()
# XXX should be generated
report = Radiobutton(
radio_frame, text="Report", variable=self.box,
value="Report", command=self.refresh_results_window)
raw_met = Radiobutton(
radio_frame, text="Raw metrics", variable=self.box,
value="Raw metrics", command=self.refresh_results_window)
dup = Radiobutton(
radio_frame, text="Duplication", variable=self.box,
value="Duplication", command=self.refresh_results_window)
ext = Radiobutton(
radio_frame, text="External dependencies",
variable=self.box, value="External dependencies",
command=self.refresh_results_window)
stat = Radiobutton(
radio_frame, text="Statistics by type",
variable=self.box, value="Statistics by type",
command=self.refresh_results_window)
msg_cat = Radiobutton(
radio_frame, text="Messages by category",
variable=self.box, value="Messages by category",
command=self.refresh_results_window)
msg = Radiobutton(
radio_frame, text="Messages", variable=self.box,
value="Messages", command=self.refresh_results_window)
source_file = Radiobutton(
radio_frame, text="Source File", variable=self.box,
value="Source File", command=self.refresh_results_window)
report.select()
report.grid(column=0, row=0, sticky=W)
raw_met.grid(column=1, row=0, sticky=W)
dup.grid(column=2, row=0, sticky=W)
msg.grid(column=3, row=0, sticky=W)
stat.grid(column=0, row=1, sticky=W)
msg_cat.grid(column=1, row=1, sticky=W)
ext.grid(column=2, row=1, sticky=W)
source_file.grid(column=3, row=1, sticky=W)
#dictionary for check boxes and associated error term
self.msg_type_dict = {
'I': lambda: self.information_box.get() == 1,
'C': lambda: self.convention_box.get() == 1,
'R': lambda: self.refactor_box.get() == 1,
'E': lambda: self.error_box.get() == 1,
'W': lambda: self.warning_box.get() == 1,
'F': lambda: self.fatal_box.get() == 1
}
self.txt_module.focus_set()
a = 0
looop = 0
test = 0
s = 0
#Tk
root = Tk()
root.title('GIP6IW')
frame = Frame(root)
arduino = Frame(root)
usb = Frame(root)
infof = Frame(root)
TIme = Frame(root)
Loop = Frame(root)
Delay = StringVar()
Backup = StringVar()
X = StringVar()
INfo = StringVar()
Delay.set('2')
X.set("0 0 1")
Backup.set('1')
#column 0
t0 = StringVar()
t0.set('Temperatuur')
v0 = StringVar()
v0.set('Vochtigheid')
l0 = StringVar()
l0.set('Licht')
z0 = StringVar()
def __init__(self, parent, txt=dict()):
"""Instanciating the output workbook."""
self.parent = parent
Frame.__init__(self)
# subframe
self.FrDb = Labelframe(self,
name='database',
text=txt.get('gui_fr2', "SGBD"))
# DB variables
self.opt_pgvw = IntVar(self.FrDb) # able/disable PostGIS views
self.host = StringVar(self.FrDb, 'localhost')
self.port = IntVar(self.FrDb, 5432)
self.dbnb = StringVar(self.FrDb)
self.user = StringVar(self.FrDb, 'postgres')
self.pswd = StringVar(self.FrDb)
# Form widgets
self.ent_H = Entry(self.FrDb, textvariable=self.host)
self.ent_P = Entry(self.FrDb, textvariable=self.port, width=5)
self.ent_D = Entry(self.FrDb, textvariable=self.dbnb)
self.ent_U = Entry(self.FrDb, textvariable=self.user)
self.ent_M = Entry(self.FrDb, textvariable=self.pswd, show='*')
caz_pgvw = Checkbutton(self.FrDb,
text=txt.get('gui_views', "Views enabled"),
variable=self.opt_pgvw)
# Label widgets
self.lb_H = Label(self.FrDb, text=txt.get('gui_host', "Host"))
self.lb_P = Label(self.FrDb, text=txt.get('gui_port', "Port"))
self.lb_D = Label(self.FrDb, text=txt.get('gui_db', "Database"))
self.lb_U = Label(self.FrDb, text=txt.get('gui_user', "User"))
self.lb_M = Label(self.FrDb, text=txt.get('gui_mdp', "Password"))
# widgets placement
self.ent_H.grid(row=1,
column=1,
columnspan=2,
sticky="NSEW",
padx=2,
pady=2)
self.ent_P.grid(row=1,
column=3,
columnspan=1,
sticky="NSE",
padx=2,
pady=2)
self.ent_D.grid(row=2,
column=1,
columnspan=1,
sticky="NSEW",
padx=2,
pady=2)
self.ent_U.grid(row=2,
column=3,
columnspan=1,
sticky="NSEW",
padx=2,
pady=2)
self.ent_M.grid(row=3,
column=1,
columnspan=3,
sticky="NSEW",
padx=2,
pady=2)
self.lb_H.grid(row=1, column=0, sticky="NSEW", padx=2, pady=2)
self.lb_P.grid(row=1, column=3, sticky="NSW", padx=2, pady=2)
self.lb_D.grid(row=2, column=0, sticky="NSW", padx=2, pady=2)
self.lb_U.grid(row=2, column=2, sticky="NSW", padx=2, pady=2)
self.lb_M.grid(row=3, column=0, sticky="NSWE", padx=2, pady=2)
caz_pgvw.grid(row=4, column=0, sticky="NSWE", padx=2, pady=2)
# frame position
self.FrDb.grid(row=3, column=1, sticky="NSWE", padx=2, pady=2)
def __init__(self, master, system, coefficient, coefficients, editflag):
"""Constructor method. Makes the GUI using the list of "Layer" objects
"layers." """
# Read the Tkinter information
self.master = master
self.version = system.version
self.fonttype = system.fonttype
self.formulatype = system.formulatype
self.superfont = get_superfont(self.fonttype)
self.subfont = get_superfont(self.formulatype)
self.tframe = Frame(master.tframe)
self.frame = Frame(master.frame)
self.bframe = Frame(master.bframe)
self.bgcolor = self.frame.cget('bg')
self.top = None
self.concunit = system.concunit
self.timeunit = system.timeunit
self.concunits = system.concunits
# Convert mass concentration units to corresponding molar concentration units
if self.concunit == system.concunits[0]:
self.concunit = system.concunits[3]
if self.concunit == system.concunits[1]:
self.concunit = system.concunits[4]
if self.concunit == system.concunits[2]:
self.concunit = system.concunits[5]
# Read the system information
self.coefficient = coefficient
self.coefficients = coefficients
self.layers = system.layers
self.editflag = editflag
if self.editflag == 0:
self.layer_full_list = []
self.reaction_full_list = []
for layer in system.layers:
self.layer_full_list.append(layer.name)
for reaction in system.reactions:
self.reaction_full_list.append(reaction.name)
self.layer_list = []
self.reaction_list = []
for layer in system.layers:
coef_check = 0
for reaction in system.reactions:
if coefficients[layer.name][reaction.name].lam == 0:
coef_check = 1
if coef_check == 1:
self.layer_list.append(layer.name)
self.reaction_list.append([])
for reaction in system.reactions:
if coefficients[layer.name][reaction.name].lam == 0:
self.reaction_list[-1].append(reaction.name)
self.layer = StringVar(value=self.layer_list[0])
self.reaction = StringVar(value=self.reaction_list[0][0])
self.equation = StringVar(value='')
else:
self.layer = coefficient.layer.name
self.reaction = coefficient.reaction.name
self.equation = coefficient.reaction.equation
self.reactants = coefficient.reaction.reactants
self.lam = DoubleVar(value=coefficient.lam)
self.cancelflag = 0
def make_entry(self, master, field, field_spec, values, bar):
# print 'make entry',self.field_index,field,field_spec
if field_spec['shape'] == 'tab':
self.current_tab = Tab(master, field_spec['name'])
bar.add(self.current_tab, field_spec['text'])
self.tab_row = 1
return None
elif field_spec['shape'] == 'sep':
Label(self.current_tab, text='', anchor=W).grid(row=self.tab_row,
column=0,
sticky=W)
self.tab_row += 1
return None
else:
# print 'replace param in make entry',field
# print 'content', field, self.field_content[field]
# is it in the field content dictionary
if not field in self.field_content:
self.mon.log(
self, "Value for field not found in opened file: " + field)
return None
else:
if field_spec['must'] == 'yes':
bg = 'pink'
else:
bg = 'white'
# write the label
Label(self.current_tab, text=field_spec['text'],
anchor=W).grid(row=self.tab_row, column=0, sticky=W)
# make the editable field
if field_spec['shape'] in ('entry', 'colour', 'browse',
'font'):
obj = Entry(self.current_tab,
bg=bg,
width=40,
font='arial 11')
obj.insert(END, self.field_content[field])
elif field_spec['shape'] == 'text':
obj = ScrolledText(self.current_tab,
bg=bg,
height=8,
width=40,
font='arial 11')
obj.insert(END, self.field_content[field])
elif field_spec['shape'] == 'spinbox':
obj = Spinbox(self.current_tab,
bg=bg,
values=values,
wrap=True)
obj.insert(END, self.field_content[field])
elif field_spec['shape'] == 'option-menu':
self.option_val = StringVar(self.current_tab)
self.option_val.set(self.field_content[field])
obj = apply(OptionMenu,
[self.current_tab, self.option_val] + values)
self.entries.append(self.option_val)
else:
self.mon.log(self, "Uknown shape for: " + field)
return None
if field_spec['read-only'] == 'yes':
obj.config(state="readonly", bg='dark grey')
obj.grid(row=self.tab_row, column=1, sticky=W)
# display buttons where required
if field_spec['shape'] == 'browse':
but = Button(self.current_tab,
width=1,
height=1,
bg='dark grey',
command=(lambda o=obj: self.browse(o)))
but.grid(row=self.tab_row, column=2, sticky=W)
elif field_spec['shape'] == 'colour':
but = Button(self.current_tab,
width=1,
height=1,
bg='dark grey',
command=(lambda o=obj: self.pick_colour(o)))
but.grid(row=self.tab_row, column=2, sticky=W)
elif field_spec['shape'] == 'font':
but = Button(self.current_tab,
width=1,
height=1,
bg='dark grey',
command=(lambda o=obj: self.pick_font(o)))
but.grid(row=self.tab_row, column=2, sticky=W)
self.tab_row += 1
return obj
