blob: 51400312af163fe9c9048ee1d64f24801ab9549f [file] [log] [blame]
#!/usr/bin/env python3
# Copyright (c) 2019, Nordic Semiconductor ASA and Ulf Magnusson
# SPDX-License-Identifier: ISC
# _load_images() builds names dynamically to avoid having to give them twice
# (once for the variable and once for the filename). This forces consistency
# too.
# pylint: disable=undefined-variable
A Tkinter-based menuconfig implementation, based around a treeview control and
a help display. The interface should feel familiar to people used to qconf
('make xconfig'). Compatible with both Python 2 and Python 3.
The display can be toggled between showing the full tree and showing just a
single menu (like Only single-menu mode distinguishes between
symbols defined with 'config' and symbols defined with 'menuconfig'.
A show-all mode is available that shows invisible items in red.
Supports both mouse and keyboard controls. The following keyboard shortcuts are
Ctrl-S : Save configuration
Ctrl-O : Open configuration
Ctrl-A : Toggle show-all mode
Ctrl-N : Toggle show-name mode
Ctrl-M : Toggle single-menu mode
Ctrl-F, /: Open jump-to dialog
ESC : Close
======= can be run either as a standalone executable or by calling the
menuconfig() function with an existing Kconfig instance. The second option is a
bit inflexible in that it will still load and save .config, etc.
When run in standalone mode, the top-level Kconfig file to load can be passed
as a command-line argument. With no argument, it defaults to "Kconfig".
The KCONFIG_CONFIG environment variable specifies the .config file to load (if
it exists) and save. If KCONFIG_CONFIG is unset, ".config" is used.
When overwriting a configuration file, the old version is saved to
<filename>.old (e.g. .config.old).
$srctree is supported through Kconfiglib.
# Note: There's some code duplication with below, especially for
# the help text. Maybe some of it could be moved into or a shared
# helper script, but OTOH it's pretty nice to have things standalone and
# customizable.
import errno
import os
import re
import sys
_PY2 = sys.version_info[0] < 3
if _PY2:
# Python 2
from Tkinter import *
import ttk
import tkFont as font
import tkFileDialog as filedialog
import tkMessageBox as messagebox
# Python 3
from tkinter import *
import tkinter.ttk as ttk
import tkinter.font as font
from tkinter import filedialog, messagebox
from kconfiglib import Symbol, Choice, MENU, COMMENT, MenuNode, \
AND, OR, \
expr_str, expr_value, split_expr, \
standard_sc_expr_str, \
standard_kconfig, standard_config_filename
# If True, use GIF image data embedded in this file instead of separate GIF
# files. See _load_images().
# Help text for the jump-to dialog
_JUMP_TO_HELP = """\
Type one or more strings/regexes and press Enter to list items that match all
of them. Python's regex flavor is used (see the 're' module). Double-clicking
an item will jump to it. Item values can be toggled directly within the dialog.\
def _main():
# Global variables used below:
# _root:
# The Toplevel instance for the main window
# _tree:
# The Treeview in the main window
# _jump_to_tree:
# The Treeview in the jump-to dialog. None if the jump-to dialog isn't
# open. Doubles as a flag.
# _jump_to_matches:
# List of Nodes shown in the jump-to dialog
# _menupath:
# The Label that shows the menu path of the selected item
# _backbutton:
# The button shown in single-menu mode for jumping to the parent menu
# _status_label:
# Label with status text shown at the bottom of the main window
# ("Modified", "Saved to ...", etc.)
# _id_to_node:
# We can't use Node objects directly as Treeview item IDs, so we use their
# id()s instead. This dictionary maps Node id()s back to Nodes. (The keys
# are actually str(id(node)), just to simplify lookups.)
# _cur_menu:
# The current menu. Ignored outside single-menu mode.
# _show_all_var/_show_name_var/_single_menu_var:
# Tkinter Variable instances bound to the corresponding checkboxes
# _show_all/_single_menu:
# Plain Python bools that track _show_all_var and _single_menu_var, to
# speed up and simplify things a bit
# _conf_filename:
# File to save the configuration to
# _minconf_filename:
# File to save minimal configurations to
# _conf_changed:
# True if the configuration has been changed. If False, we don't bother
# showing the save-and-quit dialog.
# We reset this to False whenever the configuration is saved.
# _*_img:
# PhotoImage instances for images
def menuconfig(kconf):
Launches the configuration interface, returning after the user exits.
Kconfig instance to be configured
global _kconf
global _conf_filename
global _minconf_filename
global _jump_to_tree
global _cur_menu
_kconf = kconf
_jump_to_tree = None
# Filename to save configuration to
_conf_filename = standard_config_filename()
# Load existing configuration and check if it's outdated
# Filename to save minimal configuration to
_minconf_filename = "defconfig"
# Current menu in single-menu mode
_cur_menu = _kconf.top_node
# Any visible items in the top menu?
if not _shown_menu_nodes(kconf.top_node):
# Nothing visible. Start in show-all mode and try again.
if not _shown_menu_nodes(kconf.top_node):
# Give up and show an error. It's nice to be able to assume that
# the tree is non-empty in the rest of the code.
"Empty configuration -- nothing to configure.\n\n"
"Check that environment variables are set properly.")
# Build the initial tree
# Select the first item and focus the Treeview, so that keyboard controls
# work immediately
_select(_tree, _tree.get_children()[0])
# Make geometry information available for centering the window. This
# indirectly creates the window, so hide it so that it's never shown at the
# old location.
# Center the window
(_root.winfo_screenwidth() - _root.winfo_reqwidth())//2,
(_root.winfo_screenheight() - _root.winfo_reqheight())//2))
# Show it
# Prevent the window from being automatically resized. Otherwise, it
# changes size when scrollbars appear/disappear before the user has
# manually resized it.
def _load_config():
# Loads any existing .config file. See the Kconfig.load_config() docstring.
# Returns True if .config is missing or outdated. We always prompt for
# saving the configuration in that case.
if not os.path.exists(_conf_filename):
# No .config
return True
return _needs_save()
def _needs_save():
# Returns True if a just-loaded .config file is outdated (would get
# modified when saving)
if _kconf.missing_syms:
# Assignments to undefined symbols in the .config
return True
for sym in _kconf.unique_defined_syms:
if sym.user_value is None:
if sym.config_string:
# Unwritten symbol
return True
elif sym.orig_type in (BOOL, TRISTATE):
if sym.tri_value != sym.user_value:
# Written bool/tristate symbol, new value
return True
elif sym.str_value != sym.user_value:
# Written string/int/hex symbol, new value
return True
# No need to prompt for save
return False
def _create_id_to_node():
global _id_to_node
_id_to_node = {str(id(node)): node for node in _kconf.node_iter()}
def _create_ui():
# Creates the main window UI
global _root
global _tree
# Create the root window. This initializes Tkinter and makes e.g.
# PhotoImage available, so do it early.
_root = Tk()
# Create the pane with the Kconfig tree and description text
panedwindow, _tree = _create_kconfig_tree_and_desc(_root)
panedwindow.grid(column=0, row=1, sticky="nsew")
_root.columnconfigure(0, weight=1)
# Only the pane with the Kconfig tree and description grows vertically
_root.rowconfigure(1, weight=1)
# Start with show-name disabled
_tree.bind("<Left>", _tree_left_key)
_tree.bind("<Right>", _tree_right_key)
# Note: Binding this for the jump-to tree as well would cause issues due to
# the Tk bug mentioned in _tree_open()
_tree.bind("<<TreeviewOpen>>", _tree_open)
# add=True to avoid overriding the description text update
_tree.bind("<<TreeviewSelect>>", _update_menu_path, add=True)
_root.bind("<Control-s>", _save)
_root.bind("<Control-o>", _open)
_root.bind("<Control-a>", _toggle_showall)
_root.bind("<Control-n>", _toggle_showname)
_root.bind("<Control-m>", _toggle_tree_mode)
_root.bind("<Control-f>", _jump_to_dialog)
_root.bind("/", _jump_to_dialog)
_root.bind("<Escape>", _on_quit)
def _load_images():
# Loads GIF images, creating the global _*_img PhotoImage variables.
# Base64-encoded images embedded in this script are used if
# _USE_EMBEDDED_IMAGES is True, and separate image files in the same
# directory as the script otherwise.
# Using a global variable indirectly prevents the image from being
# garbage-collected. Passing an image to a Tkinter function isn't enough to
# keep it alive.
def load_image(name, data):
var_name = "_{}_img".format(name)
globals()[var_name] = PhotoImage(data=data, format="gif")
globals()[var_name] = PhotoImage(
file=os.path.join(os.path.dirname(__file__), name + ".gif"),
# Note: Base64 data can be put on the clipboard with
# $ base64 -w0 foo.gif | xclip
load_image("icon", "R0lGODlhMAAwAPEDAAAAAADQAO7u7v///yH5BAUKAAMALAAAAAAwADAAAAL/nI+gy+2Pokyv2jazuZxryQjiSJZmyXxHeLbumH6sEATvW8OLNtf5bfLZRLFITzgEipDJ4mYxYv6A0ubuqYhWk66tVTE4enHer7jcKvt0LLUw6P45lvEprT6c0+v7OBuqhYdHohcoqIbSAHc4ljhDwrh1UlgSydRCWWlp5wiYZvmSuSh4IzrqV6p4cwhkCsmY+nhK6uJ6t1mrOhuJqfu6+WYiCiwl7HtLjNSZZZis/MeM7NY3TaRKS40ooDeoiVqIultsrav92bi9c3a5KkkOsOJZpSS99m4k/0zPng4Gks9JSbB+8DIcoQfnjwpZCHv5W+ip4aQrKrB0uOikYhiMCBw1/uPoQUMBADs=")
load_image("n_bool", "R0lGODdhEAAQAPAAAAgICP///ywAAAAAEAAQAAACIISPacHtvp5kcb5qG85hZ2+BkyiRF8BBaEqtrKkqslEAADs=")
load_image("y_bool", "R0lGODdhEAAQAPEAAAgICADQAP///wAAACwAAAAAEAAQAAACMoSPacLtvlh4YrIYsst2cV19AvaVF9CUXBNJJoum7ymrsKuCnhiupIWjSSjAFuWhSCIKADs=")
load_image("n_tri", "R0lGODlhEAAQAPD/AAEBAf///yH5BAUKAAIALAAAAAAQABAAAAInlI+pBrAKQnCPSUlXvFhznlkfeGwjKZhnJ65h6nrfi6h0st2QXikFADs=")
load_image("y_tri", "R0lGODlhEAAQAPEDAAICAgDQAP///wAAACH5BAUKAAMALAAAAAAQABAAAAI0nI+pBrAYBhDCRRUypfmergmgZ4xjMpmaw2zmxk7cCB+pWiVqp4MzDwn9FhGZ5WFjIZeGAgA7")
load_image("m_my", "R0lGODlhEAAQAPEDAAAAAOQMuv///wAAACH5BAUKAAMALAAAAAAQABAAAAI5nIGpxiAPI2ghxFinq/ZygQhc94zgZopmOLYf67anGr+oZdp02emfV5n9MEHN5QhqICETxkABbQ4KADs=")
load_image("n_locked", "R0lGODlhEAAQAPABAAAAAP///yH5BAUKAAEALAAAAAAQABAAAAIgjB8AyKwN04pu0vMutpqqz4Hih4ydlnUpyl2r23pxUAAAOw==")
load_image("m_locked", "R0lGODlhEAAQAPD/AAAAAOQMuiH5BAUKAAIALAAAAAAQABAAAAIylC8AyKwN04ohnGcqqlZmfXDWI26iInZoyiore05walolV39ftxsYHgL9QBBMBGFEFAAAOw==")
load_image("not_selected", "R0lGODlhEAAQAPD/AAAAAP///yH5BAUKAAIALAAAAAAQABAAAAIrlA2px6IBw2IpWglOvTYhzmUbGD3kNZ5QqrKn2YrqigCxZoMelU6No9gdCgA7")
load_image("selected", "R0lGODlhEAAQAPD/AAAAAP///yH5BAUKAAIALAAAAAAQABAAAAIzlA2px6IBw2IpWglOvTah/kTZhimASJomiqonlLov1qptHTsgKSEzh9H8QI0QzNPwmRoFADs=")
def _fix_treeview_issues():
# Fixes some Treeview issues
global _treeview_rowheight
style = ttk.Style()
# The treeview rowheight isn't adjusted automatically on high-DPI displays,
# so do it ourselves. The font will probably always be TkDefaultFont, but
# play it safe and look it up.
_treeview_rowheight = font.Font(font=style.lookup("Treeview", "font")) \
.metrics("linespace") + 2
style.configure("Treeview", rowheight=_treeview_rowheight)
# Work around regression in,
# which breaks tag background colors
for option in "foreground", "background":
# Filter out any styles starting with ("!disabled", "!selected", ...).
# returns an empty list for missing options, so this should
# be future-safe.
**{option: [elm for elm in"Treeview", query_opt=option)
if elm[:2] != ("!disabled", "!selected")]})
def _init_misc_ui():
# Does misc. UI initialization, like setting the title, icon, and theme
# iconphoto() isn't available in Python 2's Tkinter"wm", "iconphoto", _root._w, "-default", _icon_img)
# Reducing the width of the window to 1 pixel makes it move around, at
# least on GNOME. Prevent weird stuff like that.
_root.minsize(128, 128)
_root.protocol("WM_DELETE_WINDOW", _on_quit)
# Use the 'clam' theme on *nix if it's available. It looks nicer than the
# 'default' theme.
if"tk", "windowingsystem") == "x11":
style = ttk.Style()
if "clam" in style.theme_names():
def _create_top_widgets():
# Creates the controls above the Kconfig tree in the main window
global _show_all_var
global _show_name_var
global _single_menu_var
global _menupath
global _backbutton
topframe = ttk.Frame(_root)
topframe.grid(column=0, row=0, sticky="ew")
ttk.Button(topframe, text="Save", command=_save) \
.grid(column=0, row=0, sticky="ew", padx=".05c", pady=".05c")
ttk.Button(topframe, text="Save as...", command=_save_as) \
.grid(column=1, row=0, sticky="ew")
ttk.Button(topframe, text="Save minimal (advanced)...",
command=_save_minimal) \
.grid(column=2, row=0, sticky="ew", padx=".05c")
ttk.Button(topframe, text="Open...", command=_open) \
.grid(column=3, row=0)
ttk.Button(topframe, text="Jump to...", command=_jump_to_dialog) \
.grid(column=4, row=0, padx=".05c")
_show_name_var = BooleanVar()
ttk.Checkbutton(topframe, text="Show name", command=_do_showname,
variable=_show_name_var) \
.grid(column=0, row=1, sticky="nsew", padx=".05c", pady="0 .05c",
_show_all_var = BooleanVar()
ttk.Checkbutton(topframe, text="Show all", command=_do_showall,
variable=_show_all_var) \
.grid(column=1, row=1, sticky="nsew", pady="0 .05c")
# Allow the show-all and single-menu status to be queried via plain global
# Python variables, which is faster and simpler
def show_all_updated(*_):
global _show_all
_show_all = _show_all_var.get()
_trace_write(_show_all_var, show_all_updated)
_single_menu_var = BooleanVar()
ttk.Checkbutton(topframe, text="Single-menu mode", command=_do_tree_mode,
variable=_single_menu_var) \
.grid(column=2, row=1, sticky="nsew", padx=".05c", pady="0 .05c")
_backbutton = ttk.Button(topframe, text="<--", command=_leave_menu,
_backbutton.grid(column=0, row=4, sticky="nsew", padx=".05c", pady="0 .05c")
def tree_mode_updated(*_):
global _single_menu
_single_menu = _single_menu_var.get()
if _single_menu:
_trace_write(_single_menu_var, tree_mode_updated)
# Column to the right of the buttons that the menu path extends into, so
# that it can grow wider than the buttons
topframe.columnconfigure(5, weight=1)
_menupath = ttk.Label(topframe)
_menupath.grid(column=0, row=3, columnspan=6, sticky="w", padx="0.05c",
pady="0 .05c")
def _create_kconfig_tree_and_desc(parent):
# Creates a Panedwindow with a Treeview that shows Kconfig nodes and a Text
# that shows a description of the selected node. Returns a tuple with the
# Panedwindow and the Treeview. This code is shared between the main window
# and the jump-to dialog.
panedwindow = ttk.Panedwindow(parent, orient=VERTICAL)
tree_frame, tree = _create_kconfig_tree(panedwindow)
desc_frame, desc = _create_kconfig_desc(panedwindow)
panedwindow.add(tree_frame, weight=1)
def tree_select(_):
# The Text widget does not allow editing the text in its disabled
# state. We need to temporarily enable it.
desc["state"] = "normal"
sel = tree.selection()
if not sel:
desc.delete("1.0", "end")
desc["state"] = "disabled"
# Text.replace() is not available in Python 2's Tkinter
desc.delete("1.0", "end")
desc.insert("end", _info_str(_id_to_node[sel[0]]))
desc["state"] = "disabled"
tree.bind("<<TreeviewSelect>>", tree_select)
tree.bind("<1>", _tree_click)
tree.bind("<Double-1>", _tree_double_click)
tree.bind("<Return>", _tree_enter)
tree.bind("<KP_Enter>", _tree_enter)
tree.bind("<space>", _tree_toggle)
tree.bind("n", _tree_set_val(0))
tree.bind("m", _tree_set_val(1))
tree.bind("y", _tree_set_val(2))
return panedwindow, tree
def _create_kconfig_tree(parent):
# Creates a Treeview for showing Kconfig nodes
frame = ttk.Frame(parent)
tree = ttk.Treeview(frame, selectmode="browse", height=20,
tree.heading("#0", text="Option", anchor="w")
tree.heading("name", text="Name", anchor="w")
tree.tag_configure("n-bool", image=_n_bool_img)
tree.tag_configure("y-bool", image=_y_bool_img)
tree.tag_configure("m-tri", image=_m_tri_img)
tree.tag_configure("n-tri", image=_n_tri_img)
tree.tag_configure("m-tri", image=_m_tri_img)
tree.tag_configure("y-tri", image=_y_tri_img)
tree.tag_configure("m-my", image=_m_my_img)
tree.tag_configure("y-my", image=_y_my_img)
tree.tag_configure("n-locked", image=_n_locked_img)
tree.tag_configure("m-locked", image=_m_locked_img)
tree.tag_configure("y-locked", image=_y_locked_img)
tree.tag_configure("not-selected", image=_not_selected_img)
tree.tag_configure("selected", image=_selected_img)
tree.tag_configure("edit", image=_edit_img)
tree.tag_configure("invisible", foreground="red")
tree.grid(column=0, row=0, sticky="nsew")
_add_vscrollbar(frame, tree)
frame.columnconfigure(0, weight=1)
frame.rowconfigure(0, weight=1)
# Create items for all menu nodes. These can be detached/moved later.
# Micro-optimize this a bit.
insert = tree.insert
id_ = id
Symbol_ = Symbol
for node in _kconf.node_iter():
item = node.item
insert("", "end", iid=id_(node), if item.__class__ is Symbol_ else "")
return frame, tree
def _create_kconfig_desc(parent):
# Creates a Text for showing the description of the selected Kconfig node
frame = ttk.Frame(parent)
desc = Text(frame, height=12, wrap="none", borderwidth=0,
desc.grid(column=0, row=0, sticky="nsew")
# Work around not being to Ctrl-C/V text from a disabled Text widget, with a
# tip found in
desc.bind("<1>", lambda _: desc.focus_set())
_add_vscrollbar(frame, desc)
frame.columnconfigure(0, weight=1)
frame.rowconfigure(0, weight=1)
return frame, desc
def _add_vscrollbar(parent, widget):
# Adds a vertical scrollbar to 'widget' that's only shown as needed
vscrollbar = ttk.Scrollbar(parent, orient="vertical",
vscrollbar.grid(column=1, row=0, sticky="ns")
def yscrollcommand(first, last):
# Only show the scrollbar when needed. 'first' and 'last' are
# strings.
if float(first) <= 0.0 and float(last) >= 1.0:
vscrollbar.set(first, last)
widget["yscrollcommand"] = yscrollcommand
def _create_status_bar():
# Creates the status bar at the bottom of the main window
global _status_label
_status_label = ttk.Label(_root, anchor="e", padding="0 0 0.4c 0")
_status_label.grid(column=0, row=3, sticky="ew")
def _set_status(s):
# Sets the text in the status bar to 's'
_status_label["text"] = s
def _set_conf_changed(changed):
# Updates the status re. whether there are unsaved changes
global _conf_changed
_conf_changed = changed
if changed:
def _update_tree():
# Updates the Kconfig tree in the main window by first detaching all nodes
# and then updating and reattaching them. The tree structure might have
# changed.
# If a selected/focused item is detached and later reattached, it stays
# selected/focused. That can give multiple selections even though
# selectmode=browse. Save and later restore the selection and focus as a
# workaround.
old_selection = _tree.selection()
old_focus = _tree.focus()
# Detach all tree items before re-stringing them. This is relatively fast,
# luckily.
if _single_menu:
def _build_full_tree(menu):
# Updates the tree starting from menu.list, in full-tree mode. To speed
# things up, only open menus are updated. The menu-at-a-time logic here is
# to deal with invisible items that can show up outside show-all mode (see
# _shown_full_nodes()).
for node in _shown_full_nodes(menu):
_add_to_tree(node, _kconf.top_node)
# _shown_full_nodes() includes nodes from menus rooted at symbols, so
# we only need to check "real" menus/choices here
if node.list and not isinstance(node.item, Symbol):
if _tree.item(id(node), "open"):
# We're just probing here, so _shown_menu_nodes() will work
# fine, and might be a bit faster
shown = _shown_menu_nodes(node)
if shown:
# Dummy element to make the open/closed toggle appear
_tree.move(id(shown[0]), id(shown[0].parent), "end")
def _shown_full_nodes(menu):
# Returns the list of menu nodes shown in 'menu' (a menu node for a menu)
# for full-tree mode. A tricky detail is that invisible items need to be
# shown if they have visible children.
def rec(node):
res = []
while node:
if _visible(node) or _show_all:
if node.list and isinstance(node.item, Symbol):
# Nodes from menu created from dependencies
res += rec(node.list)
elif node.list and isinstance(node.item, Symbol):
# Show invisible symbols (defined with either 'config' and
# 'menuconfig') if they have visible children. This can happen
# for an m/y-valued symbol with an optional prompt
# ('prompt "foo" is COND') that is currently disabled.
shown_children = rec(node.list)
if shown_children:
res += shown_children
node =
return res
return rec(menu.list)
def _build_menu_tree():
# Updates the tree in single-menu mode. See _build_full_tree() as well.
for node in _shown_menu_nodes(_cur_menu):
_add_to_tree(node, _cur_menu)
def _shown_menu_nodes(menu):
# Used for single-menu mode. Similar to _shown_full_nodes(), but doesn't
# include children of symbols defined with 'menuconfig'.
def rec(node):
res = []
while node:
if _visible(node) or _show_all:
if node.list and not node.is_menuconfig:
res += rec(node.list)
elif node.list and isinstance(node.item, Symbol):
shown_children = rec(node.list)
if shown_children:
# Invisible item with visible children
if not node.is_menuconfig:
res += shown_children
node =
return res
return rec(menu.list)
def _visible(node):
# Returns True if the node should appear in the menu (outside show-all
# mode)
return node.prompt and expr_value(node.prompt[1]) and not \
(node.item == MENU and not expr_value(node.visibility))
def _add_to_tree(node, top):
# Adds 'node' to the tree, at the end of its menu. We rely on going through
# the nodes linearly to get the correct order. 'top' holds the menu that
# corresponds to the top-level menu, and can vary in single-menu mode.
parent = node.parent
_tree.move(id(node), "" if parent is top else id(parent), "end")
# The _show_all test avoids showing invisible items in red outside
# show-all mode, which could look confusing/broken. Invisible symbols
# are shown outside show-all mode if an invisible symbol has visible
# children in an implicit menu.
tags=_img_tag(node) if _visible(node) or not _show_all else
_img_tag(node) + " invisible")
def _node_str(node):
# Returns the string shown to the right of the image (if any) for the node
if node.prompt:
if node.item == COMMENT:
s = "*** {} ***".format(node.prompt[0])
s = node.prompt[0]
if isinstance(node.item, Symbol):
sym = node.item
# Print "(NEW)" next to symbols without a user value (from e.g. a
# .config), but skip it for choice symbols in choices in y mode,
# and for symbols of UNKNOWN type (which generate a warning though)
if sym.user_value is None and sym.type and not \
(sym.choice and sym.choice.tri_value == 2):
s += " (NEW)"
elif isinstance(node.item, Symbol):
# Symbol without prompt (can show up in show-all)
s = "<{}>".format(
# Choice without prompt. Use standard_sc_expr_str() so that it shows up
# as '<choice (name if any)>'.
s = standard_sc_expr_str(node.item)
if isinstance(node.item, Symbol):
sym = node.item
if sym.orig_type == STRING:
s += ": " + sym.str_value
elif sym.orig_type in (INT, HEX):
s = "({}) {}".format(sym.str_value, s)
elif isinstance(node.item, Choice) and node.item.tri_value == 2:
# Print the prompt of the selected symbol after the choice for
# choices in y mode
sym = node.item.selection
if sym:
for sym_node in sym.nodes:
# Use the prompt used at this choice location, in case the
# choice symbol is defined in multiple locations
if sym_node.parent is node and sym_node.prompt:
s += " ({})".format(sym_node.prompt[0])
# If the symbol isn't defined at this choice location, then
# just use whatever prompt we can find for it
for sym_node in sym.nodes:
if sym_node.prompt:
s += " ({})".format(sym_node.prompt[0])
# In single-menu mode, print "--->" next to nodes that have menus that can
# potentially be entered. Print "----" if the menu is empty. We don't allow
# those to be entered.
if _single_menu and node.is_menuconfig:
s += " --->" if _shown_menu_nodes(node) else " ----"
return s
def _img_tag(node):
# Returns the tag for the image that should be shown next to 'node', or the
# empty string if it shouldn't have an image
item = node.item
if item in (MENU, COMMENT) or not item.orig_type:
return ""
if item.orig_type in (STRING, INT, HEX):
return "edit"
if _is_y_mode_choice_sym(item):
# Choice symbol in y-mode choice
return "selected" if item.choice.selection is item else "not-selected"
if len(item.assignable) <= 1:
# Pinned to a single value
return "" if isinstance(item, Choice) else item.str_value + "-locked"
if item.type == BOOL:
return item.str_value + "-bool"
# item.type == TRISTATE
if item.assignable == (1, 2):
return item.str_value + "-my"
return item.str_value + "-tri"
def _is_y_mode_choice_sym(item):
# The choice mode is an upper bound on the visibility of choice symbols, so
# we can check the choice symbols' own visibility to see if the choice is
# in y mode
return isinstance(item, Symbol) and item.choice and item.visibility == 2
def _tree_click(event):
# Click on the Kconfig Treeview
tree = event.widget
if tree.identify_element(event.x, event.y) == "image":
item = tree.identify_row(event.y)
# Select the item before possibly popping up a dialog for
# string/int/hex items, so that its help is visible
_select(tree, item)
_change_node(_id_to_node[item], tree.winfo_toplevel())
return "break"
def _tree_double_click(event):
# Double-click on the Kconfig treeview
# Do an extra check to avoid weirdness when double-clicking in the tree
# heading area
if not _in_heading(event):
return _tree_enter(event)
def _in_heading(event):
# Returns True if 'event' took place in the tree heading
tree = event.widget
return hasattr(tree, "identify_region") and \
tree.identify_region(event.x, event.y) in ("heading", "separator")
def _tree_enter(event):
# Enter press or double-click within the Kconfig treeview. Prefer to
# open/close/enter menus, but toggle the value if that's not possible.
tree = event.widget
sel = tree.focus()
if sel:
node = _id_to_node[sel]
if tree.get_children(sel):
elif _single_menu_mode_menu(node, tree):
_change_node(node, tree.winfo_toplevel())
return "break"
def _tree_toggle(event):
# Space press within the Kconfig treeview. Prefer to toggle the value, but
# open/close/enter the menu if that's not possible.
tree = event.widget
sel = tree.focus()
if sel:
node = _id_to_node[sel]
if _changeable(node):
_change_node(node, tree.winfo_toplevel())
elif _single_menu_mode_menu(node, tree):
elif tree.get_children(sel):
return "break"
def _tree_left_key(_):
# Left arrow key press within the Kconfig treeview
if _single_menu:
# Leave the current menu in single-menu mode
return "break"
# Otherwise, default action
def _tree_right_key(_):
# Right arrow key press within the Kconfig treeview
sel = _tree.focus()
if sel:
node = _id_to_node[sel]
# If the node can be entered in single-menu mode, do it
if _single_menu_mode_menu(node, _tree):
return "break"
# Otherwise, default action
def _single_menu_mode_menu(node, tree):
# Returns True if single-menu mode is on and 'node' is an (interface)
# menu that can be entered
return _single_menu and tree is _tree and node.is_menuconfig and \
def _changeable(node):
# Returns True if 'node' is a Symbol/Choice whose value can be changed
sc = node.item
if not isinstance(sc, (Symbol, Choice)):
return False
# This will hit for invisible symbols, which appear in show-all mode and
# when an invisible symbol has visible children (which can happen e.g. for
# symbols with optional prompts)
if not (node.prompt and expr_value(node.prompt[1])):
return False
return sc.orig_type in (STRING, INT, HEX) or len(sc.assignable) > 1 \
or _is_y_mode_choice_sym(sc)
def _tree_toggle_open(item):
# Opens/closes the Treeview item 'item'
if _tree.item(item, "open"):
_tree.item(item, open=False)
node = _id_to_node[item]
if not isinstance(node.item, Symbol):
# Can only get here in full-tree mode
_tree.item(item, open=True)
def _tree_set_val(tri_val):
def tree_set_val(event):
# n/m/y press within the Kconfig treeview
# Sets the value of the currently selected item to 'tri_val', if that
# value can be assigned
sel = event.widget.focus()
if sel:
sc = _id_to_node[sel].item
if isinstance(sc, (Symbol, Choice)) and tri_val in sc.assignable:
_set_val(sc, tri_val)
return tree_set_val
def _tree_open(_):
# Lazily populates the Kconfig tree when menus are opened in full-tree mode
if _single_menu:
# Work around
# ("ttk::treeview open/closed indicators can be toggled while hidden").
# Clicking on the hidden indicator will call _build_full_tree() in
# single-menu mode otherwise.
node = _id_to_node[_tree.focus()]
# _shown_full_nodes() includes nodes from menus rooted at symbols, so we
# only need to check "real" menus and choices here
if not isinstance(node.item, Symbol):
def _update_menu_path(_):
# Updates the displayed menu path when nodes are selected in the Kconfig
# treeview
sel = _tree.selection()
_menupath["text"] = _menu_path_info(_id_to_node[sel[0]]) if sel else ""
def _item_row(item):
# Returns the row number 'item' appears on within the Kconfig treeview,
# starting from the top of the tree. Used to preserve scrolling.
# ttkTreeview.c in the Tk sources defines a RowNumber() function that does
# the same thing, but it's not exposed.
row = 0
while True:
prev = _tree.prev(item)
if prev:
item = prev
row += _n_rows(item)
item = _tree.parent(item)
if not item:
return row
row += 1
def _n_rows(item):
# _item_row() helper. Returns the number of rows occupied by 'item' and #
# its children.
rows = 1
if _tree.item(item, "open"):
for child in _tree.get_children(item):
rows += _n_rows(child)
return rows
def _attached(item):
# Heuristic for checking if a Treeview item is attached. Doesn't seem to be
# good APIs for this. Might fail for super-obscure cases with tiny trees,
# but you'd just get a small scroll mess-up.
return bool( or _tree.prev(item) or _tree.parent(item))
def _change_node(node, parent):
# Toggles/changes the value of 'node'. 'parent' is the parent window
# (either the main window or the jump-to dialog), in case we need to pop up
# a dialog.
if not _changeable(node):
# sc = symbol/choice
sc = node.item
if sc.type in (INT, HEX, STRING):
s = _set_val_dialog(node, parent)
# Tkinter can return 'unicode' strings on Python 2, which Kconfiglib
# can't deal with. UTF-8-encode the string to work around it.
if _PY2 and isinstance(s, unicode):
s = s.encode("utf-8", "ignore")
if s is not None:
_set_val(sc, s)
elif len(sc.assignable) == 1:
# Handles choice symbols for choices in y mode, which are a special
# case: .assignable can be (2,) while .tri_value is 0.
_set_val(sc, sc.assignable[0])
# Set the symbol to the value after the current value in
# sc.assignable, with wrapping
val_index = sc.assignable.index(sc.tri_value)
_set_val(sc, sc.assignable[(val_index + 1) % len(sc.assignable)])
def _set_val(sc, val):
# Wrapper around Symbol/Choice.set_value() for updating the menu state and
# _conf_changed
# Use the string representation of tristate values. This makes the format
# consistent for all symbol types.
if val in TRI_TO_STR:
val = TRI_TO_STR[val]
if val != sc.str_value:
# Update the tree and try to preserve the scroll. Do a cheaper variant
# than in the show-all case, that might mess up the scroll slightly in
# rare cases, but is fast and flicker-free.
stayput = _loc_ref_item() # Item to preserve scroll for
old_row = _item_row(stayput)
# If the reference item disappeared (can happen if the change was done
# from the jump-to dialog), then avoid messing with the scroll and hope
# for the best
if _attached(stayput):
_tree.yview_scroll(_item_row(stayput) - old_row, "units")
if _jump_to_tree:
def _set_val_dialog(node, parent):
# Pops up a dialog for setting the value of the string/int/hex
# symbol at node 'node'. 'parent' is the parent window.
def ok(_=None):
# No 'nonlocal' in Python 2
global _entry_res
s = entry.get()
if sym.type == HEX and not s.startswith(("0x", "0X")):
s = "0x" + s
if _check_valid(dialog, entry, sym, s):
_entry_res = s
def cancel(_=None):
global _entry_res
_entry_res = None
sym = node.item
dialog = Toplevel(parent)
dialog.title("Enter {} value".format(TYPE_TO_STR[sym.type]))
dialog.resizable(False, False)
dialog.protocol("WM_DELETE_WINDOW", cancel)
ttk.Label(dialog, text=node.prompt[0] + ":") \
.grid(column=0, row=0, columnspan=2, sticky="w", padx=".3c",
pady=".2c .05c")
entry = ttk.Entry(dialog, width=30)
# Start with the previous value in the editbox, selected
entry.insert(0, sym.str_value)
entry.selection_range(0, "end")
entry.grid(column=0, row=1, columnspan=2, sticky="ew", padx=".3c")
range_info = _range_info(sym)
if range_info:
ttk.Label(dialog, text=range_info) \
.grid(column=0, row=2, columnspan=2, sticky="w", padx=".3c",
pady=".2c 0")
ttk.Button(dialog, text="OK", command=ok) \
.grid(column=0, row=4 if range_info else 3, sticky="e", padx=".3c",
ttk.Button(dialog, text="Cancel", command=cancel) \
.grid(column=1, row=4 if range_info else 3, padx="0 .3c")
# Give all horizontal space to the grid cell with the OK button, so that
# Cancel moves to the right
dialog.columnconfigure(0, weight=1)
# Hack to scroll the entry so that the end of the text is shown, from
# Related Tk ticket:
def scroll_entry(_):
entry.bind("<Expose>", scroll_entry)
# The dialog must be visible before we can grab the input
dialog.bind("<Return>", ok)
dialog.bind("<KP_Enter>", ok)
dialog.bind("<Escape>", cancel)
# Wait for the user to be done with the dialog
# Regrab the input in the parent
return _entry_res
def _center_on_root(dialog):
# Centers 'dialog' on the root window. It often ends up at some bad place
# like the top-left corner of the screen otherwise. See the menuconfig()
# function, which has similar logic.
dialog_width = dialog.winfo_reqwidth()
dialog_height = dialog.winfo_reqheight()
screen_width = _root.winfo_screenwidth()
screen_height = _root.winfo_screenheight()
x = _root.winfo_rootx() + (_root.winfo_width() - dialog_width)//2
y = _root.winfo_rooty() + (_root.winfo_height() - dialog_height)//2
# Clamp so that no part of the dialog is outside the screen
if x + dialog_width > screen_width:
x = screen_width - dialog_width
elif x < 0:
x = 0
if y + dialog_height > screen_height:
y = screen_height - dialog_height
elif y < 0:
y = 0
dialog.geometry("+{}+{}".format(x, y))
def _check_valid(dialog, entry, sym, s):
# Returns True if the string 's' is a well-formed value for 'sym'.
# Otherwise, pops up an error and returns False.
if sym.type not in (INT, HEX):
# Anything goes for non-int/hex symbols
return True
base = 10 if sym.type == INT else 16
int(s, base)
except ValueError:
"Bad value",
"'{}' is a malformed {} value".format(
s, TYPE_TO_STR[sym.type]),
return False
for low_sym, high_sym, cond in sym.ranges:
if expr_value(cond):
low_s = low_sym.str_value
high_s = high_sym.str_value
if not int(low_s, base) <= int(s, base) <= int(high_s, base):
"Value out of range",
"{} is outside the range {}-{}".format(s, low_s, high_s),
return False
return True
def _range_info(sym):
# Returns a string with information about the valid range for the symbol
# 'sym', or None if 'sym' doesn't have a range
if sym.type in (INT, HEX):
for low, high, cond in sym.ranges:
if expr_value(cond):
return "Range: {}-{}".format(low.str_value, high.str_value)
return None
def _save(_=None):
# Tries to save the configuration
if _try_save(_kconf.write_config, _conf_filename, "configuration"):
def _save_as():
# Pops up a dialog for saving the configuration to a specific location
global _conf_filename
filename = _conf_filename
while True:
filename = filedialog.asksaveasfilename(
title="Save configuration as",
if not filename:
if _try_save(_kconf.write_config, filename, "configuration"):
_conf_filename = filename
def _save_minimal():
# Pops up a dialog for saving a minimal configuration (defconfig) to a
# specific location
global _minconf_filename
filename = _minconf_filename
while True:
filename = filedialog.asksaveasfilename(
title="Save minimal configuration as",
if not filename:
if _try_save(_kconf.write_min_config, filename,
"minimal configuration"):
_minconf_filename = filename
def _open(_=None):
# Pops up a dialog for loading a configuration
global _conf_filename
if _conf_changed and \
not messagebox.askokcancel(
"Unsaved changes",
"You have unsaved changes. Load new configuration anyway?"):
filename = _conf_filename
while True:
filename = filedialog.askopenfilename(
title="Open configuration",
if not filename:
if _try_load(filename):
# Maybe something fancier could be done here later to try to
# preserve the scroll
_conf_filename = filename
if _single_menu and not _shown_menu_nodes(_cur_menu):
# Turn on show-all if we're in single-menu mode and would end
# up with an empty menu
def _toggle_showname(_):
# Toggles show-name mode on/off
_show_name_var.set(not _show_name_var.get())
def _do_showname():
# Updates the UI for the current show-name setting
# Columns do not automatically shrink/expand, so we have to update
# column widths ourselves
tree_width = _tree.winfo_width()
if _show_name_var.get():
_tree["displaycolumns"] = ("name",)
_tree["show"] = "tree headings"
name_width = tree_width//3
_tree.column("#0", width=max(tree_width - name_width, 1))
_tree.column("name", width=name_width)
_tree["displaycolumns"] = ()
_tree["show"] = "tree"
_tree.column("#0", width=tree_width)
def _toggle_showall(_):
# Toggles show-all mode on/off
_show_all_var.set(not _show_all)
def _do_showall():
# Updates the UI for the current show-all setting
# Don't allow turning off show-all if we'd end up with no visible nodes
if _nothing_shown():
# Save scroll information. old_scroll can end up negative here, if the
# reference item isn't shown (only invisible items on the screen, and
# show-all being turned off).
stayput = _vis_loc_ref_item()
# Probe the middle of the first row, to play it safe. identify_row(0) seems
# to return the row before the top row.
old_scroll = _item_row(stayput) - \
if _show_all:
# Deep magic: Unless we call update_idletasks(), the scroll adjustment
# below is restricted to the height of the old tree, instead of the
# height of the new tree. Since the tree with show-all on is guaranteed
# to be taller, and we want the maximum range, we only call it when
# turning show-all on.
# Strictly speaking, something similar ought to be done when changing
# symbol values, but it causes annoying flicker, and in 99% of cases
# things work anyway there (with usually minor scroll mess-ups in the
# 1% case).
# Restore scroll
_tree.yview(_item_row(stayput) - old_scroll)
def _nothing_shown():
# _do_showall() helper. Returns True if no nodes would get
# shown with the current show-all setting. Also handles the
# (obscure) case when there are no visible nodes in the entire
# tree, meaning guiconfig was automatically started in
# show-all mode, which mustn't be turned off.
return not _shown_menu_nodes(
_cur_menu if _single_menu else _kconf.top_node)
def _toggle_tree_mode(_):
# Toggles single-menu mode on/off
_single_menu_var.set(not _single_menu)
def _do_tree_mode():
# Updates the UI for the current tree mode (full-tree or single-menu)
loc_ref_node = _id_to_node[_loc_ref_item()]
if not _single_menu:
# _jump_to() -> _enter_menu() already updates the tree, but
# _jump_to() -> load_parents() doesn't, because it isn't always needed.
# We always need to update the tree here, e.g. to add/remove "--->".
def _enter_menu_and_select_first(menu):
# Enters the menu 'menu' and selects the first item. Used in single-menu
# mode.
_select(_tree, _tree.get_children()[0])
def _enter_menu(menu):
# Enters the menu 'menu'. Used in single-menu mode.
global _cur_menu
_cur_menu = menu
_backbutton["state"] = "disabled" if menu is _kconf.top_node else "normal"
def _leave_menu():
# Leaves the current menu. Used in single-menu mode.
global _cur_menu
if _cur_menu is not _kconf.top_node:
old_menu = _cur_menu
_cur_menu = _parent_menu(_cur_menu)
_select(_tree, id(old_menu))
if _cur_menu is _kconf.top_node:
_backbutton["state"] = "disabled"
def _select(tree, item):
# Selects, focuses, and see()s 'item' in 'tree'
def _loc_ref_item():
# Returns a Treeview item that can serve as a reference for the current
# scroll location. We try to make this item stay on the same row on the
# screen when updating the tree.
# If the selected item is visible, use that
sel = _tree.selection()
if sel and _tree.bbox(sel[0]):
return sel[0]
# Otherwise, use the middle item on the screen. If it doesn't exist, the
# tree is probably really small, so use the first item in the entire tree.
return _tree.identify_row(_tree.winfo_height()//2) or \
def _vis_loc_ref_item():
# Like _loc_ref_item(), but finds a visible item around the reference item.
# Used when changing show-all mode, where non-visible (red) items will
# disappear.
item = _loc_ref_item()
vis_before = _vis_before(item)
if vis_before and _tree.bbox(vis_before):
return vis_before
vis_after = _vis_after(item)
if vis_after and _tree.bbox(vis_after):
return vis_after
return vis_before or vis_after
def _vis_before(item):
# _vis_loc_ref_item() helper. Returns the first visible (not red) item,
# searching backwards from 'item'.
while item:
if not _tree.tag_has("invisible", item):
return item
prev = _tree.prev(item)
item = prev if prev else _tree.parent(item)
return None
def _vis_after(item):
# _vis_loc_ref_item() helper. Returns the first visible (not red) item,
# searching forwards from 'item'.
while item:
if not _tree.tag_has("invisible", item):
return item
next =
if next:
item = next
item = _tree.parent(item)
if not item:
item =
return None
def _on_quit(_=None):
# Called when the user wants to exit
if not _conf_changed:
_quit("No changes to save (for '{}')".format(_conf_filename))
while True:
ync = messagebox.askyesnocancel("Quit", "Save changes?")
if ync is None:
if not ync:
_quit("Configuration ({}) was not saved".format(_conf_filename))
if _try_save(_kconf.write_config, _conf_filename, "configuration"):
# _try_save() already prints the "Configuration saved to ..."
# message
def _quit(msg=None):
# Quits the application
# Do not call sys.exit() here, in case we're being run from a script
if msg:
def _try_save(save_fn, filename, description):
# Tries to save a configuration file. Pops up an error and returns False on
# failure.
# save_fn:
# Function to call with 'filename' to save the file
# description:
# String describing the thing being saved
# save_fn() returns a message to print
msg = save_fn(filename)
return True
except EnvironmentError as e:
"Error saving " + description,
"Error saving {} to '{}': {} (errno: {})"
.format(description, e.filename, e.strerror,
return False
def _try_load(filename):
# Tries to load a configuration file. Pops up an error and returns False on
# failure.
# filename:
# Configuration file to load
msg = _kconf.load_config(filename)
return True
except EnvironmentError as e:
"Error loading configuration",
"Error loading '{}': {} (errno: {})"
.format(filename, e.strerror, errno.errorcode[e.errno]))
return False
def _jump_to_dialog(_=None):
# Pops up a dialog for jumping directly to a particular node. Symbol values
# can also be changed within the dialog.
# Note: There's nothing preventing this from doing an incremental search
# like does, but currently it's a bit jerky for large Kconfig
# trees, at least when inputting the beginning of the search string. We'd
# need to somehow only update the tree items that are shown in the Treeview
# to fix it.
global _jump_to_tree
def search(_=None):
_update_jump_to_matches(msglabel, entry.get())
def jump_to_selected(event=None):
# Jumps to the selected node and closes the dialog
# Ignore double clicks on the image and in the heading area
if event and (tree.identify_element(event.x, event.y) == "image" or
sel = tree.selection()
if not sel:
node = _id_to_node[sel[0]]
if node not in _shown_menu_nodes(_parent_menu(node)):
if not _single_menu:
# See comment in _do_tree_mode()
def tree_select(_):
jumpto_button["state"] = "normal" if tree.selection() else "disabled"
dialog = Toplevel(_root)
_root.winfo_rootx() + 50, _root.winfo_rooty() + 50))
dialog.title("Jump to symbol/choice/menu/comment")
dialog.minsize(128, 128) # See _create_ui()
ttk.Label(dialog, text=_JUMP_TO_HELP) \
.grid(column=0, row=0, columnspan=2, sticky="w", padx=".1c",
entry = ttk.Entry(dialog)
entry.grid(column=0, row=1, sticky="ew", padx=".1c", pady=".1c")
entry.bind("<Return>", search)
entry.bind("<KP_Enter>", search)
ttk.Button(dialog, text="Search", command=search) \
.grid(column=1, row=1, padx="0 .1c", pady="0 .1c")
msglabel = ttk.Label(dialog)
msglabel.grid(column=0, row=2, sticky="w", pady="0 .1c")
panedwindow, tree = _create_kconfig_tree_and_desc(dialog)
panedwindow.grid(column=0, row=3, columnspan=2, sticky="nsew")
# Clear tree
_jump_to_tree = tree
jumpto_button = ttk.Button(dialog, text="Jump to selected item",
state="disabled", command=jump_to_selected)
jumpto_button.grid(column=0, row=4, columnspan=2, sticky="ns", pady=".1c")
dialog.columnconfigure(0, weight=1)
# Only the pane with the Kconfig tree and description grows vertically
dialog.rowconfigure(3, weight=1)
# See the menuconfig() function
# The dialog must be visible before we can grab the input
tree.bind("<Double-1>", jump_to_selected)
tree.bind("<Return>", jump_to_selected)
tree.bind("<KP_Enter>", jump_to_selected)
# add=True to avoid overriding the description text update
tree.bind("<<TreeviewSelect>>", tree_select, add=True)
dialog.bind("<Escape>", lambda _: dialog.destroy())
# Wait for the user to be done with the dialog
_jump_to_tree = None
def _update_jump_to_matches(msglabel, search_string):
# Searches for nodes matching the search string and updates
# _jump_to_matches. Puts a message in 'msglabel' if there are no matches,
# or regex errors.
global _jump_to_matches
# We could use re.IGNORECASE here instead of lower(), but this is
# faster for regexes like '.*debug$' (though the '.*' is redundant
# there). Those probably have bad interactions with, which
# matches anywhere in the string.
regex_searches = [re.compile(regex).search
for regex in search_string.lower().split()]
except re.error as e:
msg = "Bad regular expression"
# re.error.msg was added in Python 3.5
if hasattr(e, "msg"):
msg += ": " + e.msg
msglabel["text"] = msg
# Clear tree
_jump_to_matches = []
add_match = _jump_to_matches.append
for node in _sorted_sc_nodes():
# Symbol/choice
sc = node.item
for search in regex_searches:
# Both the name and the prompt might be missing, since
# we're searching both symbols and choices
# Does the regex match either the symbol name or the
# prompt (if any)?
if not ( and search( or
node.prompt and search(node.prompt[0].lower())):
# Give up on the first regex that doesn't match, to
# speed things up a bit when multiple regexes are
# entered
# Search menus and comments
for node in _sorted_menu_comment_nodes():
for search in regex_searches:
if not search(node.prompt[0].lower()):
msglabel["text"] = "" if _jump_to_matches else "No matches"
if _jump_to_matches:
item = id(_jump_to_matches[0])
def _update_jump_to_display():
# Updates the images and text for the items in _jump_to_matches, and sets
# them as the items of _jump_to_tree
# Micro-optimize a bit
item = _jump_to_tree.item
id_ = id
node_str = _node_str
img_tag = _img_tag
visible = _visible
for node in _jump_to_matches:
tags=img_tag(node) if visible(node) else
img_tag(node) + " invisible")
_jump_to_tree.set_children("", *map(id, _jump_to_matches))
def _jump_to(node):
# Jumps directly to 'node' and selects it
if _single_menu:
_select(_tree, id(node))
# Obscure Python: We never pass a value for cached_nodes, and it keeps pointing
# to the same list. This avoids a global.
def _sorted_sc_nodes(cached_nodes=[]):
# Returns a sorted list of symbol and choice nodes to search. The symbol
# nodes appear first, sorted by name, and then the choice nodes, sorted by
# prompt and (secondarily) name.
if not cached_nodes:
# Add symbol nodes
for sym in sorted(_kconf.unique_defined_syms,
key=lambda sym:
# += is in-place for lists
cached_nodes += sym.nodes
# Add choice nodes
choices = sorted(_kconf.unique_choices,
key=lambda choice: or "")
cached_nodes += sorted(
[node for choice in choices for node in choice.nodes],
key=lambda node: node.prompt[0] if node.prompt else "")
return cached_nodes
def _sorted_menu_comment_nodes(cached_nodes=[]):
# Returns a list of menu and comment nodes to search, sorted by prompt,
# with the menus first
if not cached_nodes:
def prompt_text(mc):
return mc.prompt[0]
cached_nodes += sorted(_kconf.menus, key=prompt_text)
cached_nodes += sorted(_kconf.comments, key=prompt_text)
return cached_nodes
def _load_parents(node):
# Menus are lazily populated as they're opened in full-tree mode, but
# jumping to an item needs its parent menus to be populated. This function
# populates 'node's parents.
# Get all parents leading up to 'node', sorted with the root first
parents = []
cur = node.parent
while cur is not _kconf.top_node:
cur = cur.parent
for i, parent in enumerate(parents):
if not _tree.item(id(parent), "open"):
# Found a closed menu. Populate it and all the remaining menus
# leading up to 'node'.
for parent in parents[i:]:
# We only need to populate "real" menus/choices. Implicit menus
# are populated when their parents menus are entered.
if not isinstance(parent.item, Symbol):
def _parent_menu(node):
# Returns the menu node of the menu that contains 'node'. In addition to
# proper 'menu's, this might also be a 'menuconfig' symbol or a 'choice'.
# "Menu" here means a menu in the interface.
menu = node.parent
while not menu.is_menuconfig:
menu = menu.parent
return menu
def _trace_write(var, fn):
# Makes fn() be called whenever the Tkinter Variable 'var' changes value
# trace_variable() is deprecated according to the docstring,
# which recommends trace_add()
if hasattr(var, "trace_add"):
var.trace_add("write", fn)
var.trace_variable("w", fn)
def _info_str(node):
# Returns information about the menu node 'node' as a string.
# The helper functions are responsible for adding newlines. This allows
# them to return "" if they don't want to add any output.
if isinstance(node.item, Symbol):
sym = node.item
return (
_name_info(sym) +
_help_info(sym) +
_direct_dep_info(sym) +
_defaults_info(sym) +
_select_imply_info(sym) +
if isinstance(node.item, Choice):
choice = node.item
return (
_name_info(choice) +
_help_info(choice) +
'Mode: {}\n\n'.format(choice.str_value) +
_choice_syms_info(choice) +
_direct_dep_info(choice) +
_defaults_info(choice) +
# node.item in (MENU, COMMENT)
return _kconfig_def_info(node)
def _name_info(sc):
# Returns a string with the name of the symbol/choice. Choices are shown as
# <choice (name if any)>.
return ( if else standard_sc_expr_str(sc)) + "\n\n"
def _value_info(sym):
# Returns a string showing 'sym's value
# Only put quotes around the value for string symbols
return "Value: {}\n".format(
if sym.orig_type == STRING
else sym.str_value)
def _choice_syms_info(choice):
# Returns a string listing the choice symbols in 'choice'. Adds
# "(selected)" next to the selected one.
s = "Choice symbols:\n"
for sym in choice.syms:
s += " - " +
if sym is choice.selection:
s += " (selected)"
s += "\n"
return s + "\n"
def _help_info(sc):
# Returns a string with the help text(s) of 'sc' (Symbol or Choice).
# Symbols and choices defined in multiple locations can have multiple help
# texts.
s = ""
for node in sc.nodes:
if is not None:
s += + "\n\n"
return s
def _direct_dep_info(sc):
# Returns a string describing the direct dependencies of 'sc' (Symbol or
# Choice). The direct dependencies are the OR of the dependencies from each
# definition location. The dependencies at each definition location come
# from 'depends on' and dependencies inherited from parent items.
return "" if sc.direct_dep is _kconf.y else \
'Direct dependencies (={}):\n{}\n' \
_split_expr_info(sc.direct_dep, 2))
def _defaults_info(sc):
# Returns a string describing the defaults of 'sc' (Symbol or Choice)
if not sc.defaults:
return ""
s = "Default"
if len(sc.defaults) > 1:
s += "s"
s += ":\n"
for val, cond in sc.orig_defaults:
s += " - "
if isinstance(sc, Symbol):
s += _expr_str(val)
# Skip the tristate value hint if the expression is just a single
# symbol. _expr_str() already shows its value as a string.
# This also avoids showing the tristate value for string/int/hex
# defaults, which wouldn't make any sense.
if isinstance(val, tuple):
s += ' (={})'.format(TRI_TO_STR[expr_value(val)])
# Don't print the value next to the symbol name for choice
# defaults, as it looks a bit confusing
s +=
s += "\n"
if cond is not _kconf.y:
s += " Condition (={}):\n{}" \
_split_expr_info(cond, 4))
return s + "\n"
def _split_expr_info(expr, indent):
# Returns a string with 'expr' split into its top-level && or || operands,
# with one operand per line, together with the operand's value. This is
# usually enough to get something readable for long expressions. A fancier
# recursive thingy would be possible too.
# indent:
# Number of leading spaces to add before the split expression.
if len(split_expr(expr, AND)) > 1:
split_op = AND
op_str = "&&"
split_op = OR
op_str = "||"
s = ""
for i, term in enumerate(split_expr(expr, split_op)):
s += "{}{} {}".format(indent*" ",
" " if i == 0 else op_str,
# Don't bother showing the value hint if the expression is just a
# single symbol. _expr_str() already shows its value.
if isinstance(term, tuple):
s += " (={})".format(TRI_TO_STR[expr_value(term)])
s += "\n"
return s
def _select_imply_info(sym):
# Returns a string with information about which symbols 'select' or 'imply'
# 'sym'. The selecting/implying symbols are grouped according to which
# value they select/imply 'sym' to (n/m/y).
def sis(expr, val, title):
# sis = selects/implies
sis = [si for si in split_expr(expr, OR) if expr_value(si) == val]
if not sis:
return ""
res = title
for si in sis:
res += " - {}\n".format(split_expr(si, AND)[0].name)
return res + "\n"
s = ""
if sym.rev_dep is not _kconf.n:
s += sis(sym.rev_dep, 2,
"Symbols currently y-selecting this symbol:\n")
s += sis(sym.rev_dep, 1,
"Symbols currently m-selecting this symbol:\n")
s += sis(sym.rev_dep, 0,
"Symbols currently n-selecting this symbol (no effect):\n")
if sym.weak_rev_dep is not _kconf.n:
s += sis(sym.weak_rev_dep, 2,
"Symbols currently y-implying this symbol:\n")
s += sis(sym.weak_rev_dep, 1,
"Symbols currently m-implying this symbol:\n")
s += sis(sym.weak_rev_dep, 0,
"Symbols currently n-implying this symbol (no effect):\n")
return s
def _kconfig_def_info(item):
# Returns a string with the definition of 'item' in Kconfig syntax,
# together with the definition location(s) and their include and menu paths
nodes = [item] if isinstance(item, MenuNode) else item.nodes
s = "Kconfig definition{}, with parent deps. propagated to 'depends on'\n" \
.format("s" if len(nodes) > 1 else "")
s += (len(s) - 1)*"="
for node in nodes:
s += "\n\n" \
"At {}:{}\n" \
"{}" \
"Menu path: {}\n\n" \
"{}" \
.format(node.filename, node.linenr,
return s
def _include_path_info(node):
if not node.include_path:
# In the top-level Kconfig file
return ""
return "Included via {}\n".format(
" -> ".join("{}:{}".format(filename, linenr)
for filename, linenr in node.include_path))
def _menu_path_info(node):
# Returns a string describing the menu path leading up to 'node'
path = ""
while node.parent is not _kconf.top_node:
node = node.parent
# Promptless choices might appear among the parents. Use
# standard_sc_expr_str() for them, so that they show up as
# '<choice (name if any)>'.
path = " -> " + (node.prompt[0] if node.prompt else
standard_sc_expr_str(node.item)) + path
return "(Top)" + path
def _name_and_val_str(sc):
# Custom symbol/choice printer that shows symbol values after symbols
# Show the values of non-constant (non-quoted) symbols that don't look like
# numbers. Things like 123 are actually symbol references, and only work as
# expected due to undefined symbols getting their name as their value.
# Showing the symbol value for those isn't helpful though.
if isinstance(sc, Symbol) and not sc.is_constant and not _is_num(
if not sc.nodes:
# Undefined symbol reference
return "{}(undefined/n)".format(
return '{}(={})'.format(, sc.str_value)
# For other items, use the standard format
return standard_sc_expr_str(sc)
def _expr_str(expr):
# Custom expression printer that shows symbol values
return expr_str(expr, _name_and_val_str)
def _is_num(name):
# Heuristic to see if a symbol name looks like a number, for nicer output
# when printing expressions. Things like 16 are actually symbol names, only
# they get their name as their value when the symbol is undefined.
except ValueError:
if not name.startswith(("0x", "0X")):
return False
int(name, 16)
except ValueError:
return False
return True
if __name__ == "__main__":