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()