class ChatWindow(object):
def __init__(self, parent, line_sender):
self.parent = parent
self.main = self.build_window()
self.line_sender = line_sender
def build_window(self):
self.toplevel = tk.Toplevel(self.parent)
f = tk.Frame(self.toplevel)
f.pack()
self.area = ScrolledText(f)
self.area.pack(side=tk.TOP)
self.area.config(state=tk.DISABLED)
self.line = tk.Entry(f)
self.line.pack(side=tk.BOTTOM, padx=10, pady=10)
self.line.focus_force()
self.toplevel.bind('<Return>', self.send_line)
return f
def send_line(self, _evt):
line = self.line.get()
self.line.delete(0, tk.END)
self.line_sender(line)
def add_message(self, msg):
self.area.config(state=tk.NORMAL)
self.area.insert(tk.END, '%s\n' % msg)
self.area.config(state=tk.DISABLED)
def set_dispose_callback(self, callback):
self.toplevel.protocol('WM_DELETE_WINDOW', callback)
def show(self):
if self.class_:
self.root = Toplevel(slef.master, class_=self.class_)
else:
self.root = Toplevel(self.master)
self.root.title(self.title)
self.root.iconname(self.title)
self.frame = Frame(self.root, padx=5, pady=5)
self.stf = Frame(self.frame)
stext = ScrolledText(self.stf, bg='white', height=20, width=120)
stext.insert(END, self.text)
stext.pack(fill=BOTH, side=LEFT, expand=True)
stext.focus_set()
self.stf.pack(expand=True, fill=BOTH)
self.frame.pack(expand=True, fill=BOTH)
self.root.bind('<Return>', self.return_evt)
b = Button(self.frame, text='Close', width=10,
command=self.wm_delete_window)
b.pack(side=TOP, pady=5)
self.root.protocol('WM_DELETE_WINDOW', self.wm_delete_window)
self._set_transient(self.relx, self.rely)
self.root.wait_visibility()
self.root.grab_set()
self.root.mainloop()
self.root.destroy()
class ErrDialog(Dialog):
def __init__(self,master=None, Title="Error", Short="",Msg=""):
self.Title=Title
self.Msg=Msg
self.Short = Short
Dialog.__init__(self,parent=master,title=Title)
def body(self,unused):
self.text = ScrolledText(self)
self.text["height"] = "8"
self.text["width"] = "50"
self.text.pack(side="top",expand="yes",fill="both")
self.text.insert("0.0", self.Msg)
self.text["state"] = "disabled"
self.result = False
def buttonbox(self):
box = Frame(self)
w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
w.pack(side=LEFT, padx=5, pady=5)
self.bind("<Return>", self.ok)
box.pack()
def textFieldConstructor(self, labelText, value):
def selectAllText(event):
xField = event.widget
xField.tag_add(SEL, '1.0', 'end')
xField.mark_set(INSERT, "1.0")
xField.see(INSERT)
return 'break'
#Label(self.body, text=labelText).grid(row=0, column=0, sticky='nw')
Label(self.body, text=labelText).pack(side=TOP)
#xTextbox = Text(self.body) ## ver que width y height poner
xTextbox = ScrollText(self.body)
#xTextbox.bind('<KeyRelease>', lambda event: apply())
xTextbox.bind('<Control-Key-a>', lambda event: selectAllText(event) )
xTextbox.bind('<Control-Key-A>', lambda event: selectAllText(event) )
#xTextbox.grid(row=1, column=0, sticky='nw')
xTextbox.pack(side=BOTTOM, fill=BOTH, expand=True)
xTextbox.insert('1.0', value)
self.entries[labelText] = xTextbox
if self.firstField == None:
self.firstField = xTextbox
#SQL buttons from module
params = {'parent':self.upper, 'field':self.firstField}
MOD.runModules('TOPLEVEL', params)
def browser(self, file):
new = Toplevel()
text = ScrolledText(new, height=30, width=90)
text.config(font=('Courier', 9, 'normal'))
text.pack()
new.title("Poor-man's Text Editor")
new.iconname("PyBrowser")
text.insert('0.0', open(file, 'r').read() )
def browser(self, filename):
new = Toplevel() # make new window
text = ScrolledText(new, height=30, width=90) # Text with scrollbar
text.config(font=('courier', 10, 'normal')) # use fixed-width font
text.pack()
new.title("Text Viewer") # set window mgr attrs
new.iconname("browser")
text.insert('0.0', open(filename, 'r').read() ) # insert file's text
def __init__(self, parent, text, title="Phoshare Help"):
Toplevel.__init__(self, parent)
self.transient(parent)
self.title(title)
self.parent = parent
t = ScrolledText(self)
t.insert(END, text)
t.config(state=DISABLED)
t.pack()
class Toplevel_ScolledText(tk.Toplevel):
def __init__(self, master=None, cnf={}, **kw):
tk.Toplevel.__init__(self, master=None, cnf={}, **kw)
self.__ShowText = ScrolledText(self,height = 20,width=40)
self.__ShowText.pack(expand=1,fill='both')
def addtext(self,Text_output=''):
self.__ShowText.insert('end',Text_output)
print(Text_output)
class App(object):
def __init__(self):
self.window = tk.Tk()
self.window.attributes("-fullscreen",True)
self.window.minsize(width=320, height=240)
self.window.maxsize(width=320, height=240)
self.buttonFrame = tk.Frame(self.window)
self.printButton=tk.Button(self.buttonFrame, text='PRINT!', height=2, command=self.printTxt)
self.printButton.pack(side=tk.LEFT, fill=tk.X, padx=5, pady=5)
self.loadButton=tk.Button(self.buttonFrame, text='LOAD', height=2, command=self.load)
self.loadButton.pack(side=tk.LEFT, fill=tk.X, padx=5, pady=5, expand=1)
self.exitButton=tk.Button(self.buttonFrame, text='EXIT', height=2, command=self.exitWin)
self.exitButton.pack(side=tk.LEFT, fill=tk.X, padx=5, pady=5, expand=1)
self.buttonFrame.pack(side=tk.TOP)
self.filename = '/home/pi/Desktop/fly.txt'
self.txt = ScrolledText(self.window)
self.txt.vbar.config(width=18)
self.txt.pack(expand=True, fill=tk.BOTH)
self.loadFile()
self.poll()
def poll(self):
if(float(self.txt.vbar.get()[1])==1):
self.txt.see(1.0) #goto top
else:
self.txt.yview(tk.SCROLL,1,tk.UNITS)
self.window.after(1000, self.poll)
def load(self):
self.filename = askopenfilename(initialdir="/home/pi/Desktop", title="SELECT TXT", filetypes=(("txt files","*.txt"),("all files","*.*")) )
self.loadFile()
def loadFile(self):
self.txt.delete(1.0,tk.END)
fly = open(self.filename,'r')
self.txt.insert(1.0, fly.read())
fly.close()
def printTxt(self):
call(["lp", self.filename])
tkMessageBox.showinfo("PRINT", "it's printing!")
def exitWin(self):
result = tkMessageBox.askquestion("EXIT?!", "zomg, u sure?", icon='warning')
if result == 'yes':
self.window.quit()
class MainApplication():
def __init__(self, master):
self.filename = ""
self.confg = ""
self.master = master
#setting color.
bkc = "floral white"
fgc = "RosyBrown4"
bgc = "misty rose"
self.FontForButton = tkFont.Font(family="Verdana", size=12)
self.FontForLabel = tkFont.Font(family="Verdana", weight="bold")
self.frame = tk.Frame(self.master, bg=bkc)
self.frame.pack()
self.chose_button = tk.Button(self.frame, text = u"選擇檔案", command = self.open_file, font=self.FontForButton, width = 20, bg=bgc, fg=fgc)
self.chose_button.pack(padx = 5, pady = 10, side = tk.TOP)
self.chose_confg_button = tk.Button(self.frame, text = u"選擇設定檔", command = self.get_confg, font=self.FontForButton, width = 20, bg=bgc, fg=fgc)
self.chose_confg_button.pack(padx = 5, pady = 10, side = tk.TOP)
self.run_button = tk.Button(self.frame, text = u"執行", command = self.run, font=self.FontForButton, width = 20, bg=bgc, fg=fgc)
self.run_button.pack(padx = 5, pady = 10, side = tk.TOP)
self.text = ScrolledText(self.frame)
self.text.pack()
self.mdby = tk.Label(self.frame, text="\nPowered By MITLab", font=self.FontForLabel, fg="SkyBlue1", bg=bkc)
self.mdby.pack(side='bottom')
def open_file(self):
self.filename = tkFileDialog.askopenfilename()
if self.filename :
setup_env.display_message(u"選擇檔案: " + self.filename)
def get_confg(self):
self.confg = tkFileDialog.askopenfilename()
if self.confg :
setup_env.display_message(u"選擇設定檔案: " + self.confg)
def write(self, massage):
self.text.insert(tk.END, massage)
self.text.see(tk.END)
self.text.update_idletasks()#display message real time
def run(self):
try:
if not self.filename or not self.confg:
raise Exception('請選擇檔案!')
setup_env.display_message(u"開始執行...")
setup_env.set_environment(self.confg)
table = rw_data.read_excel(self.filename, 0)
rw_data.get_title_col(table)
cmp_data.filter_data(table)
cmp_data.cmp_data()
except Exception as e:
setup_env.display_message(e.message)
finally:
setup_env.clean_envirnoment()
def tk_scroll(text, title = 'Help'):
win = Tk()
fnt = tkFont.Font(family="Fixedsys", size=12)
fnt = tkFont.Font(family="Courier", size=12)
scroll = ScrolledText(win, fg='white', bg='black', font=fnt, height=20)
scroll.pack(side=BOTTOM, fill=BOTH, expand=1)
scroll.insert('end', text)
Button(win, text='OK', command=win.destroy).pack(side=BOTTOM)
win.title(title)
return win
class MemorablePwdsApp(pp2e_laj.gui.tools.guimixin.GuiMixin,
pp2e_laj.gui.tools.guimaker.GuiMakerWindowMenu):
"""(Tkinter) User interface for memorable passwords application."""
def clear(self):
"""Clear all the candidate passwords."""
self._candidates = []
self.refreshCandidates()
def generate(self):
"""Generates a set of candidate passwords."""
for i in range(0, 8):
self._candidates.append(self._generator.next())
self.refreshCandidates()
def help(self):
pp2e_laj.gui.tools.guimaker.GuiMakerWindowMenu.help(self)
def makeWidgets(self):
middle = Frame(self)
middle.pack(expand=YES, fill=BOTH)
Label(middle, text='Candidate Passwords').grid(row=0,
column=0,
sticky=NSEW)
self.candidatesView = ScrolledText(middle, height=15, width=45)
self.candidatesView.config(font=('courier', 10, 'normal'))
self.candidatesView.grid(row=1, column=0, sticky=NSEW)
Label(middle, text='Try It!').grid(row=0, column=1, sticky=NSEW)
self.scratchPadView = ScrolledText(middle, height=15, width=45)
self.scratchPadView.config(font=('courier', 10, 'normal'))
self.scratchPadView.grid(row=1, column=1, sticky=NSEW)
def refreshCandidates(self):
self.candidatesView.delete('1.0', END)
for word in self._candidates:
self.candidatesView.insert(END, word + '\n')
def start(self):
"""Initialize the menu bar and tool bar of the application."""
self._candidates = []
self._generator = mem_pwds.MemorablePwds.MemorablePwds()
self.menuBar = [
('File', 0, [('New', 0, self.clear),
('Exit', 0, sys.exit)]),
('Edit', 0, [('Generate', 0, self.generate)]),
]
self.toolBar = [
('Generate', self.generate, {'side': LEFT}),
('Clear', self.clear, {'side': LEFT}),
]
class Run_UI:
def __init__(self,root):
#creating the title and window dimensions
root.iconbitmap('Images\img.ico')
root.title("Never Miss Class")
root.maxsize(width=450,height=300)
root.minsize(width=450,height=300)
centre_screen(root,225,150)
#creating a canvas to place widgets on
self.main_canvas = Canvas(root,width = 450, height =300,highlightthickness=0)
self.main_canvas.pack()
self.text_field = ScrolledText(self.main_canvas,width=52,height=18)
#You have to set the state to normal to make changes to it. Disabling it makes it uneditable
self.text_field.configure(state='normal')
#deleting anything previously in the text field
self.text_field.delete(1.0,END)
#putting stuff in the text field. Works just like appending onto a list.
self.text_field.insert(END, "The program is now running in the background. \n")
#open the current day's database file
today = datetime.datetime.now().weekday()
weekdays = {0:"Monday",1:"Tuesday",2:"Wednesday",3:"Thursday",4:"Friday"}
f = open(weekdays[today]+".txt", "r")
classes = []
for line in f:
classes.append(line.strip("\n").split("|"))
f.close()
# sort the 2d list by class times, and sort the class names and URLs
# in the same way so the times and names stay together
insert_sort(classes[1], classes[0], classes[2])
# set up default names for any classes the user has not named
for i in range(len(classes[2])):
if classes[2][i] == "":
classes[2][i] = "Class " + str(i)
# print out the sorted schedule
self.text_field.insert(END, "Here is "+weekdays[today]+"'s schedule: \n")
self.text_field.insert(END, ("{0:25}{1:>10}").format("Class Name", "Class Time \n"))
self.text_field.insert(END, "-" * 35 + "\n")
# iterate through the list of URLs
for i in range(len(classes[0])):
# for every non-empty url, print the associated name and date of the class
if classes[0][i] != "":
self.text_field.insert(END, ("{0:25}{1:>10}").format(classes[2][i], classes[1][i] + "\n"))
# disable the text field after writing to it
self.text_field.configure(state='disabled')
self.text_field.place(x=5,y=5)
def onViewMail():
# view selected message
msgnum = selectedMsg()
if not (1 <= msgnum <= len(msgList)):
showerror('PyMail', 'No message selected')
else:
text = msgList[msgnum-1] # or put in a TextEditor
from ScrolledText import ScrolledText
window = Toplevel()
window.title('PyMail message viewer #' + str(msgnum))
browser = ScrolledText(window)
browser.insert('0.0', text)
browser.pack(expand=YES, fill=BOTH)
class NoteCreate(Toplevel):
"""
Create Note page
"""
def __init__(self):
Toplevel.__init__(self)
self.bg_page = PhotoImage(file="Image/note_bg1.gif")
self.favorite_logo = PhotoImage(file="Image/favorite2.gif")
def note_page(self, text_title, text_note, favorite):
"""Display a Note when add new note or edit note"""
def add_destroy():
"""add new data and destroy current window"""
message = tkMessageBox.showinfo('Status', 'Complete')
add_data(text_title, text_note, date(), favorite)
self.destroy()
self.background = Label(self, image=self.bg_page)
self.new_note = Label(self, text=text_title,
bg='#efe9dc', fg='#f46b2f',
font=('AngsanaUPC', 18, 'bold'))
self.txt = ScrolledText(self, width=44, height=13, bg='#efe9dc',\
font=('AngsanaUPC', 14), relief=FLAT)
self.txt.insert('1.0', text_note)
self.txt.config(state='disable')
self.ok = Button(self, text='Ok', bg='#02d602', relief=FLAT,
width=10, fg='white', font=('Arial', 10, 'bold'),
command=add_destroy, activebackground='#49B203',
activeforeground='white')
self.cancel = Button(self, text='Cancel', bg='#a0a0a0', relief=FLAT,
width=10, fg='white', font=('Arial', 10, 'bold'),
activebackground='#838483', activeforeground=
'white', command=self.destroy)
self.background.place(x=0, y=0)
self.new_note.place(x=30, y=50)
self.txt.place(x=25, y=100)
self.ok.place(x=80, y=455)
self.cancel.place(x=190, y=455)
if favorite == 1:
self.favor = Label(self, image=self.favorite_logo, bg='#efe9dc')
self.favor.place(x=266, y=40)
self.bind("<Button-1>", self.flat)
def flat(self, event):
"""Event widget flat"""
event.widget.config(relief=FLAT)
class NoAnnDialog(Dialog):
result = None
def __init__(self,master=None, Title="No Annotation File Found", Filename="",
Msg="The file you have loaded does not have an associated annotation file"):
self.Title=Title
self.Msg=Msg
self.filename = Filename
#self.Short = Short
Dialog.__init__(self,master,title=self.Title)
def body(self,unused):
self.text = ScrolledText(self)
self.text["height"] = "6"
self.text["width"] = "50"
self.text.pack(side="top",expand="yes",fill="both")
self.text.insert("1.0", self.Msg)
self.text["state"] = "disabled"
self.result = False
def ok(self, unused=None):
self.result = True
Dialog.ok(self)
return True
def buttonbox(self):
box = Frame(self)
w = Button(box, text="Simple BTA", width=10, command=lambda :self.click("simple"), default=ACTIVE)
w1 = Button(box, text="Reset File", width=10, command=lambda :self.click("reset"), default=ACTIVE)
w2 = Button(box, text="Mark Unknown", width=10, command=lambda :self.click("unknown"), default=ACTIVE)
w.pack(side=LEFT, padx=5, pady=5)
w1.pack(side=LEFT, padx=5, pady=5)
w2.pack(side=LEFT, padx=5, pady=5)
#self.bind("<Return>", self.ok)
box.pack()
def click(self, value):
self.result = value
Dialog.ok(self)
def onViewRawMail():
# view selected message - raw mail text with header lines
msgnum = selectedMsg()
if not (1 <= msgnum <= len(msgList)):
showerror("PyMail", "No message selected")
else:
text = msgList[msgnum - 1] # put in ScrolledText
from ScrolledText import ScrolledText
window = Toplevel()
window.title("PyMail raw message viewer #" + str(msgnum))
browser = ScrolledText(window)
browser.insert("0.0", text)
browser.pack(expand=YES, fill=BOTH)
class Updates():
""" обновление программы """
def __init__(self,app):
self.app=app
self.win=Frame(self.app.win)
self.check_b=Button(self.win,text='Проверить доступные обновления',style='mini2.TButton',image=self.app.app.app.img['check'],compound='left',command=self.update_list)
self.check_b.grid(row=0,column=0,padx=5,pady=5,sticky=N)
self.txt=ScrolledText(self.win,width=85,height=10,font=('normal',10))
self.txt.grid(row=1,column=0,sticky=N,padx=30)
self.down_but=Button(self.win,text='Загрузить обновления',image=self.app.app.app.img['download'],compound='left',style='mini2.TButton',state='disable',command=self.download_updates)
self.down_but.grid(row=2,column=0,pady=5)
def update_list(self):
""" загружаем список доступных обновлений """
serv=self.app.app.app.sets.sync_server
try:last=int(self.app.app.app.sets.last_update)
except:last=0
self.check_b['state']='disable'
self.txt.delete(0.0,END)
self.txt.insert(END,'Выполняется проверка обновлений...\n')
self.win.update()
data={}
data['data']=str(last)
try:
resp=urllib.urlopen(serv+'/updates',urllib.urlencode(data)).read()
resp=eval(resp)
except Exception,x:
self.txt.insert(END,'Не удалось подключиться к серверу обновлений :(')
self.win.update()
self.check_b['state']='normal'
return
if len(resp)==0:
self.txt.insert(END,'Новых обновлений не найдено!')
self.win.update()
self.check_b['state']='normal'
return
self.txt.delete(0.0,END)
for x in resp:
self.txt.insert(END,'Обновление от %s.\n%s\n\n'%(int2date(x[0]),x[1].encode('utf-8')))
self.resp=resp
self.down_but['state']='normal'
class GuiOutput:
def __init__(self, parent=None):
self.text = None
if parent: self.popupnow(parent) # popup now or on first write
def popupnow(self, parent=None): # in parent now, Toplevel later
if self.text: return
self.text = ScrolledText(parent or Toplevel())
self.text.config(font=('courier', 9, 'normal'))
self.text.pack()
def write(self, text):
self.popupnow()
self.text.insert(END, str(text))
self.text.see(END)
self.text.update()
def writelines(self, lines): # lines already have '\n'
for line in lines: self.write(line) # or map(self.write, lines)
class my_form(Frame):
"""Form"""
def __init__(self, master=None):
"""create elements of form"""
Frame.__init__(self, master)
self.pack()
#self.createWidgets()
self.textBox = ScrolledText(self, height=15, width=100)
self.textBox.pack()
self.textBox.tag_config("b", foreground="blue")
self.textBox.tag_config("r", foreground="red")
# insert the msg from lets_rock will display when finished,
# that's to late
if os.getenv('LANG')[0:2] == "de":
self.textBox.insert(END,
"Es kann eine Weile dauern, "
+ "vielleicht eine Tasse Kaffee geniessen...")
else:
self.textBox.insert(END,
"Working, this can take a while, enjoy a cup of coffee...\n")
self.pressButton = Button(self,
text="ID3 easyTAG Editor", command=self.call_id3_editor)
# the button will appear when finished
#self.pressButton.pack()
# registering callback
self.listenID = self.after(400, self.lets_rock)
#self.listenID = self.lets_rock
def display_logging(self, log_message, text_format):
"""display messages in form, loading periodically """
if text_format is None:
self.textBox.insert(END, log_message + "\n")
else:
self.textBox.insert(END, log_message + "\n", text_format)
def call_id3_editor(self):
self.textBox.insert(END, "Click" + "\n")
# start subprocess
try:
subprocess.Popen(["easytag", ac.app_workin_path],
stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
except Exception, e:
self.display_logging("Error: %s" % str(e), "r")
return None
def showhelp(helptext=helptext, appname="PyMail"): # show helptext in
from ScrolledText import ScrolledText # a non-modal dialog
new = Toplevel() # make new popup window
bar = Frame(new) # pack first=clip last
bar.pack(side=BOTTOM, fill=X)
code = Button(bar, bg="beige", text="Source", command=showsource)
quit = Button(bar, bg="beige", text="Cancel", command=new.destroy)
code.pack(pady=1, side=LEFT)
quit.pack(pady=1, side=LEFT)
text = ScrolledText(new) # add Text + scrollbar
text.config(font="system", width=70) # too big for showinfo
text.config(bg="steelblue", fg="white") # erase on btn or return
text.insert("0.0", helptext)
text.pack(expand=YES, fill=BOTH)
new.title(appname + " Help")
new.bind("<Return>", (lambda event, new=new: new.destroy()))
def onHist(self):
# show recent calcs log popup
# self.infobox('PyCalc History', self.eval.getHist())
from ScrolledText import ScrolledText
new = Toplevel() # make new window
ok = Button(new, text="OK", command=new.destroy)
ok.pack(pady=1, side=BOTTOM) # pack first=clip last
text = ScrolledText(new, bg='beige') # add Text + scrollbar
text.insert('0.0', self.eval.getHist()) # get Evaluator text
text.pack(expand=YES, fill=BOTH)
# new window goes away on ok press or enter key
new.title("PyCalc History")
new.bind("<Return>", (lambda event, new=new: new.destroy()))
ok.focus_set() # make new window modal:
new.grab_set() # get keyboard focus, grab app
new.wait_window() # don't return till new.destroy
class aAbout(tkSimpleDialog.Dialog):
""" The application's about box """
def __init__(self, master=None):
tkSimpleDialog.Dialog.__init__(self, master)
def buttonbox(self):
# Stolen from tkSimpleDialog.py
# add standard button box. override if you don't want the
# standard buttons
box = Tk.Frame(self)
w = Tk.Button(box, text="OK", width=10)
w.pack(side=Tk.RIGHT, padx=5, pady=5)
self.bind("<Return>", self.ok)
box.pack(side=Tk.BOTTOM,fill=X)
def body(self, master):
self.resizable(0,0)
self.catIconImage = Tk.PhotoImage(file=GIFFILE) # statt file=
self.catIcon = Tk.Label(master, image=self.catIconImage)
self.catIcon.pack(side=Tk.TOP)
label = Tk.Label(master, text=crnotice1)
label.pack(side=Tk.TOP)
font = "Helvetica "+TITLEFONTSIZE
label = Tk.Label(master, font=font, text=crnotice2,
justify=Tk.CENTER)
label.pack(side=Tk.TOP)
color = 'green'
font = "Helvetica "+AXISFONTSIZE
self.infoText = ScrolledText(master, relief=Tk.FLAT,
padx=3, pady=3,
background=color,
#foreground="black",
wrap='word',
width=60, height=12,
font=font)
self.infoText.pack(expand=0, fill=X, side=Tk.BOTTOM)
self.infoText.delete('0.0', Tk.END)
self.infoText.insert('0.0', getLicense())
self.infoText.configure(state=Tk.DISABLED)
self.title("STARS - About")
def ok(self):
print 'ok'
class LogViewer(Frame):
def __init__(self, parent, filename):
Frame.__init__(self,parent)
self.filename = filename
self.file = open(filename, 'r')
self.text = ScrolledText(parent)
self.text.pack(fill=BOTH)
data = self.file.read()
self.size = len(data)
self.text.insert(END, data)
self.after(100, self.poll)
def poll(self):
if os.path.getsize(self.filename) > self.size:
data = self.file.read()
self.size = self.size + len(data)
self.text.insert(END, data)
self.after(100,self.poll)
class Terminal(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
self.CreateWidgets()
self.prompt = '>>> '
configfile = open('adminclientconfig.txt', 'r')
hostname = configfile.readline().strip()
port = int(configfile.readline().strip())
username = configfile.readline().strip()
password = configfile.readline().strip()
self.conn = Connection(hostname, port, username, password
,self.ReceiveMessage
,lambda: self.ReceiveMessage("connection successful")
,lambda: self.ReceiveMessage("ERROR!!!!"))
def destroy(self):
self.conn.Shutdown()
Frame.destroy(self)
def CreateWidgets(self):
self.text = ScrolledText(self, state=DISABLED, height=30)
self.text["fg"] = "white"
self.text["bg"] = "black"
self.text.pack()
self.entry = Entry(self)
self.entry["fg"] = "white"
self.entry["bg"] = "black"
self.entry.pack(fill=X,pady=0)
self.entry.bind("<Key-Return>", self.SendMessage)
# self.entry.bind("<Key-Tab>", lambda _: self.entry.insert(INSERT, "\t"))
def SendMessage(self, event):
data = self.entry.get()
self.entry.delete(0, END)
self.conn.OnCommand(data, self.OnResult)
self.ReceiveMessage(self.prompt + data) # echo
def ReceiveMessage(self, data):
self.text.config(state=NORMAL)
self.text.insert(END, data+"\n")
self.text.config(state=DISABLED)
self.text.yview_pickplace('end')
def OnResult(self, more):
if more:
self.prompt = '... '
else:
self.prompt = '>>> '
class Licensing( Frame ):
BUTTON_TEXT = "Copy to clipboard"
def __init__( self, master ):
Frame.__init__( self, master )
COMPOSITOR.register_view( self )
self._setup_view()
self.on_model_updated( COMPOSITOR.OTHER_UPDATED )
def _setup_view( self ):
self.rowconfigure( 0, weight = 1 )
self.columnconfigure( 0, weight = 1 )
self.license_box = ScrolledText( self, state = DISABLED )
self.license_box.grid( row = 0, column = 0, sticky = W + E + N + S, padx = 5, pady = 5 )
self.clipboard_button = Button( self, text = self.BUTTON_TEXT, command = self._on_copy_pressed )
self.clipboard_button.grid( row = 1, column = 0, sticky = N + E )
def _on_copy_pressed( self ):
self.license_box.clipboard_clear()
self.license_box.clipboard_append( self.license_box.get( '0.0', END ) )
self.clipboard_button.configure( text = "Copied!", state = DISABLED )
self.after( 2500, lambda: self.clipboard_button.configure( text = self.BUTTON_TEXT, state = NORMAL ) )
def on_model_updated( self, reason ):
if reason not in [COMPOSITOR.OTHER_UPDATED, COMPOSITOR.SELECTED_TYPE_CHANGED, COMPOSITOR.LAYER_ADDED, COMPOSITOR.LAYER_REMOVED, COMPOSITOR.SHEET_SELECTED, COMPOSITOR.LAYER_ORDER_CHANGED]:
return
# The compositor changed state, so make sure we're up to date, too.
self.license_box.configure( state = NORMAL )
# clear the existing text
self.license_box.delete( 1.0, END )
sheets = COMPOSITOR.get_selected_sheets().values()
license_text = LICENSING.get_formatted_licensing( sheets )
self.license_box.insert( END, license_text )
self.license_box.configure( state = DISABLED )
def destroy( self ):
COMPOSITOR.deregister_view( self )
Frame.destroy( self )
class StringViewer(Frame):
def __init__(self, parent, get_func, title=None):
Frame.__init__(self,parent)
self.text = ScrolledText(parent)
self.text.pack(fill=BOTH,expand="yes")
self.prev = get_func()
self.text.insert(END,self.prev)
self.after(1000, self.poll)
self.get_func=get_func
parent.wm_title(title)
def poll(self):
str = self.get_func()
if not str == self.prev:
self.text.delete("1.0", END)
self.text.insert(END, self.get_func())
self.text.see(END)
self.after(1000,self.poll)
class Chore:
def __init__(self, parent, day, day_index = None):
# Create a new Chore object, loading day_index from Day
# If day_index is not set, create blank Chore
self.check_state = BooleanVar()
#self.description = StringVar()
self.this = self
self.parent = parent
self.frame = Frame(parent, borderwidth = 1, relief = RAISED)
self.check = Checkbutton(self.frame, variable=self.check_state,
text = "Done",
onvalue = True, offvalue = False)
self.textb = ScrolledText(self.frame,
wrap=WORD, width = 40, height = 3,
selectbackground ="#ff5500")
if(day_index != None):
self.textb.insert("1.0", day.get_index(day_index)[1])
self.check_state.set(day.get_index(day_index)[0])
print day.get_index(day_index)[0].__class__
else:
self.check_state.set(0)
self.check.pack(side = LEFT)
self.textb.pack(side = LEFT)
self.delete = Button(self.frame, width = 6,text = "Delete", command =
lambda: self.seppuku()).pack(side = TOP)
self.clear = Button(self.frame, width = 6, text = "Clear", command =
lambda: self.text.delete("1.0", END))
self.clear.pack(side = BOTTOM)
self.frame.pack()
def seppuku(self):
# Really bad design here, instances should not delete themselves...
self.frame.destroy()
del self
def display(grammar, src, trace):
r = tk.Tk()
f = tk.Frame(master=r)
lt = ScrolledText(master=f)
rt = ScrolledText(master=f)
lt.pack(side="left", expand=True, fill="both")
rt.pack(side="right", expand=True, fill="both")
bot = ScrolledText(master=r, height=5)
tracer = Tracer(lt, rt, bot, trace)
toolbar = tk.Frame(master=r)
tk.Button(toolbar, text="Next", width=5, command=tracer.advance).pack(side="left")
tk.Button(toolbar, text="Prev", width=5, command=tracer.rewind).pack(side="left")
f.pack(expand=1, fill="both")
toolbar.pack(fill=tk.X)
bot.pack(fill=tk.X)
lt.insert(tk.END, grammar)
rt.insert(tk.END, src)
tracer.display()
return r
class LD_GUI(Frame):
def __init__(self, parent):
Frame.__init__(self, master=parent)
parent.title('Liar\'s Dice')
self.canvas = Canvas(self, width=550, height=500)
self.canvas.pack(fill='both', expand = True)
self.canvas.place(x=0, y=0)
self.bid_logs = ScrolledText(self, undo=True, width=100, height = 100)
self.bid_logs.pack(fill='both', expand = True)
self.bid_logs['font'] = ('consolas', '12')
self.bid_logs.place(x=350, y=0)
self.input_box = Text(self, undo=True, width=100, height=100)
self.input_box.pack(fill='both', expand = True)
self.input_box['font'] = ('consolas', '12')
self.input_box.place(x=350, y=450)
self.pack(fill='both', expand = True)
self.insert_to_log()
def insert_to_log(self):
self.bid_logs.insert(tki.INSERT, 'HI!')
self.input_box.insert(tki.INSERT, 'OK')
def initGame(self):
try:
self.idot = Image.open("dot.png")
self.dot = ImageTk.PhotoImage(self.idot)
self.ihead = Image.open("head.png")
self.head = ImageTk.PhotoImage(self.ihead)
self.iapple = Image.open("apple.png")
self.apple = ImageTk.PhotoImage(self.iapple)
except IOError, e:
print e
sys.exit(1)
self.createObjects()
self.locateApple()
self.bind_all("<Key>", self.onKeyPressed)
self.after(DELAY, self.onTimer)
class MainWindow(Tkinter.Tk, TkSelectMixIn):
def __init__(self):
Tkinter.Tk.__init__(self)
self.textbox = ScrolledText(self, bg='white')
self.textbox.pack(fill=BOTH, expand=1)
self.server()
self.start()
def server(self):
# inicializa o servidor
self.sock = socket.socket(socket.AF_INET, \
socket.SOCK_STREAM)
self.sock.bind(('localhost', 8000))
self.sock.listen(1)
# a chamada para input_read para o socket do servidor e
# um pouco diferente, tendo como callback o metodo
# self.accept
self.server_tag = self.input_add(self.sock, \
INPUT_READ, self.accept)
# mantemos uma lista dos clientes conectados
self.clients = {}
def accept(self, source, condition):
# metodo chamado quando o servidor tem um cliente
# esperando para ser aceito
conn, addr = source.accept()
self.insert("%s:%s conectado\n" % addr)
# insere o cliente na lista e registra o metodo self.write
# como callback para quando existirem dados esperando para
# serem lidos.
self.clients[addr] = (conn,
self.input_add(conn, INPUT_READ, self.write))
def write(self, source, condition):
# metodo chamado quando um cliente envia dados
data = source.recv(1024)
if not data.strip() or data.strip() == 'bye':
# se o cliente enviar um "bye" ou uma linha em branco,
# desconecte-o
source.close()
for addr, (conn, tag) in self.clients.iteritems():
if source is conn:
self.input_remove(tag)
self.insert('%s:%s desconectado\n' % addr)
del self.clients[addr]
break
else:
for (addr, port), (conn, tag) in \
self.clients.iteritems():
if source is conn:
self.insert('%s:%s>>>%s\n'%(addr, port, \
data.strip()))
break
def insert(self, data):
self.textbox.insert(END, data)
self.textbox.see(END)
def quit(self):
self.input_remove(self.server_tag)
for add, (conn, tag) in self.clients.iteritems():
self.input_remove(tag)
conn.close()
self.sock.close()
Tkinter.Tk.destroy(self)
class JSearch():
def __init__(self, master):
tries=False
self.var=StringVar()
self.var.set('Nothing to Display, Enter text to search')
self.master=master
master.title("JSearch")
self.var1=StringVar() #holds the result
self.label2=Label(master, text='type text to search')
self.label2.grid(sticky=E)
self.countlabel=Label(master, text="")
self.countlabel.grid(row=3)
self.entry=Entry(master,bd=5)
self.entry.grid(row=0, column=1) #search entry
self.label=Label(master, text=self.var.get(), width=40, height=5)
self.label.grid(row=2)
self.results=ScrolledText(master, width=70, height=15)
self.results.insert(INSERT, '')
self.results.grid(row=2, column=1)
self.searchButton=Button(master, text="Search", command=self.main)
self.searchButton.grid(row=1, column=1)
def chDsp(self):
self.var.set('updated')
self.label.configure( text=self.var.get())
self.label.update()
root.update_idletasks()
#scans the system
def systemScan(self,iniList, location):
global count,total
self.location=location
self.iniList=iniList
length= len(iniList)
searchText=self.entry.get()
if (self.entry.get()==''):
self.var.set('you must enter a text to search for')
self.label.configure(text=self.var.get())
self.label.update()
return
else:
self.var.set('SEARCHING...............')
self.label.configure(text=self.var.get())
pass
for i in range(length):
total +=1
if (iniList[i].find('.wine')!=-1): #.wine folder produces an infinite loop
continue
try:
new_list = os.listdir(location +'/' + iniList[i])
temp=location + '/' + iniList[i]
self.var.set(temp)
self.label.configure(text=self.var.get())
self.label.update()
save[temp] = new_list
self.systemScan(new_list, temp)
except OSError:
pass
try:
self.fileSearch(searchText, str(iniList[i]), location)
except:
pass
self.var.set('finished....')
self.label.configure(text=self.var.get())
self.label.update()
return save
# method to search for strings in a file
def fileSearch(self, toSearch, currentFile, loc):
self.currentFile=currentFile
self.toSearch=toSearch
s=''
lst=len(os.listdir(location))
global tries, count
if(currentFile.find('.wine')!=-1):
print 'found', loc
return
if (currentFile.find(toSearch)!=-1):
s+='\n found '+ currentFile + '==> '+ loc+ ' \n'
self.results.insert(INSERT, str(s))
self.results.update
count +=1
def main(self):
global count, total
try:
initial_list=os.listdir(location)
except OSError:
print ("error")
print ('.......................')
k = self.systemScan(initial_list, location)
self.countlabel.configure(text=str(total)+' Files searched '+str(count) +' Files found')
self.countlabel.update()
def get_input(self):
searchStr =input()
return str(searchStr)
class Tkui(base.BaseUI):
"""
This is a ui class which handles the complete Tk user interface.
"""
def __init__(self):
""" Initializes."""
base.BaseUI.__init__(self)
# internal ui queue
self._event_queue = Queue.Queue()
# map of session -> (bold, foreground, background)
self._currcolors = {}
# ses -> string
self._unfinishedcolor = {}
self._viewhistory = 0
self._do_i_echo = 1
# holds a map of window names -> window references
self._windows = {}
# instantiate all the widgets
self._tk = Tk()
self._tk.geometry("800x600")
self.settitle()
fnt = tkFont.Font(family="FixedSys", size=10)
self._entry = CommandEntry(self._tk, self, fg='white', bg='black',
insertbackground='yellow', font=fnt,
insertwidth='2')
self._entry.pack(side='bottom', fill='both')
self._topframe = Frame(self._tk)
self._topframe.pack(side='top', fill='both', expand=1)
self._txt = ScrolledText(self._topframe, fg='white',
bg='black', font=fnt, height=20)
self._txt.pack(side='bottom', fill='both', expand=1)
self._txt.bind("<KeyPress>", self._ignoreThis)
self._txtbuffer = ScrolledText(self._topframe, fg='white',
bg='black', font=fnt, height=20)
self._txtbuffer.bind("<KeyPress-Escape>", self.escape)
self._txtbuffer.bind("<KeyPress>", self._ignoreThis)
self._entry.focus_set()
self._initColorTags()
self.dequeue()
exported.hook_register("config_change_hook", self.configChangeHandler)
exported.hook_register("to_user_hook", self.write)
# FIXME - fix this explanation. this is just terrible.
tc = config.BoolConfig("saveinputhighlight", 0, 1,
"Allows you to change the behavior of the command entry. When "
"saveinputhighlight is off, we discard whatever is on the entry "
"line. When it is on, we will retain the contents allowing you "
"to press the enter key to do whatever you typed again.")
exported.add_config("saveinputhighlight", tc)
self._quit = 0
def runui(self):
global HELP_TEXT
exported.add_help("tkui", HELP_TEXT)
exported.write_message("For tk help type \"#help tkui\".")
exported.add_command("colorcheck", colorcheck_cmd)
# run the tk mainloop here
self._tk.mainloop()
def wantMainThread(self):
# The tkui needs the main thread of execution so we return
# a 1 here.
return 1
def quit(self):
if not self._quit:
self._quit = 1
self._topframe.quit()
def dequeue(self):
qsize = self._event_queue.qsize()
if qsize > 10:
qsize = 10
for i in range(qsize):
ev = self._event_queue.get_nowait()
ev.execute(self)
self._tk.after(25, self.dequeue)
def settitle(self, title=""):
"""
Sets the title bar to the Lyntin title plus the given string.
@param title: the title to set
@type title: string
"""
if title:
title = constants.LYNTINTITLE + title
else:
title = constants.LYNTINTITLE
self._event_queue.put(_TitleEvent(self._tk, title))
def removeWindow(self, windowname):
"""
This removes a NamedWindow from our list of NamedWindows.
@param windowname: the name of the window to write to
@type windowname: string
"""
if self._windows.has_key(windowname):
del self._windows[windowname]
def writeWindow(self, windowname, message):
"""
This writes to the window named "windowname". If the window
does not exist, we spin one off. It handles ansi text and
messages just like writing to the main window.
@param windowname: the name of the window to write to
@type windowname: string
@param message: the message to write to the window
@type message: string or Message instance
"""
self._event_queue.put(_WriteWindowEvent(windowname, message))
def writeWindow_internal(self, windowname, message):
if not self._windows.has_key(windowname):
self._windows[windowname] = NamedWindow(windowname, self, self._tk)
self._windows[windowname].write(message)
def _ignoreThis(self, tkevent):
""" This catches keypresses from the history buffer."""
# kludge so that ctrl-c doesn't get caught allowing windows
# users to copy the buffer....
if tkevent.keycode == 17 or tkevent.keycode == 67:
return
self._entry.focus()
if tkevent.char:
# we do this little song and dance so as to pass events
# we don't want to deal with to the entry widget essentially
# by creating a new event and tossing it in the event list.
# it only sort of works--but it's the best code we've got
# so far.
args = ('event', 'generate', self._entry, "<KeyPress>")
args = args + ('-rootx', tkevent.x_root)
args = args + ('-rooty', tkevent.y_root)
args = args + ('-keycode', tkevent.keycode)
args = args + ('-keysym', tkevent.keysym)
self._tk.tk.call(args)
return "break"
def pageUp(self):
""" Handles prior (Page-Up) events."""
if self._viewhistory == 0:
self._txtbuffer.pack(side='top', fill='both', expand=1)
self._viewhistory = 1
self._txtbuffer.delete ("1.0", "end")
lotofstuff = self._txt.get ('1.0', 'end')
self._txtbuffer.insert ('end', lotofstuff)
for t in self._txt.tag_names():
taux=None
tst=0
for e in self._txt.tag_ranges(t):
if tst==0:
taux=e
tst=1
else:
tst=0
self._txtbuffer.tag_add(t,str(taux),str(e))
self._txtbuffer.yview('moveto', '1')
if os.name != 'posix':
self._txtbuffer.yview('scroll', '20', 'units')
self._tk.update_idletasks()
self._txt.yview('moveto','1.0')
if os.name != 'posix':
self._txt.yview('scroll', '220', 'units')
else:
# yscroll up stuff
self._txtbuffer.yview('scroll', '-15', 'units')
def pageDown(self):
""" Handles next (Page-Down) events."""
if self._viewhistory == 1:
# yscroll down stuff
self._txtbuffer.yview('scroll', '15', 'units')
def escape(self, tkevent):
""" Handles escape (Escape) events."""
if self._viewhistory == 1:
self._txtbuffer.forget()
self._viewhistory = 0
else:
self._entry.clearInput()
def configChangeHandler(self, args):
""" This handles config changes including mudecho. """
name = args["name"]
newvalue = args["newvalue"]
if name == "mudecho":
if newvalue == 1:
# echo on
self._do_i_echo = 1
self._entry.configure(show='')
else:
# echo off
self._do_i_echo = 0
self._entry.configure(show='*')
def _yadjust(self):
"""Handles y scrolling after text insertion."""
self._txt.yview('moveto', '1')
# if os.name != 'posix':
self._txt.yview('scroll', '20', 'units')
def _clipText(self):
"""
Scrolls the text buffer up so that the new text written at
the bottom of the text buffer can be seen.
"""
temp = self._txt.index("end")
ind = temp.find(".")
temp = temp[:ind]
if (temp.isdigit() and int(temp) > 800):
self._txt.delete ("1.0", "100.end")
def write(self, args):
"""
This writes text to the text buffer for viewing by the user.
This is overridden from the 'base.BaseUI'.
"""
self._event_queue.put(_OutputEvent(args))
def write_internal(self, args):
mess = args["message"]
if type(mess) == types.StringType:
mess = message.Message(mess, message.LTDATA)
elif "window" in mess.hints:
self.writeWindow_internal(mess.hints["window"], mess)
return
line = mess.data
ses = mess.session
if line == '' or self.showTextForSession(ses) == 0:
return
color, leftover = buffer_write(mess, self._txt, self._currcolors,
self._unfinishedcolor)
if mess.type == message.MUDDATA:
self._unfinishedcolor[ses] = leftover
self._currcolors[ses] = color
self._clipText()
self._yadjust()
def convertColor(self, name):
"""
Tk has this really weird color palatte. So I switched to using
color names in most cases and rgb values in cases where I couldn't
find a good color name.
This method allows me to specify either an rgb or a color name
and it converts the color names to rgb.
@param name: either an rgb value or a name
@type name: string
@returns: the rgb color value
@rtype: string
"""
if name.startswith("#"):
return name
rgb = self._tk._getints(self._tk.tk.call('winfo', 'rgb', self._txt, name))
rgb = "#%02x%02x%02x" % (rgb[0]/256, rgb[1]/256, rgb[2]/256)
print name, "converted to: ", rgb
return rgb
def _initColorTags(self):
""" Sets up Tk tags for the text widget (fg/bg/u)."""
for ck in fg_color_codes.keys():
color = self.convertColor(fg_color_codes[ck])
self._txt.tag_config(ck, foreground=color)
self._txtbuffer.tag_config(ck, foreground=color)
for ck in bg_color_codes.keys():
self._txt.tag_config(ck, background=bg_color_codes[ck])
self._txtbuffer.tag_config(ck, background=bg_color_codes[ck])
self._txt.tag_config("u", underline=1)
self._txtbuffer.tag_config("u", underline=1)
def colorCheck(self):
"""
Goes through and displays all the combinations of fg and bg
with the text string involved. Purely for debugging
purposes.
"""
fgkeys = ['30','31','32','33','34','35','36','37']
bgkeys = ['40','41','42','43','44','45','46','47']
self._txt.insert('end', 'color check:\n')
for bg in bgkeys:
for fg in fgkeys:
self._txt.insert('end', str(fg), (fg, bg))
self._txt.insert('end', str("b" + fg), ("b" + fg, bg))
self._txt.insert('end', '\n')
for fg in fgkeys:
self._txt.insert('end', str(fg), (fg, "b" + bg))
self._txt.insert('end', str("b" + fg), ("b" + fg, "b" + bg))
self._txt.insert('end', '\n')
self._txt.insert('end', '\n')
self._txt.insert('end', '\n')
class TextDemo(Demo):
label = 'Text widget displaying source with cheap syntax highlighting:\n'+\
'(Move mouse over text and watch indent-structure highlighting.)'
font = ('Courier', 10, 'normal')
bold = ('Courier', 10, 'bold')
Highlights = {'#.*': Options(foreground='red'),
r'\'.*?\'': Options(foreground='yellow'),
r'\bdef\b\s.*:':Options(foreground='blue', spacing1=2),
r'\bclass\b\s.*\n':Options(background='pink', spacing1=5),
r'\b(class|def|for|in|import|from|break|continue)\b':
Options(font=bold)
}
def __init__(self, master):
Demo.__init__(self, master)
self.text = ScrolledText(self, width=80, height=20,
font=self.font, background='gray65',
spacing1=1, spacing2=1, tabs='24')
self.text.pack(side=TOP, expand=YES, fill=BOTH)
content = open(sys.argv[0], 'r').read()
self.text.insert(AtEnd(), content)
reg = re.compile('([\t ]*).*\n')
pos = 0
indentTags = []
while 1:
match = reg.search(content, pos)
if not match: break
indent = match.end(1)-match.start(1)
if match.end(0)-match.start(0) == 1:
indent = len(indentTags)
tagb = 'Tagb%08d' % match.start(0)
tagc = 'Tage%08d' % match.start(0)
self.text.tag_configure(tagc, background='', relief=FLAT, borderwidth=2)
self.text.tag_add(tagb, Char( match.start(0)), Char(match.end(0)))
self.text.tag_bind(tagb, '<Enter>',
lambda e,self=self,tagc=tagc: self.Enter(tagc))
self.text.tag_bind(tagb, '<Leave>',
lambda e,self=self,tagc=tagc: self.Leave(tagc))
del indentTags[indent:]
indentTags.extend( (indent-len(indentTags))*[None] )
indentTags.append(tagc)
for tag in indentTags:
if tag:
self.text.tag_add(tag, Char(match.start(0)),
Char(match.end(0)))
pos = match.end(0)
for key,kw in self.Highlights.items():
self.text.tag_configure(key, cnf=kw)
reg = re.compile(key)
pos = 0
while 1:
match = reg.search(content, pos)
if not match: break
self.text.tag_add(key, Char(match.start(0)),Char(match.end(0)))
pos = match.end(0)
def Enter(self, tag):
self.text.tag_raise(tag)
self.text.tag_configure(tag, background='gray80', relief=RAISED)
def Leave(self, tag):
self.text.tag_configure(tag, background='', relief=FLAT)
class Updates():
""" обновление программы """
def __init__(self, app):
self.app = app
self.win = Frame(self.app.win)
self.check_b = Button(self.win,
text='Проверить доступные обновления',
style='mini2.TButton',
image=self.app.app.app.img['check'],
compound='left',
command=self.update_list)
self.check_b.grid(row=0, column=0, padx=5, pady=5, sticky=N)
self.txt = ScrolledText(self.win,
width=85,
height=10,
font=('normal', 10))
self.txt.grid(row=1, column=0, sticky=N, padx=30)
self.down_but = Button(self.win,
text='Загрузить обновления',
image=self.app.app.app.img['download'],
compound='left',
style='mini2.TButton',
state='disable',
command=self.download_updates)
self.down_but.grid(row=2, column=0, pady=5)
def update_list(self):
""" загружаем список доступных обновлений """
serv = self.app.app.app.sets.sync_server
try:
last = int(self.app.app.app.sets.last_update)
except:
last = 0
self.check_b['state'] = 'disable'
self.txt.delete(0.0, END)
self.txt.insert(END, 'Выполняется проверка обновлений...\n')
self.win.update()
data = {}
data['data'] = str(last)
try:
resp = urllib.urlopen(serv + '/updates',
urllib.urlencode(data)).read()
resp = eval(resp)
except Exception, x:
self.txt.insert(END,
'Не удалось подключиться к серверу обновлений :(')
self.win.update()
self.check_b['state'] = 'normal'
return
if len(resp) == 0:
self.txt.insert(END, 'Новых обновлений не найдено!')
self.win.update()
self.check_b['state'] = 'normal'
return
self.txt.delete(0.0, END)
for x in resp:
self.txt.insert(
END, 'Обновление от %s.\n%s\n\n' %
(int2date(x[0]), x[1].encode('utf-8')))
self.resp = resp
self.down_but['state'] = 'normal'
def viewfile():
new = Toplevel()
text = ScrolledText(new, height=30, width=90)
text.config(font=('Comic Sans MS', 14, 'normal'))
text.pack()
text.insert('0.0', askopenfile().read(16384))
class Socketgui(Tkinter.Tk):
def __init__(self):
Tkinter.Tk.__init__(self)
self.title('RemoteControlServer')
self.geometry('300x200')
self.server = echoserver.Socketserver()
self.set_widgets()
self.resizable(width=False, height=False)
def set_widgets(self):
self.port_label = Tkinter.Label(self, text='端口号 :')
self.port_label.place(x=30, y=25)
self.default_port = Tkinter.StringVar()
self.port_input = Tkinter.Entry(self,
width=18,
textvariable=self.default_port)
self.default_port.set('4444')
self.port_input.place(x=80, y=25)
self.port_label = Tkinter.Label(self, text='IP地址 :')
self.port_label.place(x=30, y=60)
self.ip_readonly = Tkinter.StringVar()
self.ip_display = Tkinter.Entry(self, text=self.ip_readonly, width=18)
self.ip_readonly.set(localip.get_local_ip())
self.ip_display['state'] = 'readonly'
self.ip_display.place(x=80, y=60)
self.start_btn = Tkinter.Button(self,
text='开启',
command=self.start_btn_response)
self.start_btn.place(x=220, y=21)
self.stop_btn = Tkinter.Button(self,
text='清空',
command=self.clear_btn_response)
self.stop_btn.place(x=220, y=56)
# self.ms_readonly = Tkinter.StringVar()
# self.ms_display = Tkinter.Entry(self,textvariable=self.ms_readonly,width=25,relief='flat',highlightcolor='white')
# self.ms_readonly.set(outsave.OUTSAVE)
# # self.ms_display['state'] = 'readonly'
# self.ms_display.place(x=30,y=120)
# self.last_ms = outsave.OUTSAVE
# self.th_outsave = threading.Thread(target=self.output_change)
# self.th_outsave.setDaemon(True)
# self.th_outsave.start()
self.ms_listbox = ScrolledText(self, height=6, width=35, relief='flat')
self.ms_listbox.place(x=5, y=100)
self.th_outsave = threading.Thread(target=self.ms_display)
self.th_outsave.setDaemon(True)
self.th_outsave.start()
def start_btn_response(self):
self.port = int(self.port_input.get())
self.addr = localip.get_local_ip()
self.server_thread = threading.Thread(target=self.server.Server_start,
args=(self.addr, self.port))
self.server_thread.setDaemon(True) #子线程随主线程一起关闭
self.server_thread.start()
def clear_btn_response(self):
self.ms_listbox.delete(1.0, 'end')
def ask_quit(self):
print "i'm here"
self.quit()
def ms_display(self):
while True:
if outsave.FLAG:
self.ms_listbox.insert('end', outsave.OUTSAVE)
outsave.FLAG = False
self.ms_listbox.yview_scroll(1, "units")
class Room(Toplevel):
__client_sock = None
__user_name = None
__room_name = None
__main_frame = None
__top_frame = None
__exit_room = False
def __init__(self, client, room_name, main_frame, top_frame):
Toplevel.__init__(self)
self['background'] = 'grey'
self.protocol('WM_DELETE_WINDOW', self.close_room)
self.__user_name = main_frame.get_user_name()
self.title("Room Name:" + room_name)
self.__room_name = room_name
self.configure_GUI()
self.__client_sock = client
self.__top_frame = top_frame
self.__main_frame = main_frame
self.__main_frame.add_new_room(self.__room_name, self)
self.withdraw()
self.mainloop()
def show_room(self):
self.__top_frame.withdraw()
self.deiconify()
def close_room(self):
self.withdraw()
def configure_GUI(self):
# main window
bg_color = '#208090'
self['bg'] = bg_color
self.geometry("400x500+520+500")
self.resizable(width=True, height=True)
self.frm_top = Frame(self, width=380, height=250)
self.frm_mid = Frame(self, width=380, height=150)
self.frm_btm = Frame(self, width=380, height=30)
self.frm_btm['bg'] = bg_color
self.label_msg_list = Label(self, justify=LEFT, text=u"""消息列表""")
self.label_user_name = Label(self, justify=LEFT, text=self.__user_name)
self.text_msg_List = ScrolledText(self.frm_top,
borderwidth=1,
highlightthickness=0,
relief='flat',
bg='#fffff0')
self.text_msg_List.tag_config('userColor', foreground='red')
self.text_msg_List.place(x=0, y=0, width=380, height=250)
self.text_client_msg = ScrolledText(self.frm_mid)
self.text_client_msg.grid(row=0, column=0)
self.button_send_msg = Button(self.frm_btm,
text='发送消息',
command=self.__send_msg_btn_cmd)
self.button_send_msg.place(x=0, y=0, width=100, height=30)
self.button_exit_room = Button(self.frm_btm,
text='退出房间',
command=self.__exit_room_btn_cmd)
self.button_exit_room.place(x=280, y=0, width=100, height=30)
self.label_msg_list.grid(row=0, column=0, padx=2, pady=2, sticky=W)
self.frm_top.grid(row=1, column=0, padx=2, pady=2)
self.label_user_name.grid(row=2, column=0, padx=2, pady=2, sticky=W)
self.frm_mid.grid(
row=3,
column=0,
padx=2,
pady=2,
)
self.frm_btm.grid(
row=4,
column=0,
padx=2,
pady=2,
)
self.frm_top.grid_propagate(0)
self.frm_mid.grid_propagate(0)
self.frm_btm.grid_propagate(0)
def destroy_room(self):
self.destroy()
def query_room_user_name(self):
msg = {'roomName': self.__room_name}
data = package_sys_msg("SysRoomUserNameRequest", msg)
self.__client_sock.append_to_msg_sending_queue(data)
def __exit_room_btn_cmd(self):
self.__exit_room = True
msg = {'roomName': self.__room_name}
data = package_sys_msg("SysExitRoomRequest", msg)
self.__client_sock.append_to_msg_sending_queue(data)
def __send_msg_btn_cmd(self):
if self.__exit_room:
return
usr_msg = self.text_client_msg.get('0.0', END)
self.display_new_msg(self.__user_name, usr_msg, 'userColor')
self.text_client_msg.delete('0.0', END)
data = package_room_chat_msg(self.__user_name, self.__room_name,
usr_msg)
self.__client_sock.append_to_msg_sending_queue(data)
def display_new_msg(self, user_name, msg, config=''):
self.text_msg_List['state'] = 'normal'
msg_time = time.strftime(" %Y-%m-%d %H:%M:%S", time.localtime()) + '\n'
self.text_msg_List.insert(END, user_name + ': ' + msg_time + msg,
config)
self.text_msg_List['state'] = 'disabled'
class Crawler_plusplus():
def __init__(self):
self.rt = tk.Tk() #创建窗口
self.rt.title('Automatically download pictures') #窗口标题
self.menu = tk.Menu(self.rt) #在根窗口里创建一个菜单
self.rt.config(menu=self.menu) #把新创建菜单定为根窗口的菜单
self.aboutmenu = tk.Menu(self.menu) #在根窗口菜单里创建一个菜单
self.picturemenu = tk.Menu(self.menu) #在根窗口菜单里创建一个菜单
self.aboutmenu.add_command(label='help',
command=self.help) #菜单里的菜单增加“help”命令
self.menu.add_cascade(label='About',
menu=self.aboutmenu) #把菜单里的菜单命名为about
self.menu.add_cascade(label='Picture Proecessing',
menu=self.picturemenu)
self.picturemenu.add_command(label='Start Proecessing',
command=self.Picture_Processing)
self.menu.add_command(label='refresh', command=self.refresh)
self.menu.add_command(label='Exit', command=self.close)
self.frame1 = tk.Frame(self.rt, height=260, width=520) #左边模块，负责爬取百度图片
self.middle = tk.Frame(self.rt, height=260, width=120) #右边模块，用来提示错误信息
self.lframe1 = tk.LabelFrame(self.frame1,
height=60,
width=520,
text='Save path')
self.lframe2 = tk.LabelFrame(self.frame1,
height=200,
width=520,
text='Download')
self.b1 = tk.Button(self.lframe1,
text='Choose',
width=8,
height=1,
command=self.get_directory1)
self.b2 = tk.Button(self.lframe1,
text='Confirm',
width=10,
height=1,
command=self.confirm_e)
self.b3 = tk.Button(self.lframe1,
text='Cancel',
width=10,
height=1,
command=self.deconfirm_e,
state='disabled')
self.a1 = tk.Button(self.lframe2,
text='Get the picture',
width=10,
height=1,
command=self.start_cr,
state='disabled')
self.e1 = tk.Entry(self.lframe1, takefocus=True)
self.e2 = tk.Entry(self.lframe2, state='disabled')
self.alo = tk.Label(self.rt, text='Note:') #中间模块的内容
self.ala = tk.Label(self.rt, text='',
foreground='red') #中间模块的错误提示，内容现在是空的
self.l1 = tk.Label(self.lframe2, text='Key words:', relief='flat')
self.l2 = tk.Label(self.lframe2,
text='Download progress:',
relief='groove')
self.s = ScrolledText(self.lframe2,
height=8,
width=40,
state='disabled',
wrap='char',
borderwidth=0)
self.frame1.grid(column=0, row=0, rowspan=2, columnspan=1)
self.lframe1.grid(row=0, column=1)
self.b1.place(x=45, y=15, anchor='center')
self.e1.place(x=280, y=15, anchor='e')
self.b2.place(x=400, y=15, anchor='e')
self.b3.place(x=480, y=15, anchor='e')
self.lframe2.grid(row=1, column=1)
self.l1.place(x=130, y=15, anchor='e')
self.e2.place(x=280, y=15, anchor='e')
self.a1.place(x=400, y=15, anchor='e')
self.l2.place(x=15, y=45, anchor='w')
self.s.place(x=15, y=115, anchor='w')
self.middle.grid(column=1, row=0)
self.ala.place(x=580, y=140, anchor='center')
self.alo.place(x=580, y=120, anchor='center')
#图形处理界面
def Picture_Processing(self):
top = tk.Toplevel()
top.title('Picture Processing')
top.geometry('520x260')
self.frame2 = tk.Frame(top, height=260, width=520) #框架 用来批量处理图片
self.lframe3 = tk.LabelFrame(self.frame2,
height=140,
width=520,
text='图片预处理')
self.lframe4 = tk.LabelFrame(self.frame2,
height=60,
width=520,
text='保存图片集')
self.lframe5 = tk.LabelFrame(self.frame2,
height=60,
width=520,
text='预处理图片路径选择')
self.b4 = tk.Button(self.lframe5,
text='选择图片目录',
width=12,
height=1,
command=self.get_directory5)
self.b5 = tk.Button(self.lframe5,
text='确定该目录',
width=10,
height=1,
command=self.confirm_e1)
self.b6 = tk.Button(self.lframe5,
text='取消确定',
width=10,
height=1,
command=self.deconfirm_e1,
state='disabled')
self.a2 = tk.Button(self.lframe3,
text='图片处理启动',
width=10,
height=1,
command=self.start_pi,
state='disabled')
self.ad = tk.Button(self.lframe4,
text='选择保存文件夹',
width=14,
height=1,
command=self.get_directory4,
state='disabled')
self.a3 = tk.Button(self.lframe4,
text='确定该目录',
width=10,
height=0,
command=self.confirm_e2,
state='disabled')
self.a4 = tk.Button(self.lframe4,
text='取消确定',
width=10,
height=0,
command=self.deconfirm_e2,
state='disabled')
self.a5 = tk.Button(self.lframe3,
text='默认设置',
width=10,
height=1,
command=self.reset,
state='disabled')
self.e3 = tk.Entry(self.lframe5, takefocus=True)
self.e4 = tk.Entry(self.lframe4, takefocus=True, state='disabled')
self.alb = tk.Label(self.lframe5, text='', foreground='red')
self.l3 = tk.Label(self.lframe3, text='处理进度:', relief='groove')
self.xlen = tk.IntVar()
self.xlen.set(128)
self.ylen = tk.IntVar()
self.ylen.set(128)
self.xl = tk.Entry(self.lframe3,
state='readonly',
width=4,
textvariable=self.xlen,
invcmd=self.alarm)
self.yl = tk.Entry(self.lframe3,
state='readonly',
width=4,
textvariable=self.ylen,
invcmd=self.alarm)
self.xv = tk.Label(self.lframe3, text='输出图宽:')
self.yv = tk.Label(self.lframe3, text='输出图高:')
self.note1 = tk.Label(self.lframe3, text='建议输出\n128*128')
self.s1 = ScrolledText(self.lframe3,
height=6,
width=40,
state='disabled',
borderwidth=0)
self.color = tk.IntVar()
self.color.set(0)
self.rb1 = tk.Radiobutton(self.lframe3,
text='灰色',
variable=self.color,
value=0,
state='disabled')
self.rb2 = tk.Radiobutton(self.lframe3,
text='彩色',
variable=self.color,
value=1,
state='disabled')
self.cls = tk.Label(self.lframe3, text='输出图片颜色')
self.type = tk.Label(self.lframe3, text='输出图片格式')
self.type.place(x=75, y=5, anchor='w')
self.ty = tk.IntVar()
self.ty.set(0)
self.rb3 = tk.Radiobutton(self.lframe3,
text='jpg',
variable=self.ty,
value=0,
state='disabled')
self.rb4 = tk.Radiobutton(self.lframe3,
text='png',
variable=self.ty,
value=1,
state='disabled')
self.rb5 = tk.Radiobutton(self.lframe3,
text='jpeg',
variable=self.ty,
value=2,
state='disabled')
self.rb3.place(x=150, y=5, anchor='w')
self.rb4.place(x=200, y=5, anchor='w')
self.rb5.place(x=250, y=5, anchor='w')
self.a3.place(x=400, y=45, anchor='e')
self.a4.place(x=480, y=45, anchor='e')
self.frame2.grid(column=2, row=0, rowspan=3, columnspan=1)
self.lframe5.grid(column=0, row=0)
self.b4.place(x=80, y=15, anchor='center')
self.e3.place(x=280, y=15, anchor='e')
self.b5.place(x=400, y=15, anchor='e')
self.b6.place(x=480, y=15, anchor='e')
self.alb.place(x=550, y=15, anchor='e')
self.lframe4.grid(column=0, row=1)
self.ad.place(x=80, y=15, anchor='center')
self.e4.place(x=280, y=15, anchor='e')
self.a3.place(x=400, y=15, anchor='e')
self.a4.place(x=480, y=15, anchor='e')
self.lframe3.grid(column=0, row=2)
self.l3.place(x=15, y=15, anchor='w')
self.s1.place(x=15, y=70, anchor='w')
self.xv.place(x=330, y=30, anchor='w')
self.xl.place(x=390, y=30, anchor='w')
self.yv.place(x=330, y=60, anchor='w')
self.yl.place(x=390, y=60, anchor='w')
self.note1.place(x=420, y=45, anchor='w')
self.rb1.place(x=380, y=5, anchor='w')
self.rb2.place(x=440, y=5, anchor='w')
self.cls.place(x=305, y=5, anchor='w')
self.a2.place(x=480, y=90, anchor='e')
self.a5.place(x=400, y=90, anchor='e')
#打开readme.txt文件查看帮助
def help(self):
os.system('notepad.exe readme.txt')
#程序功能无法使用时刷新，重新启动该脚本
def refresh(self):
self.quit()
os.system('python root.py')
#运行程序，打开窗口
def run(self):
self.rt.mainloop()
#爬图前确认图片关键字是否存在
def start_cr(self):
word = self.e2.get()
if word != '':
st = askyesno(title='确认开始', message='确定开始下载图片?这会有一段时间的卡顿,中途不要退出页面')
if st:
self.start_in() #图片关键字存在，开始爬图
else:
self.s.config(state='normal')
self.s.delete(1.0, 'end')
self.s.insert('end', '请先输入图片关键字(如:周杰伦)')
self.s.config(state='disabled')
def close(self):
cl = askyesno(title='确认关闭', message='确定要关闭吗？')
if cl:
self.quit()
def quit(self):
self.rt.destroy()
def confirm_e(self):
path = self.e1.get()
if path == '':
self.ala.config(text='请先选择图片保存目录!')
elif os.path.exists(path) is False:
self.ala.config(text='该路径不存在!')
else:
self.ala.config(text='')
self.e1.config(state='disabled')
self.e2.config(state='normal')
self.b1.config(state='disabled')
self.b2.config(state='disabled')
self.b3.config(state='normal')
self.a1.config(state='normal')
def confirm_e1(self):
path = self.e3.get()
if path == '':
self.ala.config(text='请先选择图片目录!')
elif os.path.exists(path) is False:
self.ala.config(text='该路径不存在!')
else:
self.ala.config(text='')
self.b4.config(state='disabled')
self.b5.config(state='disabled')
self.e3.config(state='disabled')
self.e4.config(state='normal')
self.b6.config(state='normal')
self.ad.config(state='normal')
self.a3.config(state='normal')
def confirm_e2(self):
path = self.e4.get()
if path == '':
self.ala.config(text='请先选择图片保存目录!')
elif os.path.exists(path) is False:
self.ala.config(text='该路径不存在!')
else:
self.ala.config(text='')
self.b6.config(state='disabled')
self.ad.config(state='disabled')
self.e4.config(state='disabled')
self.a3.config(state='disabled')
self.a4.config(state='normal')
self.rb1.config(state='normal')
self.rb2.config(state='normal')
self.rb3.config(state='normal')
self.rb4.config(state='normal')
self.rb5.config(state='normal')
self.xl.config(state='normal')
self.yl.config(state='normal')
self.a2.config(state='normal')
self.a5.config(state='normal')
def deconfirm_e(self):
self.e1.config(state='normal')
self.e2.config(state='disabled')
self.b1.config(state='normal')
self.b2.config(state='normal')
self.b3.config(state='disabled')
self.a1.config(state='disabled')
self.a3.config(state='disabled')
self.s.config(state='disabled')
def deconfirm_e1(self):
self.b4.config(state='normal')
self.b5.config(state='normal')
self.e3.config(state='normal')
self.e4.config(state='disabled')
self.b6.config(state='disabled')
self.ad.config(state='disabled')
self.a3.config(state='disabled')
def deconfirm_e2(self):
self.b6.config(state='normal')
self.ad.config(state='normal')
self.e4.config(state='normal')
self.a3.config(state='normal')
self.a4.config(state='disabled')
self.b6.config(state='normal')
self.ad.config(state='normal')
self.e4.config(state='normal')
self.a3.config(state='normal')
self.a4.config(state='disabled')
self.rb1.config(state='disabled')
self.rb2.config(state='disabled')
self.rb3.config(state='disabled')
self.rb4.config(state='disabled')
self.rb5.config(state='disabled')
self.xl.config(state='disabled')
self.yl.config(state='disabled')
self.a2.config(state='disabled')
self.a5.config(state='disabled')
def reset(self):
self.xlen.set(128)
self.ylen.set(128)
self.color.set(0)
self.ty.set(0)
self.a2.config(state='normal')
#开始收集'存储地址'和'图片关键字'并开始爬图
def start_in(self):
word = self.e2.get()
self.a1.config(state='disabled')
self.e2.config(state='disabled')
self.s.config(state='normal')
self.b1.config(state='disabled')
self.b2.config(state='disabled')
self.b3.config(state='disabled')
path = self.e1.get()
self.s.delete(1.0, 'end')
ins = word.encode('utf-8')
self.s.insert('end', '正在百度搜索：' + ins)
self.get_images(word, path) #这是爬图的主程序
#格式错误反馈
def alarm(self):
self.ala.config(text='输入格式有误!')
#self.a.delete(0,'end')
#读取网页url
def readurl(self, url):
page = urllib.urlopen(url)
htm = page.read()
return htm
#下载网络图片
#imgurl：单张网络图片的url地址
#path：图片存储路径
#x：图片编号，同时也是图片名
#lastname：网络图片的后缀名
def downloadimg(self, imgurl, path, x, lastname):
error_time = 0
while True:
time.sleep(1)
try:
try:
urllib.urlretrieve(imgurl, path + '/%s' % x +
lastname) # 从地址上下载单张图片到指定存储位置上
#self.s.insert('insert', '\n第%s张图片下载成功' % x)
except socket.timeout: # 防止超时卡死，重新下载
self.s.insert('insert', '\nReloading...')
count = 1 # 卡死计数
while count <= 2: # 重新下载图片两次
try:
urllib.urlretrieve(imgurl,
path + '/%s' % x + lastname)
time.sleep(0.001)
self.s.insert('insert', '\n第%s张图片下载成功' % x)
break
except socket.timeout:
err_info = 'Reloading for %d time' % count if count == 1 else 'Reloading for %d times' % count
self.s.insert('insert', '\n' + err_info)
count = count + 1
if count > 2: # 卡死次数过多
# 删除错误文件
os.remove(path + '/%s' % x + lastname)
imgname = path + '/%s' % x + lastname
size = os.path.getsize(imgname) / float(1024) # 获取图片大小
# size单位为kb
if size < 20: # 删除小于20kb的图片
os.remove(path + '/%s' % x + lastname)
self.s.insert('insert', '\n第%s张图片大小太小,跳过' % x)
except:
error_time += 1
if error_time == 100:
print('your network is little bad')
time.sleep(60)
if error_time == 101:
print('your network is broken')
break
continue
break
#获取图片地址列表
#jpgre：jpg图片地址的正则表达式形式
#pngre和jpegre同上
#htm：网页源代码
def get_imglist(self, jpgre, pngre, jpegre, htm):
jpglist = re.findall(jpgre, htm) #在htm里寻找所有jpg图片的源代码，并做成一个列表
pnglist = re.findall(pngre, htm)
jpeglist = re.findall(jpegre, htm)
piclist = [jpglist, pnglist, jpeglist]
return piclist #piclist是一个三元列表，每一个元素也是一个列表
#获得文件夹目录
def get_directory1(self):
savepath = askdirectory()
self.e1.delete(0, 'end')
self.e1.insert('insert', savepath)
def get_directory5(self):
savepath = askdirectory()
self.e3.delete(0, 'end')
self.e3.insert('insert', savepath)
def get_directory4(self):
savepath = askdirectory()
self.e4.delete(0, 'end')
self.e4.insert('insert', savepath)
#爬取图片主程序
#word：图片关键字
#path：图片存储路径
def get_images(self, word, path):
var1 = word.encode('utf-8') #get()函数得到的字符串不是utf-8编码，需要转到utf-8
search = urllib.quote(var1) #用urllib的网页格式转码utf-8格式的图片关键字
pn = 0 # pn = 20*(页数+1)
err_num = 0 #错误计数，连续十个网址下载出现错误时就终止爬图
x = 1 #图片编号
jpg = 'objURL":"(.+?.jpg)",' #百度图片的URL地址的正则表达式
jpgre = re.compile(jpg) #编译正则表达式，用于寻找网页源代码里的图片地址
jpeg = 'objURL":"(.+?.jpeg)",'
jpegre = re.compile(jpeg)
png = 'objURL":"(.+?.png)",'
pngre = re.compile(png)
self.s.insert('insert', '\n--------开始爬图--------')
while True:
url = 'http://image.baidu.com/search/flip?tn=baiduimage&ie=utf-8&word=' + search + '&pn=' + str(
pn) + '&gsm=3c&ct=&ic=0&lm=-1&width=0&height=0'
try:
self.s.insert('insert', '\n正在读取源代码...')
htm = self.readurl(url) #从网页地址里读取网页源代码
piclist = self.get_imglist(jpgre, pngre, jpegre,
htm) #在网页文件里寻找编译后的URL地址，并返回一个列表
namelist = ['.jpg', '.png',
'.jpeg'] #后缀名列表，百度图片的后缀名一般只有三种：jpg,png,jpeg
n = 0
m = 0
self.s.insert('insert', '\n--------------')
self.s.insert('insert', '\n源代码读取完毕')
self.s.insert('insert', '\n--------------')
for list in piclist: #注意：piclist是一个三元列表，每一个元素也是一个列表
lastname = namelist[n]
n = n + 1
for imgurl in list: #list存储着许多图片的URL地址，每个imgurl是单张图片的url地址
dlth = threading.Thread(
target=self.downloadimg,
args=(
imgurl,
path,
x,
lastname,
)) #把下载单张图片交给子进程去完成，提供进程需要执行的目标函数和函数参数
dlth.setDaemon(True) #dlth这三行缺一不可
dlth.start() #开始执行进程
self.s.insert('insert', '\n第%s张图片下载成功' % x)
x = x + 1
#开始下载下一张图片
err_num = 0 #一张网页的下载顺利完成，错误代码归零
except:
self.s.insert('insert', '\n...结束本页内容下载 继续')
#跳过该页面下载下一页
pn = pn + 20 #pn = 20*(页数+1)
err_num = err_num + 1
if pn > 1960: #图片关键字只会存100页的图片，所以pn>1960时不可能查到图
self.s.insert('insert', '\n...图片全部下载完毕')
break
elif err_num > 10:
self.s.insert('insert', '\n...搜索不到更多图片，下载完毕')
break
elif x >= 1024:
self.s.insert('insert', '\n...图片下载已达到上限')
break
self.s.insert('insert', '\n--------加载下一页--------')
#以下为图片预处理部分
def start_pi(self):
st = askyesno(title='确认开始',
message='确定开始批处理图片?这会有一段时间的卡顿，但是可以去存储的文件夹拿到处理好的图')
if st:
reload(sys)
sys.setdefaultencoding('utf8')
self.start_pic()
def start_pic(self):
xLen = self.xl.get()
yLen = self.yl.get()
if xLen.isdigit() is True and yLen.isdigit() is True:
self.ala.config(text='')
self.a2.config(state='disabled')
self.s1.config(state='normal')
self.s1.insert('end', '\nxLen:' + str(xLen))
self.s1.insert('end', '\nyLen:' + str(yLen))
picpath = self.e3.get()
savepath = self.e4.get()
self.s1.insert('end', '\npicpath:' + picpath)
self.s1.insert('end', '\nsavepath:' + savepath)
pictypelist = ['LA', 'RGB']
pictype = pictypelist[self.color.get()]
self.s1.insert('end', '\npictype:' + pictype)
lastnamelist = ['.jpg', '.png', '.jpeg']
lastname = lastnamelist[self.ty.get()]
self.s1.insert('end', '\nlastname:' + lastname)
self.pre_main(picpath, savepath, pictype, xLen, yLen, lastname)
else:
self.ala.config(text='长宽输入格式有误!')
def getNameList(self, picpath):
if os.path.exists(picpath) is False:
self.ala.config(text='该路径不存在!')
else:
self.ala.config(text='')
files = os.listdir(picpath)
return files
def picdeal(self, name, picpath, savepath, pictype, xLen, yLen, lastname):
try:
names = name.split('.')[0]
img = Image.open(picpath + '/' + name).convert(pictype).resize(
(int(xLen), int(yLen)))
img.save(savepath + '/%s' % names + lastname)
except socket.timeout:
count = 1
while count <= 2:
try:
img.save(savepath + '/%s' % names + lastname)
self.s1.insert('end', '\n重新保存图片%s' % name + '1次')
except socket.timeout:
img.save(savepath + '/%s' % names + lastname)
self.s1.insert('end',
'\n重新保存图片%s' % name + '%d次' % (count + 1))
count = count + 1
if count >= 2:
os.remove(savepath + '/%s' % names + lastname)
except:
names = name.split('.')[0]
os.remove(savepath + '/%s' % names + lastname)
def pre_main(self, picpath, savepath, pictype, xLen, yLen, lastname):
nameList = self.getNameList(picpath)
self.s1.insert('end', '\n共有%d张图片需要处理' % len(nameList))
for name in nameList:
self.s1.insert('end', '\n正在处理图片:' + name)
prth = threading.Thread(target=self.picdeal,
args=(
name,
picpath,
savepath,
pictype,
xLen,
yLen,
lastname,
))
prth.setDaemon(True)
prth.start()
class MimeViewer:
def __init__(self, parent, title, msg):
self.title = title
self.msg = msg
self.frame = Frame(parent, {'relief': 'raised', 'bd': 2})
self.frame.packing = {'expand': 0, 'fill': 'both'}
self.button = Checkbutton(self.frame, {
'text': title,
'command': self.toggle
})
self.button.pack({'anchor': 'w'})
headertext = msg.getheadertext(
lambda x: x != 'received' and x[:5] != 'x400-')
height = countlines(headertext, 4)
if height:
self.htext = ScrolledText(
self.frame, {
'height': height,
'width': 80,
'wrap': 'none',
'relief': 'raised',
'bd': 2
})
self.htext.packing = {
'expand': 1,
'fill': 'both',
'after': self.button
}
self.htext.insert('end', headertext)
else:
self.htext = Frame(self.frame, {'relief': 'raised', 'bd': 2})
self.htext.packing = {
'side': 'top',
'ipady': 2,
'fill': 'x',
'after': self.button
}
body = msg.getbody()
if type(body) == StringType:
self.pad = None
height = countlines(body, 10)
if height:
self.btext = ScrolledText(
self.frame, {
'height': height,
'width': 80,
'wrap': 'none',
'relief': 'raised',
'bd': 2
})
self.btext.packing = {'expand': 1, 'fill': 'both'}
self.btext.insert('end', body)
else:
self.btext = None
self.parts = None
else:
self.pad = Frame(self.frame, {'relief': 'flat', 'bd': 2})
self.pad.packing = {
'side': 'left',
'ipadx': 10,
'fill': 'y',
'after': self.htext
}
self.parts = []
for i in range(len(body)):
p = MimeViewer(self.frame, '%s.%d' % (title, i + 1), body[i])
self.parts.append(p)
self.btext = None
self.collapsed = 1
def pack(self):
self.frame.pack(self.frame.packing)
def destroy(self):
self.frame.destroy()
def show(self):
if self.collapsed:
self.button.invoke()
def toggle(self):
if self.collapsed:
self.explode()
else:
self.collapse()
def collapse(self):
self.collapsed = 1
for comp in self.htext, self.btext, self.pad:
if comp:
comp.forget()
if self.parts:
for part in self.parts:
part.frame.forget()
self.frame.pack({'expand': 0})
def explode(self):
self.collapsed = 0
for comp in self.htext, self.btext, self.pad:
if comp: comp.pack(comp.packing)
if self.parts:
for part in self.parts:
part.pack()
self.frame.pack({'expand': 1})
class App(Frame):
def __init__(self, master = None):
Frame.__init__(self, master)
self.grid()
self.master.title("Kuehlaggregat")
self.stat = False
#Frame Kopfzeilen
FrameKopf = Frame(master)
FrameKopf.grid(row = 0, column = 0, rowspan = 2, columnspan = 10, pady = 2)
#Frame Links
FrameLinks = Frame(master)
FrameLinks.grid(row = 2, column = 0, rowspan = 5, columnspan = 2, pady = 10)
#Frame Rechts
FrameRechts = Frame(master)
FrameRechts.grid(row = 2, column = 2, rowspan = 5, columnspan = 8, pady = 2, sticky = W+N)
#Frame Unten
FrameUnten = Frame(master)
FrameUnten.grid(row = 8, column = 0, columnspan = 10, pady = 10, sticky = W, padx = 13)
# Widgets Serielle Schnittstelle
self.labelSer = Label(FrameKopf, text = "Serielle Schnittstelle")
self.buttonStart = Button(FrameKopf, text = "Start", fg = "green", height = 2, width = 6, command = self.startdata)
self.buttonStop = Button(FrameKopf, text = "Stop", fg = "red", height = 2, width = 6, command = self.stopdata)
#Widgets Steuerung Aggregat
self.labelAgg = Label(FrameKopf, text = "Steuerung Aggregat")
self.buttonKuehlen = Button(FrameKopf, text = "Kuehlen", height = 2, width = 6, command = self.cool)
self.buttonHeizen = Button(FrameKopf, text = "Heizen", height = 2, width = 6,command = self.hot)
self.buttonAus = Button(FrameKopf, text = "Aus", height = 2, width = 6, command = self.aus)
#Widgets Steuerung Temperatur
self.labelSTTemp = Label(FrameKopf, text = "Steuerung Temperatur")
self.scaleTemp = Scale(FrameKopf, from_=10, to=42, orient = HORIZONTAL)
self.buttonTemp = Button(FrameKopf, text = "Senden", height = 2, width = 6, command = self.senden)
#Widgets Programm
self.labelProg = Label(FrameKopf, text = "Programm")
self.labelStat = Label(FrameKopf, relief = SUNKEN, text = "Status:")
self.textStat = Text(FrameKopf, height = 1, width = 10)
self.buttonBeenden = Button(FrameKopf, text = "Beenden", fg = "red", height = 2, width = 6, command = master.quit)
#Widgets Aktuelle Temperatur
self.labelAktuelleTemp = Label(FrameLinks, text = "Aktuelle Temperatur")
self.labelRaum = Label(FrameLinks, relief = SUNKEN, height = 2, width = 12, text = "Raum:")
self.textRaum = Text(FrameLinks, height = 2, width = 4)
self.labelTank = Label(FrameLinks, relief = SUNKEN, height = 2, width = 12, text = "Tank:")
self.textTank = Text(FrameLinks, height = 2, width = 4)
self.labelPelIn = Label(FrameLinks, relief = SUNKEN, height = 2, width = 12, text = "Pelitier Innen:")
self.textPelIn = Text(FrameLinks, height = 2, width = 4)
self.labelPelAu = Label(FrameLinks, relief = SUNKEN, height = 2, width = 12, text = "Pelitier Aussen:")
self.textPelAu = Text(FrameLinks, height = 2, width = 4)
#Widgets Plotting
self.dataplot()
self.canvas = FigureCanvasTkAgg(plt.f,FrameRechts)
self.canvas.show()
#self.toolbar = NavigationToolbar2TkAgg(self.canvas, FrameRechts)
#self.toolbar.update()
#Widgets Konsole
self.labelKonsole = Label(FrameUnten, relief = SUNKEN, height = 2, width = 12, text = "Konsole:")
self.textKonsole = ScrolledText(FrameUnten, height = 3, width = 80)
#Setzen der einzelen Widgets
self.labelSer.grid(row = 0, column = 0, columnspan = 2, pady = 5, padx = 20)
self.labelAgg.grid(row = 0, column = 2, columnspan = 3, padx = 25)
self.labelSTTemp.grid(row = 0, column = 5, columnspan = 2, padx = 30)
self.labelProg.grid(row = 0, column = 7, columnspan = 3, padx = 20)
self.buttonStart.grid(row = 1, column = 0, sticky = E)
self.buttonStop.grid(row = 1, column = 1, sticky = W)
self.buttonKuehlen.grid(row = 1, column = 2, sticky = E)
self.buttonHeizen.grid(row = 1, column = 3)
self.buttonAus.grid(row = 1, column = 4, sticky = W)
self.scaleTemp.grid(row = 1, column = 5, sticky = E)
self.buttonTemp.grid(row = 1, column = 6, sticky = W)
self.labelStat.grid(row = 1, column = 7, sticky = E, padx = 5)
self.textStat.grid(row = 1, column = 8, sticky = W)
self.buttonBeenden.grid(row = 1, column = 9, padx = 5)
self.labelAktuelleTemp.grid(row = 0, column = 0, pady = 5)
self.labelRaum.grid(row = 1, column = 0)
self.labelTank.grid(row = 2, column = 0)
self.labelPelIn.grid(row = 3, column = 0)
self.labelPelAu.grid(row = 4, column = 0)
self.textRaum.grid(row = 1, column = 1)
self.textTank.grid(row = 2, column = 1)
self.textPelIn.grid(row = 3, column = 1)
self.textPelAu.grid(row = 4, column = 1)
self.canvas.get_tk_widget().grid(row = 0, column = 0, pady = 10, padx = 10)
#self.canvas._tkcanvas.grid(row = 0, column = 0)
self.labelKonsole.grid(row = 0, column = 0, sticky = W)
self.textKonsole.grid(row = 0, column = 1, padx = 13, sticky = S)
# Function: Starting Connection to Arduino and start Datalogging
def startdata(self):
self.textKonsole.delete('1.0', END)
self.textKonsole.insert(END, "Starting...\n")
self.textKonsole.insert(END, "Scanning for Ports: \n")
self.arduinoPort = self.findArduinoPort()
if not self.arduinoPort:
self.textKonsole.insert(END,"No Arduino found\n")
else:
self.textKonsole.insert(END,"Arduino found: ")
self.textKonsole.insert(END, self.arduinoPort)
self.textKonsole.insert(END, "\nTry connecting to arduino...\n")
self.serialArduino = serial.Serial(str(self.arduinoPort), 9600, timeout = 2)
self.stat = (str(self.serialArduino.isOpen()))
if not self.stat:
self.textKonsole.insert(END, "Connection failed!")
else:
self.textKonsole.insert(END, "Connection establish!\n")
self.textKonsole.insert(END, "Starting Datalogging..\n")
self.datalog()
return self.stat
def datalog(self):
self.datei = open('data.log','w+',0)
def dataplot(self):
plt.f = Figure(figsize=(15,8), dpi=100)
plt.f.subplots_adjust(hspace = .5)
plt.a = plt.f.add_subplot(211)
plt.a.plot()
plt.a.axis(ymin = 10, ymax = 40)
plt.a.set_title('Temperaturverlauf')
plt.a.set_ylabel('Temperatur')
plt.a.set_xlabel('Zeit')
plt.b = plt.f.add_subplot(212)
plt.b.plot()
plt.b.axis(ymin = -0.5, ymax = 1.5)
plt.b.set_title('Statusverlauf')
plt.b.set_ylabel('Status')
plt.b.set_xlabel('Zeit')
#plt.tight_layout(h_pad = 1)
def findArduinoPort(self):
self.ports = list(serial.tools.list_ports.comports())
for port in self.ports:
if "VID:PID=0403:6001" in port[0]\
or "VID:PID=0403:6001" in port[1]\
or "VID:PID=0403:6001" in port[2]:
return port[0]
def stopdata(self):
self.textKonsole.delete('1.0', END)
self.textKonsole.insert(END, "Stopping...\n")
if not self.stat:
self.textKonsole.insert(END, "Nothing to do\n")
else:
self.textKonsole.insert(END,"Closing Serial...\n")
self.serialArduino.close()
self.stat = False
self.textKonsole.insert(END,"Close Serial!\n")
def cool(self):
print ("Kuehlen")
def hot(self):
print ("Heizen")
def aus(self):
print ("Aggregat aus")
def senden(self):
print(self.scale.get())
root.grid_columnconfigure(0, weight=1, minsize=300)
Label(root, text='Drop text here:').grid(row=0, column=0, padx=10, pady=5)
buttonbox = Frame(root)
buttonbox.grid(row=2, column=0, columnspan=2, pady=5)
Button(buttonbox, text='Quit', command=root.quit).pack(side=LEFT, padx=5)
msg = 'Dropping onto compound widgets works only with the latest versions ' +\
'of tkdnd.\nIf you can drop text here, the installed version of ' +\
'tkdnd already supports this feature.\n'
lf = LabelFrame(root, text='"Megawidget" text box')
lf.grid(row=1, column=0, padx=5, pady=5, sticky='news')
text = ScrolledText(lf)
text.pack(fill='both', expand=1)
text.insert('end', msg)
# make the text box a drop target:
def drop_enter(event):
event.widget.focus_force()
print('Entering %s' % event.widget)
return event.action
def drop_position(event):
print('Position: x %d, y %d' % (event.x_root, event.y_root))
return event.action
class my_form(Frame):
"""Form"""
def __init__(self, master=None):
"""Elemente der Form kreieren"""
Frame.__init__(self, master)
self.pack()
#self.createWidgets()
self.text_label = Label(self,
height=1, width=80, anchor=NW, text="Play-Out-Logging Nr: ")
self.text_label.pack()
self.text_label_1 = Label(self,
height=1, width=80, text="Titel aktuell")
self.text_label_1.pack()
self.textBox = ScrolledText(self, height=5, width=80)
self.textBox.pack()
self.textBox.insert(END, "In the Beginning...\n")
self.text_label_2 = Label(self,
height=1, width=80, text="Rueckmeldung von Webserver")
self.text_label_2.pack()
self.textBox1 = ScrolledText(self, height=10, width=80)
self.textBox1.pack()
self.textBox1.insert(END, "...and the End\n")
# registering callback
self.listenID = self.after(500, self.lets_rock)
def display_logging(self, log_meldung_1, log_meldung_2):
"""display messages in form, loading periodically """
if log_meldung_1 is not None:
self.text_label.config(text="Play-Out-Logging Nr: "
+ str(ac.app_counter) + " / Interval von "
+ str(int(db.ac_config_1[2])) + " Sekunden")
self.textBox.delete('1.0', '3.end')
self.textBox.insert(END, log_meldung_1 + "\n")
if log_meldung_2 is not None:
self.text_label.config(text="Play-Out-Logging Nr: "
+ str(ac.app_counter) + " / Interval von "
+ str(int(db.ac_config_1[2])) + " Sekunden")
self.textBox1.delete('1.0', '8.end')
self.textBox1.insert(END, log_meldung_2 + "\n")
self.listenID = self.after(
int(db.ac_config_1[2]) * 1000, self.lets_rock)
return
def lets_rock(self):
"""man funktion"""
lib_cm.message_write_to_console(ac, u"lets rock")
ac.app_counter += 1
log_data = None
time_now = datetime.datetime.now()
time_back = datetime.datetime.now() + datetime.timedelta(hours=- 1)
c_time = time_back.strftime("%Y-%m-%d %H")
lib_cm.message_write_to_console(ac, c_time)
# time for reloading mpd
# skipping mpd-check
if time_now.hour == 4:
if time_now.minute == 40:
if time_now.second >= 5 and time_now.second <= 30:
log_meldung_1 = "Logging waehrend MPD-Neustart ausgesetzt"
db.write_log_to_db_a(ac, log_meldung_1,
"p", "write_also_to_console")
self.display_logging(log_meldung_1, "")
return
# 1. load sources
# 2. assign sources transmittime
source_id = check_source(self, c_time, time_now)
if source_id is None:
return
# 3. Pruefen ob Quelle Aussenuebertragung, VP oder Studios
# Bei Aussenuebertragung stehen keine Logfiles zur Verfuegung,
# Sendung muesste in db zu finden sein
if source_id == "05":
log_changed_ext = logging_source_ext(self, source_id, time_now)
if log_changed_ext is None:
return
if source_id == "01" or source_id == "02":
# Daten aus Logfiles holen bzw. aus db
lib_cm.message_write_to_console(ac, u"Sendung aus Studio")
log_changed = check_mairlist_log(self, source_id,
time_now, log_data)
if log_changed is None:
return
if source_id == "03":
# else source_id == "05":
# Daten aus Logfiles holen bzw. aus db
lib_cm.message_write_to_console(ac,
u"Sendung via Playout oder Internetstream")
# Daten aus mAirlist_Logdatei holen
# if mairlist
if db.ac_config_1[9] == "mairlist":
log_changed = check_mairlist_log(self, source_id,
time_now, log_data)
if log_changed is None:
return
if db.ac_config_1[9] == "mpd":
log_changed = check_mpd_log(self, time_now, log_data)
if log_changed is None:
return
if ac.log_author is None:
ac.log_start = (str(time_now.date()) + " "
+ str(time_now.time())[0:8])
ac.log_author = db.ac_config_1[3]
if ac.log_title is None:
ac.log_title = db.ac_config_1[4]
# Bezeichnung der Quelle holen
log_source_desc = db.read_tbl_row_with_cond(ac,
db, "SG_HF_SOURCE", "SG_HF_SOURCE_ID, SG_HF_SOURCE_DESC",
"SG_HF_SOURCE_ID ='" + source_id + "'")
if log_source_desc is None:
log_meldung_1 = ("Keine Bezeichnung Sendequelle gefunden,"
" nichts uebertragen..")
db.write_log_to_db_a(ac, log_meldung_1,
"p", "write_also_to_console")
self.display_logging(log_meldung_1, "")
return
# 5. Logging in db
db.write_log_to_db(ac,
log_source_desc[1].strip() + ": " + ac.log_author + " - "
+ ac.log_title, "a")
log_meldung_1 = (log_source_desc[1]
+ ": \n" + ac.log_author + " - " + ac.log_title)
# 6. Upload auf Webserver
web = upload_data_prepare()
if web is not None:
self.display_logging(log_meldung_1, web)
else:
ac.log_start = (str(time_now.date()) + " "
+ str(time_now.time())[0:8])
ac.log_author = db.ac_config_1[3]
ac.log_title = db.ac_config_1[4]
log_meldung_1 = ac.app_errorslist[4] + " \n"
self.display_logging(log_meldung_1, None)
return
class App:
def __init__(self, master):
self.tweetProcessorObject = TweetProcessor()
self.politicianObject = Politician()
# tweet processor frame
rowTweetProcessor = 0
tweetProcessorFrame = LabelFrame(master, text="Tweet Processor")
tweetProcessorFrame.grid(row=rowTweetProcessor, column=0)
## add tweet
lblAddTweet = Label(tweetProcessorFrame,
text="Add Tweet (json): ",
anchor='w',
justify='left')
self.txtAddTweet = Text(tweetProcessorFrame, height=10)
lblAddTweet.grid(row=0, column=0)
self.txtAddTweet.grid(row=1, column=0)
btnAddTweet = Button(tweetProcessorFrame,
text="Add",
command=self.addTweet)
btnAddTweet.grid(row=2, column=0)
btnExportGephi = Button(tweetProcessorFrame,
text="Export Gephi file (*.gexf)",
command=self.exportGephi)
btnExportGephi.grid(row=3, column=0)
# politician frame
rowPolitician = 1
politicianFrame = LabelFrame(master, text="Politician")
politicianFrame.grid(row=rowPolitician, column=0)
## add politician
lblAddPolitican = Label(politicianFrame,
text="Add Politician (dbpedia URI): ",
anchor='w',
justify='left')
self.entryAddPolitician = Entry(politicianFrame, width=40)
lblAddPolitican.grid(row=0, column=0)
self.entryAddPolitician.grid(row=0, column=1)
btnAddPolitician = Button(politicianFrame,
text="Add",
command=self.addPolitician)
btnAddPolitician.grid(row=0, column=2)
## list politicians
btnListPoliticians = Button(politicianFrame,
text="List",
command=self.listPoliticians)
btnListPoliticians.grid(row=1, column=0, columnspan=3)
# output frame
rowOutputFrame = 2
outputFrame = LabelFrame(master, text="Output")
outputFrame.grid(row=rowOutputFrame, column=0, sticky=W + E + N + S)
self.txtOutputFrame = ScrolledText(outputFrame, width=160)
self.txtOutputFrame.pack(fill=BOTH, expand=1)
self.txtOutputFrame.config(wrap=NONE)
def addTweet(self):
try:
output = self.tweetProcessorObject.process(
self.txtAddTweet.get(1.0, END))
if len(output) == 0:
out = "Match politician <-> tweet not found"
else:
out = ""
out += str(len(output)) + " sentiments added\n"
out += "-------- DETAILS ------------\n"
for [politician, sentiment] in output:
out += "Politician: " + politician[
"familyName"] + " " + politician["givenName"] + "\n"
out += sentiment.upper() + " sentiment\n"
out += "-------------------------------\n"
self.writeOutput(out)
except Exception as eDetail:
self.writeOutput(eDetail)
raise
def addPolitician(self):
try:
if self.politicianObject.add(self.entryAddPolitician.get()):
self.writeOutput("Politician added")
else:
self.writeOutput("Internal error")
except Exception as eDetail:
self.writeOutput(eDetail)
raise
def exportGephi(self):
e = Etl()
from tkFileDialog import asksaveasfilename
import tkMessageBox
filename = asksaveasfilename()
if e.exportGephi(filename):
tkMessageBox.showinfo("Info", "File salvato con successo.")
def listPoliticians(self):
out = ""
for politician in self.politicianObject.getRawList():
out += politician
self.writeOutput(out)
def writeOutput(self, text):
#self.txtOutputFrame.config(state=NORMAL)
self.txtOutputFrame.delete(1.0, END)
self.txtOutputFrame.insert(END, text)
class ScriptingWindow(Frame):
"""This is the object that creates and maintains the main GUI."""
def __init__(self, available_scripts, title='Knack Scripts', master=None):
self.avail_scripts = available_scripts
self.title = title
## This just builds the window
self.root = Tk()
Frame.__init__(self, master)
self.initWindow()
def initWindow(self):
self.master.title(self.title)
self.root.geometry("920x420")
self.createWidgets()
def createWidgets(self):
############################
# Setup some things first
############################
## These are strings we use to control other things.
## Note that these are tkinter string objects, so
## to retrieve the values, we have to use "var.get()"
self.status = StringVar()
self.input_filename = StringVar()
self.output_filename = StringVar()
self.helptext = StringVar()
## Default text for said strings
self.input_filename.set(os.getcwd() + '/data/all_actives-4-26-19.csv')
self.output_filename.set(os.getcwd() + '/results/out.csv')
## Keep track of which script is currently selected
self.processing_function = self.avail_scripts[0].processing_function
## Script selection drop down
self.scriptoptions = [script.name for script in self.avail_scripts]
self.selected_script = StringVar()
## This sets default option for the drop down
self.selected_script.set(self.scriptoptions[0])
## Folder Icon
self.foldericon = PhotoImage(file=os.getcwd() +
"/icons/magnifier_17.gif")
###################################################################
# Position everything in the master frame (the window itself)
###################################################################
## Base Layer (everything builds on this)
self.master.grid()
self.master.columnconfigure(0, weight=1)
self.master.rowconfigure(0, weight=1)
###########
# First frame separates the
# checkboxes from everything else.
#
# ------------------------
# | | |
# | other | checkboxes |
# | stuff | |
# | | |
# ------------------------
frame1 = Frame(self.master)
frame1.grid(sticky='nsew')
## This makes it so this frame
## stretches when you resize the main window
frame1.columnconfigure(0, weight=1)
frame1.rowconfigure(0, weight=1)
###########
# Second layer of frames form the
# base for the checkboxes and
# everything else, respectively.
#
# --------------------------------
# | | |
# | ------------ | ------------- |
# | | primary | | | checkbox | |
# | | frame | | | frame | |
# | ------------ | ------------- |
# | | |
# --------------------------------
frame_primary = Frame(frame1)
frame_checkboxes = LabelFrame(frame1, text="Data to Export")
frame_primary.grid(row=0, column=0, sticky='nsew')
frame_checkboxes.grid(row=0, column=1, sticky='nsew')
## Stretch the column with all the text boxes
frame_primary.columnconfigure(1, weight=1)
## Stretch the row with the script description
frame_primary.rowconfigure(3, weight=1)
###########
# Build primary frame
#
# --------------------------------
# | | |
# | ------------ | ------------- |
# | | 1st row | | | | |
# | ------------ | | | |
# | | 2nd row | | | | |
# | ------------ | | | |
# | | . | | | | |
# | | . | | | | |
# | | . | | | | |
# | ------------ | ------------- |
# | | |
# --------------------------------
## 1st row
lbl_script = Label(frame_primary, text="Script:")
lbl_script.grid(row=0, column=0, sticky='w')
self.scriptmenu = OptionMenu(frame_primary,
self.selected_script,
*self.scriptoptions,
command=self._update_script)
self.scriptmenu.grid(row=0, column=1, sticky="we")
## 2nd row
lbl_input = Label(frame_primary, text="Input File:")
lbl_input.grid(row=1, column=0, sticky='w')
self.input_entry = Entry(frame_primary,
textvariable=self.input_filename)
self.input_entry.grid(row=1, column=1, sticky="we")
inbutton = Button(frame_primary,
command=lambda: self._getfilename_input())
inbutton.config(image=self.foldericon, width="17", height="17")
inbutton.grid(row=1, column=2)
## 3rd row
lbl_output = Label(frame_primary, text="Output File:")
lbl_output.grid(row=2, column=0, sticky='w')
self.output_entry = Entry(frame_primary,
textvariable=self.output_filename)
self.output_entry.grid(row=2, column=1, sticky="we")
outbutton = Button(frame_primary,
command=lambda: self._getfilename_output())
outbutton.config(image=self.foldericon, width="17", height="17")
outbutton.grid(row=2, column=2)
## 4th row
helptext_frame = LabelFrame(frame_primary,
text="Description of Selected Script")
helptext_frame.grid(row=3, column=1, sticky='nsew')
helptext_frame.columnconfigure(0, weight=1)
helptext_frame.rowconfigure(0, weight=1)
self.helptext_lbl = ScrolledText(helptext_frame, wrap=WORD)
self.helptext_lbl.insert(INSERT, self.avail_scripts[0].description)
self.helptext_lbl.config(state=DISABLED)
self.helptext_lbl.grid(sticky="nsew", padx=5, pady=5)
## 5th row
self.statusprompt = Label(frame_primary, textvariable=self.status)
self.statusprompt.grid(row=4, column=0, columnspan=3)
## 6th row
self.procbutton = Button(frame_primary,
text="Process File!",
command=self.run_script)
self.procbutton.grid(row=5, column=0, columnspan=3, pady=10)
###########
# Build checkbox frame
#
# ---------------------------------
# | | |
# | ------------ | -------------- |
# | | | | | | |
# | | | | | checkboxes | |
# | | | | | | |
# | | | | -------------- |
# | | | | | text | |
# | | | | -------------- |
# | | | | | user input | |
# | ------------ | -------------- |
# | | |
# ---------------------------------
## Each element: [header_text, is_checked_by_default]
common_data = [['Individual', True], ['Name: First', False],
['Name: Last', False], ['Department', True],
['Secondary Department', False],
['Employer Unique Name', False],
['Employment Status', False], ['Member Status', True],
['Preferred Email', True], ['Secondary Email', True],
['Assessment', True], ['Last Assessment Date', True],
['Hire Date', False], ['FTE', False]]
checkboxes = []
self.checkbox_strings = []
self.checkbox_values = []
for idx, export_elt in enumerate(common_data):
## Set default checkbox state
this_value = IntVar()
if export_elt[1]:
this_value.set(1)
else:
this_value.set(0)
## Build current checkbox
this_box = Checkbutton(frame_checkboxes,
text=export_elt[0],
variable=this_value)
this_box.grid(row=idx, column=0, sticky='w')
## Save some parameters to change later
self.checkbox_strings += [export_elt[0]]
self.checkbox_values += [this_value]
checkboxes += [this_box]
lblstr = 'Custom Entry:\n(comma separated, e.g. "Building,Office #")'
user_header_lbl = Label(frame_checkboxes, text=lblstr)
user_header_lbl.grid()
self.user_header_text = StringVar()
user_header = Entry(frame_checkboxes,
textvariable=self.user_header_text)
user_header.grid(sticky='we')
def _getfilename_input(self):
"""
Internal function.
This gets called when the input file search button is pressed.
"""
self.input_filename.set(tkFileDialog.askopenfilename())
def _getfilename_output(self):
"""
Internal function.
This gets called when the output file search button is pressed.
"""
self.output_filename.set(tkFileDialog.askopenfilename())
def _update_script(self, new_script_name):
"""
Internal function.
This gets called whenever a different script gets selected
(in the drop-down menu)
"""
## Figure out which script got selected
script_names = [script.name for script in self.avail_scripts]
for idx, name in enumerate(script_names):
if name == new_script_name:
new_index = idx
## Update everything with the new script's information
self.processing_function = self.avail_scripts[new_index].\
processing_function
## Need to update the textbox explicitly, since it doesn't
## support linking to a StringVar
self.helptext_lbl.config(state=NORMAL)
self.helptext_lbl.delete(1.0, END)
self.helptext_lbl.insert(INSERT,
self.avail_scripts[new_index].description)
self.helptext_lbl.config(state=DISABLED)
def setstatus(self, status):
self.status.set(status)
def getfilename_output(self):
"""Returns the contents of the outut file dialog box"""
return self.output_filename.get()
def getfilename_input(self):
"""Returns the contents of the input file dialog box"""
return self.input_filename.get()
def get_processing_function(self):
"""Returns the selected script's processing function"""
return self.processing_function
def get_export_header(self):
"""Returns a list of all headers that are selected with checkboxes"""
## Get headers from checkboxes
export_header = []
checkbox_values = [check.get() for check in self.checkbox_values]
for idx, checkbox_value in enumerate(checkbox_values):
if checkbox_value == 1:
export_header += [self.checkbox_strings[idx]]
## Get user-added headers
user_str = self.user_header_text.get()
if user_str:
export_header += user_str.split(',')
return export_header
def run_script(self):
"""This is the top-level processing function.
It is called when the "Process File" button is pressed
and does the following:
1) import data from csv
2) run selected processing script on data
3) export results to csv
"""
self.status.set("Processing ...")
try:
# Read in file
data = importcsv(self.getfilename_input())
# Run processing function on data
processing_fn = self.get_processing_function()
processed_data = processing_fn(data)
# Write processed data
writecsv_byid(processed_data, self.get_export_header(),
self.getfilename_output())
except:
self.setstatus("Processing Error :-( (see command prompt)")
raise
self.setstatus("Done!")
class gui:
def __init__(self):
self.master = Tk()
self.master.geometry("800x600+100+10")
self.master.title("WIReS - Web Information Retrieval System")
self.master.configure(background='white')
self.master.resizable(width=FALSE, height=FALSE)
########################################################################################################
def guimain(self):
global query
query = StringVar(None)
def devs():
tkMessageBox.showinfo("DEVELOPERS", '''BS COMPUTER SCIENCE 302
CAVITE STATE UNIVERSITY - ROSARIO CAMPUS
Lamberto A. Bruno. Jr.
Jomari R. Iringan
''')
def help():
tkMessageBox.showinfo("HELP", '''CONTACT US:
Bruno ( 0905-511-9881 )
Joms ( 0906-870-2976 )
EMAIL US:
[email protected]
''')
def priv():
tkMessageBox.showinfo("PRIVACY", '''For privacy terms and policies please see
https://www.google.com/policies/privacy/
''')
def clearBtn():
self.searchEntry.delete(0,END)
self.searchEntry.focus_set()
return
self.label1 = Label(self.master, text="WIReS", font=('Impact',70),bg='white')
self.label2 = Label(self.master, text=" SEARCH ENGINE", bg ='#008080', fg='white', font=('arial',7))
self.lineLabel = Label(self.master,text="____________________________",fg='red',bg='red', font =('arial',7))
self.helpBtn = Button(self.master, text="HELP", font=('Courier',10),command = help)
self.privBtn = Button(self.master, text="PRIVACY", font=('Courier',10),command = priv)
self.devsBtn = Button(self.master, text="DEVS", font=('Courier',10),command = devs)
self.searchEntry = Entry(self.master, width='50', relief='groove', borderwidth='5', font=('Calibri',15), textvariable=query)
self.searchButton = Button(self.master, text="SEARCH!", width='30')
self.clearButton = Button(self.master, text="CLEAR FIELD", command = clearBtn)
#locs
self.label1.place(x=300,y=150)
self.label2.place(x=455,y=250)
self.lineLabel.place(x=310,y=250)
self.searchEntry.place(x=180,y=320)
self.searchButton.place(x=400,y=400)
self.clearButton.place(x=250, y=400)
self.devsBtn.place(x=690,y=570)
self.helpBtn.place(x=738,y=570)
self.privBtn.place(x=618, y=570)
self.searchEntry.focus_set()
self.searchButton.bind("<Button-1>",self.searchBtn)
self.searchEntry.bind("<Return>", self.searchBtn)
def searchBtn(self, event):
try:
global xTime
global query
xTime = StringVar()
query = StringVar(None)
search_ = Search()
query = self.searchEntry.get()
if query not in (None, '', ' '):
start_time = time.time()
global title_url
title_url = [None]
raw = search_.fetch_url(query)
title_url = search_.process_url(raw)
self.master.withdraw()
xTime = (time.time() - start_time)
self.guiresults()
else:
tkMessageBox.showinfo('Info', 'You must put a keyword')
except Exception as e:
tkMessageBox.showinfo('Info', 'No Internet Connection Try Again Later')
exit()
####################
def guiresults(self):
global q_String
q_String = StringVar()
graph = Graph()
html_parse = htmlParser()
def showGraph():
raws = StringVar()
raws = self.result_label.get(1.0, END)
graph.plot_word(raws)
def showPos():
raws = StringVar()
raws = self.result_label.get(1.0, END)
graph.plot_pos(raws)
def clearBtn1():
self.searchEntry1.delete(0,END)
self.searchEntry1.focus_set()
return
start_time = time.time()
self.masters = Tk()
self.masters.geometry("1100x700+100+10")
self.masters.title("WIReS - Web Information Retrieval System")
self.masters.configure(background='white')
self.masters.resizable(width=FALSE, height=FALSE)
self.searchEntry1 = Entry(self.masters, width='50', relief='groove', borderwidth='5', font=('Calibri',15))
self.searchButton = Button(self.masters, text="SEARCH!", width='25')
self.clearButton1 = Button(self.masters, text="CLEAR FIELD", width='25',command = clearBtn1)
self.labelss = Label(self.masters, text="SEARCH RESULTS:", bg ='#008080', fg='white', font=('arial',10))
self.timeLabel = Label(self.masters, text="SEARCH COMPLETED AT ", font=('arial',8))
self.resultframe = LabelFrame(self.masters,text="PAGE RESULT",height=520, width=990,relief = "groove", bg ="white")
self.resultframe1 = LabelFrame(self.masters,height=540, width=990,relief = "groove", bg ="white")
self.result_label = ScrolledText(self.resultframe,width = 120, height = 32,bg = 'white', undo = True)
self.graphButton = Button(self.masters, text="WORD OCCURENCE(GRAPH)", width='25',command = showGraph)
self.posButton = Button(self.masters, text="PART OF SPEECH(GRAPH)", width='25', command = showPos)
#URL
self.labelres1 = Label(self.resultframe1, text = title_url[0][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres1= Label(self.resultframe1, text = title_url[0][1], fg="blue", cursor="hand2", bg="white")
self.labelres2 = Label(self.resultframe1, text = title_url[1][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres2 = Label(self.resultframe1, text = title_url[1][1], fg="blue", cursor="hand2", bg="white")
self.labelres3 = Label(self.resultframe1, text = title_url[2][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres3 = Label(self.resultframe1, text = title_url[2][1], fg="blue", cursor="hand2", bg="white")
self.labelres4 = Label(self.resultframe1, text = title_url[3][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres4 = Label(self.resultframe1, text = title_url[3][1], fg="blue", cursor="hand2", bg="white")
self.labelres5 = Label(self.resultframe1, text = title_url[4][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres5 = Label(self.resultframe1, text = title_url[4][1], fg="blue", cursor="hand2", bg="white")
self.labelres6 = Label(self.resultframe1, text = title_url[5][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres6 = Label(self.resultframe1, text = title_url[5][1], fg="blue", cursor="hand2", bg="white")
self.labelres7 = Label(self.resultframe1, text = title_url[6][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres7 = Label(self.resultframe1, text = title_url[6][1], fg="blue", cursor="hand2", bg="white")
self.labelres8 = Label(self.resultframe1, text = title_url[7][0], font=('arial 13 bold'), bg="white", cursor="hand2")
self.linkres8 = Label(self.resultframe1, text = title_url[7][1], fg="blue", cursor="hand2", bg="white")
#gui2 loc
self.resultframe1.place(x=15,y=80)
self.searchEntry1.place(x=15,y=15)
self.searchButton.place(x=550,y=18)
self.labelss.place(x=15,y=60)
self.timeLabel.place(x=15,y=630)
self.labelres1.place(x=1,y=30)
self.linkres1.place(x=5,y=60)
self.labelres2.place(x=1,y=90)
self.linkres2.place(x=5,y=120)
self.labelres3.place(x=1,y=150)
self.linkres3.place(x=5,y=180)
self.labelres4.place(x=1,y=210)
self.linkres4.place(x=5,y=240)
self.labelres5.place(x=1,y=270)
self.linkres5.place(x=5,y=300)
self.labelres6.place(x=1,y=330)
self.linkres6.place(x=5,y=360)
self.labelres7.place(x=1,y=390)
self.linkres7.place(x=5,y=420)
self.labelres8.place(x=1,y=450)
self.linkres8.place(x=5,y=480)
self.clearButton1.place(x=800,y=18)
self.searchEntry1.insert(END,query)
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (xTime), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
def graphloc():
self.graphButton.place(x = 550, y=50)
self.posButton.place(x = 800, y=50)
#eventfunc
def callback1(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[0][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback2(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[1][1]))
self.resultframe1.destroy()
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback3(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[2][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback4(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[3][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback5(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[4][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback6(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[5][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback7(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[6][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def callback8(event):
start_time = time.time()
raw = html_parse.clean_html(html_parse.url_opener(title_url[7][1]))
self.resultframe1.destroy()
self.resultframe.place(x=15,y=80)
self.result_label.place(x = 1, y = 1)
self.result_label.insert(END,raw)
self.result_label.configure(state = 'disabled')
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (time.time() - start_time), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
graphloc()
def searchAction(event):
try:
global query
global mTime
mTime = StringVar(None)
query = StringVar(None)
search_ = Search()
query = self.searchEntry1.get()
if query not in (None, '', ' '):
start_time = time.time()
global title_url
title_url = [None]
raw = search_.fetch_url(query)
title_url = search_.process_url(raw)
self.masters.withdraw()
mTime = (time.time() - start_time)
self.guiresults()
self.timeLabelres = Label(self.masters, text="--- %s seconds ---" % (mTime), font=('arial',8))
self.timeLabelres.place(x=150,y=630)
else:
tkMessageBox.showinfo('Info', 'You must put a keyword')
except Exception as e:
tkMessageBox.showinfo('Info', 'No Internet Connection Try Again Later')
exit()
#eventlink
self.searchButton.bind("<Button-1>",searchAction)
self.searchEntry1.bind("<Return>",searchAction)
self.linkres1.bind("<Button-1>", callback1)
self.linkres2.bind("<Button-1>", callback2)
self.linkres3.bind("<Button-1>", callback3)
self.linkres4.bind("<Button-1>", callback4)
self.linkres5.bind("<Button-1>", callback5)
self.linkres6.bind("<Button-1>", callback6)
self.linkres7.bind("<Button-1>", callback7)
self.linkres8.bind("<Button-1>", callback8)
self.labelres1.bind("<Button-1>", callback1)
self.labelres2.bind("<Button-1>", callback2)
self.labelres3.bind("<Button-1>", callback3)
self.labelres4.bind("<Button-1>", callback4)
self.labelres5.bind("<Button-1>", callback5)
self.labelres6.bind("<Button-1>", callback6)
self.labelres7.bind("<Button-1>", callback7)
self.labelres8.bind("<Button-1>", callback8)
self.searchEntry1.insert(END,'')
class Application:
def __init__(self, parent):
self.parent = parent
self.frames()
self.f_saved = True #Sampled data saved
root.protocol("WM_DELETE_WINDOW", self.on_closing)
def on_closing(self):
if (self.f_saved == False):
if tkMessageBox.askokcancel(
"Quit", "Sampled data not saved. Do you wanto to quit?"):
root.destroy()
else:
root.destroy()
def frames(self):
frame1 = Tk.Frame(root, bd=5, relief='raised', borderwidth=1)
frame2 = Tk.Frame(root, bd=5, relief='raised')
note = ttk.Notebook(frame2)
self.tab1 = ttk.Frame(note)
self.tab2 = ttk.Frame(note)
note.add(self.tab1, text="Frquency")
note.add(self.tab2, text="Time")
# Positioning
frame1.pack(side='left', fill='both', padx=5, pady=5)
frame2.pack(side='right', fill='both', expand='true')
boton_open = Tk.Button(frame1,
text="Open file",
command=self.open_file)
boton_save = Tk.Button(frame1,
text="Save to file",
command=self.save_file)
boton_scan = Tk.Button(frame1,
text="Scan serial ports",
command=self.scan_ports)
boton_read = Tk.Button(frame1,
text="Read serial data",
command=self.read_serial)
label1 = Tk.Label(frame1, text="Select Serial Port:")
self.sel_puerto = ttk.Combobox(frame1,
textvariable='',
state="readonly")
portnames = scan_serial()
self.sel_puerto['values'] = portnames
if (portnames != []):
self.sel_puerto.current(0)
self.text_message = ScrolledText(frame1, height=10, width=20)
self.window_var = Tk.IntVar()
self.window_var.set(1) #Option rectangular window
radio_button1 = Tk.Radiobutton(frame1,
text="Rectangular Window",
variable=self.window_var,
value=1,
command=self.win_sel)
radio_button2 = Tk.Radiobutton(frame1,
text="Hann Window",
variable=self.window_var,
value=2,
command=self.win_sel)
radio_button3 = Tk.Radiobutton(frame1,
text="Flattop Window",
variable=self.window_var,
value=3,
command=self.win_sel)
# Grid
boton_open.grid(row=1, column=0, padx=5, pady=5)
boton_save.grid(row=2, column=0, padx=5, pady=5)
boton_scan.grid(row=3, column=0, padx=5, pady=5)
label1.grid(row=4, column=0, padx=5, pady=5)
self.sel_puerto.grid(row=5, column=0, padx=5, pady=5)
boton_read.grid(row=6, column=0, padx=5, pady=5)
self.text_message.grid(row=7, column=0, padx=5, pady=5)
radio_button1.grid(row=8, column=0, sticky="W")
radio_button2.grid(row=9, column=0, sticky="W")
radio_button3.grid(row=10, column=0, sticky="W")
#note.grid(row = 0, column=0)
note.pack(side='top', fill='both', padx=5, pady=5)
#Figure 1
fig1 = Figure(figsize=(10, 7))
fig1.suptitle('Sampled signal - Acceleration')
ax_11 = fig1.add_subplot(2, 1, 1)
ax_11.hold(False)
ax_11.set_title("Channel X")
ax_11.set_ylabel('g')
ax_11.grid() #Shows grid.
ax_12 = fig1.add_subplot(2, 1, 2)
ax_12.hold(False)
ax_12.set_title("Channel Y")
ax_12.set_xlabel('ms')
ax_12.set_ylabel('g')
ax_12.grid() #Shows grid.
#Figure 2
fig2 = Figure(figsize=(10, 7))
fig2.suptitle('FFT spectrum')
ax_21 = fig2.add_subplot(2, 1, 1)
ax_21.hold(False)
ax_21.set_title("Channel X")
ax_21.set_ylabel('g')
ax_21.set_xlim(xmax=max_freq)
ax_21.grid()
ax_22 = fig2.add_subplot(2, 1, 2)
ax_22.hold(False)
ax_22.set_title("Channel Y")
ax_22.set_xlabel('Hz')
ax_22.set_xlim(xmax=max_freq)
ax_22.set_ylabel('g')
ax_22.grid()
# Canvas
self.canvas2 = FigureCanvasTkAgg(fig1, master=self.tab2)
self.canvas2.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.toolbar2 = NavigationToolbar2TkAgg(self.canvas2, self.tab2)
self.toolbar2.update()
self.canvas2._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.canvas1 = FigureCanvasTkAgg(fig2, master=self.tab1)
self.canvas1.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.toolbar1 = NavigationToolbar2TkAgg(self.canvas1, self.tab1)
self.toolbar1.update()
self.canvas1._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
def read_serial(self):
puerto = self.sel_puerto.get()
print(puerto)
message_string = "Port: {0} \n".format(puerto)
self.show_message(self.text_message, message_string)
estado_serial = False
try:
serial_avr = serial.Serial(port=puerto,
baudrate=500000,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=0)
time.sleep(2) # waiting the initialization...
print("Initializing")
message_string = "Initializing... \n"
self.show_message(self.text_message, message_string)
if (serial_avr.isOpen() == True):
estado_serial = True
else:
estado_serial = False
except (serial.SerialException, ValueError) as ex:
#print "Can´t open serial port: " + str(ex)
tkMessageBox.showerror("Result",
"Can't open serial port: " + str(ex))
if (estado_serial == True):
global g_canal_1, g_canal_2, datos_a_leer
canal_1 = []
canal_2 = []
buffer = ''
paquete = ''
valores = []
serial_avr.flushInput()
serial_avr.flushOutput()
valores_decod = []
conta_datos_rx = 0
#Received samples counter.
print("Sending INI")
message_string = "Sending INI \n"
self.show_message(self.text_message, message_string)
serial_avr.write('INI') #Start data sampling command.
#serial_avr.write(chr(0x22)) #CRC 'INI'. Not used.
serial_avr.write(chr(0x7E)) #End of packet.
while conta_datos_rx < datos_a_leer:
if serial_avr.inWaiting():
lectura = serial_avr.read(serial_avr.inWaiting())
buffer = buffer + lectura
valores = []
if len(buffer) > 10:
i = buffer.find(chr(0x7E))
if i >= 0:
paquete = buffer[:i]
buffer = buffer[i + 1:]
#print("Paquete: %s" % (paquete))
valores = [ord(i) for i in paquete]
paquete = ''
x = 0
while x < len(valores):
if valores[x] == 0x7D:
valores_decod.append(valores[x + 1] ^ 0x20)
x = x + 1
else:
valores_decod.append(valores[x])
x = x + 1
canal1 = (valores_decod[0] * 256) + valores_decod[1]
canal2 = (valores_decod[2] * 256) + valores_decod[3]
canal_1.append(canal1)
canal_2.append(canal2)
#print("Canal 1: %s Canal2: %s " % (canal1, canal2))
valores = []
valores_decod = []
conta_datos_rx += 1
#print("conta_datos_rx = %s" %conta_datos_rx)
#time.sleep(0.001) #Sin esta línea, el programa consume 90% de recursos CPU
#Cuando la velocidad del puerto serial es alta y se recibe una gran cantidad
#de datos, time.sleep() impone un tiempo demasiado largo.
print("Sending PAR")
self.text_message.config(state=Tk.NORMAL) #Enable to modify
self.text_message.insert(Tk.END, "Sending PAR \n")
self.text_message.config(state=Tk.DISABLED) #Disable - Read only
root.update_idletasks() #Needed to make message visible
serial_avr.write('PAR') #Stop data sampling.
serial_avr.write(chr(0x7E)) #End of packet.
serial_avr.close() #Close serial port.
print("Amount of samples channel 1: %s" % len(canal_1))
print("Amount of samples channel 2: %s" % len(canal_2))
message_string = "Amount of samples channel 1: {0} \n".format(
len(canal_1))
message_string += "Amount of samples channel 2: {0} \n".format(
len(canal_2))
self.show_message(self.text_message, message_string)
#Keep a copy of the original values
g_canal_1 = canal_1[:] #Copy list by value not by reference
g_canal_2 = canal_2[:]
self.f_saved = False #Sampled data not saved
self.window_var.set(1) #Option rectangular window
self.plot(self.tab1, self.tab2, canal_1, canal_2, win_var=1)
def show_message(self, text_message, message_string):
"""Shows messages on a scrollable textbox"""
text_message.config(state=Tk.NORMAL) #Enable to modify
text_message.insert(Tk.END, message_string)
text_message.config(state=Tk.DISABLED) #Disable - Read only
text_message.see("end") #Show the "end" of text
root.update_idletasks() #Needed to make message visible
def scan_ports(self):
portnames = []
portnames = scan_serial()
self.sel_puerto['values'] = portnames
if (portnames != []):
self.sel_puerto.current(0)
def plot(self, tab1, tab2, canal_1, canal_2, win_var=1):
num_datos = len(canal_1)
X = range(0, num_datos, 1)
# Scale the signal in g's
for indice in X:
canal_1[indice] *= g_scale
canal_2[indice] *= g_scale
# Calculates medium value for each channel.
vdc_canal_1 = 0
vdc_canal_2 = 0
for indice in X:
vdc_canal_1 += canal_1[indice]
vdc_canal_2 += canal_2[indice]
vdc_canal_1 = vdc_canal_1 / num_datos
vdc_canal_2 = vdc_canal_2 / num_datos
#print("Vdc Channel 1: {0}, Vdc Channel 2: {1}".format(vdc_canal_1, vdc_canal_2))
# Substract DC offset
for indice in X:
canal_1[indice] -= vdc_canal_1
canal_2[indice] -= vdc_canal_2
#----------------- Plotting ----------
X1 = np.linspace(0, num_datos / 5,
num=num_datos) # X axis, 5000 sps, 1/5 ms.
# Figure 1. Sampled signals.
#Channel X
ax_11, ax_12 = self.canvas2.figure.get_axes()
ax_11.clear()
ax_11.plot(X1, canal_1)
ax_11.set_title("Channel X")
ax_11.set_ylabel('g')
ax_11.grid() #Shows grid.
#Channel Y
ax_12.clear()
ax_12.plot(X1, canal_2)
ax_12.set_title("Channel Y")
ax_12.set_xlabel('ms')
ax_12.set_ylabel('g')
ax_12.grid() #Shows grid.
# Figure 2. FFT from signals.
#Channel X
canal_fft = []
canal_fft = canal_1
N = len(canal_fft) # length of the signal
#Window function
if (win_var == 2):
w = signal.hann(N, sym=False) #Hann (Hanning) window
elif (win_var == 3):
w = signal.flattop(N, sym=False) #Flattop window
else:
w = 1 #Rectangular window
T = 1.0 / sample_rate
y = canal_fft
yf = fftpack.fft(y * w)
xf = np.linspace(0.0, 1.0 / (2.0 * T), N / 2)
ax_21, ax_22 = self.canvas1.figure.get_axes()
ax_21.clear()
ax_21.plot(xf, 2.0 / N * np.abs(yf[:N / 2]))
ax_21.grid()
ax_21.set_title("Channel X")
ax_21.set_ylabel('g')
ax_21.set_xlim(xmax=max_freq)
#Channel Y
canal_fft = []
canal_fft = canal_2
N = len(canal_fft) # length of the signal
T = 1.0 / sample_rate
y = canal_fft
yf = fftpack.fft(y * w)
xf = np.linspace(0.0, 1.0 / (2.0 * T), N / 2)
ax_22.clear()
ax_22.plot(xf, 2.0 / N * np.abs(yf[:N / 2]))
ax_22.grid()
ax_22.set_title("Channel Y")
ax_22.set_xlabel('Hz')
ax_22.set_xlim(xmax=max_freq)
ax_22.set_ylabel('g')
self.canvas1.draw()
self.canvas2.draw()
def win_sel(self):
"""Window selection. Every time a window is selected,
the FFT spectrum is calculated, applying the selected window function"""
global g_canal_1, g_canal_2
canal_1 = g_canal_1[:] #Copy list by value not by reference
canal_2 = g_canal_2[:]
win_var = self.window_var.get()
if (len(canal_1) != 0): #Apply only if data available
self.plot(self.tab1, self.tab2, canal_1, canal_2, win_var)
def open_file(self):
"""Opens dialog to select a file, reads data from file and plots the data"""
ftypes = [('Text files', '*.txt'), ('All files', '*')]
dlg = tkFileDialog.Open(root, filetypes=ftypes)
fl = dlg.show()
if fl != '':
# Open file for reading
arch = open(fl, "r")
datos_arch = arch.read()
# Searches for every channel, delimited by L1 and L2 tags.
canal_1 = extraer_int_tag(datos_arch, 'L1')
canal_2 = extraer_int_tag(datos_arch, 'L2')
print("Amount of samples in channel 1: %s" % len(canal_1))
print("Amount of samples on channel 2: %s" % len(canal_2))
message_string = "Amount of samples channel 1: {0} \n".format(
len(canal_1))
message_string += "Amount of samples channel 2: {0} \n".format(
len(canal_2))
self.show_message(self.text_message, message_string)
global g_canal_1, g_canal_2
#Keep a copy of the original values
g_canal_1 = canal_1[:] #Copy list by value not by reference
g_canal_2 = canal_2[:]
self.window_var.set(1) #Option rectangular window
self.plot(self.tab1, self.tab2, canal_1, canal_2, win_var=1)
def save_file(self):
ftypes = [('Text files', '*.txt'), ('All files', '*')]
dlg = tkFileDialog.SaveAs(root, filetypes=ftypes)
fl = dlg.show()
if fl != '':
global g_canal_1, g_canal_2
if (len(g_canal_1) > 0):
grabar(g_canal_1, g_canal_2, fl)
self.f_saved = True #Sampled data saved
else:
print("No samled data to save")
message_string = "No samled data to save\n"
self.show_message(self.text_message, message_string)
class client_GUI(Thread):
alias = None
room = None
flag = False
in_room = False
client = socket()
IP = raw_input("IP Address: ")
if not IP:
IP = 'localhost'
try:
client.connect((IP, 9000))
except Exception as e:
print "Could not connect to IP"
logging.exception(e)
exit()
def __init__(self, master):
Thread.__init__(self)
frame = Frame(master)
frame.pack()
self.setAlias()
#creates the thread for listening to the Server
def run(self):
Recieve(self.client)
def clearWindow(self):
for widget in root.winfo_children():
widget.destroy()
def assemble_packet(self, msg, code):
parser = Parser()
if code == utils.codes["send_msg"]:
date = datetime.datetime.now().strftime(utils.DATE_FORMAT)
packet = parser.assemble(utils.codes["send_msg"], self.alias,
self.room, date, msg)
elif code == utils.codes["set_alias"]:
packet = parser.assemble(utils.codes["set_alias"], msg, "", "", "")
elif code == utils.codes["set_room"]:
packet = parser.assemble(utils.codes["set_room"], self.alias, msg,
"", "")
elif code == utils.codes["get_roomlist"]:
packet = parser.assemble(utils.codes["get_roomlist"], self.alias,
self.room, "", "")
logging.info("Sending packet %s" % (packet))
return packet
def breakdown_packet(self, packet):
parser = Parser()
parser.breakdown(packet)
if parser.code == utils.codes["recv_msg"]:
return parser.body
elif parser.code == utils.codes["recv_roomlist"]:
return parser.body
elif parser.code == utils.codes["alias_success"]:
self.alias = parser.alias
return parser.body
elif parser.code == utils.codes["alias_invalid"]:
return parser.alias
elif parser.code == utils.codes["room_success"]:
self.room = parser.room
return parser.room
elif parser.code == utils.codes["room_invalid"]:
return parser.room
else:
logging.info("Invalid packet recieved")
return
def setAlias(self):
def setRoom():
aliasCheck = None
self.alias = self.aliasInfo.get().translate(None, '\\')
self.alias = self.alias.translate(None, ' ')
if len(self.alias) > 20:
self.alias = self.alias[:19]
packet = self.assemble_packet(self.alias, utils.codes["set_alias"])
try:
self.client.send(packet)
except Exception as e:
logging.exception(e)
time.sleep(1)
if not inputQueue.empty():
aliasCheck = str(inputQueue.get())
if aliasCheck.startswith(utils.codes["alias_success"]):
roomList = self.breakdown_packet(aliasCheck)
self.clearWindow()
self.changeRoom(roomList)
else:
self.flag = True
self.clearWindow()
self.setAlias()
else:
self.flag = True
self.clearWindow()
self.setAlias()
self.intro = Label(root,
text="Welcome to TrashTalk",
width=600,
font=8000,
fg="red",
pady=100)
self.intro.pack(anchor=CENTER)
self.aliasLabel = Label(root, text="Set Your Alias:", pady=10)
self.aliasLabel.pack(anchor=CENTER)
self.aliasInfo = Entry(root, width=40)
self.aliasInfo.pack(anchor=CENTER)
self.spacing = Label(root, text="", pady=70)
if self.flag:
self.spacing.config(text="Invalid, please try again", fg="red")
self.spacing.pack(anchor=CENTER)
self.login = Button(root,
height=2,
width=10,
text="Pick A Room",
command=setRoom)
self.login.pack(anchor=CENTER)
def changeRoom(self, roomList):
def enterRoom():
self.clearWindow()
chosenRoom = self.v.get()
if not chosenRoom:
chosenRoom = firstRoom
packet = self.assemble_packet(chosenRoom, utils.codes["set_room"])
try:
self.client.send(packet)
except Exception as e:
logging.exception(e)
time.sleep(1)
if not inputQueue.empty():
roomCheck = str(inputQueue.get())
if roomCheck.startswith(utils.codes["room_success"]):
self.room = chosenRoom
self.in_room = True
self.inRoom(chosenRoom)
else:
self.changeRoom(roomList)
root.title("TrashTalk")
rooms = roomList.split()
firstRoom = rooms[0]
self.v = StringVar(value=firstRoom)
self.roomLabel = Label(
root,
text="Select which Chat Room You Would Like to Join",
pady=70,
font=800)
self.roomLabel.pack(anchor=CENTER)
for room in rooms:
self.b = Radiobutton(root, text=room, variable=self.v, value=room)
self.b.pack(anchor=CENTER)
self.b.deselect()
self.login = Button(root,
height=2,
width=20,
text="Enter Chosen Room",
command=enterRoom)
self.login.place(relx=0.5, y=400, anchor=CENTER)
def inRoom(self, room):
def newMessage():
message = self.entryBox.get()
if message:
self.entryBox.delete(0, 'end')
message = message.translate(None, '\\')
if len(message) > 900:
message = message[:899]
packet = self.assemble_packet(message, utils.codes["send_msg"])
try:
self.client.send(packet)
except Exception as e:
logging.exception(e)
def changingRoom():
packet = self.assemble_packet("", utils.codes["get_roomlist"])
try:
self.client.send(packet)
except Exception as e:
logging.exception(e)
time.sleep(1)
if not inputQueue.empty():
roomCheck = str(inputQueue.get())
if roomCheck.startswith(utils.codes["recv_roomlist"]):
in_room = False
roomList = self.breakdown_packet(roomCheck)
self.clearWindow()
self.changeRoom(roomList)
def exitProgram():
self.client.close()
os._exit(1)
root.title("TrashTalk - " + room)
self.messageHistory = ScrolledText(root, undo=True)
self.messageHistory.bind("<Key>", lambda e: "break")
self.messageHistory.pack(anchor=W)
self.messageHistory.insert(
END, "Welcome " + self.alias + " to the " + room + " chat room!")
self.entryBox = Entry(root, width=85)
self.entryBox.place(x=0, y=400, anchor=W)
self.sendButton = Button(root,
height=2,
width=19,
text="Send Message",
command=newMessage)
self.sendButton.place(x=518, y=388, anchor=NW)
self.sendButton = Button(root,
height=4,
width=25,
text="Change Room",
command=changingRoom)
self.sendButton.place(x=725, y=300, anchor=NW)
self.sendButton = Button(root,
height=4,
width=25,
text="Quit",
command=exitProgram)
self.sendButton.place(x=725, y=400, anchor=NW)
def update_chat():
if not buildQueue.empty():
MYINFO = buildQueue.get()
if MYINFO.startswith(utils.codes["leave_room"]):
changingRoom()
elif self.in_room:
msg = self.breakdown_packet(MYINFO)
endOfBox = self.messageHistory.vbar.get()
self.messageHistory.insert(END, "\n" + msg)
if endOfBox[1] == 1.0:
endOfBox = self.messageHistory.see("end")
root.after(100, update_chat)
root.after(100, update_chat)
