class PasswordDialog(Dialog):
def __init__(self, title, prompt, parent):
self.prompt = prompt
Dialog.__init__(self, parent, title)
def body(self, master):
from tkinter import Label
from tkinter import Entry
from tkinter import Checkbutton
from tkinter import IntVar
from tkinter import W
self.checkVar = IntVar()
Label(master, text=self.prompt).grid(row=0, sticky=W)
self.e1 = Entry(master)
self.e1.grid(row=0, column=1)
self.cb = Checkbutton(master,
text="Save to keychain",
variable=self.checkVar)
#self.cb.pack()
self.cb.grid(row=1, columnspan=2, sticky=W)
self.e1.configure(show='*')
def apply(self):
self.result = (self.e1.get(), self.checkVar.get() == 1)
def make_form(root):
global csd, i, fixed, fixed_standard, power, rows
ions = list(csd.keys())[1:] #To ignore power
csds = list(csd.values())[1:]
fixeds = list(fixed_standard.values())
rows = []
power = []
for k in range(len(ions)):
i = i + 1
items = []
for j in range(0, 2): #Columns
b = Entry(root, width=10)
if j == 0: b.insert(j, ions[k])
else: b.insert(j, csds[k])
items.append(b)
b.grid(row=i, column=j)
var = IntVar()
var.set(fixeds[k]) #To already have checked buttons
c = Checkbutton(root, variable=var, width=10, anchor='w')
c.val = var
items.append(c)
c.grid(row=i, column=2)
rows.append(items)
e3 = Entry(root, width=5)
e3.insert(0, csd.get('power'))
e3.grid(row=1, column=2, padx=5, pady=5, sticky='e')
power.append(e3)
e4 = Label(root, text='Power 1e+', width=8)
e4.grid(row=1, column=2, padx=5, pady=5, sticky='w')
def init(self):
Label(self, text='Folder root:').grid(row=0, column=0, sticky='E')
sf = Entry(self, textvariable=self.source_folder)
sf.bind('<Return>', self.l_gen_pdf)
sf.grid(row=0, column=1, columnspan=2, sticky='EW')
sf.focus_set()
Button(self, text='...', command=self.get_source_dir).grid(row=0, column=3)
Label(self, text='Output (same folder if empty):').grid(row=1, column=0, sticky='E')
of = Entry(self, textvariable=self.out_folder)
of.bind('<Return>', self.l_gen_pdf)
of.grid(row=1, column=1, columnspan=2, sticky='EW')
Button(self, text='...', command=self.get_out_file).grid(row=1, column=3)
Label(self, text='Quality:').grid(row=2, column=0, sticky='E')
qf = Entry(self, textvariable=self.quality)
qf.bind('<Return>', self.l_gen_pdf)
qf.grid(row=2, column=1)
Label(self, text='Optimize:').grid(row=2, column=2, sticky='E')
pf = Checkbutton(self, variable=self.optimize)
pf.grid(row=2, column=3)
gb = Button(self, text='Generate', command=self.l_gen_pdf)
gb.bind('<Return>', self.l_gen_pdf)
gb.grid(row=3, column=0, columnspan=4, sticky='EW')
def __init__(self, client):
# Basic setup
super(Preferences, self).__init__()
self.client = client
# Setup the variables used
self.echo_input = BooleanVar()
self.echo_input.set(self.client.config['UI'].getboolean('echo_input'))
self.echo_input.trace("w", self.echo_handler)
self.logging = BooleanVar()
self.logging.set(
self.client.config['logging'].getboolean('log_session'))
self.logging.trace('w', self.logging_handler)
self.log_dir = self.client.config['logging']['log_directory']
# Build the actual window and widgets
prefs = Toplevel(self)
prefs.wm_title("Preferences")
echo_input_label = Label(prefs, text="Echo Input:")
logging_label = Label(prefs, text='Log to file:')
echo_checkbox = Checkbutton(prefs, variable=self.echo_input)
logging_checkbox = Checkbutton(prefs, variable=self.logging)
logging_button_text = 'Choose file...' if self.log_dir == "" else self.log_dir
logging_button = Button(prefs,
text=logging_button_text,
command=self.logging_pick_location)
# Pack 'em in.
echo_input_label.grid(row=0, column=0)
echo_checkbox.grid(row=0, column=1)
logging_label.grid(row=1, column=0)
logging_checkbox.grid(row=1, column=1)
logging_button.grid(row=1, column=2)
def __init__(self, master):
super().__init__(master)
self.mon_var = IntVar()
self.tue_var = IntVar()
self.wed_var = IntVar()
self.thu_var = IntVar()
self.fri_var = IntVar()
self.sat_var = IntVar()
self.sun_var = IntVar()
self.int_vars = (self.mon_var, self.tue_var, self.wed_var,
self.thu_var, self.fri_var, self.sat_var,
self.sun_var)
row, col = 0, 0
for day, var in zip(('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'),
self.int_vars):
cb = Checkbutton(self, text=day, variable=var)
cb.grid(row=row, column=col, sticky='w')
cb.toggle()
col += 1
if col % 4 == 0:
row += 1
col = 0
def initUI(self):
self.centerWindow()
self.pack(fill=BOTH, expand=True)
self.parent.title('Выберите параметры для анализа')
container1 = Frame(self)
group = LabelFrame(container1, text='Шрифт')
group.pack(side=TOP, fill=BOTH, expand=True)
group2 = LabelFrame(container1, text='Абзац')
group2.pack(side=TOP, fill=BOTH, expand=True)
i = 0
for param_id, param in PARAMS.items():
if i < 4:
but = Checkbutton(group,
text=param.name,
variable=self.user_selected[param_id])
but.grid(row=i, sticky=W, padx=(5, 25))
else:
but = Checkbutton(group2,
text=param.name,
variable=self.user_selected[param_id])
but.grid(row=i, sticky=W, padx=(5, 25))
i += 1
container1.pack(side=LEFT, fill=BOTH)
quitButton = Button(self, text="Продолжить", command=self.goAnalyse)
quitButton.pack(padx=15, side=LEFT)
def __init__(self, app, font):
self.app = app
self.frame = LabelFrame(
app.frame,
text='LEDs and Switches',
font=font,
)
self.LEDs = []
self.switches = []
for column in range(8):
LED_var = IntVar(self.frame)
LED = Checkbutton(
self.frame,
indicatoron=0,
selectcolor='#8080ff',
text=str(column),
variable=LED_var,
)
LED.bind('<Button-1>', lambda _: 'break') # Output only.
LED.grid(row=0, column=7 - column)
switch_var = IntVar(self.frame)
switch = Checkbutton(
self.frame,
command=(lambda i=column: self._set_switch(i)),
variable=switch_var,
)
switch.grid(row=1, column=7 - column)
self.LEDs.append(LED_var)
self.switches.append(switch_var)
self._monkey_patch_LED_write(self.app.cpu)
def build_options_list(self):
"""
Construit la liste des options disponibles
:return: list(IntVar) - Liste contenant les identifiants des options
"""
# Label
opt_label = Label(self, text="Options")
opt_label.configure(font=font.Font(family=Config.FONT["main"],
size=Config.SIZE["large"]),
background=Config.COLOR["main-bg"],
foreground=Config.COLOR["main-fg"])
opt_label.grid(sticky='w', padx=10)
# Checkbox
opt_list = []
for text in Menu.OPTIONS:
x = IntVar()
ckb = Checkbutton(self, text=text, variable=x, tristatevalue=0)
ckb.configure(font=font.Font(family=Config.FONT["main"],
size=Config.SIZE["medium"]),
background=Config.COLOR["main-bg"],
foreground=Config.COLOR["main-fg"],
activebackground=Config.COLOR["main-bg"],
activeforeground=Config.COLOR["main-fg"],
selectcolor=Config.COLOR["main-bg"])
ckb.grid(sticky='w', padx=20)
opt_list.append(x)
return opt_list
def __init__(self):
# create the window
window = Tk()
window.title("Widget Demo")
# create the first frame
frame1 = Frame(window)
frame1.pack()
# create variables for buttons and create the buttons
self.v1 = IntVar()
cbtBold = Checkbutton(frame1,
text="Bold",
variable=self.v1,
command=self.processCheckbutton)
self.v2 = IntVar()
rbRed = Radiobutton(frame1,
text="Red",
bg="red",
variable=self.v2,
value=1,
command=self.processRadiobutton)
rbYellow = Radiobutton(frame1,
text="Yellow",
bg="yellow",
variable=self.v2,
value=2,
command=self.processRadiobutton)
# set the buttons in the frame
cbtBold.grid(row=1, column=1)
rbRed.grid(row=1, column=2)
rbYellow.grid(row=1, column=3)
# create the second frame
frame2 = Frame(window)
frame2.pack()
# create labels and entry and button and message
label = Label(frame2, text="Enter Your Name: ")
self.name = StringVar()
entryName = Entry(frame2, textvariable=self.name)
btGetName = Button(frame2, text="Get Name", command=self.processButton)
message = Message(frame2, text="This is the Message Widget")
# position what we just made
label.grid(row=1, column=1)
entryName.grid(row=1, column=2)
btGetName.grid(row=1, column=3)
message.grid(row=1, column=4)
# create a text window and add text to it
text = Text(window)
text.pack()
text.insert(END, "Tip\nThe Best way to learn tkinter is to read ")
text.insert(END, "these carefully designed examples and use them ")
text.insert(END, "to create your application")
window.mainloop()
class SettingsWindowFrame:
def __init__(self, master, fields):
self.fields = fields
self.frame = Frame(master, bd=2, relief=GROOVE)
ROW_WINDOW_SETTINGS = 0
ROW_DIMENSIONS = 1
ROW_MESSAGE_SHUFFLE = 2
Label(self.frame, text="Window Settings").grid(row=ROW_WINDOW_SETTINGS, column=0, columnspan=3, sticky=W)
self.frameDimensions = Frame(self.frame)
self.LABEL_WINDOW_WIDTH = Label(self.frameDimensions, text="Width:")
self.LABEL_WINDOW_WIDTH.grid(row=0, column=0, sticky=E, pady=1)
self.ENTRY_WINDOW_WIDTH = Entry(self.frameDimensions, textvariable=self.fields.VAR_WINDOW_WIDTH, width=5)
self.ENTRY_WINDOW_WIDTH.grid(row=0, column=1, sticky=W, pady=1)
Label(self.frameDimensions, text="pixels").grid(row=0, column=2, sticky=W, pady=1)
self.LABEL_WINDOW_HEIGHT = Label(self.frameDimensions, text="Height:")
self.LABEL_WINDOW_HEIGHT.grid(row=1, column=0, sticky=E, pady=1)
self.ENTRY_WINDOW_HEIGHT = Entry(self.frameDimensions, textvariable=self.fields.VAR_WINDOW_HEIGHT, width=5)
self.ENTRY_WINDOW_HEIGHT.grid(row=1, column=1, sticky=W, pady=1)
Label(self.frameDimensions, text="pixels").grid(row=1, column=2, sticky=W, pady=1)
self.frameDimensions.grid(row=ROW_DIMENSIONS, sticky=W, pady=1)
self.frameShuffle = Frame(self.frame)
self.checkButtonShuffle = Checkbutton(self.frameShuffle, borderwidth=0, text="Display Messages in Random Order", variable=self.fields.VAR_MESSAGE_SHUFFLE)
self.checkButtonShuffle.grid(pady=1, sticky=W)
self.frameShuffle.grid(row=ROW_MESSAGE_SHUFFLE, sticky=W, pady=1)
def _addCheck(self, key, label, value, command=None):
'''
'''
if command is None:
command = self._updatePrice
# end if
parent = self.fData
if value:
value = 1
else:
value = 0
# end if
boolVar = IntVar(value=value)
checkbutton = Checkbutton(parent,
text=label,
variable=boolVar,
width=30,
anchor='w',
command=command)
checkbutton.grid(row=self.row, columnspan=2, sticky='W')
self.dCheck[key] = boolVar
self.dCheckButton[key] = checkbutton
self.row += 1
def __init__(self, client):
# Basic setup
super(Preferences, self).__init__()
self.client = client
# Setup the variables used
self.echo_input = BooleanVar()
self.echo_input.set(self.client.config['UI'].getboolean('echo_input'))
self.echo_input.trace("w", self.echo_handler)
self.logging = BooleanVar()
self.logging.set(self.client.config['logging'].getboolean('log_session'))
self.logging.trace('w', self.logging_handler)
self.log_dir = self.client.config['logging']['log_directory']
# Build the actual window and widgets
prefs = Toplevel(self)
prefs.wm_title("Preferences")
echo_input_label = Label(prefs, text="Echo Input:")
logging_label = Label(prefs, text='Log to file:')
echo_checkbox = Checkbutton(prefs, variable=self.echo_input)
logging_checkbox = Checkbutton(prefs, variable=self.logging)
logging_button_text = 'Choose file...' if self.log_dir == "" else self.log_dir
logging_button = Button(prefs, text=logging_button_text, command=self.logging_pick_location)
# Pack 'em in.
echo_input_label.grid(row=0, column=0)
echo_checkbox.grid(row=0, column=1)
logging_label.grid(row=1, column=0)
logging_checkbox.grid(row=1, column=1)
logging_button.grid(row=1, column=2)
def create_light_widget(self, master, light):
v = IntVar()
light_checkbox = Checkbutton(
master,
text=light.get('name'),
variable=v,
command=lambda: self.select_light(light, v),
bg="black",
fg=self.green_color,
activebackground="black",
activeforeground=self.green_color,
)
print(light.get('color'))
light_state = Frame(
master,
width=32,
height=32,
bg=convert_xy_to_hex(light.get("color")),
bd=2,
highlightbackground="white",
highlightcolor="white",
highlightthickness=2,
)
light_checkbox.grid(row=light.get('id'), column=0, pady=2)
light_state.grid(row=light.get('id'), column=1, pady=2)
return light_checkbox, light_state
class Missed:
def __init__(self, master, count):
self.text = ''
self.points = 0
self.comment_txt = Entry(master=master)
self.comment_txt.grid(column=0, row=count)
self.comment_txt.insert(END, "")
self.point_txt = Entry(master=master)
self.point_txt.grid(column=1, row=count)
self.point_txt.insert(END, "0")
self.var = IntVar()
self.chk = Checkbutton(master, text=" ", variable=self.var)
self.chk.grid(column=2, row=count)
def get_points(self):
return self.point_txt.get()
def get_comment(self):
return self.comment_txt.get()
def get_chk(self):
return self.var.get()
def set_false(self):
self.var.set(False)
def createPage(self):
Label(self, text='特征分析').grid(row=0, column=0)
#设置窗口背景
style = ttk.Style()
style.configure("BW.TLabel", font=("微软雅黑", "12")) #默认字体
self.learn_pathdb = StringVar()
Entry(self, textvariable=self.learn_pathdb, width=50).grid(row=1,
column=0)
Button(self, text='导入学习文件',
command=self.selectLearningPath).grid(row=1, column=1)
Button(self, text='运行', width=10, command=self.run).grid(row=3,
column=1)
algo_frame = Frame(self)
algo_frame.grid(row=3)
self.weight_check = BooleanVar()
Checkbutton1 = Checkbutton(algo_frame,
text="特征权重",
variable=self.weight_check,
command=self.func)
Checkbutton1.grid(row=0, column=0, sticky='W')
self.per_check = BooleanVar()
Checkbutton2 = Checkbutton(algo_frame,
text="相关系数",
variable=self.per_check,
command=self.func)
Checkbutton2.grid(row=0, column=1, sticky='W')
def CreateCheckList(self, frame, labels, values=None, colors=None):
all_widgetes = [w for w in frame.winfo_children() if w.winfo_class() == 'Checkbutton']
for w in all_widgetes:
w.destroy()
all_widgetes = [w for w in frame.winfo_children() if w.winfo_class() == 'Label']
for w in all_widgetes[1:]:
w.destroy()
var = []
if values is not None:
add_text = ["%5.1f" % (values[i]) +'%' for i in range(len(values))]
for i in range(len(labels)):
var.append(BooleanVar())
fgc = "black"
if colors is not None:
mycolor = '#%02x%02x%02x' % (int(colors[i,0]), int(colors[i,1]), int(colors[i,2]))
if (colors[i,0]+colors[i,1]+colors[i,2])/3/255<=0.5:
fgc = "#FFFFFF"
else:
mycolor = frame.cget('bg')
cb = Checkbutton(frame, text=labels[i], state=DISABLED, variable=var[i], bg=mycolor, disabledforeground=fgc, anchor=W)
# cb.pack(anchor=W, fill=X, padx=2)
cb.grid(row=i+2,column=0,sticky=W+E)
if values is not None:
cb = Label(frame, text=add_text[i], bg=mycolor, fg=fgc, anchor=E)
cb.grid(row=i+2,column=1,sticky=W+E+N+S)
frame.grid_rowconfigure(i+2, weight=0)
return var
class PasswordDialog(Dialog):
def __init__(self, title, prompt, parent):
self.prompt = prompt
Dialog.__init__(self, parent, title)
def body(self, master):
from tkinter import Label
from tkinter import Entry
from tkinter import Checkbutton
from tkinter import IntVar
from tkinter import W
self.checkVar = IntVar()
Label(master, text=self.prompt).grid(row=0, sticky=W)
self.e1 = Entry(master)
self.e1.grid(row=0, column=1)
self.cb = Checkbutton(master, text="Save to keychain", variable=self.checkVar)
self.cb.pack()
self.cb.grid(row=1, columnspan=2, sticky=W)
self.e1.configure(show='*')
def apply(self):
self.result = (self.e1.get(), self.checkVar.get() == 1)
class ConfigWindow(Toplevel):
'''Represent the configuration window.'''
def __init__(self, parent=None):
'''Constructor of ConfigWindow.'''
Toplevel.__init__(self, parent)
self.title('Configuracion')
self._states = [
IntVar(value=CONFIG['GAME_TRACKING']),
IntVar(value=CONFIG['CONFIRM_EXIT'])
]
self._cbox_gtrack = Checkbutton(self, text='Seguimiento del juego')
self._cbox_gtrack.config(variable=self._states[0])
self._cbox_confexit = Checkbutton(self, text='Confirmacion al salir')
self._cbox_confexit.config(variable=self._states[1])
self._cbox_gtrack.grid(row=0, column=0, sticky=W)
self._cbox_confexit.grid(row=1, column=0, sticky=W)
self._button_cancel = Button(self,
text='Cancelar',
command=self.destroy)
self._button_cancel.grid(row=3, column=1, sticky=E)
self._button_accept = Button(self, text='Guardar y Salir')
self._button_accept.config(command=self.save_config)
self._button_accept.grid(row=3, column=0, sticky=E)
def save_config(self):
pass
def get_state_game_tracking(self):
return self._states[0].get()
def get_state_confirm_exit(self):
return self._states[1].get()
class ConfigWindow(Toplevel):
'''Represent the configuration window.'''
def __init__(self, parent=None):
'''Constructor of ConfigWindow.'''
Toplevel.__init__(self, parent)
self.title('Configuracion')
self._states = [IntVar(value=CONFIG['GAME_TRACKING']),
IntVar(value=CONFIG['CONFIRM_EXIT'])]
self._cbox_gtrack = Checkbutton(self, text='Seguimiento del juego')
self._cbox_gtrack.config(variable=self._states[0])
self._cbox_confexit = Checkbutton(self, text='Confirmacion al salir')
self._cbox_confexit.config(variable=self._states[1])
self._cbox_gtrack.grid(row=0, column=0, sticky=W)
self._cbox_confexit.grid(row=1, column=0, sticky=W)
self._button_cancel = Button(self, text='Cancelar', command=self.destroy)
self._button_cancel.grid(row=3, column=1, sticky=E)
self._button_accept = Button(self, text='Guardar y Salir')
self._button_accept.config(command=self.save_config)
self._button_accept.grid(row=3, column=0, sticky=E)
def save_config(self):
pass
def get_state_game_tracking(self):
return self._states[0].get()
def get_state_confirm_exit(self):
return self._states[1].get()
def test3():
root = Tk()
root.title('Test 3 - Login')
labelUsername = Label(root, text='Username:'******'Password:'******'Remember me')
if mode == 0:
buttonLogin = Button(root, text='Login', fg='red', command=login)
elif mode == 1:
buttonLogin = Button(root, text='Login', fg='red')
buttonLogin.bind('<Button-1>', login) # <Button-1>: Left click
labelUsername.grid(row=0, column=0, sticky=E)
labelPassword.grid(row=1, column=0, sticky=E)
entryUsername.grid(row=0, column=1)
entryPassword.grid(row=1, column=1)
rememberCheck.grid(row=2, column=0, columnspan=2)
buttonLogin.grid(row=3, column=0, columnspan=2)
root.mainloop()
class DamageFrame(ttk.LabelFrame):
"""
Frame comprising damage entry field.
"""
def __init__(self, character_panel):
"""
Initialises frame.
"""
ttk.LabelFrame.__init__(self, character_panel, text=DAMAGE_TEXT)
self.damage = CharacterValueField(self, validate_integer)
self.critical_state = IntVar()
self.critical_state.set(0)
self.tulutes = Checkbutton(self,
text=TULUTES_TEXT,
variable=self.critical_state)
self.zero_zero_state = IntVar()
self.zero_zero_state.set(0)
self.zero_zero = Checkbutton(self,
text='00',
variable=self.zero_zero_state)
self.damage.grid(row=0, column=0)
self.tulutes.grid(row=0, column=1)
self.zero_zero.grid(row=0, column=2)
def reset_frame(self):
"""
Resets all child widgets of the frame.
"""
self.damage.reset_fld()
self.critical_state.set(0)
self.zero_zero_state.set(0)
def get_damage(self):
"""
Tries to return value of entry field. Returns
an error message if the value of the field
is invalid.
"""
try:
damage = self.damage.get_validated()
return True, damage
except FieldValidationError as error:
return False, error.message
def is_critical(self):
"""
Checks whether the critical tick-box is checked.
"""
return self.critical_state.get()
def is_zero_zero(self):
"""
Checks whether the 00 tickbox is checked.
"""
return self.zero_zero_state.get()
def __init__(self, master, mech):
self.mech = mech
frame = Frame(master)
frame.grid()
rct_label = Label(frame, text='Select Reactants')
rct_label.grid(column=1, row=1)
and_or = Label(frame, text='AND/OR')
and_or.grid(column=3, row=1)
prod_label = Label(frame, text='Select Products')
prod_label.grid(column=4, row=1)
what_to_do = Label(frame, text='Execute')
what_to_do.grid(column=6, row=1)
reactants_scrollbar = Scrollbar(frame, orient=VERTICAL)
self.reactants = Listbox(frame,
selectmode=EXTENDED,
exportselection=0,
yscrollcommand=reactants_scrollbar.set)
self.reactants.grid(column=1, row=2)
reactants_scrollbar.config(command=self.reactants.yview)
reactants_scrollbar.grid(column=2, row=2, sticky=N + S)
self.logical_and = IntVar()
self.logical_and.set(1)
c = Checkbutton(frame, text="AND", variable=self.logical_and)
c.grid(column=3, row=2)
products_scrollbar = Scrollbar(frame, orient=VERTICAL)
self.products = Listbox(frame, selectmode=EXTENDED, exportselection=0)
self.products.grid(column=4, row=2)
products_scrollbar.config(command=self.products.yview)
products_scrollbar.grid(column=5, row=2, sticky=N + S)
self.method_list = Listbox(frame,
selectmode=EXTENDED,
exportselection=0)
self.method_list.grid(column=6, row=2)
#self.methods = [k for k in dir(self.mech) if k[:1] != '_' and isinstance(getattr(self.mech, k), MethodType)]
self.methods = [
'plot_rxns', 'find_rxns', 'print_rxns', 'print_irrs',
'print_net_rxn', 'plot_proc'
]
method_labels = [
'Plot Reactions', 'Show Rxn Ids', 'Print Rxns', 'Print IRRs',
'Print Net Rxn', 'Process Plot'
]
for method in method_labels:
self.method_list.insert(END, method)
species_keys = list(self.mech.species_dict.keys())
species_keys.sort()
self.species_objects = [
self.mech.species_dict[spc] for spc in species_keys
]
for spc in species_keys:
self.reactants.insert(END, spc)
self.products.insert(END, spc)
self.execute_button = Button(frame, text="go", command=self.execute)
self.execute_button.grid(column=6, row=4)
class MainWindow(Window):
var: list[IntVar]
menu: MainMenuBar
words_sets: WordsSets
set_checkbutton: Checkbutton
game_window: GameWindow
soft_update_win: UpdateWindow
def __init__(self, parent=None):
super().__init__(parent)
self.root.protocol('WM_DELETE_WINDOW', self.save_and_askokcancel)
select_label = Label(self, text='Select a set of word', anchor=NE)
select_label.grid(column=0, columnspan=2)
self.var = list()
with codecs.open('sets/sets.json', 'r', encoding='utf-8') as sets:
self.words_sets = WordsSets(load(sets))
for words_set in self.words_sets:
self.var.append(IntVar())
self.set_checkbutton = Checkbutton(self,
text=words_set.get_name(),
variable=self.var[-1],
command=self.cb)
self.set_checkbutton.grid(column=0, sticky=W)
self.start_button = Button(self, text='Start', command=self.start)
self.start_button.grid(column=0)
self.menu = MainMenuBar(self)
self.cb()
self.root.config(menu=self.menu)
self.software_update()
def cb(self):
if len([value for value in self.var if value.get() > 0]):
self.menu.file_menu.entryconfig('Start', state='normal')
self.start_button.config(state='normal')
else:
self.menu.file_menu.entryconfig('Start', state='disabled')
self.start_button.config(state='disabled')
def start(self):
window = Tk()
self.game_window = GameWindow.GameWindow(self, root=window)
def save(self):
self.words_sets.save()
def save_and_askokcancel(self):
self.save()
Window.askokcancel(self)
def software_update(self):
url = 'https://api.github.com/repos/Vikka/Meteor/releases'
try:
response = requests.get(url, timeout=2)
except requests.exceptions:
return # Do nothing, no update if no response
if response.status_code == 200 \
and response.json()[0].get('tag_name') != VERSION:
self.soft_update_win = UpdateWindow(response, Tk())
def __init__(self, parentwin, kvgrouppairs, flyoverfn, baserow=6):
# CSV Generation options check button
self.master = parentwin
self.kvgrouppairs = kvgrouppairs
self.flyoverfn = flyoverfn
# the checkbox gui items to enable / disable various optional activities
self.delbutton = Checkbutton(parentwin,
text="Delete\nselected",
variable=self.kvgrouppairs['DeleteCheck'],
onvalue=True,
offvalue=False).grid(row=baserow + 15,
column=4,
columnspan=1,
sticky=W)
self.copycheckbutton = Checkbutton(
parentwin,
text="Copy\nselected",
variable=self.kvgrouppairs['CopyCheck'],
onvalue=True,
offvalue=False).grid(row=baserow + 15,
column=3,
columnspan=1,
sticky=W)
self.printcheckbutton = Checkbutton(
parentwin,
text="Print CSV recs",
variable=self.kvgrouppairs['PrintCheck'],
onvalue=True,
offvalue=False).grid(row=baserow + 15,
column=2,
columnspan=1,
sticky=W)
self.dupcheckbutton = Checkbutton(
parentwin,
text="Dup checking",
variable=self.kvgrouppairs['DupCheck'],
onvalue=True,
offvalue=False).grid(row=baserow + 15,
column=1,
columnspan=1,
sticky=W)
# note that we don't need to keep the handle to the check buttons so they are not instance self.xx variables
timercheckbutton = Checkbutton(
parentwin,
text="Timer enable",
variable=self.kvgrouppairs['TimerCheck'],
onvalue=True,
offvalue=False)
timercheckbutton.grid(row=baserow + 15,
column=0,
columnspan=1,
sticky=W)
timercheckbutton.bind(
"<Enter>", lambda event: self.flyoverfn(
"You can turn the timer off so that timer won't monitor insertion/removal automatically\n\n\n"
))
timercheckbutton.bind("<Leave>", self.flyoverfn(None))
class LoginFrame(Frame): # pylint: disable=too-many-ancestors
"""build frame for gui"""
def __init__(self, master, main=None):
super().__init__(master)
self.main = main
self._label_username = Label(self, text="Username")
self._label_password = Label(self, text="Password")
self._entry_username = Entry(self)
self._entry_password = Entry(self, show="*")
self._label_username.grid(row=0, sticky=E)
self._label_password.grid(row=1, sticky=E)
self._entry_username.grid(row=0, column=1)
self._entry_password.grid(row=1, column=1)
self._var = IntVar()
self._var.set(1)
self._checkbox = Checkbutton(self,
text="Save login data (64-bit)",
variable=self._var)
self._checkbox.grid(columnspan=2)
self._loader = Loader()
self._login_button = Button(self,
text="login",
command=self.__login_click,
height=HEIGHT,
width=WIDTH)
self._load_button = Button(self,
text="Load from " + self._loader.last_date,
command=self._close,
height=HEIGHT,
width=WIDTH)
self._login_button.config(state=NORMAL)
self._load_button.config(state=DISABLED)
if self._loader.is_exist: # pragma: no cover
self._load_button.config(state=NORMAL)
self._login_button.grid(row=3, column=0)
self._load_button.grid(row=3, column=1)
self.pack()
def __login_click(self):
User().user64 = '{}:{}'.format(self._entry_username.get(),
self._entry_password.get())
if self._var.get(): # pragma: no cover
self._loader.write(User().user64)
self._close()
def _close(self):
self.master.destroy()
if self.main is not None:
self.main.close()
class AuthDialog(Popup):
message = _('Enter username and password\nfor "%(method)s" at "%(realm)s"')
def __init__(self, parent, deferred, method, realm, addnl=None):
self.deferred = deferred
self.method = method
self.realm = realm
self._saveOK = False
Popup.__init__(self, parent, addnl)
def _saveBoolean(self, *value):
self._saveOK = not self._saveOK
def getResult(self):
return (self.uentry.get(), self.pentry.get(), self._saveOK)
def body(self):
print("auth body")
from tkinter import NW, E, W, Frame, Label, Button, Entry, Checkbutton
defargs = {'padx': 5, 'pady': 5, 'sticky': W}
self.top = Frame(self)
self.top.grid(row=1, column=1, sticky=NW)
msg = self.message % {'realm': self.realm, 'method': self.method}
self.label = Label(self.top, text=msg, justify='center')
self.label.grid(row=1, column=1, columnspan=4, **defargs)
self.ulabel = Label(self.top,
text=_('User Name') + ':',
justify='left')
self.ulabel.grid(row=2, column=1, columnspan=2, **defargs)
self.uentry = Entry(self.top)
self.uentry.grid(row=2, column=3, columnspan=2, **defargs)
self.uentry.focus_set()
self.plabel = Label(self.top, text=_('Password') + ':', justify='left')
self.plabel.grid(row=3, column=1, columnspan=2, **defargs)
self.pentry = Entry(self.top, show="*")
self.pentry.grid(row=3, column=3, columnspan=2, **defargs)
self._saveOk = False
self.saveCheck = Checkbutton(self.top, command=self._saveBoolean)
self.saveCheck.grid(row=4, column=1, columnspan=1, **defargs)
self.savelabel = Label(self.top,
text=_('Save this username and password'))
self.savelabel.grid(row=4, column=2, columnspan=3, **defargs)
defargs['sticky'] = W
self.cancelb = Button(self.top, text=_('Cancel'), command=self.cancel)
self.cancelb.grid(row=5, column=3, columnspan=1, **defargs)
self.okb = Button(self.top, text=_('OK'), command=self.selected)
self.okb.grid(row=5, column=4, columnspan=1, **defargs)
def __init__(self, parent, controller):
self.file = ''
self.SeatNum = StringVar()
Frame.__init__(self, parent)
Frame.config(self, bg=bg)
label = Label(self,
text='Student',
font=SUPER_LARGE_FONT,
bg=bg,
fg='white')
label.grid(row=0, column=3, pady=10, padx=120)
label2 = Label(self, text='', bg=bg)
label2.grid(row=1, column=1, pady=25)
back = ttk.Button(
self,
text='<Back',
command=lambda: controller.show_frame(StudentORTeacher))
back.grid(row=0, column=0, padx=0, pady=10)
SeatNumEntry = ttk.Entry(self, textvariable=self.SeatNum)
SeatNumEntry.grid(row=5, column=0, padx=10, pady=10)
addFileBtn = ttk.Button(
self,
text='Add File',
command=lambda: TryExcept(partial(self.getFile)))
addFileBtn.grid(row=6, column=0)
self.fileStatus = Label(self, text='Add a File', bg=bg, fg='white')
self.fileStatus.grid(row=5, column=3, padx=100)
ExportPDF = ttk.Button(self,
text='Export Selected',
command=self.Export,
width=25)
ExportPDF.grid(row=8, column=5, pady=5)
SubVSMks = ttk.Button(self, text='Subject VS Marks', width=25)
SubVSMks.grid(row=3, column=5, pady=10)
AllSem = ttk.Button(
self,
text='Your Performance VS Class',
command=lambda: TryExcept(partial(self.all_sem_performance)),
width=25)
AllSem.grid(row=4, column=5, pady=10)
IndStud = ttk.Button(self,
text='Individual Student',
command=lambda: TryExcept(partial(self.IndStud)),
width=25)
IndStud.grid(row=5, column=5)
StudentDetail = ttk.Button(
self,
text='Student Detail',
command=lambda: TryExcept(partial(self.StudentDetail)),
width=25)
StudentDetail.grid(row=6, column=5, pady=10)
self.cb = [IntVar(), IntVar()]
AllSemRB = Checkbutton(self, text='', variable=self.cb[0], bg=bg)
AllSemRB.grid(row=4, column=6, padx=5)
IndStudRB = Checkbutton(self, text='', variable=self.cb[1], bg=bg)
IndStudRB.grid(row=5, column=6, pady=5, padx=5)
self.SeatData = array([])
def injectGUIElements(self):
# Add an extra checkbox to the top frame
Label(self.STATE.topFrame, text="Angular Mode:", anchor="e").grid(
row=1, column=3, sticky="ew"
)
timestampEnabled = Checkbutton(
self.STATE.topFrame, variable=self.STATE.angular_mode
)
timestampEnabled.grid(row=1, column=4)
def __init__(self, parent, controller):
Frame.__init__(self, parent)
rows = 0
while rows < 21:
# self.grid_rowconfigure(rows,weight=6)
self.grid_columnconfigure(rows, weight=1)
rows += 1
label = Label(self,
text="SIGN IN",
font=("Calisto MT", 28, "bold", "underline"),
bg="gray94",
fg="black")
label.grid(row=0, column=10, columnspan=2, rowspan=3)
Label(self, text="\n\n\n\n").grid(row=3)
label1 = Label(self, text="E-mail", font=("Calisto MT", 18))
label1.grid(row=6, column=10)
label2 = Label(self, text="Password", font=("Calisto MT", 18))
label2.grid(row=7, column=10)
e1 = Entry(self, font=("Calisto MT", 16))
e2 = Entry(self, font=("Calisto MT", 16), show="*")
e1.grid(row=6, column=11)
e2.grid(row=7, column=11)
ldict_ent = {"E-mail": e1, "Password": e2}
var1 = IntVar()
cb1 = Checkbutton(self,
text="Show Password",
variable=var1,
command=lambda: cb_change(var1, e2))
cb1.grid(row=7, column=12)
Label(self, text="\n\n").grid(row=8)
button1 = tk.Button(
self,
text="Login",
font=("Calisto MT", 12),
command=lambda: self.log_status(controller, ldict_ent),
activebackground="light cyan",
relief=tk.RAISED,
width=15)
button1.grid(row=10, column=11)
button2 = tk.Button(
self,
text="New User? Register",
font=("Calisto MT", 12),
command=lambda: controller.show_frame(RegisterPage),
activebackground="light cyan",
relief=tk.RAISED,
width=15)
button2.grid(row=10, column=10)
class RaffleGramGUI:
def __init__(self, master):
self.master = master
master.title("RaffleGram")
self.users = []
self.username_label = Label(master, text="Username:"******"Password:"******"Post URL:")
self.mediaid_entry = Entry(master)
self.result_label = Label(master)
self.removeDuplicates_checkVar = IntVar()
self.removeDuplicates_check = Checkbutton(
master,
text="Remove duplicates",
variable=self.removeDuplicates_checkVar)
self.go_button = Button(master, text="Submit", command=self.pick_user)
self.refresh_button = Button(master,
text="Refresh",
command=self.refresh)
self.username_label.grid(row=0, columnspan=2)
self.username_entry.grid(row=1, columnspan=2)
self.password_label.grid(row=2, columnspan=2)
self.password_entry.grid(row=3, columnspan=2)
self.mediaid_label.grid(row=4, columnspan=2)
self.mediaid_entry.grid(row=5, columnspan=2)
self.result_label.grid(row=6, columnspan=2)
self.removeDuplicates_check.grid(row=7)
self.go_button.grid(row=8, column=0)
self.refresh_button.grid(row=8, column=1)
def pick_user(self):
api = connect(self.username_entry.get(), self.password_entry.get())
comments = get_comments(api, get_media_id(self.mediaid_entry.get()))
comments_json = convert_to_json(comments)
self.users = get_usernames(comments_json)
# Remove duplicate entries if checkbox checked.
if self.removeDuplicates_checkVar.get():
self.remove_duplicates()
# Get new random name from existing list.
self.refresh()
for u in self.users:
print(u)
def refresh(self):
self.result_label['text'] = random.choice(self.users)
def remove_duplicates(self):
self.users = list(dict.fromkeys(self.users))
def __init__(self, rootf, graph, control_panel):
# keep a reference of the graph area and control paknel
self.graph = graph
self.graph.canvas.bind("<Button-1>", lambda e: self.clicked(e))
self.control_panel = control_panel
# create the frame for the buttons
self.frame = LabelFrame(rootf, text="Zoom options")
# create the input boxes
self.inputs = InputEntry.DataBoxes(self.frame)
# create the entries for the zoomed width and height
self.inputs.place_entry("width", 0.0, "float", 0, 0)
self.inputs.bind("width", "<Return>",
lambda e: self.update_rectangle(e, "width"))
self.inputs.place_entry("height", 0.0, "float", 0, 1)
self.inputs.bind("height", "<Return>",
lambda e: self.update_rectangle(e, "height"))
# have variables that describe the coordinates between the mandelbrot
# coordinates and the graph coordinates
self.mandel_coords_x = None
self.mandel_coords_y = None
self.graph_coords_x = None
self.graph_coords_y = None
# store the ratio, useful for maintain proportions
self.ratio = None
self.maintain_proportion = IntVar(value=1)
check_prop = Checkbutton(self.frame,
text="maintain proportions",
variable=self.maintain_proportion)
check_prop.grid(row=1, columnspan=2)
# place the center
self.inputs.place_entry("center_x", 0.0, "float", 2, 0)
self.inputs.place_entry("center_y", 0.0, "float", 2, 1)
self.center = (0, 0)
#update the data boxes
self.calc_proportions()
# zoom and render
bzoom_render = Button(self.frame,
text="zoom and render",
command=self.zoom_render)
bzoom_render.grid(row=3, column=0, columnspan=2)
def pack(self):
for k in range(len(self.names)):
self.isSelected.append(IntVar())
c = Checkbutton(self,
text=self.names[k],
variable=self.isSelected[k])
c.grid(row=k)
Button(self, text="OK!", command=self.Done).grid(row=len(self.names))
super().pack()
def __list_todos(self):
todos = self.__db.list_todos()
for i, t in zip(range(len(todos)), todos):
task_box = Checkbutton(self.__todo_frame,
text='',
command=self.__create_todo_check(t[0]))
task_box.grid(row=i, column=0)
task_label = Label(self.__todo_frame, text=t[1])
task_label.grid(row=i, column=1)
def openfile():
name = askopenfilename()
nam = name.split("/")
g=nam[-1].split(".")
grup= g[0]
print(nam,g)
print(grup)
fitxer = open(name, mode='r')
for linia in fitxer:
coordinates = linia.split('\t')
N,X,Y,Z,C = coordinates
N = coordinates[0]
X = coordinates[1]
Y = coordinates[2]
Z = coordinates[3]
C = [coordinates[4]]
if len(coordinates)>5:
i=5
for c in range(len(coordinates)-5):
C.append(coordinates[i])
codis.add(c)
i = i+1
codis.add(C[0])
i= 0
r = 2
c = 1
if askyesno('codis...','Vols unir per codis?'):
codis_linia.clear()
tria = tk.Toplevel()
ok = tk.Button(tria, text='ok', width=25, command=tria.destroy)
ok.grid(column=0, row=0,columnspan=5)
for item in codis:
codis_linia[str(item)]= IntVar()
chb =Checkbutton(tria,text = str(item), variable = codis_linia[item], onvalue = True, offvalue = False, height=5 )
if c > 5:
c = 1
r = r+1
chb.grid(column =c, row=r)
c = c+1
label2.config(text= 'Quins codis son linies')
def __init__(self):
Tk.__init__(self)
self.minsize(200, 250)
self.result = None
self._model_name = ''
self._icon_name = ''
self.title("Viewer generator")
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
self.grid_rowconfigure(0, weight=0)
self.grid_rowconfigure(1, weight=1)
self.resizable(True, True)
Label(self, text='Model').grid(row=0, column=0, sticky=(N, E))
self.models = ttk.Combobox(
self, textvariable=StringVar(), state='readonly')
self.models.grid(row=0, column=1, sticky=(N, W, E, S), padx=3, pady=3)
mainframe = Frame(self, bd=1, relief=SUNKEN)
mainframe.grid(
row=1, column=0, columnspan=2, sticky=(N, S, E, W), padx=3, pady=3)
current_row = 0
current_col = 0
self.check = []
for value in ('add', 'list', 'edit', 'search', 'modify', 'listing', 'show', 'label', 'delete', 'print'):
chkbtn_val = IntVar()
chkbtn = Checkbutton(mainframe, text=value, variable=chkbtn_val)
chkbtn.grid(
row=current_row, column=current_col, sticky=W, padx=3, pady=3)
self.check.append((value, chkbtn_val))
current_col += 1
if current_col == 2:
current_col = 0
current_row += 1
Label(mainframe, text='Icon').grid(
row=(current_row + 1), column=0, columnspan=2, sticky=(N, W, E, S), padx=3)
self.icons = ttk.Combobox(
mainframe, textvariable=StringVar(), state='readonly')
self.icons.grid(
row=(current_row + 2), column=0, columnspan=2, sticky=(N, W, E, S), padx=3)
btnframe = Frame(self, bd=1)
btnframe.grid(row=2, column=0, columnspan=2)
Button(btnframe, text="OK", width=10, command=self.cmd_ok).grid(
row=1, column=0, sticky=(N, S, E, W), padx=5, pady=3)
Button(btnframe, text="Cancel", width=10, command=self.cmd_cancel).grid(
row=1, column=1, sticky=(N, S, E, W), padx=5, pady=3)
def __init__(self,master=None):
Frame.__init__(self,master)
#Sides of Dice
labelSides=Label(self,text="Sides")
labelSides.grid(row=0,column=0)
self.sides=StringVar()
self.sides.set(20)
spinboxSides=Spinbox(self,from_=1,to=20,increment=1,width=4)
spinboxSides.config(textvariable=self.sides, font="sans 24", justify="center")
spinboxSides.grid(row=0,column=1)
#Number of Dices
labelNumber=Label(self,text="Number")
labelNumber.grid(row=1,column=0)
self.number=StringVar()
self.number.set(1)
spinboxNumber=Spinbox(self,from_=1,to=30,increment=1,width=4)
spinboxNumber.config(textvariable=self.number, font="sans 24", justify="center")
spinboxNumber.grid(row=1,column=1)
#Modifier
labelModifier=Label(self,text="Modifier")
labelModifier.grid(row=2,column=0)
self.modifier=StringVar()
self.modifier.set(0)
spinboxModifier=Spinbox(self,from_=-5,to=5,increment=1,width=4)
spinboxModifier.config(textvariable=self.modifier, font="sans 24", justify="center")
spinboxModifier.grid(row=2,column=1)
#Hide Checkbox
labelHide=Label(self, text="Hide")
labelHide.grid(row=2, column=2)
self.hide=IntVar()
self.hide.set(0)
checkbuttonHide=Checkbutton(self,variable=self.hide)
checkbuttonHide.grid(row=2,column=3)
#Result display
self.result=StringVar()
self.result.set("")
labelResult1=Label(self,text="Result")
labelResult1.grid(row=1, column=4)
labelResult2=Label(self,text=self.result.get(),relief=SUNKEN,width=4)
labelResult2.grid(row=1,column=5)
#Button to roll
buttonRoll=Button(self,text="Roll!", command=self.roll)
buttonRoll.grid(row=2,column=5)
def __init__(self, master):
column0_padx = 24
row_pady = 36
#Label 1
lbl_testcase_exec = Label(master, text="Test case execution",
wraplength=100, anchor='w', justify='left')
lbl_results_cmp = Label(master, text="Results comparison",
wraplength=100, justify='left')
lbl_tolerance = Label(master, text="Tolerance (5%)", wraplength=100)
testcase_exec = Checkbutton(master)
results_cmp = Checkbutton(master)
tolerance = Entry(master, width=4)
lbl_analysis = Label(master, text="Analysis Library")
analysis_lib = Entry(master, width=30)
lbl_testcase_exec.grid(row=0, column=2, padx=20, pady=12, sticky='w')
lbl_results_cmp.grid(row=0, column=3, pady=12, sticky='w')
lbl_tolerance.grid(row=0, column=4, padx=20, pady=12, sticky='wn')
lbl_analysis.grid(row=1, column=0, sticky='w', padx=column0_padx)
analysis_lib.grid(row=1, column=1, sticky='w')
testcase_exec.grid(row=1, column=2, padx=20, sticky='w')
results_cmp.grid(row=1, column=3, sticky='w')
tolerance.grid(row=1, column=4, padx=20, sticky='w')
#Label 2
lbl_ref_analysis = Label(
master, text="Reference Analysis Libary Version",
wraplength=150, justify='left', pady=row_pady)
ref_analysis_lib = Entry(master, width=30)
lbl_ref_analysis.grid(row=2, column=0, sticky='w', padx=column0_padx)
ref_analysis_lib.grid(row=2, column=1, sticky='w')
# version
lbl_version = Label(master, text="Version under Test")
version = Label(master, text="vA.B.C.D")
lbl_version.grid(row=3, column=0, sticky='w', padx=column0_padx)
version.grid(row=3, column=1, sticky='w')
# test all
lbl_testall = Label(master, text="Test All")
testall = Checkbutton(master)
lbl_testall.grid(row=4, column=0, pady=row_pady, padx=column0_padx,
sticky='w')
testall.grid(row=4, column=1, sticky='w')
# buttons
bottom_frame = Frame(master)
bottom_frame.grid(row=5, column=1, columnspan=3, sticky='w')
btn_start = Button(bottom_frame, text = "Go", width=7)
btn_start.pack(side='left')
btn_commit = Button(bottom_frame, text="Commit", width=7)
btn_commit.pack(side='left', padx=80)
btn_exit = Button(bottom_frame, text="Exit", width=7)
btn_exit.pack(side='left')
class MLNQueryGUI(object):
def __init__(self, master, gconf, directory=None):
self.master = master
self.initialized = False
self.master.bind('<Return>', self.infer)
self.master.bind('<Escape>', lambda a: self.master.quit())
self.master.protocol('WM_DELETE_WINDOW', self.quit)
self.dir = os.path.abspath(ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
self.frame = Frame(master)
self.frame.pack(fill=BOTH, expand=1)
self.frame.columnconfigure(1, weight=1)
row = 0
# pracmln project options
Label(self.frame, text='PRACMLN Project: ').grid(row=row, column=0,
sticky='ES')
project_container = Frame(self.frame)
project_container.grid(row=row, column=1, sticky="NEWS")
# new proj file
self.btn_newproj = Button(project_container, text='New Project...', command=self.new_project)
self.btn_newproj.grid(row=0, column=1, sticky="WS")
# open proj file
self.btn_openproj = Button(project_container, text='Open Project...', command=self.ask_load_project)
self.btn_openproj.grid(row=0, column=2, sticky="WS")
# save proj file
self.btn_updateproj = Button(project_container, text='Save Project...', command=self.noask_save_project)
self.btn_updateproj.grid(row=0, column=3, sticky="WS")
# save proj file as...
self.btn_saveproj = Button(project_container, text='Save Project as...', command=self.ask_save_project)
self.btn_saveproj.grid(row=0, column=4, sticky="WS")
# grammar selection
row += 1
Label(self.frame, text='Grammar: ').grid(row=row, column=0, sticky='E')
grammars = ['StandardGrammar', 'PRACGrammar']
self.selected_grammar = StringVar()
self.selected_grammar.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_grammar) + tuple(grammars))
l.grid(row=row, column=1, sticky='NWE')
# logic selection
row += 1
Label(self.frame, text='Logic: ').grid(row=row, column=0, sticky='E')
logics = ['FirstOrderLogic', 'FuzzyLogic']
self.selected_logic = StringVar()
self.selected_logic.trace('w', self.settings_setdirty)
l = OptionMenu(*(self.frame, self.selected_logic) + tuple(logics))
l.grid(row=row, column=1, sticky='NWE')
# mln section
row += 1
Label(self.frame, text="MLN: ").grid(row=row, column=0, sticky='NE')
self.mln_container = FileEditBar(self.frame, directory=self.dir,
filesettings={'extension': '.mln', 'ftypes': [('MLN files', '.mln')]},
defaultname='*unknown{}',
importhook=self.import_mln,
deletehook=self.delete_mln,
projecthook=self.save_proj,
filecontenthook=self.mlnfilecontent,
fileslisthook=self.mlnfiles,
updatehook=self.update_mln,
onchangehook=self.project_setdirty)
self.mln_container.editor.bind("<FocusIn>", self._got_focus)
self.mln_container.grid(row=row, column=1, sticky="NEWS")
self.mln_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
row += 1
self.use_emln = IntVar()
self.use_emln.set(0)
self.cb_use_emln = Checkbutton(self.frame, text="use model extension",
variable=self.use_emln,
command=self.onchange_use_emln)
self.cb_use_emln.grid(row=row, column=1, sticky="W")
# mln extension section
row += 1
self.emlncontainerrow = row
self.emln_label = Label(self.frame, text="EMLN: ")
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky='NE')
self.emln_container = FileEditBar(self.frame,
directory=self.dir,
filesettings={'extension': '.emln', 'ftypes': [('MLN extension files','.emln')]},
defaultname='*unknown{}',
importhook=self.import_emln,
deletehook=self.delete_emln,
projecthook=self.save_proj,
filecontenthook=self.emlnfilecontent,
fileslisthook=self.emlnfiles,
updatehook=self.update_emln,
onchangehook=self.project_setdirty)
self.emln_container.grid(row=self.emlncontainerrow, column=1, sticky="NEWS")
self.emln_container.editor.bind("<FocusIn>", self._got_focus)
self.emln_container.columnconfigure(1, weight=2)
self.onchange_use_emln(dirty=False)
self.frame.rowconfigure(row, weight=1)
# db section
row += 1
Label(self.frame, text="Evidence: ").grid(row=row, column=0, sticky='NE')
self.db_container = FileEditBar(self.frame, directory=self.dir,
filesettings={'extension': '.db', 'ftypes': [('Database files', '.db')]},
defaultname='*unknown{}',
importhook=self.import_db,
deletehook=self.delete_db,
projecthook=self.save_proj,
filecontenthook=self.dbfilecontent,
fileslisthook=self.dbfiles,
updatehook=self.update_db,
onchangehook=self.project_setdirty)
self.db_container.grid(row=row, column=1, sticky="NEWS")
self.db_container.editor.bind("<FocusIn>", self._got_focus)
self.db_container.columnconfigure(1, weight=2)
self.frame.rowconfigure(row, weight=1)
# inference method selection
row += 1
self.list_methods_row = row
Label(self.frame, text="Method: ").grid(row=row, column=0, sticky=E)
self.selected_method = StringVar()
self.selected_method.trace('w', self.select_method)
methodnames = sorted(InferenceMethods.names())
self.list_methods = OptionMenu(*(self.frame, self.selected_method) + tuple(methodnames))
self.list_methods.grid(row=self.list_methods_row, column=1, sticky="NWE")
# options
row += 1
option_container = Frame(self.frame)
option_container.grid(row=row, column=1, sticky="NEWS")
# Multiprocessing
self.multicore = IntVar()
self.cb_multicore = Checkbutton(option_container, text="Use all CPUs",
variable=self.multicore,
command=self.settings_setdirty)
self.cb_multicore.grid(row=0, column=2, sticky=W)
# profiling
self.profile = IntVar()
self.cb_profile = Checkbutton(option_container, text='Use Profiler',
variable=self.profile,
command=self.settings_setdirty)
self.cb_profile.grid(row=0, column=3, sticky=W)
# verbose
self.verbose = IntVar()
self.cb_verbose = Checkbutton(option_container, text='verbose',
variable=self.verbose,
command=self.settings_setdirty)
self.cb_verbose.grid(row=0, column=4, sticky=W)
# options
self.ignore_unknown_preds = IntVar()
self.cb_ignore_unknown_preds = Checkbutton(option_container,
text='ignore unkown predicates',
variable=self.ignore_unknown_preds,
command=self.settings_setdirty)
self.cb_ignore_unknown_preds.grid(row=0, column=5, sticky="W")
# queries
row += 1
Label(self.frame, text="Queries: ").grid(row=row, column=0, sticky=E)
self.query = StringVar()
self.query.trace('w', self.settings_setdirty)
Entry(self.frame, textvariable=self.query).grid(row=row, column=1, sticky="NEW")
# additional parameters
row += 1
Label(self.frame, text="Add. params: ").grid(row=row, column=0, sticky="NE")
self.params = StringVar()
self.params.trace('w', self.settings_setdirty)
self.entry_params = Entry(self.frame, textvariable=self.params)
self.entry_params.grid(row=row, column=1, sticky="NEW")
# closed-world predicates
row += 1
Label(self.frame, text="CW preds: ").grid(row=row, column=0, sticky="E")
cw_container = Frame(self.frame)
cw_container.grid(row=row, column=1, sticky='NEWS')
cw_container.columnconfigure(0, weight=1)
self.cwPreds = StringVar()
self.cwPreds.trace('w', self.settings_setdirty)
self.entry_cw = Entry(cw_container, textvariable=self.cwPreds)
self.entry_cw.grid(row=0, column=0, sticky="NEWS")
self.closed_world = IntVar()
self.cb_closed_world = Checkbutton(cw_container, text="CW Assumption",
variable=self.closed_world,
command=self.onchange_cw)
self.cb_closed_world.grid(row=0, column=1, sticky='W')
# output filename
row += 1
output_cont = Frame(self.frame)
output_cont.grid(row=row, column=1, sticky='NEWS')
output_cont.columnconfigure(0, weight=1)
# - filename
Label(self.frame, text="Output: ").grid(row=row, column=0, sticky="NE")
self.output_filename = StringVar()
self.entry_output_filename = Entry(output_cont, textvariable=self.output_filename)
self.entry_output_filename.grid(row=0, column=0, sticky="NEW")
# - save option
self.save = IntVar()
self.cb_save = Checkbutton(output_cont, text="save", variable=self.save)
self.cb_save.grid(row=0, column=1, sticky=W)
# start button
row += 1
start_button = Button(self.frame, text=">> Start Inference <<", command=self.infer)
start_button.grid(row=row, column=1, sticky="NEW")
self.settings_dirty = IntVar()
self.project_dirty = IntVar()
self.gconf = gconf
self.project = None
self.project_dir = os.path.abspath(ifnone(directory, ifnone(gconf['prev_query_path'], os.getcwd())))
if gconf['prev_query_project': self.project_dir] is not None:
self.load_project(os.path.join(self.project_dir, gconf['prev_query_project':self.project_dir]))
else:
self.new_project()
self.config = self.project.queryconf
self.project.addlistener(self.project_setdirty)
self.mln_container.dirty = False
self.emln_container.dirty = False
self.db_container.dirty = False
self.project_setdirty(dirty=False)
self.master.geometry(gconf['window_loc_query'])
self.initialized = True
def _got_focus(self, *_):
if self.master.focus_get() == self.mln_container.editor:
if not self.project.mlns and not self.mln_container.file_buffer:
self.mln_container.new_file()
elif self.master.focus_get() == self.db_container.editor:
if not self.project.dbs and not self.db_container.file_buffer:
self.db_container.new_file()
elif self.master.focus_get() == self.emln_container.editor:
if not self.project.emlns and not self.emln_container.file_buffer:
self.emln_container.new_file()
def quit(self):
if self.settings_dirty.get() or self.project_dirty.get():
savechanges = messagebox.askyesnocancel("Save changes", "You have unsaved project changes. Do you want to save them before quitting?")
if savechanges is None:
return
elif savechanges:
self.noask_save_project()
self.master.destroy()
else:
# write gui settings and destroy
self.write_gconfig()
self.master.destroy()
####################### PROJECT FUNCTIONS #################################
def new_project(self):
self.project = MLNProject()
self.project.addlistener(self.project_setdirty)
self.project.name = DEFAULTNAME.format('.pracmln')
self.reset_gui()
self.set_config(self.project.queryconf)
self.mln_container.update_file_choices()
self.emln_container.update_file_choices()
self.db_container.update_file_choices()
self.project_setdirty(dirty=True)
def project_setdirty(self, dirty=False, *args):
self.project_dirty.set(dirty or self.mln_container.dirty or self.db_container.dirty or
self.emln_container.dirty)
self.changewindowtitle()
def settings_setdirty(self, *args):
self.settings_dirty.set(1)
self.changewindowtitle()
def changewindowtitle(self):
title = (WINDOWTITLEEDITED if (self.settings_dirty.get() or self.project_dirty.get()) else WINDOWTITLE).format(self.project_dir, self.project.name)
self.master.title(title)
def ask_load_project(self):
filename = askopenfilename(initialdir=self.dir, filetypes=[('PRACMLN project files', '.pracmln')], defaultextension=".pracmln")
if filename and os.path.exists(filename):
self.load_project(filename)
else:
logger.info('No file selected.')
return
def load_project(self, filename):
if filename and os.path.exists(filename):
projdir, _ = ntpath.split(filename)
self.dir = os.path.abspath(projdir)
self.project_dir = os.path.abspath(projdir)
self.project = MLNProject.open(filename)
self.project.addlistener(self.project_setdirty)
self.reset_gui()
self.set_config(self.project.queryconf.config)
self.mln_container.update_file_choices()
self.db_container.update_file_choices()
if len(self.project.mlns) > 0:
self.mln_container.selected_file.set(self.project.queryconf['mln'] or list(self.project.mlns.keys())[0])
self.mln_container.dirty = False
if len(self.project.emlns) > 0:
self.emln_container.selected_file.set(self.project.queryconf['emln'] or list(self.project.emlns.keys())[0])
self.emln_container.dirty = False
if len(self.project.dbs) > 0:
self.db_container.selected_file.set(self.project.queryconf['db'] or list(self.project.dbs.keys())[0])
self.db_container.dirty = False
self.write_gconfig(savegeometry=False)
self.settings_dirty.set(0)
self.project_setdirty(dirty=False)
self.changewindowtitle()
else:
logger.error('File {} does not exist. Creating new project...'.format(filename))
self.new_project()
def noask_save_project(self):
if self.project.name and not self.project.name == DEFAULTNAME.format('.pracmln'):
self.save_project(os.path.join(self.project_dir, self.project.name))
else:
self.ask_save_project()
def ask_save_project(self):
fullfilename = asksaveasfilename(initialdir=self.project_dir,
confirmoverwrite=True,
filetypes=[('PRACMLN project files','.pracmln')],
defaultextension=".pracmln")
self.save_project(fullfilename)
def save_project(self, fullfilename):
if fullfilename:
fpath, fname = ntpath.split(fullfilename)
fname = fname.split('.')[0]
self.project.name = fname
self.dir = os.path.abspath(fpath)
self.project_dir = os.path.abspath(fpath)
self.mln_container.save_all_files()
self.emln_container.save_all_files()
self.db_container.save_all_files()
self.update_config()
self.project.save(dirpath=self.project_dir)
self.write_gconfig()
self.load_project(fullfilename)
self.settings_dirty.set(0)
def save_proj(self):
self.project.save(dirpath=self.project_dir)
self.write_gconfig()
self.project_setdirty(dirty=False)
####################### MLN FUNCTIONS #####################################
def import_mln(self, name, content):
self.project.add_mln(name, content)
def delete_mln(self, fname):
if fname in self.project.mlns:
self.project.rm_mln(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.mlns:
self.project.rm_mln(fnamestr)
def update_mln(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.mln_container.selected_file.get()
if new is None:
new = self.mln_container.selected_file.get().strip('*')
if content is None:
content = self.mln_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.mlns[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.mlns[old] = content
else:
if new in self.project.mlns:
if askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.mlns[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.mlns[new] = content
return 1
def mlnfiles(self):
return list(self.project.mlns.keys())
def mlnfilecontent(self, filename):
return self.project.mlns.get(filename, '').strip()
# /MLN FUNCTIONS #####################################
####################### EMLN FUNCTIONS #####################################
def import_emln(self, name, content):
self.project.add_emln(name, content)
def delete_emln(self, fname):
if fname in self.project.emlns:
self.project.rm_emln(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.emlns:
self.project.rm_emln(fnamestr)
def update_emln(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.emln_container.selected_file.get()
if new is None:
new = self.emln_container.selected_file.get().strip('*')
if content is None:
content = self.emln_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.emlns[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.emlns[old] = content
else:
if new in self.project.emlns:
if askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.emlns[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.emlns[new] = content
return 1
def emlnfiles(self):
return list(self.project.emlns.keys())
def emlnfilecontent(self, filename):
return self.project.emlns.get(filename, '').strip()
# /EMLN FUNCTIONS #####################################
# DB FUNCTIONS #####################################
def import_db(self, name, content):
self.project.add_db(name, content)
def delete_db(self, fname):
if fname in self.project.dbs:
self.project.rm_db(fname)
fnamestr = fname.strip('*')
if fnamestr in self.project.dbs:
self.project.rm_db(fnamestr)
def update_db(self, old=None, new=None, content=None, askoverwrite=True):
if old is None:
old = self.db_container.selected_file.get()
if new is None:
new = self.db_container.selected_file.get().strip('*')
if content is None:
content = self.db_container.editor.get("1.0", END).strip()
if old == new and askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.dbs[old] = content
else:
logger.error('no name specified!')
return -1
elif old == new and not askoverwrite:
self.project.dbs[old] = content
else:
if new in self.project.dbs:
if askoverwrite:
savechanges = messagebox.askyesno("Save changes", "A file '{}' already exists. Overwrite?".format(new))
if savechanges:
self.project.dbs[new] = content
else:
logger.error('no name specified!')
return -1
else:
self.project.dbs[new] = content
return 1
def dbfiles(self):
return list(self.project.dbs.keys())
def dbfilecontent(self, filename):
return self.project.dbs.get(filename, '').strip()
# /DB FUNCTIONS #####################################
# GENERAL FUNCTIONS #################################
def select_method(self, *args):
self.set_outputfilename()
self.settings_setdirty()
def onchange_use_emln(self, dirty=True, *args):
if not self.use_emln.get():
self.emln_label.grid_forget()
self.emln_container.grid_forget()
else:
self.emln_label.grid(row=self.emlncontainerrow, column=0, sticky="NE")
self.emln_container.grid(row=self.emlncontainerrow, column=1, sticky="NWES")
if dirty:
self.settings_setdirty()
def onchange_cw(self, *args):
if self.closed_world.get():
self.entry_cw.configure(state=DISABLED)
else:
self.entry_cw.configure(state=NORMAL)
self.settings_setdirty()
def reset_gui(self):
self.set_config({})
self.db_container.clear()
self.emln_container.clear()
self.mln_container.clear()
def set_config(self, newconf):
self.config = newconf
self.selected_grammar.set(ifnone(newconf.get('grammar'), 'PRACGrammar'))
self.selected_logic.set(ifnone(newconf.get('logic'), 'FirstOrderLogic'))
self.mln_container.selected_file.set(ifnone(newconf.get('mln'), ''))
if self.use_emln.get():
self.emln_container.selected_file.set(ifnone(newconf.get('mln'), ''))
self.db_container.selected_file.set(ifnone(newconf.get('db'), ""))
self.selected_method.set(ifnone(newconf.get("method"), InferenceMethods.name('MCSAT'), transform=InferenceMethods.name))
self.multicore.set(ifnone(newconf.get('multicore'), 0))
self.profile.set(ifnone(newconf.get('profile'), 0))
self.params.set(ifnone(newconf.get('params'), ''))
self.use_emln.set(ifnone(newconf.get('use_emln'), 0))
self.verbose.set(ifnone(newconf.get('verbose'), 1))
self.ignore_unknown_preds.set(ifnone(newconf.get('ignore_unknown_preds'), 0))
self.output_filename.set(ifnone(newconf.get('output_filename'), ''))
self.cwPreds.set(ifnone(newconf.get('cw_preds'), ''))
self.closed_world.set(ifnone(newconf.get('cw'), 0))
self.save.set(ifnone(newconf.get('save'), 0))
self.query.set(ifnone(newconf.get('queries'), ''))
self.onchange_cw()
def set_outputfilename(self):
if not hasattr(self, "output_filename") or not hasattr(self, "db_filename") or not hasattr(self, "mln_filename"):
return
mln = self.mln_container.selected_file.get()
db = self.db_container.selected_file.get()
if "" in (mln, db):
return
if self.selected_method.get():
method = InferenceMethods.clazz(self.selected_method.get())
methodid = InferenceMethods.id(method)
filename = config.query_output_filename(mln, methodid, db)
self.output_filename.set(filename)
def update_config(self):
self.config = PRACMLNConfig()
self.config["use_emln"] = self.use_emln.get()
self.config['mln'] = self.mln_container.selected_file.get().strip().lstrip('*')
self.config['emln'] = self.emln_container.selected_file.get().strip().lstrip('*')
self.config["db"] = self.db_container.selected_file.get().strip().lstrip('*')
self.config["method"] = InferenceMethods.id(self.selected_method.get().strip())
self.config["params"] = self.params.get().strip()
self.config["queries"] = self.query.get()
self.config["output_filename"] = self.output_filename.get().strip()
self.config["cw"] = self.closed_world.get()
self.config["cw_preds"] = self.cwPreds.get()
self.config['profile'] = self.profile.get()
self.config['logic'] = self.selected_logic.get()
self.config['grammar'] = self.selected_grammar.get()
self.config['multicore'] = self.multicore.get()
self.config['save'] = self.save.get()
self.config['ignore_unknown_preds'] = self.ignore_unknown_preds.get()
self.config['verbose'] = self.verbose.get()
self.config['window_loc'] = self.master.winfo_geometry()
self.config['dir'] = self.dir
self.project.queryconf = PRACMLNConfig()
self.project.queryconf.update(self.config.config.copy())
def write_gconfig(self, savegeometry=True):
self.gconf['prev_query_path'] = self.dir
self.gconf['prev_query_project': self.dir] = self.project.name
# save geometry
if savegeometry:
self.gconf['window_loc_query'] = self.master.geometry()
self.gconf.dump()
def infer(self, savegeometry=True, options={}, *args):
mln_content = self.mln_container.editor.get("1.0", END).strip()
db_content = self.db_container.editor.get("1.0", END).strip()
# create conf from current gui settings
self.update_config()
# write gui settings
self.write_gconfig(savegeometry=savegeometry)
# hide gui
self.master.withdraw()
try:
print((headline('PRACMLN QUERY TOOL')))
print()
if options.get('mlnarg') is not None:
mlnobj = MLN(mlnfile=os.path.abspath(options.get('mlnarg')),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
else:
mlnobj = parse_mln(mln_content, searchpaths=[self.dir],
projectpath=os.path.join(self.dir, self.project.name),
logic=self.config.get('logic', 'FirstOrderLogic'),
grammar=self.config.get('grammar', 'PRACGrammar'))
if options.get('emlnarg') is not None:
emln_content = mlnpath(options.get('emlnarg')).content
else:
emln_content = self.emln_container.editor.get("1.0", END).strip()
if options.get('dbarg') is not None:
dbobj = Database.load(mlnobj, dbfiles=[options.get('dbarg')], ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
else:
out(self.config.get('ignore_unknown_preds', True))
dbobj = parse_db(mlnobj, db_content, ignore_unknown_preds=self.config.get('ignore_unknown_preds', True))
if options.get('queryarg') is not None:
self.config["queries"] = options.get('queryarg')
infer = MLNQuery(config=self.config, mln=mlnobj, db=dbobj, emln=emln_content)
result = infer.run()
# write to file if run from commandline, otherwise save result to project results
if options.get('outputfile') is not None:
output = io.StringIO()
result.write(output)
with open(os.path.abspath(options.get('outputfile')), 'w') as f:
f.write(output.getvalue())
logger.info('saved result to {}'.format(os.path.abspath(options.get('outputfile'))))
elif self.save.get():
output = io.StringIO()
result.write(output)
fname = self.output_filename.get()
self.project.add_result(fname, output.getvalue())
self.project.save(dirpath=self.dir)
logger.info('saved result to file results/{} in project {}'.format(fname, self.project.name))
else:
logger.debug('No output file given - results have not been saved.')
except:
traceback.print_exc()
# restore main window
sys.stdout.flush()
self.master.deiconify()
chapnum = StringVar()
bookname = StringVar()
chap_entry = ttk.Entry(mainframe, width=7, textvariable=chapnum)
chap_entry.grid(column=2, row=1, sticky=(W, E))
book_entry = ttk.Entry(mainframe, width=7, textvariable=bookname)
book_entry.grid(column=2, row=2, sticky=(W, E))
ttk.Label(mainframe, text="Chapter:").grid(column=1, row=1, sticky=E)
ttk.Label(mainframe, text="Book:").grid(column=1, row=2, sticky=E)
row = 2
trigger_list = ["gore", "overt racism (non-fictional)", "ableism"]
trigger_dict = dict()
for t in trigger_list:
trigger_dict[t] = IntVar()
l = Checkbutton(root, text=t, variable=trigger_dict[t])
l.grid(column=1, row=row, sticky=W)
row += 1
ttk.Button(mainframe, text="Blog, dog", command=blog_dog).grid(column=2, row=row, sticky=W)
mainframe.bind("<Return>", blog_dog)
for child in mainframe.winfo_children():
child.grid_configure(padx=5, pady=5)
chap_entry.focus()
root.mainloop()
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.bind((host, port))
self.grid()
self.columnconfigure(0, minsize=100)
self.columnconfigure(1, minsize=200)
self.columnconfigure(2, minsize=200)
self.columnconfigure(3, minsize=150)
self.columnconfigure(4, minsize=150)
self.columnconfigure(5, minsize=150)
self.columnconfigure(6, minsize=150)
self.create_widgets()
self.settables = self.assemble_settables()
self.gui_logger = logging.getLogger('gui')
self.request_update()
def create_widgets(self):
self.create_monitor()
self.create_check_buttons()
self.create_ranges()
self.create_scales()
self.create_radio_buttons()
self.create_voices()
self.quitButton = Button(self, text='Quit', command=self.quit)
self.quitButton.grid(columnspan=7, sticky=E + W)
def assemble_settables(self):
settables = self.winfo_children()
for w in settables:
settables += w.winfo_children()
return [w for w in settables if w.__class__.__name__ in ['Scale', 'Checkbutton']]
def create_radio_buttons(self):
# Scale related
entries = ['DIATONIC', 'HARMONIC', 'MELODIC', 'PENTATONIC', 'PENTA_MINOR',
'GREEK_CHROMATIC', 'GREEK_ENHARMONIC']
self.scale = StringVar()
self.scale.set('DIATONIC')
self.rb_frame = Frame(self)
for e in entries:
rb = Radiobutton(self.rb_frame, value=e, text=e, anchor=W,
command=self.send_scale, variable=self.scale)
rb.grid(row=len(self.rb_frame.winfo_children()), sticky=W)
self.rb_frame.grid(column=1, row=len(self.grid_slaves(column=1)), rowspan=3)
def create_monitor(self):
self.monitor_frame = LabelFrame(self, text="Monitor and Transport")
this_cycle = Scale(self.monitor_frame, label='cycle_pos', orient=HORIZONTAL,
from_=1, to=16, resolution=1)
this_cycle.disable, this_cycle.enable = (None, None)
this_cycle.ref = 'cycle_pos'
this_cycle.grid(column=0, row=0, sticky=E + W)
self.updateButton = Button(self.monitor_frame,
text='Reload all Settings',
command=self.request_update)
self.updateButton.grid(row=1, sticky=E + W)
self.ForceCaesuraButton = Button(self.monitor_frame,
text='Force Caesura',
command=self.force_caesura)
self.ForceCaesuraButton.grid(row=2, sticky=E + W)
self.saveBehaviourButton = Button(self.monitor_frame,
text='Save current behaviour',
command=self.request_saving_behaviour)
self.saveBehaviourButton.grid(row=3, sticky=E + W)
self.saveBehaviourNameEntry = Entry(self.monitor_frame)
self.saveBehaviourNameEntry.grid(row=4, sticky=E + W)
self.saveBehaviourNameEntry.bind('<KeyRelease>', self.request_saving_behaviour)
self.selected_behaviour = StringVar()
self.selected_behaviour.trace('w', self.new_behaviour_chosen)
self.savedBehavioursMenu = OptionMenu(self.monitor_frame,
self.selected_behaviour, None,)
self.savedBehavioursMenu.grid(row=5, sticky=E + W)
self.monitor_frame.grid(column=0, row=10, sticky=E + W)
def request_update(self):
self.send({'sys': 'update'})
def request_saving_behaviour(self, event=None):
"""callback for save behaviour button and textentry"""
if event and event.widget == self.saveBehaviourNameEntry:
if event.keysym == 'Return':
name = self.saveBehaviourNameEntry.get()
self.saveBehaviourNameEntry.delete(0, len(name))
else:
return
else: # button was pressed
name = self.saveBehaviourNameEntry.get()
if name:
self.send({'sys': ['save_behaviour', name]})
def force_caesura(self):
self.send({'force_caesura': True})
def create_voices(self):
voice_ids = ['1', '2', '3', '4']
SCALES = OrderedDict([
('pan_pos', {'min': -1, 'max': 1, 'start': 0.5, 'res': 0.001}),
('volume', {'min': 0, 'max': 1, 'start': 0.666, 'res': 0.001}),
('slide_duration_msecs', {'min': 0, 'max': 2000, 'start': 60, 'res': 1}),
('slide_duration_prop', {'min': 0, 'max': 2, 'start': 0.666, 'res': 0.001}),
('binaural_diff', {'min': 0, 'max': 66, 'start': 0.2, 'res': 0.01})
])
for vid in voice_ids:
counter = 0
for sca in SCALES:
name = 'voice_' + vid + '_' + sca
setattr(self, 'min_' + name, SCALES[sca]['min'])
setattr(self, 'max_' + name, SCALES[sca]['max'])
this_sca = Scale(self, label=sca, orient=HORIZONTAL,
from_=getattr(self, 'min_' + name),
to=getattr(self, 'max_' + name),
resolution=SCALES[sca]['res'])
this_sca.enable = ('enable' in list(SCALES[sca].keys()) and
SCALES[sca]['enable'] or None)
this_sca.disable = ('disable' in list(SCALES[sca].keys()) and
SCALES[sca]['disable'] or None)
this_sca.grid(column=int(2 + int(vid)), row=counter, sticky=E + W)
this_sca.bind("<ButtonRelease>", self.scale_handler)
this_sca.ref = name
counter += 1
CHECK_BUTTONS = OrderedDict(
[('mute', False),
('automate_binaural_diffs', True),
('automate_note_duration_prop', True),
('use_proportional_slide_duration', {'val': True, 'label': 'proportional slide'}),
('automate_pan', True),
('automate_wavetables', True)])
for vid in voice_ids:
counter = 0
cb_frame = LabelFrame(self, text="Voice {0} - Automation".format(vid))
setattr(self, 'voice_' + vid + '_cb_frame', cb_frame)
for cb in CHECK_BUTTONS:
options = CHECK_BUTTONS[cb]
name = 'voice_' + vid + '_' + cb
if isinstance(options, dict) and 'label' in list(options.keys()):
label = options['label']
else:
label = cb[9:] if cb[:9] == 'automate_' else cb
setattr(self, name, IntVar(
value=type(options) == dict and options['val'] or options))
self.this_cb = Checkbutton(cb_frame, text=label, variable=getattr(self, name))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = None
self.this_cb.grid(sticky=W, column=0, row=counter)
self.this_cb.ref = name
counter += 1
# add trigger wavetable-button
trigWavetableButton = Button(cb_frame, text='Next Wavetable')
trigWavetableButton.bind('<Button-1>', self.trigger_waveform_handler)
trigWavetableButton.ref = 'voice_' + vid + "_trigger_wavetable"
trigWavetableButton.grid(row=counter)
cb_frame.grid(column=int(vid) + 2, row=5, sticky=E + W + N, rowspan=8)
for vid in voice_ids:
generation_types = ["random", "random_harmonic", "harmonic"]
partial_pools = ["even", "odd", "all"]
prefix = 'voice_' + vid + '_'
types_name = prefix + 'wavetable_generation_type'
pools_name = prefix + 'partial_pool'
setattr(self, types_name, StringVar())
getattr(self, types_name).set("random")
setattr(self, pools_name, StringVar())
getattr(self, pools_name).set("all")
target_frame = getattr(self, 'voice_' + vid + '_cb_frame')
gen_typ_frame = LabelFrame(target_frame, text="type")
gen_typ_frame.grid(row=len(target_frame.winfo_children()), sticky=W)
for gen_t in generation_types:
gen_t_entry = Radiobutton(gen_typ_frame, value=gen_t, text=gen_t, anchor=W,
variable=getattr(self, types_name))
gen_t_entry.bind('<ButtonRelease-1>', self.wt_handler)
gen_t_entry.ref = types_name
gen_t_entry.grid(row=len(gen_typ_frame.winfo_children()), sticky=W)
pp_frame = LabelFrame(target_frame, text="harmonics")
for pp in partial_pools:
pp_entry = Radiobutton(pp_frame, value=pp, text=pp, anchor=W,
variable=getattr(self, pools_name))
pp_entry.bind('<ButtonRelease-1>', self.wt_handler)
pp_entry.ref = pools_name
pp_entry.grid(row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials = Scale(pp_frame, label='number of harmonics', orient=HORIZONTAL,
from_=1, to=24, resolution=1)
this_num_partials.ref = prefix + 'num_partials'
this_num_partials.grid(column=0, row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials.bind("<ButtonRelease>", self.scale_handler)
pp_frame.grid(row=len(target_frame.winfo_children()), sticky=E + W)
def wt_handler(self, event):
print(event.widget.tk)
ref = event.widget.ref
self.send({ref: getattr(self, ref).get()})
def create_check_buttons(self):
self.cb_frame = LabelFrame(self, text="Global Settings")
for cb in CHECK_BUTTONS:
label = cb
target_parent = self.cb_frame
if isinstance(CHECK_BUTTONS[cb], dict) and 'sub_frame' in list(CHECK_BUTTONS[cb].keys()):
target_parent = getattr(self, CHECK_BUTTONS[cb]['sub_frame'])
setattr(self, cb, IntVar(value=type(CHECK_BUTTONS[cb]) == dict and
CHECK_BUTTONS[cb]['val'] or
CHECK_BUTTONS[cb]))
self.this_cb = Checkbutton(target_parent, text=label, variable=getattr(self, cb))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = (type(CHECK_BUTTONS[cb]) == dict and
'disable' in list(CHECK_BUTTONS[cb].keys()))
self.this_cb.grid(sticky=W, column=0, row=len(target_parent.winfo_children()))
self.this_cb.ref = cb
for but in GLOBAL_BUTTONS:
label = but
ele = GLOBAL_BUTTONS[but]
this_but = Button(self.cb_frame, text=but)
this_but.bind('<ButtonRelease-1>', getattr(self, ele['handler']))
this_but.ref = but
this_but.grid(sticky=W, column=0, row=len(self.cb_frame.winfo_children()))
self.cb_frame.grid(column=0, row=0, rowspan=10, sticky=N)
def new_behaviour_chosen(self, a, b, c):
self.send({'sys': ['change_behaviour', self.selected_behaviour.get()]})
def set_value(self, name, val):
'''sets a widget to the specified value
various different widget types need custom setting functionality'''
direct = ['scale', 'wavetable_generation_type', 'partial_pool']
if [x for x in direct if match("(voice_\d_|)" + x, name)]:
self.gui_logger.info("setting: '{0}' to '{1}' in GUI".format(name, val))
getattr(self, name).set(val)
return
if name == 'saved_behaviours' and len(val):
self.savedBehavioursMenu.destroy()
self.savedBehavioursMenu = OptionMenu(self.monitor_frame,
self.selected_behaviour, *sorted(val))
self.savedBehavioursMenu.grid(row=5, sticky=E + W)
return
for w in self.settables:
typ = w.__class__.__name__
if w.ref == name:
# print "setting '{0}' of type: '{1}' to: {2}".format(name, typ, val)
if typ == 'Scale':
w.set(val)
elif typ == "Checkbutton":
w.select() if val else w.deselect()
def check_boxes_handler(self, event):
'''handles checkbox events.
shows and hides gui elements according to their enable/disable fields'''
# print event.__dict__
# print event.widget.__dict__
ref = event.widget.ref
val = not getattr(self, ref).get() # because is read before the var is changed
self.send({ref: val})
# print ref, val
# handle gui elements
# enable/disable functionality temporarily(?) commented on:
# Wed Aug 17 09:39:54 CEST 2011
# if event.widget.disable:
# for w in self.children.values():
#
# # this try clause is for debugging, remove when stable
# try:
# w.ref
# #print w.ref
# except:
# pass
# if (w.__class__.__name__ == 'Scale' and
# (w.disable or w.enable)):
# if w.disable == ref:
# if val:
# w.grid()
# else:
# w.grid_remove()
# elif w.enable == ref:
# if val:
# w.grid_remove()
# else:
# w.grid()
# #print w.disable, w.enable
def create_scales(self):
counter = 0
for sca in SCALES:
label = SCALES[sca]['label'] if 'label' in list(SCALES[sca].keys()) else sca
setattr(self, 'min_' + sca, SCALES[sca]['min'])
setattr(self, 'max_' + sca, SCALES[sca]['max'])
self.this_scale = Scale(self, label=label, orient=HORIZONTAL,
from_=getattr(self, 'min_' + sca),
to=getattr(self, 'max_' + sca),
resolution=SCALES[sca]['res'])
self.this_scale.set(SCALES[sca]['start'])
self.this_scale.enable = ('enable' in list(SCALES[sca].keys()) and
SCALES[sca]['enable'] or None)
self.this_scale.disable = ('disable' in list(SCALES[sca].keys()) and
SCALES[sca]['disable'] or None)
if 'pos' in list(SCALES[sca].keys()):
pos = SCALES[sca]['pos']
col = pos['c']
row = pos['r']
else:
row = counter
col = 1
counter += 1
self.this_scale.grid(column=col, row=row, sticky=E + W)
self.this_scale.ref = sca
self.this_scale.bind("<ButtonRelease>", self.scale_handler)
def scale_handler(self, event):
self.send({event.widget.ref: event.widget.get()})
self.gui_logger.info("handling scale: {0}, with new value: {1}".format(
event.widget.ref, event.widget.get()))
def trigger_waveform_handler(self, event):
self.send({event.widget.ref: True})
# print event.widget.ref, "- triggering wavetable"
def send_scale(self):
do = {'scale': self.scale.get()}
self.send(do)
def send(self, msg):
self.gui_logger.info("sending: {0}".format(msg))
self.send_sock.sendto(json.dumps(msg), (remote_host, send_port))
def create_ranges(self):
counter = 0
for ran in RANGES:
setattr(self, 'min_' + ran, RANGES[ran]['min'])
setattr(self, 'max_' + ran, RANGES[ran]['max'])
self.this_min_scale = Scale(self, label='min ' + ran, orient=HORIZONTAL,
from_=getattr(self, 'min_' + ran),
to=getattr(self, 'max_' + ran),
resolution=RANGES[ran]['res'])
self.this_max_scale = Scale(self, label='max ' + ran, orient=HORIZONTAL,
from_=getattr(self, 'min_' + ran),
to=getattr(self, 'max_' + ran),
resolution=RANGES[ran]['res'])
self.this_min_scale.set(RANGES[ran]['min_start'])
self.this_max_scale.set(RANGES[ran]['max_start'])
self.this_min_scale.enable = ('enable' in list(RANGES[ran].keys()) and
RANGES[ran]['enable'] or None)
self.this_min_scale.disable = ('disable' in list(RANGES[ran].keys()) and
RANGES[ran]['disable'] or None)
self.this_max_scale.enable = ('enable' in list(RANGES[ran].keys()) and
RANGES[ran]['enable'] or None)
self.this_max_scale.disable = ('disable' in list(RANGES[ran].keys()) and
RANGES[ran]['disable'] or None)
self.this_min_scale.grid(column=2, row=counter, sticky=E + W)
self.this_max_scale.grid(column=2, row=counter + 1, sticky=E + W)
self.this_min_scale.ref = 'min_' + ran
self.this_max_scale.ref = 'max_' + ran
self.this_min_scale.bind("<ButtonRelease>", self.scale_handler)
self.this_max_scale.bind("<ButtonRelease>", self.scale_handler)
counter += 2
def socket_read_handler(self, file, mask):
data_object = json.loads(file.recv(1024))
do = list(data_object.items())[0]
self.set_value(do[0], do[1])
def createWidgets(self):
'''Create and align widgets'''
top = self.winfo_toplevel()
top.rowconfigure(0, weight=1)
top.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1)
self.passwordout = StringVar()
self.passwordout.set('- No password generated -')
self.isnew = IntVar()
ttitle = Label(self, text=versionStr, font=self.getFont(4))
wisnew = Checkbutton(self, height=2, font=self.getFont(),
text=('This is a new password, that I have not '
'used before'),
variable=self.isnew, command=self.toggleCheck)
tlabel = Label(self, text='Label', font=self.getFont(2))
tpasswordin1 = Label(self, text='Password', font=self.getFont(2))
tpasswordin2 = Label(self, text='Password (again)',
font=self.getFont(2))
tlength = Label(self, text='Length', font=self.getFont(2))
talgorithm = Label(self, text='Algorithm', font=self.getFont(2))
tsequence = Label(self, text='Sequence #', font=self.getFont(2))
self.label = ttk.Combobox(self, width=27, font=self.getFont(),
postcommand=self.filterLabels)
self.passwordin1 = Entry(self, width=27, font=self.getFont(), show="*")
self.passwordin2 = Entry(self, width=27, font=self.getFont(), show="*",
state=DISABLED)
length = Spinbox(self, width=3, font=self.getFont, from_=9,
to=171, textvariable=self.lengthVar)
self.algorithm = ttk.Combobox(self, width=27, font=self.getFont(),
values=algos.algorithms)
sequence = Spinbox(self, width=3, font=self.getFont, from_=1,
to=sys.maxsize, textvariable=self.sequenceVar)
genbutton = Button(self, text="Generate password",
font=self.getFont(), command=self.validateAndShow,
default="active")
clrbutton = Button(self, text="Clear fields", font=self.getFont(),
command=self.clearIO)
self.result = Entry(self, font=self.getFont(4),
textvariable=self.passwordout, state="readonly",
fg="black", readonlybackground="gray")
# Keybindings
self.passwordin1.bind('<Return>', lambda e: genbutton.invoke())
self.passwordin2.bind('<Return>', lambda e: genbutton.invoke())
length.bind('<Return>', lambda e: genbutton.invoke())
self.algorithm.bind('<Return>', lambda e: genbutton.invoke())
sequence.bind('<Return>', lambda e: genbutton.invoke())
self.master.bind('<Control-q>', lambda e: self.quit())
self.master.bind('<Escape>', lambda e: self.reset())
self.label.bind('<<ComboboxSelected>>', self.labelSelected)
self.label.bind('<FocusOut>', self.labelFocusOut)
# Layout widgets in a grid
ttitle.grid(row=0, column=0, sticky=N + S + E + W, columnspan=2)
wisnew.grid(row=1, column=0, sticky=N + S + E + W, columnspan=2)
tlabel.grid(row=2, column=0, sticky=N + S + W)
self.label.grid(row=2, column=1, sticky=N + S + E + W)
tpasswordin1.grid(row=3, column=0, sticky=N + S + W)
self.passwordin1.grid(row=3, column=1, sticky=N + S + E + W)
tpasswordin2.grid(row=4, column=0, sticky=N + S + W)
self.passwordin2.grid(row=4, column=1, sticky=N + S + E + W)
tlength.grid(row=5, column=0, sticky=N + S + W)
length.grid(row=5, column=1, sticky=N + S + E + W)
talgorithm.grid(row=6, column=0, sticky=N + S + W)
self.algorithm.grid(row=6, column=1, sticky=N + S + E + W)
tsequence.grid(row=7, column=0, sticky=N + S + W)
sequence.grid(row=7, column=1, sticky=N + S + E + W)
clrbutton.grid(row=8, column=0, sticky=N + S + E + W, columnspan=2)
genbutton.grid(row=9, column=0, sticky=N + S + E + W, columnspan=2)
self.result.grid(row=10, column=0, sticky=N + S + E + W, columnspan=2)
# Initial values
self.algorithm.set(self.settings.algorithm)
# Initially, set focus on self.label
self.label.focus_set()
class ParameterSetup:
def __init__(self, master, par=False):
"""
GUI for selecting default parameters - will write parameters to file \
of users choosing.
:type master: Tk
:param master: Tkinter window
:type par: EQcorrscanParameters
:param par: Default parameters to start-up with.
"""
from tkinter import Label, Button, Entry, DoubleVar, StringVar, IntVar
from tkinter import BooleanVar, OptionMenu, Checkbutton
import tkMessageBox
from eqcorrscan.utils import parameters
from obspy import UTCDateTime
import warnings
# Set the default par, only if they don't already exist.
if not par:
par = parameters.EQcorrscanParameters([''], 2, 10, 4, 100, 2,
'1900-01-01', '2300-01-01',
'', 'seishub', 4, False, '',
'jpg', False, 8, 'MAD', 6)
# Callback functions for all variables (ugly)
def update_template_names(*args):
par.template_names = [name.strip() for name in
template_names.get().split(',')]
template_names.set(', '.join(par.template_names))
def update_lowcut(*args):
par.lowcut = lowcut.get()
lowcut.set(par.lowcut)
def update_highcut(*args):
par.highcut = highcut.get()
if par.highcut >= 0.5 * par.samp_rate:
msg = ('Highcut must be less than the Nyquist, setting to ' +
str((par.samp_rate / 2.0) - 1))
tkMessageBox.showwarning(title="Nyquist error",
message=msg)
par.highcut = (par.samp_rate / 2.0) - 1
highcut.set(par.highcut)
def update_filt_order(*args):
par.filt_order = filt_order.get()
filt_order.set(par.filt_order)
def update_samp_rate(*args):
par.samp_rate = samp_rate.get()
if par.highcut >= 0.5 * par.samp_rate:
msg = ('Highcut must be less than the Nyquist, setting to ' +
str((par.samp_rate / 2.0) - 1))
tkMessageBox.showwarning(title="Nyquist error",
message=msg)
par.highcut = (par.samp_rate / 2.0) - 1
highcut.set(par.highcut)
samp_rate.set(par.samp_rate)
def update_debug(*args):
par.debug = debug.get()
debug.set(par.debug)
def update_startdate(*args):
par.startdate = UTCDateTime(startdate.get())
startdate.set(str(par.startdate))
def update_enddate(*args):
par.enddate = UTCDateTime(enddate.get())
enddate.set(str(par.enddate))
def update_archive(*args):
par.archive = archive.get()
archive.set(par.archive)
def update_arc_type(*args):
par.arc_type = arc_type.get()
arc_type.set(par.arc_type)
def update_cores(*args):
par.cores = cores.get()
cores.set(par.cores)
def update_plotvar(*args):
par.plotvar = plotvar.get()
plotvar.set(par.plotvar)
def update_plot_format(*args):
par.plot_format = plot_format.get()
plot_format.set(par.plot_format)
def update_tempdir(*args):
par.tempdir = tempdir.get()
tempdir.set(par.tempdir)
def update_threshold(*args):
par.threshold = threshold.get()
threshold.set(par.threshold)
def update_threshold_type(*args):
par.threshold_type = threshold_type.get()
threshold_type.set(par.threshold_type)
def update_plotdir(*args):
par.plotdir = plotdir.get()
plotdir.set(par.plotdir)
def update_trigger_interval(*args):
par.trigger_interval = trigger_interval.get()
trigger_interval.set(par.trigger_interval)
# Set some grid parameters
nrows = 25
ncolumns = 3
self.master = master
master.title("EQcorrscan parameter setup")
self.label = Label(master, text="Alpha GUI for default setup")
self.label.grid(column=0, columnspan=ncolumns, row=0)
# Set up parameter input
self.t_names_label = Label(master, text="Template names", anchor='e')
self.t_names_label.grid(column=0, row=1, sticky='e')
template_names = StringVar()
template_names.set(', '.join(par.template_names))
self.t_names_box = Entry(master, bd=2, textvariable=template_names)
self.t_names_box.grid(column=1, row=1)
template_names.trace("w", update_template_names)
self.t_names_lookup = Button(master, text="Lookup",
command=lambda: self.get_template_names(par))
self.t_names_lookup.grid(column=2, row=1)
self.lowcut_label = Label(master, text="Lowcut (Hz)", anchor='e')
self.lowcut_label.grid(column=0, row=2, sticky='e')
lowcut = DoubleVar()
lowcut.set(par.lowcut)
self.lowcut_box = Entry(master, bd=2, textvariable=lowcut)
self.lowcut_box.grid(column=1, row=2)
lowcut.trace("w", update_lowcut)
self.highcut_label = Label(master, text="Highcut (Hz)", anchor='e')
self.highcut_label.grid(column=0, row=3, sticky='e')
highcut = DoubleVar()
highcut.set(par.highcut)
self.highcut_box = Entry(master, bd=2, textvariable=highcut)
self.highcut_box.grid(column=1, row=3)
highcut.trace("w", update_highcut)
self.filt_order_label = Label(master, text="Filter order")
self.filt_order_label.grid(column=0, row=4, sticky='e')
filt_order = DoubleVar()
filt_order.set(par.filt_order)
self.filt_order_box = Entry(master, bd=2, textvariable=filt_order)
self.filt_order_box.grid(column=1, row=4)
filt_order.trace("w", update_filt_order)
self.samp_rate_label = Label(master, text="Sample rate (Hz)")
self.samp_rate_label.grid(column=0, row=5, sticky='e')
samp_rate = DoubleVar()
samp_rate.set(par.samp_rate)
self.samp_rate_box = Entry(master, bd=2, textvariable=samp_rate)
self.samp_rate_box.grid(column=1, row=5)
samp_rate.trace("w", update_samp_rate)
self.debug_label = Label(master, text="Debug")
self.debug_label.grid(column=0, row=6, sticky='e')
debug = IntVar()
debug.set(par.debug)
self.debug_box = Entry(master, bd=2, textvariable=debug)
self.debug_box.grid(column=1, row=6)
debug.trace("w", update_debug)
self.startdate_label = Label(master, text="Start date (yyyy-mm-dd)")
self.startdate_label.grid(column=0, row=6, sticky='e')
startdate = StringVar()
startdate.set(par.startdate)
self.startdate_box = Entry(master, bd=2, textvariable=startdate)
self.startdate_box.grid(column=1, row=6)
startdate.trace("w", update_startdate)
self.enddate_label = Label(master, text="End date (yyyy-mm-dd)")
self.enddate_label.grid(column=0, row=8, sticky='e')
enddate = StringVar()
enddate.set(par.enddate)
self.enddate_box = Entry(master, bd=2, textvariable=enddate)
self.enddate_box.grid(column=1, row=8)
enddate.trace("w", update_enddate)
self.archive_label = Label(master, text="Archive")
self.archive_label.grid(column=0, row=9, sticky='e')
archive = StringVar()
archive.set(par.archive)
self.archive_box = Entry(master, bd=2, textvariable=archive)
self.archive_box.grid(column=1, row=9)
archive.trace("w", update_archive)
self.archive_lookup = Button(master, text="Lookup",
command=lambda: self.get_archive(par))
self.archive_lookup.grid(column=2, row=9)
self.arc_type_label = Label(master, text="Archive type")
self.arc_type_label.grid(column=0, row=10, sticky='e')
arc_type = StringVar()
arc_type.set(par.arc_type)
self.arc_type_box = OptionMenu(master, arc_type,
"seishub", "fdsn", "day_vols")
self.arc_type_box.grid(column=1, row=10, sticky='w,e')
arc_type.trace("w", update_arc_type)
self.cores_label = Label(master, text="Number of cores")
self.cores_label.grid(column=0, row=11, sticky='e')
cores = IntVar()
cores.set(par.cores)
self.cores_box = Entry(master, bd=2, textvariable=cores)
self.cores_box.grid(column=1, row=11)
cores.trace("w", update_cores)
self.plotvar_label = Label(master, text="Plotting on/off")
self.plotvar_label.grid(column=0, row=12, sticky='e')
plotvar = BooleanVar()
plotvar.set(par.plotvar)
self.plotvar_box = Checkbutton(master, text='Plot on', var=plotvar,
onvalue=True, offvalue=False)
self.plotvar_box.grid(column=1, row=12)
plotvar.trace("w", update_plotvar)
self.plotdir_label = Label(master, text="Plot directory")
self.plotdir_label.grid(column=0, row=13, sticky='e')
plotdir = StringVar()
plotdir.set(par.plotdir)
self.plotdir_box = Entry(master, bd=2, textvariable=plotdir)
self.plotdir_box.grid(column=1, row=13)
plotdir.trace("w", update_plotdir)
self.plotdir_lookup = Button(master, text="Lookup",
command=lambda: self.get_plotdir(par))
self.plotdir_lookup.grid(column=2, row=13)
self.plot_format_label = Label(master, text="Plot format")
self.plot_format_label.grid(column=0, row=14, sticky='e')
plot_format = StringVar()
plot_format.set(par.plot_format)
self.plot_format_box = OptionMenu(master, plot_format,
"jpg", "eps", "pdf", "png")
self.plot_format_box.grid(column=1, row=14, sticky='w,e')
plot_format.trace("w", update_plot_format)
self.tempdir_label = Label(master, text="Temporary directory")
self.tempdir_label.grid(column=0, row=15, sticky='e')
tempdir = StringVar()
tempdir.set(par.tempdir)
self.tempdir_box = Entry(master, bd=2, textvariable=tempdir)
self.tempdir_box.grid(column=1, row=15)
tempdir.trace("w", update_tempdir)
self.tempdir_lookup = Button(master, text="Lookup",
command=lambda: self.get_tempdir(par))
self.tempdir_lookup.grid(column=2, row=15)
self.threshold_label = Label(master, text="Threshold")
self.threshold_label.grid(column=0, row=16, sticky='e')
threshold = DoubleVar()
threshold.set(par.threshold)
self.threshold_box = Entry(master, bd=2, textvariable=threshold)
self.threshold_box.grid(column=1, row=16)
threshold.trace("w", update_threshold)
self.threshold_type_label = Label(master, text="Threshold type")
self.threshold_type_label.grid(column=0, row=17, sticky='e')
threshold_type = StringVar()
threshold_type.set(par.threshold_type)
self.threshold_type_box = OptionMenu(master, threshold_type,
"MAD", "absolute", "av_chan_corr")
self.threshold_type_box.grid(column=1, row=17, sticky='w,e')
threshold_type.trace("w", update_threshold_type)
self.trigger_interval_label = Label(master,
text="Minimum trigger " +
"interval (s)")
self.trigger_interval_label.grid(column=0, row=18, sticky='e')
trigger_interval = DoubleVar()
trigger_interval.set(par.trigger_interval)
self.trigger_interval_box = Entry(master, bd=2,
textvariable=trigger_interval)
self.trigger_interval_box.grid(column=1, row=18)
trigger_interval.trace("w", update_trigger_interval)
# End of user editable section, now we have read/write buttons
self.read_button = Button(master, text="Read parameters",
command=lambda: self.read_par(master))
self.read_button.grid(column=0, row=nrows-2, sticky='w,e')
self.write_button = Button(master, text="Write parameters",
command=lambda: self.write_par(par))
self.write_button.grid(column=1, row=nrows-2, sticky='w,e')
def read_par(self, master):
"""
Function to open a file-browser and to select a parameter file.
"""
from eqcorrscan.utils import parameters
from tkFileDialog import askopenfilename
parameter_filename = askopenfilename()
try:
par = parameters.read_parameters(parameter_filename)
# Start a new instance
master.destroy()
run(par=par)
except IOError:
print 'No such file'
return
except TypeError:
print 'Invalid parameter file'
return
def write_par(self, par):
import tkMessageBox
from eqcorrscan.utils import parameters
from tkFileDialog import asksaveasfilename
parameter_filename = asksaveasfilename()
print(parameter_filename)
# Set overwrite to true because asksavefilename already checks this.
if len(par.template_names) == 1 and len(par.template_names[0]) == 0:
msg = ("Warning: You have not selected any templates, " +
"you must add them before running matched-filter.")
tkMessageBox.showwarning(title="No templates",
message=msg)
par.write(parameter_filename, overwrite=True)
def get_template_names(self, par):
from tkFileDialog import askopenfilenames
par.template_names = askopenfilenames()
self.master.destroy()
run(par=par)
def get_archive(self, par):
from tkFileDialog import askdirectory
par.archive = askdirectory()
par.arc_type = 'day_vols'
self.master.destroy()
run(par=par)
def get_plotdir(self, par):
from tkFileDialog import askdirectory
par.plotdir = askdirectory()
self.master.destroy()
run(par=par)
def get_tempdir(self, par):
from tkFileDialog import askdirectory
par.tempdir = askdirectory()
self.master.destroy()
run(par=par)
def initUI( self ):
#pack framework
self.pack( fill=BOTH, expand=1 )
#setting font
FONT = ('serif', 10)
#setting UI grid
self.columnconfigure(0, weight=1)
self.columnconfigure(2, pad=10)
self.rowconfigure(6, pad=200, weight=1)
#setting widgets
#Label
available_lb = Label( self, text='Availabel sessions:', font=FONT )
available_lb.grid( row=0, column=0, sticky=W )
#list
y_scroll = Scrollbar( self, orient=VERTICAL )
y_scroll.grid( row=1, column=1, rowspan=9, sticky=N+S )
self.script_list = Listbox( self, bg='white', font=FONT, selectmode=SINGLE,
yscrollcommand=y_scroll.set )
self.script_list.grid( row=1, column=0, rowspan=9, sticky=W+E+N+S )
#button
exec_btn = Button( self, text='Execute', width=6, font=FONT,
command=self.execute )
exec_btn.grid( row=1, column=2 )
copy_btn = Button( self, text='Copy', width=6, font=FONT,
command=self.copyCheck )
copy_btn.grid( row=3, column=2 )
create_btn = Button( self, text='Create', width=6, font=FONT,
command=lambda:self.popWidget( self.createFile ) )
create_btn.grid( row=2, column=2 )
edit_btn = Button( self, text='Edit', width=6, font=FONT, command=self.editFile )
edit_btn.grid( row=4, column=2 )
delete_btn = Button( self, text='Delete', width=6, font=FONT,
command=self.deleteFile )
delete_btn.grid( row=5, column=2 )
help_btn = Button( self, text='Help', width=6, font=FONT, command=self.usageHelp )
help_btn.grid( row=7, column=3, sticky=E )
abt_btn = Button( self, text='About', width=6, font=FONT, command=self.about )
abt_btn.grid( row=8, column=3, sticky=E )
quit_btn = Button( self, text='Quit', width=6, font=FONT, command=self.quit )
quit_btn.grid( row=9, column=3, sticky=E )
#Option
lbl2 = Label( self, text='Exeuction Options:' )
lbl2.grid( row=0, column=3, sticky=W )
execute_with_term = Checkbutton( self, text='Execute with terminal',
variable=self.opt_exec_with_term )
execute_with_term.grid( row=1, column=3, sticky=E )
class GraphicalUserInterface(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.__initUI()
def __initUI(self):
self.parent.title("Fuel Manager")
# parameters that the user can modify
self.__exchvar = BooleanVar()
self.__exchrate = True
self.__datevar = BooleanVar()
self.__datetime = True
self.__empty_tank_var = BooleanVar()
self.__empty_tank = False
self.__airport_file = "input files/airport.csv"
self.__aircraft_file = "input files/aircraft.csv"
self.__currency_file = "input files/countrycurrency.csv"
self.__exchange_rate_file = "input files/currencyrates.csv"
self.__itinerary_file = "input files/testroutes.csv"
self.__output_file = "bestroutes/bestroutes.csv"
self.__home_airport = ["DUB"]
self.__other_airports = ["LHR", "CDG", "JFK", "AAL", "AMS", "ORK"]
self.__hubs = ["MHP"]
self.__stopover_cost = 0
self.__constraints = "JFK AAL / JFK CDG"
self.__aircraft_code = "747"
# main frame
frame = Frame(self, relief=RAISED, borderwidth=1)
frame.pack(fill=BOTH, expand=True)
self.pack(fill=BOTH, expand=True)
# manage single itinerary frame
self.manual_frame = LabelFrame(self, text="Manage a single itinerary", font=("Helvetica", 14), width=300)
self.manual_frame.place(x=50, y=50)
# Empty row to put some space between the other rows and to control the width of this frame because
# I don't know what I'm doing
self.empty_label = Label(self.manual_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=0, sticky="W")
# Text field where user can enter home airport
self.home_airport_label = Label(self.manual_frame, width=22, text="Home airport:", anchor='w')
self.home_airport_label.grid(row=1, sticky="W")
self.home_airport_entry = Entry(self.manual_frame, width=50)
self.home_airport_entry.grid(row=2, sticky="E")
self.home_airport_entry.insert(0, self.__home_airport)
self.empty_label = Label(self.manual_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=3, sticky="W")
# Text field where user can enter other airports
self.other_airports_label = Label(self.manual_frame, width=22, text="Other airports:", anchor='w')
self.other_airports_label.grid(row=4, sticky="W")
self.other_airports_entry = Entry(self.manual_frame, width=50)
self.other_airports_entry.grid(row=5, sticky="E")
self.other_airports_entry.insert(0, self.__other_airports)
self.empty_label = Label(self.manual_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=6, sticky="W")
# Text field where user can enter aircraft code
self.aircraft_label = Label(self.manual_frame, width=22, text="Aircraft code:", anchor='w')
self.aircraft_label.grid(row=7, sticky="W")
self.aircraft_entry = Entry(self.manual_frame, width=50)
self.aircraft_entry.grid(row=8, sticky="E")
self.aircraft_entry.insert(0, self.__aircraft_code)
self.empty_label = Label(self.manual_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=9, sticky="W")
# Text field where user can enter constraints
self.constraints_label = Label(self.manual_frame, width=22, text="Constraints:", anchor='w')
self.constraints_label.grid(row=13, sticky="W")
self.constraints_entry = Entry(self.manual_frame, width=50)
self.constraints_entry.grid(row=14, sticky="E")
self.constraints_entry.insert(0, self.__constraints)
self.constraints_explanation_label = \
Label(self.manual_frame, width=50,
text="Each constraint should consist of three-letter airport codes"
"\nseparated by spaces. To enter more than one constraint,"
"\nuse ' / ' to separate them", anchor='w', justify='left')
self.constraints_explanation_label.grid(row=15, sticky="W")
self.empty_label = Label(self.manual_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=16, sticky="W")
# run button
self.run_button = Button(self.manual_frame, text='Manage itinerary', command=self.__manage_single_itinerary,
bg="#CCE1E8")
self.run_button.grid(row=16, sticky="E")
# manage list of itineraries frame
self.itinerary_list_frame = LabelFrame(self, text="Manage a list of itineraries",
font=("Helvetica", 14), width=300)
self.itinerary_list_frame.place(x=50, y=375)
# Empty row to put some space between the other rows and to control the width of this frame
self.empty_label = Label(self.itinerary_list_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=12, sticky="W")
# Text field where user can enter itinerary filepath
self.itinerary_label = Label(self.itinerary_list_frame, width=22, text="Itinerary list: ", anchor='w')
self.itinerary_label.grid(row=13, sticky="W")
self.itinerary_entry = Entry(self.itinerary_list_frame, width=50)
self.itinerary_entry.grid(row=13, sticky="E")
self.itinerary_entry.insert(0, self.__itinerary_file)
self.itinerary_button = Button(self.itinerary_list_frame, text='Browse...',
command=self.__get_itinerary_filename)
self.itinerary_button.grid(row=14, sticky="E")
self.empty_label = Label(self.itinerary_list_frame, text=" ", width=60, height=2, font=("Helvetica", 1))
self.empty_label.grid(row=15, sticky="W")
# run button
self.run_button = Button(self.itinerary_list_frame, text='Manage list of itineraries',
command=self.__manage_list, bg="#CCE1E8")
self.run_button.grid(row=16, sticky="E")
# Fuel management settings frame
self.general_frame = LabelFrame(self, text="Fuel management settings", font=("Helvetica", 14), width=300)
self.general_frame.place(x=500, y=50)
# Empty row to put some space between the other rows and to control the width of this frame
self.empty_label = Label(self.general_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=0, sticky="W")
# Text field where user can enter hubs
self.hubs_label = Label(self.general_frame, width=22, text="Hubs:", anchor='w')
self.hubs_label.grid(row=1, sticky="W")
self.hubs_entry = Entry(self.general_frame, width=50)
self.hubs_entry.grid(row=2, sticky="E")
self.hubs_entry.insert(0, self.__hubs)
self.empty_label = Label(self.general_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=3, sticky="W")
# Text field where user can enter cost of extra stopovers
self.stopover_cost_label = Label(self.general_frame, width=40, text="Cost of each extra stopover (euros):",
anchor='w')
self.stopover_cost_label.grid(row=4, sticky="W")
self.stopover_cost_entry = Entry(self.general_frame, width=50)
self.stopover_cost_entry.grid(row=5, sticky="E")
self.stopover_cost_entry.insert(0, self.__stopover_cost)
self.empty_label = Label(self.general_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=6, sticky="W")
# bring home extra fuel checkbox
self.empty_tank_cb = Checkbutton(self.general_frame,
text="Always return to home airport with an empty tank",
variable=self.__empty_tank_var, command=self.__empty_tank_toggle)
self.empty_tank_cb.grid(row=7, sticky="W")
self.empty_label = Label(self.general_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=8, sticky="W")
# manage inputs frame
self.input_frame = LabelFrame(self, text="Inputs", font=("Helvetica", 14), width=300)
self.input_frame.place(x=500, y=250)
self.empty_label = Label(self.input_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=0, sticky="W")
# Text field where user can enter airport filepath
self.airport_label = Label(self.input_frame, width=22, text="Airport list: ", anchor='w')
self.airport_label.grid(row=1, sticky="W")
self.airport_entry = Entry(self.input_frame, width=50)
self.airport_entry.grid(row=1, sticky="E")
self.airport_entry.insert(0, self.__airport_file)
self.airport_button = Button(self.input_frame, text='Browse...', command=self.__get_airport_filename)
self.airport_button.grid(row=2, sticky="E")
self.empty_label = Label(self.input_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=3, sticky="W")
# Text field where user can enter aircraft filepath
self.aircraft_file_label = Label(self.input_frame, width=22, text="Aircraft list: ", anchor='w')
self.aircraft_file_label.grid(row=4, sticky="W")
self.aircraft_file_entry = Entry(self.input_frame, width=50)
self.aircraft_file_entry.grid(row=4, sticky="E")
self.aircraft_file_entry.insert(0, self.__aircraft_file)
self.aircraft_file_button = Button(self.input_frame, text='Browse...', command=self.__get_aircraft_filename)
self.aircraft_file_button.grid(row=5, sticky="E")
self.empty_label = Label(self.input_frame, text=" ", width=425, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=6, sticky="W")
# Text field where user can enter country-currency filepath
self.currency_label = Label(self.input_frame, width=22, text="Currency list: ", anchor='w')
self.currency_label.grid(row=7, sticky="W")
self.currency_entry = Entry(self.input_frame, width=50)
self.currency_entry.grid(row=7, sticky="E")
self.currency_entry.insert(0, self.__currency_file)
self.currency_button = Button(self.input_frame, text='Browse...', command=self.__get_currency_filename)
self.currency_button.grid(row=8, sticky="E")
self.empty_label = Label(self.input_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=9, sticky="W")
# Text field where user can enter exchange rate filepath
self.exchange_rate_label = Label(self.input_frame, width=22, text="Exchange rate list: ", anchor='w')
self.exchange_rate_label.grid(row=10, sticky="W")
self.exchange_rate_entry = Entry(self.input_frame, width=50)
self.exchange_rate_entry.grid(row=10, sticky="E")
self.exchange_rate_entry.insert(0, self.__exchange_rate_file)
self.exchange_rate_button = Button(self.input_frame, text='Browse...', command=self.__get_exchange_rate_filename)
self.exchange_rate_button.grid(row=11, sticky="E")
# real-time exchange rates checkbox
self.forex = Checkbutton(self.input_frame, text="Use real-time exchange rates", variable=self.__exchvar,
command=self.__forex_toggle)
self.forex.select()
self.forex.grid(row=12, sticky="W")
# manage output frame
self.output_frame = LabelFrame(self, text="Output", font=("Helvetica", 14), width=300)
self.output_frame.place(x=500, y=550)
self.empty_label = Label(self.output_frame, text=" ", width=60, height=1, font=("Helvetica", 1))
self.empty_label.grid(row=0, sticky="W")
# Text field where user can enter output filepath
self.output_label = Label(self.output_frame, width=22, text="Output file: ", anchor='w')
self.output_label.grid(row=1, sticky="W")
self.output_entry = Entry(self.output_frame, width=50)
self.output_entry.grid(row=1, sticky="E")
self.output_entry.insert(0, self.__output_file)
self.output_button = Button(self.output_frame, text='Browse...', command=self.__get_output_filename)
self.output_button.grid(row=2, sticky="E")
# append date to output filename checkbox
self.datetime_cb = Checkbutton(self.output_frame,
text="Append date and time to filename (e.g., bestroutes 20151218 160000.csv)",
variable=self.__datevar, command=self.__datetime_toggle)
self.datetime_cb.grid(row=3, sticky="W")
self.datetime_cb.select()
# GUI methods
def __forex_toggle(self):
if self.__exchvar.get() == True:
self.__exchrate = True
else:
self.__exchrate = False
def __datetime_toggle(self):
if self.__datevar.get() == True:
self.__datetime = True
else:
self.__datetime = False
def __empty_tank_toggle(self):
if self.__empty_tank_var.get() == True:
self.__empty_tank = True
else:
self.__empty_tank = False
def __get_airport_filename(self):
self.__airport_file = filedialog.askopenfilename(
filetypes=(("Comma-separated values files", "*.csv"), ("All files", "*.*")))
self.airport_entry.delete(0, END)
self.airport_entry.insert(0, self.__airport_file)
def __get_aircraft_filename(self):
self.__aircraft_file = filedialog.askopenfilename(
filetypes=(("Comma-separated values files", "*.csv"), ("All files", "*.*")))
self.aircraft_file_entry.delete(0, END)
self.aircraft_file_entry.insert(0, self.__aircraft_file)
def __get_currency_filename(self):
self.__currency_file = filedialog.askopenfilename(
filetypes=(("Comma-separated values files", "*.csv"), ("All files", "*.*")))
self.currency_entry.delete(0, END)
self.currency_entry.insert(0, self.__currency_file)
def __get_exchange_rate_filename(self):
self.__exchange_rate_file = filedialog.askopenfilename(
filetypes=(("Comma-separated values files", "*.csv"), ("All files", "*.*")))
self.exchange_rate_entry.delete(0, END)
self.exchange_rate_entry.insert(0, self.__exchange_rate_file)
def __get_itinerary_filename(self):
self.__itinerary_file = filedialog.askopenfilename(
filetypes=(("Comma-separated values files", "*.csv"), ("All files", "*.*")))
self.itinerary_entry.delete(0, END)
self.itinerary_entry.insert(0, self.__itinerary_file)
def __get_output_filename(self):
self.__output_file = filedialog.asksaveasfilename(defaultextension=".csv", filetypes=(
("Comma-separated values file", "*.csv"), ("All Files", "*.*")))
self.output_entry.delete(0, END)
self.output_entry.insert(0, self.__output_file)
def __manage_list(self):
# validate user inputs
hubs, stopover_cost = validate_inputs_for_list_of_itineraries(self.hubs_entry.get().upper().split(),
self.stopover_cost_entry.get())
print("Managing list of itineraries...")
manage_list_of_routes(self.__exchrate,
self.__datetime,
self.__empty_tank,
hubs,
stopover_cost,
self.itinerary_entry.get(),
self.airport_entry.get(),
self.aircraft_file_entry.get(),
self.currency_entry.get(),
self.exchange_rate_entry.get(),
self.output_entry.get())
def __manage_single_itinerary(self):
# validate user inputs
try:
hubs, stopover_cost, constraints_list, home_airport, other_airports, aircraft_code = \
validate_inputs_for_single_itinerary(self.hubs_entry.get().upper().split(),
self.stopover_cost_entry.get(),
self.constraints_entry.get().upper().split(),
self.home_airport_entry.get().upper(),
self.other_airports_entry.get().upper().split(),
self.aircraft_entry.get().upper())
except TypeError:
return
print("Managing single itinerary...")
manage_single_route(home_airport,
other_airports,
aircraft_code,
self.__exchrate,
self.__datetime,
self.__empty_tank,
hubs,
stopover_cost,
constraints_list,
self.airport_entry.get(),
self.aircraft_file_entry.get(),
self.currency_entry.get(),
self.exchange_rate_entry.get(),
self.output_entry.get())
class makeLoginPanel:
def __init__(self,master):
self.master = master
refresh()
frame = Frame(master)
frame.pack()
# variable to store checkbox value
self.keeplogin = IntVar()
self.UserLabel = Label(frame,
text="Username")
self.PassLabel = Label(frame,
text="Password")
self.HashLabel = Label(frame,
text="HashCode")
self.UserLabel.grid(row=0,column=0,sticky=W)
self.PassLabel.grid(row=1,column=0,sticky=W)
self.HashLabel.grid(row=2,column=0,sticky=W)
self.UserEntry = Entry(frame)
self.PassEntry = Entry(frame,show='*')
self.HashEntry = Entry(frame)
self.UserEntry.grid(row=0,column=1,columnspan=2)
self.PassEntry.grid(row=1,column=1,columnspan=2)
self.HashEntry.grid(row=2,column=1,columnspan=2)
self.ImgBox = ImageTk.PhotoImage(file='image.png')
self.ImgLabel = Label(frame, image=self.ImgBox)
self.ImgLabel.image = self.ImgBox
self.ImgLabel.grid(row=3,column=0,columnspan=2)
self.RefreshBtn = Button(frame, text="Refresh",command=self.refresh)
self.RefreshBtn.grid(row=3,column=2,sticky=W+E)
self.KeepLoginChkBtn = Checkbutton(frame,text='KeepLogin',variable=self.keeplogin)
self.KeepLoginChkBtn.grid(row=4,column=0)
self.LoginBtn = Button(frame,text='Login',command=self.login)
self.LoginBtn.grid(row=4,column=1,columnspan=2,sticky=W+E)
def refresh(self):
global IMAGE_HASH
html = rq.get('http://bt.byr.cn/login.php').text
soup = BeautifulSoup(html)
IMAGE_HASH = soup.select('input[name="imagehash"]')[0]['value']
with open('image.png','wb') as f:
r = rq.get('http://bt.byr.cn/image.php?action=regimage&imagehash='+IMAGE_HASH)
# f.write(io.StringIO(r.content))
f.write(r.content)
print(IMAGE_HASH)
self.ImgBox = ImageTk.PhotoImage(file='image.png')
self.ImgLabel.config(image=self.ImgBox)
def login(self):
global IMAGE_HASH
global COOKIES
username = self.UserEntry.get()
password = self.PassEntry.get()
hashcode = self.HashEntry.get()
'''
The login form-data are here:
username:hansnow
password:***
imagestring:72b6c3
imagehash:70534bea566661cdc83a86785ba48090
'''
payload = {"username": username,
"password": password,
"imagestring": hashcode,
"imagehash": IMAGE_HASH}
r = rq.post('http://bt.byr.cn/takelogin.php',data=payload,allow_redirects=False)
if not ('图片代码无效' in r.text):
COOKIES = rq.utils.dict_from_cookiejar(r.cookies)
if self.keeplogin.get():
with open('cookies.txt','w') as f:
f.write(json.dumps(COOKIES))
print(r.text)
print('login success')
self.master.destroy()
else:
print(r.text)
print('login failed')
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
self.createWidgets()
def generate(self):
n = int(self.menu_gen.get())
seed = self.inp_seed.get()
self.output = Generator.convert(seed, n)
if len(self.output) > 0:
self.generated = True
self.butt_draw.config( state= 'normal')
self.chek_fullscrn.config(state= 'normal')
self.clearOutput(self.output)
def draw(self, n, step=False):
p1, p2 = Draw.move(n)
self.curr_canvas.create_line(p1[0], p1[1], p2[0], p2[1], fill= self.color, width= self.thick)
if step:
self.curr_canvas.update_idletasks()
def do(self, action, step, rainbow):
if len(action) > 1:
p = action[1]
else:
p = 1.0
self.timebuff += step
cmd = action[0].lower()
if cmd == "draw":
if rainbow:
self.incColor()
if self.incThickYN:
self.incThick(self.reverseThick, False)
elif self.incThickYN:
self.incThick(self.reverseThick, True)
if self.timebuff > 1.0:
truncate = int(self.timebuff)
self.after(truncate, self.draw(float(p), True))
self.timebuff -= truncate
else:
self.draw(float(p))
elif cmd == "turn":
Draw.turn(float(p))
elif cmd == "skip":
Draw.skip(float(p))
elif cmd == "back":
Draw.back(float(p))
elif cmd == "color":
if not rainbow:
self.color = Color.getHexString(p)
elif cmd == "thick":
self.thick = int(p)
else:
print("Unknown command " + cmd)
def drawAll(self, newWindow= True):
if self.generated == True:
self.butt_print.config(state= 'disabled')
self.timebuff = 0.0
self.color = Color.white()
self.thick = 2
l = float(self.slid_linesize.get())
a = float(self.slid_angle.get())
Draw.init(self.startingPoint, l, a)
if self.fullScreen.get() == 1:
if newWindow:
self.curr_canvas = dc.BigCanvas(self).canvas
self.canvas.delete("all")
else:
self.curr_canvas = self.canvas
self.curr_canvas.delete("all")
self.curr_canvas.config(bg= Color.getHexString(self.bgColor.get()))
rainbow = self.rainbowCheck.get() == 1
if rainbow or self.incThickYN:
self.incStep = 1.0/float(self.getDrawCount(self.output))
self.percent = 0.0
for c in self.output:
if c == '[':
Draw.push()
elif c == ']':
Draw.pop()
else:
for r in Rule.getDrawings():
if c == r[0]:
if len(r) > 2:
params = (r[1], r[2])
else:
params = (r[1],)
s = float(self.slid_timer.get())
self.do(params, s, rainbow)
break
self.butt_print.config(state= 'normal')
def incColor(self):
self.color = Color.getValueByPercent(self.percent)
self.percent += self.incStep
def incThick(self, reverse, incYN):
maxthick = 5
minthick = 1
diff = maxthick - minthick
if reverse:
result = maxthick - int(diff * self.percent)
else:
result = minthick + int(diff * self.percent)
self.thick = result
if incYN:
self.percent += self.incStep
def getDrawCount(self, s):
draw_commands = []
for r in Rule.getDrawings():
if r[1].lower() == "draw":
draw_commands.append(r[0])
draw_count = 0;
for c in s:
for d in draw_commands:
if c == d:
draw_count += 1
break
return draw_count
def clearOutput(self, replacement=None):
self.text_output.config(state= 'normal')
self.text_output.delete(1.0, END)
if replacement:
self.text_output.insert(END, replacement)
self.text_output.config(state= 'disabled')
def formatRules(self, rules):
ret = []
for r in rules:
entry = r[0] + " | " + r[1]
if len(r) > 2:
entry += " " + r[2]
ret.append(entry)
return ret
def getRuleFromFormatted(self, s):
if s:
rule = s.split('|')
rule[0] = rule[0].strip()
rule[1] = rule[1].strip()
prod = rule[1].split(" ")
if len(prod) == 1:
return (rule[0], prod[0])
else:
return (rule[0], prod[0], prod[1])
def RefreshLists(self):
self.list_prod.delete(0, END)
self.list_draw.delete(0, END)
l = self.formatRules(Rule.getProductions())
for p in l:
self.list_prod.insert(END, p)
l = self.formatRules(Rule.getDrawings())
for d in l:
self.list_draw.insert(END, d)
def AddProductionRule(self, edit=None):
rule = dp.AddProductionRuleDialog(self, edit).result
if rule:
if edit:
Rule.removeProd(edit[0])
Rule.AddProduction(rule)
self.RefreshLists()
def AddDrawingRule(self, edit=None):
rule = dd.AddDrawingRuleDialog(self, edit).result
if rule:
if edit:
Rule.removeDraw(edit[0])
Rule.AddDrawing(rule)
self.RefreshLists()
def EditProductionRule(self):
s = self.list_prod.curselection()
if s:
idx = s[0]
rule = (idx,) + self.getRuleFromFormatted(self.list_prod.get(idx))
if rule:
self.AddProductionRule(rule)
def EditDrawingRule(self):
s = self.list_draw.curselection()
if s:
idx = s[0]
rule = (idx,) + self.getRuleFromFormatted(self.list_draw.get(idx))
if rule:
self.AddDrawingRule(rule)
def DeleteProductionRule(self):
s = self.list_prod.curselection()
if s:
Rule.removeProd(s[0])
self.RefreshLists()
def DeleteDrawingRule(self):
s = self.list_draw.curselection()
if s:
Rule.removeDraw(s[0])
self.RefreshLists()
def packOutput(self):
ret = ""
ret += self.packAxiom()
ret += self.packProdRules()
ret += self.packDrawRules()
return ret
def packAxiom(self):
return "@" + str(self.inp_seed.get()).strip()
def packRules(self, rules):
ret = "@"
for r in rules:
ret += "$" + str(r[0]) + "|" + str(r[1])
if len(r) > 2:
ret += ":" + str(r[2])
return ret
def packProdRules(self):
return self.packRules(Rule.getProductions())
def packDrawRules(self):
return self.packRules(Rule.getDrawings())
def parseProdRules(self, raw):
rules = raw.split('$')
for rule in rules:
if rule is not "":
r = rule.split('|')
Rule.AddProduction((r[0], r[1]))
def parseDrawRules(self, raw):
rules = raw.split('$')
for rule in rules:
if rule is not "":
r = rule.split('|')
p = r[1].split(':')
if len(p) == 1:
tup = (r[0], p[0])
else:
tup = (r[0], p[0], p[1])
Rule.AddDrawing(tup)
def parseSaveFile(self, s):
Rule.wipe()
settings = s.split('@')
self.inp_seed.set(str(settings[1]))
self.parseProdRules(settings[2])
self.parseDrawRules(settings[3])
self.RefreshLists()
def save(self):
try:
filename = filedialog.asksaveasfilename(**self.file_options['txt'])
if filename:
f = open(filename, 'w')
f.write(self.packOutput())
f.close()
except Exception as e:
print("File IO error in save\n", e)
def load(self):
try:
filename = filedialog.askopenfilename(**self.file_options['txt'])
if filename:
f = open(filename, 'r')
self.parseSaveFile(f.read())
f.close()
self.slid_linesize.set(1.0)
self.slid_timer.set(0.0)
self.menu_gen.set(1)
self.clearOutput()
except Exception as e:
print("File IO error in load\n" + e)
def help(self):
help.HelpDialog(self)
def saveImage(self):
filename = filedialog.asksaveasfilename(**self.file_options['ps'])
self.curr_canvas.postscript(file=filename, colormode='color')
def click(self, event):
self.startingPoint = (event.x, event.y)
def clickAndRedraw(self, event):
self.click(event)
self.drawAll(False)
def fileOptions(self):
self.file_options = {}
txt_options = {}
ps_options = {}
txt_options['defaultextension'] = '.txt'
txt_options['filetypes'] = [('Plaintext', '.txt')]
txt_options['initialdir'] = 'Patterns'
ps_options['defaultextension'] = '.ps'
ps_options['filetypes'] = [('Postscript Image', '.ps')]
ps_options['initialdir'] = 'Images'
self.file_options['txt'] = txt_options
self.file_options['ps'] = ps_options
def makeMenuBar(self):
self.menubar = Menu(self);
self.menubar.add_command(label="Save", command= self.save)
self.menubar.add_command(label="Load", command= self.load)
self.menubar.add_command(label="Help", command= self.help)
root.config(menu= self.menubar)
def makeInputFrame(self):
self.inp_seed = String()
self.bgColor = String()
self.gen_value = Int()
self.rainbowCheck = Int()
self.fram_input = Frame(self, bd= 2, relief= self.style, width= input_frame_width, height= input_frame_height)
self.fram_seed = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_prod = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_draw = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_drawParams = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_gen = Frame(self.fram_input, bd= 1, relief= self.style)
self.fram_output = Frame(self.fram_input, bd= 1, relief= self.style)
self.menu_gen = DropDown(self.fram_gen, textvariable= self.gen_value, state= 'readonly')
self.entr_seed = Input(self.fram_seed, textvariable= self.inp_seed)
self.text_output = Output(self.fram_output, width= 35, height= 10)
self.scrl_output = Scrollbar(self.fram_output)
self.list_prod = List(self.fram_prod, selectmode= BROWSE, font= "Courier 8", height= 5)
self.list_draw = List(self.fram_draw, selectmode= BROWSE, font= "Courier 8", height= 5)
self.slid_linesize = Slider(self.fram_drawParams, from_= 0.1, to= 10.0, orient= HORIZONTAL, resolution= 0.1, length= 180)
self.slid_timer = Slider(self.fram_drawParams, from_= 0, to= 2, orient= HORIZONTAL, resolution= 0.02, length= 180)
self.slid_angle = Slider(self.fram_drawParams, from_= 0, to= 359, orient= HORIZONTAL, length= 180)
self.entr_bgcolor = Input (self.fram_drawParams, textvariable= self.bgColor)
self.butt_prodAdd = Button(self.fram_prod, text= "Add", width=8, command= self.AddProductionRule)
self.butt_prodEdit = Button(self.fram_prod, text= "Edit", width=8, command= self.EditProductionRule)
self.butt_prodDelete = Button(self.fram_prod, text= "Delete", width=8, command= self.DeleteProductionRule)
self.butt_drawAdd = Button(self.fram_draw, text= "Add", width=8, command= self.AddDrawingRule)
self.butt_drawEdit = Button(self.fram_draw, text= "Edit", width=8, command= self.EditDrawingRule)
self.butt_drawDelete = Button(self.fram_draw, text= "Delete", width=8, command= self.DeleteDrawingRule)
self.chek_incColor = CheckBox(self.fram_draw, text= "Rainbow", variable= self.rainbowCheck)
Label(self.fram_seed, text= "Axiom:", width=8).grid (row=0, column=0)
Label(self.fram_prod, text= "Production\nRules:", width=8).grid (row=0, column=0)
Label(self.fram_draw, text= "Drawing\nRules:", width=8).grid (row=0, column=0)
Label(self.fram_drawParams, text= "Line Size:").grid (row=0, column=0)
Label(self.fram_drawParams, text= "Delay (ms):").grid (row=1, column=0)
Label(self.fram_drawParams, text= "Starting Angle:").grid (row=2, column=0)
Label(self.fram_drawParams, text= "Background Color:").grid (row=3, column=0)
Label(self.fram_output, text= "Output:").grid (row=0, column=0)
Label(self.fram_gen, text= "Generations:").grid (row=0, column=0)
self.gen_value.set(1)
self.menu_gen['values'] = tuple(range(1, 13))
self.slid_linesize.set(1.0)
self.bgColor.set( Color.default() )
self.text_output.config(state='disabled', yscrollcommand= self.scrl_output.set)
self.scrl_output.config(command=self.text_output.yview)
self.fram_input.grid (row=0, column=0)
self.fram_seed.grid (row=1, column=0, sticky= 'ew')
self.fram_prod.grid (row=2, column=0, sticky= 'ew')
self.fram_draw.grid (row=3, column=0, sticky= 'ew')
self.fram_drawParams.grid (row=4, column=0, sticky= 'ew')
self.fram_gen.grid (row=5, column=0, sticky= 'ew')
self.fram_output.grid (row=6, column=0, sticky= 'ew')
self.entr_seed.grid (row=0, column=1, sticky= 'ew')
self.list_prod.grid (row=0, column=1, sticky= 'ew')
self.butt_prodAdd.grid (row=1, column=0, sticky= 'ew')
self.butt_prodEdit.grid (row=1, column=1, sticky= 'ew')
self.butt_prodDelete.grid (row=1, column=2, sticky= 'ew')
self.list_draw.grid (row=0, column=1)
self.butt_drawAdd.grid (row=1, column=0, sticky= 'ew')
self.butt_drawEdit.grid (row=1, column=1, sticky= 'ew')
self.butt_drawDelete.grid (row=1, column=2, sticky= 'ew')
self.chek_incColor.grid (row=0, column=2)
self.slid_linesize.grid (row=0, column=1, sticky= 'ew')
self.slid_timer.grid (row=1, column=1, sticky= 'ew')
self.slid_angle.grid (row=2, column=1, sticky= 'ew')
self.entr_bgcolor.grid (row=3, column=1, sticky= 'ew')
self.menu_gen.grid (row=0, column=1, sticky= 'ew')
self.text_output.grid (row=1, column=0)
self.scrl_output.grid (row=1, column=1, sticky= 'ns')
def makeCanvasFrame(self):
self.fram_canvas = Frame(self, bd=10, relief=self.style)
self.canvas = Canvas(self.fram_canvas, width= canvas_width, height= canvas_height)
self.fram_canvas.grid(row=0, column=1, sticky='nesw')
self.canvas.grid(sticky='nesw')
self.canvas.bind("<Button-1>", self.click)
self.curr_canvas = self.canvas
def makeIgnitionFrame(self):
self.fullScreen = Int()
self.fram_ignition = Frame(self, bd=4, relief=self.style, width= ignition_frame_width, height= ignition_frame_height)
self.butt_generate = Button(self.fram_ignition, text= " -- GENERATE -- ", width=111, command= self.generate)
self.butt_draw = Button(self.fram_ignition, text= " -- DRAW -- ", width=100, command= self.drawAll, state= 'disabled')
self.butt_print = Button(self.fram_ignition, text= "Save Image", command= self.saveImage, state= 'disabled')
self.chek_fullscrn = CheckBox(self.fram_ignition, text= "Fullscreen", variable= self.fullScreen, state= 'disabled')
self.fram_ignition.grid(row=1, column=0, columnspan=2)
self.butt_generate.grid(row=0, column=0, columnspan=2)
self.butt_draw.grid( row=1, column=0)
self.butt_print.grid( row=0, column=2, rowspan= 2, sticky='ns')
self.chek_fullscrn.grid(row=1, column=1)
def createWidgets(self):
self.incThickYN = False
self.reverseThick = False
self.style = RIDGE
self.startingPoint = (20, 20)
self.generated = False
self.fileOptions()
self.makeMenuBar()
self.makeInputFrame()
self.makeCanvasFrame()
self.makeIgnitionFrame()
class Main:
def __init__(self, master): # we will define everything in the UI below
logger.info("Program start")
self.master = master
self.master.wm_title("Lautaloader v.1.03") # title of window
self.master.resizable(width=FALSE, height=FALSE) # window is not resizable
self.master.geometry('420x240') # resolution of the window in pixels
self.master.grid_propagate(False) # window will not resize in any case
self.r_selection = IntVar() # these are radiobuttons and checkbuttons
self.c1_selection = IntVar()
self.c2_selection = IntVar()
self.c1_selection.set(0) # checkbuttons will be off at launch
self.c2_selection.set(0)
self.r_selection.set(1) # we need one radiobutton selected at start
self.status_text = StringVar() # status text is visible at the bottom of GUI
self.status_text.set('Ready to work') # we can (and will) set the status text like this
self.save_folder = '' # we will save into this folder
self.filenames = [] # this is our folder filenames list
self.url_text = StringVar()
self.num_pics = 0
self.num_mp4 = 0
self.num_mp3 = 0
self.image_url = ''
self.name_of_file = ''
self.res = ''
self.imagefile = ''
self.filesize = ''
self.imagewritten = False
self.read_timeout = 1.0
self.headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) '
'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36',
'Upgrade-Insecure-Requests': '1',
'Referer': '',
'DNT': '1',
'Accept-Language': 'fi-FI,fi;q=0.8,en-US;q=0.6,en;q=0.4',
'Accept-Encoding': 'gzip, deflate, sdch',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8'
} # need to send some headers or server refuses connection
self.lf = LabelFrame(master, text=' Get ')
self.lf.grid(row=1, column=1, rowspan=4)
self.lf2 = LabelFrame(master, text=' Options ')
self.lf2.grid(row=1, column=2)
self.R1 = Radiobutton(self.lf, text="All", variable=self.r_selection, value=1)
self.R1.grid(row=1, column=1, sticky=W)
self.R2 = Radiobutton(self.lf, text="only img", variable=self.r_selection, value=2)
self.R2.grid(row=2, column=1, sticky=W)
self.R3 = Radiobutton(self.lf, text="only mp4", variable=self.r_selection, value=3)
self.R3.grid(row=3, column=1, sticky=W)
self.R4 = Radiobutton(self.lf, text="only mp3", variable=self.r_selection, value=4)
self.R4.grid(row=4, column=1, sticky=W)
self.C1 = Checkbutton(self.lf2, text="Create new filenames", variable=self.c1_selection,
state=NORMAL, onvalue=1, offvalue=0)
self.C1.grid(row=1, column=2, sticky=W)
self.C2 = Checkbutton(self.lf2, text="Overwrite if found", variable=self.c2_selection,
state=NORMAL, onvalue=1, offvalue=0)
self.C2.grid(row=2, column=2, sticky=W)
self.folder_label = Label(master, text="Folder: ")
self.folder_label.grid(row=5, sticky=E)
self.url_label = Label(root, text="URL: ")
self.url_label.grid(row=6, sticky=E)
self.folder_entry = Entry(master, textvariable=self.save_folder, state="readonly", width=50)
self.folder_entry.grid(row=5, column=1, columnspan=2)
self.url_entry = Entry(master, textvariable=self.url_text, width=50)
self.url_entry.grid(row=6, column=1, columnspan=2)
self.selectbutton = Button(master, text="Select..", state=NORMAL, command=self.get_folder)
self.selectbutton.grid(row=5, column=3, sticky=W)
self.openfolderbutton = Button(master, text="Open folder", state=DISABLED, command=self.openfolder)
self.openfolderbutton.grid(row=3, column=2, sticky=W, padx=22)
self.urlbutton = Button(master, text="Download", state=DISABLED, command=self.logic)
self.urlbutton.grid(row=6, column=3, sticky=W)
self.status = Label(master, textvariable=self.status_text, wraplength=300)
self.status.grid(row=9, columnspan=4, sticky=W)
self.progressbar = Progressbar(master, orient="horizontal", length=100, mode="determinate")
self.progressbar.grid(row=8, sticky='we', columnspan=3, pady=3)
self.manage_config() # process through config file
self.url_1 = config.get('basic_config', 'url_1')
logging.debug("url_1 set to %s" % self.url_1)
self.url_2 = config.get('basic_config', 'url_2')
logging.debug("url_2 set to %s" % self.url_2)
if self.save_folder != '': # if save folder is not empty, we probably have a valid folder
self.urlbutton['state'] = 'normal' # so we can enable urlbutton already
self.openfolderbutton['state'] = 'normal' # and we can also enable open folder button
def manage_config(self):
if not os.path.isfile(os.path.expanduser("~\\documents\\lloader_cfg.ini")):
with open((os.path.expanduser("~\\documents\\lloader_cfg.ini")), 'w') as cfgfile:
config.add_section('basic_config') # cfg file not exists so we make it
config.set('basic_config', 'save_folder', self.save_folder)
config.set('basic_config', 'html_tag1', ".filecontainer figcaption a")
config.set('basic_config', 'html_tag2', ".filecontainer .file a")
config.set('basic_config', 'url_1', "ylilauta.org")
config.set('basic_config', 'url_2', "www.ylilauta.org")
# .filecontainer .file a = ALL images (np included) but not mp4
# .filecontainer figcaption a = not np images, but all uploaded images & mp4
config.write(cfgfile)
logger.debug("Created a config file")
else:
try:
config.read(os.path.expanduser('~\\documents\\lloader_cfg.ini'))
self.folder_entry['state'] = 'normal' # make the folder field writable
self.folder_entry.delete(0, END)
self.save_folder = config.get('basic_config', 'save_folder') # get save folder from file
self.folder_entry.insert(0, self.save_folder) # write to folder field
self.folder_entry['state'] = 'readonly' # make it read-only again
logger.debug("Read from config")
except (IOError, OSError):
logger.exception("Config error")
except (configparser.MissingSectionHeaderError, configparser.NoSectionError): # correct section not found from file
os.remove(os.path.expanduser("~\\documents\\lloader_cfg.ini"))
self.manage_config() # delete file and try to create it from start
def get_folder(self):
dir_opt = options = {} # define options for get folder function
options['initialdir'] = self.save_folder
options['mustexist'] = False
options['parent'] = self.master
options['title'] = 'Choose a directory'
self.save_folder = filedialog.askdirectory(**dir_opt) # actual function to get the folder name
with open((os.path.expanduser("~\\documents\\lloader_cfg.ini")), 'w') as cfgfile:
config.set('basic_config', 'save_folder', self.save_folder)
config.write(cfgfile) # write new save folder to config file
self.folder_entry['state'] = 'normal' # make the folder field writable
self.folder_entry.delete(0, END)
self.folder_entry.insert(0, self.save_folder) # update folder field
self.folder_entry['state'] = 'readonly' # make it read-only again
self.clear_savefolder_list()
self.openfolderbutton['state'] = 'normal' # we can now press the open folder and url buttons
self.urlbutton['state'] = 'normal' # because we have defined a save folder
def openfolder(self):
os.startfile(self.save_folder) # opens the save folder
def clear_savefolder_list(self):
del self.filenames[:] # clears the list of files in a folder
self.filenames.append(next(os.walk(self.save_folder))[2]) # adds every file in folder to list
def check_for_url(self):
parse = urlparse(self.url_texti.lower()) # checks if url is ylilauta
logging.debug("url started with %s" % parse.netloc)
if (parse.netloc.startswith(self.url_1) or
parse.netloc.startswith(self.url_2)):
return True
else:
return False
def is_image(self):
if (self.image_url.lower().endswith(".jpg") or
self.image_url.lower().endswith(".jpeg") or
self.image_url.lower().endswith(".png")): # link seems to be image
return True
else:
return False
def is_mp4(self):
if self.image_url.lower().endswith(".mp4"): # link ends in mp4 so its mp4
return True
else:
return False
def is_mp3(self):
if self.image_url.lower().endswith(".mp3"): # link ends in mp3 so its mp3
return True
else:
return False
def we_want_it_anyway(self):
if self.c2_selection.get() == 1: # checkbutton2 is selected so we want all files
return True
else:
return False
def getting_both(self):
if self.r_selection.get() == 1: # first radio button is selected so dl both
return True
else:
return False
def getting_img(self):
if self.r_selection.get() == 2: # second radio button is selected so dl images only
return True
else:
return False
def getting_mp4(self):
if self.r_selection.get() == 3: # third radio button is selected so dl mp4 only
return True
else:
return False
def getting_mp3(self):
if self.r_selection.get() == 4: # fourth radio button is selected so we get mp3 only
return True
else:
return False
def rename_file(self):
get_filetype = os.path.splitext(os.path.basename(self.image_url))[1] # get filetype
new_file_name_start = ''
for i in range(0, 15):
new_file_name_start += str(random.randint(0, 9)) # create random string of numbers
self.name_of_file = (new_file_name_start + get_filetype) # create the whole new name
def write_file(self):
self.status_text.set('Downloading %s' % self.name_of_file)
logger.info('Downloading %s' % self.name_of_file)
self.master.update()
self.res = requests.get(self.image_url)
self.res.raise_for_status()
try:
with open(os.path.join(self.save_folder,
self.name_of_file), 'wb') as self.imagefile:
for chunk in self.res.iter_content(100000):
self.imagefile.write(chunk)
self.imagewritten = True
except IOError:
logger.exception("Exception with file write")
self.status_text.set('File error')
self.master.update()
def file_get_logic(self):
self.clear_savefolder_list() # need to update this list between files
self.imagewritten = False # need to change this here because if same thread has same pictures
if self.c1_selection.get() == 1: # if want new random name
self.rename_file()
else:
self.name_of_file = os.path.basename(self.image_url) # using default filename
if self.name_of_file in self.filenames[0]: # file exists
if self.c2_selection.get() == 1: # we want to overwrite
self.write_file()
else:
pass
elif self.name_of_file not in self.filenames[0]: # file does not exist in folder
self.write_file() # so we take it in
self.master.update()
def connect_logic(self):
try:
self.res = requests.get(self.url_texti, headers=self.headers,
timeout=(10.0, self.read_timeout))
self.res.raise_for_status()
except (requests.exceptions.ReadTimeout, requests.exceptions.HTTPError):
logger.exception("Connection exception")
self.status_text.set("Network error %s" % self.res.status_code)
self.master.update()
def logic(self):
self.clear_savefolder_list()
self.num_pics = 0 # make these 0 because we just called the function
self.num_mp4 = 0
self.num_mp3 = 0
self.imagewritten = False
self.url_texti = ''
self.progressbar["value"] = 0
done = False
if self.url_text != '':
self.url_texti = (self.url_text.get()) # if url text is not empty we will set it to variable
if not self.url_text or self.check_for_url() is False: # if url is wrong or empty
self.status_text.set('URL not supported')
logger.debug("URL is false: %s" % self.url_texti)
while not done and self.check_for_url() is True:
self.urlbutton['state'] = 'disabled' # disable buttons so they cant be pressed while run
self.selectbutton['state'] = 'disabled' # we will enable them again in the end
self.R1['state'] = 'disabled'
self.R2['state'] = 'disabled'
self.R3['state'] = 'disabled'
self.R4['state'] = 'disabled'
self.C1['state'] = 'disabled'
self.C2['state'] = 'disabled'
self.url_entry['state'] = 'readonly'
self.status_text.set(("Getting from %s" % self.url_texti))
self.progressbar['value'] = 0
self.master.update()
self.connect_logic()
soup = bs4.BeautifulSoup(self.res.text, 'html.parser') # create soup
total_stuff = 0
html_tag1 = config.get('basic_config', 'html_tag1') # we will fetch from these tags
html_tag2 = config.get('basic_config', 'html_tag2')
list_of_links = []
for imglink in soup.select(html_tag1): # grab items from tags and put them to list
if imglink.get('href') not in list_of_links:
list_of_links.append(str(imglink.get('href')))
for imglink in soup.select(html_tag2):
if imglink.get('href') not in list_of_links:
list_of_links.append(str(imglink.get('href')))
try:
list_of_links = [x for x in list_of_links if x != "None"] # clear "none"s from list
except ValueError: # there is no "none" in list
pass
total_stuff = len(list_of_links) # variable helps with progressbar
logger.debug("total stuff is: %s" % total_stuff)
for link in list_of_links: # iterate through list of links
link = 'http:' + link # make item a valid link
self.image_url = link # file get logic still uses global variable lol
if (link.lower().endswith('.jpg') or
link.lower().endswith('png') or
link.lower().endswith('jpeg')): # we have an image
if self.getting_both() or self.getting_img(): # we want an image
self.file_get_logic() # we get an image
if self.imagewritten: # logic is complete and image is written
self.num_pics += 1
if link.lower().endswith('.mp4'): # same as above but with mp4
if self.getting_both() or self.getting_mp4():
self.file_get_logic()
if self.imagewritten:
self.num_mp4 += 1
if link.lower().endswith('.mp3'):
if self.getting_both() or self.getting_mp3():
self.file_get_logic()
if self.imagewritten:
self.num_mp3 += 1
self.progressbar['value'] += 100 / total_stuff # progressbar fills
self.status_text.set('Downloaded %s images, %s mp4, %s mp3.' % (self.num_pics,
self.num_mp4,
self.num_mp3))
self.urlbutton['state'] = 'normal'
self.url_entry['state'] = 'normal'
self.selectbutton['state'] = 'normal'
self.R1['state'] = 'normal'
self.R2['state'] = 'normal'
self.R3['state'] = 'normal'
self.R4['state'] = 'normal'
self.C1['state'] = 'normal'
self.C2['state'] = 'normal' # we have enabled all buttons to be used again
logger.info("Done.")
break
logging.shutdown()
class App:
def __init__(self, master):
frame = Frame(master, borderwidth=5)
frame.grid(column=0, row=0, pady=5)
self.state = []
self.states = 256
self.laststate = 2 # 0=Black, 1=White, 2=Transp.
self.size = 16
self.gridsz = 20
for x in range(1024):
self.state.append(2)
self.screen = Canvas(frame, height=320, width=320, bg=color[2])
self.screen.bind("<Button-1>", self.scrnclick1)
self.screen.bind("<Button-3>", self.scrnclick2)
self.screen.bind("<B1-Motion>", self.scrndrag)
for x in range(16):
self.screen.create_line((x * 20, 0, x * 20, 320), fill=color[3])
self.screen.create_line((0, x * 20, 320, x * 20), fill=color[3])
self.screen.grid(row=0, column=0, columnspan=5)
frame2 = Frame(master, borderwidth=5)
frame2.grid(column=0, row=1, pady=5)
self.clear = Button(frame2, text="Clear", command=self.clearit)
self.clear.grid(row=0, column=0, pady=20)
self.doit = Button(frame2, text="Print", command=self.doit)
self.doit.grid(row=0, column=1, pady=20)
#self.doitlab = Label(frame2, text="(Output to stdout)");
#self.doitlab.grid(row=1, column=1);
self.parse = Button(frame2, text="Parse", command=self.parsetext)
self.parse.grid(row=0, column=2, pady=20)
self.large = 0
self.dummy = IntVar()
self.largeb = Checkbutton(frame2, text="Large", var=self.dummy, command=self.changesize)
self.largeb.grid(row=0, column=3, pady=20)
self.prev = Canvas(frame2, height=17, width=17, bg=color[2], relief=RIDGE)
self.prev.grid(row=0, column=4, pady=20, padx=20)
# DataParsers
self.bmlabel = Label(frame2, text="Bitmap Data (paste hex from code)")
self.bmlabel.grid(row=2, column=0, columnspan=5, sticky="W")
self.bmentry = Text(frame2, width=80, height=9, font="Times 8")
self.bmentry.bind("<Leave>", self.bmtextpaste)
self.bmentry.grid(row=3, column=0, columnspan=5, pady=5)
self.msklabel = Label(frame2, text="Mask Data (paste hex from code)")
self.msklabel.grid(row=4, column=0, columnspan=5, sticky="W")
self.mskentry = Text(frame2, width=80, height=9, font="Times 8")
self.mskentry.bind("<Leave>", self.msktextpaste)
self.mskentry.grid(row=5, column=0, columnspan=5, pady=5)
def changesize(self):
self.large = ~self.large
if self.large:
self.size = 32
self.gridsz = 10
self.states = 1024
oldstate = self.state
self.state = []
for n in range(1024):
col = (n // 2) % 16
row = int(n // 64)
self.state.append(oldstate[16 * row + col])
oldstate = []
else:
self.size = 16
self.gridsz = 20
self.states = 256
oldstate = self.state
self.state = []
for n in range(1024):
if not((n % 2) or ((n // 32) % 2)):
self.state.append(oldstate[n])
for n in range(256, 1024):
self.state.append(2)
oldstate = []
# Insert scaling here
self.updatescrn()
self.prev.config(width=self.size + 1, height=self.size + 1)
for n in range(self.states):
self.updateprev(n)
#self.prev.grid(row=0, column=4, padx=self.gridsz, pady=self.gridsz)
def scrnclick1(self, event):
self.scrnclick(event, 1)
def scrnclick2(self, event):
self.scrnclick(event, -1)
def scrnclick(self, event, direction):
if (event.x > 319) or (event.y > 319) or (event.x < 0) or (event.y < 0):
return
n = (event.x // self.gridsz) + self.size * (event.y // self.gridsz)
self.state[n] += direction
self.state[n] %= 3
row = n % self.size
col = n // self.size
self.screen.create_rectangle((self.gridsz * row + 1,
self.gridsz * col + 1,
self.gridsz * row + self.gridsz - 1,
self.gridsz * col + self.gridsz - 1),
fill=color[self.state[n]], outline="")
self.laststate = self.state[n]
self.updateprev(n)
def scrndrag(self, event):
if (event.x > 319) or (event.y > 319) or (event.x < 0) or (event.y < 0):
return
n = (event.x // self.gridsz) + self.size * (event.y // self.gridsz)
row = n % self.size
col = n // self.size
self.screen.create_rectangle((self.gridsz * row + 1,
self.gridsz * col + 1,
self.gridsz * row + self.gridsz - 1,
self.gridsz * col + self.gridsz - 1),
fill=color[self.laststate], outline="")
self.state[n] = self.laststate
self.updateprev(n)
def updateprev(self, n):
x = n % self.size + 1
y = n // self.size + 1
if self.large:
pad = 12
else:
pad = 20
self.prev.create_line(x + 1, y + 1, x + 2, y + 1, fill=color[self.state[n]])
self.prev.grid(row=0, column=4, padx=pad, pady=pad)
def updatescrn(self):
self.screen.create_rectangle(0, 0, 320, 320, fill=color[2])
for x in range(self.size):
self.screen.create_line((x * self.gridsz, 0, x * self.gridsz, 320), fill=color[3])
self.screen.create_line((0, x * self.gridsz, 320, x * self.gridsz), fill=color[3])
for n in range(self.states):
row = n % self.size
col = n // self.size
self.screen.create_rectangle((self.gridsz * row + 1,
self.gridsz * col + 1,
self.gridsz * row + self.gridsz - 1,
self.gridsz * col + self.gridsz - 1),
fill=color[self.state[n]], outline="")
def bmtextpaste(self, event):
string = self.bmentry.get(1.0, END)
self.bmentry.delete(1.0, END)
string = string.replace("\t", "")
self.bmentry.insert(END, string)
def msktextpaste(self, event):
string = self.mskentry.get(1.0, END)
self.mskentry.delete(1.0, END)
string = string.replace("\t", "")
self.mskentry.insert(END, string)
def parsetext(self):
bmstring = self.bmentry.get(1.0, END)
bmstring = bmstring.replace(",", " ")
bmstring = bmstring.split()
mskstring = self.mskentry.get(1.0, END)
mskstring = mskstring.replace(",", " ")
mskstring = mskstring.split()
if len(bmstring) != len(mskstring):
print("Mismatched data. Bitmap and mask must be same size,")
return
elif not (len(bmstring) == 32 or len(bmstring) == 128):
print("Size Error, input must be 32 or 128 hex bytes. ")
return
for n in range(self.states):
self.state[n] = 0
m = 0
for entry in bmstring:
e = int(entry, 16)
for bit in range(8):
self.state[m] = (e & 1)
e = e >> 1
m += 1
m = 0
for entry in mskstring:
e = int(entry, 16)
for bit in range(8):
if not (e & 1):
self.state[m] = 2
e = e >> 1
m += 1
self.updatescrn()
for n in range(self.states):
self.updateprev(n)
def clearit(self):
for n in range(self.states):
self.state[n] = 2
self.updateprev(n)
self.updatescrn()
self.bmentry.delete(0.0, END)
self.mskentry.delete(0.0, END)
def doit(self):
mask = []
bitmap = []
numbytes = self.size * self.size // 8
for i in range(numbytes):
m = 0
b = 0
for j in range(8):
m <<= 1
b <<= 1
if (self.state[(i * 8) + (7 - j)] != 2):
m |= 1
if (self.state[(i * 8) + (7 - j)] == 1):
b |= 1
#print((i * 8) + (7 - j), self.state[(i * 8) + (7 - j)], m)
mask.append(m)
bitmap.append(b)
print("\n\nstatic char bitmap[] = {", end=' ')
for i in range(numbytes):
b1 = bitmap[i]
if not(i % 8):
print("\n\t", end=' ')
print("0x%(b1)02x, " % vars(), end=' ')
print("\n};")
print("\nstatic char mask[] = {", end=' ')
for i in range(numbytes):
b1 = mask[i]
if not(i % 8):
print("\n\t", end=' ')
print("0x%(b1)02x, " % vars(), end=' ')
print("\n};")
