#!/usr/bin/env python3

# SPDX-License-Identifier: ISC

# Copyright (c) 2018, Nordic Semiconductor ASA and Ulf Magnusson

"""

Overview

========

A curses-based menuconfig implementation. The interface should feel familiar to

people used to mconf ('make menuconfig').

Supports the same keys as mconf, and also supports a set of keybindings

inspired by Vi:

J/K : Down/Up

L : Enter menu/Toggle item

H : Leave menu

Ctrl-D/U: Page Down/Page Up

G/End : Jump to end of list

g/Home : Jump to beginning of list

The mconf feature where pressing a key jumps to a menu entry with that

character in it in the current menu isn't supported. A jump-to feature for

jumping directly to any symbol (including invisible symbols), choice, menu or

comment (as in a Kconfig 'comment "Foo"') is available instead.

Space and Enter are "smart" and try to do what you'd expect for the given menu

entry.

A few different modes are available:

F: Toggle show-help mode, which shows the help text of the currently selected

item in the window at the bottom of the menu display. This is handy when

browsing through options.

C: Toggle show-name mode, which shows the symbol name before each symbol menu

entry

A: Toggle show-all mode, which shows all items, including currently invisible

items and items that lack a prompt. Invisible items are drawn in a different

style to make them stand out.

Running

=======

menuconfig.py 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.

$srctree is supported through Kconfiglib.

Color schemes

=============

It is possible to customize the color scheme by setting the MENUCONFIG_STYLE

environment variable. For example, setting it to 'aquatic' will enable an

alternative, less yellow, more 'make menuconfig'-like color scheme, contributed

by Mitja Horvat (pinkfluid).

This is the current list of built-in styles:

- default classic Kconfiglib theme with a yellow accent

- monochrome colorless theme (uses only bold and standout) attributes,

this style is used if the terminal doesn't support colors

- aquatic blue tinted style loosely resembling the lxdialog theme

It is possible to customize the current style by changing colors of UI

elements on the screen. This is the list of elements that can be stylized:

- path Top row in the main display, with the menu path

- separator Separator lines between windows. Also used for the top line

in the symbol information display.

- list List of items, e.g. the main display

- selection Style for the selected item

- inv-list Like list, but for invisible items. Used in show-all mode.

- inv-selection Like selection, but for invisible items. Used in show-all

mode.

- help Help text windows at the bottom of various fullscreen

dialogs

- show-help Window showing the help text in show-help mode

- frame Frame around dialog boxes

- body Body of dialog boxes

- edit Edit box in pop-up dialogs

- jump-edit Edit box in jump-to dialog

- text Symbol information text

The color definition is a comma separated list of attributes:

- fg:COLOR Set the foreground/background colors. COLOR can be one of

* or * the basic 16 colors (black, red, green, yellow, blue,

- bg:COLOR magenta,cyan, white and brighter versions, for example,

brightred). On terminals that support more than 8 colors,

you can also directly put in a color number, e.g. fg:123

(hexadecimal and octal constants are accepted as well).

Colors outside the range -1..curses.COLORS-1 (which is

terminal-dependent) are ignored (with a warning). The COLOR

can be also specified using a RGB value in the HTML

notation, for example #RRGGBB. If the terminal supports

color changing, the color is rendered accurately.

Otherwise, the visually nearest color is used.

If the background or foreground color of an element is not

specified, it defaults to -1, representing the default

terminal foreground or background color.

Note: On some terminals a bright version of the color

implies bold.

- bold Use bold text

- underline Use underline text

- standout Standout text attribute (reverse color)

More often than not, some UI elements share the same color definition. In such

cases the right value may specify an UI element from which the color definition

will be copied. For example, "separator=help" will apply the current color

definition for "help" to "separator".

A keyword without the '=' is assumed to be a style template. The template name

is looked up in the built-in styles list and the style definition is expanded

in-place. With this, built-in styles can be used as basis for new styles.

For example, take the aquatic theme and give it a red selection bar:

MENUCONFIG_STYLE="aquatic selection=fg:white,bg:red"

If there's an error in the style definition or if a missing style is assigned

to, the assignment will be ignored, along with a warning being printed on

stderr.

The 'default' theme is always implicitly parsed first (or the 'monochrome'

theme if the terminal lacks colors), so the following two settings have the

same effect:

MENUCONFIG_STYLE="selection=fg:white,bg:red"

MENUCONFIG_STYLE="default selection=fg:white,bg:red"

Other features

==============

- Seamless terminal resizing

- No dependencies on *nix, as the 'curses' module is in the Python standard

library

- Unicode text entry

- Improved information screen compared to mconf:

* Expressions are split up by their top-level &&/|| operands to improve

readability

* Undefined symbols in expressions are pointed out

* Menus and comments have information displays

* Kconfig definitions are printed

* The include path is shown, listing the locations of the 'source'

statements that included the Kconfig file of the symbol (or other

item)

Limitations

===========

- Python 3 only

This is mostly due to Python 2 not having curses.get_wch(), which is needed

for Unicode support.

- Doesn't work out of the box on Windows

Has been tested to work with the wheels provided at

https://www.lfd.uci.edu/~gohlke/pythonlibs/#curses though.

"""

import curses

import errno

import locale

import os

import platform

import re

import sys

import textwrap

from kconfiglib import Symbol, Choice, MENU, COMMENT, MenuNode, \

BOOL, STRING, INT, HEX, UNKNOWN, \

AND, OR, \

expr_str, expr_value, split_expr, \

standard_sc_expr_str, \

TRI_TO_STR, TYPE_TO_STR, \

standard_kconfig, standard_config_filename

#

# Configuration variables

#

# If True, try to convert LC_CTYPE to a UTF-8 locale if it is set to the C

# locale (which implies ASCII). This fixes curses Unicode I/O issues on systems

# with bad defaults. ncurses configures itself from the locale settings.

#

# Related PEP: https://www.python.org/dev/peps/pep-0538/

_CONVERT_C_LC_CTYPE_TO_UTF8 = True

# How many steps an implicit submenu will be indented. Implicit submenus are

# created when an item depends on the symbol before it. Note that symbols

# defined with 'menuconfig' create a separate menu instead of indenting.

_SUBMENU_INDENT = 4

# Number of steps for Page Up/Down to jump

_PG_JUMP = 6

# Height of the help window in show-help mode

_SHOW_HELP_HEIGHT = 8

# How far the cursor needs to be from the edge of the window before it starts

# to scroll. Used for the main menu display, the information display, the

# search display, and for text boxes.

_SCROLL_OFFSET = 5

# Minimum width of dialogs that ask for text input

_INPUT_DIALOG_MIN_WIDTH = 30

# Number of arrows pointing up/down to draw when a window is scrolled

_N_SCROLL_ARROWS = 14

# Lines of help text shown at the bottom of the "main" display

_MAIN_HELP_LINES = """

[Space/Enter] Toggle/enter [ESC] Leave menu [S] Save

[O] Load [?] Symbol info [/] Jump to symbol

[F] Toggle show-help mode [C] Toggle show-name mode [A] Toggle show-all mode

[Q] Quit (prompts for save) [D] Save minimal config (advanced)

"""[1:-1].split("\n")

# Lines of help text shown at the bottom of the information dialog

_INFO_HELP_LINES = """

[ESC/q] Return to menu [/] Jump to symbol

"""[1:-1].split("\n")

# Lines of help text shown at the bottom of the search dialog

_JUMP_TO_HELP_LINES = """

Type text to narrow the search. Regexes are supported (via Python's 're'

module). The up/down cursor keys step in the list. [Enter] jumps to the

selected symbol. [ESC] aborts the search. Type multiple space-separated

strings/regexes to find entries that match all of them. Type Ctrl-F to

view the help of the selected item without leaving the dialog.

"""[1:-1].split("\n")

#

# Styling

#

_STYLES = {

"default": """

path=fg:black,bg:white,bold

separator=fg:black,bg:yellow,bold

list=fg:black,bg:white

selection=fg:white,bg:blue,bold

inv-list=fg:red,bg:white

inv-selection=fg:red,bg:blue

help=path

show-help=list

frame=fg:black,bg:yellow,bold

body=fg:white,bg:black

edit=fg:white,bg:blue

jump-edit=edit

text=list

""",

# This style is forced on terminals that do no support colors

"monochrome": """

path=bold

separator=bold,standout

list=

selection=bold,standout

inv-list=bold

inv-selection=bold,standout

help=bold

show-help=

frame=bold,standout

body=

edit=standout

jump-edit=

text=

""",

# Blue tinted style loosely resembling lxdialog

"aquatic": """

path=fg:cyan,bg:blue,bold

separator=fg:white,bg:cyan,bold

help=path

frame=fg:white,bg:cyan,bold

body=fg:brightwhite,bg:blue

edit=fg:black,bg:white

"""

}

# Standard colors definition

_STYLE_STD_COLORS = {

# Basic colors

"black": curses.COLOR_BLACK,

"red": curses.COLOR_RED,

"green": curses.COLOR_GREEN,

"yellow": curses.COLOR_YELLOW,

"blue": curses.COLOR_BLUE,

"magenta": curses.COLOR_MAGENTA,

"cyan": curses.COLOR_CYAN,

"white": curses.COLOR_WHITE,

# Bright versions

"brightblack": curses.COLOR_BLACK + 8,

"brightred": curses.COLOR_RED + 8,

"brightgreen": curses.COLOR_GREEN + 8,

"brightyellow": curses.COLOR_YELLOW + 8,

"brightblue": curses.COLOR_BLUE + 8,

"brightmagenta": curses.COLOR_MAGENTA + 8,

"brightcyan": curses.COLOR_CYAN + 8,

"brightwhite": curses.COLOR_WHITE + 8,

# Aliases

"purple": curses.COLOR_MAGENTA,

"brightpurple": curses.COLOR_MAGENTA + 8,

}

def _rgb_to_6cube(rgb):

# Converts an 888 RGB color to a 3-tuple (nice in that it's hashable)

# representing the closests xterm 256-color 6x6x6 color cube color.

#

# The xterm 256-color extension uses a RGB color palette with components in

# the range 0-5 (a 6x6x6 cube). The catch is that the mapping is nonlinear.

# Index 0 in the 6x6x6 cube is mapped to 0, index 1 to 95, then 135, 175,

# etc., in increments of 40. See the links below:

#

# https://commons.wikimedia.org/wiki/File:Xterm_256color_chart.svg

# https://github.com/tmux/tmux/blob/master/colour.c

# 48 is the middle ground between 0 and 95.

return tuple(0 if x < 48 else int(round(max(1, (x - 55)/40))) for x in rgb)

def _6cube_to_rgb(r6g6b6):

# Returns the 888 RGB color for a 666 xterm color cube index

return tuple(0 if x == 0 else 40*x + 55 for x in r6g6b6)

def _rgb_to_gray(rgb):

# Converts an 888 RGB color to the index of an xterm 256-color grayscale

# color with approx. the same perceived brightness

# Calculate the luminance (gray intensity) of the color. See

# https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color

# and

# https://www.w3.org/TR/AERT/#color-contrast

luma = 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2]

# Closests index in the grayscale palette, which starts at RGB 0x080808,

# with stepping 0x0A0A0A

index = int(round((luma - 8)/10))

# Clamp the index to 0-23, corresponding to 232-255

return max(0, min(index, 23))

def _gray_to_rgb(index):

# Convert a grayscale index to its closet single RGB component

return 3*(10*index + 8,) # Returns a 3-tuple

# Obscure Python: We never pass a value for rgb2index, and it keeps pointing to

# the same dict. This avoids a global.

def _alloc_rgb(rgb, rgb2index={}):

# Initialize a new entry in the xterm palette to the given RGB color,

# returning its index. If the color has already been initialized, the index

# of the existing entry is returned.

#

# ncurses is palette-based, so we need to overwrite palette entries to make

# new colors.

#

# The colors from 0 to 15 are user-defined, and there's no way to query

# their RGB values, so we better leave them untouched. Also leave any

# hypothetical colors above 255 untouched (though we're unlikely to

# allocate that many colors anyway).

if rgb in rgb2index:

return rgb2index[rgb]

# Many terminals allow the user to customize the first 16 colors. Avoid

# changing their values.

color_index = 16 + len(rgb2index)

if color_index >= 256:

_warn("Unable to allocate new RGB color ", rgb, ". Too many colors "

"allocated.")

return 0

# Map each RGB component from the range 0-255 to the range 0-1000, which is

# what curses uses

curses.init_color(color_index, *(int(round(1000*x/255)) for x in rgb))

rgb2index[rgb] = color_index

return color_index

def _color_from_num(num):

# Returns the index of a color that looks like color 'num' in the xterm

# 256-color palette (but that might not be 'num', if we're redefining

# colors)

# - _alloc_rgb() won't touch the first 16 colors or any (hypothetical)

# colors above 255, so we can always return them as-is

#

# - If the terminal doesn't support changing color definitions, or if

# curses.COLORS < 256, _alloc_rgb() won't touch any color, and all colors

# can be returned as-is

if num < 16 or num > 255 or not curses.can_change_color() or \

curses.COLORS < 256:

return num

# _alloc_rgb() might redefine colors, so emulate the xterm 256-color

# palette by allocating new colors instead of returning color numbers

# directly

if num < 232:

num -= 16

return _alloc_rgb(_6cube_to_rgb(((num//36)%6, (num//6)%6, num%6)))

return _alloc_rgb(_gray_to_rgb(num - 232))

def _color_from_rgb(rgb):

# Returns the index of a color matching the 888 RGB color 'rgb'. The

# returned color might be an ~exact match or an approximation, depending on

# terminal capabilities.

# Calculates the Euclidean distance between two RGB colors

def dist(r1, r2): return sum((x - y)**2 for x, y in zip(r1, r2))

if curses.COLORS >= 256:

# Assume we're dealing with xterm's 256-color extension

if curses.can_change_color():

# Best case -- the terminal supports changing palette entries via

# curses.init_color(). Initialize an unused palette entry and

# return it.

return _alloc_rgb(rgb)

# Second best case -- pick between the xterm 256-color extension colors

# Closest 6-cube "color" color

c6 = _rgb_to_6cube(rgb)

# Closest gray color

gray = _rgb_to_gray(rgb)

if dist(rgb, _6cube_to_rgb(c6)) < dist(rgb, _gray_to_rgb(gray)):

# Use the "color" color from the 6x6x6 color palette. Calculate the

# color number from the 6-cube index triplet.

return 16 + 36*c6[0] + 6*c6[1] + c6[2]

# Use the color from the gray palette

return 232 + gray

# Terminal not in xterm 256-color mode. This is probably the best we can

# do, or is it? Submit patches. :)

min_dist = float('inf')

best = -1

for color in range(curses.COLORS):

# ncurses uses the range 0..1000. Scale that down to 0..255.

d = dist(rgb, tuple(int(round(255*c/1000))

for c in curses.color_content(color)))

if d < min_dist:

min_dist = d

best = color

return best

# Dictionary mapping element types to the curses attributes used to display

# them

_style = {}

def _parse_style(style_str, parsing_default):

# Parses a string with '<element>=<style>' assignments. Anything not

# containing '=' is assumed to be a reference to a built-in style, which is

# treated as if all the assignments from the style were inserted at that

# point in the string.

#

# The parsing_default flag is set to True when we're implicitly parsing the

# 'default'/'monochrome' style, to prevent warnings.

for sline in style_str.split():

# Words without a "=" character represents a style template

if "=" in sline:

key, data = sline.split("=", 1)

# The 'default' style template is assumed to define all keys. We

# run _style_to_curses() for non-existing keys as well, so that we

# print warnings for errors to the right of '=' for those too.

if key not in _style and not parsing_default:

_warn("Ignoring non-existent style", key)

# If data is a reference to another key, copy its style

if data in _style:

_style[key] = _style[data]

else:

_style[key] = _style_to_curses(data)

elif sline in _STYLES:

# Recursively parse style template. Ignore styles that don't exist,

# for backwards/forwards compatibility.

_parse_style(_STYLES[sline], parsing_default)

else:

_warn("Ignoring non-existent style template", sline)

def _style_to_curses(style_def):

# Parses a style definition string (<element>=<style>), returning

# a (fg_color, bg_color, attributes) tuple.

def parse_color(color_def):

color_def = color_def.split(":", 1)[1]

if color_def in _STYLE_STD_COLORS:

return _color_from_num(_STYLE_STD_COLORS[color_def])

# HTML format, #RRGGBB

if re.match("#[A-Fa-f0-9]{6}", color_def):

return _color_from_rgb((

int(color_def[1:3], 16),

int(color_def[3:5], 16),

int(color_def[5:7], 16)))

try:

color_num = _color_from_num(int(color_def, 0))

except ValueError:

_warn("Ignoring color ", color_def, "that's neither predefined "

"nor a number")

return -1

if not -1 <= color_num < curses.COLORS:

_warn("Ignoring color {}, which is outside the range "

"-1..curses.COLORS-1 (-1..{})"

.format(color_def, curses.COLORS - 1))

return -1

return color_num

fg_color = -1

bg_color = -1

attrs = 0

if style_def:

for field in style_def.split(","):

if field.startswith("fg:"):

fg_color = parse_color(field)

elif field.startswith("bg:"):

bg_color = parse_color(field)

elif field == "bold":

# A_BOLD tends to produce faint and hard-to-read text on the

# Windows console, especially with the old color scheme, before

# the introduction of

# https://blogs.msdn.microsoft.com/commandline/2017/08/02/updating-the-windows-console-colors/

attrs |= curses.A_NORMAL if _IS_WINDOWS else curses.A_BOLD

elif field == "standout":

attrs |= curses.A_STANDOUT

elif field == "underline":

attrs |= curses.A_UNDERLINE

else:

_warn("Ignoring unknown style attribute", field)

return _style_attr(fg_color, bg_color, attrs)

def _init_styles():

if curses.has_colors():

curses.use_default_colors()

# Use the 'monochrome' style template as the base on terminals without

# color

_parse_style("default" if curses.has_colors() else "monochrome", True)

# Add any user-defined style from the environment

if "MENUCONFIG_STYLE" in os.environ:

_parse_style(os.environ["MENUCONFIG_STYLE"], False)

# color_attribs holds the color pairs we've already created, indexed by a

# (<foreground color>, <background color>) tuple.

#

# Obscure Python: We never pass a value for color_attribs, and it keeps

# pointing to the same dict. This avoids a global.

def _style_attr(fg_color, bg_color, attribs, color_attribs={}):

# Returns an attribute with the specified foreground and background color

# and the attributes in 'attribs'. Reuses color pairs already created if

# possible, and creates a new color pair otherwise.

#

# Returns 'attribs' if colors aren't supported.

if not curses.has_colors():

return attribs

if (fg_color, bg_color) not in color_attribs:

# Create new color pair. Color pair number 0 is hardcoded and cannot be

# changed, hence the +1s.

curses.init_pair(len(color_attribs) + 1, fg_color, bg_color)

color_attribs[(fg_color, bg_color)] = \

curses.color_pair(len(color_attribs) + 1)

return color_attribs[(fg_color, bg_color)] | attribs

#

# Main application

#

# Used as the entry point in setup.py

def _main():

menuconfig(standard_kconfig())

def menuconfig(kconf):

"""

Launches the configuration interface, returning after the user exits.

kconf:

Kconfig instance to be configured

"""

global _kconf

global _show_all

global _conf_changed

_kconf = kconf

# Always prompt for save if the configuration file doesn't exist

_conf_changed = not kconf.load_config()

# Any visible items in the top menu?

_show_all = False

if not _shown_nodes(kconf.top_node):

# Nothing visible. Start in show-all mode and try again.

_show_all = True

if not _shown_nodes(kconf.top_node):

# Give up. The implementation relies on always having a selected

# node.

print("Empty configuration -- nothing to configure.\n"

"Check that environment variables are set properly.")

return

# Disable warnings. They get mangled in curses mode, and we deal with

# errors ourselves.

kconf.disable_warnings()

# Make curses use the locale settings specified in the environment

locale.setlocale(locale.LC_ALL, "")

# Try to fix Unicode issues on systems with bad defaults

if _CONVERT_C_LC_CTYPE_TO_UTF8:

_convert_c_lc_ctype_to_utf8()

# Get rid of the delay between pressing ESC and jumping to the parent menu,

# unless the user has set ESCDELAY (see ncurses(3)). This makes the UI much

# smoother to work with.

#

# Note: This is strictly pretty iffy, since escape codes for e.g. cursor

# keys start with ESC, but I've never seen it cause problems in practice

# (probably because it's unlikely that the escape code for a key would get

# split up across read()s, at least with a terminal emulator). Please

# report if you run into issues. Some suitable small default value could be

# used here instead in that case. Maybe it's silly to not put in the

# smallest imperceptible delay here already, though I don't like guessing.

#

# (From a quick glance at the ncurses source code, ESCDELAY might only be

# relevant for mouse events there, so maybe escapes are assumed to arrive

# in one piece already...)

os.environ.setdefault("ESCDELAY", "0")

# Enter curses mode. _menuconfig() returns a string to print on exit, after

# curses has been de-initialized.

print(curses.wrapper(_menuconfig))

# Global variables used below:

#

# _stdscr:

# stdscr from curses

#

# _cur_menu:

# Menu node of the menu (or menuconfig symbol, or choice) currently being

# shown

#

# _shown:

# List of items in _cur_menu that are shown (ignoring scrolling). In

# show-all mode, this list contains all items in _cur_menu. Otherwise, it

# contains just the visible items.

#

# _sel_node_i:

# Index in _shown of the currently selected node

#

# _menu_scroll:

# Index in _shown of the top row of the main display

#

# _parent_screen_rows:

# List/stack of the row numbers that the selections in the parent menus

# appeared on. This is used to prevent the scrolling from jumping around

# when going in and out of menus.

#

# _show_help/_show_name/_show_all:

# If True, the corresponding mode is on. See the module docstring.

#

# _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 explicitly

# from the save dialog.

def _menuconfig(stdscr):

# Logic for the main display, with the list of symbols, etc.

global _stdscr

global _conf_changed

global _show_help

global _show_name

_stdscr = stdscr

_init()

while True:

_draw_main()

curses.doupdate()

c = _get_wch_compat(_menu_win)

if c == curses.KEY_RESIZE:

_resize_main()

elif c in (curses.KEY_DOWN, "j", "J"):

_select_next_menu_entry()

elif c in (curses.KEY_UP, "k", "K"):

_select_prev_menu_entry()

elif c in (curses.KEY_NPAGE, "\x04"): # Page Down/Ctrl-D

# Keep it simple. This way we get sane behavior for small windows,

# etc., for free.

for _ in range(_PG_JUMP):

_select_next_menu_entry()

elif c in (curses.KEY_PPAGE, "\x15"): # Page Up/Ctrl-U

for _ in range(_PG_JUMP):

_select_prev_menu_entry()

elif c in (curses.KEY_END, "G"):

_select_last_menu_entry()

elif c in (curses.KEY_HOME, "g"):

_select_first_menu_entry()

elif c in (curses.KEY_RIGHT, " ", "\n", "l", "L"):

# Do appropriate node action. Only Space is treated specially,

# preferring to toggle nodes rather than enter menus.

sel_node = _shown[_sel_node_i]

if sel_node.is_menuconfig and not \

(c == " " and _prefer_toggle(sel_node.item)):

_enter_menu(sel_node)

else:

_change_node(sel_node)

if _is_y_mode_choice_sym(sel_node.item) and not sel_node.list:

# Immediately jump to the parent menu after making a choice

# selection, like 'make menuconfig' does, except if the

# menu node has children (which can happen if a symbol

# 'depends on' a choice symbol that immediately precedes

# it).

_leave_menu()

elif c in ("n", "N"):

_set_sel_node_tri_val(0)

elif c in ("m", "M"):

_set_sel_node_tri_val(1)

elif c in ("y", "Y"):

_set_sel_node_tri_val(2)

elif c in (curses.KEY_LEFT, curses.KEY_BACKSPACE, _ERASE_CHAR,

"\x1B", "h", "H"): # \x1B = ESC

if c == "\x1B" and _cur_menu is _kconf.top_node:

res = _quit_dialog()

if res:

return res

else:

_leave_menu()

elif c in ("o", "O"):

if _conf_changed:

c = _key_dialog(

"Load",

"You have unsaved changes. Load new\n"

"configuration anyway?\n"

"\n"

" (Y)es (C)ancel",

"yc")

if c is None or c == "c":

continue

if _load_dialog():

_conf_changed = False

elif c in ("s", "S"):

if _save_dialog(_kconf.write_config, standard_config_filename(),

"configuration"):

_conf_changed = False

elif c in ("d", "D"):

_save_dialog(_kconf.write_min_config, "defconfig",

"minimal configuration")

elif c == "/":

_jump_to_dialog()

# The terminal might have been resized while the fullscreen jump-to

# dialog was open

_resize_main()

elif c == "?":

_info_dialog(_shown[_sel_node_i], False)

# The terminal might have been resized while the fullscreen info

# dialog was open

_resize_main()

elif c in ("f", "F"):

_show_help = not _show_help

_set_style(_help_win, "show-help" if _show_help else "help")

_resize_main()

elif c in ("c", "C"):

_show_name = not _show_name

elif c in ("a", "A"):

_toggle_show_all()

elif c in ("q", "Q"):

res = _quit_dialog()

if res:

return res

def _quit_dialog():

if not _conf_changed:

return "No changes to save"

while True:

c = _key_dialog(

"Quit",

" Save configuration?\n"

"\n"

"(Y)es (N)o (C)ancel",

"ync")

if c is None or c == "c":

return None

if c == "y":

if _try_save(_kconf.write_config, standard_config_filename(),

"configuration"):

return "Configuration saved to '{}'" \

.format(standard_config_filename())

elif c == "n":

return "Configuration was not saved"

def _init():

# Initializes the main display with the list of symbols, etc. Also does

# misc. global initialization that needs to happen after initializing

# curses.

global _ERASE_CHAR

global _path_win

global _top_sep_win

global _menu_win

global _bot_sep_win

global _help_win

global _parent_screen_rows

global _cur_menu

global _shown

global _sel_node_i

global _menu_scroll

global _show_help

global _show_name

# Looking for this in addition to KEY_BACKSPACE (which is unreliable) makes

# backspace work with TERM=vt100. That makes it likely to work in sane

# environments.

#

# erasechar() returns a 'bytes' object. Since we use get_wch(), we need to

# decode it. Just give up and avoid crashing if it can't be decoded.

_ERASE_CHAR = curses.erasechar().decode("utf-8", "ignore")

_init_styles()

# Hide the cursor

_safe_curs_set(0)

# Initialize windows

# Top row, with menu path

_path_win = _styled_win("path")

# Separator below menu path, with title and arrows pointing up

_top_sep_win = _styled_win("separator")

# List of menu entries with symbols, etc.

_menu_win = _styled_win("list")

_menu_win.keypad(True)

# Row below menu list, with arrows pointing down

_bot_sep_win = _styled_win("separator")

# Help window with keys at the bottom. Shows help texts in show-help mode.

_help_win = _styled_win("help")

# The rows we'd like the nodes in the parent menus to appear on. This

# prevents the scroll from jumping around when going in and out of menus.

_parent_screen_rows = []

# Initial state

_cur_menu = _kconf.top_node

_shown = _shown_nodes(_cur_menu)

_sel_node_i = _menu_scroll = 0

_show_help = _show_name = False

# Give windows their initial size

_resize_main()

def _resize_main():

# Resizes the main display, with the list of symbols, etc., to fill the

# terminal

global _menu_scroll

screen_height, screen_width = _stdscr.getmaxyx()

_path_win.resize(1, screen_width)

_top_sep_win.resize(1, screen_width)

_bot_sep_win.resize(1, screen_width)

help_win_height = _SHOW_HELP_HEIGHT if _show_help else \

len(_MAIN_HELP_LINES)

menu_win_height = screen_height - help_win_height - 3

if menu_win_height >= 1:

_menu_win.resize(menu_win_height, screen_width)

_help_win.resize(help_win_height, screen_width)

_top_sep_win.mvwin(1, 0)

_menu_win.mvwin(2, 0)

_bot_sep_win.mvwin(2 + menu_win_height, 0)

_help_win.mvwin(2 + menu_win_height + 1, 0)

else:

# Degenerate case. Give up on nice rendering and just prevent errors.

menu_win_height = 1

_menu_win.resize(1, screen_width)

_help_win.resize(1, screen_width)

for win in _top_sep_win, _menu_win, _bot_sep_win, _help_win:

win.mvwin(0, 0)

# Adjust the scroll so that the selected node is still within the window,

# if needed

if _sel_node_i - _menu_scroll >= menu_win_height:

_menu_scroll = _sel_node_i - menu_win_height + 1

def _menu_win_height():

# Returns the height of the menu display

return _menu_win.getmaxyx()[0]

def _prefer_toggle(item):

# For nodes with menus, determines whether Space should change the value of

# the node's item or enter its menu. We toggle symbols (which have menus

# when they're defined with 'menuconfig') and choices that can be in more

# than one mode (e.g. optional choices). In other cases, we enter the menu.

return isinstance(item, Symbol) or \

(isinstance(item, Choice) and len(item.assignable) > 1)