def addVar(self,
names,
lbs,
ubs,
tols,
currValues,
_name='',
_lb='',
_ub='',
_tol='',
_val=''):
nameEntry, lb, ub, tol, valEntry = Entry(names), Entry(lbs), Entry(
ubs), Entry(tols), Entry(currValues)
nameEntry.insert(0, _name)
lb.insert(0, _lb)
ub.insert(0, _ub)
tol.insert(0, _tol)
valEntry.insert(0, _val)
self.NameEntriesList.append(nameEntry)
self.LB_EntriesList.append(lb)
self.UB_EntriesList.append(ub)
self.TolEntriesList.append(tol)
self.ValueEntriesList.append(valEntry)
nameEntry.pack(side='top')
lb.pack(side='top')
ub.pack(side='top')
tol.pack(side='top')
valEntry.pack(side='top')
class FInput:
""" Class created to manipulate files for output """
def __init__(self, master, label=""):
self.label = Label(master, text=label)
self.entry = Entry(master)
self.button = Button(master, text="Open", command=self.getLoadName)
self.options = {}
def __call__(self):
return self.entry.get()
def set(self, value):
self.entry.delete(0, END)
self.entry.insert(0, value)
def setOptions(self, options):
""" Getting the options """
self.options = options
def getLoadName(self):
""" The method that takes the filename """
filename = tkFileDialog.askopenfilename(**self.options)
self.entry.delete(0, END)
self.entry.insert(0, filename)
def enable(self):
self.label.config(state=NORMAL)
self.entry.config(state=NORMAL)
self.button.config(state=NORMAL)
def disable(self):
self.label.config(state=DISABLED)
self.entry.config(state=DISABLED)
self.button.config(state=DISABLED)
def create_file_entry(_master_, ups_frame, fi_text, _default_file):
''' Quite self explanatoy...
creates a row in which is possible to search for a file'''
file_row = Frame(ups_frame)
f_ex = ((fi_text, '.' + _default_file.split('.')[-1]), )
_f_labels = format_dec([file_row, fi_text], _pack_=False)
Efile = Entry(file_row, width=13)
Efile.insert(END, _default_file)
Efile.xview_moveto(1)
Bsearch = Button(file_row,
image=get_file_img(),
command=(lambda El=Efile: _master_.browsefile(El, f_ex)))
# Just packing
format_dec(_f_labels, _create_=False)
Efile.pack(side='left', expand='yes', fill=X)
Bsearch.pack(side='right', padx=0, pady=0)
file_row.pack(side='top', fill=X, pady=3)
# For tracing purposes list appending
return Efile
class ClsFrmKeyValue(Frame):
"""
Класс обеспечивает работу с парой ключ:значение.
"""
def __init__(self, root=None, key='Key', value='None'):
"""
Конструтирует пару ключ:значение.
:param root:
:param key:
:param value:
:return:
"""
self.__root = root
Frame.__init__(self, master=root, border=2, relief='ridge')
self.pack(fill='x', side='top')
self.lbl_key = Label(self, text=key, border=1, relief='ridge', width=14)
self.lbl_key.pack(side='left', fill='x', expand=1)
self.ent_val = Entry(self, border=1, relief='groove')
self.ent_val.pack(side='left', fill='x', expand=1)
self.ent_val.delete(0, 'end')
self.ent_val.insert(0, value)
def get_val(self):
"""
Возвращает значение ключа из пары ключ:значение.
:return:
"""
return self.ent_val.get()
def createfileentry(self, parent_frame, fi_text, _def_fi_, f_ex=None):
''' Quite self explanatoy...
creates a row in which is possible to search for a file'''
file_row = Frame(parent_frame)
if f_ex == None:
f_ex = ((fi_text, '.' + _def_fi_.split('.')[-1]), )
_f_labels = format_dec([file_row, fi_text], _pack_=False)
Efile = Entry(file_row, width=13)
Efile.insert('end', _def_fi_)
Efile.bind("<Key>", lambda e: "break") # Magic
Efile.xview_moveto(1)
Bsearch = Button(file_row,
image=self.im_file,
command=(lambda El=Efile: self.browsefile(El, f_ex)))
# Just packing
format_dec(_f_labels, _create_=False)
Efile.pack(side='left', expand='yes', fill='x')
Bsearch.pack(side='right', padx=0, pady=0)
file_row.pack(side='top', fill='x', pady=3)
# For tracing purposes list appending
return Efile
class LoginDialog(tkSimpleDialog.Dialog):
def body(self, login_frame):
Label(login_frame,
text='Sie sind noch nicht auf \
http://www.sleeptracker.net eingeloggt!'
).grid(row=0, column=0, columnspan=2, sticky=W + E)
Label(login_frame,
text='Bitte loggen Sie sich ein.'
).grid(row=1, column=0, columnspan=2, sticky=W + E)
Label(login_frame, text='').grid(row=2, column=0)
Label(login_frame,
text='Benutzername (eMail):'
).grid(row=3, column=0, sticky=W)
Label(login_frame,
text='Passwort:').grid(row=4, column=0, sticky=W)
Label(login_frame, text='').grid(row=5, column=0)
self.user = Entry(login_frame)
self.user.insert(0, 'Benutzername')
self.pwd = Entry(login_frame, show='*')
self.pwd.insert(0, '')
self.user.grid(row=3, column=1)
self.pwd.grid(row=4, column=1)
# initial focus
return self.user
def apply(self):
username = str(self.user.get())
password = str(self.pwd.get())
self.result = username, password
class Input:
def __init__(self,
master,
label,
default,
row_n,
column_n=0,
pad_y=5,
width_n=15,
secondary_label=None):
Label(master, text=label).grid(row=row_n,
column=column_n,
padx=10,
pady=pad_y,
sticky='e')
f = tk.Frame(master)
f.grid(row=row_n, column=column_n + 1, sticky='w')
self.input = Entry(f, width=width_n)
self.input.grid(row=row_n, column=0, pady=pad_y, sticky='w')
self.input.insert(tk.END, default)
if not secondary_label == None:
Label(f, text=secondary_label).grid(row=row_n,
column=1,
pady=pad_y,
sticky='w')
def get(self):
return self.input.get()
class readInputParams:
def __init__(self, master):
self.master = master
master.title("Enter Filter Criteria:")
self.label_CANSLIMParams = Label(master,
text="CANSLIM EPS Parameters:")
self.label_latestYear = Label(master, text="Latest Year")
self.label_prevYear = Label(master, text="Previous Year")
self.label_prevprevYear = Label(master, text="2nd Prev Year")
self.label_currentQtr = Label(master, text="current Qtr")
self.label_QtrEPSAlone = Label(master, text="Quater EPS Growth alone")
self.filter_button = Button(master,
text="Filter",
command=lambda: self.runFilter())
self.entry_EPSY1 = Entry(master)
self.entry_EPSY2 = Entry(master)
self.entry_EPSY3 = Entry(master)
self.entry_EPSCurrQtr = Entry(master)
self.entry_EPSQtrAlone = Entry(master)
#layout
#first row
self.label_latestYear.grid(row=1, column=2)
self.label_prevYear.grid(row=1, column=3)
self.label_prevprevYear.grid(row=1, column=4)
self.label_currentQtr.grid(row=1, column=5)
#second row
self.label_CANSLIMParams.grid(row=2, column=1)
self.entry_EPSY1.grid(row=2, column=2)
self.entry_EPSY2.grid(row=2, column=3)
self.entry_EPSY3.grid(row=2, column=4)
self.entry_EPSCurrQtr.grid(row=2, column=5)
#third row
self.label_QtrEPSAlone.grid(row=3, column=1)
self.entry_EPSQtrAlone.grid(row=3, column=2)
#fourth row
self.filter_button.grid(row=4, column=1)
#set default values
self.entry_EPSY1.insert(0, 10)
self.entry_EPSY2.insert(0, 8)
self.entry_EPSY3.insert(0, 0)
self.entry_EPSCurrQtr.insert(0, 15)
self.entry_EPSQtrAlone.insert(0, 10)
def runFilter(self):
EPSY1 = self.entry_EPSY1.get()
EPSY2 = self.entry_EPSY2.get()
EPSY3 = self.entry_EPSY3.get()
EPSCurrQtr = self.entry_EPSCurrQtr.get()
EPSQtrAlone = self.entry_EPSQtrAlone.get()
print("in filter Y1 %s Y2 %s Y3 %s Curren %s QtrAlone %s" %
(EPSY1, EPSY2, EPSY3, EPSCurrQtr, EPSQtrAlone))
getCompleteReport(EPSY1, EPSY2, EPSY3, EPSCurrQtr, EPSQtrAlone)
print("CompleteReport Done..\n")
class ReadOnlyEntry(Frame):
def __init__(self, master, withFocus = True):
'''
withFocus -> enabled
User can set the widget to focus, but the widget will not update
while it has user focus (even programatically it cannot be updated)
withFocus -> disabled
User cannot set focus on the Entry widget. The moment it gets focus,
focus is shifted to a dummy Frame.
Widget can be updated programatically anytime.
Note: in both cases the widget is readonly
'''
Frame.__init__(self, master)
self.master = master
self.withFocus = withFocus
self.hasFocus = False
vcmd = (self.master.register(self.onValidate),
'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
self.readOnlyEntry = Entry(self, justify=CENTER, validate="all", validatecommand=vcmd, width=50)
self.readOnlyEntry.grid(row=0, column=0)
self.dummyFrame = Frame(self)
self.dummyFrame.grid(row=0, column=1)
def onValidate(self, d, i, P, s, S, v, V, W):
"""
If withFocus is True, then do not accept keyboard inputs
If withFocus is False, set focus to the dummy Frame that is not visible
"""
if self.withFocus == True:
if V == "focusin":
self.hasFocus = True
elif V == "focusout":
self.hasFocus = False
if self.hasFocus == False and V == "key":
return True
else:
return False
else:
if V == "focusin":
self.dummyFrame.focus_set()
return True
def configure(self, **kwargs):
self.readOnlyEntry.configure(**kwargs)
def config(self, **kwargs):
self.configure(**kwargs)
def get(self):
return self.readOnlyEntry.get()
def set(self, text):
self.readOnlyEntry.delete(0, END)
self.readOnlyEntry.insert(0, text)
def makeentry(parent, caption, cur, row, column=0, ro=False, **options):
Label(parent, text=caption).grid(row=row, column=column)
entry = Entry(parent, **options)
entry.insert(0, '%s' % cur)
if ro:
entry.config(state='readonly')
entry.grid(row=row, column=column + 1)
return entry
def add_entries(self,vl):
for el in vl:
if not hasattr(self.ea,el['name']):
raise TypeError('you try to set up an entry for a name which is no attribute of the chosen EA')
fr=Frame(self.f_actn); fr.pack()
lab=Label(fr,text=el['name']); lab.pack()
e = Entry(fr); e.pack(); e.insert(0,str(el['inival'])) # number of generations
el['Entry']=e
class UsernameOverlay(Overlay):
def __init__(self, *args, **kwargs):
Overlay.__init__(self, *args, **kwargs)
self.label = ""
self.field = ""
self.button = ""
self.user = ""
self.logger = JPYLogger(self)
self.config(
background="gold",
cursor="arrow"
)
self.renderLabel()
self.renderField()
self.renderButton()
def renderLabel(self):
self.label = Label(self)
self.label.config(
text="CHANGE PLAYERNAME",
font=Fonts.MONEY_BIG,
background="gold"
)
self.label.pack()
def renderField(self):
self.field = Entry(self)
self.field.config(
relief="solid",
bd=2,
highlightcolor="black",
font=Fonts.USER_LABEL_NAME_BIG
)
self.field.pack()
def renderButton(self):
Label(self, text='\n', background="gold").pack()
self.button = Button(self)
self.button.config(
text="OK",
relief="solid",
background="black",
foreground="gold",
font=Fonts.MONEY_MEDIUM,
command=self.save
)
self.button.pack()
def save(self):
self.logger.prompt("User " + str(self.user.id) + " changed name from '" + self.user.name.get() + "' to '" + self.field.get() + "'")
self.user.name.set(self.field.get())
self.hide(self)
self.root.root.inputController.blockBuzzer = False
def insert(self, user):
self.field.delete(0, END)
self.field.insert(0, user.name.get())
def makeROEntry(parent, row, column, label, initVal):
lbl = Label(parent, text = label)
lbl.grid(row = row, column = column)
entry = Entry(parent)
entry.grid(row = row, column = column + 1)
entry['readonly'] = 'gray10'
entry.insert(0, initVal)
entry['state'] = 'readonly'
return lbl, entry
class Scroller(object):
"""
Scrolls through a solution list.
"""
def __init__(self, wdw, sols):
"""
Stores the list of solutions in sols
and defines the layout of the GUI.
"""
wdw.title('solutions scroller')
self.sols = sols
self.cursor = 0
self.lbl = Label(wdw, text="solution : ")
self.lbl.grid(row=0, column=0, sticky=E)
self.ent = Entry(wdw)
self.ent.grid(row=0, column=1, stick=W)
self.ent.insert(INSERT, "0 of %d" % len(sols))
self.myft = Font(family="Courier New", size=12, weight="normal")
self.mlen = self.myft.measure("M")
lines = sols[0].split('\n')
self.width = max([len(line) for line in lines])
self.display = StringVar()
self.display.set(self.sols[0])
self.mess = Message(wdw, textvariable=self.display, \
font=self.myft, width=self.width*self.mlen, background='white')
self.mess.grid(row=1, column=0, columnspan=2)
self.btnext = Button(wdw, command=self.next, text='next')
self.btnext.grid(row=2, column=1, sticky=W+E)
self.btprev = Button(wdw, command=self.previous, text='previous')
self.btprev.grid(row=2, column=0, sticky=W+E)
def show(self):
"""
Shows the solution at position self.cursor
in the message widget and updates the entry widget.
"""
self.display.set(self.sols[self.cursor])
self.ent.delete(0, END)
self.ent.insert(INSERT, '%d of %d' % (self.cursor, len(self.sols)))
def next(self):
"""
Increases the cursor by one if possible.
"""
if self.cursor < len(self.sols) - 1:
self.cursor = self.cursor + 1
self.show()
def previous(self):
"""
Decreases the cursor by one if possible.
"""
if self.cursor > 0:
self.cursor = self.cursor - 1
self.show()
class readInputParams:
def __init__(self, master):
self.master = master
master.title("Enter Filter Criteria:")
self.label_CANSLIMParams = Label(master, text="CANSLIM EPS Parameters:")
self.label_latestYear = Label(master, text="Latest Year")
self.label_prevYear = Label(master, text="Previous Year")
self.label_prevprevYear = Label(master, text="2nd Prev Year")
self.label_currentQtr = Label(master, text="current Qtr")
self.label_QtrEPSAlone = Label(master, text="Quater EPS Growth alone")
self.filter_button = Button(master, text="Filter", command=lambda: self.runFilter())
self.entry_EPSY1 = Entry(master)
self.entry_EPSY2 = Entry(master)
self.entry_EPSY3 = Entry(master)
self.entry_EPSCurrQtr = Entry(master)
self.entry_EPSQtrAlone = Entry(master)
#layout
#first row
self.label_latestYear.grid(row=1, column=2)
self.label_prevYear.grid(row=1, column=3)
self.label_prevprevYear.grid(row=1, column=4)
self.label_currentQtr.grid(row=1, column=5)
#second row
self.label_CANSLIMParams.grid(row=2, column=1)
self.entry_EPSY1.grid(row=2, column=2)
self.entry_EPSY2.grid(row=2, column=3)
self.entry_EPSY3.grid(row=2, column=4)
self.entry_EPSCurrQtr.grid(row=2, column=5)
#third row
self.label_QtrEPSAlone.grid(row=3, column=1)
self.entry_EPSQtrAlone.grid(row=3, column=2)
#fourth row
self.filter_button.grid(row=4, column=1)
#set default values
self.entry_EPSY1.insert(0, 10)
self.entry_EPSY2.insert(0, 8)
self.entry_EPSY3.insert(0, 0)
self.entry_EPSCurrQtr.insert(0, 15)
self.entry_EPSQtrAlone.insert(0, 10)
def runFilter(self):
EPSY1 = self.entry_EPSY1.get()
EPSY2 = self.entry_EPSY2.get()
EPSY3 = self.entry_EPSY3.get()
EPSCurrQtr = self.entry_EPSCurrQtr.get()
EPSQtrAlone = self.entry_EPSQtrAlone.get()
print("in filter Y1 %s Y2 %s Y3 %s Curren %s QtrAlone %s" %(EPSY1, EPSY2, EPSY3, EPSCurrQtr, EPSQtrAlone))
getCompleteReport(EPSY1, EPSY2, EPSY3, EPSCurrQtr, EPSQtrAlone)
print("CompleteReport Done..\n")
class Scroller(object):
"""
Scrolls through a solution list.
"""
def __init__(self, wdw, sols):
"""
Stores the list of solutions in sols
and defines the layout of the GUI.
"""
wdw.title('solutions scroller')
self.sols = sols
self.cursor = 0
self.lbl = Label(wdw, text="solution : ")
self.lbl.grid(row=0, column=0, sticky=E)
self.ent = Entry(wdw)
self.ent.grid(row=0, column=1, stick=W)
self.ent.insert(INSERT, "0 of %d" % len(sols))
self.myft = Font(family="Courier New", size=12, weight="normal")
self.mlen = self.myft.measure("M")
lines = sols[0].split('\n')
self.width = max([len(line) for line in lines])
self.display = StringVar()
self.display.set(self.sols[0])
self.mess = Message(wdw, textvariable=self.display, \
font=self.myft, width=self.width*self.mlen, background='white')
self.mess.grid(row=1, column=0, columnspan=2)
self.btnext = Button(wdw, command=self.next, text='next')
self.btnext.grid(row=2, column=1, sticky=W + E)
self.btprev = Button(wdw, command=self.previous, text='previous')
self.btprev.grid(row=2, column=0, sticky=W + E)
def show(self):
"""
Shows the solution at position self.cursor
in the message widget and updates the entry widget.
"""
self.display.set(self.sols[self.cursor])
self.ent.delete(0, END)
self.ent.insert(INSERT, '%d of %d' % (self.cursor, len(self.sols)))
def next(self):
"""
Increases the cursor by one if possible.
"""
if self.cursor < len(self.sols) - 1:
self.cursor = self.cursor + 1
self.show()
def previous(self):
"""
Decreases the cursor by one if possible.
"""
if self.cursor > 0:
self.cursor = self.cursor - 1
self.show()
def initUI(self):
# Main Window
self.parent.title("gBot")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=1)
# Debug Window
Toplevel1 = Toplevel(self)
Toplevel1.title("gBot Debug Console")
self.pack(fill=BOTH, expand=1)
TL_T1 = Text(Toplevel1, width=50)
TL_T1.pack()
Toplevel1.state("withdrawn")
Toplevel1.protocol('WM_DELETE_WINDOW', lambda:Toplevel1.state("withdrawn"))
Toplevel1.attributes("-topmost", True)
# Username Input
L1 = Label(self, text="G+ User Name")
L1.grid(row=0, column=0, sticky=E, ipady=1)
E1 = Entry(self, width=30)
E1.grid(row=0, column=1, ipady=1, sticky=E)
# Password Input
L2 = Label(self, text="G+ Password")
L2.grid(row=1, column=0, sticky=E, ipady=1)
E2 = Entry(self, width=30)
E2.grid(row=1, column=1, ipady=1, sticky=E)
# Output Path Input
L3 = Label(self, text="Output Path")
L3.grid(row=2, column=0, sticky=E, pady=1)
E3 = Entry(self, width=30)
E3.grid(row=2, column=1, ipady=1, sticky=E)
E3.insert(0, "%s\links.txt" % (os.getcwd()))
# Num Posts
L4 = Label(self, text="# Of Posts")
L4.grid(row=3, column=0, sticky=E, pady=1)
S1 = Spinbox(self, from_=1, to=9999999, width=28)
S1.grid(row=3, column=1, ipady=1, sticky=E)
# Post Input
T1 = Text(self, width=30)
T1.grid(row=5, columnspan=2, sticky=W+E, pady=1)
# Start button
B1 = Button(self, text="Start Posting", command=lambda:self.doPosting(B1,TL_T1,E1.get(),E2.get(),T1.get(1.0,END),E3.get(),S1.get()))
B1.grid(row=6,columnspan=2, sticky=W+E)
# Debug button
B2 = Button(self, text="Debug log", command=lambda:Toplevel1.state("normal"))
B2.grid(row=7, columnspan=2, sticky=W+E)
self.addDebug(TL_T1,"Started successfully")
def create_entry(_main_row_, _desc_txt, _def_txt_, t_len, ckbc=None, fn=None):
''' creates a tkinter entry '''
_row_ = Frame(_main_row_)
if ckbc <> None and fn <> None:
label0 = Label(_row_, width=3, text=" ", anchor='w')
cvar = IntVar()
label1 = Checkbutton(_row_,
width=0,
variable=cvar,
command=fn,
anchor='w')
label2 = Label(_row_, width=t_len, text=_desc_txt + " ", anchor='w')
ckbc.append([cvar, label1])
else:
label0 = Label(_row_, width=3, text=" >", anchor='w')
label1 = Label(_row_, width=t_len, text=_desc_txt, anchor='w')
label2 = Label(_row_, width=2, text=" :", anchor='w')
if type(_def_txt_) == str:
Ent_It = Entry(_row_) #, width=13)
Ent_It.insert('end', _def_txt_)
elif type(_def_txt_) in [list, tuple]:
Ent_It = StringVar()
aux_ddl = Drop_Down_List(
_row_,
textvariable=Ent_It,
values=tuple(_def_txt_[1]),
#state = "readonly"
)
aux_ddl.bind("<Key>", lambda e: "break") # Magic
Ent_It.set(_def_txt_[0])
finalspace = Label(_row_, width=5, text=" ", anchor='w')
# Just packing
label0.pack(side='left', padx=1)
label1.pack(side='left', padx=6)
label2.pack(side='left', padx=0)
if type(_def_txt_) == str:
Ent_It.pack(side='left', expand=True, fill=X)
elif type(_def_txt_) in [list, tuple]:
aux_ddl.pack(side='left', expand=True, fill=X)
finalspace.pack(side='right', padx=0)
_row_.pack(side='top', fill=X, pady=3)
# For tracing purposes list appending
return Ent_It
class Application(Frame):
def chodir(self, gb, key):
gb.dirs[key] = askdirectory(initialdir="/", parent=root)
# normalized version of directory path
# @see http://docs.python.org/2/library/os.path.html#os.path.normpath
dirnormpath = path.normpath(gb.dirs[key])
if key == "source":
self.srctxt['text'] = dirnormpath
if key == "destination":
self.dsttxt['text'] = dirnormpath
def createWidgets(self):
gb = GalleryBatch()
self.src = Button(self)
self.src["text"] = "Find images (subdirectories included)"
self.src["command"] = lambda: self.chodir(gb, "source")
self.src.pack({"fill":"x"})
self.srctxt = Label(self)
self.srctxt['text'] = "Select source directory"
self.srctxt.pack({"fill":"x"})
self.dst = Button(self)
self.dst["text"] = "Create symlink gallery to"
self.dst["command"] = lambda: self.chodir(gb, "destination")
self.dst.pack({"fill":"x"})
self.dsttxt = Label(self)
self.dsttxt['text'] = "Select destination directory"
self.dsttxt.pack({"fill":"x"})
self.runop = Button(self)
self.runop["text"] = "Run"
self.runop["bg"] = "#008000"
self.runop["fg"] = "white"
self.runop["command"] = lambda: gb.run(self.skip_mb.get())
self.runop.pack({"side":"right"})
self.QUIT = Button(self)
self.QUIT["text"] = "QUIT"
self.QUIT["fg"] = "red"
self.QUIT["command"] = self.quit
self.QUIT.pack({"side":"left"})
self.skip_mb_label = Label(self, text="Ignore file larger than (MB)")
self.skip_mb_label.pack()
self.skip_mb = Entry()
self.skip_mb.insert(0, gb.skip_limit_mb)
self.skip_mb.pack()
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
self.createWidgets()
def makeCmdButton(self, parent, cmd, row):
cmdText = Entry(parent, width=self.cmdWidth)
cmdText.grid(row=row, column=1, sticky="ew", ipady=2)
cmdText.delete(0, END)
cmdText.insert(0, cmd["cmd"])
button = Button(parent, text=cmd["button"], command=lambda: self.execute(cmd["button"], cmdText))
button.grid(row=row, column=0, sticky="ew", padx=2, pady=2)
if "tooltip" in cmd:
ToolTip(button, cmd["tooltip"])
ToolTip(cmdText, cmd["tooltip"])
class InputDialog(_TkDialog):
def __init__(self, message, default=''):
_TkDialog.__init__(self, message, default)
def _create_selector(self, parent, default):
self._entry = Entry(parent)
self._entry.insert(0, default)
self._entry.select_range(0, END)
return self._entry
def _get_value(self):
return self._entry.get()
class InputDialog(_TkDialog):
def __init__(self, message, default='', hidden=False):
_TkDialog.__init__(self, message, default, hidden=hidden)
def _create_selector(self, parent, default, hidden):
self._entry = Entry(parent, show='*' if hidden else '')
self._entry.insert(0, default)
self._entry.select_range(0, END)
return self._entry
def _get_value(self):
return self._entry.get()
class InputDialog(_TkDialog):
def __init__(self, message, default='', hidden=False):
_TkDialog.__init__(self, message, default, hidden=hidden)
def _create_selector(self, parent, default, hidden):
self._entry = Entry(parent, show='*' if hidden else '')
self._entry.insert(0, default)
self._entry.select_range(0, END)
return self._entry
def _get_value(self):
return self._entry.get()
class InputDialog(_TkDialog):
def __init__(self, message, default=''):
_TkDialog.__init__(self, message, default)
def _create_selector(self, parent, default):
self._entry = Entry(parent)
self._entry.insert(0, default)
self._entry.select_range(0, END)
return self._entry
def _get_value(self):
return self._entry.get()
class _QueryPassword(_QueryString):
def body(self, master):
w = Label(master, text=self.prompt, justify=LEFT)
w.grid(row=0, padx=5, sticky=W)
self.entry = Entry(master, name="entry", show="*")
self.entry.grid(row=1, padx=5, sticky=W + E)
if self.initialvalue:
self.entry.insert(0, self.initialvalue)
self.entry.select_range(0, END)
return self.entry
def create_entry_ck(self, _row2use_, _i_=None, container=[]):
''' creates a too custom check row so it aparts here'''
_row_ = Frame(_row2use_)
if _i_ == None:
_group_, _def_ids_, _def_fcoord_, _res_ens_ = container
else:
_group_ = self._entries_[_i_]
_def_fcoord_ = self._defvals_[_i_]
_def_ids_ = self.range_ids[_i_]
_res_ens_ = self.range_ens[_i_]
label0 = Label(_row_, width=1, text=" ", anchor='w')
# first check button
cvar = IntVar()
label1 = Checkbutton(_row_,
width=0,
variable=cvar,
command=self.checkbuttonstuff,
anchor='w')
self.ckb_c.append([cvar, label1])
# group description
label2 = Label(_row_, width=6, text='Group ', anchor='w')
Ent_gr = Entry(_row_, width=8)
Ent_gr.insert('end', _group_)
label2_2 = Label(_row_, width=5, text=" ids", anchor='w')
# group ids
Ent_ids = Entry(_row_, width=10)
Ent_ids.insert('end', _def_ids_)
label3 = Label(_row_, width=7, text=" K:xyz ", anchor='w')
Ent_it = Entry(_row_, width=6)
Ent_it.insert('end', _def_fcoord_)
label4 = Label(_row_, width=5, text=" In run", anchor='w')
Ent_ens = Entry(_row_, width=6)
Ent_ens.insert('end', _res_ens_)
finalspace = Label(_row_, width=5, text=" ", anchor='w')
# Just packing
label0.pack(side='left', padx=0)
label1.pack(side='left', padx=2)
label2.pack(side='left', padx=0)
Ent_gr.pack(side='left', expand=True, fill=X)
label2_2.pack(side='left', padx=0)
Ent_ids.pack(side='left', expand=True, fill=X)
label3.pack(side='left', padx=0)
Ent_it.pack(side='left', expand=True, fill=X)
label4.pack(side='left', padx=0)
Ent_ens.pack(side='left', expand=True, fill=X)
finalspace.pack(side='right', padx=0)
_row_.pack(side='top', fill=X, pady=3)
# For tracing purposes list appending
self.ent_c.append([Ent_gr, Ent_ids, Ent_it, Ent_ens])
def create_player(self):
player = Frame(self.root)
player.pack(fill=X, expand=1)
# left
left_frame = Frame(player)
left_frame.pack(side=LEFT)
left_team_name = Entry(left_frame, bg='pink', fg='black')
left_team_name.insert(0, 'A队')
left_team_name.pack()
for i in range(1, 7):
e = Entry(left_frame, bg='red', fg='white')
name = 'Player' + str(i)
e.insert(0, name)
e.pack()
# right
right_frame = Frame(player)
right_frame.pack(side=RIGHT)
right_team_name = Entry(right_frame, bg='lightBlue', fg='black')
right_team_name.insert(0, 'B队')
right_team_name.pack()
for i in range(7, 13):
e = Entry(right_frame, bg='blue', fg='white')
name = 'Player' + str(i)
e.insert(0, name)
e.pack()
self.left_frame = left_frame
self.right_frame = right_frame
class _QueryPassword(_QueryString):
def body(self, master):
w = Label(master, text=self.prompt, justify=LEFT)
w.grid(row=0, padx=5, sticky=W)
self.entry = Entry(master, name="entry",show="*")
self.entry.grid(row=1, padx=5, sticky=W+E)
if self.initialvalue:
self.entry.insert(0, self.initialvalue)
self.entry.select_range(0, END)
return self.entry
def add_entries(self, vl):
for el in vl:
if not hasattr(self.ea, el['name']):
raise TypeError(
'you try to set up an entry for a name which is no attribute of the chosen EA'
)
fr = Frame(self.f_actn)
fr.pack()
lab = Label(fr, text=el['name'])
lab.pack()
e = Entry(fr)
e.pack()
e.insert(0, str(el['inival'])) # number of generations
el['Entry'] = e
def quickentry(labels, callback, title='', defaults=None):
"Simple dialog from grabbing parameters from the user."
if defaults is None:
defaults = {}
root = Tk()
root.title(title)
root['padx'] = 20
root['pady'] = 10
widgets = {}
for label in labels:
# Create a text frame to hold the text Label and the Entry widget
f = Frame(root)
#Create a Label in textFrame
l = Label(f)
l['text'] = label
l['width'] = 10
l.pack(side=LEFT)
w = Entry(f)
w['width'] = 20
w.pack(side=LEFT)
w.insert(0, defaults.get(label, ''))
widgets[label] = w
f.pack()
def cb():
callback({label: widgets[label].get().strip() for label in labels})
Button(root, text="Quit",
command=lambda root=root: root.destroy()).pack(side=RIGHT)
Button(root, text='Submit', command=cb).pack(side=RIGHT)
root.protocol("WM_DELETE_WINDOW", lambda root=root: root.destroy())
print '[quickentry] running'
root.bind("<Return>", lambda e: cb())
root.bind("<Escape>", lambda e: root.destroy())
root.mainloop()
print '[quickentry] done'
return root
class IssueDialog(tkSimpleDialog.Dialog):
def body(self, top):
self.title("Issue Number")
Label(top, text="Enter issue number: ").grid(row=0, sticky=W)
Label(top, text="Chapter number to start with: ").grid(row=1, sticky=W)
Label(top, text="Enter password for " + user + ": ").grid(row=2, sticky=W)
self.e1 = Entry(top)
self.e1.insert(0, "000")
self.e1.grid(row=0, column=1)
self.e3 = Entry(top)
self.e3.insert(0, "2")
self.e3.grid(row=1, column=1)
self.e2 = Entry(top, show="*")
self.e2.grid(row=2, column=1)
self.var = IntVar()
self.b = Checkbutton(top, text="Debug?", variable= self.var, onvalue = 1, offvalue = 0)
self.b.grid(row=3, columnspan=2, sticky=W)
#def callConvert():
#essa_clipboardDateConvert.convert()
#self.convertButton = Button(top, text="Convert clipboard date", command=callConvert)
#self.convertButton.grid(row=4, columnspan=2, sticky=W)
def apply(self):
global issue
issue = self.e1.get()
global chapNum
chapNum = int(self.e3.get())
global password
password = self.e2.get()
global debug
debug = self.var.get()
def quickentry(labels, callback, title='', defaults=None):
"Simple dialog from grabbing parameters from the user."
if defaults is None:
defaults = {}
root = Tk()
root.title(title)
root['padx'] = 20
root['pady'] = 10
widgets = {}
for label in labels:
# Create a text frame to hold the text Label and the Entry widget
f = Frame(root)
#Create a Label in textFrame
l = Label(f)
l['text'] = label
l['width'] = 10
l.pack(side=LEFT)
w = Entry(f)
w['width'] = 20
w.pack(side=LEFT)
w.insert(0, defaults.get(label, ''))
widgets[label] = w
f.pack()
def cb():
callback({label: widgets[label].get().strip() for label in labels})
Button(root, text="Quit", command=lambda root=root: root.destroy()).pack(side=RIGHT)
Button(root, text='Submit', command=cb).pack(side=RIGHT)
root.protocol("WM_DELETE_WINDOW", lambda root=root: root.destroy())
print '[quickentry] running'
root.bind("<Return>", lambda e: cb())
root.bind("<Escape>", lambda e: root.destroy())
root.mainloop()
print '[quickentry] done'
return root
class SphereDialog(tkSimpleDialog.Dialog):
def __init__(self,
master,
data_a=10,
data_x=0,
data_y=0,
data_z=0,
data_mat='m0'):
self.data_x = data_x
self.data_y = data_y
self.data_z = data_z
self.data_a = data_a
self.data_mat = data_mat
tkSimpleDialog.Dialog.__init__(self, master)
def body(self, master):
Label(master, text='Radius: ').grid(row=0)
Label(master, text='X: ').grid(row=1)
Label(master, text='Y: ').grid(row=2)
Label(master, text='Z: ').grid(row=3)
Label(master, text='Material: ').grid(row=4)
self.eR = Entry(master)
self.eX = Entry(master)
self.eY = Entry(master)
self.eZ = Entry(master)
self.emat = ttk.Combobox(master, values=materials.keys())
self.eR.insert(0, self.data_a)
self.eX.insert(0, self.data_x)
self.eY.insert(0, self.data_y)
self.eZ.insert(0, self.data_z)
self.emat.insert(0, self.data_mat)
self.eR.grid(row=0, column=1)
self.eX.grid(row=1, column=1)
self.eY.grid(row=2, column=1)
self.eZ.grid(row=3, column=1)
self.emat.grid(row=4, column=1)
return self.eR # initial focus
def validate(self):
try:
X = float(self.eX.get())
Y = float(self.eY.get())
Z = float(self.eZ.get())
R = float(self.eR.get())
mat_key = self.emat.get()
assert mat_key in materials
self.result = R, X, Y, Z, mat_key
return True
except ValueError as err:
tkMessageBox.showerror('Error', str(err))
return False
def apply(self):
pass
def addVar(self, names, lbs, ubs, tols, currValues, _name='', _lb='', _ub='', _tol='', _val=''):
nameEntry, lb, ub, tol, valEntry = Entry(names), Entry(lbs), Entry(ubs), Entry(tols), Entry(currValues)
nameEntry.insert(0, _name)
lb.insert(0, _lb)
ub.insert(0, _ub)
tol.insert(0, _tol)
valEntry.insert(0, _val)
self.NameEntriesList.append(nameEntry)
self.LB_EntriesList.append(lb)
self.UB_EntriesList.append(ub)
self.TolEntriesList.append(tol)
self.ValueEntriesList.append(valEntry)
nameEntry.pack(side = 'top')
lb.pack(side = 'top')
ub.pack(side = 'top')
tol.pack(side = 'top')
valEntry.pack(side = 'top')
class ClsKeyValue(Frame):
"""
Класс обеспечивает пару "ключ:значение"
"""
def __init__(self, root=None, key='key', value='None'):
Frame.__init__(self, master=root, border=3, relief='groove')
self.pack(side='top', fill='x')
self.key=key
self.value=value
self.lblKey = Label(master=self, text=key)
self.lblKey.pack(side='left', fill='x')
self.entValue = Entry(master=self)
self.entValue.pack(side='right')
self.entValue.insert(0, value)
class GenerateMaterialDialog(tkSimpleDialog.Dialog):
choises = ['4+2j', 'air', 'glass', 'water', 'alloyAuAg']
def __init__(self, master, data_name='1.0', data_conc=0):
self.data_name = data_name
self.data_conc = data_conc
tkSimpleDialog.Dialog.__init__(self, master)
def body(self, master):
Label(master, text='Material name:').grid(row=1)
Label(master, text='Concentration:').grid(row=2)
self.ename = ttk.Combobox(master, values=self.choises)
self.ename.bind('<<ComboboxSelected>>', self._cbselected)
self.ename.current(0)
self.econc = Entry(master, state='disabled')
self.econc.insert(0, self.data_conc)
self.ename.grid(row=1, column=1)
self.econc.grid(row=2, column=1)
return self.ename # initial focus
def _cbselected(self, event=None):
if self.ename.get() == 'alloyAuAg':
self.econc.configure(state='normal')
else:
self.econc.configure(state='disabled')
def validate(self):
try:
name = self.ename.get()
if not (name in self.choises):
_ = np.complex(self.ename.get())
if name == 'alloyAuAg':
self.result = name, float(self.econc.get())
else:
self.result = name, None
return True
except ValueError as err:
tkMessageBox.showerror('Error', 'Bad data entered\n%s' % err)
return False
def apply(self):
pass
class SearchFrame(Frame):
def __init__(self, win, search=""):
Frame.__init__(self, win)
self["bg"] = "white"
self.entry_view = Entry(self,
width=config.getWindowSize("search_box_width"))
self.entry_view.insert(10, search)
self.entry_view.pack(side=Tkinter.LEFT, ipadx=10, ipady=2)
self.button = Button(self, text=u"搜索")
self.button.pack(side=Tkinter.LEFT, padx=10)
def setSearchCommand(self, search_command):
self.button["command"] = search_command
return self
def getSearchString(self):
return self.entry_view.get()
class SelectGame(tkSimpleDialog.Dialog, object):
"""Server settings window class."""
def __init__(self, *args, **kwargs):
"""Initiates SelectGame instance with additional attributes.
:param args: positional arguments - positional arguments passed to parent __init__ method
:param kwargs: keyword arguments - keyword arguments passed to parent __init__ method
"""
self.select_game, self.num_players, self.num_turns = None, None, None
super(SelectGame, self).__init__(*args, **kwargs)
def body(self, master):
"""Creates select game window.
:param master: instance - master widget instance
:return: Entry instance
"""
self.resizable(False, False)
Label(master, text='Type in new game title or select existing one').grid(row=0, columnspan=2)
Label(master, text='Select game:').grid(row=1, sticky='W')
Label(master, text='Number of players:').grid(row=2, sticky='W')
Label(master, text='Game duration:').grid(row=3, sticky='W')
self.select_game = Combobox(master)
self.select_game.bind('<Button-1>', self.refresh_games)
self.select_game.grid(row=1, column=1, sticky='W')
self.num_players = Entry(master)
self.num_players.insert(END, self.parent.num_players if self.parent.num_players else '')
self.num_players.grid(row=2, column=1, sticky='W')
self.num_turns = Entry(master)
self.num_turns.insert(END, self.parent.num_turns if self.parent.num_turns else '')
self.num_turns.grid(row=3, column=1, sticky='W')
return self.select_game
def apply(self):
"""Assigns entered values to parent game and num_players attributes."""
self.parent.game = self.select_game.get() if self.select_game.get() != '' else None
if self.parent.game not in self.parent.available_games:
self.parent.num_players = int(self.num_players.get()) if self.num_players.get().isdigit() else None
self.parent.num_turns = int(self.num_turns.get()) if self.num_turns.get().isdigit() else None
def refresh_games(self, _):
"""Refreshes games list."""
self.select_game.configure(values=self.parent.available_games)
def __init__(self, master, enc):
## XXX ?
from Tkinter import Toplevel, Text, Label, TOP, W, Entry, X, Frame, Button
from Tkinter import LEFT, BOTH
self.should_edit = False
self.root = top = Toplevel(master)
top.bind("<Return>", self.return_event)
top.bind("<Escape>", self.do_ok)
top.protocol("WM_DELETE_WINDOW", self.wm_delete_window)
top.wm_title("I/O Warning")
top.wm_iconname("I/O Warning")
self.top = top
l1 = Label(top,
text="Non-ASCII found, yet no encoding declared. Add a line like")
l1.pack(side=TOP, anchor=W)
l2 = Entry(top, font="courier")
l2.insert(0, "# -*- coding: %s -*-" % enc)
# For some reason, the text is not selectable anymore if the
# widget is disabled.
# l2['state'] = DISABLED
l2.pack(side=TOP, anchor = W, fill=X)
l3 = Label(top, text="to your file\n"
"Choose OK to save this file as %s\n"
"Edit your general options to silence this warning" % enc)
l3.pack(side=TOP, anchor = W)
buttons = Frame(top)
buttons.pack(side=TOP, fill=X)
# Both return and cancel mean the same thing: do nothing
self.default = self.cancel = 0
b1 = Button(buttons, text="Ok", default="active",
command=self.do_ok)
b1.pack(side=LEFT, fill=BOTH, expand=1)
b2 = Button(buttons, text="Edit my file",
command=self.do_edit)
b2.pack(side=LEFT, fill=BOTH, expand=1)
self._set_transient(master)
class Edit1Dialog(tkSimpleDialog.Dialog):
def __init__(self, parent, title, label, default):
# save the extra args to instance variables
self.label_1 = label
self.default_1 = default
# and call the base class _init_which uses the args in body
tkSimpleDialog.Dialog.__init__(self, parent, title)
def body(self, master):
Label(master, text=self.label_1).grid(row=0)
self.field1 = Entry(master)
self.field1.grid(row=0, column=1)
self.field1.insert(0,self.default_1)
return self.field1 # initial focus on title
def apply(self):
self.result= self.field1.get()
return self.result
class OptionsDialog(tkSimpleDialog.Dialog):
def __init__(self, parent, options_file, title=None, ):
# instantiate the subclass attributes
self.options_file=options_file
# init the super class
tkSimpleDialog.Dialog.__init__(self, parent, title)
def body(self, master):
self.result=False
config=ConfigParser.ConfigParser()
config.read(self.options_file)
Label(master, text="").grid(row=20, sticky=W)
Label(master, text="Pi Presents Data Home:").grid(row=21, sticky=W)
self.e_home = Entry(master,width=80)
self.e_home.grid(row=22)
self.e_home.insert(0,config.get('config','home',0))
Label(master, text="").grid(row=30, sticky=W)
Label(master, text="Inital directory for media:").grid(row=31, sticky=W)
self.e_media = Entry(master,width=80)
self.e_media.grid(row=32)
self.e_media.insert(0,config.get('config','media',0))
Label(master, text="").grid(row=40, sticky=W)
Label(master, text="Offset for Current Profiles:").grid(row=41, sticky=W)
self.e_offset = Entry(master,width=80)
self.e_offset.grid(row=42)
self.e_offset.insert(0,config.get('config','offset',0))
return None # no initial focus
def validate(self):
if os.path.exists(self.e_home.get()) is False:
tkMessageBox.showwarning("Pi Presents Editor","Data Home not found")
return 0
if os.path.exists(self.e_media.get()) is False:
tkMessageBox.showwarning("Pi Presents Editor","Media Directory not found")
return 0
if os.path.exists(self.e_home.get()+os.sep+'pp_profiles'+self.e_offset.get()) is False:
tkMessageBox.showwarning("Pi Presents Editor","Current Profles directory not found")
return 0
return 1
def apply(self):
self.save_options()
self.result=True
def save_options(self):
""" save the output of the options edit dialog to file"""
config=ConfigParser.ConfigParser()
config.add_section('config')
config.set('config','home',self.e_home.get())
config.set('config','media',self.e_media.get())
config.set('config','offset',self.e_offset.get())
with open(self.options_file, 'wb') as optionsfile:
config.write(optionsfile)
def create_time_inputs(self):
time_inputs_frame = Frame(self.root)
time_inputs_frame.pack(fill=X, expand=1)
left_frame = Frame(time_inputs_frame)
left_frame.pack(side=LEFT)
label_start_time = Label(
left_frame,
text="Start time in seconds (0 = start from beginning):")
label_end_time = Label(
left_frame, text="End time in seconds (0 = analyze till the end):")
label_fps = Label(left_frame, text='FPS of analyzer:')
label_start_time.pack()
label_end_time.pack()
label_fps.pack()
right_frame = Frame(time_inputs_frame)
right_frame.pack(side=RIGHT)
start_time = Entry(right_frame, bg='lightBlue', fg='black')
start_time.insert(0, '0')
start_time.pack()
end_time = Entry(right_frame, bg='lightBlue', fg='black')
end_time.insert(0, '0')
end_time.pack()
fps = Entry(right_frame, bg='lightBlue', fg='black')
fps.insert(0, '2')
fps.pack()
self.time_inputs_frame = right_frame
def reset_params(self):
children = self.param_canvas.winfo_children()
for child in children:
child.pack_forget()
self.param_entries = {}
for param in self.model.params:
var_text = self.param_gui_names.get(param, param)
can = Canvas(self.param_canvas)
lab = Label(can, width=25, height=1 + var_text.count('\n'),
text=var_text, anchor=W, takefocus=0)
lab.pack(side='left')
ent = Entry(can, width=11)
val = getattr(self.model, param)
if isinstance(val, bool):
val = int(val) # Show 0/1 which can convert back to bool
elif isinstance(val, float):
val = '%.2f' %val
ent.insert(0, str(val))
ent.pack(side='left')
can.pack(side='top')
self.param_entries[param] = ent
if self.param_entries:
self.buttonSaveParameters = Button(self.param_canvas, width=50,
height=1, command=self.saveParametersCmd,
text="Save parameters to the running model", state=DISABLED)
self.showHelp(self.buttonSaveParameters,
"Saves the parameter values.\n" +
"Not all values may take effect on a running model\n" +
"A model reset might be required.")
self.buttonSaveParameters.pack(side='top', padx=5, pady=5)
self.buttonSaveParametersAndReset = Button(self.param_canvas, width=50,
height=1, command=self.saveParametersAndResetCmd,
text="Save parameters to the model and reset the model")
self.showHelp(self.buttonSaveParametersAndReset,
"Saves the given parameter values and resets the model")
self.buttonSaveParametersAndReset.pack(side='top', padx=5, pady=5)
class ButtonEntry(Frame):
def __init__(self, parent, width=20):
Frame.__init__(self, parent)
self.browseButton = Button(self, text="Browse", command=self.browse)
self.fileEntry = Entry(self, width=width)
self.browseButton.pack(side=LEFT)
self.fileEntry.pack(side=LEFT)
def browse(self):
filename = tkFileDialog.askopenfilename(filetypes = (("Tldr Files", "*.tldr"),))
if filename:
self.filename = filename
self.fileEntry.delete(0, END)
width = int(self.fileEntry['width'])
if len(filename) > width:
filename = "...%s" % (filename[-width:])
self.fileEntry.insert(0, filename)
def get(self):
return self.filename
def initUI(self, arg=None): #Level Properties title name = "Me!" tileset = "The best!" entry_row = 0 Lname = Label(self, text="Name") Lname.grid(row=entry_row, column=0) Ename = Entry(self) Ename.grid(row=entry_row, column=1) Ename.insert(INSERT, name) entry_row = 1 Ltileset = Label(self, text="Tileset") Ltileset.grid(row=entry_row, column=0) Etileset = Entry(self) Etileset.grid(row=entry_row, column=1) Etileset.insert(INSERT, tileset) self.pack(fill=BOTH, expand=1) self.name = Ename self.tileset = Etileset
def init_dialog(self, master):
self.master = master
master.title("Joint positions")
self.entries = []
for i in range(0, self.num_joints):
new_label = Label(master, text="Joint " + str(i))
new_label.grid(row=i, column=0)
callback_with_arg = partial(self.inc, -1, i)
minus_button = Button(master, text="-", command=callback_with_arg)
minus_button.grid(row=i, column=1)
new_entry = Entry(master)
new_entry.insert(0, "0.0")
new_entry.config(width=5)
new_entry.grid(row=i, column=2)
self.entries.append(new_entry)
callback_with_arg = partial(self.inc, 1, i)
minus_button = Button(master, text="+", command=callback_with_arg)
minus_button.grid(row=i, column=3)
self.publish_button = Button(master, text="Send", command=self.send)
self.publish_button.grid(row=self.num_joints, column=0)
def init_dialog(self, master):
self.master = master
master.title("Joint positions")
self.entries = []
for i in range(0,self.num_joints):
new_label = Label(master, text="Joint " + str(i))
new_label.grid(row=i, column=0)
callback_with_arg = partial(self.inc, -1, i)
minus_button = Button(master, text="-", command=callback_with_arg)
minus_button.grid(row=i, column=1)
new_entry = Entry(master)
new_entry.insert(0,"0.0")
new_entry.config(width=5)
new_entry.grid(row=i, column=2)
self.entries.append(new_entry)
callback_with_arg = partial(self.inc, 1, i)
minus_button = Button(master, text="+", command=callback_with_arg)
minus_button.grid(row=i, column=3)
self.publish_button = Button(master, text="Send", command=self.send)
self.publish_button.grid(row=self.num_joints, column=0)
def setup_parms(self, SCRfilename):
xoffset = 0
yoffset = 0
y_mult = 100
yrounding = 2
frame2 = Frame()
frame2.grid(row=1, column=0, sticky='w')
l1 = Label(frame2, text='Y multiplier', width=20, anchor=W)
l1.grid(row=0, column=0)
e1 = Entry(frame2, width=10)
e1.grid(row=1, column=0)
e1.insert(0, y_mult)
l2 = Label(frame2, text='Y axis rounding', width=20, anchor=W)
l2.grid(row=0, column=1)
e2 = Entry(frame2, width=10)
e2.grid(row=1, column=1)
e2.insert(0, yrounding)
l3 = Label(frame2, text='X Offset', width=20, anchor=W)
l3.grid(row=0, column=2)
e3 = Entry(frame2, width=10)
e3.grid(row=1, column=2)
e3.insert(0, xoffset)
l4 = Label(frame2, text='Y Offset', width=20, anchor=W)
l4.grid(row=0, column=3)
e4 = Entry(frame2, width=10)
e4.grid(row=1, column=3)
e4.insert(0, yoffset)
submit = Button(frame2, text="Enter", width=15, command=lambda: self.valueGET(e1.get(), e2.get(), e3.get(), e4.get()))
submit.grid()
return
class GenerateSpheresDialog(tkSimpleDialog.Dialog):
def __init__(self,
master,
data_N=0,
data_a=10,
data_d=5,
materials=['m0']):
self.data_N = data_N
self.data_a = data_a
self.data_d = data_d
self.materials = materials
tkSimpleDialog.Dialog.__init__(self, master)
def body(self, master):
Label(master, text='Number of spheres:').grid(row=1)
Label(master, text='Spheres radius:').grid(row=2)
Label(master, text='Gap between spheres:').grid(row=3)
Label(master, text='Material ID:').grid(row=4)
self.eN = Entry(master)
self.eN.insert(0, self.data_N)
self.ea = Entry(master)
self.ea.insert(0, self.data_a)
self.ed = Entry(master)
self.ed.insert(0, self.data_d)
self.cbmat = ttk.Combobox(master, values=self.materials)
self.cbmat.insert(0, self.materials[-1])
self.eN.grid(row=1, column=1)
self.ea.grid(row=2, column=1)
self.ed.grid(row=3, column=1)
self.cbmat.grid(row=4, column=1)
return self.eN # initial focus
def validate(self):
try:
N = int(self.eN.get())
a = float(self.ea.get())
d = float(self.ed.get())
mat_key = self.cbmat.get()
assert mat_key in materials
self.result = N, a, d, mat_key
return True
except ValueError as err:
tkMessageBox.showerror('Error', str(err))
return False
def apply(self):
pass
def initUI(self, arg=None): #Position/Size Labels x, y = 0, 1 w, h = 2, 3 entry_width = 10 entry_row = 0 Lx = Label(self, text="x", width=2) Lx.grid(row=entry_row, column=0) Ex = Entry(self, width=entry_width) Ex.insert(INSERT, x) Ex.grid(row=entry_row, column=1) Ly = Label(self, text="y") Ly.grid(row=entry_row, column=2) Ey = Entry(self, width=entry_width) Ey.insert(INSERT, y) Ey.grid(row=entry_row, column=3) entry_row = 1 Lw = Label(self, text="w") Lw.grid(row=entry_row, column=0) Ew = Entry(self, width=entry_width) Ew.grid(row=entry_row, column=1) Ew.insert(INSERT, w) Lh = Label(self, text="h") Lh.grid(row=entry_row, column=2) Eh = Entry(self, width=entry_width) Eh.grid(row=entry_row, column=3) Eh.insert(INSERT, h) self.pack(fill=BOTH, expand=1) self.x, self.y = Ex, Ey self.w, self.h = Ew, Eh
class LintGui:
"""Build and control a window to interact with pylint"""
def __init__(self, root=None):
"""init"""
self.root = root or Tk()
self.root.title('Pylint')
#reporter
self.reporter = None
#message queue for output from reporter
self.msg_queue = Queue.Queue()
self.msgs = []
self.filenames = []
self.rating = StringVar()
self.tabs = {}
self.report_stream = BasicStream(self)
#gui objects
self.lbMessages = None
self.showhistory = None
self.results = None
self.btnRun = None
self.information_box = None
self.convention_box = None
self.refactor_box = None
self.warning_box = None
self.error_box = None
self.fatal_box = None
self.txtModule = None
self.status = None
self.msg_type_dict = None
self.init_gui()
def init_gui(self):
"""init helper"""
#setting up frames
top_frame = Frame(self.root)
mid_frame = Frame(self.root)
radio_frame = Frame(self.root)
res_frame = Frame(self.root)
msg_frame = Frame(self.root)
check_frame = Frame(self.root)
history_frame = Frame(self.root)
btn_frame = Frame(self.root)
rating_frame = Frame(self.root)
top_frame.pack(side=TOP, fill=X)
mid_frame.pack(side=TOP, fill=X)
history_frame.pack(side=TOP, fill=BOTH, expand=True)
radio_frame.pack(side=TOP, fill=BOTH, expand=True)
rating_frame.pack(side=TOP, fill=BOTH, expand=True)
res_frame.pack(side=TOP, fill=BOTH, expand=True)
check_frame.pack(side=TOP, fill=BOTH, expand=True)
msg_frame.pack(side=TOP, fill=BOTH, expand=True)
btn_frame.pack(side=TOP, fill=X)
#Message ListBox
rightscrollbar = Scrollbar(msg_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.lbMessages = Listbox(msg_frame,
yscrollcommand=rightscrollbar.set,
xscrollcommand=bottomscrollbar.set,
bg="white")
self.lbMessages.pack(expand=True, fill=BOTH)
rightscrollbar.config(command=self.lbMessages.yview)
bottomscrollbar.config(command=self.lbMessages.xview)
#History ListBoxes
rightscrollbar2 = Scrollbar(history_frame)
rightscrollbar2.pack(side=RIGHT, fill=Y)
bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL)
bottomscrollbar2.pack(side=BOTTOM, fill=X)
self.showhistory = Listbox(history_frame,
yscrollcommand=rightscrollbar2.set,
xscrollcommand=bottomscrollbar2.set,
bg="white")
self.showhistory.pack(expand=True, fill=BOTH)
rightscrollbar2.config(command=self.showhistory.yview)
bottomscrollbar2.config(command=self.showhistory.xview)
self.showhistory.bind('<Double-Button-1>', self.select_recent_file)
self.set_history_window()
#status bar
self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W)
self.status.pack(side=BOTTOM, fill=X)
#labels
self.lblRatingLabel = Label(rating_frame, text='Rating:')
self.lblRatingLabel.pack(side=LEFT)
self.lblRating = Label(rating_frame, textvariable=self.rating)
self.lblRating.pack(side=LEFT)
Label(mid_frame, text='Recently Used:').pack(side=LEFT)
Label(top_frame, text='Module or package').pack(side=LEFT)
#file textbox
self.txtModule = Entry(top_frame, background='white')
self.txtModule.bind('<Return>', self.run_lint)
self.txtModule.pack(side=LEFT, expand=True, fill=X)
#results box
rightscrollbar = Scrollbar(res_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.results = Listbox(res_frame,
yscrollcommand=rightscrollbar.set,
xscrollcommand=bottomscrollbar.set,
bg="white", font="Courier")
self.results.pack(expand=True, fill=BOTH, side=BOTTOM)
rightscrollbar.config(command=self.results.yview)
bottomscrollbar.config(command=self.results.xview)
#buttons
Button(top_frame, text='Open', command=self.file_open).pack(side=LEFT)
Button(top_frame, text='Open Package', command=(lambda : self.file_open(package=True))).pack(side=LEFT)
self.btnRun = Button(top_frame, text='Run', command=self.run_lint)
self.btnRun.pack(side=LEFT)
Button(btn_frame, text='Quit', command=self.quit).pack(side=BOTTOM)
#radio buttons
self.information_box = IntVar()
self.convention_box = IntVar()
self.refactor_box = IntVar()
self.warning_box = IntVar()
self.error_box = IntVar()
self.fatal_box = IntVar()
i = Checkbutton(check_frame, text="Information", fg=COLORS['(I)'], variable=self.information_box, command=self.refresh_msg_window)
c = Checkbutton(check_frame, text="Convention", fg=COLORS['(C)'], variable=self.convention_box, command=self.refresh_msg_window)
r = Checkbutton(check_frame, text="Refactor", fg=COLORS['(R)'], variable=self.refactor_box, command=self.refresh_msg_window)
w = Checkbutton(check_frame, text="Warning", fg=COLORS['(W)'], variable=self.warning_box, command=self.refresh_msg_window)
e = Checkbutton(check_frame, text="Error", fg=COLORS['(E)'], variable=self.error_box, command=self.refresh_msg_window)
f = Checkbutton(check_frame, text="Fatal", fg=COLORS['(F)'], variable=self.fatal_box, command=self.refresh_msg_window)
i.select()
c.select()
r.select()
w.select()
e.select()
f.select()
i.pack(side=LEFT)
c.pack(side=LEFT)
r.pack(side=LEFT)
w.pack(side=LEFT)
e.pack(side=LEFT)
f.pack(side=LEFT)
#check boxes
self.box = StringVar()
# XXX should be generated
report = Radiobutton(radio_frame, text="Report", variable=self.box, value="Report", command=self.refresh_results_window)
rawMet = Radiobutton(radio_frame, text="Raw metrics", variable=self.box, value="Raw metrics", command=self.refresh_results_window)
dup = Radiobutton(radio_frame, text="Duplication", variable=self.box, value="Duplication", command=self.refresh_results_window)
ext = Radiobutton(radio_frame, text="External dependencies", variable=self.box, value="External dependencies", command=self.refresh_results_window)
stat = Radiobutton(radio_frame, text="Statistics by type", variable=self.box, value="Statistics by type", command=self.refresh_results_window)
msgCat = Radiobutton(radio_frame, text="Messages by category", variable=self.box, value="Messages by category", command=self.refresh_results_window)
msg = Radiobutton(radio_frame, text="Messages", variable=self.box, value="Messages", command=self.refresh_results_window)
report.select()
report.grid(column=0, row=0, sticky=W)
rawMet.grid(column=1, row=0, sticky=W)
dup.grid(column=2, row=0, sticky=W)
msg.grid(column=3, row=0, sticky=E)
stat.grid(column=0, row=1, sticky=W)
msgCat.grid(column=1, row=1, sticky=W)
ext.grid(column=2, row=1, columnspan=2, sticky=W)
#dictionary for check boxes and associated error term
self.msg_type_dict = {
'I' : lambda : self.information_box.get() == 1,
'C' : lambda : self.convention_box.get() == 1,
'R' : lambda : self.refactor_box.get() == 1,
'E' : lambda : self.error_box.get() == 1,
'W' : lambda : self.warning_box.get() == 1,
'F' : lambda : self.fatal_box.get() == 1
}
self.txtModule.focus_set()
def select_recent_file(self, event):
"""adds the selected file in the history listbox to the Module box"""
if not self.showhistory.size():
return
selected = self.showhistory.curselection()
item = self.showhistory.get(selected)
#update module
self.txtModule.delete(0, END)
self.txtModule.insert(0, item)
def refresh_msg_window(self):
"""refresh the message window with current output"""
#clear the window
self.lbMessages.delete(0, END)
for msg in self.msgs:
if (self.msg_type_dict.get(msg[0])()):
msg_str = self.convert_to_string(msg)
self.lbMessages.insert(END, msg_str)
fg_color = COLORS.get(msg_str[:3], 'black')
self.lbMessages.itemconfigure(END, fg=fg_color)
def refresh_results_window(self):
"""refresh the results window with current output"""
#clear the window
self.results.delete(0, END)
try:
for res in self.tabs[self.box.get()]:
self.results.insert(END, res)
except:
pass
def convert_to_string(self, msg):
"""make a string representation of a message"""
if (msg[2] != ""):
return "(" + msg[0] + ") " + msg[1] + "." + msg[2] + " [" + msg[3] + "]: " + msg[4]
else:
return "(" + msg[0] + ") " + msg[1] + " [" + msg[3] + "]: " + msg[4]
def process_incoming(self):
"""process the incoming messages from running pylint"""
while self.msg_queue.qsize():
try:
msg = self.msg_queue.get(0)
if msg == "DONE":
self.report_stream.output_contents()
return False
#adding message to list of msgs
self.msgs.append(msg)
#displaying msg if message type is selected in check box
if (self.msg_type_dict.get(msg[0])()):
msg_str = self.convert_to_string(msg)
self.lbMessages.insert(END, msg_str)
fg_color = COLORS.get(msg_str[:3], 'black')
self.lbMessages.itemconfigure(END, fg=fg_color)
except Queue.Empty:
pass
return True
def periodic_call(self):
"""determine when to unlock the run button"""
if self.process_incoming():
self.root.after(100, self.periodic_call)
else:
#enabling button so it can be run again
self.btnRun.config(state=NORMAL)
def mainloop(self):
"""launch the mainloop of the application"""
self.root.mainloop()
def quit(self, _=None):
"""quit the application"""
self.root.quit()
def halt(self):
"""program halt placeholder"""
return
def file_open(self, package=False, _=None):
"""launch a file browser"""
if not package:
filename = askopenfilename(parent=self.root, filetypes=[('pythonfiles', '*.py'),
('allfiles', '*')], title='Select Module')
else:
filename = askdirectory(title="Select A Folder", mustexist=1)
if filename == ():
return
self.txtModule.delete(0, END)
self.txtModule.insert(0, filename)
def update_filenames(self):
"""update the list of recent filenames"""
filename = self.txtModule.get()
if not filename:
filename = os.getcwd()
if filename+'\n' in self.filenames:
index = self.filenames.index(filename+'\n')
self.filenames.pop(index)
#ensure only 10 most recent are stored
if len(self.filenames) == 10:
self.filenames.pop()
self.filenames.insert(0, filename+'\n')
def set_history_window(self):
"""update the history window with info from the history file"""
#clear the window
self.showhistory.delete(0, END)
# keep the last 10 most recent files
try:
view_history = open(HOME+HISTORY, 'r')
for hist in view_history.readlines():
if not hist in self.filenames:
self.filenames.append(hist)
self.showhistory.insert(END, hist.split('\n')[0])
view_history.close()
except IOError:
# do nothing since history file will be created later
return
def run_lint(self, _=None):
"""launches pylint"""
self.update_filenames()
self.root.configure(cursor='watch')
self.reporter = GUIReporter(self, output=self.report_stream)
module = self.txtModule.get()
if not module:
module = os.getcwd()
#cleaning up msgs and windows
self.msgs = []
self.lbMessages.delete(0, END)
self.tabs = {}
self.results.delete(0, END)
self.btnRun.config(state=DISABLED)
#setting up a worker thread to run pylint
worker = Thread(target=lint_thread, args=(module, self.reporter, self,))
self.periodic_call()
worker.start()
# Overwrite the .pylint-gui-history file with all the new recently added files
# in order from filenames but only save last 10 files
write_history = open(HOME+HISTORY, 'w')
write_history.writelines(self.filenames)
write_history.close()
self.set_history_window()
self.root.configure(cursor='')
class CFGEditor(object):
"""
A dialog window for creating and editing context free grammars.
C{CFGEditor} places the following restrictions on what C{CFG}s can
be edited:
- All nonterminals must be strings consisting of word
characters.
- All terminals must be strings consisting of word characters
and space characters.
"""
# Regular expressions used by _analyze_line. Precompile them, so
# we can process the text faster.
ARROW = SymbolWidget.SYMBOLS['rightarrow']
_LHS_RE = re.compile(r"(^\s*\w+\s*)(->|("+ARROW+"))")
_ARROW_RE = re.compile("\s*(->|("+ARROW+"))\s*")
_PRODUCTION_RE = re.compile(r"(^\s*\w+\s*)" + # LHS
"(->|("+ARROW+"))\s*" + # arrow
r"((\w+|'[\w ]*'|\"[\w ]*\"|\|)\s*)*$") # RHS
_TOKEN_RE = re.compile("\\w+|->|'[\\w ]+'|\"[\\w ]+\"|("+ARROW+")")
_BOLD = ('helvetica', -12, 'bold')
def __init__(self, parent, cfg=None, set_cfg_callback=None):
self._parent = parent
if cfg is not None: self._cfg = cfg
else: self._cfg = ContextFreeGrammar(Nonterminal('S'), [])
self._set_cfg_callback = set_cfg_callback
self._highlight_matching_nonterminals = 1
# Create the top-level window.
self._top = Toplevel(parent)
self._init_bindings()
self._init_startframe()
self._startframe.pack(side='top', fill='x', expand=0)
self._init_prodframe()
self._prodframe.pack(side='top', fill='both', expand=1)
self._init_buttons()
self._buttonframe.pack(side='bottom', fill='x', expand=0)
self._textwidget.focus()
def _init_startframe(self):
frame = self._startframe = Frame(self._top)
self._start = Entry(frame)
self._start.pack(side='right')
Label(frame, text='Start Symbol:').pack(side='right')
Label(frame, text='Productions:').pack(side='left')
self._start.insert(0, self._cfg.start().symbol())
def _init_buttons(self):
frame = self._buttonframe = Frame(self._top)
Button(frame, text='Ok', command=self._ok,
underline=0, takefocus=0).pack(side='left')
Button(frame, text='Apply', command=self._apply,
underline=0, takefocus=0).pack(side='left')
Button(frame, text='Reset', command=self._reset,
underline=0, takefocus=0,).pack(side='left')
Button(frame, text='Cancel', command=self._cancel,
underline=0, takefocus=0).pack(side='left')
Button(frame, text='Help', command=self._help,
underline=0, takefocus=0).pack(side='right')
def _init_bindings(self):
self._top.title('CFG Editor')
self._top.bind('<Control-q>', self._cancel)
self._top.bind('<Alt-q>', self._cancel)
self._top.bind('<Control-d>', self._cancel)
#self._top.bind('<Control-x>', self._cancel)
self._top.bind('<Alt-x>', self._cancel)
self._top.bind('<Escape>', self._cancel)
#self._top.bind('<Control-c>', self._cancel)
self._top.bind('<Alt-c>', self._cancel)
self._top.bind('<Control-o>', self._ok)
self._top.bind('<Alt-o>', self._ok)
self._top.bind('<Control-a>', self._apply)
self._top.bind('<Alt-a>', self._apply)
self._top.bind('<Control-r>', self._reset)
self._top.bind('<Alt-r>', self._reset)
self._top.bind('<Control-h>', self._help)
self._top.bind('<Alt-h>', self._help)
self._top.bind('<F1>', self._help)
def _init_prodframe(self):
self._prodframe = Frame(self._top)
# Create the basic Text widget & scrollbar.
self._textwidget = Text(self._prodframe, background='#e0e0e0',
exportselection=1)
self._textscroll = Scrollbar(self._prodframe, takefocus=0,
orient='vertical')
self._textwidget.config(yscrollcommand = self._textscroll.set)
self._textscroll.config(command=self._textwidget.yview)
self._textscroll.pack(side='right', fill='y')
self._textwidget.pack(expand=1, fill='both', side='left')
# Initialize the colorization tags. Each nonterminal gets its
# own tag, so they aren't listed here.
self._textwidget.tag_config('terminal', foreground='#006000')
self._textwidget.tag_config('arrow', font='symbol')
self._textwidget.tag_config('error', background='red')
# Keep track of what line they're on. We use that to remember
# to re-analyze a line whenever they leave it.
self._linenum = 0
# Expand "->" to an arrow.
self._top.bind('>', self._replace_arrows)
# Re-colorize lines when appropriate.
self._top.bind('<<Paste>>', self._analyze)
self._top.bind('<KeyPress>', self._check_analyze)
self._top.bind('<ButtonPress>', self._check_analyze)
# Tab cycles focus. (why doesn't this work??)
def cycle(e, textwidget=self._textwidget):
textwidget.tk_focusNext().focus()
self._textwidget.bind('<Tab>', cycle)
prod_tuples = [(p.lhs(),[p.rhs()]) for p in self._cfg.productions()]
for i in range(len(prod_tuples)-1,0,-1):
if (prod_tuples[i][0] == prod_tuples[i-1][0]):
if () in prod_tuples[i][1]: continue
if () in prod_tuples[i-1][1]: continue
print prod_tuples[i-1][1]
print prod_tuples[i][1]
prod_tuples[i-1][1].extend(prod_tuples[i][1])
del prod_tuples[i]
for lhs, rhss in prod_tuples:
print lhs, rhss
s = '%s ->' % lhs
for rhs in rhss:
for elt in rhs:
if isinstance(elt, Nonterminal): s += ' %s' % elt
else: s += ' %r' % elt
s += ' |'
s = s[:-2] + '\n'
self._textwidget.insert('end', s)
self._analyze()
# # Add the producitons to the text widget, and colorize them.
# prod_by_lhs = {}
# for prod in self._cfg.productions():
# if len(prod.rhs()) > 0:
# prod_by_lhs.setdefault(prod.lhs(),[]).append(prod)
# for (lhs, prods) in prod_by_lhs.items():
# self._textwidget.insert('end', '%s ->' % lhs)
# self._textwidget.insert('end', self._rhs(prods[0]))
# for prod in prods[1:]:
# print '\t|'+self._rhs(prod),
# self._textwidget.insert('end', '\t|'+self._rhs(prod))
# print
# self._textwidget.insert('end', '\n')
# for prod in self._cfg.productions():
# if len(prod.rhs()) == 0:
# self._textwidget.insert('end', '%s' % prod)
# self._analyze()
# def _rhs(self, prod):
# s = ''
# for elt in prod.rhs():
# if isinstance(elt, Nonterminal): s += ' %s' % elt.symbol()
# else: s += ' %r' % elt
# return s
def _clear_tags(self, linenum):
"""
Remove all tags (except C{arrow} and C{sel}) from the given
line of the text widget used for editing the productions.
"""
start = '%d.0'%linenum
end = '%d.end'%linenum
for tag in self._textwidget.tag_names():
if tag not in ('arrow', 'sel'):
self._textwidget.tag_remove(tag, start, end)
def _check_analyze(self, *e):
"""
Check if we've moved to a new line. If we have, then remove
all colorization from the line we moved to, and re-colorize
the line that we moved from.
"""
linenum = int(self._textwidget.index('insert').split('.')[0])
if linenum != self._linenum:
self._clear_tags(linenum)
self._analyze_line(self._linenum)
self._linenum = linenum
def _replace_arrows(self, *e):
"""
Replace any C{'->'} text strings with arrows (char \\256, in
symbol font). This searches the whole buffer, but is fast
enough to be done anytime they press '>'.
"""
arrow = '1.0'
while 1:
arrow = self._textwidget.search('->', arrow, 'end+1char')
if arrow == '': break
self._textwidget.delete(arrow, arrow+'+2char')
self._textwidget.insert(arrow, self.ARROW, 'arrow')
self._textwidget.insert(arrow, '\t')
arrow = '1.0'
while 1:
arrow = self._textwidget.search(self.ARROW, arrow+'+1char',
'end+1char')
if arrow == '': break
self._textwidget.tag_add('arrow', arrow, arrow+'+1char')
def _analyze_token(self, match, linenum):
"""
Given a line number and a regexp match for a token on that
line, colorize the token. Note that the regexp match gives us
the token's text, start index (on the line), and end index (on
the line).
"""
# What type of token is it?
if match.group()[0] in "'\"": tag = 'terminal'
elif match.group() in ('->', self.ARROW): tag = 'arrow'
else:
# If it's a nonterminal, then set up new bindings, so we
# can highlight all instances of that nonterminal when we
# put the mouse over it.
tag = 'nonterminal_'+match.group()
if tag not in self._textwidget.tag_names():
self._init_nonterminal_tag(tag)
start = '%d.%d' % (linenum, match.start())
end = '%d.%d' % (linenum, match.end())
self._textwidget.tag_add(tag, start, end)
def _init_nonterminal_tag(self, tag, foreground='blue'):
self._textwidget.tag_config(tag, foreground=foreground,
font=CFGEditor._BOLD)
if not self._highlight_matching_nonterminals:
return
def enter(e, textwidget=self._textwidget, tag=tag):
textwidget.tag_config(tag, background='#80ff80')
def leave(e, textwidget=self._textwidget, tag=tag):
textwidget.tag_config(tag, background='')
self._textwidget.tag_bind(tag, '<Enter>', enter)
self._textwidget.tag_bind(tag, '<Leave>', leave)
def _analyze_line(self, linenum):
"""
Colorize a given line.
"""
# Get rid of any tags that were previously on the line.
self._clear_tags(linenum)
# Get the line line's text string.
line = self._textwidget.get(`linenum`+'.0', `linenum`+'.end')
# If it's a valid production, then colorize each token.
if CFGEditor._PRODUCTION_RE.match(line):
# It's valid; Use _TOKEN_RE to tokenize the production,
# and call analyze_token on each token.
def analyze_token(match, self=self, linenum=linenum):
self._analyze_token(match, linenum)
return ''
CFGEditor._TOKEN_RE.sub(analyze_token, line)
elif line.strip() != '':
# It's invalid; show the user where the error is.
self._mark_error(linenum, line)
def _mark_error(self, linenum, line):
"""
Mark the location of an error in a line.
"""
arrowmatch = CFGEditor._ARROW_RE.search(line)
if not arrowmatch:
# If there's no arrow at all, highlight the whole line.
start = '%d.0' % linenum
end = '%d.end' % linenum
elif not CFGEditor._LHS_RE.match(line):
# Otherwise, if the LHS is bad, highlight it.
start = '%d.0' % linenum
end = '%d.%d' % (linenum, arrowmatch.start())
else:
# Otherwise, highlight the RHS.
start = '%d.%d' % (linenum, arrowmatch.end())
end = '%d.end' % linenum
# If we're highlighting 0 chars, highlight the whole line.
if self._textwidget.compare(start, '==', end):
start = '%d.0' % linenum
end = '%d.end' % linenum
self._textwidget.tag_add('error', start, end)
def _analyze(self, *e):
"""
Replace C{->} with arrows, and colorize the entire buffer.
"""
self._replace_arrows()
numlines = int(self._textwidget.index('end').split('.')[0])
for linenum in range(1, numlines+1): # line numbers start at 1.
self._analyze_line(linenum)
def _parse_productions(self):
"""
Parse the current contents of the textwidget buffer, to create
a list of productions.
"""
productions = []
# Get the text, normalize it, and split it into lines.
text = self._textwidget.get('1.0', 'end')
text = re.sub(self.ARROW, '->', text)
text = re.sub('\t', ' ', text)
lines = text.split('\n')
# Convert each line to a CFG production
for line in lines:
line = line.strip()
if line=='': continue
productions += parse_cfg_production(line)
#if line.strip() == '': continue
#if not CFGEditor._PRODUCTION_RE.match(line):
# raise ValueError('Bad production string %r' % line)
#
#(lhs_str, rhs_str) = line.split('->')
#lhs = Nonterminal(lhs_str.strip())
#rhs = []
#def parse_token(match, rhs=rhs):
# token = match.group()
# if token[0] in "'\"": rhs.append(token[1:-1])
# else: rhs.append(Nonterminal(token))
# return ''
#CFGEditor._TOKEN_RE.sub(parse_token, rhs_str)
#
#productions.append(Production(lhs, *rhs))
return productions
def _destroy(self, *e):
if self._top is None: return
self._top.destroy()
self._top = None
def _ok(self, *e):
self._apply()
self._destroy()
def _apply(self, *e):
productions = self._parse_productions()
start = Nonterminal(self._start.get())
cfg = ContextFreeGrammar(start, productions)
if self._set_cfg_callback is not None:
self._set_cfg_callback(cfg)
def _reset(self, *e):
self._textwidget.delete('1.0', 'end')
for production in self._cfg.productions():
self._textwidget.insert('end', '%s\n' % production)
self._analyze()
if self._set_cfg_callback is not None:
self._set_cfg_callback(self._cfg)
def _cancel(self, *e):
try: self._reset()
except: pass
self._destroy()
def _help(self, *e):
# The default font's not very legible; try using 'fixed' instead.
try:
ShowText(self._parent, 'Help: Chart Parser Demo',
(_CFGEditor_HELP).strip(), width=75, font='fixed')
except:
ShowText(self._parent, 'Help: Chart Parser Demo',
(_CFGEditor_HELP).strip(), width=75)
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.padx = 3
self.pady = 3
self.grid()
self.results = []
self.playlists = []
self.vids = []
self.__createWidgets()
def __createWidgets(self):
self.__searchFields()
self.__resultArea()
self.__buttons()
self.__markdownArea()
self.bind('<Return>', self.search_button)
def __buttons(self):
self.resultSelect = Button(text='OK', state=DISABLED)
self.resultSelect.grid(row=5, column=4, sticky=E,
padx=self.padx, pady=self.pady)
self.status = Label(text="", bd=1, relief=SUNKEN, anchor=W)
self.status.grid(row=9, column=0, columnspan=10, sticky=N + E + S + W)
self.__vidButtons()
self.__rmVidButtons()
self.resultSelect.grid_forget()
def __searchFields(self):
Label(text="User", anchor=E).grid(row=0, column=0,
padx=self.padx, pady=self.pady,
sticky=W)
self.user_entry = Entry()
self.user_entry.grid(row=0, column=1, padx=self.padx, pady=self.pady,
sticky=W)
Label(text="Search terms").grid(row=0, column=3,
padx=self.padx, pady=self.pady,
sticky=W)
self.search_terms = Entry()
self.search_terms.grid(row=0, column=4,
padx=self.padx, pady=self.pady,
sticky=W)
Label(text="playlist id").grid(row=1, column=3,
padx=self.padx, pady=self.pady,
sticky=W)
self.playlist_id = Entry()
self.playlist_id.grid(row=1, column=4, padx=self.padx, pady=self.pady,
sticky=W)
self.search_button = Button(text="Search", command=self.__search)
self.search_button.grid(row=2, column=4,
padx=self.padx, pady=self.pady, sticky=E)
def __resultArea(self):
self.result_label = Label(text="Results")
self.result_label.grid(row=2, column=0,
padx=self.padx, pady=self.pady,
sticky=W)
self.resultshowbut = Button(text="View", command=self.__showResults)
self.resultshowbut.grid(row=2, column=1, sticky=W)
self.yScroll = Scrollbar(orient=VERTICAL)
self.xScroll = Scrollbar(orient=HORIZONTAL)
self.listbox = Listbox(xscrollcommand=self.xScroll.set,
yscrollcommand=self.yScroll.set,
selectmode=SINGLE)
self.xScroll.config(command=self.listbox.xview)
self.yScroll.config(command=self.listbox.yview)
def __showResults(self):
self.resultshowbut.config(text="Hide", command=self.__hideResults)
self.yScroll.grid(row=3, column=5, sticky=N + S)
self.xScroll.grid(row=4, column=0, sticky=E + W, columnspan=5)
self.listbox.grid(row=3, column=0, sticky=N + S + E + W, columnspan=5)
self.markdownarea.config(height=10)
def __hideResults(self):
self.resultshowbut.config(text="View", command=self.__showResults)
self.yScroll.grid_forget()
self.xScroll.grid_forget()
self.listbox.grid_forget()
self.markdownarea.config(height=30)
def __markdownArea(self):
self.markdownlabel = Label(text="Markdown")
self.mdyScroll = Scrollbar(orient=VERTICAL)
self.mdxScroll = Scrollbar(orient=HORIZONTAL)
self.markdownarea = Text(wrap=WORD, height=10,
yscrollcommand=self.mdyScroll.set,
xscrollcommand=self.mdxScroll.set)
self.copymarkdown = Button(text="Copy To Clipboard",
command=self.__copyMarkdown)
self.mdxScroll.config(command=self.markdownarea.xview)
self.mdyScroll.config(command=self.markdownarea.yview)
def __vidButtons(self):
self.modtitle = Button(text='Modify titles', command=self.__modTitles)
#self.modtitle.grid(row=5, column=0, sticky=W, columnspan=2,
# padx=self.padx, pady=self.pady)
self.getcaps = Button(text="Get captions", command=self.__getCaptions)
self.getcaps.grid(row=5, column=2, columnspan=3, sticky=E,
padx=self.padx, pady=self.pady)
def __rmVidButtons(self):
self.modtitle.grid_remove()
self.getcaps.grid_remove()
self.bind('<Return>', self.search_button)
def __search(self):
user = self.user_entry.get()
playlist = self.playlist_id.get()
searchterms = self.search_terms.get()
self.__showResults()
self.resultSelect.config(state=DISABLED)
self.__rmVidButtons()
self.__rmMarkdown()
if not self.__validparams(user, searchterms, playlist):
return False
if len(playlist) > 0:
self.__searchPlaylist(playlist)
return
self.__searchUser(user, searchterms)
def __showMarkdown(self):
self.markdownlabel.grid(row=5, column=0,
padx=self.padx, pady=self.pady,
sticky=W)
self.markdownarea.grid(row=6, column=0, columnspan=5,
padx=self.padx, pady=self.pady,
sticky=N + S + E + W)
self.mdyScroll.grid(row=6, column=5, sticky=N + S)
self.mdxScroll.grid(row=7, column=0, sticky=E + W, columnspan=5)
self.copymarkdown.grid(row=8, column=2, columnspan=3, sticky=E,
padx=self.padx, pady=self.pady)
def __rmMarkdown(self):
self.markdownarea.grid_forget()
self.markdownlabel.grid_forget()
self.copymarkdown.grid_forget()
self.mdyScroll.grid_forget()
self.mdxScroll.grid_forget()
def __searchPlaylist(self, playlistid):
self.__getvids(playlistid)
def __searchUser(self, user, searchterms):
self.listbox.delete(0, END)
self.__status("Searching for%splaylists by user \"%s\"" % (
" \"%s\" " % searchterms if len(searchterms) else " ",
user))
self.playlists = []
try:
self.playlists = lib.yt.search.PlaylistSearch(user=user,
search=searchterms).query()
except HTTPError:
self.__status("User %s does not exist at youtube" % user)
return
if self.playlists is None or len(self.playlists) == 0:
self.__status("Search returned no results")
return
self.__populateResults([v['title'] for v in self.playlists])
self.resultSelect.config(command=self.__getVidsFromSelected,
state=NORMAL)
self.__status("")
self.resultSelect.grid(row=5, column=4, sticky=E,
padx=self.padx, pady=self.pady)
def __populateResults(self, values):
self.listbox.delete(0, END)
for i, val in enumerate(values):
self.listbox.insert(i, val)
self.listbox.activate(0)
self.listbox.selection_set(0)
def __getVidsFromSelected(self):
selected = int(self.listbox.curselection()[0])
self.__getvids(self.playlists[selected]['id'])
def __getvids(self, playlistid):
self.playlist_id.delete(0, END)
self.playlist_id.insert(0, playlistid)
self.resultSelect.grid_forget()
title = playlistid
if len(self.playlists) > 0:
for playlist in self.playlists:
if playlist['id'] == playlistid:
title = playlist['title']
break
self.__status("Getting videos for %s" % title)
self.listbox.delete(0, END)
try:
self.vids = lib.yt.search.PlaylistVideoSearch(
id=playlistid).query()
self.__populateResults([v['title'] for v in self.vids])
self.__status("%d Videos found" % len(self.vids))
self.__vidButtons()
self.bind('<Return>', self.getcaps)
except HTTPError:
self.__status("No videos found! is %s a valid playlist?" %
playlistid)
def __status(self, msg):
if len(msg) > 75:
msg = msg[:70] + '...'
self.status.config(text=msg)
self.status.update_idletasks()
def __trackSelect(self, vid, tracks, preftrack=None):
pref = self.__prefAvailable(preftrack, tracks)
if pref is None:
sel = lib.trackSelect.TrackSelect(self, vid=vid,
tracks=tracks)
if sel.result is None:
self.__status("skipped")
tracks = None
else:
tracks = [sel.result[0]]
if sel.preflang is not None:
preftrack['lang'] = sel.preflang
if sel.prefname is not None:
preftrack['name'] = sel.prefname
else:
tracks = pref
return tracks, preftrack
def __getCaptions(self):
preftrack = {'name': None, 'lang': None}
self.listbox.delete(0, END)
self.markdownarea.delete(1.0, END)
self.__showMarkdown()
for i, vid in enumerate(self.vids):
nocapmsg = '[%02d] --NO CAPTIONS-- %s' % (i + 1, vid['title'])
tracks = lib.yt.search.CaptionSearch(id=vid['id']).query()
self.vids[i]['text'] = ''
if len(tracks) == 0:
self.__status('No captions available for %s' %
self.vids[i]['title'])
self.listbox.insert(END, nocapmsg)
elif len(tracks) > 1:
sel = self.__trackSelect(vid, tracks, preftrack)
if sel[0] is None:
msg = '[%02d] --SKIPPED-- %s' % (i + 1, vid['title'])
self.listbox.insert(END, msg)
self.listbox.see(END)
continue
tracks = sel[0]
if len(tracks) == 1:
self.__trackCaps(i, tracks, nocapmsg)
self.__status('')
self.__hideResults()
def __trackCaps(self, vidIndex, tracks, nocapmsg):
i = vidIndex
vid = self.vids[i]
msg = '%02d of %02d Getting captions for %s' % (
i + 1, len(self.vids), self.vids[i]['title'])
self.__status(msg)
self.listbox.insert(END, msg)
self.vids[i]['text'] = lib.markdown.heading(vid['title'])
captions = lib.yt.search.GetCaptions(id=vid['id'],
lang=tracks[0]['lang'],
name=tracks[0]['name'])
captions.query()
captiontext = captions.textOnly()
sleep(0.2)
msg = nocapmsg
if captiontext is not None and len(captiontext) > 0:
self.vids[i]['text'] += (lib.markdown.to_utf8(captiontext)
+ '\n\n')
msg = '[%02d] --DONE-- %s' % (i + 1, vid['title'])
self.listbox.delete(END, END)
self.listbox.insert(END, msg)
self.listbox.see(END)
self.markdownarea.insert(END, self.vids[i]['text'])
self.markdownarea.see(END)
def __prefAvailable(self, preftrack, tracks):
if preftrack['lang'] is None:
return None
pref = None
for track in tracks:
if (track['lang'] == preftrack['lang'] and
track['name'] == preftrack['name']):
return [track]
if track['lang'] == preftrack['lang'] and pref is None:
pref = [track]
return pref
def __modTitles(self):
pass
def __validparams(self, user, searchterms, playlist):
if len(user) == 0 and len(playlist) == 0:
msg = "Either a valid youtube user or playlist id must be given."
tkMessageBox.showwarning("missing information", msg)
return False
if len(user) > 0 and not self.__validstring(user):
msg = "The user given contains invalid characters"
tkMessageBox.showwarning('Bad user', msg)
return False
if len(playlist) > 0 and not self.__validstring(playlist):
msg = "The playlist given contains invalid characters"
tkMessageBox.showwarning('Bad playlist', msg)
return False
if len(searchterms) > 0 and not self.__validstring(searchterms, True):
msg = "The search terms given contain invalid characters"
tkMessageBox.showwarning('Bad search', msg)
return False
return True
def __validstring(self, s, spacechar=False):
validchars = string.letters + string.digits + string.punctuation
if spacechar:
validchars += ' '
for c in s:
if c not in validchars:
return False
return True
def __copyMarkdown(self):
self.markdownarea.clipboard_clear()
self.markdownarea.clipboard_append(self.markdownarea.get(1.0, END))
class App(Frame):
def __init__(self, master=None):
self.computing = False
self.S = None
self.progress_queue = Queue.Queue()
self.cancel_event = threading.Event()
Frame.__init__(self, master)
self.grid()
self.master.protocol("WM_DELETE_WINDOW", self.close_handler)
w = Label(self,text=" ",fg="red")
w.grid(row=0,column=0,pady=10,sticky=W)
## Object parameters
w = Label(self,text="Tower parameters:",fg="red")
w.grid(row=0,column=1,pady=10,sticky=W)
w = Label(self,text="Latitude (deg):")
w.grid(row=1,column=1,sticky=W)
self.lat_ent = Entry(self,width=36)
self.lat_ent.grid(row=1,column=2,sticky=W)
self.lat_ent.insert(0, "60")
w = Label(self,text="Tower height (m):")
w.grid(row=2,column=1,sticky=W)
self.height_ent = Entry(self,width=36)
self.height_ent.grid(row=2,column=2,sticky=W)
self.height_ent.insert(0, "50")
w = Label(self,text="Tower diameter (m):")
w.grid(row=3,column=1,sticky=W)
self.diam_ent = Entry(self,width=36)
self.diam_ent.grid(row=3,column=2,sticky=W)
self.diam_ent.insert(0, "30")
## Simulation parameters
w = Label(self,text="Simulation parameters",fg="red")
w.grid(row=4,column=1,pady=10,sticky=SW)
w = Label(self,text="Time vector (s):")
w.grid(row=5,column=1,sticky=W)
self.time_ent = Entry(self,width=36)
self.time_ent.grid(row=5,column=2)
self.time_ent.insert(0, "arange(0,365*24*3600,10*60)")
## Output parameters
w = Label(self,text="Output parameters",fg="red")
w.grid(row=6,column=1,pady=10,sticky=SW)
w = Label(self,text="East-west grid (m):")
w.grid(row=7,column=1,sticky=W)
self.gridx_ent = Entry(self,width=36)
self.gridx_ent.grid(row=7,column=2)
self.gridx_ent.insert(0, "linspace(-4*tower_height,4*tower_height,10)")
w = Label(self,text="South-north grid (m):")
w.grid(row=8,column=1,sticky=W)
self.gridy_ent = Entry(self,width=36)
self.gridy_ent.grid(row=8,column=2)
self.gridy_ent.insert(0, "linspace(-4*tower_height,4*tower_height,10)")
self.compute_btn = Button(self, text="Start computation", width=15, command=self.compute_btn_handler)
self.compute_btn.grid(row=9,column=1,pady=10,sticky=E)
w = Label(self,text=" ",fg="red")
w.grid(row=0,column=3,pady=10,sticky=W)
self.periodicCall()
def close_handler(self):
self.cancel_event.set()
self.master.quit()
def parse_entries(self):
self.phi = 0
self.latitude = float(eval(self.lat_ent.get()))
tower_height = float(eval(self.height_ent.get()))
self.tower_height = tower_height
self.tower_diameter = float(eval(self.diam_ent.get()))
self.time_vector = eval(self.time_ent.get())
x = eval(self.gridx_ent.get())
y = eval(self.gridy_ent.get())
X,Y = meshgrid(x,y)
self.X = X
self.Y = Y
def compute_btn_handler(self):
if self.computing:
self.cancel_event.set()
self.thread1.join()
self.compute_btn.config(text="Start computation")
else:
self.cancel_event = threading.Event()
self.meter = Meter(self, relief='ridge', bd=3, width=250)
self.meter.grid(row=9,column=2)
self.parse_entries()
self.compute_btn.config(text="Stop computation")
self.thread1 = threading.Thread(target=self.worker_thread)
self.thread1.start()
def periodicCall(self):
"""
Check every 100 ms if there is something new in the queue.
"""
while self.progress_queue.qsize():
try:
msg = self.progress_queue.get(0)
if msg == 1.0:
self.meter.set(msg,"Completed successfully")
else:
self.meter.set(msg)
except Queue.Empty:
pass
if self.computing:
self.compute_btn.config(text="Stop computation")
else:
self.compute_btn.config(text="Start computation")
if self.S != None:
self.plot_shadow_map()
self.S = None
self.master.after(100, self.periodicCall)
def plot_shadow_map(self):
ion()
contourf(self.X, self.Y, self.S/3600.,levels=[0.1,5,10,15,30,40,50,100,1e6],cmap=cm.get_cmap(name="gist_heat_r"))
clim(0,100)
colorbar()
CS = contour(self.X, self.Y, self.S/3600.,levels=[0.0001,5,10,15,30,40,50,100],antialiased=True,colors='k')
clabel(CS, inline=1, fontsize=8)
xlabel('Location west-east (m)')
ylabel('Location south-north (m)')
show()
def worker_thread(self):
self.S = None
self.computing = True
S = shadow.tower_shadow_map(self.phi, \
self.latitude*pi/180., \
self.tower_height, \
self.tower_diameter, \
self.time_vector, \
self.X, \
self.Y, \
self.progress_queue, \
self.cancel_event)
self.S = S
self.computing = False
class Recherche(Vue):
"""
Vue principal
"""
def __init__(self, fenetre):
"""
Constructeur de la fenetre
"""
self.parent = fenetre
self.frame = Frame(self.parent, borderwidth=1, relief='groove', width=100)
self.frame.pack_configure(side='top', fill='both')
self.frame.pack()
self.titre = Label(self.frame, text=GT_('Url'), font=(20))
self.titre.pack()
self.img = PhotoImage(file="%slogo.gif" % RESSOURCES_PATH)
self.logo = Label(self.frame, image=self.img)
self.logo.pack(pady=(0, 20), side="left")
self.brand = Label(self.frame, text=GT_('WebForge %s' % VERSION), font=(20))
self.brand.pack(pady=(10, 20), padx=(0, 20), side="left")
self.txt_recherche = Entry(self.frame, font=(22))
self.txt_recherche.pack(pady=(0, 20), expand='yes', fill='both', side='left')
self.btn_go = Button(self.frame, text="GO")
self.btn_go.pack(pady=(0, 20), side='right')
self.btn_erase = Button(self.frame, text="X")
self.btn_erase.pack(pady=(0, 20), side='right')
def set_url(self, url):
"""
Set a new url value to the field
"""
self.txt_recherche.insert(0, url)
