class Scratchpad:
def __init__(self):
self.window = Tk()
self.window.title("Onager Scratchpad")
self.create_frame()
self.create_editing_window()
self.window.bind('<F7>', self.save_file)
self.window.bind('<F5>', self.open_file)
def create_frame(self):
frame_style = Style()
frame_style.theme_use('alt')
frame_style.configure("TFrame",
relief='raised')
self.frame = Frame(self.window, style="frame_style.TFrame")
self.frame.rowconfigure(1)
self.frame.columnconfigure(1)
self.frame.grid(row=0, column=0)
def create_editing_window(self):
self.editing_window = ScrolledText(self.frame)
self.editing_window.configure(fg='gold',
bg='blue',
font='serif 12',
padx='15',
pady='15',
wrap='word',
borderwidth='10',
relief='sunken',
tabs='48',
insertbackground='cyan')
self.editing_window.grid(row=0, column=0)
def save_file(self, event=None):
name = asksaveasfilename()
outfile = open(name, 'w')
contents = self.editing_window.get(0.0, END)
outfile.write(contents)
outfile.close()
def open_file(self, event=None):
name = askopenfilename()
infile = open(name, 'r')
contents = infile.read()
self.editing_window.insert(INSERT, contents)
infile.close()
class GuiConsole(Frame):
def __init__(self, master=None, cnf={}, **kw):
super(GuiConsole, self).__init__(master, cnf, **kw)
self.pack(fill=BOTH, expand=YES)
self.console = ScrolledText(self, font=('Source Code Pro', 12, 'normal'))
self.console.pack(side=TOP, fill=BOTH, expand=YES, padx=5, pady=5)
self.console.focus()
self.console.mark_set(INSERT, '1.0')
def clear(self):
self.console.delete('1.0', END)
def write(self, text):
text = '{}'.format(text)
self.console.insert(INSERT, text)
self.console.mark_set(INSERT, INSERT+'+{}c'.format(len(text)))
def writeline(self, text):
self.write('{}\n'.format(text))
def writelines(self, lines):
for line in lines:
self.writeline(line)
def read(self):
pass
def update(self, event):
self.selected = self.listbox.curselection()
self.removeTabs()
try:
e = self.listitems[int(self.selected[0])]
self.entryTab = ScrolledText(self.notebook, relief=SUNKEN, padx=10, pady=5)
self.entryTab.insert(END, "Signature: %s\n" % e.signature)
self.entryTab.insert(END, "Fixup array offset: %s\n" % e.fixup_array_offset)
self.entryTab.insert(END, "Fixup array entries: %s\n" % e.fixup_array_entries)
self.entryTab.insert(END, "$LogFile sequence number: %s\n" % e.lsn)
self.entryTab.insert(END, "Sequence: %s\n" % e.sequence)
self.entryTab.insert(END, "Link count: %s\n" % e.link_count)
self.entryTab.insert(END, "Attribute offset: %s\n" % e.attribute_offset)
self.entryTab.insert(END, "Flags: %s\n" % e.flags)
self.entryTab.insert(END, "Used size: %s\n" % e.used_size)
self.entryTab.insert(END, "Allocated size: %s\n" % e.allocated_size)
self.entryTab.insert(END, "File reference: %s\n" % e.file_ref)
self.entryTab.insert(END, "Next attribute ID: %s\n" % e.next_attr_id)
self.entryTab.config(state=DISABLED)
self.notebook.add(self.entryTab, text=e.filename)
for attribute in e.attributes:
tab = ScrolledText(self.notebook, relief=SUNKEN, padx=10, pady=5)
for i in attribute.export():
tab.insert(END, i + "\n")
tab.config(state=DISABLED)
self.notebook.add(tab, text=attribute.attr_type.value)
except IndexError:
pass
def editContactView(self, infoWindow, Contact):
window = Toplevel()
window.focus_set()
window.title("Edit Contact")
window.resizable(width=FALSE, height=FALSE)
Label(window, text="Name ").grid(row=0, column=0)
name = Entry(window, width=30)
name.grid(row=0, column=1)
name.insert(0, Contact["name"])
Label(window, text="Line ").grid(row=1, column=0)
line = Entry(window, width=30)
line.grid(row=1, column=1)
line.insert(0, Contact["line"])
Label(window, text="Email ").grid(row=2, column=0)
Email = Entry(window, width=30)
Email.grid(row=2, column=1)
Email.insert(0, Contact["Email"])
Label(window, text="Phone ").grid(row=3, column=0)
telephone = ScrolledText(window, width=37)
telephone.grid(row=3, column=1)
for i in Contact["telephone"]:
telephone.insert(INSERT, str(i) + "\n")
okButton = Button(window, text="Finish",
command=lambda: self.editContact(window, infoWindow, uuid=Contact["uuid"], name=name.get(),
line=line.get(),
Email=Email.get(),
Telephone=telephone.get(1.0, END)))
okButton.grid(row=4)
cancelButton = Button(window, text="Cancel", command=window.destroy)
cancelButton.grid(row=4, column=1, sticky=E)
class ReadMailWindow:
def __init__(self, receiver='*****@*****.**', sender='*****@*****.**', topic='DefaultTopic', text='Dear:\n\nDefaultLine\nDefaultLine2\nDefaultLine3\n\nSincerely,\nDefaultUser'):
'''
create the ReadMailWindow.
'''
self.root = tk.Tk()
self.root.title('Mail from '+sender)
self.root.geometry('300x200')
self.receiver=receiver
self.sender=sender
self.topic=topic
self.text=text
self.pane_for_sender = tk.PanedWindow(self.root,orient=tk.HORIZONTAL, borderwidth=5)
self.pane_for_sender.pack(fill=tk.BOTH)
self.lable_for_sender = tk.Label(self.pane_for_sender, text='From:', width=5, justify=tk.LEFT, anchor=tk.W)
self.entry_for_sender = tk.Entry(self.pane_for_sender, width=10)
self.entry_for_sender.insert(0, self.sender)
self.entry_for_sender.config(state=tk.DISABLED)
self.pane_for_sender.add(self.lable_for_sender)
self.pane_for_sender.add(self.entry_for_sender)
self.pane_for_topic = tk.PanedWindow(self.root, orient=tk.HORIZONTAL, borderwidth=5)
self.pane_for_topic.pack(fill=tk.BOTH)
self.lable_for_topic = tk.Label(self.pane_for_topic, text='Topic:', width=5, justify=tk.LEFT, anchor=tk.W)
self.entry_for_topic = tk.Entry(self.pane_for_topic, width=10)
self.entry_for_topic.insert(0, self.topic)
self.entry_for_topic.config(state=tk.DISABLED)
self.pane_for_topic.add(self.lable_for_topic)
self.pane_for_topic.add(self.entry_for_topic)
self.pane_for_content = tk.PanedWindow(self.root, orient=HORIZONTAL, borderwidth=7)
self.pane_for_content.pack(fill=tk.BOTH, expand=1)
self.lable_for_content = tk.Label(self.pane_for_content, text='Text:', justify=tk.LEFT, anchor=tk.W)
self.text_for_content = ScrolledText(self.pane_for_content, width=10, height=4)
self.text_for_content.insert(1.0, self.text)
self.text_for_content.config(state=tk.DISABLED)
self.pane_for_content.add(self.lable_for_content)
self.pane_for_content.add(self.text_for_content)
self.pane_for_button = tk.PanedWindow(self.root, orient=tk.HORIZONTAL)
self.pane_for_button.pack(fill=tk.BOTH)
self.button_for_reply = tk.Button(self.pane_for_button, text="Reply", command=self.Reply)
self.button_for_close = tk.Button(self.pane_for_button, text="Exit", command=self.Destroy, width=5)
self.pane_for_button.add(self.button_for_close)
self.pane_for_button.add(self.button_for_reply)
def Reply(self):
with open('acpwd.txt') as file:
for line in file:
acpwd = line.split(':')
self.SMW = smw.SendMailWindow(self.receiver, self.sender, acpwd[1])
self.SMW.text_for_content.insert(1.0, '\n\n---------------\n'+self.text)
#self.root.destroy()
def Destroy(self):
self.root.destroy()
def _conButtonCmd(self):
popwin = PopupWindow("Container Log")
popwin.grab_set()
popwin.focus()
details = self.checkresult.getContainerLogs()
stext = ScrolledText(popwin)
stext.config(font = ("courier", 15, "normal"))
stext.pack()
for d in details:
stext.insert("end",d)
stext.see("end")
class HMDmain(tk.Frame):
def __init__(self, parent, *args, **kwargs):
tk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
self.parent.option_add('*tearOff', False)
self.after(50, self.onAfter)
#set this frame to expand to %100 available space
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
#init menu
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = Menu(menubar)
fileMenu.add_command(label="Save", command=self.onSave)
fileMenu.add_command(label="Load", command=self.onLoad)
fileMenu.add_command(label="Exit", command=self.onExit)
menubar.add_cascade(label="File", menu=fileMenu)
#init textbox
self.text = ScrolledText(self, wrap='word')
#add widgets to the layout manager
self.text.grid(sticky=inflate)
def onExit(self):
self.quit()
def onSave(self):
darkIO.DarkIO.save(asksaveasfilename(), self.text.get(0.0, 'end'))
def onLoad(self):
if not askyesno(
"Clear All Text",
"Loading a new file will clear the current project \n"
"Would you like to continue?"):
return
loadText = ""
try:
fname = askopenfile()
loadText = darkIO.DarkIO.load(fname.name)
except UnicodeDecodeError:
showerror("Invalid File Type", "Unable to read file.")
else:
self.text.delete(0.0, 'end')
self.text.insert(0.0, loadText)
def onAfter(self):
print("Working")
self.after(30000, self.onAfter)
class LongTextbox(Textbox):
def config(self, **kwargs):
try:
self.sentry.config(height=kwargs['height'])
except:
pass
# print("the widget could not be configured")
try:
self.sentry.config(width=kwargs['width'])
except:
pass
#print("the widget could not be configured")
try:
self.sentry.delete(1.0, END)
self.sentry.insert(END, kwargs['text'])
except:
pass
#print("the widget could not be configured")
def trytoplace(self, **kwargs):
self.parent = kwargs['parent']
self.row = kwargs['row']
self.column = kwargs['column']
def place(self, **kwargs):
try:
self.trytoplace(**kwargs)
except:
print("widget could not be placed")
self.label = Label(self.parent, text=self.text)
self.sentry = ScrolledText(self.parent, relief=GROOVE)
self.label.grid(row=self.row, column=self.column)
self.sentry.grid(row=self.row, column=self.column+1, sticky=W+E, columnspan=100)
def getData(self):
return self.sentry.get(1.0, END)
def setData(self, data):
self.sentry.delete(1.0, END)
self.sentry.insert(END, self.text)
# self.config(text=data)
def _buttonCmd(self):
popwin = PopupWindow("Details")
popwin.grab_set()
popwin.focus()
details = self.checkresult.getDetails()
# with os.popen("kubectl describe nodes/115.154.138.241") as re:
# details = re.readlines()
stext = ScrolledText(popwin)
stext.config(font = ("courier", 15, "normal"))
stext.pack()
for d in details:
stext.insert("end",d)
stext.see("end")
def Login(entries,root):
text=[]
for entry in entries:
text.append(entry[1].get())
print(text)
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(text[0], username=text[1], password=text[2])
stdin, stdout, stderr = ssh.exec_command(text[3])
u=stdout.readlines()
output = ''.join(u)
sc=ScrolledText(root)
sc.pack(side=LEFT)
sc.insert(END, output)
def createTab(self, text, content):
ind = self.tabIndMax
tab = Radiobutton(self.tabs_panel, text=text,
font=NORMAL_FONT, indicatoron=NO,
variable=self.tabInd, value=ind,
command=lambda:self.switchTab(ind))
self.tabIndMax += 1
tab.pack(side=TOP, fill=X)
txtCtrl = ScrolledText(self.txt_panel, undo = True)
txtCtrl.insert(1.0, content)
self.tabs.append(tab)
self.txtCtrls.append(txtCtrl)
return ind
def contViewRaw(self, msgnums, pyedit=True):
for msgnum in msgnums:
fulltext = self.getMessage(msgnum)
if not pyedit:
from tkinter.scrolledtext import ScrolledText
window = windows.QuietPopupWindow(appname, 'raw message viewer')
browser = ScrolledText(window)
browser.insert('0.0', fulltext)
browser.pack(expand=YES, fill=BOTH)
else:
wintitle = ' - raw message text'
browser = textEditor.TextEditorMainPopup(self, winTitle=wintitle)
browser.update()
browser.setAllText(fulltext)
browser.clearModified()
def __init__(self, appname, helptext, iconfile=None, showsource=lambda:0):
PopupWindow.__init__(self, appname, 'Help', iconfile)
from tkinter.scrolledtext import ScrolledText # a nonmodal dialog
bar = Frame(self) # 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=self.destroy)
code.pack(pady=1, side=LEFT)
quit.pack(pady=1, side=LEFT)
text = ScrolledText(self) # add Text + scrollbar
text.config(font=self.myfont)
text.config(width=self.mywidth) # 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)
self.bind("<Return>", (lambda event: self.destroy()))
def contViewRaw(self, msgnums, pyedit=True): # do we need full TextEditor?
for msgnum in msgnums: # could be a nested def
fulltext = self.getMessage(msgnum) # fulltext is Unicode decoded
if not pyedit:
# display in a scrolledtext
from tkinter.scrolledtext import ScrolledText
window = windows.QuietPopupWindow(appname, 'raw message viewer')
browser = ScrolledText(window)
browser.insert('0.0', fulltext)
browser.pack(expand=YES, fill=BOTH)
else:
# 3.0/4E: more useful PyEdit text editor
wintitle = ' - raw message text'
browser = textEditor.TextEditorMainPopup(self, winTitle=wintitle)
browser.update()
browser.setAllText(fulltext)
browser.clearModified()
def onHist(self):
# show recent calcs log popup
from tkinter.scrolledtext import ScrolledText # or PP4E.Gui.Tour
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.see(END) # 3.0: scroll to end
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.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 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)
def __init__(self,appname,helptext,iconfile=None,
showsource=lambda:0):
PopupWindow.__init__(self,appname,'Help',iconfile)
from tkinter.scrolledtext import ScrolledText
bar=Frame(self)
bar.pack(side=BOTTOM,fill=X)
code=Button(bar,bg='beige',text='Source',command=showsource)
quit=Button(bar,bg='beige',text='Cancel',command=self.destroy)
code.pack(pady=1,side=LEFT)
quit.pack(pady=1,side=LEFT)
text=ScrolledText(self)
text.config(font=self.myfont)
text.config(width=self.mywidth)
text.config(bg='steelblue',fg='white')
text.insert('0.0',helptext)
text.pack(expand=YES,fill=BOTH)
self.bind('<Return>',(lambda event:self.destroy()))
def __init__(self, parent, title=None, text=None):
self.had_focus = parent.focus_get()
Toplevel.__init__(self, parent)
if title:
self.title(title)
stext = ScrolledText(self, background="gray")
stext.pack(padx=5, pady=5)
if text is not None:
stext.insert("end", text)
stext["state"] = "disabled"
separ = Separator(self, orient="horizontal")
separ.pack(expand=1, fill="x")
b = Button(self, text=_("OK"), width=10,
command=self.destroy, default="active")
self.bind("<Escape>", self.destroy)
b.pack()
self.protocol("WM_DELETE_WINDOW", self.destroy)
b.focus_set()
self.grab_set()
self.wait_window()
class GuiOutput:
font = ('courier', 9, 'normal') # in class for all, self for one
def __init__(self, parent=None):
self.text = None
if parent: self.popupnow(parent) # pop up 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=self.font)
self.text.pack()
def write(self, text):
self.popupnow()
self.text.insert(END, str(text))
self.text.see(END)
self.text.update() # update gui after each line
def writelines(self, lines): # lines already have '\n'
for line in lines: self.write(line) # or map(self.write, lines)
class MessageTester:
def __init__(self, root):
root.title("Message tester")
Label(root, text="Enter message event below", bg="light green").pack()
self.event_field = ScrolledText(root, width=180, height=10)
self.event_field.pack()
Label(root, text="Enter test case below", bg="light green").pack()
self.test_case_field = ScrolledText(root, width=180, height=20)
self.test_case_field.pack()
Label(root, text="Test result:", bg="light green").pack()
self.result_field = ScrolledText(root, width=180, height=10)
self.result_field.pack()
self.result_field.config(state=DISABLED)
self.button = Button(root, text="Evaluate", fg="red",
command=self._clicked)
self.button.pack()
self.event_field.delete('1.0', END)
self.event_field.insert('insert', EXAMPLE_EVENT)
self.test_case_field.delete('1.0', END)
self.test_case_field.insert('insert', EXAMPLE_TEST_CASE)
def _clicked(self):
event = self.event_field.get('1.0', END)
test_case = self.test_case_field.get('1.0', END)
evaluation = skill_tester.EvaluationRule(ast.literal_eval(test_case))
evaluation.evaluate(ast.literal_eval(event))
self.result_field.config(state=NORMAL)
self.result_field.delete('1.0', END)
self.result_field.insert('insert', evaluation.rule)
self.result_field.config(state=DISABLED)
class MyGUI:
def __init__(self, reps=3):
self.reps = reps
self.text = ScrolledText()
self.text.pack()
threadChecker(self.text)
self.text.bind('<Button-1>',
lambda event: list(map(self.onEvent, range(6))))
def onEvent(self, i):
myname = 'thread-%s' % i
startThread(action=self.threadaction, args=(i, ),
context=(myname,), onExit=self.threadexit,
onFail=self.threadfail, onProgress=self.threadprogress)
def threadaction(self, id, progress):
for i in range(self.reps):
time.sleep(1)
if progress: progress(i)
if id % 2 == 1: raise Exception
def threadexit(self, myname):
self.text.insert('end', '%s\texit\n' % myname)
self.text.see('end')
def threadfail(self, exc_info, myname):
self.text.insert('end', '%s\tfail\t%s\n' % (myname, exc_info[0]))
self.text.see('end')
def threadprogress(self, count, myname):
self.text.insert('end', '%s\tprog\t%s\n' % (myname, count))
self.text.see('end')
self.text.update()
class GuiOutput:
font = ('courier', 12, 'normal')
def __init__(self, parent=None):
self.text = None
if parent:
self.popupnow(parent)
def popupnow(self, parent=None):
if self.text: return
self.text = ScrolledText(parent or Toplevel())
self.text.config(font=self.font)
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):
for line in lines:
self.write(line)
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 Logger(Frame):
ERROR, BORRING, EVENT, NORMAL = "error", "borring", "event", None
def __init__(self, *args, **kw):
text_height = kw.pop("text_height", 25)
Frame.__init__(self, *args, **kw)
self.deque = deque()
self.txt = ScrolledText(self, wrap=WORD, state=DISABLED, relief=SUNKEN, height=text_height)
self.txt.grid(column=0, row=0, sticky=(N, W, E, S))
self.txt.configure(LoggerColors.default)
for k, v in LoggerColors.tags.items():
self.txt.tag_configure(k, v)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
self.after(100, self._toscreen)
def __call__(self, *args):
self.deque.appendleft(args)
def _toscreen(self):
if len(self.deque):
self.txt["state"] = NORMAL
while(len(self.deque)):
self.txt.insert(
END,
"\n[{}] ".format(strftime("%H:%M:%S")),
"time",
*self.deque.pop())
self.txt.yview(END)
self.txt["state"] = DISABLED
self.after(100, self._toscreen)
def onRE(self):
window = Toplevel(self)
window.title('正则表达式信息提取')
label = Label(window)
label.pack()
result = ScrolledText(window)
result.pack(fill=BOTH, expand=1)
htmlFile = 'data/凤凰网.html'
start = time.clock()
titles = regex.fetchTitles(htmlFile)
links = regex.fetchLinks(htmlFile)
elapsed = time.clock() - start
label['text'] = '耗时: {0:.1f} ms'.format(elapsed*1000)
result.insert(INSERT, 'Titles:\n')
result.insert(INSERT, '\n'.join(titles))
result.insert(INSERT, '\n\nLinks:\n')
result.insert(INSERT, '\n'.join(links))
class MyGUI:
def __init__(self, reps=3):
self.reps = reps # uses default Tk root
self.text = ScrolledText() # save widget as state
self.text.pack()
threadChecker(self.text) # start thread check loop
self.text.bind('<Button-1>', # 3.x need list for map, range ok
lambda event: list(map(self.onEvent, range(6))) )
def onEvent(self, i): # code that spawns thread
myname = 'thread-%s' % i
startThread(
action = self.threadaction,
args = (i, ),
context = (myname,),
onExit = self.threadexit,
onFail = self.threadfail,
onProgress = self.threadprogress)
# thread's main action
def threadaction(self, id, progress): # what the thread does
for i in range(self.reps): # access to object state here
time.sleep(1)
if progress: progress(i) # progress callback: queued
if id % 2 == 1: raise Exception # odd numbered: fail
# thread callbacks: dispatched off queue in main thread
def threadexit(self, myname):
self.text.insert('end', '%s\texit\n' % myname)
self.text.see('end')
def threadfail(self, exc_info, myname): # have access to self state
self.text.insert('end', '%s\tfail\t%s\n' % (myname, exc_info[0]))
self.text.see('end')
def threadprogress(self, count, myname):
self.text.insert('end', '%s\tprog\t%s\n' % (myname, count))
self.text.see('end')
self.text.update() # works here: run in main thread
class Window:
def __init__(self,
width,
height,
title="MyWindow",
resizable=(False, False),
icon=r"resources/feather.ico"):
self.root = Tk()
self.root.title(title)
# self.root.geometry(f"{width}x{height}+200+200")
self.root.geometry("+600+300")
# self.root.resizable(resizable[0], resizable[1])
if icon:
self.root.iconbitmap(icon)
self.text = ScrolledText(self.root)
def run(self):
self.draw_widgets()
self.root.mainloop()
def draw_widgets(self):
self.draw_menu()
self.text.pack()
def draw_menu(self):
menu_bar = Menu(self.root)
file_menu = Menu(menu_bar, tearoff=0)
file_menu.add_command(label="Открыть", command=self.open_file)
file_menu.add_command(label="Сохранить как", command=self.save_file)
file_menu.add_command(label="Отркыть папку", command=self.open_dir)
file_menu.add_separator()
file_menu.add_command(label="Выйти", command=self.exit)
info_menu = Menu(menu_bar, tearoff=0)
info_menu.add_command(label="О приложении", command=self.show_info)
menu_bar.add_cascade(label="Файл", menu=file_menu)
menu_bar.add_cascade(label="Справка", menu=info_menu)
self.root.configure(menu=menu_bar)
def open_file(self):
# wanted_files = (
# ("IMAGES", "*.jpeg;*.png;*.gif"),
# ("TEXT files", "*.txt;*.log"),
# ("PY files", "*.py"),
# ("ALL", "*.*")
# )
#
# file_name = fd.askopenfilename(initialdir="D:/", title="FIND A FILE", filetypes=wanted_files)
# self.text.insert(END, f"Надо открыть файл: {file_name}\nСодержимое:\n")
# if file_name:
# with open(file_name, "r") as f:
# self.text.insert(END, f.read())
# file = fd.askopenfile()
# self.text.insert(END, file.read())
# file.close()
file_names = fd.askopenfilenames()
self.text.insert(END, str(file_names))
def save_file(self):
name = fd.asksaveasfilename(filetypes=(("TEXT files", "*.txt"),
("Py files", "*.py")))
if name:
self.text.insert(END, f"Сохранить файл по пути {name}\n")
# with open(name, "w") as f:
# f.write("123")
# file = fd.asksaveasfile()
# file.write("123")
# file.close()
def open_dir(self):
path = fd.askdirectory(mustexist=True)
self.text.insert(END, f"Папка {path}\n")
def show_info(self):
mb.showinfo("Информация", "Лучшее графическое приложение на свете")
def exit(self):
choice = mb.askyesno("Quit", "Do you want to quit?")
if choice:
self.root.destroy()
def create_child(self,
width,
height,
title="Child",
resizable=(False, False),
icon=None):
ChildWindow(self.root, width, height, title, resizable, icon)
user = IP + ':' + PORT
#聊天窗口
root1 = tkinter.Tk()
root1.geometry("600x500")
root1.title('聊天室')
root1.resizable(0, 0)
listbox = ScrolledText(root1) #消息界面
listbox.place(x=5, y=0, width=550, height=320)
listbox.tag_config('red', foreground='red')
listbox.tag_config('blue', foreground='blue')
listbox.tag_config('pink', foreground='yellow')
listbox.tag_config('green', foreground='green')
listbox.tag_config('pink', foreground='pink')
listbox.insert(tkinter.END, 'Welcome to the chat room!', 'yellow')
INPUT = tkinter.StringVar()
INPUT.set('')
entryIuput = tkinter.Entry(root1, width=120, textvariable=INPUT)
entryIuput.place(x=10, y=370, width=550, height=80)
#在线用户列表
listbox1 = tkinter.Listbox(root1)
listbox1.place(x=445, y=0, width=130, height=320)
def send(*args):
if chat not in users:
tkinter.messagebox.showerror('error', message='找不到对象!')
return
fontdict = {"family": "Calibri", "size": 14, "style": "normal"}
e = ScrolledText(root,
bg='black',
fg='white',
insertbackground='white',
selectbackground='blue',
font=(fontdict["family"], fontdict["size"],
fontdict["style"]),
undo=True)
e.pack(fill="both", expand=True)
# Shortcuts
root.bind("<Escape>", lambda x: root.attributes('-fullscreen', False)
) # only if u use F11 will F5 work
root.bind("<F5>", lambda x: e.insert(INSERT, time.ctime()))
root.bind("<F4>", lambda x: e.insert(INSERT, colorchooser.askcolor()))
root.bind("<Control_L>+", lambda x: set_font_size(fontdict["size"] + 5))
root.bind("<Control_L>-", lambda x: set_font_size(fontdict["size"] - 5))
root.bind("<Control_L><d>", lambda x: delete_all(1))
root.bind("<Control_L><f>", lambda x: find(1))
root.bind("<Control_L><h>", lambda x: replace(1))
# status bar
def wordcount():
status.config(
text="Character count: " + str(len(e.get(1.0, "end-1c"))) +
" Word count: " + str(len(e.get(1.0, "end-1c").split())) +
" Line count: " +
str(len(e.get(1.0, "end-1c").split("\n")))) # returns line count)
class Edit(Screen):
def __init__(self):
Screen.__init__(self)
self.edit_key = 0
self.options = ["one", "two"]
self.tkvar = tk.StringVar(self)
self.tkvar.set(self.options[0])
self.lbl_title = tk.Label(self,
text="Edit Title",
font=("Arial", "25"))
self.lbl_title.grid(row=0, column=0, sticky="news", columnspan=3)
self.genre = tk.Label(self, text="Genre:", font=("arial", "18"))
self.genre.grid(row=1, column=0, sticky="news")
self.edit_genre = tk.Entry(self)
self.edit_genre.grid(row=1, column=1)
background = self.edit_genre.cget("bg")
self.title = tk.Label(self, text="Title:", font=("arial", "18"))
self.title.grid(row=1, column=2, sticky="news")
self.edit_title = tk.Entry(self)
self.edit_title.grid(row=1, column=3)
background = self.edit_title.cget("bg")
self.dev = tk.Label(self, text="Dev:", font=("arial", "18"))
self.dev.grid(row=2, column=0, sticky="news")
self.edit_dev = tk.Entry(self)
self.edit_dev.grid(row=2, column=1)
background = self.edit_dev.cget("bg")
self.pub = tk.Label(self, text="Pub:", font=("arial", "18"))
self.pub.grid(row=2, column=2, sticky="news")
self.edit_pub = tk.Entry(self)
self.edit_pub.grid(row=2, column=3)
background = self.edit_pub.cget("bg")
self.system = tk.Label(self, text="System:", font=("arial", "18"))
self.system.grid(row=3, column=0, sticky="news")
self.edit_system = tk.Entry(self)
self.edit_system.grid(row=3, column=1)
background = self.edit_system.cget("bg")
self.release = tk.Label(self,
text="Release Date:",
font=("arial", "18"))
self.release.grid(row=3, column=2, sticky="news")
self.edit_release = tk.Entry(self)
self.edit_release.grid(row=3, column=3)
background = self.edit_release.cget("bg")
self.rating = tk.Label(self, text="Rating:", font=("arial", "18"))
self.rating.grid(row=4, column=0, sticky="news")
self.edit_rating = tk.Entry(self)
self.edit_rating.grid(row=4, column=1, sticky='news')
background = self.edit_rating.cget("bg")
self.coop = tk.Label(self,
text="Multiplayer or Single:",
font=("arial", "18"))
self.coop.grid(row=4, column=2, sticky="news")
self.edit_coop = tk.Entry(self)
self.edit_coop.grid(row=4, column=3)
background = self.edit_coop.cget("bg")
self.price = tk.Label(self, text="Price:", font=("arial", "18"))
self.price.grid(row=5, column=0, sticky="news")
self.edit_price = tk.Entry(self)
self.edit_price.grid(row=5, column=1)
background = self.edit_price.cget("bg")
self.beaten = tk.Label(self,
text="Beaten Campaign:",
font=("arial", "18"))
self.beaten.grid(row=5, column=2, sticky="news")
self.edit_beaten = tk.Entry(self)
self.edit_beaten.grid(row=5, column=3)
background = self.edit_beaten.cget("bg")
self.pur_date = tk.Label(self,
text="Purchase date:",
font=("arial", "18"))
self.pur_date.grid(row=6, column=0, sticky="news")
self.edit_pur_date = tk.Entry(self)
self.edit_pur_date.grid(row=6, column=1)
background = self.edit_pur_date.cget("bg")
self.Notes = tk.Label(self, text="Notes:", font=("arial", "18"))
self.Notes.grid(row=7, column=2, sticky="news")
self.edit_space = ScrolledText(
self,
wrap='word', # wrap text at full words only
width=40, # characters
height=10, # text lines
# bg='blue' # background color of edit area
)
self.edit_space.grid(row=8, column=2)
self.btn_cancel = tk.Button(self,
text="Cancel",
font=("Arial", "15"),
command=self.go_home)
self.btn_cancel.grid(row=9, column=0)
self.btn_clear = tk.Button(self, text="Clear", font=("Arial", "15"))
self.btn_clear.grid(row=9, column=1)
self.btn_submit = tk.Button(self,
text="Submit",
font=("Arial", "15"),
command=self.submit_edit)
self.btn_submit.grid(row=9, column=2)
self.grid_columnconfigure(0, weight=1)
self.grid_columnconfigure(1, weight=1)
self.grid_columnconfigure(2, weight=1)
self.grid_columnconfigure(3, weight=1)
#this is what will change the read file
def edit_update(self):
entry = games[self.edit_key]
self.edit_genre.delete(0, "end")
self.edit_genre.insert(0, entry[0])
self.edit_title.delete(0, "end")
self.edit_title.insert(0, entry[1])
self.edit_dev.delete(0, "end")
self.edit_dev.insert(0, entry[2])
self.edit_pub.delete(0, "end")
self.edit_pub.insert(0, entry[3])
self.edit_system.delete(0, "end")
self.edit_system.insert(0, entry[4])
self.edit_release.delete(0, "end")
self.edit_release.insert(0, entry[5])
self.edit_rating.delete(0, "end")
self.edit_rating.insert(0, entry[6])
self.edit_coop.delete(0, "end")
self.edit_coop.insert(0, entry[7])
self.edit_price.delete(0, "end")
self.edit_price.insert(0, entry[8])
self.edit_beaten.delete(0, "end")
self.edit_beaten.insert(0, entry[9])
self.edit_pur_date.delete(0, "end")
self.edit_pur_date.insert(0, entry[10])
self.edit_space.delete(0.0, "end")
self.edit_space.insert(0.0, entry[11])
def go_home(self):
Screen.current = 0
Screen.switch_frame()
#oh boy the submit command
def submit_edit(self):
entry = []
entry.append(self.edit_genre.get())
entry.append(self.edit_title.get())
entry.append(self.edit_dev.get())
entry.append(self.edit_pub.get())
entry.append(self.edit_system.get())
entry.append(self.edit_release.get())
entry.append(self.edit_rating.get())
entry.append(self.edit_coop.get())
entry.append(self.edit_price.get())
entry.append(self.edit_beaten.get())
entry.append(self.edit_pur_date.get())
entry.append(self.edit_space.get(0.0, "end"))
games[self.edit_key] = entry
Screen.current = 0
Screen.switch_frame()
class App(Frame):
"""Гланое окно приложения"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# screen_width = self.winfo_screenwidth()
# print(screen_width, self.winfo_screenheight())
self.master.title(f'Mem-translate {__version__}')
self.master.minsize(300, 200)
menu = Menu(self.master)
self.master.configure(menu=menu)
menu_file = Menu(menu)
menu_file.add_command(label='Импорт', command=self.on_import)
menu.add_cascade(label='Файл', menu=menu_file)
width = 73
self.text = ScrolledText(self, bg='white', height=31, width=width, undo=True, wrap='word')
self.text['font'] = DEFAULT_FONT
self.text.tag_configure(TAG_BLUE, background='#aaf')
self.text.focus_set()
self.text.bind('<Key>', self.on_key_text)
self.text.grid_configure(row=0, column=0, rowspan=2)
self.text_fuzz = ScrolledText(self, bg='white', height=15, width=width, wrap='word')
self.text_fuzz['font'] = DEFAULT_FONT
self.text_fuzz.tag_configure(TAG_BLUE, background='#afa')
self.text_fuzz.bind('<Key>', lambda event: 'break')
self.text_fuzz.grid_configure(row=0, column=1, sticky='n')
self.text_tran = ScrolledText(self, bg='white', height=15, width=width, wrap='word')
self.text_tran['font'] = DEFAULT_FONT
self.text_tran.bind('<Key>', lambda event: 'break')
self.text_tran.grid_configure(row=1, column=1, sticky='s')
self.grid_configure()
def destroy(self):
# todo
log.info('destroy')
super().destroy()
def on_import(self):
"""Обработчик кнопки Импорт"""
filename = Open(initialdir='../you-can/source/', filetypes=(('Текст', '*.txt'),)).show()
text_ls = do_import(filename)
self.do_open(text_ls)
def do_open(self, text_ls: List[str]):
"""Отрисовать текст"""
for line in text_ls:
self.text.insert('end', line)
# добавляем немного подсветки
# if not line.startswith(PREFIX_TRANSLATE) and line != PREFIX_CUT:
if not line.startswith('>>>'):
i = self.text.index('insert').split('.', 1)[0]
self.text.tag_add(TAG_BLUE, f'{i}.0', f'{i}.{len(line)}')
self.text.insert('end', '\n')
log.debug(self.text.tag_ranges(TAG_BLUE))
def on_key_text(self, event):
"""Обработчик нажатий любой клавиши в главном textArea"""
if event.keycode == 36: # Return
self.do_enter()
return 'break'
log.debug(event)
def do_enter(self):
tag_range = self.text.tag_nextrange(TAG_BLUE, self.text.index('insert'))
if not tag_range:
return
index1, index2 = tag_range
# двигаем курсор
index = int(index2.split('.')[0]) + 1
self.text.mark_set('insert', f'{index}.{len(PREFIX_TRANSLATE)}')
self.text.see('insert')
text: str = self.text.get(index1, index2)
# переводим текст
self.text_tran.delete('1.0', 'end')
start_new_thread(self.thread_translate, (text,))
# ...
self.text_fuzz.delete('1.0', 'end')
start_new_thread(self.thread_fuzz, (text,))
def thread_translate(self, text: str):
"""Асинхронно запускаем машинный перевод"""
try:
text2 = translate_yandex(text)
except BaseException as ex:
text2 = str(ex)
self.text_tran.insert('1.0', text2)
def thread_fuzz(self, text: str):
"""Асинхронно ищем нечёткие совпадения"""
# todo закешировать + парсить перевод + перенести в text.py
ls: list = self.text.get('1.0', 'end').split('\n')
ls.remove(text)
choices = [f'{i + 1}: {line}' for i, line in enumerate(ls) if not line.startswith('>>>')]
# result = [f'{line} ({p})' for line, p in extractBests(text, choices, score_cutoff=1, limit=7)]
# result = [(line, fuzz.token_set_ratio(line, text)) for line in choices]
ww = set(re.findall(r'\w{4,}', text)) - {'that', 'That', 'only', 'Only'}
result = []
for line in choices:
p = len(set(re.findall(r'\w{4,}', line)) & ww)
if p > 0:
result.append((line, p))
result = heapq.nlargest(7, result, key=lambda x: x[1])
result = [line for line, p in result]
# self.text_fuzz.insert('1.0', '\n'.join(result))
for line in result:
self.text_fuzz.insert('end', line)
i = self.text_fuzz.index('insert').split('.', 1)[0]
# for m in SequenceMatcher(None, line.lower(), text.lower()).get_matching_blocks():
# self.text_fuzz.tag_add(TAG_BLUE, f'{i}.{m.a}', f'{i}.{m.a + m.size}')
for w in ww:
for m in re.finditer(w, line):
self.text_fuzz.tag_add(TAG_BLUE, f'{i}.{m.start()}', f'{i}.{m.end()}')
self.text_fuzz.insert('end', '\n')
class App(Frame):
lock = False
def __init__(self, master=None):
Frame.__init__(self, master)
# self. grid()
self.pack()
self.master = master
self.download_type = IntVar()
self.audio_only = BooleanVar()
self.from_url = StringVar()
self.to_url = StringVar()
self.radois = Frame(self, relief=RAISED, borderwidth=1)
self.radois.pack(fill=BOTH, expand=True)
self.download_playlist = Radiobutton(self.radois,
text='Плейлист целиком',
variable=self.download_type,
value=0)
self.download_playlist.pack(ipadx=10, ipady=10, side=LEFT)
self.download_file_only = Radiobutton(self.radois,
text='Только файл',
variable=self.download_type,
value=1)
self.download_file_only.pack(ipadx=10, ipady=10, side=LEFT)
self.download_url_label = Label(text="Откуда качать")
self.download_url_label.pack(ipadx=10, ipady=10)
self.download_url = Entry(self.master, textvariable=self.from_url)
self.download_url.pack(ipadx=10, ipady=3, expand=True, fill=BOTH)
self.download_url_label = Label(text="Куда качать")
self.download_url_label.pack(ipadx=10, ipady=10)
self.save_url = Entry(self.master, textvariable=self.to_url)
self.save_url.pack(ipadx=10, ipady=3, expand=True, fill=BOTH)
self.audio_checkbox = Checkbutton(self.master,
text='Только аудио',
variable=self.audio_only,
onvalue=True,
offvalue=False)
self.audio_checkbox.pack(ipadx=10, ipady=10)
self.message_button = Button(text="Скачать", command=self.run_program)
self.message_button.pack(ipadx=10, ipady=10)
self.editArea = ScrolledText(master=self.master,
wrap=WORD,
width=20,
height=10)
self.editArea.pack(padx=10, pady=10, fill=BOTH, expand=True)
def run_program(self):
if not self.lock:
self.lock = True
thread = threading.Thread(
target=self.run,
args=(),
)
thread.daemon = True
thread.start()
else:
messagebox.showerror(
"Error",
"В данный момент уже идет загрузка, подождите окончания предыдущей и попробуйте снова!"
)
def run(self):
if self.download_type.get() == 0:
self.edit_print("Качаем весь плейлист")
download_playlist(self.from_url.get(), self.to_url.get(),
self.audio_only.get())
elif self.download_type == 1:
self.edit_print("Качаем один файл")
download_song(self.from_url.get(), self.to_url.get(),
self.audio_only.get())
self.lock = False
def edit_print(self, text):
self.editArea.insert(END, text + "\n")
self.editArea.yview(END)
class Console(tk.Frame):
"""Simple console that can execute bash commands"""
def __init__(self, master, *args, **kwargs):
tk.Frame.__init__(self, master, *args, **kwargs)
self.text_options = {"state": "disabled",
"bg": "black",
"fg": "#08c614",
"insertbackground": "#08c614",
"selectbackground": "#f01c1c"}
self.text = ScrolledText(self, **self.text_options)
# It seems not to work when Text is disabled...
# self.text.bind("<<Modified>>", lambda: self.text.frame.see(tk.END))
self.text.pack(expand=True, fill="both")
# bash command, for example 'ping localhost' or 'pwd'
# that will be executed when "Execute" is pressed
self.command = ""
self.popen = None # will hold a reference to a Popen object
self.running = False # True if the process is running
self.bottom = tk.Frame(self)
self.prompt = tk.Label(self.bottom, text="Enter the command: ")
self.prompt.pack(side="left", fill="x")
self.entry = tk.Entry(self.bottom)
self.entry.bind("<Return>", self.start_thread)
self.entry.bind("<Command-a>", lambda e: self.entry.select_range(0, "end"))
self.entry.bind("<Command-c>", self.clear)
self.entry.focus()
self.entry.pack(side="left", fill="x", expand=True)
self.executer = tk.Button(self.bottom, text="Execute", command=self.start_thread)
self.executer.pack(side="left", padx=5, pady=2)
self.clearer = tk.Button(self.bottom, text="Clear", command=self.clear)
self.clearer.pack(side="left", padx=5, pady=2)
self.stopper = tk.Button(self.bottom, text="Stop", command=self.stop)
self.stopper.pack(side="left", padx=5, pady=2)
self.bottom.pack(side="bottom", fill="both")
def clear_text(self):
"""Clears the Text widget"""
self.text.config(state="normal")
self.text.delete(1.0, "end-1c")
self.text.config(state="disabled")
def clear_entry(self):
"""Clears the Entry command widget"""
self.entry.delete(0, "end")
def clear(self, event=None):
"""Does not stop an eventual running process,
but just clears the Text and Entry widgets."""
self.clear_entry()
self.clear_text()
def show(self, message):
"""Inserts message into the Text wiget"""
self.text.config(state="normal")
self.text.insert("end", message)
self.text.see("end")
self.text.config(state="disabled")
def start_thread(self, event=None):
"""Starts a new thread and calls process"""
self.stop()
self.running = True
self.command = self.entry.get()
# self.process is called by the Thread's run method
threading.Thread(target=self.process).start()
def process(self):
"""Runs in an infinite loop until self.running is False"""
while self.running:
self.execute()
def stop(self):
"""Stops an eventual running process"""
if self.popen:
try:
self.popen.kill()
except ProcessLookupError:
pass
self.running = False
def execute(self):
"""Keeps inserting line by line into self.text
the output of the execution of self.command"""
try:
# self.popen is a Popen object
self.popen = Popen(self.command.split(), stdout=PIPE, bufsize=1)
lines_iterator = iter(self.popen.stdout.readline, b"")
# poll() return None if the process has not terminated
# otherwise poll() returns the process's exit code
while self.popen.poll() is None:
for line in lines_iterator:
self.show(line.decode("utf-8"))
self.show("Process " + self.command + " terminated.\n\n")
except FileNotFoundError:
self.show("Unknown command: " + self.command + "\n\n")
except IndexError:
self.show("No command entered\n\n")
self.stop()
class ChatForm(tk.Frame):
font_color = "#000000"
font_size = 10
user_list = []
tag_i = 0
def remove_listener_and_close(self):
remove_message_listener(self.message_listener)
client.util.socket_listener.remove_listener(self.socket_listener)
self.master.destroy()
if self.target['id'] in client.memory.window_instance[self.target['type']]:
del client.memory.window_instance[self.target['type']][self.target['id']]
def message_listener(self, data):
self.digest_message(data)
def socket_listener(self, data):
if data['type'] == MessageType.query_room_users_result:
if data['parameters'][1] != self.target['id']:
return
# [id, nickname, online, username]
self.user_list = data['parameters'][0]
self.refresh_user_listbox()
if data['type'] == MessageType.room_user_on_off_line:
# [room_id, user_id, online]
if data['parameters'][0] != self.target['id']:
return
for i in range(0, len(self.user_list)):
if self.user_list[i][0] == data['parameters'][1]:
self.user_list[i][2] = data['parameters'][2]
self.refresh_user_listbox()
def refresh_user_listbox(self):
# [id, nickname, online, username]
self.user_listbox.delete(0, END)
self.user_list.sort(key=lambda x: x[2])
for user in self.user_list:
self.user_listbox.insert(0, user[1] + ("(在线)" if user[2] else "(离线)"))
self.user_listbox.itemconfig(0, {'fg': ("green" if user[2] else "#999")})
def digest_message(self, data):
time = datetime.datetime.fromtimestamp(
int(data['time']) / 1000
).strftime('%Y-%m-%d %H:%M:%S')
self.append_to_chat_box(data['sender_name'] + " " + time + '\n',
('me' if client.memory.current_user['id'] == data[
'sender_id'] else 'them'))
# type 0 - 文字消息 1 - 图片消息
if data['message']['type'] == 0:
self.tag_i += 1
self.chat_box.tag_config('new' + str(self.tag_i),
lmargin1=16,
lmargin2=16,
foreground=data['message']['fontcolor'],
font=(None, data['message']['fontsize']))
self.append_to_chat_box(data['message']['data'] + '\n',
'new' + str(self.tag_i))
if data['message']['type'] == 1:
client.memory.tk_img_ref.append(ImageTk.PhotoImage(data=data['message']['data']))
self.chat_box.image_create(END, image=client.memory.tk_img_ref[-1], padx=16, pady=5)
self.append_to_chat_box('\n', '')
def user_listbox_double_click(self, _):
if len(self.user_listbox.curselection()) == 0:
return None
index = self.user_listbox.curselection()[0]
selected_user_id = self.user_list[len(self.user_list) - 1 - index][0]
selected_user_nickname = self.user_list[len(self.user_list) - 1 - index][1]
selected_user_username = self.user_list[len(self.user_list) - 1 - index][3]
if selected_user_id == client.memory.current_user['id']:
return
client.memory.contact_window[0].try_open_user_id(selected_user_id, selected_user_nickname,
selected_user_username)
# pprint(selected_user_id)
return
def __init__(self, target, master=None):
super().__init__(master)
self.master = master
self.target = target
self.user_listbox = tk.Listbox(self, bg='#EEE')
client.util.socket_listener.add_listener(self.socket_listener)
client.memory.unread_message_count[self.target['type']][self.target['id']] = 0
client.memory.contact_window[0].refresh_contacts()
master.resizable(width=True, height=True)
master.geometry('660x500')
master.minsize(520, 370)
self.sc = client.memory.sc
if self.target['type'] == 0:
self.master.title(self.target['nickname'])
if self.target['type'] == 1:
self.master.title("群:" + str(self.target['id']) + " " + self.target['room_name'])
self.sc.send(MessageType.query_room_users, self.target['id'])
self.right_frame = tk.Frame(self, bg='white')
self.user_listbox.bind('<Double-Button-1>', self.user_listbox_double_click)
if self.target['type'] == 1:
self.user_listbox.pack(side=LEFT, expand=False, fill=BOTH)
self.right_frame.pack(side=LEFT, expand=True, fill=BOTH)
self.input_frame = tk.Frame(self.right_frame, bg='white')
self.input_textbox = ScrolledText(self.right_frame, height=10)
self.input_textbox.bind("<Control-Return>", self.send_message)
self.input_textbox.bind_all('<Key>', self.apply_font_change)
self.send_btn = tk.Button(self.input_frame, text='发送消息(Ctrl+Enter)', command=self.send_message)
self.send_btn.pack(side=RIGHT, expand=False)
self.font_btn = tk.Button(self.input_frame, text='字体颜色', command=self.choose_color)
self.font_btn.pack(side=LEFT, expand=False)
self.font_btn = tk.Button(self.input_frame, text='字体大小', command=self.choose_font_size)
self.font_btn.pack(side=LEFT, expand=False)
self.image_btn = tk.Button(self.input_frame, text='发送图片', command=self.send_image)
self.image_btn.pack(side=LEFT, expand=False)
self.chat_box = ScrolledText(self.right_frame, bg='white')
self.input_frame.pack(side=BOTTOM, fill=X, expand=False)
self.input_textbox.pack(side=BOTTOM, fill=X, expand=False, padx=(0, 0), pady=(0, 0))
self.chat_box.pack(side=BOTTOM, fill=BOTH, expand=True)
self.chat_box.bind("<Key>", lambda e: "break")
self.chat_box.tag_config("default", lmargin1=10, lmargin2=10, rmargin=10)
self.chat_box.tag_config("me", foreground="green", spacing1='5')
self.chat_box.tag_config("them", foreground="blue", spacing1='5')
self.chat_box.tag_config("message", foreground="black", spacing1='0')
self.chat_box.tag_config("system", foreground="grey", spacing1='0',
justify='center',
font=(None, 8))
self.pack(expand=True, fill=BOTH)
add_message_listener(self.target['type'], self.target['id'], self.message_listener)
master.protocol("WM_DELETE_WINDOW", self.remove_listener_and_close)
# 历史消息显示
if target['id'] in client.memory.chat_history[self.target['type']]:
for msg in client.memory.chat_history[self.target['type']][target['id']]:
self.digest_message(msg)
self.append_to_chat_box('- 以上是历史消息 -\n', 'system')
def append_to_chat_box(self, message, tags):
self.chat_box.insert(tk.END, message, [tags, 'default'])
self.chat_box.update()
self.chat_box.see(tk.END)
def send_message(self, _=None):
message = self.input_textbox.get("1.0", END)
if not message or message.replace(" ", "").replace("\r", "").replace("\n", "") == '':
return
self.sc.send(MessageType.send_message,
{'target_type': self.target['type'], 'target_id': self.target['id'],
'message': {
'type': 0,
'data': message.strip().strip('\n'),
'fontsize': self.font_size,
'fontcolor': self.font_color
}
})
self.input_textbox.delete("1.0", END)
return 'break'
def choose_color(self):
_, self.font_color = colorchooser.askcolor(initialcolor=self.font_color)
self.apply_font_change(None)
def choose_font_size(self):
result = simpledialog.askinteger("设置", "请输入字体大小", initialvalue=self.font_size)
if result is None:
return
self.font_size = result
self.apply_font_change(None)
def apply_font_change(self, _):
try:
self.input_textbox.tag_config('new', foreground=self.font_color, font=(None, self.font_size))
self.input_textbox.tag_add('new', '1.0', END)
except:
pass
def send_image(self):
filename = filedialog.askopenfilename(filetypes=[("Image Files",
["*.jpg", "*.jpeg", "*.png", "*.gif", "*.JPG", "*.JPEG",
"*.PNG", "*.GIF"]),
("All Files", ["*.*"])])
if filename is None or filename == '':
return
with open(filename, "rb") as imageFile:
f = imageFile.read()
b = bytearray(f)
self.sc.send(MessageType.send_message,
{'target_type': self.target['type'], 'target_id': self.target['id'],
'message': {'type': 1, 'data': b}})
# prepare re
input_text = entry.get()
target_re = re.compile(input_text)
# get scrolled text's all text
src_text = text.get("1.0", END)
lines = src_text.splitlines()
for i, line in enumerate(lines):
for mo in target_re.finditer(line):
text.tag_add('found', f"{i+1}.{mo.span()[0]}",
f"{i+1}.{mo.span()[1]}")
print(mo)
pass
button = Button(input_frame, text="Find", command=find, takefocus=False)
button.pack(side=RIGHT)
# text
text = ScrolledText(height=30, font=("Consolas", 11))
text.insert(END, wiki_python)
text.pack(side=BOTTOM, fill=X)
def stop(event=None):
window.quit()
window.bind("<Escape>", stop)
window.mainloop()
def call_results(number3):
txt2 = ScrolledText(window, width=40, height=7, font=("Arial", 12))
txt2.place(x=75, y=650)
try:
if flag1001 == 0:
messagebox.showinfo('ERROR 404',
'Please add documents to preprocess')
return
except:
messagebox.showinfo('ERROR 404', 'Please add documents to preprocess')
return
str2 = number3.get()
print(str2)
if str2 == "":
str2 = str(0)
elif str2[0] == '-':
messagebox.showinfo('ERROR 404', 'Give a correct lower bound')
elif str2[len(str2) - 1] == '%':
str2 = str2[0:len(str2) - 1]
try:
if not (float(str2) >= 0 and float(str2) <= 100):
messagebox.showinfo('ERROR 404', 'Give a correct upper bound')
return
except:
messagebox.showinfo('ERROR 404', 'Give a correct upper bound')
return
string = txt3.get('1.0', tk.END)
text = string.lower()
text = text.replace("\n", " ")
token_orignal = word_tokenize(text)
spell_check = SpellCheck(token_orignal)
text1 = spell_check.text
if text != text1:
messagebox.showinfo(
'Did u Mean',
'After correcting some spelling errors the text becomes:-\n' +
text1)
docx = Document(text1, flag=False)
res = mycorpus.cosineSimilarity(docx)
if res is None:
messagebox.showinfo(
'NO MATCH',
"The given text doesn't match with anything based on non stopwords words."
)
return None
res = res.reshape(-1)
docorder = np.argsort(res)
docorder = np.flip(docorder)
answer = str()
for x in docorder:
if (round(100 * res[x], 4)) < float(str2):
break
answer += mycorpus.doclist[x].name + " has " + str(
str(round(100 * res[x], 4))) + "% plagiarism.\n"
#print(answer)
print(answer)
txt2.insert(tk.END, answer)
txt2.config(state='disabled')
def call_result(number1, number2, flag=0):
try:
if flag1001 == 0:
messagebox.showinfo('ERROR 404',
'Please add documents to preprocess')
return
except:
messagebox.showinfo('ERROR 404', 'Please add documents to preprocess')
return
#print("the content vector started at " + str(time.time()))
txt2 = ScrolledText(window, width=40, height=11, font=("Arial", 12))
txt2.place(x=75, y=270)
str1 = 'business/' + number1.get()
str2 = number2.get()
if str2 == "":
str2 = str(0)
elif str2[0] == '-':
messagebox.showinfo('ERROR 404', 'Give a correct upper bound')
elif str2[len(str2) - 1] == '%':
str2 = str2[0:len(str2) - 1]
try:
print(float(str2))
if not (float(str2) >= 0 and float(str2) <= 100):
messagebox.showinfo('ERROR 404', 'Give a correct upper bound')
return
except:
messagebox.showinfo('ERROR 404', 'Give a correct upper bound')
return
docx = None
if mycorpus.getDocInd(number1.get()):
flag = 1
docx = Document(str1)
# str2 me percentage hai plagrisam ka
if docx != None:
with open('filename.pickle', 'rb+') as handle:
unserialized_data = pickle.load(handle)
list1 = docx.tokens
list1.append(str2)
if tuple(list1) in unserialized_data:
txt2.insert(tk.END, unserialized_data[tuple(docx.tokens)])
txt2.config(state='disabled')
print("inside cache")
print(time.time())
elif flag == 0:
messagebox.showinfo(
'ERROR 404',
'The given Document is not available in the given Corpus')
elif flag == 1:
cache = dict()
res = mycorpus.cosineSimilarity(docx).reshape(-1)
docorder = np.argsort(res)
docorder = np.flip(docorder)
answer = str()
lim = 0
for x in docorder:
if (round(100 * res[x], 4)) < float(str2):
break
answer += mycorpus.doclist[x].name + " has " + str(
str(round(100 * res[x], 4))) + "% plagiarism.\n"
cache[tuple(list1)] = answer
with open('filename.pickle', 'rb+') as handle:
un = pickle.load(handle)
un.update(cache)
with open('filename.pickle', 'wb') as handle:
pickle.dump(un, handle, protocol=pickle.HIGHEST_PROTOCOL)
#print(answer)
txt2.insert(tk.END, answer)
txt2.config(state='disabled')
else:
str1 = number1.get()
docx = Document(str1)
res = mycorpus.cosineSimilarity(docx).reshape(-1)
docorder = np.argsort(res)
docorder = np.flip(docorder)
list1 = docx.tokens
list1.append(str2)
with open('filename.pickle', 'rb+') as handle:
unserialized_data = pickle.load(handle)
if tuple(list1) in unserialized_data:
txt2.insert(tk.END, unserialized_data[tuple(docx.tokens)])
txt2.config(state='disabled')
print("inside cache")
return
answer = str()
lim = 0
for x in docorder:
if (round(100 * res[x], 4)) < float(str2):
break
answer += mycorpus.doclist[x].name + " has " + str(
str(round(100 * res[x], 4))) + "% plagiarism.\n"
# print(answer)
cache = {}
cache[tuple(list1)] = answer
with open('filename.pickle', 'rb+') as handle:
un = pickle.load(handle)
un.update(cache)
with open('filename.pickle', 'wb') as handle:
pickle.dump(un, handle, protocol=pickle.HIGHEST_PROTOCOL)
txt2.insert(tk.END, answer)
txt2.config(state='disabled')
print("the content ended at started at " + str(time.time()))
class ClassConfigDialog(Dialog):
errormessage = "Not true format."
def __init__(self, title, prompt=None, initialvalue=None, parent=None):
if not parent:
parent = tk._default_root
self.prompt = prompt
self.initialvalue = initialvalue
Dialog.__init__(self, parent, title)
def destroy(self):
self.entry = None
Dialog.destroy(self)
def body(self, master):
l_prompt = tk.Label(master, text=self.prompt, anchor="w")
l_prompt.pack(side="top", fill="x")
self.t_input_text = ScrolledText(master, name="text", height=10)
self.t_input_text.pack(fill="both", expand=True)
if self.initialvalue is not None:
for classname, classvalue in self.initialvalue:
self.t_input_text.insert(tk.END,
"%s %s\n" % (classname, classvalue))
return self.t_input_text
def buttonbox(self):
box = tk.Frame(self)
w = tk.Button(box, text="OK", width=10, command=self.ok)
w.pack(side="left", padx=5, pady=5)
w = tk.Button(box, text="Cancel", width=10, command=self.cancel)
w.pack(side="left", padx=5, pady=5)
# self.bind("<Return>", self.ok)
self.bind("<Escape>", self.cancel)
box.pack(side="bottom")
def validate(self):
try:
result = self.getresult()
except ValueError:
tkMessagebox.showwarning("Illegal value",
self.errormessage + "\nPlease try again",
parent=self)
return 0
self.result = result
return 1
def getresult(self):
results = []
value = self.t_input_text.get('0.0', tk.END)
lines = value.strip().split("\n")
for line in lines:
if line == "":
continue
try:
classname, classid = line.strip().split(" ")
results.append((classname, classid))
except:
raise ValueError
return results
def create_tkinter_gui(tests, command_string):
root = tk.Tk()
root.title("SeleniumBase Commander | GUI for pytest")
root.minsize(820, 645)
tk.Label(root, text="").pack()
options_list = [
"Use Chrome Browser (Default)",
"Use Edge Browser (--edge)",
"Use Firefox Browser (--firefox)",
]
if "darwin" in sys.platform:
options_list.append("Use Safari Browser (--safari)")
brx = tk.StringVar(root)
brx.set(options_list[0])
question_menu = tk.OptionMenu(root, brx, *options_list)
question_menu.pack()
options_list = [
"New Session Per Test (Default)",
"Reuse Session for all tests in thread (--rs)",
"Reuse Session / clear cookies (--rs --crumbs)",
]
rsx = tk.StringVar(root)
rsx.set(options_list[2])
question_menu = tk.OptionMenu(root, rsx, *options_list)
question_menu.pack()
options_list = [
"Number of Threads: 1 (Default)",
"Number of Threads: 2 (-n=2)",
"Number of Threads: 3 (-n=3)",
"Number of Threads: 4 (-n=4)",
]
ntx = tk.StringVar(root)
ntx.set(options_list[0])
question_menu = tk.OptionMenu(root, ntx, *options_list)
question_menu.pack()
vox = tk.IntVar()
chk = tk.Checkbutton(root, text="Verbose Output (-v)", variable=vox)
chk.pack()
chk.select()
dmx = tk.IntVar()
chk = tk.Checkbutton(root, text="Demo Mode (--demo)", variable=dmx)
chk.pack()
mmx = tk.IntVar()
chk = tk.Checkbutton(root, text="Mobile Mode (--mobile)", variable=mmx)
chk.pack()
dbx = tk.IntVar()
chk = tk.Checkbutton(root, text="Dashboard (--dashboard)", variable=dbx)
chk.pack()
chk.select()
hrx = tk.IntVar()
chk = tk.Checkbutton(root,
text="Report (--html=report.html)",
variable=hrx)
chk.pack()
chk.select()
hbx = tk.IntVar()
chk = tk.Checkbutton(root,
text="Headless Browser (--headless)",
variable=hbx)
chk.pack()
ssx = tk.IntVar()
chk = tk.Checkbutton(root,
text="Save Screenshots (--screenshot)",
variable=ssx)
chk.pack()
tk.Label(root, text="").pack()
run_display = ("Select from %s tests: "
"(If NO TESTS are selected, then ALL TESTS will be run)" %
len(tests))
if len(tests) == 1:
run_display = "Only ONE TEST was found: (Will be run automatically)"
tk.Label(root, text=run_display, fg="blue").pack()
text_area = ScrolledText(root,
width=100,
height=12,
wrap="word",
state=tk.DISABLED)
text_area.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
count = 0
ara = {}
for row in tests:
row += " " * 200
ara[count] = tk.IntVar()
cb = tk.Checkbutton(
text_area,
text=(row),
bg='white',
anchor='w',
variable=ara[count],
)
text_area.window_create('end', window=cb)
text_area.insert('end', '\n')
count += 1
tk.Label(root, text="").pack()
additional_options = ""
aopts = tk.StringVar(value=additional_options)
tk.Label(
root,
text='Additional pytest Options: (space-separated)',
fg="blue",
).pack()
entry = tk.Entry(root, textvariable=aopts)
entry.pack()
entry.focus()
entry.bind(
"<Return>",
(lambda _: do_pytest_run(
root,
tests,
ara,
command_string,
brx.get(),
rsx.get(),
ntx.get(),
vox.get(),
dmx.get(),
mmx.get(),
dbx.get(),
hrx.get(),
hbx.get(),
ssx.get(),
aopts.get(),
)),
)
tk.Button(
root,
text="Run Selected Tests",
fg="green",
command=lambda: do_pytest_run(
root,
tests,
ara,
command_string,
brx.get(),
rsx.get(),
ntx.get(),
vox.get(),
dmx.get(),
mmx.get(),
dbx.get(),
hrx.get(),
hbx.get(),
ssx.get(),
aopts.get(),
),
).pack()
tk.Label(root, text="\n").pack()
# Bring form window to front
send_window_to_front(root)
# Use decoy to set correct focus on main window
decoy = tk.Tk()
decoy.geometry("1x1")
decoy.iconify()
decoy.update()
decoy.deiconify()
decoy.destroy()
# Start tkinter
root.mainloop()
class Principal():
def __init__(self, janela):
# Funções do menu
def Sair():
self.janela.destroy()
# Configurações do menu
self.janela = janela
self.janela = janela
self.menubar = Menu(self.janela)
self.janela.config(menu=self.menubar)
self.Menu_1 = Menu(self.menubar)
self.Menu_2 = Menu(self.menubar)
self.Menu_3 = Menu(self.menubar)
self.menubar.add_cascade(label='Janela', menu=self.Menu_1)
self.menubar.add_cascade(label='Arquivo', menu=self.Menu_2)
self.Menu_1.add_command(label='Sair', command=Sair)
self.Menu_2.add_command(label='Abrir', command=self.NovoArquivo)
self.Menu_2.add_command(label='Salvar')
self.Menu_2.add_command(label='Adicionar pasta', command=self.AdicionarPasta)
# Corpo do programa
self.TituloUm = Label(self.janela, text='Selecione o arquivo ou diretorio:')
self.EntradaLocal = ScrolledText(self.janela, relief='solid')
self.EntradaLocal.focus()
self.BotaoSelecionar = Button(self.janela, text='...', borderwidth='0.5', relief='solid', command=self.NovoArquivo)
self.BotaoProcessar = Button(self.janela, text='Processar arquivos', bg='#008000', fg='#fff', borderwidth='0.5', relief='solid', command=lambda : self.ProcessarTexto(self.EntradaLocal))
# Posição dos widgets
self.TituloUm.place(x=5,y=0, width=170, height=30)
self.EntradaLocal.place(x=5,y=30, width=550, height=50)
self.BotaoSelecionar.place(x=555,y=30,width=55, height=50)
self.BotaoProcessar.place(x=660,y=5,width=120, height=30)
self.janela.mainloop()
def NovoArquivo(self):
self.EntradaLocal.delete('1.0',END)
self.LocalArquivo = filedialog.askopenfilename(initialdir = "o:/captura/",title = "Informe o arquivo PDF do Edital",filetypes = (("Arquivos PDF","*.pdf"),("Todos os Arquivos","*.*")))
self.EntradaLocal.insert(END,self.LocalArquivo + '\n')
def AdicionarPasta(self):
self.LocalPasta = filedialog.askdirectory()
Arquivos = os.listdir(self.LocalPasta)
for Arquivo in Arquivos:
self.EntradaLocal.insert(END,self.LocalPasta + '/' + Arquivo + '\n')
def ProcessarTexto(self,Local):
self.Local = Local
TextoPDF = PegarTexto(self.Local)
for Paginas in TextoPDF:
processado = open('Resultado\\'+NomeArquivo+'.txt', 'a')
#Decomentar somente quando querer os dados em um só arquivo
#processado = open('Resultado\\Resultado.txt', 'a')
processado.write(str(NomeArquivo)+str(Paginas))
processado.close()
def ProcessarImagens(self):
ExtrairImagens(self.Local)
class Application(ttk.Frame):
lbl = [None] * 20
ent = [None] * 20
btnSet = [None] * 20
btnDec = [None] * 20
btnInc = [None] * 20
ID_ENGINERPM = 1
ID_VEHICLESPEED = 2
ID_THROTTLEPOSITION = 3
ID_FUELLEVELINPUT = 4
ID_ENGINEFUELRATE = 5
ID_MAFAIRFLOWRATE = 6
ID_CALCULATEDENGINELOAD = 7
paramValue = [None] * 20
paramValue[ID_ENGINERPM] = 0
paramValue[ID_VEHICLESPEED] = 0
paramValue[ID_THROTTLEPOSITION] = 0
paramValue[ID_FUELLEVELINPUT] = 0
paramValue[ID_ENGINEFUELRATE] = 0
paramValue[ID_MAFAIRFLOWRATE] = 0
paramValue[ID_CALCULATEDENGINELOAD] = 0
SET = 1
INC = 2
DEC = 3
def paramControl(self, index, label, callback, callbackDecParameter,
callbackIncParameter, row, column):
log.output("Label = " + label)
self.label = label
self.callback = callback
# Parameter Label
self.lbl[index] = ttk.Label(self.frmParameters, style="Bold.TLabel")
self.lbl[index]["text"] = self.label
self.lbl[index].grid(sticky="W", row=row, column=column)
# Parameter Decrement Button
self.btnDec[index] = ttk.Button(self.frmParameters,
style="Bold1.TButton")
self.btnDec[index]["text"] = "-"
self.btnDec[index]["command"] = callbackDecParameter
self.btnDec[index].grid(sticky="E", row=row, column=column + 2)
# Parameter Entry
self.ent[index] = ttk.Entry(self.frmParameters,
validate="focusout",
validatecommand=callback)
self.ent[index].grid(sticky="NSWE",
row=row,
column=column + 3,
columnspan=2)
# Parameter Increment Button
self.btnInc[index] = ttk.Button(self.frmParameters,
style="Bold1.TButton")
self.btnInc[index]["text"] = "+"
self.btnInc[index]["command"] = callbackIncParameter
self.btnInc[index].grid(sticky="W", row=row, column=column + 5)
# Parameter Setting Apply Button
self.btnSet[index] = ttk.Button(self.frmParameters)
self.btnSet[index]["text"] = "Apply"
self.btnSet[index]["command"] = callback
self.btnSet[index].grid(row=row,
column=column + 6,
sticky=N + S + E + W)
def initialiseParams(self):
for i in range(self.ID_ENGINERPM, self.ID_CALCULATEDENGINELOAD + 1):
self.ent[i].insert(0, self.paramValue[i])
log.output("")
def connectDevice(self):
connectedStatus, portPath = self.device.connectDevice(self)
if connectedStatus == True:
self.lblStatus["text"] = "Status: Connected [" + portPath + "]"
self.lblStatus.configure(style="Green.TLabel")
self.btnConnectDevice["state"] = "disabled"
self.btnDisconnect["state"] = "normal"
def closeDevice(self):
self.device.closeConnection(self)
self.lblStatus["text"] = "Status: Disconnected"
self.lblStatus.configure(style="Red.TLabel")
self.btnConnectDevice["state"] = "normal"
self.btnDisconnect["state"] = "disabled"
def cmdLogging(self):
if self.loggingstate.get() == 1:
log.level(1)
self.lblLogHeading["text"] = "Log Output (Logging enabled)"
else:
log.level(0)
self.lblLogHeading["text"] = "Log Output (Logging disabled)"
def cmdIncreaseEngineRPM(self):
self.cmdSetEngineRPM(self.INC)
def cmdDecreaseEngineRPM(self):
self.cmdSetEngineRPM(self.DEC)
def cmdSetEngineRPM(self, mode=SET):
rpm = int(self.ent[self.ID_ENGINERPM].get(), base=10)
if mode == self.SET:
self.device.setEngineRPM(self, rpm)
if mode == self.INC:
rpm = rpm + 1
self.device.setEngineRPM(self, rpm)
self.ent[self.ID_ENGINERPM].delete(0, END)
self.ent[self.ID_ENGINERPM].insert(0, rpm)
if mode == self.DEC:
rpm = rpm - 1
self.device.setEngineRPM(self, rpm)
self.ent[self.ID_ENGINERPM].delete(0, END)
self.ent[self.ID_ENGINERPM].insert(0, rpm)
def cmdIncreaseVehicleSpeed(self):
self.cmdSetVehicleSpeed(self.INC)
def cmdDecreaseVehicleSpeed(self):
self.cmdSetVehicleSpeed(self.DEC)
def cmdSetVehicleSpeed(self, mode=SET):
speed = int(self.ent[self.ID_VEHICLESPEED].get(), base=10)
if mode == self.INC:
speed = speed + 1
self.ent[self.ID_VEHICLESPEED].delete(0, END)
self.ent[self.ID_VEHICLESPEED].insert(0, speed)
if mode == self.DEC:
speed = speed - 1
self.ent[self.ID_VEHICLESPEED].delete(0, END)
self.ent[self.ID_VEHICLESPEED].insert(0, speed)
self.device.setVehicleSpeed(self, speed)
def cmdIncreaseThrottlePosition(self):
self.cmdSetThrottlePosition(self.INC)
def cmdDecreaseThrottlePosition(self):
self.cmdSetThrottlePosition(self.DEC)
def cmdSetThrottlePosition(self, mode=SET):
throttle = int(self.ent[self.ID_THROTTLEPOSITION].get(), base=10)
if mode == self.INC:
throttle = throttle + 1
self.ent[self.ID_THROTTLEPOSITION].delete(0, END)
self.ent[self.ID_THROTTLEPOSITION].insert(0, throttle)
if mode == self.DEC:
throttle = throttle - 1
self.ent[self.ID_THROTTLEPOSITION].delete(0, END)
self.ent[self.ID_THROTTLEPOSITION].insert(0, throttle)
self.device.setThrottlePosition(self, throttle)
def cmdIncreaseFuelLevelInput(self):
self.cmdSetFuelLevelInput(self.INC)
def cmdDecreaseFuelLevelInput(self):
self.cmdSetFuelLevelInput(self.DEC)
def cmdSetFuelLevelInput(self, mode=SET):
level = int(self.ent[self.ID_FUELLEVELINPUT].get(), base=10)
if mode == self.INC:
level = level + 1
self.ent[self.ID_FUELLEVELINPUT].delete(0, END)
self.ent[self.ID_FUELLEVELINPUT].insert(0, level)
if mode == self.DEC:
level = level - 1
self.ent[self.ID_FUELLEVELINPUT].delete(0, END)
self.ent[self.ID_FUELLEVELINPUT].insert(0, level)
self.device.setFuelLevelInput(self, level)
def cmdIncreaseEngineFuelRate(self):
self.cmdSetEngineFuelRate(self.INC)
def cmdDecreaseEngineFuelRate(self):
self.cmdSetEngineFuelRate(self.DEC)
def cmdSetEngineFuelRate(self, mode=SET):
rate = int(self.ent[self.ID_ENGINEFUELRATE].get(), base=10)
if mode == self.INC:
rate = rate + 1
self.ent[self.ID_ENGINEFUELRATE].delete(0, END)
self.ent[self.ID_ENGINEFUELRATE].insert(0, rate)
if mode == self.DEC:
rate = rate - 1
self.ent[self.ID_ENGINEFUELRATE].delete(0, END)
self.ent[self.ID_ENGINEFUELRATE].insert(0, rate)
self.device.setEngineFuelRate(self, rate)
def cmdIncreaseMAFAirFlowRate(self):
self.cmdSetMAFAirFlowRate(self.INC)
def cmdDecreaseMAFAirFlowRate(self):
self.cmdSetMAFAirFlowRate(self.DEC)
def cmdSetMAFAirFlowRate(self, mode=SET):
rate = int(self.ent[self.ID_MAFAIRFLOWRATE].get(), base=10)
if mode == self.INC:
rate = rate + 1
self.ent[self.ID_MAFAIRFLOWRATE].delete(0, END)
self.ent[self.ID_MAFAIRFLOWRATE].insert(0, rate)
if mode == self.DEC:
rate = rate - 1
self.ent[self.ID_MAFAIRFLOWRATE].delete(0, END)
self.ent[self.ID_MAFAIRFLOWRATE].insert(0, rate)
self.device.setMAFAirFlowRate(self, rate)
def cmdIncreaseCalculatedEngineLoad(self):
self.cmdSetCalculatedEngineLoad(self.INC)
def cmdDecreaseCalculatedEngineLoad(self):
self.cmdSetCalculatedEngineLoad(self.DEC)
def cmdSetCalculatedEngineLoad(self, mode=SET):
load = int(self.ent[self.ID_CALCULATEDENGINELOAD].get(), base=10)
if mode == self.INC:
load = load + 1
self.ent[self.ID_CALCULATEDENGINELOAD].delete(0, END)
self.ent[self.ID_CALCULATEDENGINELOAD].insert(0, load)
if mode == self.DEC:
load = load - 1
self.ent[self.ID_CALCULATEDENGINELOAD].delete(0, END)
self.ent[self.ID_CALCULATEDENGINELOAD].insert(0, load)
self.device.setCalculatedEngineLoad(self, load)
def cmdIncByPID(self):
self.cmdSetByPID(self.INC)
def cmdDecByPID(self):
self.cmdSetByPID(self.DEC)
def cmdSetByPID(self, mode=SET):
pid = self.entPID.get()
pidValue = int(self.entPIDValue.get(), base=10)
if mode == self.INC:
pidValue = pidValue + 1
self.entPIDValue.delete(0, END)
self.entPIDValue.insert(0, pidValue)
if mode == self.DEC:
pidValue = pidValue - 1
self.entPIDValue.delete(0, END)
self.entPIDValue.insert(0, pidValue)
self.device.setPIDValue(self, pid, pidValue)
###pid = self.entPID.get()
###pidValue = self.entPIDValue.get()
log.output("PID = " + pid)
log.output("PID Value= " + str(pidValue))
def cmdTest(self):
log.output("test")
obd.main()
def callback(self):
log.output("Callback!")
############################################################
# createWidgets
#
def createWidgets(self):
self.loggingstate = tk.IntVar()
boldText = ttk.Style()
boldText.configure("Bold.TLabel", font=('Sans', '12', 'bold'))
labelGreenStyle = ttk.Style()
labelGreenStyle.configure("Green.TLabel", foreground='forest green')
labelRedStyle = ttk.Style()
labelRedStyle.configure("Red.TLabel", foreground='red')
heading1Style = ttk.Style()
heading1Style.configure("Heading1.TLabel",
font=('Sans', '20', 'bold'),
background='royal blue')
frameStyle = ttk.Style()
frameStyle.configure("Blue.TFrame", background='royal blue')
self.frmHeading = ttk.Frame(self.frmApp, style="Blue.TFrame")
self.frmHeading.grid(row=0,
column=0,
rowspan=1,
columnspan=6,
sticky=N + S + E + W)
self.lblHeading = ttk.Label(self.frmHeading, style="Heading1.TLabel")
self.lblHeading["text"] = "OBD-II Emulator Control"
self.lblHeading.grid(row=0, column=0, sticky=N + S + E + W)
self.frmDeviceConnection = ttk.Frame(self.frmApp, relief=SUNKEN)
self.frmDeviceConnection.grid(row=1,
column=0,
columnspan=4,
sticky=N + S + E + W)
self.btnConnectDevice = ttk.Button(self.frmDeviceConnection)
self.btnConnectDevice["text"] = "Connect Device"
self.btnConnectDevice["command"] = self.connectDevice
self.btnConnectDevice.grid(row=1, column=1, sticky=N + S + E + W)
self.btnDisconnect = ttk.Button(self.frmDeviceConnection)
self.btnDisconnect["text"] = "Disconnect Device"
self.btnDisconnect["command"] = self.closeDevice
self.btnDisconnect.grid(row=1, column=2, sticky=N + S + E + W)
self.lblStatus = ttk.Label(self.frmDeviceConnection)
self.lblStatus.configure(style="Red.TLabel")
self.lblStatus["text"] = "Status: Disconnected"
self.lblStatus.grid(sticky="W", row=1, column=3)
self.chkLogging = ttk.Checkbutton(self.frmApp,
variable=self.loggingstate)
self.chkLogging["text"] = "Logging"
self.chkLogging["command"] = self.cmdLogging
self.chkLogging.grid(row=1, column=4, sticky=N + S + E + W)
self.btnQuit = ttk.Button(self.frmApp)
self.btnQuit["text"] = "QUIT"
self.btnQuit["command"] = ask_quit
self.btnQuit.grid(row=1, column=5, sticky=N + S + E + W)
self.lblProtocol = ttk.Label(self.frmApp)
self.lblProtocol["text"] = "Protocol: ----"
self.lblProtocol.grid(sticky="W", row=2, column=1)
self.frmParameters = ttk.Frame(self.frmApp, relief=SUNKEN)
self.frmParameters.grid(row=3, column=0, columnspan=6, rowspan=10)
self.paramControl(self.ID_ENGINERPM, "Engine RPM",
self.cmdSetEngineRPM, self.cmdDecreaseEngineRPM,
self.cmdIncreaseEngineRPM, 1, 1)
self.paramControl(self.ID_VEHICLESPEED, "Vehicle Speed",
self.cmdSetVehicleSpeed,
self.cmdDecreaseVehicleSpeed,
self.cmdIncreaseVehicleSpeed, 2, 1)
self.paramControl(self.ID_THROTTLEPOSITION, "Throttle",
self.cmdSetThrottlePosition,
self.cmdDecreaseThrottlePosition,
self.cmdIncreaseThrottlePosition, 3, 1)
self.paramControl(self.ID_FUELLEVELINPUT, "Fuel Level Input",
self.cmdSetFuelLevelInput,
self.cmdDecreaseFuelLevelInput,
self.cmdIncreaseFuelLevelInput, 4, 1)
self.paramControl(self.ID_ENGINEFUELRATE, "Engine Fuel Rate",
self.cmdSetEngineFuelRate,
self.cmdDecreaseEngineFuelRate,
self.cmdIncreaseEngineFuelRate, 5, 1)
self.paramControl(self.ID_MAFAIRFLOWRATE, "MAF Air Flow Rate",
self.cmdSetMAFAirFlowRate,
self.cmdDecreaseMAFAirFlowRate,
self.cmdIncreaseMAFAirFlowRate, 6, 1)
self.paramControl(self.ID_CALCULATEDENGINELOAD,
"Calculated Engine Load",
self.cmdSetCalculatedEngineLoad,
self.cmdDecreaseCalculatedEngineLoad,
self.cmdIncreaseCalculatedEngineLoad, 7, 1)
self.lblVIN = ttk.Label(self.frmParameters, style="Bold.TLabel")
self.lblVIN["text"] = "VIN"
self.lblVIN.grid(sticky="W", row=0, column=1)
self.entVIN = ttk.Entry(
self.frmParameters
) #, validate="focusout", validatecommand=cmdVIN)
self.entVIN.grid(sticky="NSWE", row=0, column=2, columnspan=4)
self.btnVIN = ttk.Button(self.frmParameters)
self.btnVIN["text"] = "Apply"
self.btnVIN.grid(row=0, column=7)
self.lblPID = ttk.Label(self.frmParameters, style="Bold.TLabel")
self.lblPID["text"] = "PID"
self.lblPID.grid(sticky="W", row=8, column=1)
self.entPID = ttk.Entry(self.frmParameters)
self.entPID.grid(sticky="NSWE", row=8, column=2)
self.btnPIDValueDec = ttk.Button(self.frmParameters,
style="Bold1.TButton")
self.btnPIDValueDec["text"] = "-"
self.btnPIDValueDec["command"] = self.cmdDecByPID
self.btnPIDValueDec.grid(sticky="E", row=8, column=3)
self.entPIDValue = ttk.Entry(self.frmParameters)
self.entPIDValue.grid(sticky="NSWE", row=8, column=4, columnspan=2)
self.btnPIDValueInc = ttk.Button(self.frmParameters,
style="Bold1.TButton")
self.btnPIDValueInc["text"] = "+"
self.btnPIDValueInc["command"] = self.cmdIncByPID
self.btnPIDValueInc.grid(sticky="W", row=8, column=6)
self.btnPIDValueApply = ttk.Button(self.frmParameters)
self.btnPIDValueApply["text"] = "Apply"
self.btnPIDValueApply["command"] = self.cmdSetByPID
self.btnPIDValueApply.grid(row=8, column=7, sticky=N + S + E + W)
self.frmLogOutput = ttk.Frame(self.frmApp)
self.frmLogOutput.grid(row=13,
column=0,
rowspan=2,
columnspan=6,
sticky=N + S + E + W)
self.lblLogHeading = ttk.Label(self.frmLogOutput)
self.lblLogHeading["text"] = "Log Output (Logging disabled)"
self.lblLogHeading.grid(row=0, column=0, sticky=N + S + E + W)
self.txtLogText = ScrolledText(self.frmLogOutput, height=10, width=120)
self.txtLogText.grid(row=1, column=0, sticky=N + S + E + W)
#self.writeLogText("Test message\n")
#self.txtLogText.insert(INSERT, "Test message")
#self.txtLogText.insert(INSERT, "\n")
#self.txtLogText.insert(INSERT, "Test message2")
def writeLogText(self, logText):
if log.readloglevel() == 1:
self.txtLogText.insert(INSERT, logText)
self.txtLogText.see(END)
def initialiseWidgets(self):
self.btnDisconnect["state"] = "disabled"
def __init__(self, master=None):
self.frmApp = ttk.Frame(master)
self.frmApp.grid(column=0, row=0, columnspan=1, sticky=N + S + E + W)
self.device = obd.OBDEmulator()
#self.frmApp.pack()
self.createWidgets()
self.initialiseWidgets()
self.initialiseParams()
class AO3Scraper:
def __init__(self):
self.window = Tk()
self.window.title("AO3 Scraper")
# limit
self.limitFrame = Frame(self.window)
self.limitFrame.grid(row=0, column=1)
self.limitVar = IntVar(value=1000)
self.initLimitFrame(1)
# message
self.output = ""
self.messageVar = StringVar()
# fandom options
self.optionsFrame = Frame(self.window)
self.optionsFrame.grid(row=0, column=0)
self.animeURL = "https://archiveofourown.org/media/Anime%20*a*%20Manga/fandoms"
self.moviesURL = "https://archiveofourown.org/media/Movies/fandoms"
self.showsURL = "https://archiveofourown.org/media/TV%20Shows/fandoms"
self.gamesURL = "https://archiveofourown.org/media/Video%20Games/fandoms"
self.urlVar = StringVar(value=self.animeURL)
self.initOptionsFrame()
# submit button
self.submitFrame = Frame(self.window)
self.submitFrame.grid(row=3, column=1, sticky=E)
self.statusVar = StringVar()
Label(self.submitFrame, textvariable=self.statusVar).grid(row=0,
column=0,
sticky=E)
Button(self.submitFrame, text="Submit",
command=self.submit).grid(row=0, column=1, sticky=E)
self.txt = ScrolledText(self.window)
self.txt.grid(row=4, columnspan=2)
def initLimitFrame(self, row):
Label(self.limitFrame, text="Lower Bound").grid(row=row, column=0)
Entry(self.limitFrame, textvariable=self.limitVar).grid(row=row,
column=1,
sticky=W)
def initOptionsFrame(self):
Label(self.optionsFrame, text="Genre").grid(rowspan=4)
Radiobutton(self.optionsFrame,
value=self.animeURL,
text="Anime & Manga",
variable=self.urlVar).grid(row=0, column=1, sticky=W)
Radiobutton(self.optionsFrame,
value=self.moviesURL,
text="Movies",
variable=self.urlVar).grid(row=1, column=1, sticky=W)
Radiobutton(self.optionsFrame,
value=self.showsURL,
text="TV Shows",
variable=self.urlVar).grid(row=2, column=1, sticky=W)
Radiobutton(self.optionsFrame,
value=self.gamesURL,
text="Video Games",
variable=self.urlVar).grid(row=3, column=1, sticky=W)
def prepareDriver(self):
options = Options()
options.add_argument("--headless")
self.driver = webdriver.Firefox(
executable_path=
r'C:\Users\Angela\Documents\geckodriver\geckodriver.exe',
options=options)
self.driver.get(self.urlVar.get())
self.content = self.driver.page_source
def quitDriver(self):
self.driver.quit()
def getFandoms(self):
self.fandoms = dict()
soup = BeautifulSoup(self.content, features="html.parser")
for a in soup.find_all('a', href=True, attrs={'class': 'tag'}):
gen = a.parent.stripped_strings
count = int(next(islice(gen, 1, None))[1:-1])
self.fandoms[a.string] = count
def setFandomList(self):
self.getFandoms()
try:
for fandom in self.fandoms.keys():
if self.fandoms[fandom] >= self.limitVar.get():
line = f"{fandom}: {self.fandoms[fandom]}\n"
self.output += line
self.messageVar.set(self.output)
self.statusVar.set("Success!")
self.txt.insert(INSERT, self.output)
except:
self.statusVar.set("Failed!")
def submit(self):
self.prepareDriver()
self.txt.delete("1.0", END)
self.output = ""
self.setFandomList()
self.quitDriver()
def run(self):
self.window.mainloop()
def edit_labels(plotgui):
"""
Bring up a window to edit the labels in the plot.
This routine produces a text box in a window, within which one can
edit the label values. If no labels are defined the routine just
exits with no action.
Labels are presented one per line, with the parameter values
separated by tab symbols. One can edit the values within the text
window and then these are applied when one clicks on the "Close
Window" button.
Parameters
----------
plotgui: A matplotlib_user_interface object, for the plot holding
the labels
Returns
-------
None
"""
if plotgui.number_of_labels == 0:
return
str1 = 'Edit values below: fields are separated by tab ' \
+ 'characters\n x position y position plot ' \
+ 'label colour size font fontweight' \
+ '\n----------------------------------------------' \
+ '-------------------------------------\n'
for loop in range(plotgui.number_of_labels):
if plotgui.xparameters[plotgui.plot_labels[loop]['plot']-1]['hybridlog']:
xpos1 = general_utilities.inverse_hybrid_transform(
plotgui.plot_labels[loop]['xposition'])
else:
xpos1 = plotgui.plot_labels[loop]['xposition']
if plotgui.yparameters[plotgui.plot_labels[loop]['plot']-1]['hybridlog']:
ypos1 = general_utilities.inverse_hybrid_transform(
plotgui.plot_labels[loop]['yposition'])
else:
ypos1 = plotgui.plot_labels[loop]['yposition']
str1 = str1 + '%12.6g\t%12.6g\t%3d\t%s\t%s\t%d\t%s\t%s\n' % (
xpos1,
ypos1,
plotgui.plot_labels[loop]['plot'],
plotgui.plot_labels[loop]['labelstring'],
plotgui.plot_labels[loop]['colour'],
plotgui.plot_labels[loop]['size'],
plotgui.plot_labels[loop]['font'],
plotgui.plot_labels[loop]['fontweight'])
label_window = Tk.Toplevel()
label_window.title('Labels:')
holder = Tk.Frame(label_window)
holder.pack(side=Tk.TOP)
label_message_text = ScrolledText(holder, height=40, width=90,
wrap=Tk.NONE)
label_message_text.config(font=('courier', 16, 'bold'))
label_message_text.pack(side=Tk.TOP)
label_message_text.insert(0.0, str1)
bholder = Tk.Frame(label_window)
bholder.pack(side=Tk.TOP)
close_button = Tk.Button(
bholder, text='Close Window',
command=lambda: read_labels(plotgui, label_message_text,
label_window))
close_button.pack()
command=displaybox_4)
#Create 2 text area to display the list
#text area1 for viewing item
box_1 = ScrolledText(pan_window,
width=27,
height=11,
font=('Arial', 10),
wrap=WORD,
borderwidth=2,
relief='groove',
fg='navy blue',
yscrollcommand=set())
#text1="Please select a product category"
box_1.insert(END, 'Please select a product category')
#text area2 for diplaying item of shopper's choice
box_2 = ScrolledText(pan_window,
width=27,
height=11,
font=('Arial', 10),
wrap=WORD,
borderwidth=2,
relief='groove',
fg='navy blue',
yscrollcommand=set())
box_2.insert(INSERT, "Nothing ordered yet")
#pack the labels and widgets
the_label.place(x=70, y=5)
class APP:
def __init__(self):
self.r = Tk()
self.r.geometry('400x500')
self.r.configure(bg='beige')
self.r.title('Cantidad de Informacaion')
# Creat Pestañas
tab_control = ttk.Notebook(self.r)
txt = ttk.Frame(tab_control)
arch = ttk.Frame(tab_control)
tab_control.add(txt, text='Texto')
tab_control.add(arch, text='Archivo')
# ARchivo
# text box
# Creat Window
self.cajC = ScrolledText(arch, width=7, height=15)
self.cajC.place(x=10, y=130)
self.cajPD = ScrolledText(arch, width=8, height=15)
self.cajPD.place(x=95, y=130)
self.cajI = ScrolledText(arch, width=8, height=15)
self.cajI.place(x=200, y=130)
self.cajH = ScrolledText(arch, width=8, height=15)
self.cajH.place(x=300, y=130)
self.cajLectura = ScrolledText(arch, width=35, height=4)
self.cajLectura.place(x=10, y=29)
self.cajaruta = ttk.Entry(arch, justify=tk.LEFT)
self.cajaruta.place(x=10, y=5, width=298, height=20)
self.cajaruta.insert(0, 'c:/usuario/ejemplo')
# self.cajLectura.config(state=tk.DISABLED)
# Labels
laC = Label(arch, text="Caracter", fg="black")
laC.place(x=10, y=105)
laPD = Label(arch, text="Pro. Decimal", fg="black")
laPD.place(x=95, y=105)
laI = Label(arch, text="I", fg="black")
laI.place(x=200, y=105)
laH = Label(arch, text="H", fg="black")
laH.place(x=300, y=105)
# button inicio arch
self.botnini = ttk.Button(arch, text='Archivo', command=self.direccion)
self.botnini.place(x=315, y=4)
self.btninicio = ttk.Button(arch,
text='Iniciar',
command=self.cantidad)
self.btninicio.place(x=315, y=35)
self.btninicio.config(state=tk.DISABLED)
# TExto
# text box
self.cajatexto = ScrolledText(txt, width=35, height=5)
tab_control.pack(expand=1, fill='both')
self.cajatexto.place(x=10, y=15)
self.cajaC = ScrolledText(txt, width=7, height=15)
self.cajaC.place(x=10, y=130)
self.cajaPD = ScrolledText(txt, width=8, height=15)
self.cajaPD.place(x=95, y=130)
self.cajaI = ScrolledText(txt, width=8, height=15)
self.cajaI.place(x=200, y=130)
self.cajaH = ScrolledText(txt, width=8, height=15)
self.cajaH.place(x=300, y=130)
laC = Label(txt, text="Caracter", fg="black")
laC.place(x=10, y=105)
laPD = Label(txt, text="Pro. Decimal", fg="black")
laPD.place(x=95, y=105)
laI = Label(txt, text="I", fg="black")
laI.place(x=200, y=105)
laH = Label(txt, text="H", fg="black")
laH.place(x=300, y=105)
# button inicio txt
self.botonini = ttk.Button(txt, text='Iniciar', command=self.cantidad)
self.botonini.place(x=315, y=15)
self.r.mainloop()
def cantidad(self):
self.limpiesa(1)
ruta = self.cajaruta.get()
if ruta == "c:/usuario/ejemplo":
texto = self.cajatexto.get('0.1', END)
T = 1
else:
texto = []
ruta = self.cajaruta.get()
print(ruta)
archivo = open(ruta, encoding="utf8")
txt = archivo.readlines()
self.cajLectura.insert('0.1', txt)
for i in range(len(txt)):
for j in range(len(txt[i])):
texto.append(txt[i][j])
texto = str(texto)
T = 0
archivo.close()
longitud = (len(texto)) - 1
# print(longitud)
# print(ascii(texto))
cadena = []
for i in range(longitud):
cadena.append(texto[i])
# print(texto)
# print(cadena)
caracter = []
for i in range(longitud):
zero = caracter.count(texto[i])
if zero == 0:
caracter.append(texto[i])
# print(caracter)
prob = []
for i in range(len(caracter)):
p = cadena.count(caracter[i])
pro = round((p / longitud), 5)
prob.append([pro, caracter[i]])
# print(prob)
I = []
H = []
for j in range(len(caracter)):
ii = round(math.log2(1 / prob[j][0]), 3)
I.append(ii)
hh = round(prob[j][0] * (math.log2(1 / prob[j][0])), 3)
H.append(hh)
# print(I)
# print(H)
self.imprimitxt(caracter, prob, I, H, T)
graficar(caracter, I, H)
self.limpiesa(0)
def imprimitxt(self, caracter, prob, I, H, t):
if t == 1:
for i in range(len(caracter)):
self.cajaC.insert(0.1, caracter[i] + '\n')
self.cajaPD.insert(0.1, prob[i][0])
self.cajaI.insert(0.1, I[i])
self.cajaH.insert(0.1, H[i])
if i < len(caracter) - 1:
self.cajaPD.insert(0.1, '\n')
self.cajaI.insert(0.1, '\n')
self.cajaH.insert(0.1, '\n')
else:
for j in range(len(caracter)):
self.cajC.insert(0.1, caracter[j] + '\n')
self.cajPD.insert(0.1, prob[j][0])
self.cajI.insert(0.1, I[j])
self.cajH.insert(0.1, H[j])
if j < len(caracter) - 1:
self.cajPD.insert(0.1, '\n')
self.cajI.insert(0.1, '\n')
self.cajH.insert(0.1, '\n')
def direccion(self):
# self.cajaruta.config(state=tk.NORMAL)
self.cajaruta.delete(0, END)
extension = ["*.txt"]
archivo = eg.fileopenbox(msg="Abrir archivo",
title="Control: fileopenbox",
default='',
filetypes=extension)
self.cajaruta.insert(0, archivo)
self.cajaruta.config(state=tk.DISABLED)
self.btninicio.config(state=tk.NORMAL)
def limpiesa(self, tipo):
if tipo == 1:
self.cajaC.delete(0.1, END)
self.cajaH.delete(0.1, END)
self.cajaPD.delete(0.1, END)
self.cajaI.delete(0.1, END)
self.cajC.delete(0.1, END)
self.cajH.delete(0.1, END)
self.cajPD.delete(0.1, END)
self.cajI.delete(0.1, END)
elif tipo == 0:
self.cajaruta.config(state=tk.NORMAL)
self.cajaruta.delete(0, END)
self.cajaruta.insert(0, 'c:/usuario/ejemplo')
class ShiftApp(): ### In-progress Shift application ###
def __init__(self, db, job_name):
self.db = db
self.events = {}
self.job_name = job_name
self.start_time = time.time()
self.break_start = 0
self.break_time = 0
self.id = self.db.add_shift(self.job_name, self.start_time, None,
self.break_time, None)
self.tasks = {}
self.task_index = []
self.cur_task = 0
self.root = Tk()
self.root.title(f'Shift - {job_name}')
self.root.resizable(False, False)
self.root.overrideredirect(0)
self.tm1_selection = StringVar(self.root)
self.tm2_selection = StringVar(self.root)
self.container = ttk.Frame(self.root)
self.frame = ttk.Frame(self.container)
self.job_label = ttk.Label(self.frame, text=f'Job: {job_name}')
self.elapsed_time_label = ttk.Label(self.frame, width=18)
self.task_frame = ttk.Frame(self.frame)
self.task_label = ttk.Label(self.task_frame, text="Tasks:")
self.tm1_options, self.tm2_options = ('All Job Tasks',
'Shift Tasks Only'), ()
self.task_menu1 = ttk.OptionMenu(self.frame, self.tm1_selection,
self.tm1_options[0],
*self.tm1_options)
self.task_entry = ttk.Entry(self.frame)
self.task_list = Listbox(self.task_frame,
selectmode=SINGLE,
width=20,
height=12,
relief='sunken')
vbar = ttk.Scrollbar(self.task_frame,
orient='vertical',
command=self.task_list.yview)
self.task_list.config(yscrollcommand=vbar.set)
self.new_task_button = ttk.Button(self.frame,
text="New Task",
command=self.new_task)
self.button_frame = ttk.Frame(self.frame)
self.pause_button = ttk.Button(self.button_frame,
text='Pause',
command=self.toggle_break,
width=7)
# TODO: Add info button
self.cancel_button = ttk.Button(self.frame,
text='Cancel',
command=self.cancel_prompt)
self.notes = ScrolledText(self.frame,
undo=True,
width=60,
height=15,
relief='sunken')
self.report_job_button = ttk.Button(self.frame,
text='Prior Shifts',
command=self.launch_report_edit)
self.save_button = ttk.Button(self.frame,
text='Stop and Save',
command=self.end_prompt)
self.job_label.grid(column=2, columnspan=2, row=1, sticky=W, pady=5)
self.elapsed_time_label.grid(column=4, row=1, sticky=E)
self.task_menu1.grid(column=1, row=1, sticky=(E, W), padx=(0, 15))
self.task_entry.grid(column=1, row=2, sticky=(E, W), padx=(0, 15))
self.task_list.grid(column=1, row=1, sticky=(N, S))
vbar.grid(column=2, row=1, sticky=(N, S))
self.task_frame.grid(column=1, row=3, sticky=(N, S), pady=(5, 5))
self.new_task_button.grid(column=1, row=4, sticky=W)
self.button_frame.grid(column=2, columnspan=2, row=2, sticky=W)
self.pause_button.grid(column=2, row=1, sticky=W)
self.cancel_button.grid(column=4, row=2, sticky=E)
self.notes.grid(column=2, columnspan=3, row=3, pady=(5, 5))
self.report_job_button.grid(column=2, row=4, sticky=W)
self.save_button.grid(column=4, row=4, sticky=E)
self.frame.grid(column=0, row=0, padx=5, pady=5)
self.container.grid(column=0, row=0)
self.root.protocol("WM_DELETE_WINDOW", self.cancel_prompt)
self.task_menu1.bind("<ButtonRelease-1>",
self.filter_tasks) # filter_tasks clears notes
self.task_entry.bind("<KeyRelease>", self.filter_tasks)
self.task_list.bind("<ButtonRelease-1>", self.focus_task)
self.task_list.bind("<Double-Button-1>", self.copy_task_title)
self.notes.bind("<Command-Z>", self.edit_undo)
self.time_counter()
self.auto_save()
self.get_tasks()
def edit_undo(self, event=None):
try:
self.notes.edit_undo()
except TclError as e:
print(e)
def get_tasks(self,
event=None,
**kwargs): ## Gets set of filtered tasks from db ##
if "Job" in self.tm1_selection.get():
kwargs["job_name"] = self.job_name
else:
kwargs["shift_id"] = self.id
tasks = self.db.report_tasks(**kwargs)
self.tasks.clear()
for task in tasks:
self.tasks[task["id"]] = task
self.task_list.delete(0, END)
self.cur_task = 0
self.task_index = []
self.task_list.insert(END, "Shift Notes")
self.task_index.append(None)
for _, task in self.tasks.items():
self.task_list.insert(END, task['title'])
self.task_index.append(task["id"])
def filter_tasks(self, event=None):
# TODO: set focus to 'Shift Notes'
search_term = self.task_entry.get()
if search_term in ('', ' '):
search_term = None
self.get_tasks(search_term=search_term)
notes = self.db.get_shift(self.id)["notes"]
self.notes.delete("0.0", END)
self.notes.insert(END, notes)
def new_task(self):
task_title = self.task_entry.get()
if task_title not in ('', ' '):
task = self.db.add_task(self.id, self.job_name, task_title)
self.task_entry.delete(0, END)
self.get_tasks()
self.task_list.activate(self.task_index.index(task["id"]))
def focus_task(
self,
event=None): ## displays notes for the currently selected task ##
if self.task_list.curselection():
new_cur = self.task_list.curselection()[0]
if new_cur == self.cur_task:
return
notes = self.notes.get(0.0, END).strip('\n')
if self.cur_task: # if the notes being displayed belong to a task
task_id = self.task_index[self.cur_task]
self.tasks[task_id]["notes"] = notes
else:
self.db.update_shift(self.id, notes=notes)
if new_cur: # if the new notes to be displayed belong to a task
task_id = self.task_index[new_cur]
notes = self.tasks[task_id]["notes"]
else:
shift = self.db.report_shifts(shift_id=self.id)[0]
notes = shift["notes"]
self.notes.delete('0.0', END)
self.notes.insert(END, notes)
self.cur_task = new_cur
def copy_task_title(
self,
event=None
): ## Copies title from current selection in task_list to task_entry ##
cur = self.task_list.curselection()[0]
if cur:
task = self.tasks[self.task_index[cur]]
self.task_entry.delete(0, END)
self.task_entry.insert(0, task["title"])
self.filter_tasks()
def time_counter(self):
if not self.break_start:
elapsed_time = time.gmtime(time.time() - self.start_time -
self.break_time)
elapsed_hours = time.strftime('%H', elapsed_time)
elapsed_minutes = time.strftime('%M', elapsed_time)
elapsed_seconds = time.strftime('%S', elapsed_time)
self.elapsed_time_label[
'text'] = f'Elapsed Time: {elapsed_hours}:{elapsed_minutes}:{elapsed_seconds}'
self.events['time_counter'] = self.root.after(200, self.time_counter)
def auto_save(self):
self.save_update()
self.events['auto_save'] = self.root.after(5000, self.auto_save)
def save_update(
self): ## Commits current state for shift and tasks to db ##
if self.break_start:
break_time = self.break_time + (time.time() - self.break_start)
else:
break_time = self.break_time
end_time = time.time()
notes = self.notes.get(0.0, END).strip('\n')
if self.cur_task: # if the notes being displayed belong to a task
task_id = self.task_index[self.cur_task]
self.tasks[task_id]["notes"] = notes
notes = None
self.db.update_shift(self.id,
end_time=end_time,
break_time=break_time,
notes=notes)
for _, task in self.tasks.items():
self.db.update_task(**task)
def toggle_break(self):
if not self.break_start:
self.break_start = time.time()
self.job_label['text'] = f'{self.job_name} - Paused'
self.pause_button['text'] = 'Resume'
else:
self.break_time += time.time() - self.break_start
self.break_start = 0
self.job_label['text'] = self.job_name
self.pause_button['text'] = 'Pause'
def end_prompt(self):
popup = PopConfirm("Save and exit shift?", self.end_shift)
popup.root.mainloop()
def cancel_prompt(self):
popup = PopConfirm("Cancel and delete shift?", self.cancel_shift)
popup.root.mainloop()
def end_shift(self):
self.save_update()
self.db.complete_shift(self.id)
self.close()
def cancel_shift(self):
self.db.remove_shift(self.id)
self.close()
def launch_report_edit(self):
self.report_edit_window = ReportEditApp(self.db,
job_name=self.job_name)
self.report_edit_window.root.mainloop()
def close(self):
for val in self.events.values():
self.root.after_cancel(val)
self.root.destroy()
class clientUI():
def __init__(self, q_join, q_text, q_leave, send_q, username):
self.first_click = True
self.q_join = q_join
self.q_text = q_text
self.q_leave = q_leave
self.send_q = send_q
self.username = username
def start(self):
print("Starting clientUI...")
self.initDisplay()
self.ui_messages.insert(
tkinter.END, "%s has joined the chat room...\n" % self.username)
self.ui_input.insert(tkinter.END, "<Enter message>")
self.ui_top.after(100, self.receivedMsg)
# This call to mainloop() is blocking and will last for the lifetime
# of the GUI.
self.ui_top.mainloop()
# Should only get here after destroy() is called on ui_top
print("Stopping clientUI...")
def initDisplay(self):
self.ui_top = tkinter.Tk()
self.ui_top.wm_title("GUI Demo")
self.ui_top.resizable('1', '1')
self.ui_top.protocol("WM_DELETE_WINDOW", self.eventDeleteDisplay)
self.ui_messages = ScrolledText(
master=self.ui_top,
wrap=tkinter.WORD,
width=50, # In chars
height=25) # In chars
self.ui_input = tkinter.Text(master=self.ui_top,
wrap=tkinter.WORD,
width=50,
height=4)
# Bind the button-1 click of the Entry to the handler
self.ui_input.bind('<Button-1>', self.eventInputClick)
self.ui_button_send = tkinter.Button(master=self.ui_top,
text="Send",
command=self.sendMsg)
self.ui_button_file = tkinter.Button(master=self.ui_top,
text="File",
command=self.sendFile)
# Compute display position for all objects
self.ui_messages.pack(side=tkinter.TOP, fill=tkinter.BOTH)
self.ui_input.pack(side=tkinter.TOP, fill=tkinter.BOTH)
self.ui_button_send.pack(side=tkinter.LEFT)
self.ui_button_file.pack(side=tkinter.RIGHT)
# SEND button pressed
def sendMsg(self):
# Get user input (minus newline character at end)
msg = self.ui_input.get("0.0", tkinter.END + "-1c")
if (len(msg) > 0):
self.send_q.put(msg)
print("UI: Got text: '%s'" % msg)
# Add this data to the message window
self.ui_messages.insert(tkinter.INSERT,
"%s: %s\n" % (self.username, msg))
self.ui_messages.yview(tkinter.END) # Auto-scrolling
# Clean out input field for new data
self.ui_input.delete("0.0", tkinter.END)
def receivedMsg(self):
try:
joined_username = self.q_join.get(block=False)
joined = True
except queue.Empty:
joined = False
try:
text_username, text = self.q_text.get(block=False)
text = True
except queue.Empty:
text = False
try:
left_username = self.q_leave.get(block=False)
left = True
except queue.Empty:
left = False
if (joined):
self.ui_messages.insert(
tkinter.INSERT,
str(joined_username) + " has joined the chatroom\n")
self.ui_messages.yview(tkinter.END) # Auto-scrolling
elif (text):
self.ui_messages.insert(
tkinter.INSERT,
str(text_username) + ": " + str(text) + "\n")
self.ui_messages.yview(tkinter.END) # Auto-scrolling
elif (left):
self.ui_messages.insert(
tkinter.INSERT,
str(left_username) + " has left the chat room...\n")
self.ui_messages.yview(tkinter.END) # Auto-scrolling
self.ui_top.after(5000, self.receivedMsg)
# FILE button pressed
def sendFile(self):
file = askopenfilename()
if (len(file) > 0 and os.path.isfile(file)):
print("UI: Selected file: %s" % file)
else:
print("UI: File operation canceled")
# Event handler - User closed program via window manager or CTRL-C
def eventDeleteDisplay(self):
print("UI: Closing")
global ONLINE
ONLINE = False
# Continuing closing window now
self.ui_top.destroy()
# Event handler - User clicked inside the "ui_input" field
def eventInputClick(self, event):
if (self.first_click):
# If this is the first time the user clicked,
# clear out the tutorial message currently in the box.
# Otherwise, ignore it.
self.ui_input.delete("0.0", tkinter.END)
self.first_click = False
class ChatClient:
client_socket = None
def __init__(self, ip, port):
self.initialize_socket(ip, port)
self.initialize_gui()
self.listen_thread()
def initialize_socket(self, ip, port):
'''
TCP socket을 생성하고 server에게 연결
'''
self.client_socket = socket(AF_INET, SOCK_STREAM)
remote_ip = ip
remote_port = port
self.client_socket.connect((remote_ip, remote_port))
def send_chat(self):
'''
message를 전송하는 callback함수
'''
senders_name = self.name_widget.get().strip() + ":"
data = self.enter_text_widget.get(1.0, 'end').strip()
message = (sendes_name + data).encode('utf-8')
self.chat_transcript_area.insert('end', message.decode('utf-8')+'\n')
self.chat_transcript_area.yview(END)
self.client_socket.send(message)
self.enter_text_widget.delete(1.0, 'end')
return 'break'
def initialize_gui(self):
'''
위젯을 배치하고 초기화한다
'''
self.root = Tk()
fr = []
for i in range(0,5):
fr.append(Frame(self.root))
fr[i].pack(fill=BOTH)
self.name_label = Label(fr[0], text = '사용자 이름 ')
self.recv_label = Label(fr[1], text = '수신 메시지:')
self.send_label = Label(fr[3], text = '발신 메시지:')
self.send_btn = Button(fr[3], text ='전송', command=self.send_chat)
self.chat_transcript_area = ScrolledText(fr[2], height=20, width=60)
self.enter_text_widget = ScrolledText(fr[4], height=5, width=60)
self.name_widget = Entry(fr[0], width=15)
self.name_label.pack(side=LEFT)
self.name_widget.pack(side=LEFT)
self.recv_label.pack(side=LEFT)
self.send_btn.pack(side=RIGHT, padx=20)
self.chat_transcript_area.pack(side=LEFT, padx=2, pady=2)
self.send_label.pack(side=LEFT)
self.enter_text_widget.pack(side=LEFT, padx=2, pady=2)
def listen_thread(self):
'''
Thread를 생성하고 시작한다
'''
t = Thread(target=self.receive_message, args=(self.client_socket,))
t.start()
def receive_message(self, so):
'''
Server로부터 message룰 수신하고 문서창에 표시한다
'''
while True:
buf = so.recv(256)
if not buf:
break
self.chat_transcript_area.insert('end',buf.encode('utf-8')+ '\n')
self.chat_transcript_area.yview(END)
so.close()
label_2 = Label(root, text='Naam : ', bg='#FFCC18')
label_2.config(font=('times', 24))
label_2.grid(row=1, column=2, sticky='ne')
label_3 = Label(root, text='Bericht : ', bg='#FFCC18')
label_3.config(font=('times', 24))
label_3.grid(row=2, column=2, sticky='ne')
label_naam = Entry(root, textvariable=svar_naam, bg='#e6e6e6', borderwidth=4)
label_naam.config(font=('times', 20), width=40)
label_naam.grid(row=1, column=3, columnspan=4, sticky='nw')
label_message = ScrolledText(root, width=40, height=4, bg='#e6e6e6')
label_message.grid(row=2, column=3, columnspan=5, sticky='ew')
label_message.config(font=('times', 18))
label_message.insert(INSERT, '')
reject = lambda: beoordeel(False)
accept = lambda: beoordeel(True)
button_reject = Button(root, text='Reject', bg="red", command=accept)
button_accept = Button(root, text='accept', bg="Green", command=accept)
button_reject.config(font=('times', 32))
button_reject.grid(row=11, column=1)
button_accept.config(font=('times', 32))
button_accept.grid(row=11, column=10)
root.mainloop()
class textEditor:
def __init__(self):
self.root = Tk()
self.root.title('My Text Editor')
self.text = ScrolledText(self.root, width=100, height=50)
# if using .grid(), the area of text will be on the left when in full screen mode.
self.text.pack()
menubar = Menu(self.root)
filemenu = Menu(menubar)
menubar.add_cascade(label="File", menu=filemenu)
filemenu.add_command(label="New", command=self.new_file)
filemenu.add_command(label="Open", command=self.open_file)
filemenu.add_command(label="Save", command=self.save_file)
filemenu.add_separator()
filemenu.add_command(label="Exit", command=self.exit)
editmenu = Menu(menubar)
menubar.add_cascade(label="Edit", menu=editmenu)
fontmenu = Menu(menubar)
menubar.add_cascade(label="Font", menu=fontmenu)
fontmenu.add_command(label="Courier", command=self.font_courier)
fontmenu.add_command(label="Helvetica", command=self.font_helvetica)
fontmenu.add_command(label="Times", command=self.font_times)
fontmenu.add_command(label="Roman", command=self.font_roman)
menubar.add_command(label="Find", command=self.find_pattern)
self.root.config(menu=menubar)
self.root.mainloop()
def save_file(self):
data = self.text.get("1.0", "end-1c")
savelocation = filedialog.asksaveasfilename(defaultextension='.txt',
title='Save Text')
with open(savelocation, "w+") as f:
try:
f.write(data)
except:
messagebox.showerror(title="Oops!",
message="Unable to save it...")
def font_times(self):
self.text.config(font=("times", 12))
def font_courier(self):
self.text.config(font=("Courier", 15))
def font_helvetica(self):
self.text.config(font=("Helvetica", 12))
def font_roman(self):
self.text.config(font=("Times New Roman", 12, "bold"))
def open_file(self):
f = filedialog.askopenfile(mode='r')
t = f.read()
self.text.delete(0.0, END)
self.text.insert(0.0, t)
def new_file(self):
if len(self.text.get('1.0', END + '-1c')) > 0:
ask_for_save = messagebox.askquestion(
'save', 'do you want to save the file')
if ask_for_save == 'yes':
self.save_file()
else:
self.text.delete(0.0, END)
self.root.title('My Text Editor')
def exit(self):
ask_for_exit = messagebox.askquestion(
"Exit", "Are you sure you want to exit?")
if ask_for_exit == 'yes':
self.root.destroy()
def handle_click(self):
self.text.tag_config('Found', background='white', foreground='red')
def find_pattern(self):
self.text.tag_remove("Found", '1.0', END)
find = simpledialog.askstring("Find....", "Enter text:")
# prevent frozen because of inputing nothing in find.
if not find:
return
idx = '0.0'
if find:
idx = '1.0'
while 1:
idx = self.text.search(find, idx, nocase=1, stopindex=END)
if not idx:
break
lastidx = '%s+%dc' % (idx, len(find))
self.text.tag_add('Found', idx, lastidx)
idx = lastidx
self.text.bind("<1>", self.handle_click())
data = self.text.get('1.0', END)
occurance = data.upper().count(find.upper())
if occurance > 1:
label = messagebox.showinfo(
"Find", find + " has occurances " + str(occurance) + " times.")
elif occurance == 1:
label = messagebox.showinfo(
"Find",
find + " has just occurances " + str(occurance) + " time.")
else:
label = messagebox.showinfo("Find", "No results")
class ImportDialog(Frame):
"""Provides a frame for figure canvas and MPL settings"""
def __init__(self, parent=None, filename=None):
from .core import Table
self.parent = parent
self.filename = filename
self.df = None
self.main = Toplevel()
self.master = self.main
self.main.title('Text Import')
self.main.protocol("WM_DELETE_WINDOW", self.quit)
self.main.grab_set()
self.main.transient(parent)
delimiters = [',', '\t', ' ', ';', '/', '&', '|', '^', '+', '-']
encodings = [
'utf-8', 'ascii', 'iso8859_15', 'cp037', 'cp1252', 'big5', 'euc_jp'
]
grps = {
'formats': ['delimiter', 'decimal', 'comment'],
'data': [
'header', 'skiprows', 'index_col', 'skipinitialspace',
'skip_blank_lines', 'encoding', 'names'
],
'other': ['rowsperfile']
}
grps = OrderedDict(sorted(grps.items()))
opts = self.opts = {
'delimiter': {
'type': 'combobox',
'default': ',',
'items': delimiters,
'tooltip': 'seperator'
},
'header': {
'type': 'entry',
'default': 0,
'label': 'header',
'tooltip': 'position of column header'
},
'index_col': {
'type': 'entry',
'default': '',
'label': 'index col',
'tooltip': ''
},
'decimal': {
'type': 'combobox',
'default': '.',
'items': ['.', ','],
'tooltip': 'decimal point symbol'
},
'comment': {
'type': 'entry',
'default': '#',
'label': 'comment',
'tooltip': 'comment symbol'
},
'skipinitialspace': {
'type': 'checkbutton',
'default': 0,
'label': 'skip initial space',
'tooltip': 'skip initial space'
},
'skiprows': {
'type': 'entry',
'default': 0,
'label': 'skiprows',
'tooltip': 'rows to skip'
},
'skip_blank_lines': {
'type': 'checkbutton',
'default': 0,
'label': 'skip blank lines',
'tooltip': 'do not use blank lines'
},
'encoding': {
'type': 'combobox',
'default': 'utf-8',
'items': encodings,
'tooltip': 'file encoding'
},
#'prefix':{'type':'entry','default':None,'label':'prefix',
# 'tooltip':''}
'rowsperfile': {
'type': 'entry',
'default': '',
'label': 'rows per file',
'tooltip': 'rows to read'
},
'names': {
'type': 'entry',
'default': '',
'label': 'column names',
'tooltip': 'col labels'
},
}
bf = Frame(self.main)
bf.pack(side=LEFT, fill=BOTH)
optsframe, self.tkvars, w = dialogFromOptions(bf,
opts,
grps,
sticky='nwe',
layout='vertical')
self.m = PanedWindow(self.main, orient=VERTICAL)
self.m.pack(side=LEFT, fill=BOTH, expand=1)
self.textpreview = ScrolledText(self.main, width=80, height=10)
self.m.add(self.textpreview, weight=3)
tf = Frame(self.main)
self.m.add(tf, weight=1)
self.previewtable = Table(tf, rows=0, columns=0)
self.previewtable.show()
self.update()
optsframe.pack(side=TOP, fill=BOTH)
b = Button(bf, text="Update preview", command=self.update)
b.pack(side=TOP, fill=X, pady=2)
b = Button(bf, text="Import", command=self.doImport)
b.pack(side=TOP, fill=X, pady=2)
b = Button(bf, text="Cancel", command=self.quit)
b.pack(side=TOP, fill=X, pady=2)
self.main.wait_window()
return
def showText(self):
"""show text contents"""
with open(self.filename, 'r') as stream:
text = stream.read()
self.textpreview.delete('1.0', END)
self.textpreview.insert('1.0', text)
return
def update(self):
"""Reload previews"""
kwds = {}
other = ['rowsperfile']
for i in self.opts:
if i in other:
continue
try:
val = self.tkvars[i].get()
except:
val = None
if val == '':
val = None
elif type(self.opts[i]['default']) != int:
try:
val = int(val)
except:
pass
kwds[i] = val
self.kwds = kwds
self.showText()
f = pd.read_csv(self.filename,
chunksize=400,
error_bad_lines=False,
parse_dates=True,
warn_bad_lines=False,
**kwds)
try:
df = f.get_chunk()
except pd.parser.CParserError:
print('parser error')
df = pd.DataFrame()
model = TableModel(dataframe=df)
self.previewtable.updateModel(model)
self.previewtable.showIndex()
self.previewtable.redraw()
return
def doImport(self):
"""Do the import"""
'''pw = Toplevel(self.main)
pb = Progressbar(pw, orient='horizontal', mode='indeterminate')
pb.pack(expand=True, fill=BOTH, side=TOP)
pb.start(500)'''
self.df = pd.read_csv(self.filename, **self.kwds)
self.quit()
return
def quit(self):
self.main.destroy()
return
class ConsoleUi:
"""Poll messages from a logging queue and display them in a scrolled text widget"""
def __init__(self, frame):
self.frame = frame
# Create a ScrolledText wdiget
self.scrolled_text = ScrolledText(frame, state='disabled', height=12)
self.scrolled_text.grid(row=0, column=0, sticky=(N, S, W, E))
self.scrolled_text.configure(font='TkFixedFont')
self.scrolled_text.tag_config('INFO', foreground='black')
self.scrolled_text.tag_config('DEBUG', foreground='gray')
self.scrolled_text.tag_config('WARNING', foreground='orange')
self.scrolled_text.tag_config('ERROR', foreground='red')
self.scrolled_text.tag_config('CRITICAL',
foreground='red',
underline=1)
self.scrolled_text.tag_config(
'COPYOVER',
foreground='blue',
)
self.scrolled_text.tag_config(
'COPYNEW',
foreground='green',
)
self.scrolled_text.tag_config(
'DELETE',
foreground='red',
)
self.scrolled_text.tag_config(
'MOVE',
foreground='magenta',
)
# Start polling messages from the queue
self.frame.after(100, self.poll_log_queue)
def display(self, record):
msg = record
# Send special message to clear the log
if msg == "__clear__":
self.scrolled_text.configure(state='normal')
self.scrolled_text.delete(1.0, tk.END)
self.scrolled_text.configure(state='disabled')
return
self.scrolled_text.configure(state='normal')
self.scrolled_text.insert(tk.END, msg[1] + '\n', msg[0])
self.scrolled_text.configure(state='disabled')
# Autoscroll to the bottom
self.scrolled_text.yview(tk.END)
def poll_log_queue(self):
# Check every 100ms if there is a new message in the queue to display
while True:
try:
record = msg_queue.get(block=False)
except queue.Empty:
break
else:
self.display(record)
self.frame.after(100, self.poll_log_queue)
class ImportDialog(Frame):
"""Provides a frame for figure canvas and MPL settings"""
def __init__(self, parent=None, filename=None):
from .core import Table
self.parent = parent
self.filename = filename
self.df = None
self.main = Toplevel()
self.master = self.main
self.main.title('Text Import')
self.main.protocol("WM_DELETE_WINDOW", self.quit)
self.main.grab_set()
self.main.transient(parent)
delimiters = [',','\t',' ',';','/','&','|','^','+','-']
encodings = ['utf-8','ascii','iso8859_15','cp037','cp1252','big5','euc_jp']
grps = {'formats':['delimiter','decimal','comment'],
'data':['header','skiprows','index_col','skipinitialspace',
'skip_blank_lines','encoding','names'],
'other':['rowsperfile']}
grps = OrderedDict(sorted(grps.items()))
opts = self.opts = {'delimiter':{'type':'combobox','default':',',
'items':delimiters, 'tooltip':'seperator'},
'header':{'type':'entry','default':0,'label':'header',
'tooltip':'position of column header'},
'index_col':{'type':'entry','default':'','label':'index col',
'tooltip':''},
'decimal':{'type':'combobox','default':'.','items':['.',','],
'tooltip':'decimal point symbol'},
'comment':{'type':'entry','default':'#','label':'comment',
'tooltip':'comment symbol'},
'skipinitialspace':{'type':'checkbutton','default':0,'label':'skip initial space',
'tooltip':'skip initial space'},
'skiprows':{'type':'entry','default':0,'label':'skiprows',
'tooltip':'rows to skip'},
'skip_blank_lines': {'type':'checkbutton','default':0,'label':'skip blank lines',
'tooltip':'do not use blank lines'},
'encoding':{'type':'combobox','default':'utf-8','items':encodings,
'tooltip':'file encoding'},
#'prefix':{'type':'entry','default':None,'label':'prefix',
# 'tooltip':''}
'rowsperfile':{'type':'entry','default':'','label':'rows per file',
'tooltip':'rows to read'},
'names':{'type':'entry','default':'','label':'column names',
'tooltip':'col labels'},
}
bf = Frame(self.main)
bf.pack(side=LEFT,fill=BOTH)
optsframe, self.tkvars, w = dialogFromOptions(bf, opts, grps,
sticky='nwe', layout='vertical')
self.m = PanedWindow(self.main, orient=VERTICAL)
self.m.pack(side=LEFT,fill=BOTH,expand=1)
self.textpreview = ScrolledText(self.main, width=80, height=10)
self.m.add(self.textpreview, weight=3)
tf = Frame(self.main)
self.m.add(tf, weight=1)
self.previewtable = Table(tf,rows=0,columns=0)
self.previewtable.show()
self.update()
optsframe.pack(side=TOP,fill=BOTH)
b = Button(bf, text="Update preview", command=self.update)
b.pack(side=TOP,fill=X,pady=2)
b = Button(bf, text="Import", command=self.doImport)
b.pack(side=TOP,fill=X,pady=2)
b = Button(bf, text="Cancel", command=self.quit)
b.pack(side=TOP,fill=X,pady=2)
self.main.wait_window()
return
def showText(self):
"""show text contents"""
with open(self.filename, 'r') as stream:
text = stream.read()
self.textpreview.delete('1.0', END)
self.textpreview.insert('1.0', text)
return
def update(self):
"""Reload previews"""
kwds = {}
other = ['rowsperfile']
for i in self.opts:
if i in other:
continue
try:
val = self.tkvars[i].get()
except:
val=None
if val == '':
val=None
elif type(self.opts[i]['default']) != int:
try:
val=int(val)
except:
pass
kwds[i] = val
self.kwds = kwds
self.showText()
f = pd.read_csv(self.filename, chunksize=400, error_bad_lines=False,
parse_dates=True,
warn_bad_lines=False, **kwds)
try:
df = f.get_chunk()
except pd.parser.CParserError:
print ('parser error')
df = pd.DataFrame()
model = TableModel(dataframe=df)
self.previewtable.updateModel(model)
self.previewtable.showIndex()
self.previewtable.redraw()
return
def doImport(self):
"""Do the import"""
'''pw = Toplevel(self.main)
pb = Progressbar(pw, orient='horizontal', mode='indeterminate')
pb.pack(expand=True, fill=BOTH, side=TOP)
pb.start(500)'''
self.df = pd.read_csv(self.filename, **self.kwds)
self.quit()
return
def quit(self):
self.main.destroy()
return
def multiline(self, parent, id=None, text=''):
id = _unique(parent, id)
t = ScrolledText(parent, name=id, height=3)
t.insert('end', text)
return t
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 messagebox.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,9))
fig1.suptitle('Sampled signal - Acceleration')
ax_11 = fig1.add_subplot(3,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(3,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.
ax_12 = fig1.add_subplot(3,1,3)
#ax_12.hold(False)
ax_12.set_title("Channel Z")
ax_12.set_xlabel('ms')
ax_12.set_ylabel('g')
ax_12.grid() #Shows grid.
#Figure 2
fig2 = Figure(figsize=(10,9))
fig2.suptitle('FFT spectrum')
ax_21 = fig2.add_subplot(3,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(3,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()
ax_23 = fig2.add_subplot(3,1,3)
#ax_23.hold(False)
ax_23.set_title("Channel Z")
ax_23.set_xlabel('Hz')
#ax_23.set_xlim(xmax=max_freq)
ax_23.set_xlim(xmax=max_freq_z)
ax_23.set_ylabel('g')
ax_23.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)
messagebox.showerror( "Result", "Can't open serial port: " + str(ex))
if (estado_serial == True):
global g_canal_1, g_canal_2, g_canal_3, datos_a_leer
canal_1 = []
canal_2 = []
canal_3 = []
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(b'INI') #Start data sampling command.
#serial_avr.write(chr(0x22)) #CRC 'INI'. Not used.
serial_avr.write(b"\x7E") #End of packet.
global t_timeout
timeout_state = False
t0 = time.time() #Start loop time stamp.
while ((conta_datos_rx < datos_a_leer) and (timeout_state == False)):
if serial_avr.inWaiting():
lectura = serial_avr.read(serial_avr.inWaiting())
buffer += lectura
valores = []
if len(buffer) > 15:
try:
i = buffer.index(0x7E)
except (ValueError):
i = -1
#print("Buffer: {0}".format(buffer))
if i >= 0:
paquete = buffer[:i]
buffer = buffer[i+1:]
#print("Paquete: {0}".format(paquete))
valores=[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]
canal3 = (valores_decod[4] * 256) + valores_decod[5]
canal_1.append(canal1)
canal_2.append(canal2)
canal_3.append(canal3)
#print("Canal 1: %s Canal2: %s " % (canal1, canal2))
valores = []
valores_decod = []
conta_datos_rx += 1 ;
#print("conta_datos_rx = %s" %conta_datos_rx)
#Check if t_timeout seconds have elapsed since time stamp t0
if ((time.time() - t0) > t_timeout):
timeout_state = True
#print("Serial port timeout")
if (timeout_state == False):
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(b'PAR') #Stop data sampling.
serial_avr.write(b"\x7E") #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))
print("Amount of samples channel 3: %s" %len(canal_3))
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))
message_string += "Amount of samples channel 3: {0} \n".format(len(canal_3))
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[:]
g_canal_3 = canal_3[:]
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, canal_3, win_var=1)
else:
serial_avr.write(b'PAR') #Stop data sampling.
serial_avr.write(b"\x7E") #End of packet.
serial_avr.close() #Close serial port.
print("Serial port timeout")
message_string = ("Serial port timeout \n")
self.show_message(self.text_message, message_string)
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, canal_3, 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
canal_3[indice] *= g_scale
# Calculates medium value for each channel.
vdc_canal_1 = 0
vdc_canal_2 = 0
vdc_canal_3 = 0
for indice in X:
vdc_canal_1 += canal_1[indice]
vdc_canal_2 += canal_2[indice]
vdc_canal_3 += canal_3[indice]
vdc_canal_1 = vdc_canal_1 / num_datos
vdc_canal_2 = vdc_canal_2 / num_datos
vdc_canal_3 = vdc_canal_3 / 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
canal_3[indice] -= vdc_canal_3
#----------------- 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, ax_13 = 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.
#Channel Z
ax_13.clear()
ax_13.plot(X1,canal_3)
ax_13.set_title("Channel Z")
ax_13.set_xlabel('ms')
ax_13.set_ylabel('g')
ax_13.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)*(2/N)
yf = yf[:int(N/2)]
xf = np.linspace(0.0, 1.0/(2.0*T), N/2)
ax_21, ax_22, ax_23 = self.canvas1.figure.get_axes()
ax_21.clear()
#ax_21.plot(xf, 2.0/N * np.abs(yf[:N/2]))
ax_21.plot(xf, np.abs(yf))
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)*(2/N)
yf = yf[:int(N/2)]
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.plot(xf, np.abs(yf))
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')
#Channel Z
canal_fft = []
canal_fft = canal_3
N = len(canal_fft) # length of the signal
T = 1.0 / sample_rate
y = canal_fft
yf = fftpack.fft(y*w)*(2/N)
yf = yf[:int(N/2)]
xf = np.linspace(0.0, 1.0/(2.0*T), N/2)
ax_23.clear()
#ax_23.plot(xf, 2.0/N * np.abs(yf[:N/2]))
ax_23.plot(xf, np.abs(yf))
ax_23.grid()
ax_23.set_title("Channel Z")
ax_23.set_xlabel('Hz')
#ax_23.set_xlim(xmax=max_freq)
ax_23.set_xlim(xmax=max_freq_z)
ax_23.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, g_canal_3
canal_1 = g_canal_1[:] #Copy list by value not by reference
canal_2 = g_canal_2[:]
canal_3 = g_canal_3[:]
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, canal_3, 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 = filedialog.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, L2 and L3 tags.
canal_1 = extraer_int_tag(datos_arch, 'L1')
canal_2 = extraer_int_tag(datos_arch, 'L2')
canal_3 = extraer_int_tag(datos_arch, 'L3')
print("Amount of samples in channel 1: %s" %len(canal_1))
print("Amount of samples on channel 2: %s" %len(canal_2))
print("Amount of samples on channel 3: %s" %len(canal_3))
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))
message_string += "Amount of samples channel 3: {0} \n".format(len(canal_3))
self.show_message(self.text_message, message_string)
global g_canal_1, g_canal_2, g_canal_3
#Keep a copy of the original values
g_canal_1 = canal_1[:] #Copy list by value not by reference
g_canal_2 = canal_2[:]
g_canal_3 = canal_3[:]
self.window_var.set(1) #Option rectangular window
self.plot(self.tab1, self.tab2, canal_1, canal_2, canal_3, win_var=1)
def save_file(self):
ftypes = [('Text files', '*.txt'), ('All files', '*')]
dlg = filedialog.SaveAs(root, filetypes = ftypes)
fl = dlg.show()
if fl != '':
global g_canal_1, g_canal_2, g_canal_3
if (len(g_canal_1) > 0):
grabar(g_canal_1, g_canal_2, g_canal_3, 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 Notepad(tk.Tk):
"""A notepad application"""
def __init__(self):
super().__init__()
self.withdraw()
#this is how to check platform & set zoom status
platform = self.tk.call('tk', 'windowingsystem')
self.wm_state('zoomed') if platform == 'win32' else self.attributes(
'-zoomed', 1)
# code for naming file and about file variables.
self.file = pathlib.Path.cwd() / 'Untitled_notepad.txt'
self.file_defaults = {
'defaultextension': '*',
'filetypes': [('All Files', '.*')]
}
# code to find,search and replace variables
self.query = None
self.matches = None
self.findnext = None
self.findreplace = None
# code to do main menu setup
self.menu = tk.Menu(self)
self.configure(menu=self.menu)
self.menu_file = tk.Menu(self.menu, tearoff=False)
self.menu_edit = tk.Menu(self.menu, tearoff=False)
# file menu looks like
#To open a new file
self.menu_file.add_command(label='New',
accelerator='Ctrl+N',
command=self.new_file)
#To open already existing file.
self.menu_file.add_command(label='Open...',
accelerator='Ctrl+O',
command=self.open_file)
#To save the current file
self.menu_file.add_command(label='Save',
accelerator='Ctrl+S',
command=self.save_file)
#To save an existing file under new name
self.menu_file.add_command(label='Save As...',
accelerator='Ctrl+Shift+S',
command=self.save_file_as)
#To Exit current file or loation.
self.menu_file.add_command(label='Exit',
accelerator='Alt+F4',
command=self.quit_App)
# edit menu looks like
#To give a Feature of undo and Redo.
self.menu_edit.add_command(label='Redo',
accelerator='Ctrl+Y',
command=self.undo_edit)
self.menu_edit.add_command(label='Undo',
accelerator='Ctrl+Z',
command=self.redo_edit)
#To give a feature of cut,copy and Paste.
self.menu_edit.add_command(label='Cut',
accelerator='Ctrl+X',
command=self.text_cut)
self.menu_edit.add_command(label='Copy',
accelerator='Ctrl+C',
command=self.text_copy)
self.menu_edit.add_command(label='Paste',
accelerator='Ctrl+V',
command=self.text_paste)
#To give the feature of finding something and/or replacing it.
self.menu_edit.add_command(label='Find',
accelerator='Ctrl+F',
command=self.ask_find_next)
self.menu_edit.add_command(label='Find and Replace',
accelerator='Ctrl+H',
command=self.ask_find_replace)
#To get the current time and date at the begining of cursor.
self.menu_edit.add_command(label='Time/Date',
accelerator='F5',
command=self.get_datetime)
# code to add cascading menus to main menu
self.menu.add_cascade(label='File', menu=self.menu_file)
self.menu.add_cascade(label='Edit', menu=self.menu_edit)
# how to setup text widget
self.text_frame = tk.Frame(self)
self.text = ScrolledText(self.text_frame,
wrap=tk.WORD,
font='-size 20',
undo=True,
maxundo=10,
autoseparator=True,
blockcursor=False,
padx=5,
pady=10)
# set default tab size to 4 characters
self.font = tkfont.Font(family='Courier New',
size=12,
weight=tkfont.NORMAL,
slant=tkfont.ROMAN,
underline=False,
overstrike=False)
self.text.configure(font=self.font)
tab_width = self.font.measure(' ' * 4)
self.text.configure(tabs=(tab_width, ))
self.text.insert(tk.END,
self.file.read_text() if self.file.is_file() else '')
# packing up all widget to screen
self.text.pack(fill=tk.BOTH, expand=tk.YES)
self.text_frame.pack(fill=tk.BOTH, expand=tk.YES)
# adding up status bar
self.status_bar = StatusBar(self, self.text)
# this is the final setup
self.update_title()
#self.eval('tk::PlaceWindow . center')
self.deiconify()
# -------------defining FILE MENU starts--------------------------------------
def new_file(self, event=None):
"""Create a new file"""
# check for content change before opening new file
self.confirm_changes()
# reset text widget
self.text.delete(1.0, tk.END)
self.file = pathlib.Path.cwd() / 'Untitled_notepad.txt'
self.update_title()
def open_file(self, event=None):
"""Open an existing file"""
# check for content change before opening new file
self.confirm_changes()
# open new file
file = filedialog.askopenfilename(initialdir=self.file.parent,
**self.file_defaults)
if file:
self.text.delete(1.0, tk.END) # delete existing content
self.file = pathlib.Path(file)
self.text.insert(tk.END, self.file.read_text())
self.update_title()
self.status_bar.update_status()
def save_file(self, event=None):
"""Save the currently open file"""
if self.file.name == 'Untitled_notepad.txt':
file = filedialog.asksaveasfilename(initialfile=self.file,
**self.file_defaults)
self.file = pathlib.Path(file) if file else self.file
self.file.write_text(self.text.get(1.0, tk.END))
self.update_title()
def save_file_as(self, event=None):
"""Save the currently open file with a different name or location"""
file = filedialog.asksaveasfilename(initialdir=self.file.parent,
**self.file_defaults)
if file:
self.file = pathlib.Path(file)
self.file.write_text(self.text.get(1.0, tk.END))
self.update_title()
def confirm_changes(self):
"""Check to see if content has changed from original file; if so, confirm save"""
if self.file.is_file():
original = self.file.read_text()
current = self.text.get(1.0, tk.END)
if original != current:
confirm = messagebox.askyesno(
message="Save current file changes?")
if confirm:
self.save_file()
# new unsaved document with content is prompted to save
elif self.text.count(1.0, tk.END)[0] > 1:
confirm = messagebox.askyesno(message="Save current document?")
if confirm:
self.save_file()
def update_title(self):
"""Update the title with the file name"""
self.title(self.file.name + " - Notepad")
def quit_App(self):
"""Quit application after checking for user changes"""
self.confirm_changes()
self.destroy()
#-----------------FILE Menu definition Ends--------------------------------
#-----------------EDIT MENU definition starts------------------------------
def undo_edit(self):
"""Undo the last edit in the stack"""
try:
self.text.edit_undo()
except tk.TclError:
pass
def redo_edit(self):
"""Redo the last edit in the stack"""
try:
self.text.edit_redo()
except tk.TclError:
pass
def text_copy(self):
"""Append selected text to the clipboard"""
selected = self.text.get(tk.SEL_FIRST, tk.SEL_LAST)
self.text.clipboard_clear()
self.text.clipboard_append(selected)
def text_paste(self):
"""Paste clipboard text into text widget at cursor"""
self.text.insert(tk.INSERT, self.text.clipboard_get())
def text_cut(self):
"""Cut selected text and append to clipboard"""
selected = self.text.get(tk.SEL_FIRST, tk.SEL_LAST)
self.text.delete(tk.SEL_FIRST, tk.SEL_LAST)
self.text.clipboard_clear()
self.text.clipboard_append(selected)
def quit_application(self, event=None):
"""Quit application after checking for user changes"""
self.confirm_changes()
self.destroy()
def ask_find_next(self, event=None):
"""Create find next popup widget"""
self.findnext = Find(self, self.text)
def ask_find_replace(self, event=None):
"""Create replace popup widget"""
self.findreplace = Replace(self, self.text)
def get_datetime(self, event=None):
"""insert date and time at cursor position"""
self.text.insert(tk.INSERT, datetime.datetime.now().strftime("%c"))
class AppGUI(Frame):
def __init__(self, master=None):
# Avoiding to send it continuously.
self.lock = False
Frame.__init__(self, master)
self.grid()
self.master = master
# Setting for ComboBox.
self.url_lang_combobox_str = StringVar()
self.url_lang_combobox_list = lang_list
# UI components.
self.receiver_email_text = Label(self, text="Receiver:")
self.receiver_email_field = Entry(self, width=50)
self.subject_text = Label(self, text='Subject:')
self.subject_field = Entry(self, width=50)
self.receiver_name_text = Label(self, text='Name:')
self.receiver_name_field = Entry(self, width=50)
self.url_lang_text = Label(self, text='Link lang:')
self.url_lang_combobox = Combobox(self, textvariable=self.url_lang_combobox_str, values=self.url_lang_combobox_list, state='readonly')
self.send_progressbar = Progressbar(self, orient='horizontal', length=500, mode='determinate', maximum=300)
self.send_button = Button(self, text='Send', command=self._send_mail)
self.quit_button = Button(self, text='Exit', command=self.__exit)
self.log_msg_text = ScrolledText(self)
# Attachment.
self.mail_attachment_list = attachment_list[:]
self.url_lang_link_title = None
self.url_lang_link = copy.deepcopy(content_link)
# Mailer
self._mailer = None
# Let Mailer can control components.
Mailer.window_content = self
self.__create_widgets()
def _send_mail(self):
if not self.lock:
threading.Thread(target=self.__send_mail).start()
else:
messagebox.showinfo('Warning', "Now it's processing...")
def _choose(self, event):
# arr = self.url_lang_link.get(self.url_lang_combobox_str.get()) # Get the array by choosing language.
pass
def _modify_content_url_link(self):
link_arr = self.url_lang_link.get(self.url_lang_combobox_str.get())
content = self._mailer.content
for index in range(len(link_arr)):
content_index = content.index(self.url_lang_link_title[index]) + len(self.url_lang_link_title[index])
content = content[:content_index] + '\n' + link_arr[index] + content[content_index:]
self._mailer.content = content
return False
def _make_mailer(self):
self.mail_attachment_list = attachment_list[:] # Clone a list.
if atta_lang_list[self.url_lang_combobox.current()]:
for i in range(len(self.mail_attachment_list)):
# Only from the third file to the end file can change language.
if i > 2:
# Modify the file name.
att = self.mail_attachment_list[i].split('.')
self.mail_attachment_list[i] = ''.join([' ', atta_lang_list[self.url_lang_combobox.current()], '.']).join(att)
# ** IMPORTANT, we set the content path here!!
path = 'content.docx'
if self.url_lang_combobox.get() == lang_list[2] or self.url_lang_combobox.get() == lang_list[3]:
path = 'content chinese.docx'
if debug_log:
print(self.mail_attachment_list)
# ** IMPORTANT, we have to new an object here. Otherwise, we couldn't check the error checking.
return Mailer(content_path=path, attachment_list=self.mail_attachment_list)
def __create_widgets(self):
"""
Construct all of the UI components.
"""
self.receiver_email_text.grid(row=0, column=0)
self.receiver_email_field.grid(row=0, column=1, columnspan=6)
self.subject_text.grid(row=1, column=0)
self.subject_field.grid(row=1, column=1, columnspan=6)
self.subject_field.insert(0, 'Osaka Mariko Apartment Location & Condition')
self.receiver_name_text.grid(row=2, column=0)
self.receiver_name_field.grid(row=2, column=1, columnspan=6)
self.url_lang_text.grid(row=3, column=0)
self.url_lang_combobox.grid(row=3, column=2, columnspan=2)
self.send_progressbar.grid(row=4, column=0, columnspan=7)
self.send_button.grid(row=5, column=2)
self.quit_button.grid(row=5, column=3)
self.log_msg_text.grid(row=6, column=0, columnspan=7)
# Default setting.
self.url_lang_combobox.current(0)
self.url_lang_combobox.bind("<<ComboboxSelected>>", self._choose)
def __exit(self):
if not self.lock:
self.log_msg_text.insert(END, '\n\n -- Bye Bye --\n')
self.master.quit()
else:
messagebox.showinfo('Error', "Now it's processing...please wait it ;)")
@DecoratorThreadLockerApp()
@DecoratorErrorCheckAndInitApp()
def __send_mail(self):
self.send_progressbar.start() # Start processing the progress.
ending = 'Welcome to use my application :)' if self._mailer.send_mail() \
else '** Your sending was failed :( please send it again!'
self.log_msg_text.insert(END, ending)
self.send_progressbar.stop() # Stop processing the progress.
class Window(Listbox):
# Initializes the variables and settings for the project. Finally
# executes the create_menu for the menu bar, and the create_notepad
# for the text window
def __init__(self, master, **kw):
# Sets master, or root
super().__init__(master, **kw)
self.master = master
# Set some variables
self.current_file_path = ''
self.current_file_text = ''
self.is_saved = True
# Set up the context menu and the text box
self.context_popup_menu = Menu(self.master, tearoff=0)
self.text_window = ScrolledText(self.master, undo=True)
self.text_window.focus()
self.user_data = self.text_window.get('1.0', END + '-1c')
# Name the window, icon, and start the create functions
self.master.title(NAME)
# self.master.iconbitmap('./tk/images/icon.ico')
self.initiate_shortcuts()
self.create_menu()
self.create_notepad()
self.create_context_menu()
# Creates the context menu
def create_context_menu(self):
# Adds a command for button, separator for separator
self.context_popup_menu.add_command(label="Undo",
command=lambda: self.undo())
self.context_popup_menu.add_command(label="Redo",
command=lambda: self.redo())
self.context_popup_menu.add_separator()
self.context_popup_menu.add_command(
label="Cut",
command=lambda: self.text_window.event_generate("<<Cut>>"))
self.context_popup_menu.add_command(
label="Copy",
command=lambda: self.text_window.event_generate("<<Copy>>"))
self.context_popup_menu.add_command(
label="Paste",
command=lambda: self.text_window.event_generate("<<Paste>>"))
self.context_popup_menu.add_separator()
self.context_popup_menu.add_command(label="Delete",
command=lambda: self.clear())
self.context_popup_menu.add_separator()
self.context_popup_menu.add_command(label="Select All",
command=lambda: self.select_all())
# Creates the top bar menu
def create_menu(self):
# Creating menu bar and adding it to master
menu_bar = Menu(self.master)
text = self.text_window
# Telling root that menu_bar is the Window's menu
self.master.config(menu=menu_bar)
# Creating the File menu dropdown
file_menu = Menu(menu_bar, tearoff=False)
file_menu.add_command(label="New Document...",
command=self.new_file,
accelerator="Ctrl+N")
file_menu.add_command(label="Open Document...",
command=self.open_file,
accelerator="Ctrl+O")
file_menu.add_command(label="Save...",
command=self.save_file,
accelerator="Ctrl+S")
file_menu.add_command(label="Save as...",
command=self.save_as_file,
accelerator="Ctrl+Shift+S")
file_menu.add_separator()
file_menu.add_command(label="Quit",
command=self.exit,
accelerator="Ctrl+Q")
# Adding it to the menu_bar
menu_bar.add_cascade(label="File", menu=file_menu, underline=0)
# Creating the Edit menu dropdown
edit_menu = Menu(menu_bar, tearoff=False)
edit_menu.add_command(label="Undo",
command=self.undo,
accelerator="Ctrl+Z")
edit_menu.add_command(label="Redo",
command=self.redo,
accelerator="Ctrl+Y")
edit_menu.add_separator()
edit_menu.add_command(label="Cut",
command=lambda: text.event_generate("<<Cut>>"),
accelerator="Ctrl+X")
edit_menu.add_command(label="Copy",
command=lambda: text.event_generate("<<Copy>>"),
accelerator="Ctrl+C")
edit_menu.add_command(label="Paste",
command=lambda: text.event_generate("<<Paste>>"),
accelerator="Ctrl+V")
edit_menu.add_separator()
edit_menu.add_command(label="Select All",
command=lambda: self.select_all(),
accelerator="Ctrl+A")
edit_menu.add_command(label="Delete",
command=self.clear,
accelerator="Del")
# edit_menu.add_separator()
# edit_menu.add_command(label="Settings...", command=settings, accelerator="Ctrl+S")
# Adding it to the menu_bar
menu_bar.add_cascade(label="Edit", menu=edit_menu)
# Creating the Help menu
help_menu = Menu(menu_bar, tearoff=False)
help_menu.add_command(label="About...", command=about)
# Adding it to the menu_bar
menu_bar.add_cascade(label="Help", menu=help_menu)
# Bind the shortcuts to their specified functions
def initiate_shortcuts(self):
self.master.bind("<KeyRelease>", lambda event: self.on_text_change())
self.master.bind("<Control-n>", lambda event: self.new_file())
self.master.bind("<Control-o>", lambda event: self.open_file())
self.master.bind("<Control-s>", lambda event: self.save_file())
self.master.bind("<Control-Shift-s>",
lambda event: self.save_as_file())
self.master.bind("<Control-q>", lambda event: self.exit())
self.master.bind("<Control-z>", lambda event: self.undo())
self.master.bind("<Control-y>", lambda event: self.redo())
self.text_window.bind("<Control-a>", lambda event: self.select_all())
# self.master.bind("<Control-s>", lambda event: settings())
self.master.bind("<Button-3>",
lambda event: self.right_click_popup(event))
# Display context menu popup
def right_click_popup(self, event):
try:
# Used +45 and + 12 to corner it
self.context_popup_menu.tk_popup(event.x_root + 45,
event.y_root + 12, 0)
finally:
self.context_popup_menu.grab_release()
# Scaling the text_window to fit the screen
def create_notepad(self):
self.text_window.pack(fill="both", expand=True)
# Returns the value of the text field
def get_text_data(self):
return self.text_window.get('1.0', END + '-1c')
# Clears the text off the screen, resets the variables
def clear_text(self):
self.text_window.delete('1.0', END)
self.current_file_path = ''
self.current_file_text = ''
# Called when typing, sets the is_saved variable
def on_text_change(self):
# If the text in the textbox is equal to the saved text in the variable
# This is used when opening a file, changing something, then undoing that change
if self.get_text_data() == self.current_file_text:
self.is_saved = True
else:
# If the saved file exists or is valid
if os.path.isfile(self.current_file_path):
# Open the file, save it's data to this_file
with open(self.current_file_path, "r") as f:
this_file = f.read()
# If this_file is equal to the same text in the textbox
# Used if no changes were made, and if they were, set to False
self.is_saved = True if this_file == self.get_text_data(
) else False
else:
# If the data is not equal to variable, and no file, then changes
# must have been made
self.is_saved = False
# MENU CONTROL FUNCTIONS
# Clear current selection, erase the current file if saved
def new_file(self):
# If it's saved, clear it and set the file to saved
if self.is_saved is True:
self.clear_text()
self.is_saved = True
else:
# Popup the saved popup
popup_value = is_saved_popup()
if popup_value == "yes":
# Save the file, clear it and set the is_saved to True
if self.save_file() is True:
self.clear_text()
self.is_saved = True
elif popup_value == "no":
# Don't save the file, but clear it and set the is_saved to True
self.clear_text()
self.is_saved = True
else:
# Something went wrong
print("Error: new_file error")
# Open a file if the current file is saved, then insert new file data
def open_file(self):
# If file is saved, open the open_file window
if self.is_saved is True:
self.open_file_popup()
else:
# Save the file, if it's saved, open the open_file window
popup_value = is_saved_popup()
if popup_value == "yes":
if self.save_file() is True:
self.is_saved = True
self.open_file_popup()
# Open the open_file window
elif popup_value == "no":
self.open_file_popup()
else:
# An error occurred
print("Error: open_file error")
# The function that displays the open_file popup
def open_file_popup(self):
# Gets old data from current file
old_file = self.current_file_path
# Opens the file location, stores it in file_name
file_name = filedialog.askopenfilename(
title="Open",
filetypes=(("Text files", "*.txt"), ("All files", "*.*")))
# If a file was actually selected, open it
if file_name is not '':
with open(file_name) as f:
data = f.read()
# Clear current text
self.clear_text()
# Set the path variable of the new file
self.current_file_path = file_name if os.path.isfile(
file_name) else old_file
# Add the file data to the text_box
self.text_window.insert(INSERT, data)
# Add the file data to the variable
self.current_file_text = data
# is_saved is True
self.is_saved = True
# Save file, if file exists, overwrite it, otherwise, call save_as_file function
def save_file(self):
# If the file path exists
if os.path.isfile(self.current_file_path):
# Stores the current text data into the variable
self.current_file_text = self.get_text_data()
# Saves the data to the existing file (overwriting)
with open(self.current_file_path, "w") as f:
return True if f.writelines(
self.get_text_data()) is True else False
else:
# File doesn't exist, call save_as_file
if self.save_as_file() is True:
return True
# Saves file with asksaveasfile to open a save as window.
def save_as_file(self):
# Gets old file path
old_file = self.current_file_path
# Opens save_as window
file_name = filedialog.asksaveasfilename(
title="Save As",
defaultextension=".txt",
filetypes=(("Text files", "*.txt"), ("All files", "*.*")))
# Set current file path
self.current_file_path = old_file if file_name is None else file_name
# If the file_path already exists
if os.path.isfile(self.current_file_path):
# Copy the current text to the variable
self.current_file_text = self.get_text_data()
# Writes to the named file
with open(self.current_file_path, "w") as f:
f.writelines(self.get_text_data())
return True
else:
# A file wasn't selected
if file_name is '':
print("Error: File is none")
return False
# Create a new file to store the data
self.current_file_text = self.get_text_data()
with open(file_name, 'w'):
pass
self.is_saved = True
return True
# Exit override command
def exit(self):
# If the file is saved, exit
if self.is_saved is True:
self.master.quit()
else:
# If the file is not saved, call the saved_popup
popup_value = is_saved_popup()
if popup_value == "yes":
# Save and then quit
if self.save_file() is True:
self.is_saved = True
self.quit()
elif popup_value == "no":
# Don't save, just quit
self.master.quit()
else:
# An error occurred
print("Error: open_file error")
# Undo last action
def undo(self):
self.text_window.edit_undo()
# Redo last action
def redo(self):
self.text_window.edit_redo()
# Clear (delete) the selected text
def clear(self):
self.text_window.delete(SEL_FIRST, SEL_LAST)
self.text_window.update()
# Select the selected text (without new line)
def select_all(self):
self.text_window.tag_add(SEL, "1.0", END + '-1c')
self.text_window.mark_set(INSERT, "1.0")
self.text_window.see(INSERT)
return 'break'
class ChatGUI(Frame):
def __init__(self, parent, conn):
#Frame.__init__(self, parent, background="grey")
self.parent = parent
self.conn = conn
self.centerWindow()
self.initUI()
def initUI(self):
#mettere qui tutta l'inizializzazione dei frame anche
#direi 2 frame, uno left e uno right
self.parent.title("Python Chat")
frame = Frame(self.parent)
frame.pack(fill=BOTH, expand=1, side=LEFT)
self.box = ScrolledText(frame, wrap=WORD, relief = GROOVE, width=1, height=20)
self.box.insert(END, 'Welcome to Python Chat!')
self.box.config(state=DISABLED)
self.box.pack(expand="yes", fill=BOTH, side=TOP)
self.textarea = Text(frame, width=1, height=5)
#self.textarea.insert(END, "")
self.textarea.bind("<KeyRelease-Return>", self.gettext) #Se metto on press, rimane una newline in piu
self.textarea.pack(expand="yes", fill=BOTH, side=TOP)
okButton = Button(frame, text="Attach file", activebackground="green", command=self.sendFile)
okButton.pack(expand="no", fill=BOTH, side=TOP)
#per gestire invio con la newline --> http://userpages.umbc.edu/~dhood2/courses/cmsc433/spring2010/?section=Notes&topic=Python¬es=93
#usersFrame = Frame(self.parent)
#usersFrame.pack(fill=BOTH, expand=1, side=RIGHT)
def centerWindow(self):
w = 600
h = 450
sw = self.parent.winfo_screenwidth()
sh = self.parent.winfo_screenheight()
x = (sw - w)/2
y = (sh - h)/2
self.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))
def gettext(self, e): #e sta per event, questo e' un listener
text = self.textarea.get("1.0", END + " - 2c") # 1.0: row:columa - END-2c rimuove l'ultimo carattere, una newline \r\n
self.textarea.delete("0.0", END) #NON VA: il problema e' che viene inviato il carattere di newline ma non incluso nell'area a causa della bind mi sa. Devo escluderlo io
self.sendToServer(text)
def printConversation(self, message):
self.box.config(state=NORMAL)
self.box.insert(END,"\n" + message)
#aggiungo colorazione parte di testo --> troppo complesso per ora
''''m = re.search("", message)
lastIndex = len(m.group(0))
self.box.tag_add("header", m.start(), m.stop())
self.box.tag_config("header", foreground="green")
'''
self.box.config(state=DISABLED)
#self.box.yview_scroll(10000,"units")
self.box.see(END)
def sendToServer(self, messageToSend):
self.conn.send(messageToSend.encode(encoding='utf_8', errors='strict'))
def sendFile(self):
#aprire una dialog di quelle predefinite (Sfoglia...)
#capire come fare la send di un file sul socket...
pass
#! python3 # noqa: E265
"""
To test https://github.com/Guts/DicoGIS/issues/18
"""
import tkinter as tk
import tkinter.font as tkfont
from tkinter.scrolledtext import ScrolledText
root = tk.Tk()
frame = tk.LabelFrame(root, text="Polices")
frame.grid()
ft = tkfont.families()
txt = ScrolledText(frame, width=50, height=20)
txt.grid()
txt.insert("1.0", "Polices:\n")
txt.tag_add("tagpolices", "1.0", "insert")
for i, f in enumerate(ft):
font = tkfont.Font(frame, size=20, family=f)
tag = f"tag{i}"
txt.tag_config(tag, font=font)
txt.insert("end", f, tag, "\n")
root.mainloop()
