class VentanaEjemplo:
def __init__(self, master):
self.master = master
master.title("Distribucion Binomial")
self.etiqueta = Label(master, text="Numero de exitos n:")
self.etiqueta.pack()
self.n= Spinbox(master, from_=0, to=100)
self.n.pack()
self.etiqueta = Label(master, text="Probabilidad de exito p:")
self.etiqueta.pack()
self.p= Spinbox(master, from_=0.1, to=10)
self.p.pack()
self.botonSaludo = Button(master, text="Graficar", command=self.Graficar)
self.botonSaludo.pack()
self.botonCerrar = Button(master, text="Cerrar", command=master.quit)
self.botonCerrar.pack()
def Graficar(self):
N, P = np.float(self.n.get()), np.float(self.p.get()) # parametros de forma
binomial = stats.binom(N, P) # Distribución
X = np.arange(binomial.ppf(0.01),
binomial.ppf(0.99))
fmp = binomial.pmf(X) # Función de Masa de Probabilidad
plt.plot(X, fmp, '--')
plt.vlines(X, 0, fmp, colors='b', lw=5, alpha=0.5)
plt.title('Distribución Binomial')
plt.ylabel('probabilidad')
plt.xlabel('valores')
plt.show()
def manualDeviceSelect(self):
window = self.createTopWindow(250, 146, "Manual Device Select")
north_frame = Frame(window)
north_frame.pack(anchor="n", pady=5, padx=10)
south_frame = Frame(window)
south_frame.pack(anchor="s", pady=5, padx=10)
label = Label(north_frame, text="Device Select")
label.pack(pady=5)
temp = []
for x in range(0, len(self.power_supplies)):
temp.append(self.power_supplies[x])
for x in range(0, len(self.electronic_loads)):
temp.append(self.electronic_loads[x])
entry = Spinbox(north_frame, values=(temp))
entry.pack(pady=5)
control_frame = Frame(south_frame)
control_frame.pack()
select = Button(
control_frame,
text="Select",
command=lambda: self.setDevice(entry))
select.pack(side=tkinter.LEFT, pady=5, padx=15)
cancel = Button(
control_frame,
text="Cancel",
command=lambda: self.destroyWindow(window))
cancel.pack(side=tkinter.LEFT, pady=5)
class GuiGenerateCount(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.pack()
#step increment len
self._stepLenFrm = Frame(self); self._stepLenFrm.pack()
self._stepLenLbl = Label(self._stepLenFrm, text="Step Len: "); self._stepLenLbl.pack(side=LEFT)
self._stepLenSpin = Spinbox(self._stepLenFrm, from_=0, to=1000); self._stepLenSpin.pack(side=LEFT)
#start value
self._startFrm = Frame(self); self._startFrm.pack()
self._startLbl = Label(self._startFrm, text="Start Value: "); self._startLbl.pack(side=LEFT)
self._startTxt = Entry(self._startFrm); self._startTxt.pack(side=LEFT)
self._startTxt.insert(0, "0")
def getSettings(self):
return { "StepLen": self._stepLenSpin.get(),
"StartValue": self._startTxt.get()
}
def getName(self):
return "Counter"
def getGeneratorFunction(self):
return generateCounter
def search_by_categoria():
def mostrar_lista(event):
v = Toplevel()
sc = Scrollbar(v)
sc.pack(side=RIGHT, fill=Y)
lb = Listbox(v, width=150, yscrollcommand=sc.set)
ix = open_dir(DIR_INDEX)
parameter = str(w.get())
with ix.searcher() as searcher:
query = QueryParser("categorias",
ix.schema).parse(f'"{parameter}"')
results = searcher.search(query, limit=None)
for r in results:
lb.insert(END, f"Título: {r['titulo']}")
lb.insert(
END,
f"Rango de fechas: {r['fecha_inicio']} - {r['fecha_fin']}")
lb.insert(END, f"Cat: {r['categorias']}")
lb.insert(END, '')
lb.pack(side=LEFT, fill=BOTH)
sc.config(command=lb.yview)
categorias = listarCategorias()
master = Tk()
w = Spinbox(master, values=categorias)
w.pack()
w.bind("<Return>", mostrar_lista)
w.pack(side=LEFT)
class LabelSpin(Frame):
def __init__(self,
parent,
width=200,
height=50,
text='spinbox',
val=(0, 100),
inc=1,
font=('Times', 12),
ratio=0.5):
Frame.__init__(self, parent, width=width, height=height)
self.pack_propagate(0)
self.f1 = Frame(self, width=int(width * ratio), height=height)
self.f1.pack_propagate(0)
self.f1.pack(side='left')
self.f2 = Frame(self, width=int(width * (1 - ratio)), height=height)
self.f2.pack_propagate(0)
self.f2.pack(side='left')
self.lb = Label(self.f1, text=text, font=font)
self.lb.pack(fill='both', expand=True)
self.sp = Spinbox(self.f2,
font=font,
from_=val[0],
to=val[1],
increment=inc)
self.sp.pack(fill='both', expand=True)
def get(self):
return self.sp.get()
class FieldOptions:
def __init__(self, master, width, height):
self.frame = LabelFrame(master, text="Field option")
self.width = IntVar(value=width)
self.height = IntVar(value=height)
label_x = Label(self.frame, text="X: ")
label_x.pack(side=LEFT)
self.spin_box_width = Spinbox(self.frame,
text="width",
textvariable=self.width,
wrap=True,
to=2000,
from_=10)
self.spin_box_width.pack(side=LEFT, fill="x", expand=True)
label_y = Label(self.frame, text="Y: ")
label_y.pack(side=LEFT)
self.spin_box_height = Spinbox(self.frame,
text="height",
textvariable=self.height,
wrap=True,
to=2000,
from_=10)
self.spin_box_height.pack(side=LEFT, fill="x", expand=True)
self.frame.pack(side=TOP, fill="x", expand=True)
def get_values(self):
return self.width.get(), self.height.get()
def _create_widgets(self) -> None:
# settings
settings_frame_parent = Frame(self, bg=CONFIG['colors']['menu'])
settings_frame_child = Frame(settings_frame_parent,
bg=CONFIG['colors']['menu'])
tips_lab = Label(settings_frame_child,
text='Tips:',
bg=CONFIG['colors']['menu'],
font=CONFIG['font']['XS'])
mode_check = Checkbutton(settings_frame_child,
variable=self._mode_var,
font=CONFIG['font']['XS'],
bg=CONFIG['colors']['menu'])
rounds_count_lab = Label(settings_frame_child,
text='Rounds:',
bg=CONFIG['colors']['menu'],
font=CONFIG['font']['XS'])
rounds_count_spinbox = Spinbox(settings_frame_child,
from_=1,
to=100,
width=3,
textvariable=self._rounds_count_var,
font=CONFIG['font']['M'])
boxes_count_lab = Label(settings_frame_child,
text='Boxes:',
bg=CONFIG['colors']['menu'],
font=CONFIG['font']['XS'])
boxes_count_spinbox = Spinbox(settings_frame_child,
from_=3,
to=10,
width=3,
textvariable=self._boxes_count_var,
font=CONFIG['font']['M'])
start_but = Button(settings_frame_child,
text='START',
command=self._controller.start,
font=CONFIG['font']['S'])
# guess boxes
score_frame = Frame(self)
self._score_lab = Label(score_frame,
bg=CONFIG['colors']['score'],
text='Round: 00 | Wins: 00 | Fails: 00',
font=CONFIG['font']['M'])
# boxes
frame_boxes_parent = Frame(self)
self._frame_boxes_child = Frame(frame_boxes_parent)
# PACKED
settings_frame_parent.pack(fill='x')
settings_frame_child.pack(expand=True, padx=5, pady=5)
tips_lab.pack(side='left')
mode_check.pack(side='left')
rounds_count_lab.pack(side='left')
rounds_count_spinbox.pack(side='left', fill='y')
boxes_count_lab.pack(side='left')
boxes_count_spinbox.pack(side='left', fill='y')
start_but.pack(side='left', fill='y', padx=5)
score_frame.pack(fill='x')
self._score_lab.pack(fill='x')
frame_boxes_parent.pack(fill='both', expand=True)
self._frame_boxes_child.pack(expand=True, padx=20, pady=20)
class CustomSpinbox(Frame):
def __init__(self,
master,
*args,
label="",
minimum=0,
maximum=9999,
**kwargs):
super(CustomSpinbox, self).__init__(master, *args, **kwargs)
self.minimum = minimum
self.maximum = maximum if maximum > minimum else minimum + 1
self.create_spinbox(label)
self.register_filter()
def create_spinbox(self, label):
from tkinter import Label
self.label = Label(self, text=label, width=LABEL_WIDTH)
self.spinbox = Spinbox(self, from_=self.minimum, to=self.maximum)
self.label.pack(side="left")
self.spinbox.pack(side="left", fill="x", expand=True)
def register_filter(self):
tk = self.get_instance_tk(self)
if tk:
new_register = tk.register(self.filter_spinbox)
self.spinbox.config(validate="key",
validatecommand=(new_register, "%P"))
def filter_spinbox(self, value):
if value.isdigit() and int(value) in range(self.minimum,
self.maximum + 1):
return True
if value == "":
return True
return False
def get_instance_tk(self, widget):
from tkinter import Tk
if isinstance(widget, Tk):
return widget
else:
master = self.get_instance_tk(widget.master)
return master
def set_label(self, label):
self.label.config(text=label)
def get_value(self):
return int(self.spinbox.get())
def set_value(self, value):
if value in range(self.minimum, self.maximum + 1):
self.spinbox.delete(0, "end")
self.spinbox.insert("end", str(value))
def setup_catalog_item(self):
catalog = LabelFrame(
master=self.window,
text="Catalog Item",
font=font.Font(size=14, weight=font.BOLD),
)
frm = Frame(master=catalog)
lbl_number = Label(master=frm, text="Number:", font=self.font_style)
ent_number = Entry(
master=frm,
font=self.font_style,
width=20,
)
lbl_qtt = Label(master=frm, text="Quantity:", font=self.font_style)
spin_qtt = Spinbox(
master=frm,
from_=1,
to_=100,
width=4,
)
lbl_cost = Label(
master=frm,
text="Cost/item:",
font=self.font_style,
)
ent_cost = Entry(
master=frm,
font=self.font_style,
width=14,
state="readonly",
)
lbl_total = Label(
master=frm,
text="Total:",
font=self.font_style,
)
ent_total = Entry(
master=frm,
font=self.font_style,
width=14,
state="readonly",
)
lbl_number.pack(side=LEFT, padx=2, pady=5)
ent_number.pack(side=LEFT, padx=2, pady=5)
lbl_qtt.pack(side=LEFT, padx=2, pady=5)
spin_qtt.pack(side=LEFT, padx=2, pady=5)
lbl_cost.pack(side=LEFT, padx=2, pady=5)
ent_cost.pack(side=LEFT, padx=2, pady=5)
lbl_total.pack(side=LEFT, padx=2, pady=5)
ent_total.pack(side=LEFT, padx=2, pady=5)
frm.pack(fill=BOTH, padx=10, pady=10)
catalog.pack(fill=X, padx=20, pady=5)
def add_penalty(index):
global listed_accidents
penalties = ['Time', 'DT', 'SG10', 'SG30']
popup = Toplevel(accidents_tab)
x = window.winfo_x()
y = window.winfo_y()
popup.geometry(
"+%d+%d" %
(x + window.winfo_width() // 3.5, y + window.winfo_height() // 3))
dialog = Frame(popup, padx=20, pady=10)
dialog.pack(fill='both', anchor='center')
label = Label(dialog, text='Penalty')
label.pack(fill='both', side='left')
penalty = Combobox(dialog, values=penalties, state="readonly")
penalty.current(0)
penalty.pack(fill='both', side='left')
seconds = Spinbox(dialog,
from_=5,
to=100,
increment=5,
width=5,
state='readonly')
seconds.pack(fill='both', side='left', padx=2)
buttons = Frame(popup, padx=20, pady=5)
buttons.pack(side='bottom')
label = Label(dialog, text='To')
label.pack(fill='both', side='left')
involved_cars = listed_accidents[index][0].split(', ')
cars = Combobox(dialog, values=involved_cars, width=5)
cars.current(0)
cars.pack(fill='both', side='right', padx=2)
confirm = Button(
buttons,
text='Confirm',
command=lambda: log_accident(
index, popup,
f'Penalty: {"+"+seconds.get()+"s" if penalty.get()=="Time" else penalty.get()} to #{cars.get()}'
))
confirm.pack(fill='both', side='left', padx=2)
suggestion = Button(buttons,
text='Get commands',
command=lambda: suggest_penalty(
index, seconds.get(), penalty.get(), cars.get()))
suggestion.pack(fill='both', side='left', padx=2)
cancel = Button(buttons, text='Cancel', command=popup.destroy)
cancel.pack(fill='both', side='right', padx=2)
class SpeedWindow(ActionWindow):
def __init__(self, master):
super().__init__(master, 1)
self.edit = Spinbox(self.body, from_=2, to=10)
self.edit.pack()
def change_speed(self, track: 'Track', coef: int) -> Track:
pass
def calculate_result(self) -> Track:
track = self.selected_tracks[0]
return self.change_speed(track, int(self.edit.get()))
def add_reminder(self, date=None):
def remove():
self.alarms.remove((when, what))
rem.destroy()
rem = Frame(self.frame_alarms)
frame_when = Frame(rem, style='txt.TFrame', relief='sunken', border=1)
when = Spinbox(frame_when,
from_=0,
to=59,
width=3,
justify='center',
relief='flat',
highlightthickness=0,
validate='key',
validatecommand=(self._only_nb, '%P'))
when.pack()
when.delete(0, 'end')
what = Combobox(rem,
width=8,
state='readonly',
values=(_('minutes'), _('hours'), _('days')))
if date:
hour = int(self.start_hour.get())
minute = int(self.start_min.get())
dt = datetime.combine(self.start_entry.get_date(),
time(hour=hour, minute=minute)) - date
if dt.days > 0:
when.insert(0, str(dt.days))
what.set(_('days'))
else:
h, m, s = str(dt).split(':')
if h != "0":
when.insert(0, h)
what.set(_('hours'))
else:
when.insert(0, str(int(m)))
what.set(_('minutes'))
else:
when.insert(0, '15')
what.set(_('minutes'))
self.alarms.append((when, what))
Label(rem, text=_('Reminder:')).pack(side='left', padx=4, pady=4)
frame_when.pack(side='left', pady=4, padx=4)
what.pack(side='left', pady=4, padx=4)
Button(rem, image=self.img_moins, padding=0,
command=remove).pack(side='left', padx=4, pady=4)
rem.pack()
def add_vsc_penalty(index):
global listed_vsc
penalties = ['Time', 'DT', 'SG10', 'SG30']
popup = Toplevel(vsc_tab)
x = window.winfo_x()
y = window.winfo_y()
popup.geometry(
"+%d+%d" %
(x + window.winfo_width() // 3.5, y + window.winfo_height() // 3))
dialog = Frame(popup, padx=20, pady=10)
dialog.pack(fill='both', anchor='center')
label = Label(dialog, text='Penalty')
label.pack(fill='both', side='left')
penalty = Combobox(dialog, values=penalties, state="readonly")
penalty.current(0)
penalty.pack(fill='both', side='left')
value = StringVar(popup)
# round to nearest 5
value.set(int(5 * round(float(listed_vsc[index][1]) / 5)))
seconds = Spinbox(dialog,
from_=5,
to=100,
increment=5,
width=5,
state='readonly',
textvariable=value)
seconds.pack(fill='both', side='right', padx=2)
buttons = Frame(popup, padx=20, pady=5)
buttons.pack(side='bottom')
confirm = Button(
buttons,
text='Confirm',
command=lambda: log_vsc(
index, popup,
f'Penalty: {"+"+seconds.get()+"s" if penalty.get()=="Time" else penalty.get()}'
))
confirm.pack(fill='both', side='left', padx=2)
suggestion = Button(buttons,
text='Get commands',
command=lambda: suggest_vsc_penalty(
index, seconds.get(), penalty.get()))
suggestion.pack(fill='both', side='left', padx=2)
cancel = Button(buttons, text='Cancel', command=popup.destroy)
cancel.pack(fill='both', side='right', padx=2)
def pack(self):
key = self.parent.app.environment.get_var_key(self.variable)
if (self.parent.app.environment.is_visible(key)):
label = Label(master=self.parent, cnf={
'text': self.label,
})
label.pack()
w = Spinbox(self.parent,
from_=0,
to=1000000,
textvariable=self.variable,
command=self.parent.app.reload)
w.bind('<FocusOut>', self.parent.app.reload)
w.pack()
def open_appointment():
global tab_2_button_message
if tab_2_treeview.focus() == '':
tab_2_button_message.set("Please select an appointment")
else:
add_appointments_button["state"] = "disabled"
open_appointments_button["state"] = "disabled"
delete_appointments_button["state"] = "disabled"
tabs_window.tab(0, state="disabled")
tabs_window.tab(2, state="disabled")
tab_2_button_message.set("")
appointment_name, appointment_description, appointment_date, appointment_status, appointment_time = get_selected_appointments(tab_2_treeview.item(tab_2_treeview.focus())['text'].strip())
appointment_year, appointment_month, appointment_day = appointment_date.split('-')
global window
window = Tk()
window.title("Your Appointment")
window.geometry("700x650")
window.resizable(0, 0)
window.protocol("WM_DELETE_WINDOW", do_nothing)
appointments_label = Label(window, text="Appointment Name", font="arial 10", padx=3, pady=5)
appointments_label.pack()
appointment_name_entry = Entry(window)
appointment_name_entry.insert(0, tab_2_treeview.item(tab_2_treeview.focus())['text'].strip())
appointment_name_entry.pack()
appointment_name_entry['state'] = 'readonly'
label = Label(window, text="Appointment Description", font="arial 10", padx=3, pady=5)
label.pack()
textarea = Text(window, height=10)
textarea.insert(1.0, appointment_description)
textarea.pack()
appointment_date_label = Label(window, text="Appointment Date", font="arial 10", padx=3, pady=5)
appointment_date_label.pack()
cal = Calendar(window, selectmode='day', year=int(appointment_year), month=int(appointment_month), day=int(appointment_day))
cal.pack()
appointment_time_label = Label(window, text="Set Appointment Time", font="arial 10", padx=3, pady=5)
appointment_time_label.pack()
appointment_time_entry = Entry(window, width=10)
appointment_time_entry.insert(0, appointment_time)
appointment_time_entry.pack(padx=3, pady=5)
appointment_status_label = Label(window, text="Select Appointment Status", font="arial 10", padx=3, pady=5)
appointment_status_label.pack()
status = StringVar(window)
status.set(appointment_status)
appointment_status_spinbox = Spinbox(window, values=('Pending', 'Done'), textvariable=status, state='readonly')
appointment_status_spinbox.pack()
button = Button(window, text="OK", command=lambda: update_appointment(appointment_name_entry.get().strip(), cal.selection_get(), textarea.get("1.0", 'end').strip(), appointment_time_entry.get().strip(), appointment_status_spinbox.get()))
button.pack(pady=3)
button = Button(window, text="Cancel", command=appointment_cancel)
button.pack(pady=3)
def show_list_edit(self):
self.__menu = Frame(self.__window)
self.__menu.configure()
self.__menu.pack(fill=BOTH, expand=True)
line1 = Frame(self.__menu)
line1.pack(side=TOP, fill=X, expand=False, padx=5, pady=15)
near_sorted_btn = Button(line1)
near_sorted_btn.configure(text="create nearly sorted list",
command=self.__create_nearly_sorted_list)
near_sorted_btn.pack(side=LEFT)
true_random_btn = Button(line1)
true_random_btn.configure(text="create random list",
command=self.__create_absolutely_random_list)
true_random_btn.pack(side=LEFT)
few_unique_btn = Button(line1)
few_unique_btn.configure(text="create few unique",
command=self.__create_few_unique)
few_unique_btn.pack(side=LEFT)
max_field = Spinbox(line1, from_=1, to=100)
max_field.configure(textvariable=self.__max_var, width=9)
max_field.pack(side=RIGHT)
min_field = Spinbox(line1, from_=1, to=100)
min_field.configure(textvariable=self.__min_var, width=9)
min_field.pack(side=RIGHT)
line2 = Frame(self.__menu)
line2.pack(side=TOP, fill=X, expand=False, padx=5, pady=15)
list_field = Entry(line2)
list_field.configure(textvariable=self.__list_string_var)
list_field.pack(fill=X, expand=True, side=LEFT)
reverse_btn = Button(line2)
reverse_btn.configure(text="reverse", command=self.__reverse)
reverse_btn.pack(side=RIGHT)
line3 = Frame(self.__menu)
line3.pack(fill=X, expand=False, padx=5, pady=15)
submit_btn = Button(line3)
submit_btn.configure(text="submit", command=self.submit)
submit_btn.pack(side=TOP)
information = Text(self.__menu)
information.insert(
END,
"You can enter a list of numbers that should be sorted into the input field. \
Use a ';' to separate them. \
You can also generate nearly sorted or absolutely random lists with the buttons above,\
The fields beside them let you enter the minimal and maximal value of the generated list.\
By clicking on 'Submit', the list in the inputfield becomes the list to sort and the animation starts"
)
information.configure(state=DISABLED, relief=FLAT, wrap=WORD)
information.pack(side=BOTTOM, fill=X, padx=5, pady=10)
def drawManualControls(self):
# Top Bar Controls
if(self.device.type == 'powersupply'):
self.voltage_label = Label(self.parameter_frame, text="Voltage: ")
voltage_bar = Spinbox(
self.parameter_frame, from_=0, to=32, format="%.2f", increment=0.01)
voltage_button = Button(
self.parameter_frame,
text="Set Volts",
command=lambda: self.getEntry(voltage_bar, "V"))
if(self.first_pack):
self.voltage_label.pack(side=tkinter.LEFT, padx=5)
voltage_bar.pack(side=tkinter.LEFT)
voltage_button.pack(side=tkinter.LEFT, padx=5)
elif(self.device.type == 'electronicload'):
self.mode_label = Label(self.parameter_frame, text="Mode: CCH")
self.device.setMode('cch')
if(self.first_pack):
self.mode_label.pack(side=tkinter.LEFT, padx=5)
# Amperage Controls
self.current_label = Label(self.current_frame, text="Amperage: ")
current_bar = Spinbox(
self.current_frame, from_=0, to=5.2, format="%.3f", increment=0.001)
current_button = Button(
self.current_frame,
text="Set Amps",
command=lambda: self.getEntry(current_bar, "A"))
if(self.first_pack):
self.current_label.pack(side=tkinter.LEFT)
current_bar.pack(side=tkinter.LEFT)
current_button.pack(side=tkinter.LEFT, padx=5)
# Power Label
self.updatePower(self.voltage, self.amperage)
# Output Label
self.output_label = Label(self.output_frame, text="Output: Off")
output_on = Button(
self.output_frame, text="On",
command=lambda: self.updateOutput(1))
output_off = Button(self.output_frame, text="Off",
command=lambda: self.updateOutput(0))
if(self.first_pack):
self.output_label.pack(side=tkinter.LEFT)
output_on.pack(side=tkinter.LEFT)
output_off = output_off.pack(side=tkinter.LEFT, padx=5)
self.first_pack = False
def __init__(self, master):
super(InputSudoku, self).__init__(master)
self.pack()
self._values = []
self._frames = [Frame(self) for _ in range(9)]
for frame in self._frames:
for _ in range(9):
spin_box = Spinbox(frame, from_=0, to=10, width=2)
spin_box.pack(side=LEFT)
self._values.append(spin_box)
frame.pack(side=TOP)
self.button_save = Button(self, text="Save", command=self.save)
self.button_save.pack(side=TOP)
class View(Frame):
def __init__(self, master, controller, label, width, minimum, maximum,
current, *args, **kwargs):
super(View, self).__init__(master, *args, **kwargs)
self._controller = controller
self._create_label(label, width)
self._create_spinbox(minimum, maximum)
self._create_scale(minimum, maximum)
def w_label(self):
return self._label
def w_spinbox(self):
return self._spinbox
def w_scale(self):
return self._scale
def _create_label(self, label, width):
self._label = LabelTtk(self, text=label)
if width:
self._label.config(width=width)
self._label.pack(side='left', anchor='s')
def _create_spinbox(self, minimum, maximum):
self._spinbox = Spinbox(self, from_=minimum, to=maximum)
self._spinbox['command'] = lambda: \
self._controller.set_current(int(self._spinbox.get()))
self._spinbox.bind('<Return>', lambda e: \
self._controller.set_current(self._spinbox.get()))
self._spinbox.pack(side="left", anchor="s")
def _create_scale(self, minimum, maximum):
self._scale = Scale(self,
orient="horizontal",
from_=minimum,
to=maximum)
self._scale['command'] = lambda e: \
self._controller.set_current(self._scale.get())
self._scale.pack(side="left", fill="x", expand=True, anchor="s")
def __init__(self, master, app, *args, **kwargs):
super().__init__(master, *args, **kwargs)
delayvarlabframe = Frame(self)
delayvarlabframe.pack(side='top', fill='x')
l = Label(delayvarlabframe, text="Delay Variables", width=20, font='Verdana 8')
l.pack(side='left', padx=(30 * len(app.delay_tuners))/2, anchor='n', pady=5)
delaytunerframe = Frame(self)
delaytunerframe.pack(side='top', fill='x')
app.binds = []
for iter, (notation, var) in enumerate(app.delay_tuners.items()):
sb = Spinbox(delaytunerframe, to=100.00, from_=0.00, textvariable=var, increment=.001, width=6, command=lambda: app.tune_var())
bind = sb.bind('<Key>', app.tune_delay_variable)
app.binds.append((sb, bind))
l = Label(delaytunerframe, text=notation, width=2, font='Verdana 8')
l.pack(side='left', padx=5, anchor='n')
sb.pack(side='left', padx=5, anchor='n')
if iter == 0:
default_aavarname = notation
Label(delayvarlabframe, text="Freq.", font="Verdana 8").pack(side='right', padx=15)
Label(delayvarlabframe, text="Val.", font="Verdana 8").pack(side='right', padx=25)
Label(delayvarlabframe, text="Var.", font="Verdana 8").pack(side='right', padx=35)
Label(delayvarlabframe, text="Auto Adjustment", font="Verdana 8").pack(side='right', padx=0)
app.aafreqsb = Spinbox(delaytunerframe, to=1000, from_=0, textvariable=app.aafreq, increment=1, width=6)
app.aafreqsb.pack(side='right', padx=5)
app.aavalsb = Spinbox(delaytunerframe, to=0.1, from_=-0.1, textvariable=app.aaval, increment=0.001, width=6)
app.aavalsb.pack(side='right', padx=5)
app.auto_adjbox = Combobox(delaytunerframe, width=8, values=[var for var in list(app.delay_tuners)], textvariable=app.aavar)
app.auto_adjbox.pack(side='right', padx=5)
app.auto_adjbox.set(default_aavarname)
app.aa_enabled_var = StringVar(value='0')
app.enable_aa_btn = Checkbutton(delaytunerframe)
app.enable_aa_btn.pack(side='right', padx=55)
app.enable_aa_btn.bind("<Button 1>", lambda e: app.toggle_auto_adjustment(event=e))
app.enable_aa_btn.invoke()
app.enable_aa_btn.invoke()
class CheckSpin(Frame):
def __init__(self,
parent,
width=200,
height=50,
val=(0, 100),
inc=1,
font=('Times', 12),
ratio=0.5):
Frame.__init__(self, parent, width=width, height=height)
self.pack_propagate(0)
self.f1 = Frame(self, width=int(width * ratio), height=height)
self.f1.pack_propagate(0)
self.f1.pack(side='left')
self.f2 = Frame(self, width=int(width * (1 - ratio)), height=height)
self.f2.pack_propagate(0)
self.f2.pack(side='left')
self.isfloat = BooleanVar(self.f1)
self.limit = val
self.rd_f = Checkbutton(self.f1,
text="float",
font=font,
variable=self.isfloat,
onvalue=True,
offvalue=False)
self.rd_f.pack(side='left', fill="y")
self.sp = Spinbox(self.f2,
font=font,
from_=val[0],
to=val[1],
increment=inc)
self.sp.pack(fill='both', expand=True)
def get(self):
valstr = self.sp.get()
try:
val = float(valstr)
val = self.limit[1] if val > self.limit[1] else val
val = self.limit[0] if val < self.limit[0] else val
except ValueError:
val = 0
return self.isfloat.get(), val
class ConfigTimeFrame(RootFrame):
def __init__(self, *args, **kw):
super(ConfigTimeFrame, self).__init__(*args, **kw)
#image de fond
self.canevas.create_image(self.canevas_width / 2,
self.canevas_height / 2,
anchor=CENTER,
image=self.photo)
#label suivant
self.labelSuivant = Label(self, text="Suivant", relief=RAISED)
self.labelSuivant.configure(font=self.font,
fg=self.colorOrange,
bg="white")
#time spinbox
self.spinboxTime = Spinbox(self, from_=10, to=120, increment=10)
self.spinboxTime.focus()
self.spinboxTime.configure(font=self.font,
fg=self.colorBlue,
bg="white")
#config time
self.labelConfigTime = Label(
self, text="Entrer la durée de l'analyse en minute")
self.labelConfigTime.configure(font=self.font,
fg=self.colorBlue,
bg="white")
#display
self.labelConfigTime.pack(side="top")
self.spinboxTime.pack(side="top")
self.labelSuivant.pack(side="top")
def getTimeConfigured(self):
return int(self.spinboxTime.get())
#this method is call by provider action
def incrementTimeConfigured(self, event):
self.spinboxTime.invoke('buttonup')
#this method is call by provider action
def decrementTimeConfigured(self, event):
self.spinboxTime.invoke('buttondown')
def add_appointment():
add_appointments_button["state"] = "disabled"
open_appointments_button["state"] = "disabled"
delete_appointments_button["state"] = "disabled"
tabs_window.tab(0, state="disabled")
tabs_window.tab(2, state="disabled")
global window
window = Tk()
window.title("Add Appointment")
window.geometry("700x670")
window.resizable(0, 0)
window.protocol("WM_DELETE_WINDOW", do_nothing)
appointment_name_label = Label(window, text="Enter Appointment Name", font="arial 10", padx=3, pady=5)
appointment_name_label.pack()
global appointment_name_entry
appointment_name_entry = Entry(window)
appointment_name_entry.pack()
desc_label = Label(window, text="Enter Description", font="arial 10", padx=3, pady=5)
desc_label.pack()
global appointment_textarea
appointment_textarea = Text(window, height=10)
appointment_textarea.pack()
appointment_date_label = Label(window, text="Select Appointment Date", font="arial 10", padx=3, pady=5)
appointment_date_label.pack()
global cal
cal = Calendar(window, selectmode='day', year=localtime().tm_year, month=localtime().tm_mon, day=localtime().tm_mday)
cal.pack()
appointment_time_label = Label(window, text="Set Appointment Time", font="arial 10", padx=3, pady=5)
appointment_time_label.pack()
global appointment_time_entry
appointment_time_entry = Entry(window, width=10)
appointment_time_entry.insert(0, "HH:MM")
appointment_time_entry.pack(padx=3, pady=5)
appointment_status_label = Label(window, text="Select Appointment Status", font="arial 10", padx=3, pady=5)
appointment_status_label.pack()
global appointment_status_spinbox
appointment_status_spinbox = Spinbox(window, values=('Pending', 'Done'), state='readonly')
appointment_status_spinbox.pack()
button = Button(window, text="OK", command=save_appointment)
button.pack(pady=3)
button = Button(window, text="Cancel", command=appointment_cancel)
button.pack(pady=3)
message_label = Label(window, text="*Appointment name must be unique", font="Helvetica 12", pady=3, fg="red")
message_label.pack()
class Randomize:
def __init__(self, master, default):
self.frame = Frame(master)
self.value = IntVar(value=default)
self.spin_box = Spinbox(self.frame,
textvariable=self.value,
wrap=True,
width=3,
to=100,
from_=0)
self.spin_box.pack(side=LEFT)
label = Label(self.frame, text="%")
label.pack(side=LEFT)
self.randomize_button = Button(self.frame, text='Randomize')
self.randomize_button.pack(side=LEFT, fill="x", expand=True)
self.frame.pack(side=TOP, fill="x", expand=True)
def get_value(self):
return self.value.get()
class LabelSpin(Frame):
def __init__(self,
parent,
width=200,
height=50,
text='spinbox',
val=(0, 100),
inc=1,
font=('Times', 12),
ratio=0.5):
Frame.__init__(self, parent, width=width, height=height)
self.pack_propagate(0)
self.f1 = Frame(self, width=int(width * ratio), height=height)
self.f1.pack_propagate(0)
self.f1.pack(side='left')
self.f2 = Frame(self, width=int(width * (1 - ratio)), height=height)
self.f2.pack_propagate(0)
self.f2.pack(side='left')
self.lb = Label(self.f1, text=text, font=font)
self.lb.pack(fill='both', expand=True)
self.limit = val
self.sp = Spinbox(self.f2,
font=font,
from_=val[0],
to=val[1],
increment=inc)
self.sp.pack(fill='both', expand=True)
def get(self):
valstr = self.sp.get()
try:
val = float(valstr)
val = self.limit[1] if val > self.limit[1] else val
val = self.limit[0] if val < self.limit[0] else val
except ValueError:
val = 0
return val
def initUI(self):
self.parent.title("Lines")
self.pack(fill=BOTH, expand=1)
a_label = Label(self, text="Enter a:", font=("Purisa", 15))
a_label.pack()
a_value = Spinbox(self,
from_=-10,
to=10,
textvariable=0,
font=("Purisa", 10))
a_value.pack()
calc_btn = Button(self,
text="Build",
font=("Purisa", 12),
command=self.calculate_vars)
calc_btn.pack()
self.draw_coords_system()
class BirthOptions:
def __init__(self, master, count, default):
self.frame = LabelFrame(master, text="Born option")
self.value = IntVar(value=default)
self.spin_box = Spinbox(self.frame,
textvariable=self.value,
wrap=True,
width=int(count / 10 + 2),
to=count - 1,
from_=1)
self.spin_box.pack(side=LEFT)
self.scale = Scale(self.frame,
variable=self.value,
orient='horizontal',
to=count - 1,
from_=1,
showvalue=0)
self.scale.pack(side=LEFT, fill="x", expand=True)
self.frame.pack(side=TOP, fill="x", expand=True)
def get_values(self):
return self.value.get()
def createSpinBox(self, window_object, Label_Title):
Label(window_object, text=Label_Title).pack()
entry = Spinbox(window_object, values=("CCH", "CCL", "CV", "CRM"))
entry.pack(pady=5)
return entry
def guiMain(args=None):
mainWindow = Tk()
mainWindow.wm_title("OoT Randomizer %s" % ESVersion)
set_icon(mainWindow)
notebook = ttk.Notebook(mainWindow)
randomizerWindow = ttk.Frame(notebook)
adjustWindow = ttk.Frame(notebook)
customWindow = ttk.Frame(notebook)
notebook.add(randomizerWindow, text='Randomize')
notebook.pack()
# Shared Controls
farBottomFrame = Frame(mainWindow)
def open_output():
open_file(output_path(''))
openOutputButton = Button(farBottomFrame, text='Open Output Directory', command=open_output)
if os.path.exists(local_path('README.html')):
def open_readme():
open_file(local_path('README.html'))
openReadmeButton = Button(farBottomFrame, text='Open Documentation', command=open_readme)
openReadmeButton.pack(side=LEFT)
farBottomFrame.pack(side=BOTTOM, fill=X, padx=5, pady=5)
# randomizer controls
topFrame = Frame(randomizerWindow)
rightHalfFrame = Frame(topFrame)
checkBoxFrame = Frame(rightHalfFrame)
createSpoilerVar = IntVar()
createSpoilerCheckbutton = Checkbutton(checkBoxFrame, text="Create Spoiler Log", variable=createSpoilerVar)
suppressRomVar = IntVar()
suppressRomCheckbutton = Checkbutton(checkBoxFrame, text="Do not create patched Rom", variable=suppressRomVar)
compressRomVar = IntVar()
compressRomCheckbutton = Checkbutton(checkBoxFrame, text="Compress patched Rom", variable=compressRomVar)
openForestVar = IntVar()
openForestCheckbutton = Checkbutton(checkBoxFrame, text="Open Forest", variable=openForestVar)
openDoorVar = IntVar()
openDoorCheckbutton = Checkbutton(checkBoxFrame, text="Open Door of Time", variable=openDoorVar)
dungeonItemsVar = IntVar()
dungeonItemsCheckbutton = Checkbutton(checkBoxFrame, text="Place Dungeon Items (Compasses/Maps)", onvalue=0, offvalue=1, variable=dungeonItemsVar)
beatableOnlyVar = IntVar()
beatableOnlyCheckbutton = Checkbutton(checkBoxFrame, text="Only ensure seed is beatable, not all items must be reachable", variable=beatableOnlyVar)
hintsVar = IntVar()
hintsCheckbutton = Checkbutton(checkBoxFrame, text="Gossip Stone Hints with Stone of Agony", variable=hintsVar)
createSpoilerCheckbutton.pack(expand=True, anchor=W)
suppressRomCheckbutton.pack(expand=True, anchor=W)
compressRomCheckbutton.pack(expand=True, anchor=W)
openForestCheckbutton.pack(expand=True, anchor=W)
openDoorCheckbutton.pack(expand=True, anchor=W)
dungeonItemsCheckbutton.pack(expand=True, anchor=W)
beatableOnlyCheckbutton.pack(expand=True, anchor=W)
hintsCheckbutton.pack(expand=True, anchor=W)
fileDialogFrame = Frame(rightHalfFrame)
romDialogFrame = Frame(fileDialogFrame)
baseRomLabel = Label(romDialogFrame, text='Base Rom')
romVar = StringVar()
romEntry = Entry(romDialogFrame, textvariable=romVar)
def RomSelect():
rom = filedialog.askopenfilename(filetypes=[("Rom Files", (".z64", ".n64")), ("All Files", "*")])
romVar.set(rom)
romSelectButton = Button(romDialogFrame, text='Select Rom', command=RomSelect)
baseRomLabel.pack(side=LEFT)
romEntry.pack(side=LEFT)
romSelectButton.pack(side=LEFT)
romDialogFrame.pack()
checkBoxFrame.pack()
fileDialogFrame.pack()
drowDownFrame = Frame(topFrame)
bridgeFrame = Frame(drowDownFrame)
bridgeVar = StringVar()
bridgeVar.set('medallions')
bridgeOptionMenu = OptionMenu(bridgeFrame, bridgeVar, 'medallions', 'vanilla', 'dungeons', 'open')
bridgeOptionMenu.pack(side=RIGHT)
bridgeLabel = Label(bridgeFrame, text='Rainbow Bridge Requirement')
bridgeLabel.pack(side=LEFT)
bridgeFrame.pack(expand=True, anchor=E)
bottomFrame = Frame(randomizerWindow)
seedLabel = Label(bottomFrame, text='Seed #')
seedVar = StringVar()
seedEntry = Entry(bottomFrame, textvariable=seedVar)
countLabel = Label(bottomFrame, text='Count')
countVar = StringVar()
countSpinbox = Spinbox(bottomFrame, from_=1, to=100, textvariable=countVar)
def generateRom():
guiargs = Namespace
guiargs.seed = int(seedVar.get()) if seedVar.get() else None
guiargs.count = int(countVar.get()) if countVar.get() != '1' else None
guiargs.bridge = bridgeVar.get()
guiargs.create_spoiler = bool(createSpoilerVar.get())
guiargs.suppress_rom = bool(suppressRomVar.get())
guiargs.compress_rom = bool(compressRomVar.get())
guiargs.open_forest = bool(openForestVar.get())
guiargs.open_door_of_time = bool(openDoorVar.get())
guiargs.nodungeonitems = bool(dungeonItemsVar.get())
guiargs.beatableonly = bool(beatableOnlyVar.get())
guiargs.hints = bool(hintsVar.get())
guiargs.rom = romVar.get()
try:
if guiargs.count is not None:
seed = guiargs.seed
for _ in range(guiargs.count):
main(seed=seed, args=guiargs)
seed = random.randint(0, 999999999)
else:
main(seed=guiargs.seed, args=guiargs)
except Exception as e:
messagebox.showerror(title="Error while creating seed", message=str(e))
else:
messagebox.showinfo(title="Success", message="Rom patched successfully")
generateButton = Button(bottomFrame, text='Generate Patched Rom', command=generateRom)
seedLabel.pack(side=LEFT)
seedEntry.pack(side=LEFT)
countLabel.pack(side=LEFT, padx=(5, 0))
countSpinbox.pack(side=LEFT)
generateButton.pack(side=LEFT, padx=(5, 0))
openOutputButton.pack(side=RIGHT)
drowDownFrame.pack(side=LEFT)
rightHalfFrame.pack(side=RIGHT)
topFrame.pack(side=TOP)
bottomFrame.pack(side=BOTTOM)
if args is not None:
# load values from commandline args
createSpoilerVar.set(int(args.create_spoiler))
suppressRomVar.set(int(args.suppress_rom))
compressRomVar.set(int(args.compress_rom))
if args.nodungeonitems:
dungeonItemsVar.set(int(not args.nodungeonitems))
openForestVar.set(int(args.open_forest))
openDoorVar.set(int(args.open_door_of_time))
beatableOnlyVar.set(int(args.beatableonly))
hintsVar.set(int(args.hints))
if args.count:
countVar.set(str(args.count))
if args.seed:
seedVar.set(str(args.seed))
bridgeVar.set(args.bridge)
romVar.set(args.rom)
mainWindow.mainloop()
def guiMain(settings=None):
frames = {}
mainWindow = Tk()
mainWindow.wm_title("OoT Randomizer %s" % ESVersion)
set_icon(mainWindow)
notebook = ttk.Notebook(mainWindow)
frames['rom_tab'] = ttk.Frame(notebook)
frames['rules_tab'] = ttk.Frame(notebook)
frames['logic_tab'] = ttk.Frame(notebook)
frames['other_tab'] = ttk.Frame(notebook)
frames['aesthetic_tab'] = ttk.Frame(notebook)
adjustWindow = ttk.Frame(notebook)
customWindow = ttk.Frame(notebook)
notebook.add(frames['rom_tab'], text='ROM Options')
notebook.add(frames['rules_tab'], text='Main Rules')
notebook.add(frames['logic_tab'], text='Detailed Logic')
notebook.add(frames['other_tab'], text='Other')
notebook.add(frames['aesthetic_tab'], text='Aesthetics')
# Shared Controls
# adds a LabelFrame containing a list of radio buttons based on the given data
# returns the label_frame, and a variable associated with it
def MakeRadioList(parent, data):
# create a frame to hold the radio buttons
lable_frame = LabelFrame(parent, text=data["name"], labelanchor=NW)
# create a variable to hold the result of the user's decision
radio_var = StringVar(value=data["default"]);
# setup orientation
side = TOP
anchor = W
if "horizontal" in data and data["horizontal"]:
side = LEFT
anchor = N
# add the radio buttons
for option in data["options"]:
radio_button = Radiobutton(lable_frame, text=option["description"], value=option["value"], variable=radio_var,
justify=LEFT, wraplength=data["wraplength"])
radio_button.pack(expand=True, side=side, anchor=anchor)
# return the frame so it can be packed, and the var so it can be used
return (lable_frame, radio_var)
#######################
# randomizer controls #
#######################
# hold the results of the user's decisions here
guivars = {}
# hierarchy
############
#Rules Tab
frames['open'] = LabelFrame(frames['rules_tab'], text='Open', labelanchor=NW)
frames['logic'] = LabelFrame(frames['rules_tab'], text='Logic', labelanchor=NW)
# Logic tab
frames['rewards'] = LabelFrame(frames['logic_tab'], text='Remove Specific Locations', labelanchor=NW)
frames['tricks'] = LabelFrame(frames['logic_tab'], text='Specific expected tricks', labelanchor=NW)
#Other Tab
frames['convenience'] = LabelFrame(frames['other_tab'], text='Speed Ups', labelanchor=NW)
frames['other'] = LabelFrame(frames['other_tab'], text='Misc', labelanchor=NW)
#Aesthetics tab
frames['tuniccolor'] = LabelFrame(frames['aesthetic_tab'], text='Tunic Color', labelanchor=NW)
frames['navicolor'] = LabelFrame(frames['aesthetic_tab'], text='Navi Color', labelanchor=NW)
frames['lowhp'] = LabelFrame(frames['aesthetic_tab'], text='Low HP SFX', labelanchor=NW)
# shared
settingsFrame = Frame(mainWindow)
settings_string_var = StringVar()
settingsEntry = Entry(settingsFrame, textvariable=settings_string_var)
def show_settings(event=None):
settings = guivars_to_settings(guivars)
settings_string_var.set( settings.get_settings_string() )
# Update any dependencies
for info in setting_infos:
if info.gui_params and 'dependency' in info.gui_params:
dep_met = True
for dep_var, dep_val in info.gui_params['dependency'].items():
if guivars[dep_var].get() != dep_val:
dep_met = False
if widgets[info.name].winfo_class() == 'Frame':
for child in widgets[info.name].winfo_children():
child.configure(state= 'normal' if dep_met else 'disabled')
else:
widgets[info.name].config(state = 'normal' if dep_met else 'disabled')
def import_settings(event=None):
try:
settings = guivars_to_settings(guivars)
text = settings_string_var.get().upper()
settings.seed = guivars['seed'].get()
settings.update_with_settings_string(text)
settings_to_guivars(settings, guivars)
except Exception as e:
messagebox.showerror(title="Error", message="Invalid settings string")
label = Label(settingsFrame, text="Settings String")
importSettingsButton = Button(settingsFrame, text='Import Settings String', command=import_settings)
label.pack(side=LEFT, anchor=W, padx=5)
settingsEntry.pack(side=LEFT, anchor=W)
importSettingsButton.pack(side=LEFT, anchor=W, padx=5)
fileDialogFrame = Frame(frames['rom_tab'])
romDialogFrame = Frame(fileDialogFrame)
baseRomLabel = Label(romDialogFrame, text='Base Rom')
guivars['rom'] = StringVar(value='ZOOTDEC.z64')
romEntry = Entry(romDialogFrame, textvariable=guivars['rom'], width=40)
def RomSelect():
rom = filedialog.askopenfilename(filetypes=[("Rom Files", (".z64", ".n64")), ("All Files", "*")])
if rom != '':
guivars['rom'].set(rom)
romSelectButton = Button(romDialogFrame, text='Select Rom', command=RomSelect, width=10)
baseRomLabel.pack(side=LEFT, padx=(40,0))
romEntry.pack(side=LEFT, padx=3)
romSelectButton.pack(side=LEFT)
romDialogFrame.pack()
fileDialogFrame.pack(side=TOP, anchor=W, padx=5, pady=(5,1))
def open_output():
open_file(output_path(''))
def output_dir_select():
rom = filedialog.askdirectory(initialdir = default_output_path(guivars['output_dir'].get()))
if rom != '':
guivars['output_dir'].set(rom)
outputDialogFrame = Frame(frames['rom_tab'])
outputDirLabel = Label(outputDialogFrame, text='Output Directory')
guivars['output_dir'] = StringVar(value='')
outputDirEntry = Entry(outputDialogFrame, textvariable=guivars['output_dir'], width=40)
outputDirButton = Button(outputDialogFrame, text='Select Dir', command=output_dir_select, width=10)
outputDirLabel.pack(side=LEFT, padx=(3,0))
outputDirEntry.pack(side=LEFT, padx=3)
outputDirButton.pack(side=LEFT)
outputDialogFrame.pack(side=TOP, anchor=W, padx=5, pady=(5,1))
if os.path.exists(local_path('README.html')):
def open_readme():
open_file(local_path('README.html'))
openReadmeButton = Button(outputDialogFrame, text='Open Documentation', command=open_readme)
openReadmeButton.pack(side=LEFT, padx=5)
outputDialogFrame.pack(side=TOP, anchor=W, pady=3)
countDialogFrame = Frame(frames['rom_tab'])
countLabel = Label(countDialogFrame, text='Generation Count')
guivars['count'] = StringVar()
countSpinbox = Spinbox(countDialogFrame, from_=1, to=100, textvariable=guivars['count'], width=3)
countLabel.pack(side=LEFT)
countSpinbox.pack(side=LEFT, padx=2)
countDialogFrame.pack(side=TOP, anchor=W, padx=5, pady=(1,1))
multiworldFrame = LabelFrame(frames['rom_tab'], text='Multi-World Generation')
countLabel = Label(multiworldFrame, wraplength=300, justify=LEFT, text='This is used for co-op generations. Increasing World Count will drastically increase the generation time. For more information see https://github.com/TestRunnerSRL/bizhawk-co-op')
countLabel.pack(side=TOP, anchor=W, padx=5, pady=(1,1))
worldCountFrame = Frame(multiworldFrame)
countLabel = Label(worldCountFrame, text='World Count')
guivars['world_count'] = StringVar()
countSpinbox = Spinbox(worldCountFrame, from_=1, to=100, textvariable=guivars['world_count'], width=3)
countLabel.pack(side=LEFT)
countSpinbox.pack(side=LEFT, padx=2)
worldCountFrame.pack(side=LEFT, anchor=N, padx=5, pady=(1,1))
playerNumFrame = Frame(multiworldFrame)
countLabel = Label(playerNumFrame, text='Player Number')
guivars['player_num'] = StringVar()
countSpinbox = Spinbox(playerNumFrame, from_=1, to=100, textvariable=guivars['player_num'], width=3)
countLabel.pack(side=LEFT)
countSpinbox.pack(side=LEFT, padx=2)
playerNumFrame.pack(side=LEFT, anchor=N, padx=5, pady=(1,1))
multiworldFrame.pack(side=TOP, anchor=W, padx=5, pady=(1,1))
# build gui
############
widgets = {}
for info in setting_infos:
if info.gui_params:
if info.gui_params['widget'] == 'Checkbutton':
# determine the initial value of the checkbox
default_value = 1 if info.gui_params['default'] == "checked" else 0
# create a variable to access the box's state
guivars[info.name] = IntVar(value=default_value)
# create the checkbox
widgets[info.name] = Checkbutton(frames[info.gui_params['group']], text=info.gui_params['text'], variable=guivars[info.name], justify=LEFT, wraplength=200, command=show_settings)
widgets[info.name].pack(expand=False, anchor=W)
elif info.gui_params['widget'] == 'Combobox':
# create the variable to store the user's decision
guivars[info.name] = StringVar(value=info.gui_params['default'])
# create the option menu
widgets[info.name] = Frame(frames[info.gui_params['group']])
# dropdown = OptionMenu(widgets[info.name], guivars[info.name], *(info['options']))
if isinstance(info.gui_params['options'], list):
info.gui_params['options'] = dict(zip(info.gui_params['options'], info.gui_params['options']))
dropdown = ttk.Combobox(widgets[info.name], textvariable=guivars[info.name], values=list(info.gui_params['options'].keys()), state='readonly', width=30)
dropdown.bind("<<ComboboxSelected>>", show_settings)
dropdown.pack(side=BOTTOM, anchor=W)
# label the option
if 'text' in info.gui_params:
label = Label(widgets[info.name], text=info.gui_params['text'])
label.pack(side=LEFT, anchor=W, padx=5)
# pack the frame
widgets[info.name].pack(expand=False, side=TOP, anchor=W, padx=3, pady=3)
elif info.gui_params['widget'] == 'Scale':
# create the variable to store the user's decision
guivars[info.name] = IntVar(value=info.gui_params['default'])
# create the option menu
widgets[info.name] = Frame(frames[info.gui_params['group']])
# dropdown = OptionMenu(widgets[info.name], guivars[info.name], *(info['options']))
minval = 'min' in info.gui_params and info.gui_params['min'] or 0
maxval = 'max' in info.gui_params and info.gui_params['max'] or 100
stepval = 'step' in info.gui_params and info.gui_params['step'] or 1
scale = Scale(widgets[info.name], variable=guivars[info.name], from_=minval, to=maxval, tickinterval=stepval, resolution=stepval, showvalue=0, orient=HORIZONTAL, sliderlength=15, length=200, command=show_settings)
scale.pack(side=BOTTOM, anchor=W)
# label the option
if 'text' in info.gui_params:
label = Label(widgets[info.name], text=info.gui_params['text'])
label.pack(side=LEFT, anchor=W, padx=5)
# pack the frame
widgets[info.name].pack(expand=False, side=TOP, anchor=W, padx=3, pady=3)
elif info.gui_params['widget'] == 'Entry':
# create the variable to store the user's decision
guivars[info.name] = StringVar(value=info.gui_params['default'])
# create the option menu
widgets[info.name] = Frame(frames[info.gui_params['group']])
entry = Entry(widgets[info.name], textvariable=guivars[info.name], width=30)
entry.pack(side=BOTTOM, anchor=W)
# label the option
if 'text' in info.gui_params:
label = Label(widgets[info.name], text=info.gui_params['text'])
label.pack(side=LEFT, anchor=W, padx=5)
# pack the frame
widgets[info.name].pack(expand=False, side=TOP, anchor=W, padx=3, pady=3)
# pack the hierarchy
frames['open'].pack( fill=BOTH, expand=True, anchor=N, side=LEFT, pady=(5,1) )
frames['logic'].pack( fill=BOTH, expand=True, anchor=N, side=LEFT, pady=(5,1) )
# Logic tab
frames['rewards'].pack(fill=BOTH, expand=True, anchor=N, side=LEFT, pady=(5,1) )
frames['tricks'].pack( fill=BOTH, expand=True, anchor=N, side=LEFT, pady=(5,1) )
#Other Tab
frames['convenience'].pack(fill=BOTH, expand=True, anchor=N, side=LEFT, pady=(5,1) )
frames['other'].pack( fill=BOTH, expand=True, anchor=N, side=LEFT, pady=(5,1) )
#Aesthetics tab
frames['navicolor'].pack( fill=BOTH, expand=True, anchor=N, side=RIGHT, pady=(5,1) )
frames['tuniccolor'].pack(fill=BOTH, expand=True, anchor=W, side=TOP, pady=(5,1) )
frames['lowhp'].pack( fill=BOTH, expand=True, anchor=W, side=BOTTOM, pady=(5,1) )
notebook.pack(fill=BOTH, expand=True, padx=5, pady=5)
# didn't refactor the rest, sorry
# create the option menu
settingsFrame.pack(fill=BOTH, anchor=W, padx=5, pady=(10,0))
def generateRom():
settings = guivars_to_settings(guivars)
try:
if settings.count is not None:
orig_seed = settings.seed
for i in range(settings.count):
settings.update_seed(orig_seed + '-' + str(i))
main(settings)
else:
main(settings)
except Exception as e:
messagebox.showerror(title="Error while creating seed", message=str(e))
else:
messagebox.showinfo(title="Success", message="Rom patched successfully")
generateSeedFrame = Frame(mainWindow)
generateButton = Button(generateSeedFrame, text='Generate Patched Rom', command=generateRom)
seedLabel = Label(generateSeedFrame, text='Seed')
guivars['seed'] = StringVar()
seedEntry = Entry(generateSeedFrame, textvariable=guivars['seed'])
seedLabel.pack(side=LEFT)
seedEntry.pack(side=LEFT)
generateButton.pack(side=LEFT, padx=(5, 0))
generateSeedFrame.pack(side=BOTTOM, anchor=W, padx=5, pady=10)
if settings is not None:
# load values from commandline args
settings_to_guivars(settings, guivars)
else:
# try to load saved settings
try:
with open('settings.sav') as f:
settings = Settings( json.load(f) )
settings.update_seed("")
settings_to_guivars(settings, guivars)
except:
pass
show_settings()
mainWindow.mainloop()
# save settings on close
with open('settings.sav', 'w') as outfile:
settings = guivars_to_settings(guivars)
json.dump(settings.__dict__, outfile)
def refreshWidget(self) :
#print "refresh"
self.card_win.pack_forget()
import unicodedata
#Card window
self.card_win = PanedWindow(self.card_win.master, orient=VERTICAL)
self.card_win.pack(side=TOP, expand=True, fill=BOTH, pady=2, padx=2)
#Create the name zone
name_zone=PanedWindow(self.card_win, orient=HORIZONTAL)
name = StringVar()
name.set(self.name)
def modifName(*args) :
try :
assert('"' not in name.get())
name.get().encode('ascii')
except Exception as e:
print ("error on name")
name.set(self.name)
return
old = self.name in Card.blocked_creature
self.name=name.get()
if old or self.name in Card.blocked_creature :
self.refreshWidget()
name.trace("w", modifName)
name_wid=Entry(name_zone, width=30,textvariable=name)
name_wid.pack()
name_zone.add(name_wid)
#Create the cost ad star stringvar
#print int(floor(self.getCost()))
self.cost=StringVar()
self.stars=StringVar()
cost_wid=Label(None, textvariable=self.cost, background='red',width=5, anchor=W)
star_wid=Label(None, textvariable=self.stars, background='blue', anchor=E)
self.cost.set(str(int(floor(self.getCost()))))
self.stars.set("*"*self.getStars())
#Add them in name zone
name_zone.add(cost_wid)
name_zone.add(star_wid)
#Create an Image Zone
image_zone=Button(self.card_win, command=self.choosePhoto)
if hasattr(self,"photofile") and self.photofile :
print ("Image: ",self.photofile)
try :
pilImage=Image.open(self.photofile)
img=PhotoImage(pilImage,master=image_zone)
except :
decomp=self.photofile.split('/')
for i in range(1,6) :
try :
fname="/".join(decomp[-i:])
print ("try to open",fname)
pilImage = Image.open(fname)
img=PhotoImage(pilImage,master=image_zone)
self.photofile=fname
break
except :
self.photofile=None
if self.photofile :
w, h = img.width(), img.height()
print('wh',w,h)
if h>400 :
print("reduction")
img=PhotoImage(pilImage.resize((w//2,h//2), Image.ANTIALIAS),master=image_zone)
image_zone=Button(self.card_win,image=img, command=self.choosePhoto)
image_zone.image=img
#image_zone.configure(image=image_zone.image,width=50,height=50,compound=RIGHT)
#image_zone.pack()
#print "IMAGE CHANGED"
else :
from os import path
fname=self.name.replace(" ","_")
if path.isfile("Cards/"+fname+".png") :
image_zone.config(text='image can be taken from\n'+"Cards/"+fname+".png",background='white',anchor=CENTER)
else :
image_zone.config(text='clic to choose image',background='white',anchor=CENTER)
#image_zone.pack()
# POWER ZONE
power_zone=PanedWindow(self.card_win, orient=VERTICAL)
#fenetre=self.card_win.master
def removePowerCreator(px) :
def removePower(*args) :
#print 'avant',list_pow
self.bonus.remove(px)
#print 'apres',list_pow
#self.card_win.pack_forget()
self.refreshWidget()
return removePower
for p in self.bonus :
powline = PanedWindow(self.card_win, orient=HORIZONTAL)
pow_wid=p.initWidget(powline)
powline.add(pow_wid)
removepow=Button(powline, text="X", command=removePowerCreator(p), anchor=E)
removepow.pack()
powline.add(removepow)
power_zone.add(powline)
def addPower(*args) :
if addBonus.get()!= "add bonus":
name=addBonus.get()
else:
name=add_cost_alteration.get()
print ("added :",name)
import CardPowers
self.bonus+=[eval('CardPowers.'+name+'()')]
self.bonus[-1].parent=self.bonus
self.bonus[-1].card=self
#self.card_win.pack_forget()
self.refreshWidget()
#Add bonus Option menu
addBonus = StringVar(power_zone)
addBonus.set("add bonus") # default value
if not self.pv:
addBonus_wid = Spell.getSpellMenu(power_zone, addBonus)
else: addBonus_wid = getBonusMenu(power_zone, addBonus)
addBonus.trace('w', addPower)
if self.pv>0 or len(self.bonus)==0 or all([b.is_cost_alterator for b in self.bonus]):
addBonus_wid.pack()
#Add this to power zone
power_zone.add(addBonus_wid)
#Create save zone
save_zone = PanedWindow(self.card_win, orient=HORIZONTAL)
if self.monster_type != "all" and not(self.name in Card.blocked_creature) :
save_wid = Button(save_zone, text="Save", command=self.postAndSave)
elif self.monster_type != "all" :
save_wid = Button(save_zone, text="creature in campaign", command=None)
else:
save_wid = Button(save_zone, text="nead type", command=None)
save_wid.pack()
#Create the open button
save_zone.pack()
if Card.monster_list.keys():
self.opening = StringVar(save_zone)
self.opening.set("Open")
choice = [na for na in Card.monster_list.keys() if na not in Card.blocked_creature]
choice.sort()
#print all_monsters.keys()
open_wid = OptionMenu(save_zone, self.opening,*choice)
self.opening.trace('w', self.Open)
open_wid.pack()
save_zone.add(open_wid)
if Card.monster_list.keys():
self.delete = StringVar(save_zone)
self.delete.set("Delete")
choice = [na for na in Card.monster_list.keys() if na not in Card.blocked_creature]
choice.sort()
delete_wid = OptionMenu(save_zone, self.delete,*choice)
self.delete.trace('w', self.clicDelete)
delete_wid.pack()
save_zone.add(delete_wid)
#Create the type button
self.category = StringVar(save_zone)
self.category.set(self.monster_type)
choice = [file2name(t,"_monsters.sav") for t in glob.glob("CardFiles/*_monsters.sav")]
if "recup" in choice:
choice.remove("recup")
#print all_monsters.keys()
category_wid = OptionMenu(save_zone, self.category,*choice)
self.category.trace('w', self.setFile)
category_wid.pack()
#Add it to save zone
save_zone.add(save_wid)
save_zone.add(category_wid)
#Create a new Strength zone for att and pv
strength_zone=PanedWindow(self.card_win, orient=HORIZONTAL)
att=StringVar()
att.set(str(self.att))
pv=StringVar() ; pv.set(str(self.pv))
def modifiedAttPv(*args) :
print ("modifiedAttPv")
self.pv=int(pv.get())
if self.pv<1 and self.is_spell==False :
if len(self.bonus)==0 :
self.is_spell=True
self.refreshWidget()
else :
self.pv=1
self.refreshWidget()
if self.pv>0 and self.is_spell==True :
if len(self.bonus)==0 :
self.is_spell=False
self.refreshWidget()
else :
self.pv=0
self.refreshWidget()
self.att=int(att.get())
self.getCost()
att_wid = Spinbox(strength_zone, from_=0, to=1000,textvariable=att,command=modifiedAttPv)
att_wid.pack()
strength_zone.add(att_wid)
strength_zone.add(Label(strength_zone, text=' ', background='white',
anchor=CENTER))
pv_wid = Spinbox(strength_zone, from_=0, to=1000,textvariable=pv,command=modifiedAttPv)
pv_wid.pack()
strength_zone.add(pv_wid)
#Put it all in window
self.card_win.add(name_zone)
self.card_win.add(image_zone)
self.card_win.add(power_zone)
self.card_win.add(strength_zone)
self.card_win.add(save_zone)
self.card_win.pack()
