def __init__(self, *args, **kwargs):
kwargs.update(relief='flat',
bd=0,
highlightthickness=0,
bg=self.default_bg_color)
data_frame.DataFrame.__init__(self, *args, **kwargs)
# make the widgets
self.entry_string = tk.StringVar(self)
self.content = tk.Frame(self, relief='flat', bd=0)
self.title_label = tk.Label(
self.content,
text=self.gui_name,
justify='left',
anchor='w',
width=self.title_size,
disabledforeground=self.text_disabled_color)
self.data_entry = tk.Entry(self.content,
textvariable=self.entry_string,
justify='left')
self.data_entry.bind('<Return>', self.flush)
self.data_entry.bind('<FocusOut>', self.flush)
self.write_trace(self.entry_string, self.set_modified)
if self.gui_name != '':
self.title_label.pack(side="left", fill="x")
self.sidetip_label = tk.Label(self.content, anchor='w', justify='left')
self.populate()
self._initialized = True
def popup_clock_config(self,win, ElemAModificar):#Funcion para la modificacion de los valores del reloj con GUI
self.clk.status=False #Paramos el reloj
#ven = Toplevel() #Creamos un ventana pop up
ven = tk.Toplevel()
ven.protocol("WM_DELETE_WINDOW", lambda window=ven : self.onCloseWindow(window))#Sobreescribimos el comportamiento al cerrar el popup
entrada=tk.Entry(ven)
entrada.grid(row=1, column=1)
if ElemAModificar == 0:
label1 = tk.Label(ven, text = 'Modificar Horas') #Colocamos labels y entries en la ventana pop up
label1.grid(row=0, column=0, columnspan=2)
labelHoras = tk.Label(ven, text = 'Introduce las horas')
labelHoras.grid(row=1, column=0)
b1 = tk.Button(ven, text= "Cambiar horas", command= lambda: GUIClock.setTimeGUI_By_Selection(self,ven,entrada.get(),"h") )
b1.grid(row=2, column=0)
elif ElemAModificar == 1:
label1 = tk.Label(ven, text = 'Modificar Minutos')
label1.grid(row=0, column=0, columnspan=2)
labelminutos = tk.Label(ven, text = 'Introduce los minutos que deseas')
labelminutos.grid(row=1, column=0)
b1 = tk.Button(ven, text= "Cambiar Minutos", command= lambda: GUIClock.setTimeGUI_By_Selection(self,ven,entrada.get(),"m") )
b1.grid(row=2, column=0)
elif ElemAModificar == 2:
label1 = tk.Label(ven, text = 'Modificar segundos')
label1.grid(row=0, column=0, columnspan=2)
labelSeg = tk.Label(ven, text = 'Introduce los segundos que deseas')
labelSeg.grid(row=1, column=0)
b1 = tk.Button(ven, text= "Cambiar Segundos", command= lambda: GUIClock.setTimeGUI_By_Selection(self,ven,entrada.get(),"s") )
b1.grid(row=2, column=0)
elif ElemAModificar == 3:
label1 = tk.Label(ven, text = 'Modificar segundero')
label1.grid(row=0, column=0, columnspan=2)
labelSeg = tk.Label(ven, text = 'Introduce cada cuanto se actualizara el segundero del reloj')
labelSeg.grid(row=1, column=0)
b1 = tk.Button(ven, text= "Cambiar Segundos", command= lambda: GUIClock.setTimeGUI_By_Selection(self,ven,entrada.get(),"t") )
b1.grid(row=2, column=0)
def populate(self):
self.title_label = tk.Label(
self,
text=self.gui_name,
width=self.title_size,
anchor='w',
disabledforeground=self.text_disabled_color)
self.tooltip_string = self.desc.get('TOOLTIP')
self.title_label.tooltip_string = self.tooltip_string
for w in (self, self.title_label):
w.tooltip_string = self.desc.get('TOOLTIP')
self.import_btn = ttk.Button(self,
width=6,
text='Import',
command=self.import_node)
self.export_btn = ttk.Button(self,
width=6,
text='Export',
command=self.export_node)
self.delete_btn = ttk.Button(self,
width=6,
text='Delete',
command=self.delete_node)
# now that the field widgets are created, position them
self.pose_fields()
def populate(self):
self.title_label = tk.Label(
self,
text=self.gui_name,
width=self.title_size,
anchor='w',
disabledforeground=self.text_disabled_color)
self.field_type_name = tk.Label(
self,
text='<VOIDED>',
anchor='w',
justify='left',
disabledforeground=self.text_disabled_color)
for w in (self, self.title_label, self.field_type_name):
w.tooltip_string = self.desc.get('TOOLTIP')
# now that the field widgets are created, position them
self.pose_fields()
def setup_window(self, *args, **kwargs):
ConverterBase.setup_window(self, *args, **kwargs)
self.settings_frame = tk.LabelFrame(self, text="Conversion settings")
self.from_label = tk.Label(self.settings_frame, text="from")
self.src_menu = ScrollMenu(
self.settings_frame,
options=self.object_types,
menu_width=20,
sel_index=0,
)
self.to_label = tk.Label(self.settings_frame, text="to")
self.dst_menu = ScrollMenu(
self.settings_frame,
options=self.object_types,
menu_width=20,
sel_index=10,
)
self.pack_widgets()
self.apply_style()
def __init__(self, *args, **kwargs):
self.bit_opt_map = {}
self.checkvars = {}
self.checkbtns = {}
data_frame.DataFrame.__init__(self, *args, **kwargs)
self.content = tk.Frame(self, highlightthickness=0)
self.display_comment()
self.title_label = tk.Label(
self.content,
text=self.gui_name,
width=self.title_size,
anchor='w',
disabledforeground=self.text_disabled_color,
font=self.get_font("default"))
if self.gui_name != '':
self.title_label.pack(side='left')
self.check_canvas = tk.Canvas(self.content, highlightthickness=0)
self.check_frame = tk.Frame(self.check_canvas,
bd=self.listbox_depth,
relief='sunken',
highlightthickness=0)
self.scrollbar_y = tk.Scrollbar(self.content,
orient='vertical',
command=self.check_canvas.yview)
self.check_canvas.config(yscrollcommand=self.scrollbar_y.set,
yscrollincrement=1,
xscrollincrement=1)
self.check_frame_id = self.check_canvas.create_window(
(0, 0), window=self.check_frame, anchor='nw')
if e_c.IS_LNX:
self.check_frame.bind('<4>', self.mousewheel_scroll_y)
self.check_frame.bind('<5>', self.mousewheel_scroll_y)
self.check_canvas.bind('<4>', self.mousewheel_scroll_y)
self.check_canvas.bind('<5>', self.mousewheel_scroll_y)
else:
self.check_frame.bind('<MouseWheel>', self.mousewheel_scroll_y)
self.check_canvas.bind('<MouseWheel>', self.mousewheel_scroll_y)
self.populate()
self._initialized = True
def show_tip(self, pos_x, pos_y, tip_text):
if self.tip_window:
return
self.tip_window = tk.Toplevel(self.app_root)
self.tip_window.wm_overrideredirect(1)
self.tip_window.wm_geometry("+%d+%d" % (pos_x, pos_y))
label = tk.Label(self.tip_window,
text=tip_text,
justify='left',
relief='solid',
bg=self.tooltip_bg_color,
fg=self.text_normal_color,
borderwidth=1,
font=self.get_font("tooltip"))
label.pack()
def __init__(self, *args, **kwargs):
field_widget.FieldWidget.__init__(self, *args, **kwargs)
if self.f_widget_parent is None:
self.pack_padx = self.pack_pady = 0
kwargs.update(relief='flat', bd=0, highlightthickness=0)
show_frame = bool(kwargs.pop('show_frame', not self.blocks_start_hidden))
if self.is_empty and self.hide_if_blank:
show_frame = False
tk.Frame.__init__(self, *args, **e_c.fix_kwargs(**kwargs))
self.show = tk.BooleanVar(self)
self.show.set(show_frame)
toggle_text = '-' if show_frame else '+'
self.title = tk.Frame(self, relief='raised')
self.content = tk.Frame(self, relief="sunken")
self.show_btn = ttk.Checkbutton(
self.title, width=3, text=toggle_text, command=self.toggle_visible,
style='ShowButton.TButton')
self.title_label = tk.Label(
self.title, text=self.gui_name, anchor='w',
width=self.title_size, justify='left',
font=self.get_font("frame_title"))
self.title_label.font_type = "frame_title"
self.import_btn = ttk.Button(
self.title, width=7, text='Import',
command=self.import_node)
self.export_btn = ttk.Button(
self.title, width=7, text='Export',
command=self.export_node)
self.show_btn.pack(side="left")
self.title_label.pack(side="left", fill="x", expand=True)
self.title.pack(fill="x", expand=True)
for w in (self.export_btn, self.import_btn):
w.pack(side="right", padx=(0, 4), pady=2)
self.populate()
self._initialized = True
def __init__(self, *args, **kwargs):
kwargs.update(relief='flat', bd=0, highlightthickness=0)
data_frame.DataFrame.__init__(self, *args, **kwargs)
try:
sel_index = self.node.get_index()
except Exception:
sel_index = -1
# make the widgets
self.content = tk.Frame(self, relief='flat', bd=0)
self.display_comment()
self.title_label = tk.Label(
self.content,
text=self.gui_name,
justify='left',
anchor='w',
width=self.title_size,
disabledforeground=self.text_disabled_color)
self.sel_menu = ScrollMenu(self.content,
f_widget_parent=self,
menu_width=self.widget_width,
sel_index=sel_index,
max_index=self.desc.get('ENTRIES', 0) - 1,
disabled=self.disabled,
default_text="<INVALID>",
option_getter=self.get_options,
callback=self.select_option)
if self.gui_name != '':
self.title_label.pack(side="left", fill="x")
self.content.pack(fill="x", expand=True)
self.sel_menu.pack(side="left", fill="x")
self.populate()
self.pose_fields()
self._initialized = True
def __init__(self, win, _x , _y): #win es la ventana en la cual colocaremos el reloj, _x y _y es la posicionamiento tipo grid
self.clk = clock(True) #Creamos un atributo del tipo clock
#win.title("Window")
self.lbl = tk.Label(win, text="%02d:%02d:%02d" % (self.clk.h , self.clk.m , self.clk.s))
self.lbl.grid(row = _x , column = _y, columnspan=2)
self.btn = tk.Button(win, text ="Modificar horas", command = lambda: self.popup_clock_config(win, 0) )
self.btn.grid(row = _x+1, column = _y)
self.btn = tk.Button(win, text ="Enviar horas", command = lambda: self.popup_clock_config(win, 0) )
self.btn.grid(row = _x+1, column = _y+1)
self.btn = tk.Button(win, text ="Modificar minutos", command = lambda: self.popup_clock_config(win, 1) )
self.btn.grid(row = _x+2, column = _y)
self.btn = tk.Button(win, text ="Enviar minutos", command = lambda: self.popup_clock_config(win, 1) )
self.btn.grid(row = _x+2, column = _y+1)
self.btn = tk.Button(win, text ="Modificar segundos", command = lambda: self.popup_clock_config(win, 2) )
self.btn.grid(row = _x+3, column = _y)
self.btn = tk.Button(win, text ="Enviar segundos", command = lambda: self.popup_clock_config(win, 2) )
self.btn.grid(row = _x+3, column = _y+1)
self.btn = tk.Button(win, text ="configurar segundero", command =lambda: self.popup_clock_config(win, 3) )
self.btn.grid(row = _x+4, column = _y)
self.t = threading.Thread(target=self.clk.start , args=(self.lbl, ))
self.t.setDaemon(True)
self.t.start()
"""selstart_server = websockets.serve(hello, "localhost", 8765)
def __init__(self, *args, **kwargs):
kwargs.update(relief='flat', bd=0, highlightthickness=0)
data_frame.DataFrame.__init__(self, *args, **kwargs)
sel_index = -1 if self.node is None else self.node + 1
# make the widgets
self.content = tk.Frame(self, relief='flat', bd=0)
self.title_label = tk.Label(
self.content,
text=self.gui_name,
justify='left',
anchor='w',
width=self.title_size,
disabledforeground=self.text_disabled_color)
self.sel_menu = ScrollMenu(self.content,
f_widget_parent=self,
menu_width=self.widget_width,
sel_index=sel_index,
max_index=0,
disabled=self.disabled,
default_text="<INVALID>",
option_getter=self.get_options,
callback=self.select_option)
self.sel_menu.bind('<FocusIn>', self.flag_sanity_change)
self.sel_menu.arrow_button.bind('<FocusIn>', self.flag_sanity_change)
self.sel_menu.bind('<Enter>', self.flag_sanity_change)
self.sel_menu.arrow_button.bind('<Enter>', self.flag_sanity_change)
self.sel_menu.options_volatile = 'DYN_NAME_PATH' in self.desc
if self.gui_name != '':
self.title_label.pack(side="left", fill="x")
self.content.pack(fill="x", expand=True)
self.sel_menu.pack(side="left", fill="x")
self.populate()
self._initialized = True
def __init__(self, *args, **kwargs):
data_frame.DataFrame.__init__(self, *args, **kwargs)
self.checked = tk.IntVar(self)
self.checkbutton = tk.Checkbutton(
self,
variable=self.checked,
command=self.check,
text=" ",
disabledforeground=self.text_disabled_color)
self.title_label = tk.Label(
self,
text=self.gui_name,
width=self.title_size,
anchor='w',
disabledforeground=self.text_disabled_color)
if self.gui_name != '':
self.title_label.pack(side='left')
self.checkbutton.pack(side='left')
self.populate()
self._initialized = True
def __init__(self, *args, **kwargs):
BinillaWidget.__init__(self)
sel_index = kwargs.pop('sel_index', -1)
disabled = kwargs.pop('disabled', False)
options = kwargs.pop('options', None)
self.can_scroll = kwargs.pop('can_scroll', self.can_scroll)
self.option_getter = kwargs.pop('option_getter', None)
self.callback = kwargs.pop('callback', None)
self.variable = kwargs.pop('variable', None)
self.str_variable = kwargs.pop('str_variable', None)
self.max_index = kwargs.pop('max_index', self.max_index)
self.max_height = kwargs.pop('max_height', self.max_height)
self.f_widget_parent = kwargs.pop('f_widget_parent', None)
self.menu_width = kwargs.pop('menu_width', 0)
self.options_volatile = kwargs.pop('options_volatile', False)
self.default_text = kwargs.pop('default_text', e_c.INVALID_OPTION)
if self.max_height is None:
self.max_height = self.scroll_menu_max_height
kwargs.update(relief='sunken',
bd=self.listbox_depth,
bg=self.default_bg_color)
tk.Frame.__init__(self, *args, **kwargs)
if self.variable is None:
self.variable = tk.IntVar(self, sel_index)
self.write_trace(self.variable, lambda *a: self.update_label())
menu_width = self.menu_width if self.menu_width else self.scroll_menu_width
self.sel_label = tk.Label(self,
bg=self.enum_normal_color,
fg=self.text_normal_color,
bd=2,
relief='groove',
width=max(
min(menu_width,
self.scroll_menu_max_width), 1))
# the button_frame is to force the button to be a certain size
self.button_frame = tk.Frame(self,
relief='flat',
height=18,
width=18,
bd=0)
self.button_frame.pack_propagate(0)
self.arrow_button = tk.Button(self.button_frame, text="▼", width=2)
self.arrow_button.font_type = "fixed_small"
self.arrow_button.pack()
#self.arrow_button = ttk.Button(self.button_frame, text="▼", width=2)
#self.arrow_button.grid(row=1, column=1, sticky='news',
# ipadx=0, ipady=0, padx=0, pady=0)
self.sel_label.pack(side="left", fill="both", expand=True)
self.button_frame.pack(side="left", fill="both")
# make the option box to populate
option_frame_root = self.winfo_toplevel()
if hasattr(option_frame_root, "root_frame"):
option_frame_root = option_frame_root.root_frame
self.option_frame = tk.Frame(option_frame_root,
highlightthickness=0,
bd=0)
self.option_frame.pack_propagate(0)
self.option_bar = tk.Scrollbar(self.option_frame, orient="vertical")
self.option_box = tk.Listbox(
self.option_frame,
highlightthickness=0,
exportselection=False,
bg=self.enum_normal_color,
fg=self.text_normal_color,
selectbackground=self.enum_highlighted_color,
selectforeground=self.text_highlighted_color,
yscrollcommand=self.option_bar.set,
width=menu_width)
self.option_bar.config(command=self.option_box.yview)
# make sure the TagWindow knows these widgets are scrollable
for w in (self.sel_label, self.button_frame, self.arrow_button,
self.option_frame, self.option_bar, self.option_box):
w.can_scroll = self.can_scroll
w.f_widget_parent = self.f_widget_parent
# make bindings so arrow keys can be used to navigate the menu
self.button_frame.bind('<Up>', self.decrement_sel)
self.button_frame.bind('<Down>', self.increment_sel)
self.arrow_button.bind('<Up>', self.decrement_sel)
self.arrow_button.bind('<Down>', self.increment_sel)
self.option_bar.bind('<Up>', self.decrement_listbox_sel)
self.option_bar.bind('<Down>', self.increment_listbox_sel)
if e_c.IS_LNX:
self.sel_label.bind('<4>', self._mousewheel_scroll)
self.sel_label.bind('<5>', self._mousewheel_scroll)
self.button_frame.bind('<4>', self._mousewheel_scroll)
self.button_frame.bind('<5>', self._mousewheel_scroll)
self.arrow_button.bind('<4>', self._mousewheel_scroll)
self.arrow_button.bind('<5>', self._mousewheel_scroll)
else:
self.sel_label.bind('<MouseWheel>', self._mousewheel_scroll)
self.button_frame.bind('<MouseWheel>', self._mousewheel_scroll)
self.arrow_button.bind('<MouseWheel>', self._mousewheel_scroll)
self.sel_label.bind('<Button-1>', self.click_label)
self.arrow_button.bind('<ButtonRelease-1>', self.select_option_box)
self.arrow_button.bind('<Return>', self.select_option_box)
self.arrow_button.bind('<space>', self.select_option_box)
self.option_bar.bind('<FocusOut>', self.deselect_option_box)
self.option_bar.bind('<Return>', self.select_menu)
self.option_bar.bind('<space>', self.select_menu)
self.option_box.bind('<<ListboxSelect>>', self.select_menu)
self.set_disabled(disabled)
if options is not None:
self.set_options(options)
if self.str_variable is None:
self.str_variable = tk.StringVar(self, "")
def __init__(self, master, *args, **kwargs):
BinillaWidget.__init__(self)
self.temp_root = kwargs.pop('temp_root', self.temp_root)
textures = kwargs.pop('textures', ())
app_root = kwargs.pop('app_root', ())
self.image_canvas_ids = []
self.textures = []
self._image_handlers = {}
temp_name = str(int(random.random() * (1 << 32)))
self.temp_dir = os.path.join(self.temp_root, temp_name)
kwargs.update(relief='flat',
bd=self.frame_depth,
bg=self.default_bg_color)
tk.Frame.__init__(self, master, *args, **kwargs)
self.bitmap_index = tk.IntVar(self)
self.mipmap_index = tk.IntVar(self)
self.depth_index = tk.IntVar(self)
self.channel_index = tk.IntVar(self)
self.cube_display_index = tk.IntVar(self)
self.root_canvas = tk.Canvas(self, highlightthickness=0)
self.root_frame = tk.Frame(self.root_canvas, highlightthickness=0)
# create the root_canvas and the root_frame within the canvas
self.controls_frame0 = tk.Frame(self.root_frame, highlightthickness=0)
self.controls_frame1 = tk.Frame(self.root_frame, highlightthickness=0)
self.controls_frame2 = tk.Frame(self.root_frame, highlightthickness=0)
self.image_root_frame = tk.Frame(self.root_frame, highlightthickness=0)
self.image_canvas = tk.Canvas(self.image_root_frame,
highlightthickness=0,
bg=self.bitmap_canvas_bg_color)
self.depth_canvas = tk.Canvas(self.image_canvas,
highlightthickness=0,
bg=self.bitmap_canvas_bg_color)
self.bitmap_menu = ScrollMenu(self.controls_frame0,
menu_width=7,
variable=self.bitmap_index,
can_scroll=True)
self.mipmap_menu = ScrollMenu(self.controls_frame1,
menu_width=7,
variable=self.mipmap_index,
can_scroll=True)
self.depth_menu = ScrollMenu(self.controls_frame2,
menu_width=7,
variable=self.depth_index,
can_scroll=True)
self.channel_menu = ScrollMenu(self.controls_frame0,
menu_width=9,
variable=self.channel_index,
can_scroll=True)
self.cube_display_menu = ScrollMenu(self.controls_frame1,
menu_width=9,
variable=self.cube_display_index,
options=("cross", "linear"),
can_scroll=True)
self.save_button = ttk.Button(self.controls_frame2,
width=11,
text="Browse",
command=self.save_as)
self.depth_menu.default_text = self.mipmap_menu.default_text =\
self.bitmap_menu.default_text =\
self.channel_menu.default_text =\
self.cube_display_menu.default_text = ""
labels = []
labels.append(tk.Label(self.controls_frame0, text="Bitmap index"))
labels.append(tk.Label(self.controls_frame1, text="Mipmap level"))
labels.append(tk.Label(self.controls_frame2, text="Depth level"))
labels.append(tk.Label(self.controls_frame0, text="Channels"))
labels.append(tk.Label(self.controls_frame1, text="Cubemap display"))
labels.append(tk.Label(self.controls_frame2, text="Save to file"))
for lbl in labels:
lbl.config(width=15,
anchor='w',
bg=self.default_bg_color,
fg=self.text_normal_color,
disabledforeground=self.text_disabled_color)
self.hsb = tk.Scrollbar(self,
orient="horizontal",
command=self.root_canvas.xview)
self.vsb = tk.Scrollbar(self,
orient="vertical",
command=self.root_canvas.yview)
self.root_canvas.config(xscrollcommand=self.hsb.set,
xscrollincrement=1,
yscrollcommand=self.vsb.set,
yscrollincrement=1)
for w in [
self.root_frame, self.root_canvas, self.image_canvas,
self.controls_frame0, self.controls_frame1,
self.controls_frame2
] + labels:
if e_c.IS_LNX:
w.bind('<Shift-4>', self.mousewheel_scroll_x)
w.bind('<Shift-5>', self.mousewheel_scroll_x)
w.bind('<4>', self.mousewheel_scroll_y)
w.bind('<5>', self.mousewheel_scroll_y)
else:
w.bind('<Shift-MouseWheel>', self.mousewheel_scroll_x)
w.bind('<MouseWheel>', self.mousewheel_scroll_y)
# pack everything
# pack in this order so scrollbars aren't shrunk
self.root_frame_id = self.root_canvas.create_window(
(0, 0), anchor="nw", window=self.root_frame)
self.hsb.pack(side='bottom', fill='x', anchor='nw')
self.vsb.pack(side='right', fill='y', anchor='nw')
self.root_canvas.pack(fill='both', anchor='nw', expand=True)
self.controls_frame0.pack(side='top', fill='x', anchor='nw')
self.controls_frame1.pack(side='top', fill='x', anchor='nw')
self.controls_frame2.pack(side='top', fill='x', anchor='nw')
self.image_root_frame.pack(fill='both', anchor='nw', expand=True)
self.image_canvas.pack(fill='both',
side='right',
anchor='nw',
expand=True)
padx = self.horizontal_padx
pady = self.horizontal_pady
for lbl in labels[:3]:
lbl.pack(side='left', padx=(25, 0), pady=pady)
self.bitmap_menu.pack(side='left', padx=padx, pady=pady)
self.mipmap_menu.pack(side='left', padx=padx, pady=pady)
self.depth_menu.pack(side='left', padx=padx, pady=pady)
for lbl in labels[3:]:
lbl.pack(side='left', padx=(15, 0), pady=pady)
self.save_button.pack(side='left', padx=padx, pady=pady)
self.channel_menu.pack(side='left', padx=padx, pady=pady)
self.cube_display_menu.pack(side='left', padx=padx, pady=pady)
self.change_textures(textures)
self.write_trace(self.bitmap_index, self.settings_changed)
self.write_trace(self.mipmap_index, self.settings_changed)
self.write_trace(self.depth_index, self.settings_changed)
self.write_trace(self.cube_display_index, self.settings_changed)
self.write_trace(self.channel_index, self.settings_changed)
self.apply_style()
def populate(self):
'''Destroys and rebuilds this widgets children.'''
orient = self.desc.get('ORIENT', 'v')[:1].lower()
vertical = True
assert orient in ('v', 'h')
content = self
if getattr(self, 'content', None):
content = self.content
if self.show_title and content in (None, self):
content = tk.Frame(self,
relief="sunken",
bd=self.frame_depth,
bg=self.default_bg_color)
self.content = content
# clear the f_widget_ids list
self.f_widget_ids = []
self.f_widget_ids_map = {}
self.f_widget_ids_map_inv = {}
# destroy all the child widgets of the content
for w in self.f_widgets.values():
w.destroy()
node = self.node
desc = self.desc
picker = self.widget_picker
tag_window = self.tag_window
self.display_comment(self.content)
# if the orientation is horizontal, remake its label
if orient == 'h':
vertical = False
self.title_label = tk.Label(self,
anchor='w',
justify='left',
width=self.title_size,
text=self.gui_name,
bg=self.default_bg_color,
fg=self.text_normal_color)
if self.gui_name != '':
self.title_label.pack(fill="x", side="left")
self.sidetip_label = tk.Label(self,
anchor='w',
justify='left',
bg=self.default_bg_color,
fg=self.text_normal_color)
for w in (self, self.content):
w.tooltip_string = self.desc.get('TOOLTIP')
if getattr(self, 'title', None):
self.title.tooltip_string = self.tooltip_string
if getattr(self, 'title_label', None):
self.title_label.tooltip_string = self.tooltip_string
field_indices = range(desc['ENTRIES'])
# if the node has a steptree node, include its index in the indices
if 'STEPTREE' in desc:
field_indices = tuple(field_indices) + ('STEPTREE', )
kwargs = dict(parent=node,
tag_window=tag_window,
f_widget_parent=self,
disabled=self.disabled,
vert_oriented=vertical)
visible_field_count = self.visible_field_count
# if only one sub-widget being displayed, dont
# display the title of the widget being displayed
if self.field_count != visible_field_count and visible_field_count < 2:
if 'STEPTREE' not in desc or not self.get_visible(
desc['STEPTREE'].get('VISIBLE', True)):
# only make the title not shown if the only
# visible widget will not be the subtree
kwargs.update(show_title=False)
kwargs.update(dont_padx_fields=True)
if self.dont_padx_fields:
kwargs.update(pack_padx=0)
elif visible_field_count < 2 and not self.show_title:
# Use this widgets x padding amount so that its
# singular child appears where this widget would.
kwargs.update(use_parent_pack_padx=True)
# loop over each field and make its widget
sub_node = None
for i in field_indices:
sub_desc = desc[i]
if hasattr(node, "__getitem__"):
sub_node = node[i]
if hasattr(sub_node, 'desc'):
sub_desc = sub_node.desc
# if the field shouldnt be visible, dont make its widget
if not self.get_visible(sub_desc.get('VISIBLE', True)):
continue
widget_cls = picker.get_widget(sub_desc)
if i == field_indices[-1] and vertical:
kwargs.update(pack_pady=0)
try:
widget = widget_cls(content,
node=sub_node,
attr_index=i,
desc=sub_desc,
**kwargs)
except Exception:
print(format_exc())
widget = data_frame.NullFrame(content,
node=sub_node,
attr_index=i,
desc=sub_desc,
**kwargs)
wid = id(widget)
self.f_widget_ids.append(wid)
self.f_widget_ids_map[i] = wid
self.f_widget_ids_map_inv[wid] = i
self.build_f_widget_cache()
# now that the field widgets are created, position them
if self.show.get():
self.pose_fields()
def __init__(self, *args, **kwargs):
kwargs.update(relief='flat',
bd=0,
highlightthickness=0,
bg=self.default_bg_color)
field_widget.FieldWidget.__init__(self, *args, **kwargs)
tk.Frame.__init__(self, *args, **e_c.fix_kwargs(**kwargs))
show_frame = bool(
kwargs.pop('show_frame', not self.blocks_start_hidden))
if self.is_empty and self.hide_if_blank:
show_frame = False
self.show = tk.BooleanVar()
self.show.set(show_frame)
self.options_sane = False
node_len = 0
try:
node_len = len(self.node)
except Exception:
pass
self.sel_index = (node_len > 0) - 1
# make the title, element menu, and all the buttons
self.controls = tk.Frame(self, relief='raised', bd=self.frame_depth)
self.title = title = tk.Frame(self.controls, relief='flat', bd=0)
self.buttons = buttons = tk.Frame(self.controls, relief='flat', bd=0)
toggle_text = '-' if show_frame else '+'
self.title_label = tk.Label(
title,
text=self.gui_name,
justify='left',
anchor='w',
width=self.title_size,
font=self.get_font("frame_title"),
disabledforeground=self.text_disabled_color)
self.title_label.font_type = "frame_title"
self.show_btn = ttk.Checkbutton(title,
width=3,
text=toggle_text,
command=self.toggle_visible,
style='ShowButton.TButton')
self.sel_menu = ScrollMenu(title,
f_widget_parent=self,
sel_index=self.sel_index,
max_index=node_len - 1,
option_getter=self.get_options,
callback=self.select_option)
self.shift_up_btn = ttk.Button(title,
width=7,
text='Shift ▲',
command=self.shift_entry_up)
self.shift_down_btn = ttk.Button(buttons,
width=7,
text='Shift ▼',
command=self.shift_entry_down)
self.add_btn = ttk.Button(buttons,
width=4,
text='Add',
command=self.add_entry)
self.insert_btn = ttk.Button(buttons,
width=6,
text='Insert',
command=self.insert_entry)
self.duplicate_btn = ttk.Button(buttons,
width=9,
text='Duplicate',
command=self.duplicate_entry)
self.delete_btn = ttk.Button(buttons,
width=6,
text='Delete',
command=self.delete_entry)
self.delete_all_btn = ttk.Button(buttons,
width=10,
text='Delete all',
command=self.delete_all_entries)
self.import_btn = ttk.Button(buttons,
width=6,
text='Import',
command=self.import_node)
self.export_btn = ttk.Button(buttons,
width=6,
text='Export',
command=self.export_node)
# pack the title, menu, and all the buttons
for w in (self.shift_down_btn, self.export_btn, self.import_btn,
self.delete_all_btn, self.delete_btn, self.duplicate_btn,
self.insert_btn, self.add_btn):
w.pack(side="right", padx=(0, 4), pady=(2, 2))
self.show_btn.pack(side="left")
if self.gui_name != '':
self.title_label.pack(side="left", fill="x", expand=True)
self.sel_menu.pack(side="left", fill="x", expand=True, padx=(0, 4))
self.shift_up_btn.pack(side="right", padx=(0, 1), pady=(2, 2))
self.title.pack(fill="x", expand=True, padx=0)
self.buttons.pack(fill="x", expand=True, padx=0)
self.controls.pack(fill="x", expand=True, padx=0)
self.populate()
self._initialized = True
def __init__(self, *args, **kwargs):
field_widget.FieldWidget.__init__(self, *args, **kwargs)
self.u_node_widgets_by_u_index = {}
if self.f_widget_parent is None:
self.pack_padx = self.pack_pady = 0
kwargs.update(relief='flat',
bd=0,
highlightthickness=0,
bg=self.default_bg_color)
show_frame = bool(
kwargs.pop('show_frame', not self.blocks_start_hidden))
if self.is_empty and self.hide_if_blank:
show_frame = False
tk.Frame.__init__(self, *args, **e_c.fix_kwargs(**kwargs))
self.show = tk.BooleanVar(self)
self.show.set(show_frame)
max_u_index = len(self.desc['CASE_MAP'])
u_index = getattr(self.node, "u_index", None)
if u_index is None:
u_index = max_u_index
toggle_text = '-' if show_frame else '+'
self.title = tk.Frame(self, relief='raised')
self.show_btn = ttk.Checkbutton(self.title,
width=3,
text=toggle_text,
command=self.toggle_visible,
style='ShowButton.TButton')
self.title_label = tk.Label(self.title,
text=self.gui_name,
anchor='w',
width=self.title_size,
justify='left')
self.title_label.font_type = "frame_title"
self.sel_menu = ScrollMenu(self.title,
f_widget_parent=self,
sel_index=u_index,
max_index=max_u_index,
disabled=self.disabled,
callback=self.select_option,
option_getter=self.get_options)
self.show_btn.pack(side="left")
self.title_label.pack(side="left", fill="x", expand=True)
self.sel_menu.pack(side="left", fill="x")
self.title.pack(fill="x", expand=True)
self.content = tk.Frame(self, relief="sunken")
# make the default raw bytes union frame
self.raw_frame = tk.Frame(self.content, relief="flat", bd=0)
self.raw_label = tk.Label(self.raw_frame,
text='DataUnion',
width=self.title_size,
anchor='w',
disabledforeground=self.text_disabled_color)
self.import_btn = ttk.Button(self.raw_frame,
text='Import',
command=self.import_node,
width=7)
self.export_btn = ttk.Button(self.raw_frame,
text='Export',
command=self.export_node,
width=7)
self.raw_label.pack(side="left", expand=True, fill='x')
for w in (self.export_btn, self.import_btn):
w.pack(side="left", padx=(0, 4), pady=2)
self.populate()
self._initialized = True
def __init__(self, *args, **kwargs):
kwargs.update(relief='flat',
bd=0,
highlightthickness=0,
bg=self.default_bg_color)
data_frame.DataFrame.__init__(self, *args, **kwargs)
# make the widgets
self.content = tk.Frame(self, relief='flat', bd=0)
self.title_label = tk.Label(
self.content,
text=self.gui_name,
justify='left',
anchor='w',
disabledforeground=self.text_disabled_color,
width=self.title_size)
self.data_text = tk.Text(
self.content,
wrap=tk.NONE,
maxundo=self.max_undos,
undo=True,
height=self.textbox_height,
width=self.textbox_width,
state=tk.DISABLED if self.disabled else tk.NORMAL)
self.sidetip_label = tk.Label(self.content, anchor='w', justify='left')
self.hsb = tk.Scrollbar(self.content,
orient='horizontal',
command=self.data_text.xview)
self.vsb = tk.Scrollbar(self.content,
orient='vertical',
command=self.data_text.yview)
self.data_text.config(xscrollcommand=self.hsb.set,
yscrollcommand=self.vsb.set)
self.hsb.can_scroll = self.children_can_scroll
self.vsb.can_scroll = self.children_can_scroll
self.data_text.can_scroll = self.children_can_scroll
self.hsb.f_widget_parent = self
self.vsb.f_widget_parent = self
self.data_text.f_widget_parent = self
self.data_text.bind('<FocusOut>', self.flush)
self.data_text.bind('<Return>', self.set_modified)
self.data_text.bind('<Any-KeyPress>', self.set_modified)
self.data_text.text_undo = self._text_undo
self.data_text.text_redo = self._text_redo
self.data_text.bind('<Control-z>', self.disable_undo_redo)
self.data_text.bind('<Control-y>', self.disable_undo_redo)
if self.gui_name != '':
self.title_label.pack(fill="x")
self.hsb.pack(side="bottom", fill='x', expand=True)
self.vsb.pack(side="right", fill='y')
self.data_text.pack(side="right", fill="x", expand=True)
self.content.pack(fill="both", expand=True)
self.build_replace_map()
self.reload()
self._initialized = True
def post_toplevel_init(self):
self.update_title()
try:
self.iconbitmap(self.iconbitmap_filepath)
except Exception:
print("Could not load window icon.")
self.creating_label = tk.Label(
self, text=("Creating widgets. Please wait..."))
self.styling_label = tk.Label(self,
text=("Styling widgets. Please wait..."))
# create the root_canvas and the root_frame within the canvas
self.root_canvas = rc = tk.Canvas(self, highlightthickness=0)
self.root_frame = rf = tk.Frame(rc, highlightthickness=0)
# create and set the x and y scrollbars for the root_canvas
self.root_hsb = tk.Scrollbar(self,
orient='horizontal',
command=rc.xview)
self.root_vsb = tk.Scrollbar(self, orient='vertical', command=rc.yview)
rc.config(xscrollcommand=self.root_hsb.set,
xscrollincrement=1,
yscrollcommand=self.root_vsb.set,
yscrollincrement=1)
self.root_frame_id = rc.create_window((0, 0), window=rf, anchor='nw')
# make it so if this window is selected it changes the
# selected_tag attribute of self.app_root to self.tag
self.bind('<Button>', self.select_window)
self.bind('<FocusIn>', self.select_window)
rf.bind('<Configure>', self._resize_canvas)
rc.bind('<Configure>', self._resize_frame)
# make the window not show up on the start bar
if self.app_root:
self.transient(self.app_root)
# populate the window
self.creating_label.pack(fill="both", expand=True)
self.populate()
# pack da stuff
self.root_hsb.pack(side=t_c.BOTTOM, fill='x')
self.root_vsb.pack(side=t_c.RIGHT, fill='y')
# set the hotkey bindings
self.bind_hotkeys()
# if this tag doesnt exist at the given filepath, it's new.
try:
new = not self.tag.filepath.is_file()
except Exception:
new = True
if new:
try:
self.field_widget.set_edited()
except Exception:
pass
self.creating_label.pack_forget()
def setup_window(self, *args, **kwargs):
ConverterBase.setup_window(self, *args, **kwargs)
self.include_weather_polyhedra = tk.IntVar(self, 1)
self.include_fog_planes = tk.IntVar(self, 1)
self.include_portals = tk.IntVar(self, 1)
self.include_collision = tk.IntVar(self, 1)
self.include_renderable = tk.IntVar(self, 1)
self.include_mirrors = tk.IntVar(self, 0)
self.include_lightmaps = tk.IntVar(self, 0)
self.include_markers = tk.IntVar(self, 1)
self.include_lens_flares = tk.IntVar(self, 0)
self.fan_portals = tk.IntVar(self, 1)
self.fan_weather_polyhedra = tk.IntVar(self, 1)
self.fan_fog_planes = tk.IntVar(self, 1)
self.fan_mirrors = tk.IntVar(self, 1)
self.fan_collision = tk.IntVar(self, 1)
self.optimize_portals = tk.IntVar(self, 0)
self.optimize_fog_planes = tk.IntVar(self, 0)
self.weather_tolerance_string = tk.StringVar(
self, str(self.weather_tolerance))
self.weather_tolerance_string.trace(
"w", lambda *a, s=self: s.set_weather_tolerance())
# make the frames
self.include_frame = tk.LabelFrame(self,
text="Geometry/markers to include")
self.weather_tolerance_frame = tk.LabelFrame(
self, text="Weather polyhedron tolerance")
self.topology_frame = tk.LabelFrame(self, text="Topology generation")
# Generate the important frame and its contents
include_vars = {
"Weather polyhedra": self.include_weather_polyhedra,
"Fog planes": self.include_fog_planes,
"Portals": self.include_portals,
"Collidable": self.include_collision,
"Renderable": self.include_renderable,
"Mirrors": self.include_mirrors,
"Lightmaps": self.include_lightmaps,
"Markers": self.include_markers,
"Lens flares": self.include_lens_flares
}
self.include_buttons = []
for text in ("Collidable", "Portals", "Renderable",
"Weather polyhedra", "Fog planes", "Markers", "Mirrors",
"Lens flares", "Lightmaps"):
self.include_buttons.append(
tk.Checkbutton(self.include_frame,
variable=include_vars[text],
text=text))
# Generate the topology frame and its contents
topology_vars = {
"Weather polyhedra": self.fan_weather_polyhedra,
"Fog planes": self.fan_fog_planes,
"Mirrors": self.fan_mirrors,
"Portals": self.fan_portals,
"Collision": self.fan_collision
}
self.topology_frames = []
self.topology_labels = []
self.topology_buttons = []
for text in ("Portals", "Fog planes", "Weather polyhedra", "Mirrors",
"Collision"):
var = topology_vars[text]
f = tk.Frame(self.topology_frame)
name_lbl = tk.Label(f, text=text, width=17, anchor="w")
fan_cbtn = tk.Checkbutton(f, variable=var, text="Triangle fan")
strip_cbtn = tk.Checkbutton(f,
variable=var,
text="Triangle strip",
onvalue=0,
offvalue=1)
self.topology_frames.append(f)
self.topology_labels.append(name_lbl)
self.topology_buttons.extend((fan_cbtn, strip_cbtn))
if text == "Portals":
self.topology_buttons.append(
tk.Checkbutton(f,
variable=self.optimize_portals,
text="Optimize"))
elif text == "Fog planes":
self.topology_buttons.append(
tk.Checkbutton(f,
variable=self.optimize_fog_planes,
text="Optimize"))
self.weather_tolerance_info = tk.Label(
self.weather_tolerance_frame,
justify='left',
anchor="w",
text=
("Due to how weather polyhedrons work, there is no geometry to extract, so it must be generated. \n"
"My method for doing this isn't perfect, so sometimes geometry will be missing faces. Adjust this\n"
"value to find the sweet spot. NEVER set to 0, and be wary of setting to 0.0001 or higher.\n"
"\tNOTE: You will probably need to manually clean up the generated geometry a bit."
))
self.weather_tolerance_spinbox = tk.Spinbox(
self.weather_tolerance_frame,
from_=self.min_weather_tolerance,
to=100,
width=25,
increment=self.weather_tolerance,
textvariable=self.weather_tolerance_string,
justify="right")
self.pack_widgets()
self.apply_style()
def generate_widgets(self):
if self._initialized:
return
pr_version_str = "%s.%s.%s" % version_info[:3]
tk_version_str = str(tk.TkVersion)
main_frame = tk.Frame(self, borderwidth=0, relief='sunken')
buttons_frame = tk.Frame(self)
header_frame = tk.Frame(main_frame)
py_label_frame = tk.Frame(header_frame, borderwidth=0)
app_image_button = None
if os.path.isfile(self.appbitmap_filepath):
self.app_image = tk.PhotoImage(file=self.appbitmap_filepath)
app_image_button = tk.Button(header_frame,
text='[picture]',
bd=0,
image=self.app_image,
relief='flat',
command=self._pressed,
highlightthickness=0)
app_name_label = tk.Label(header_frame,
text=self.app_name,
font=self.get_font("heading"))
app_name_label.font_type = "heading"
python_ver_label = tk.Label(py_label_frame,
text='Python version: %s' %
pr_version_str)
tk_ver_label = tk.Label(py_label_frame,
text='Tk version: %s' % tk_version_str)
close_button = tk.Button(buttons_frame,
text='Close',
width=12,
command=self.destroy)
modules_frame = tk.Frame(main_frame, borderwidth=0)
names = tuple(sorted(self.module_infos))
max_width = 1
if len(names) > 3:
max_width = 2
x = y = 0
for name in names:
info = self.module_infos[name]
proper_name = self.get_proper_module_name(name)
accelerated_str = ""
if info.get("accelerated", None) is not None:
accelerated_str = " - " + ("Fast" if info["accelerated"] else
"Slow")
module_frame = tk.LabelFrame(
modules_frame,
text="%s - %s: %s%s" %
(info["date"], proper_name, self.get_version_string(name),
accelerated_str))
license_button = tk.Button(module_frame,
text='License',
width=8,
command=lambda s=self, n=name: s.
display_module_text(n, "license"))
readme_button = tk.Button(module_frame,
text='Readme',
width=8,
command=lambda s=self, n=name: s.
display_module_text(n, "readme"))
browse_button = tk.Button(
module_frame,
text='Browse',
width=8,
command=lambda s=self, n=name: s.open_module_location(n))
browse_button.pack(expand=True,
fill='both',
side='left',
padx=6,
pady=4)
license_button.pack(expand=True,
fill='both',
side='left',
padx=6,
pady=4)
readme_button.pack(expand=True,
fill='both',
side='left',
padx=6,
pady=4)
if not info["location"]:
browse_button.config(state="disabled")
if not info["license"]:
license_button.config(state="disabled")
if not info["readme"]:
readme_button.config(state="disabled")
module_frame.grid(row=y, column=x, sticky="news")
x += 1
if x == max_width:
x = 0
y += 1
app_name_label.pack(padx=10, fill='both')
if app_image_button:
app_image_button.pack(padx=0, pady=3)
py_label_frame.pack(padx=10, pady=0)
python_ver_label.pack(padx=10, pady=0, side='left')
tk_ver_label.pack(padx=10, pady=0, side='right')
close_button.pack(padx=5, pady=5)
header_frame.pack(expand=True, fill="both")
main_frame.pack(expand=True, fill="both")
modules_frame.pack(fill='both')
buttons_frame.pack(fill="x")
self._initialized = True
def __init__(self, *args, **kwargs):
field_widget.FieldWidget.__init__(self, *args, **kwargs)
orient = self.desc.get('ORIENT', 'v')[:1].lower()
assert orient in ('v', 'h')
self.show_title = kwargs.pop(
'show_title', orient == 'v' and self.f_widget_parent is not None)
# if only one sub-widget being displayed, dont display the title
if not self.show_title or self.visible_field_count < 2:
self.show_title = False
self.dont_padx_fields = True
if self.f_widget_parent is None:
self.pack_padx = self.pack_pady = 0
kwargs.update(relief='flat', bd=0, highlightthickness=0)
show_frame = True
if self.f_widget_parent is not None:
show_frame = bool(
kwargs.pop('show_frame', not self.blocks_start_hidden))
if self.is_empty and self.hide_if_blank:
show_frame = False
tk.Frame.__init__(self, *args, **e_c.fix_kwargs(**kwargs))
self.show = tk.BooleanVar(self)
# if the orientation is vertical, make a title frame
if self.show_title:
self.show.set(show_frame)
toggle_text = '-' if show_frame else '+'
self.title = tk.Frame(self, relief='raised')
self.show_btn = ttk.Checkbutton(self.title,
width=3,
text=toggle_text,
command=self.toggle_visible,
style='ShowButton.TButton')
self.title_label = tk.Label(self.title,
text=self.gui_name,
anchor='w',
width=self.title_size,
justify='left',
font=self.get_font("frame_title"))
self.title_label.font_type = "frame_title"
self.import_btn = ttk.Button(self.title,
width=7,
text='Import',
command=self.import_node)
self.export_btn = ttk.Button(self.title,
width=7,
text='Export',
command=self.export_node)
self.show_btn.pack(side="left")
if self.gui_name != '':
self.title_label.pack(fill="x", expand=True, side="left")
for w in (self.export_btn, self.import_btn):
w.pack(side="right", padx=(0, 4), pady=2)
self.title.pack(fill="x", expand=True)
else:
self.show.set(True)
self.populate()
self._initialized = True