def __init__(self, project_history_tracker=None, *args, **kw):
GUIDialog.__init__(self, *args, **kw)
self.title(_("Description creation"))
self.focus()
self.grid()
self.columnconfigure(0, weight=0)
self.columnconfigure(1, weight=1)
self.pht = project_history_tracker
self.rowconfigure(0, weight=0)
l = VarLabel(self, text=_("Description name"))
l.grid(row=0, column=0, sticky="NES")
v = self.var_name = StringVar()
e = self.e_name = HKEntry(self, textvariable=v)
e.grid(row=0, column=1, sticky="NEWS")
# Set input focus to description name entry initially.
e.focus_set()
v.trace_variable("w", self.on_var_name_write)
if self.pht is not None:
# do not generate name in demo mode
v.set(self.pht.p.gen_uniq_desc_name())
# autoselect default name to speed up its customization
e.selection_range(0, END)
self.rowconfigure(1, weight=0)
l = VarLabel(self, text=_("Description kind"))
l.grid(row=1, column=0, sticky="NES")
v = self.var_kind = StringVar()
cb = self.cb_kind = VarCombobox(self,
textvariable=v,
values=[
_("System bus device template"),
_("Machine draft"),
_("PCI(E) function template")
],
state="readonly")
v.set(cb.cget("values")[0].get())
cb.grid(row=1, column=1, sticky="NEWS")
cb.config(width=max([len(s.get()) for s in cb.cget("values")]))
self.rowconfigure(2, weight=0)
b = VarButton(self, text=_("Add"), command=self.on_add)
b.grid(row=2, column=0, columns=2, sticky="NES")
self.bind("<Escape>", self.on_escape, "+")
# corresponds to 'Enter' key
self.bind("<Return>", self.on_enter, "+")
def gen_prop_value_widget(self, prop_type, prop_val):
if prop_type == QOMPropertyTypeLink:
var = StringVar()
keys = [ DeviceSettingsWidget.gen_node_link_text(n) \
for n in [ None ] + list(self.dsw.mach.id2node.values())
]
ret = Combobox(self.dsw.props_lf,
textvariable = var,
values = keys,
state = "readonly"
)
if prop_val:
current = DeviceSettingsWidget.gen_node_link_text(prop_val)
else:
current = keys[0]
var.set(current)
elif prop_type == QOMPropertyTypeBoolean:
var = BooleanVar()
ret = VarCheckbutton(
self.dsw.props_lf,
text = StringVar(""),
variable = var
)
if prop_val is None:
current = False
else:
current = bool(prop_val)
var.set(current)
else:
var = StringVar()
ret = HKEntry(
self.dsw.props_lf,
textvariable = var
)
if prop_val:
if prop_type == QOMPropertyTypeInteger:
current = prop_type.build_val(prop_val)
else:
current = str(prop_val)
else:
if prop_type == QOMPropertyTypeInteger:
current = "0x0"
else:
current = ""
var.set(current)
return ret, var
def __init__(self, irq, *args, **kw):
SettingsWidget.__init__(self, irq, *args, **kw)
self.irq = irq
for pfx, txt in [
("src_", _("Source")),
("dst_", _("Destination"))
]:
lf = VarLabelFrame(self, text = txt)
lf.pack(fill = BOTH, expand = False)
lf.columnconfigure(0, weight = 0)
lf.columnconfigure(1, weight = 1)
for row in xrange(0, 3):
lf.rowconfigure(row, weight = 1)
l = VarLabel(lf, text = _("Node"))
l.grid(row = 0, column = 0, sticky = "NE")
node_var = StringVar()
node_var.trace_variable("w", self.on_node_text_changed)
node_cb = Combobox(lf,
textvariable = node_var,
values = [],
state = "readonly"
)
node_cb.grid(row = 0, column = 1, sticky = "NEW")
irq_idx_l = VarLabel(lf, text = _("GPIO index"))
irq_idx_l.grid(row = 1, column = 0, sticky = "NE")
irq_idx_var = StringVar()
irq_idx_e = HKEntry(lf, textvariable = irq_idx_var)
irq_idx_e.grid(row = 1, column = 1, sticky = "NEW")
irq_name_l = VarLabel(lf, text = _("GPIO name"))
irq_name_l.grid(row = 2, column = 0, sticky = "NE")
irq_name_var = StringVar()
irq_name_e = HKEntry(lf, textvariable = irq_name_var)
irq_name_e.grid(row = 2, column = 1, sticky = "NEW")
for v in ["lf", "node_var", "node_cb",
"irq_idx_l", "irq_idx_e", "irq_idx_var",
"irq_name_l", "irq_name_e", "irq_name_var"]:
setattr(self, pfx + v, locals()[v])
self.__auto_var_base_cbs = None
self.v_var_base.trace_variable("w", self.__on_var_base)
def __init__(self, bus, *args, **kw):
SettingsWidget.__init__(self, bus, *args, **kw)
self.bus = bus
self.bus_fr = fr = GUIFrame(self)
fr.pack(fill=BOTH, expand=False)
fr.columnconfigure(0, weight=0)
fr.columnconfigure(1, weight=1)
fr.rowconfigure(0, weight=0)
l = VarLabel(fr, text=_("Parent device"))
l.grid(row=0, column=0, sticky="NES")
self.var_parent = StringVar()
self.cb_parent = Combobox(fr,
textvariable=self.var_parent,
state="readonly")
self.cb_parent.grid(row=0, column=1, sticky="NEWS")
self.fields = []
if type(bus) is BusNode:
self.fields.extend([(_("C type"), "c_type", str),
(_("Casting macro"), "cast", str),
(_("Child name"), "child_name", str),
(_("Always show index"), "force_index", bool)])
# Common bus type
for row, (text, field, _type) in enumerate(self.fields, start=1):
if _type is str:
l = VarLabel(fr, text=text)
v = StringVar()
w = HKEntry(fr, textvariable=v)
elif _type is bool:
l = None
v = BooleanVar()
w = VarCheckbutton(fr, text=text, variable=v)
fr.rowconfigure(row, weight=0)
if l is None:
w.grid(row=row, column=0, sticky="NEWS", columnspan=2)
else:
l.grid(row=row, column=0, sticky="NES")
w.grid(row=row, column=1, sticky="NEWS")
setattr(self, "w_" + field, w)
setattr(self, "var_" + field, v)
def __init__(self, master, repo, *a, **kw):
GUIFrame.__init__(self, master, *a, **kw)
if repo is None:
refname = ""
refs = []
else:
# auto select HEAD as ref
try:
refname = repo.head.ref.name
except TypeError:
refname = repo.head.commit.hexsha
refs = [r.name for r in repo.references]
selected = StringVar()
cb = Combobox(self,
width = 41, # To fit 40 hex digits of git SHA1
values = refs,
textvariable = selected
)
cb.pack(side = "top", fill = "x", expand = True)
selected.set(refname)
self.selected = selected
def __init__(self, master):
'''Create a new panel with the given parent.'''
Frame.__init__(self, master)
self._ship_name = StringVar()
self._create_ui()
self.reset()
def add(self, itemType, cnf = {}, **kw):
# handle variable text only for items which have such parameters
if itemType in [
# "radiobutton" - TODO: check it
"cascade",
"command",
"checkbutton"
# "separator" - does not have such parameters
]:
for param in ["label", "accelerator"]:
if param in cnf:
var = cnf.pop(param)
elif param in kw:
var = kw.pop(param)
else:
var = ""
if not isinstance(var, variables):
var = StringVar(self, var)
binding = MenuVarBinding(self, var, self.count, param)
var.trace_variable("w", binding.on_var_changed)
if cnf:
cnf[param] = var.get()
else:
kw[param] = var.get()
self.count = self.count + 1
Menu.add(self, itemType, cnf or kw)
def __init__(self, *args, **kw):
QOMDescriptionSettingsWidget.__init__(self, *args, **kw)
self.mw = None
self.var_tabs = v = BooleanVar()
self.buttons_fr.columnconfigure(2, weight=0)
chb = VarCheckbutton(self.buttons_fr, text=_("Use tabs"), variable=v)
chb.grid(row=0, column=2, sticky="NEWS")
v.trace_variable("w", self.__on_tabs__)
# mesh step seleection
self.buttons_fr.columnconfigure(3, weight=0)
self.buttons_fr.columnconfigure(4, weight=0)
self.buttons_fr.columnconfigure(5, weight=0)
Separator(self.buttons_fr, orient=VERTICAL).grid(row=0,
column=3,
sticky="NEWS")
l = VarLabel(self.buttons_fr, text=_("Mesh step:"))
l.grid(row=0, column=4, sticky="NEWS")
self.var_mesh_step = v = StringVar()
v.trace_variable("w", self.__on_mesh_step)
self.mesh_step_sb = sb = Spinbox(self.buttons_fr,
from_=MIN_MESH_STEP,
to=MAX_MESH_STEP,
textvariable=v,
width=len(str(MAX_MESH_STEP)))
sb.grid(row=0, column=5, sticky="NEWS")
self.var_tabs.set(True)
def __init__(self, root=None):
"""init"""
self.root = root or Tk()
self.root.title('Pylint')
#reporter
self.reporter = None
#message queue for output from reporter
self.msg_queue = six.moves.queue.Queue()
self.msgs = []
self.visible_msgs = []
self.filenames = []
self.rating = StringVar()
self.tabs = {}
self.report_stream = BasicStream(self)
#gui objects
self.lb_messages = None
self.showhistory = None
self.results = None
self.btnRun = None
self.information_box = None
self.convention_box = None
self.refactor_box = None
self.warning_box = None
self.error_box = None
self.fatal_box = None
self.txtModule = None
self.status = None
self.msg_type_dict = None
self.init_gui()
def on_b1_press_dt(self, event):
item = self.device_tree.identify('item', event.x, event.y)
if item:
self.add_button.config(state="active")
for widget in self.fr.winfo_children():
widget.destroy()
dt_type = self.device_tree.item(item, "text")
self.v = StringVar()
self.v.set(dt_type) # initialize
b = Radiobutton(self.fr,
text=dt_type,
variable=self.v,
value=dt_type)
b.pack(anchor="w")
macros = self.device_tree.item(item, "values")[0]
if not macros == "None":
l = macros.split(" ")
for mstr in l:
b = Radiobutton(self.fr,
text=mstr,
variable=self.v,
value=mstr)
b.pack(anchor="w")
b.select()
def _init_corpus_select(self, parent):
innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
self.var = StringVar(innerframe)
self.var.set(self.model.DEFAULT_CORPUS)
Label(
innerframe,
justify=LEFT,
text=' Corpus: ',
background=self._BACKGROUND_COLOUR,
padx=2,
pady=1,
border=0,
).pack(side='left')
other_corpora = list(self.model.CORPORA.keys()).remove(
self.model.DEFAULT_CORPUS)
om = OptionMenu(innerframe,
self.var,
self.model.DEFAULT_CORPUS,
command=self.corpus_selected,
*self.model.non_default_corpora())
om['borderwidth'] = 0
om['highlightthickness'] = 1
om.pack(side='left')
innerframe.pack(side='top', fill='x', anchor='n')
def gen_str_widgets(self, master):
v = StringVar()
w = HKEntry(master, textvariable = v)
w._validate = lambda : True
w._set_color = lambda color : w.config(bg = color)
w._cast = lambda x : x
return v, w
def __init__(self, node, machine, *args, **kw):
GUIFrame.__init__(self, *args, **kw)
try:
self.mht = self.winfo_toplevel().mht
except AttributeError:
# snapshot mode
self.mht = None
if self.mht is not None:
self.mht.watch_changed(self.on_changed)
self.node = node
self.mach = machine
self.node_fr = fr = GUIFrame(self)
fr.pack(fill = BOTH, expand = False)
fr.columnconfigure(0, weight = 0)
fr.columnconfigure(1, weight = 1)
# variable name base editing
fr.rowconfigure(0, weight = 0)
VarLabel(fr,
text = _("Variable name base")
).grid(
row = 0,
column = 0,
sticky = "NSW"
)
self.v_var_base = v = StringVar()
HKEntry(fr,
textvariable = v
).grid(
row = 0,
column = 1,
sticky = "NESW"
)
fr.rowconfigure(1, weight = 0)
VarLabel(fr,
text = _("Name of variable")
).grid(
row = 1,
column = 0,
sticky = "NSW"
)
HKEntry(fr,
text = machine.node_id2var_name[node.id],
state = "readonly"
).grid(
row = 1,
column = 1,
sticky = "NESW"
)
self.refresh_after = self.after(0, self.__refresh_single__)
self.bind("<Destroy>", self.__on_destroy__)
def __init__(self, *args, **kw):
if "text" in kw:
self.text_var = kw.pop("text")
kw["text"] = self.text_var.get()
else:
self.text_var = StringVar("")
Button.__init__(self, *args, **kw)
self.text_var.trace_variable("w", self.on_var_changed)
def __refresh__(self):
desc = self.desc
for attr, info in desc.__attribute_info__.items():
try:
_input = info["input"]
except KeyError:
_input = None
cur_val = getattr(desc, attr)
v = getattr(self, "_var_" + attr)
if _input is PCIId:
if not PCIId.db.built and cur_val is None:
# use string values only without database
cur_val = ""
# use appropriate widget/variable pair
if isinstance(cur_val, str):
if not isinstance(v, StringVar):
v = StringVar()
setattr(self, "_var_" + attr, v)
# Fill frame with appropriate widget
frame = getattr(self, "_w_" + attr)
for w in frame.winfo_children():
w.destroy()
w = HKEntry(frame, textvariable = v)
w.grid(row = 0, column = 0, sticky = "NEWS")
elif cur_val is None or isinstance(cur_val, PCIId):
if not isinstance(v, ObjRefVar):
v = ObjRefVar()
setattr(self, "_var_" + attr, v)
frame = getattr(self, "_w_" + attr)
for w in frame.winfo_children():
w.destroy()
w = PCIIdWidget(v, frame)
w.grid(row = 0, column = 0, sticky = "NEWS")
widget_val = v.get()
if _input is int:
try:
widget_val = int(widget_val, base = 0)
except ValueError:
widget_val = None
if widget_val != cur_val:
v.set(cur_val)
for cb in self._all_highlights:
cb()
def main():
root = Tk()
root.title("Test VarTreeview")
device_tree = VarTreeview(root)
device_tree["columns"] = ("Macros")
dev = StringVar()
macro = StringVar()
dev.set("Devices")
macro.set("Macros")
device_tree.heading("#0", text=dev)
device_tree.heading("Macros", text=macro)
device_tree.grid(sticky="NEWS")
test = Mytest(600, dev, macro)
test.test_begin(root)
root.mainloop()
def __init__(self, *args, **kw):
text = kw.get("text", "")
if isinstance(text, variables):
kw["text"] = text.get()
Checkbutton.__init__(self, *args, **kw)
# `StringVar` requires its master to be initialized.
if not isinstance(text, variables):
text = StringVar(self, text)
self.text_var = text
text.trace_variable("w", self.on_var_changed)
def gen_row(self, row):
var_p_name = StringVar()
var_p_name.set(self.prop.prop_name)
e_p_name = HKEntry(self.dsw.props_lf, textvariable = var_p_name)
e_p_name.grid(
column = 0,
row = row,
sticky = "NEWS"
)
om_p_type, var_p_type = DeviceSettingsWidget.gen_prop_type_optionmenu(
self.dsw.props_lf,
self.prop.prop_type
)
om_p_type.grid(
column = 1,
row = row,
sticky = "NEWS"
)
var_p_type.trace_variable("w", self.on_prop_type_changed)
w_p_val, var_p_val = self.gen_prop_value_widget(
self.prop.prop_type,
self.prop.prop_val
)
w_p_val.grid(
column = 2,
row = row,
sticky = "NEWS"
)
bt_del = VarButton(
self.dsw.props_lf,
text = _("Delete"),
command = self.on_delete
)
bt_del.grid(
column = 3,
row = row,
sticky = "NEWS"
)
self.row = row
self.e_name = e_p_name
self.v_name = var_p_name
self.om_type = om_p_type
self.v_type = var_p_type
self.w_val = w_p_val
self.val_widget_prop_type = self.prop.prop_type
self.v_val = var_p_val
self.bt_del = bt_del
def __init__(self, *args, **kw):
# "textvariable" argument has same effect to VarLabel as "text"
try:
var = kw.pop("textvariable")
except KeyError:
pass
else:
if "text" in kw:
raise RuntimeError('"text" and "textvariable" '
'arguments cannot be passed together to a VarLabel'
)
kw["text"] = var
if "text" in kw:
text = kw.pop("text")
if isinstance(text, variables):
kw["text"] = text.get()
self.text_var = text
else:
self.text_var = StringVar(value = text)
else:
self.text_var = StringVar()
Label.__init__(self, *args, **kw)
self.text_var.trace_variable("w", self.on_var_changed)
def gen_prop_type_optionmenu(parent, current = None):
var = StringVar()
keys = []
for ptn in DeviceSettingsWidget.prop_type_name_map.values():
keys.append(ptn[0])
om = OptionMenu(parent, var, *keys)
if current:
current = DeviceSettingsWidget.prop_type_name_map[current][0]
else:
current = next(itervalues(DeviceSettingsWidget.prop_type_name_map))
var.set(current)
return om, var
def gen_int_widgets(self, master):
v = StringVar()
w = HKEntry(master, textvariable = v)
def validate():
try:
(int(v.get(), base = 0))
except ValueError:
return False
else:
return True
w._validate = validate
w._set_color = lambda color : w.config(bg = color)
w._cast = lambda x : int(x, base = 0)
return v, w
def gen_row(self):
p = self.dsw.buses_lf
p.rowconfigure(self.idx, weight = 1)
self.v = StringVar()
# When a bus is selected all Combobox values lists should be updated
# to prevent selecting of this bus in another Combobox
self._on_var_changed = self.v.trace_variable("w", self.on_var_changed)
self.cb = Combobox(p,
textvariable = self.v,
state = "readonly"
)
self.cb.grid(row = self.idx, column = 0, sticky = "NEWS")
self._on_bus_selected = self.dsw.bind(
DeviceSettingsWidget.EVENT_BUS_SELECTED, self.on_bus_selected, "+")
def __init__(self, cpu, *args, **kw):
QOMInstanceSettingsWidget.__init__(self, cpu, *args, **kw)
self.cpu = cpu
self.cpu_fr = fr = GUIFrame(self)
fr.pack(fill=BOTH, expand=False)
fr.columnconfigure(0, weight=0)
fr.columnconfigure(1, weight=1)
fr.rowconfigure(0, weight=0)
l = VarLabel(fr, text=_("QOM type"))
v = self.qom_type_var = StringVar()
e = HKEntry(fr, textvariable=v)
v.trace_variable("w", self._on_qom_type_var_changed)
l.grid(row=0, column=0, sticky="W")
e.grid(row=0, column=1, sticky="EW")
def append_row_to_grid(self, grid, rows, mio):
# update delete button
if not rows:
bt_del = getattr(self, "bt_del_" + mio)
bt_del.config(state="normal")
row = len(rows)
l = Label(grid, text=str(row) + ":")
l.grid(row=row, column=0, sticky="NES")
v = StringVar()
e = HKEntry(grid, textvariable=v)
e.grid(row=row, column=1, sticky="NEWS")
row_desc = (l, e, v)
rows.append(row_desc)
return row_desc
def test_auto_reformat(self):
fmt = FormatVar(value="Text is '%s'")
text = StringVar(value="[ a text will be here ]")
res = fmt % text
self.assertIsInstance(res, StringVar)
self.assertEqual(res.get(), "Text is '[ a text will be here ]'")
def on_w(*__):
val = res.get()
# print("New value: %s" % val)
self._cur_val = val
res.trace_variable("w", on_w)
text.set("A text")
self.assertEqual(self._cur_val, "Text is 'A text'")
fmt.set("'%s' is text.")
self.assertEqual(self._cur_val, "'A text' is text.")
def __mod__(self, args):
if not isinstance(args, tuple):
args = (args, )
@as_variable(self, *args)
def do_format(fmt, *args):
return fmt % args
# Wrapping do_format in `StringVar` is required because
# `Variable` instance cannot be used with Tk.
# TODO: move that mechanics elsewhere making `FormatVar` Tk
# independent.
# Initial setting
ret = StringVar(value=do_format.get())
# Auto update
do_format.trace_variable("w",
lambda: StringVar.set(ret, do_format.get()))
ret.set = forbid_set
return ret
def __init__(self, qom_desc, *args, **kw):
GUIFrame.__init__(self, *args, **kw)
self.desc = qom_desc
try:
self.pht = self.winfo_toplevel().pht
except AttributeError:
self.pht = None
# shapshot mode without PHT
if self.pht is not None:
self.pht.watch_changed(self.__on_changed__)
sf = self.settings_fr = GUIFrame(self)
sf.pack(fill = BOTH, expand = False)
f = self.qomd_fr = GUIFrame(sf)
f.pack(fill = BOTH, expand = False)
f.columnconfigure(0, weight = 0)
f.columnconfigure(1, weight = 1)
have_pciid = False
for row, (attr, info) in enumerate(qom_desc.__attribute_info__.items()):
f.rowconfigure(row, weight = 0)
l = VarLabel(f, text = info["short"])
l.grid(row = row, column = 0, sticky = "NES")
try:
_input = info["input"]
except KeyError:
# attribute is read-only
v = StringVar()
w = HKEntry(f, textvariable = v, state="readonly")
else:
if _input is str:
v = StringVar()
w = HKEntry(f, textvariable = v)
elif _input is int:
v = StringVar()
w = HKEntry(f, textvariable = v)
def validate(varname, junk, act, entry = w, var = v):
validate_int(var, entry = entry)
v.trace_variable("w", validate)
elif _input is PCIId:
have_pciid = True
""" Value of PCI Id could be presented either by PCIId
object or by a string. So the actual widget/variable pair will be assigned
during refresh. """
v = None
w = GUIFrame(f)
w.grid()
w.rowconfigure(0, weight = 1)
w.columnconfigure(0, weight = 1)
elif _input is bool:
v = BooleanVar()
w = Checkbutton(f, variable = v)
else:
raise RuntimeError("Input of QOM template attribute %s of"
" type %s is not supported" % (attr, _input.__name__)
)
w.grid(row = row, column = 1, sticky = "NEWS")
setattr(self, "_var_" + attr, v)
setattr(self, "_w_" + attr, w)
btf = self.buttons_fr = GUIFrame(self)
btf.pack(fill = BOTH, expand = False)
btf.rowconfigure(0, weight = 0)
btf.columnconfigure(0, weight = 1)
btf.columnconfigure(1, weight = 0)
bt_apply = VarButton(btf,
text = _("Apply"),
command = self.__on_apply__
)
bt_apply.grid(row = 0, column = 1, sticky = "NEWS")
bt_revert = VarButton(btf,
text = _("Refresh"),
command = self.__on_refresh__
)
bt_revert.grid(row = 0, column = 0, sticky = "NES")
self.after(0, self.__refresh__)
self.bind("<Destroy>", self.__on_destroy__, "+")
self.__have_pciid = have_pciid
if have_pciid:
self.qsig_watch("qvc_available", self.__on_qvc_available)
def init_gui(self):
"""init helper"""
window = PanedWindow(self.root, orient="vertical")
window.pack(side=TOP, fill=BOTH, expand=True)
top_pane = Frame(window)
window.add(top_pane)
mid_pane = Frame(window)
window.add(mid_pane)
bottom_pane = Frame(window)
window.add(bottom_pane)
#setting up frames
top_frame = Frame(top_pane)
mid_frame = Frame(top_pane)
history_frame = Frame(top_pane)
radio_frame = Frame(mid_pane)
rating_frame = Frame(mid_pane)
res_frame = Frame(mid_pane)
check_frame = Frame(bottom_pane)
msg_frame = Frame(bottom_pane)
btn_frame = Frame(bottom_pane)
top_frame.pack(side=TOP, fill=X)
mid_frame.pack(side=TOP, fill=X)
history_frame.pack(side=TOP, fill=BOTH, expand=True)
radio_frame.pack(side=TOP, fill=X)
rating_frame.pack(side=TOP, fill=X)
res_frame.pack(side=TOP, fill=BOTH, expand=True)
check_frame.pack(side=TOP, fill=X)
msg_frame.pack(side=TOP, fill=BOTH, expand=True)
btn_frame.pack(side=TOP, fill=X)
# Binding F5 application-wide to run lint
self.root.bind('<F5>', self.run_lint)
#Message ListBox
rightscrollbar = Scrollbar(msg_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.lb_messages = Listbox(msg_frame,
yscrollcommand=rightscrollbar.set,
xscrollcommand=bottomscrollbar.set,
bg="white")
self.lb_messages.bind("<Double-Button-1>", self.show_sourcefile)
self.lb_messages.pack(expand=True, fill=BOTH)
rightscrollbar.config(command=self.lb_messages.yview)
bottomscrollbar.config(command=self.lb_messages.xview)
#History ListBoxes
rightscrollbar2 = Scrollbar(history_frame)
rightscrollbar2.pack(side=RIGHT, fill=Y)
bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL)
bottomscrollbar2.pack(side=BOTTOM, fill=X)
self.showhistory = Listbox(history_frame,
yscrollcommand=rightscrollbar2.set,
xscrollcommand=bottomscrollbar2.set,
bg="white")
self.showhistory.pack(expand=True, fill=BOTH)
rightscrollbar2.config(command=self.showhistory.yview)
bottomscrollbar2.config(command=self.showhistory.xview)
self.showhistory.bind('<Double-Button-1>', self.select_recent_file)
self.set_history_window()
#status bar
self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W)
self.status.pack(side=BOTTOM, fill=X)
#labelbl_ratingls
lbl_rating_label = Label(rating_frame, text='Rating:')
lbl_rating_label.pack(side=LEFT)
lbl_rating = Label(rating_frame, textvariable=self.rating)
lbl_rating.pack(side=LEFT)
Label(mid_frame, text='Recently Used:').pack(side=LEFT)
Label(top_frame, text='Module or package').pack(side=LEFT)
#file textbox
self.txt_module = Entry(top_frame, background='white')
self.txt_module.bind('<Return>', self.run_lint)
self.txt_module.pack(side=LEFT, expand=True, fill=X)
#results box
rightscrollbar = Scrollbar(res_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.results = Listbox(res_frame,
yscrollcommand=rightscrollbar.set,
xscrollcommand=bottomscrollbar.set,
bg="white",
font="Courier")
self.results.pack(expand=True, fill=BOTH, side=BOTTOM)
rightscrollbar.config(command=self.results.yview)
bottomscrollbar.config(command=self.results.xview)
#buttons
Button(top_frame, text='Open', command=self.file_open).pack(side=LEFT)
Button(top_frame,
text='Open Package',
command=(lambda: self.file_open(package=True))).pack(side=LEFT)
self.btnRun = Button(top_frame, text='Run', command=self.run_lint)
self.btnRun.pack(side=LEFT)
Button(btn_frame, text='Quit', command=self.quit).pack(side=BOTTOM)
#radio buttons
self.information_box = IntVar()
self.convention_box = IntVar()
self.refactor_box = IntVar()
self.warning_box = IntVar()
self.error_box = IntVar()
self.fatal_box = IntVar()
i = Checkbutton(check_frame,
text="Information",
fg=COLORS['(I)'],
variable=self.information_box,
command=self.refresh_msg_window)
c = Checkbutton(check_frame,
text="Convention",
fg=COLORS['(C)'],
variable=self.convention_box,
command=self.refresh_msg_window)
r = Checkbutton(check_frame,
text="Refactor",
fg=COLORS['(R)'],
variable=self.refactor_box,
command=self.refresh_msg_window)
w = Checkbutton(check_frame,
text="Warning",
fg=COLORS['(W)'],
variable=self.warning_box,
command=self.refresh_msg_window)
e = Checkbutton(check_frame,
text="Error",
fg=COLORS['(E)'],
variable=self.error_box,
command=self.refresh_msg_window)
f = Checkbutton(check_frame,
text="Fatal",
fg=COLORS['(F)'],
variable=self.fatal_box,
command=self.refresh_msg_window)
i.select()
c.select()
r.select()
w.select()
e.select()
f.select()
i.pack(side=LEFT)
c.pack(side=LEFT)
r.pack(side=LEFT)
w.pack(side=LEFT)
e.pack(side=LEFT)
f.pack(side=LEFT)
#check boxes
self.box = StringVar()
# XXX should be generated
report = Radiobutton(radio_frame,
text="Report",
variable=self.box,
value="Report",
command=self.refresh_results_window)
raw_met = Radiobutton(radio_frame,
text="Raw metrics",
variable=self.box,
value="Raw metrics",
command=self.refresh_results_window)
dup = Radiobutton(radio_frame,
text="Duplication",
variable=self.box,
value="Duplication",
command=self.refresh_results_window)
ext = Radiobutton(radio_frame,
text="External dependencies",
variable=self.box,
value="External dependencies",
command=self.refresh_results_window)
stat = Radiobutton(radio_frame,
text="Statistics by type",
variable=self.box,
value="Statistics by type",
command=self.refresh_results_window)
msg_cat = Radiobutton(radio_frame,
text="Messages by category",
variable=self.box,
value="Messages by category",
command=self.refresh_results_window)
msg = Radiobutton(radio_frame,
text="Messages",
variable=self.box,
value="Messages",
command=self.refresh_results_window)
source_file = Radiobutton(radio_frame,
text="Source File",
variable=self.box,
value="Source File",
command=self.refresh_results_window)
report.select()
report.grid(column=0, row=0, sticky=W)
raw_met.grid(column=1, row=0, sticky=W)
dup.grid(column=2, row=0, sticky=W)
msg.grid(column=3, row=0, sticky=W)
stat.grid(column=0, row=1, sticky=W)
msg_cat.grid(column=1, row=1, sticky=W)
ext.grid(column=2, row=1, sticky=W)
source_file.grid(column=3, row=1, sticky=W)
#dictionary for check boxes and associated error term
self.msg_type_dict = {
'I': lambda: self.information_box.get() == 1,
'C': lambda: self.convention_box.get() == 1,
'R': lambda: self.refactor_box.get() == 1,
'E': lambda: self.error_box.get() == 1,
'W': lambda: self.warning_box.get() == 1,
'F': lambda: self.fatal_box.get() == 1
}
self.txt_module.focus_set()
def __init__(self, parent, app):
parent.title('Auth window')
self.parent = parent
self.root = app
# Widget Initialization
self._label_header = Label(
parent,
font="{Segoe UI} 20 bold",
foreground="#ff0000",
text="Trakt Account Authorization",
)
self._button_get_code = Button(
parent,
font="{MS Sans Serif} 12 bold",
text="Get PIN Code",
)
self._label_enter_code = Label(
parent,
font="{MS Sans Serif} 14",
text="Enter the code:",
)
self._label_click = Label(
parent,
font="{MS Sans Serif} 14",
text="Click the button to get a code:",
)
self.pin_code = StringVar()
self._entry_code = Entry(
parent,
font="{MS Sans Serif} 14 bold",
width=10,
justify="center",
textvariable=self.pin_code,
state="disabled",
)
self._button_done = Button(
parent,
borderwidth=3,
font="{MS Sans Serif} 12 bold",
text="Done",
state="disabled",
)
# widget commands
self._button_get_code.configure(command=self.button_get_code_command)
self._button_done.configure(command=self.button_done_command)
# Geometry Management
self._label_header.grid(in_=parent,
column=1,
row=1,
columnspan=1,
ipadx=0,
ipady=0,
padx=0,
pady=0,
rowspan=1,
sticky="ew")
self._label_click.grid(in_=parent,
column=1,
row=2,
columnspan=1,
ipadx=0,
ipady=0,
padx=0,
pady=0,
rowspan=1,
sticky="")
self._button_get_code.grid(in_=parent,
column=1,
row=3,
columnspan=1,
ipadx=0,
ipady=0,
padx=0,
pady=0,
rowspan=1,
sticky="")
self._label_enter_code.grid(in_=parent,
column=1,
row=4,
columnspan=1,
ipadx=0,
ipady=0,
padx=0,
pady=0,
rowspan=1,
sticky="")
self._entry_code.grid(in_=parent,
column=1,
row=5,
columnspan=1,
ipadx=5,
ipady=0,
padx=5,
pady=0,
rowspan=1,
sticky="")
self._button_done.grid(in_=parent,
column=1,
row=6,
columnspan=1,
ipadx=0,
ipady=0,
padx=0,
pady=0,
rowspan=1,
sticky="")
# Resize Behavior
parent.resizable(False, False)
parent.grid_rowconfigure(1, weight=1, minsize=40, pad=10)
parent.grid_rowconfigure(2, weight=1, minsize=40, pad=10)
parent.grid_rowconfigure(3, weight=1, minsize=40, pad=10)
parent.grid_rowconfigure(4, weight=1, minsize=40, pad=10)
parent.grid_rowconfigure(5, weight=1, minsize=50, pad=10)
parent.grid_rowconfigure(6, weight=1, minsize=50, pad=10)
parent.grid_columnconfigure(1, weight=1, minsize=0, pad=10)
def __init__(self, project=None):
GUITk.__init__(self, wait_msec=1)
for signame in ["qvc_dirtied", "qvd_failed", "qvc_available"]:
s = CoSignal()
s.attach(self.signal_dispatcher)
setattr(self, "sig_" + signame, s)
self.title_suffix = _("Qemu device creator GUI")
self.title_suffix.trace_variable("w", self.__on_title_suffix_write__)
self.title_not_saved_asterisk = StringVar()
self.title_not_saved_asterisk.trace_variable(
"w", self.__on_title_suffix_write__)
self.saved_operation = None
self.var_title = StringVar()
self.title(self.var_title)
# Hot keys, accelerators
self.hk = hotkeys = HotKey(self)
hotkeys.add_bindings([
HotKeyBinding(
self.invert_history_window,
key_code=43,
description=_("If editing history window is hidden then \
show it else hide it."),
symbol="H"),
HotKeyBinding(self.on_load,
key_code=32,
description=_("Load project from file."),
symbol="O"),
HotKeyBinding(self.on_new_project,
key_code=57,
description=_("Create new project."),
symbol="N"),
HotKeyBinding(self.on_add_description,
key_code=40,
description=_("Add description to the project"),
symbol="D"),
HotKeyBinding(self.on_set_qemu_build_path,
key_code=56,
description=_("Set Qemu build path for the project"),
symbol="B"),
HotKeyBinding(
self.on_sel_tgt_qemu_version,
key_code=28,
description=_("Select target Qemu version for the project"),
symbol="T"),
HotKeyBinding(self.on_generate,
key_code=42,
description=_("Launch code generation"),
symbol="G"),
HotKeyBinding(self.on_delete,
key_code=24,
description=_("Shutdown the application."),
symbol="Q"),
HotKeyBinding(self.undo,
key_code=52,
description=_("Revert previous editing."),
symbol="Z"),
HotKeyBinding(self.redo,
key_code=29,
description=_("Make reverted editing again."),
symbol="Y"),
HotKeyBinding(self.on_save,
key_code=39,
description=_("Save project."),
symbol="S"),
HotKeyBinding(self.on_reload,
key_code=27,
description=_("Reload current project from file."),
symbol="R")
])
# see `set_user_settings`
self._user_settings = None
# Menu bar
menubar = VarMenu(self)
self.filemenu = filemenu = VarMenu(menubar, tearoff=False)
filemenu.add_command(label=_("Add description"),
command=self.on_add_description,
accelerator=hotkeys.get_keycode_string(
self.on_add_description))
filemenu.add_command(label=_("Set Qemu build path"),
command=self.on_set_qemu_build_path,
accelerator=hotkeys.get_keycode_string(
self.on_set_qemu_build_path))
filemenu.add_command(label=_("Select target Qemu version"),
command=self.on_sel_tgt_qemu_version,
accelerator=hotkeys.get_keycode_string(
self.on_sel_tgt_qemu_version))
filemenu.add_command(label=_("Generate"),
command=self.on_generate,
accelerator=hotkeys.get_keycode_string(
self.on_generate))
filemenu.add_separator()
filemenu.add_command(label=_("New project"),
command=self.on_new_project,
accelerator=hotkeys.get_keycode_string(
self.on_new_project)),
filemenu.add_command(label=_("Save"),
command=self.on_save,
accelerator=hotkeys.get_keycode_string(
self.on_save)),
filemenu.add_command(label=_("Save project as..."),
command=self.on_save_as)
filemenu.add_command(label=_("Load"),
command=self.on_load,
accelerator=hotkeys.get_keycode_string(
self.on_load)),
self.reload_idx = filemenu.count
filemenu.add_command(label=_("Reload"),
command=self.on_reload,
accelerator=hotkeys.get_keycode_string(
self.on_reload)),
self.recentmenu = recentmenu = VarMenu(filemenu, tearoff=False)
filemenu.add_cascade(
label=_("Recent projects"),
menu=recentmenu,
state=DISABLED # a user settings instance is required
)
filemenu.add_separator()
filemenu.add_command(label=_("Quit"),
command=self.quit,
accelerator=hotkeys.get_keycode_string(
self.on_delete))
menubar.add_cascade(label=_("File"), menu=filemenu)
self.editmenu = editmenu = VarMenu(menubar, tearoff=False)
editmenu.add_command(label=_("Undo"),
command=self.undo,
accelerator=hotkeys.get_keycode_string(self.undo))
self.undo_idx = editmenu.count - 1
editmenu.add_command(label=_("Redo"),
command=self.redo,
accelerator=hotkeys.get_keycode_string(self.redo))
self.redo_idx = editmenu.count - 1
editmenu.add_separator()
editmenu.add_command(label=_("Rebuild Cache"),
command=self.rebuild_cache,
accelerator=hotkeys.get_keycode_string(
self.rebuild_cache))
editmenu.add_separator()
v = self.var_history_window = BooleanVar()
v.set(False)
self.__on_var_history_window = v.trace_variable(
"w", self.__on_var_history_window__)
editmenu.add_checkbutton(label=_("Editing history window"),
variable=v,
accelerator=hotkeys.get_keycode_string(
self.invert_history_window))
menubar.add_cascade(label=_("Edit"), menu=editmenu)
self.optionsmenu = optionsmenu = VarMenu(menubar, tearoff=False)
v = self.var_schedule_generation = BooleanVar()
v.set(False)
self.__on_var_schedule_generation = v.trace_variable(
"w", self.__on_var_schedule_generation__)
optionsmenu.add_checkbutton(
label=_("Schedule generation after cache loading"), variable=v)
v = self.var_gen_chunk_graphs = BooleanVar()
v.set(False)
self.__on_var_gen_chunk_graphs = v.trace_variable(
"w", self.__on_var_gen_chunk_graphs__)
optionsmenu.add_checkbutton(label=_("Generate chunk graphs"),
variable=v)
menubar.add_cascade(label=_("Options"), menu=optionsmenu)
self.config(menu=menubar)
# Widget layout
self.grid()
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Status bar
self.grid_rowconfigure(1, weight=0)
self.sb = sb = Statusbar(self)
sb.grid(row=1, column=0, sticky="NEWS")
# Target Qemu version in the status bar
self._target_qemu = Variable(None)
# This complicated scheme is required because the status must also
# be updated on language change.
@as_variable(self._target_qemu, _("No target"), _("Target Qemu: %s"))
def var_target_qemu(target, no_target, target_qemu):
if target is None:
return no_target
else:
return target_qemu % target
sb.left(var_target_qemu)
# QEMU build path displaying
self.var_qemu_build_path = StringVar()
sb.left(self.var_qemu_build_path)
# Task counters in status bar
sb.right(_("Background tasks: "))
sb.repack(CoStatusView(sb), RIGHT)
self.signal_dispatcher.watch_failed(self.__on_listener_failed)
self.protocol("WM_DELETE_WINDOW", self.on_delete)
self.set_project(GUIProject() if project is None else project)
self.__update_title__()
self.__check_saved_asterisk__()
self.qsig_watch("qvc_available", self.__on_qvc_available)
