| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  | #!/usr/bin/env python3 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # Copyright (c) 2018-2019, Nordic Semiconductor ASA and Ulf Magnusson | 
					
						
							|  |  |  | # SPDX-License-Identifier: ISC | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | """
 | 
					
						
							|  |  |  | Overview | 
					
						
							|  |  |  | ======== | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | A curses-based Python 2/3 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 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | [Space] toggles values if possible, and enters menus otherwise. [Enter] works | 
					
						
							|  |  |  | the other way around. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | When overwriting a configuration file, the old version is saved to | 
					
						
							|  |  |  | <filename>.old (e.g. .config.old). | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | $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, so the following two | 
					
						
							|  |  |  | settings have the same effect: | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     MENUCONFIG_STYLE="selection=fg:white,bg:red" | 
					
						
							|  |  |  |     MENUCONFIG_STYLE="default selection=fg:white,bg:red" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | If the terminal doesn't support colors, the 'monochrome' theme is used, and | 
					
						
							|  |  |  | MENUCONFIG_STYLE is ignored. The assumption is that the environment is broken | 
					
						
							|  |  |  | somehow, and that the important thing is to get something usable. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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 | 
					
						
							|  |  |  | =========== | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | Doesn't work out of the box on Windows, but can be made to work with | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     pip install windows-curses | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | See the https://github.com/zephyrproject-rtos/windows-curses repository. | 
					
						
							|  |  |  | """
 | 
					
						
							|  |  |  | from __future__ import print_function | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | import os | 
					
						
							|  |  |  | import sys | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | _IS_WINDOWS = os.name == "nt"  # Are we running on Windows? | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | try: | 
					
						
							|  |  |  |     import curses | 
					
						
							|  |  |  | except ImportError as e: | 
					
						
							|  |  |  |     if not _IS_WINDOWS: | 
					
						
							|  |  |  |         raise | 
					
						
							|  |  |  |     sys.exit("""\
 | 
					
						
							|  |  |  | menuconfig failed to import the standard Python 'curses' library. Try | 
					
						
							|  |  |  | installing a package like windows-curses | 
					
						
							|  |  |  | (https://github.com/zephyrproject-rtos/windows-curses) by running this command | 
					
						
							|  |  |  | in cmd.exe: | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     pip install windows-curses | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | Starting with Kconfiglib 13.0.0, windows-curses is no longer automatically | 
					
						
							|  |  |  | installed when installing Kconfiglib via pip on Windows (because it breaks | 
					
						
							|  |  |  | installation on MSYS2). | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | Exception: | 
					
						
							|  |  |  | {}: {}""".format(type(e).__name__, e))
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | import errno | 
					
						
							|  |  |  | import locale | 
					
						
							|  |  |  | import re | 
					
						
							|  |  |  | import textwrap | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | from kconfiglib import Symbol, Choice, MENU, COMMENT, MenuNode, \ | 
					
						
							|  |  |  |                        BOOL, TRISTATE, STRING, INT, HEX, \ | 
					
						
							|  |  |  |                        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 change 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/ | 
					
						
							|  |  |  | _CHANGE_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 = """
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  | [Space/Enter] Toggle/enter      [?] Help            [/] Search | 
					
						
							|  |  |  | [Q] Quit (prompts for save)     [ESC] Leave menu | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  | """[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:white,bg:blue | 
					
						
							|  |  |  |     separator=fg:white,bg:cyan | 
					
						
							|  |  |  |     help=path | 
					
						
							|  |  |  |     frame=fg:white,bg:cyan | 
					
						
							|  |  |  |     body=fg:white,bg:blue | 
					
						
							|  |  |  |     edit=fg:black,bg:white | 
					
						
							|  |  |  |     """
 | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | _NAMED_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 closest 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] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Closest 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 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # Dictionary mapping element types to the curses attributes used to display | 
					
						
							|  |  |  | # them | 
					
						
							|  |  |  | _style = {} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # 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))) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if color_def in _NAMED_COLORS: | 
					
						
							|  |  |  |             color_num = _color_from_num(_NAMED_COLORS[color_def]) | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             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(): | 
					
						
							|  |  |  |         try: | 
					
						
							|  |  |  |             curses.use_default_colors() | 
					
						
							|  |  |  |         except curses.error: | 
					
						
							|  |  |  |             # Ignore errors on funky terminals that support colors but not | 
					
						
							|  |  |  |             # using default colors. Worst it can do is break transparency and | 
					
						
							|  |  |  |             # the like. Ran across this with the MSYS2/winpty setup in | 
					
						
							|  |  |  |             # https://github.com/msys2/MINGW-packages/issues/5823, though there | 
					
						
							|  |  |  |             # seems to be a lot of general brokenness there. | 
					
						
							|  |  |  |             pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # Use the 'default' theme as the base, and add any user-defined style | 
					
						
							|  |  |  |         # settings from the environment | 
					
						
							|  |  |  |         _parse_style("default", True) | 
					
						
							|  |  |  |         if "MENUCONFIG_STYLE" in os.environ: | 
					
						
							|  |  |  |             _parse_style(os.environ["MENUCONFIG_STYLE"], False) | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # Force the 'monochrome' theme if the terminal doesn't support colors. | 
					
						
							|  |  |  |         # MENUCONFIG_STYLE is likely to mess things up here (though any colors | 
					
						
							|  |  |  |         # would be ignored), so ignore it. | 
					
						
							|  |  |  |         _parse_style("monochrome", True) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # 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 | 
					
						
							|  |  |  | # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _main(): | 
					
						
							|  |  |  |     menuconfig(standard_kconfig(__doc__)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def menuconfig(kconf): | 
					
						
							|  |  |  |     """
 | 
					
						
							|  |  |  |     Launches the configuration interface, returning after the user exits. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     kconf: | 
					
						
							|  |  |  |       Kconfig instance to be configured | 
					
						
							|  |  |  |     """
 | 
					
						
							|  |  |  |     global _kconf | 
					
						
							|  |  |  |     global _conf_filename | 
					
						
							|  |  |  |     global _conf_changed | 
					
						
							|  |  |  |     global _minconf_filename | 
					
						
							|  |  |  |     global _show_all | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _kconf = kconf | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Filename to save configuration to | 
					
						
							|  |  |  |     _conf_filename = standard_config_filename() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Load existing configuration and set _conf_changed True if it is outdated | 
					
						
							|  |  |  |     _conf_changed = _load_config() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Filename to save minimal configuration to | 
					
						
							|  |  |  |     _minconf_filename = "defconfig" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # 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.warn = False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # 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 _CHANGE_C_LC_CTYPE_TO_UTF8: | 
					
						
							|  |  |  |         _change_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)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     print(_kconf.load_config()) | 
					
						
							|  |  |  |     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 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # 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_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 explicitly | 
					
						
							|  |  |  | #     from the save dialog. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _menuconfig(stdscr): | 
					
						
							|  |  |  |     # Logic for the main display, with the list of symbols, etc. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _stdscr | 
					
						
							|  |  |  |     global _conf_filename | 
					
						
							|  |  |  |     global _conf_changed | 
					
						
							|  |  |  |     global _minconf_filename | 
					
						
							|  |  |  |     global _show_help | 
					
						
							|  |  |  |     global _show_name | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _stdscr = stdscr | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _init() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         _draw_main() | 
					
						
							|  |  |  |         curses.doupdate() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         c = _getch_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 == " ": | 
					
						
							|  |  |  |             # Toggle the node if possible | 
					
						
							|  |  |  |             sel_node = _shown[_sel_node_i] | 
					
						
							|  |  |  |             if not _change_node(sel_node): | 
					
						
							|  |  |  |                 _enter_menu(sel_node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_RIGHT, "\n", "l", "L"): | 
					
						
							|  |  |  |             # Enter the node if possible | 
					
						
							|  |  |  |             sel_node = _shown[_sel_node_i] | 
					
						
							|  |  |  |             if not _enter_menu(sel_node): | 
					
						
							|  |  |  |                 _change_node(sel_node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         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() | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         elif 0 and c in ("o", "O"): | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             _load_dialog() | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         elif 0 and c in ("s", "S"): | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             filename = _save_dialog(_kconf.write_config, _conf_filename, | 
					
						
							|  |  |  |                                     "configuration") | 
					
						
							|  |  |  |             if filename: | 
					
						
							|  |  |  |                 _conf_filename = filename | 
					
						
							|  |  |  |                 _conf_changed = False | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         elif 0 and c in ("d", "D"): | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             filename = _save_dialog(_kconf.write_min_config, _minconf_filename, | 
					
						
							|  |  |  |                                     "minimal configuration") | 
					
						
							|  |  |  |             if filename: | 
					
						
							|  |  |  |                 _minconf_filename = filename | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         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() | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         elif 0 and c in ("f", "F"): | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             _show_help = not _show_help | 
					
						
							|  |  |  |             _set_style(_help_win, "show-help" if _show_help else "help") | 
					
						
							|  |  |  |             _resize_main() | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         elif 0 and c in ("c", "C"): | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             _show_name = not _show_name | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         elif 0 and c in ("a", "A"): | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             _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 (for '{}')".format(_conf_filename) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     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": | 
					
						
							|  |  |  |             # Returns a message to print | 
					
						
							|  |  |  |             msg = _try_save(_kconf.write_config, _conf_filename, "configuration") | 
					
						
							|  |  |  |             if msg: | 
					
						
							|  |  |  |                 return msg | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "n": | 
					
						
							|  |  |  |             return "Configuration ({}) was not saved".format(_conf_filename) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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. | 
					
						
							|  |  |  |     _ERASE_CHAR = curses.erasechar() | 
					
						
							|  |  |  |     if sys.version_info[0] >= 3: | 
					
						
							|  |  |  |         # erasechar() returns a one-byte bytes object on Python 3. This sets | 
					
						
							|  |  |  |         # _ERASE_CHAR to a blank string if it can't be decoded, which should be | 
					
						
							|  |  |  |         # harmless. | 
					
						
							|  |  |  |         _ERASE_CHAR = _ERASE_CHAR.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 _height(win): | 
					
						
							|  |  |  |     # Returns the height of 'win' | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return win.getmaxyx()[0] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _width(win): | 
					
						
							|  |  |  |     # Returns the width of 'win' | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return win.getmaxyx()[1] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _enter_menu(menu): | 
					
						
							|  |  |  |     # Makes 'menu' the currently displayed menu. In addition to actual 'menu's, | 
					
						
							|  |  |  |     # "menu" here includes choices and symbols defined with the 'menuconfig' | 
					
						
							|  |  |  |     # keyword. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Returns False if 'menu' can't be entered. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _cur_menu | 
					
						
							|  |  |  |     global _shown | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if not menu.is_menuconfig: | 
					
						
							|  |  |  |         return False  # Not a menu | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     shown_sub = _shown_nodes(menu) | 
					
						
							|  |  |  |     # Never enter empty menus. We depend on having a current node. | 
					
						
							|  |  |  |     if not shown_sub: | 
					
						
							|  |  |  |         return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Remember where the current node appears on the screen, so we can try | 
					
						
							|  |  |  |     # to get it to appear in the same place when we leave the menu | 
					
						
							|  |  |  |     _parent_screen_rows.append(_sel_node_i - _menu_scroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Jump into menu | 
					
						
							|  |  |  |     _cur_menu = menu | 
					
						
							|  |  |  |     _shown = shown_sub | 
					
						
							|  |  |  |     _sel_node_i = _menu_scroll = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if isinstance(menu.item, Choice): | 
					
						
							|  |  |  |         _select_selected_choice_sym() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return True | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _select_selected_choice_sym(): | 
					
						
							|  |  |  |     # Puts the cursor on the currently selected (y-valued) choice symbol, if | 
					
						
							|  |  |  |     # any. Does nothing if if the choice has no selection (is not visible/in y | 
					
						
							|  |  |  |     # mode). | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     choice = _cur_menu.item | 
					
						
							|  |  |  |     if choice.selection: | 
					
						
							|  |  |  |         # Search through all menu nodes to handle choice symbols being defined | 
					
						
							|  |  |  |         # in multiple locations | 
					
						
							|  |  |  |         for node in choice.selection.nodes: | 
					
						
							|  |  |  |             if node in _shown: | 
					
						
							|  |  |  |                 _sel_node_i = _shown.index(node) | 
					
						
							|  |  |  |                 _center_vertically() | 
					
						
							|  |  |  |                 return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _jump_to(node): | 
					
						
							|  |  |  |     # Jumps directly to the menu node 'node' | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _cur_menu | 
					
						
							|  |  |  |     global _shown | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  |     global _show_all | 
					
						
							|  |  |  |     global _parent_screen_rows | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Clear remembered menu locations. We might not even have been in the | 
					
						
							|  |  |  |     # parent menus before. | 
					
						
							|  |  |  |     _parent_screen_rows = [] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     old_show_all = _show_all | 
					
						
							|  |  |  |     jump_into = (isinstance(node.item, Choice) or node.item == MENU) and \ | 
					
						
							|  |  |  |                 node.list | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # If we're jumping to a non-empty choice or menu, jump to the first entry | 
					
						
							|  |  |  |     # in it instead of jumping to its menu node | 
					
						
							|  |  |  |     if jump_into: | 
					
						
							|  |  |  |         _cur_menu = node | 
					
						
							|  |  |  |         node = node.list | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         _cur_menu = _parent_menu(node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _shown = _shown_nodes(_cur_menu) | 
					
						
							|  |  |  |     if node not in _shown: | 
					
						
							|  |  |  |         # The node wouldn't be shown. Turn on show-all to show it. | 
					
						
							|  |  |  |         _show_all = True | 
					
						
							|  |  |  |         _shown = _shown_nodes(_cur_menu) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _sel_node_i = _shown.index(node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if jump_into and not old_show_all and _show_all: | 
					
						
							|  |  |  |         # If we're jumping into a choice or menu and were forced to turn on | 
					
						
							|  |  |  |         # show-all because the first entry wasn't visible, try turning it off. | 
					
						
							|  |  |  |         # That will land us at the first visible node if there are visible | 
					
						
							|  |  |  |         # nodes, and is a no-op otherwise. | 
					
						
							|  |  |  |         _toggle_show_all() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _center_vertically() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # If we're jumping to a non-empty choice, jump to the selected symbol, if | 
					
						
							|  |  |  |     # any | 
					
						
							|  |  |  |     if jump_into and isinstance(_cur_menu.item, Choice): | 
					
						
							|  |  |  |         _select_selected_choice_sym() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _leave_menu(): | 
					
						
							|  |  |  |     # Jumps to the parent menu of the current menu. Does nothing if we're in | 
					
						
							|  |  |  |     # the top menu. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _cur_menu | 
					
						
							|  |  |  |     global _shown | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _cur_menu is _kconf.top_node: | 
					
						
							|  |  |  |         return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Jump to parent menu | 
					
						
							|  |  |  |     parent = _parent_menu(_cur_menu) | 
					
						
							|  |  |  |     _shown = _shown_nodes(parent) | 
					
						
							|  |  |  |     _sel_node_i = _shown.index(_cur_menu) | 
					
						
							|  |  |  |     _cur_menu = parent | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Try to make the menu entry appear on the same row on the screen as it did | 
					
						
							|  |  |  |     # before we entered the menu. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _parent_screen_rows: | 
					
						
							|  |  |  |         # The terminal might have shrunk since we were last in the parent menu | 
					
						
							|  |  |  |         screen_row = min(_parent_screen_rows.pop(), _height(_menu_win) - 1) | 
					
						
							|  |  |  |         _menu_scroll = max(_sel_node_i - screen_row, 0) | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # No saved parent menu locations, meaning we jumped directly to some | 
					
						
							|  |  |  |         # node earlier | 
					
						
							|  |  |  |         _center_vertically() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _select_next_menu_entry(): | 
					
						
							|  |  |  |     # Selects the menu entry after the current one, adjusting the scroll if | 
					
						
							|  |  |  |     # necessary. Does nothing if we're already at the last menu entry. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _sel_node_i < len(_shown) - 1: | 
					
						
							|  |  |  |         # Jump to the next node | 
					
						
							|  |  |  |         _sel_node_i += 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # If the new node is sufficiently close to the edge of the menu window | 
					
						
							|  |  |  |         # (as determined by _SCROLL_OFFSET), increase the scroll by one. This | 
					
						
							|  |  |  |         # gives nice and non-jumpy behavior even when | 
					
						
							|  |  |  |         # _SCROLL_OFFSET >= _height(_menu_win). | 
					
						
							|  |  |  |         if _sel_node_i >= _menu_scroll + _height(_menu_win) - _SCROLL_OFFSET \ | 
					
						
							|  |  |  |            and _menu_scroll < _max_scroll(_shown, _menu_win): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             _menu_scroll += 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _select_prev_menu_entry(): | 
					
						
							|  |  |  |     # Selects the menu entry before the current one, adjusting the scroll if | 
					
						
							|  |  |  |     # necessary. Does nothing if we're already at the first menu entry. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _sel_node_i > 0: | 
					
						
							|  |  |  |         # Jump to the previous node | 
					
						
							|  |  |  |         _sel_node_i -= 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # See _select_next_menu_entry() | 
					
						
							|  |  |  |         if _sel_node_i < _menu_scroll + _SCROLL_OFFSET: | 
					
						
							|  |  |  |             _menu_scroll = max(_menu_scroll - 1, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _select_last_menu_entry(): | 
					
						
							|  |  |  |     # Selects the last menu entry in the current menu | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _sel_node_i = len(_shown) - 1 | 
					
						
							|  |  |  |     _menu_scroll = _max_scroll(_shown, _menu_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _select_first_menu_entry(): | 
					
						
							|  |  |  |     # Selects the first menu entry in the current menu | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _sel_node_i = _menu_scroll = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _toggle_show_all(): | 
					
						
							|  |  |  |     # Toggles show-all mode on/off. If turning it off would give no visible | 
					
						
							|  |  |  |     # items in the current menu, it is left on. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _show_all | 
					
						
							|  |  |  |     global _shown | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Row on the screen the cursor is on. Preferably we want the same row to | 
					
						
							|  |  |  |     # stay highlighted. | 
					
						
							|  |  |  |     old_row = _sel_node_i - _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _show_all = not _show_all | 
					
						
							|  |  |  |     # List of new nodes to be shown after toggling _show_all | 
					
						
							|  |  |  |     new_shown = _shown_nodes(_cur_menu) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Find a good node to select. The selected node might disappear if show-all | 
					
						
							|  |  |  |     # mode is turned off. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Select the previously selected node itself if it is still visible. If | 
					
						
							|  |  |  |     # there are visible nodes before it, select the closest one. | 
					
						
							|  |  |  |     for node in _shown[_sel_node_i::-1]: | 
					
						
							|  |  |  |         if node in new_shown: | 
					
						
							|  |  |  |             _sel_node_i = new_shown.index(node) | 
					
						
							|  |  |  |             break | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # No visible nodes before the previously selected node. Select the | 
					
						
							|  |  |  |         # closest visible node after it instead. | 
					
						
							|  |  |  |         for node in _shown[_sel_node_i + 1:]: | 
					
						
							|  |  |  |             if node in new_shown: | 
					
						
							|  |  |  |                 _sel_node_i = new_shown.index(node) | 
					
						
							|  |  |  |                 break | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             # No visible nodes at all, meaning show-all was turned off inside | 
					
						
							|  |  |  |             # an invisible menu. Don't allow that, as the implementation relies | 
					
						
							|  |  |  |             # on always having a selected node. | 
					
						
							|  |  |  |             _show_all = True | 
					
						
							|  |  |  |             return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _shown = new_shown | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Try to make the cursor stay on the same row in the menu window. This | 
					
						
							|  |  |  |     # might be impossible if too many nodes have disappeared above the node. | 
					
						
							|  |  |  |     _menu_scroll = max(_sel_node_i - old_row, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _center_vertically(): | 
					
						
							|  |  |  |     # Centers the selected node vertically, if possible | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _menu_scroll = min(max(_sel_node_i - _height(_menu_win)//2, 0), | 
					
						
							|  |  |  |                        _max_scroll(_shown, _menu_win)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _draw_main(): | 
					
						
							|  |  |  |     # Draws the "main" display, with the list of symbols, the header, and the | 
					
						
							|  |  |  |     # footer. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # This could be optimized to only update the windows that have actually | 
					
						
							|  |  |  |     # changed, but keep it simple for now and let curses sort it out. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     term_width = _width(_stdscr) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update the separator row below the menu path | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _top_sep_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw arrows pointing up if the symbol window is scrolled down. Draw them | 
					
						
							|  |  |  |     # before drawing the title, so the title ends up on top for small windows. | 
					
						
							|  |  |  |     if _menu_scroll > 0: | 
					
						
							|  |  |  |         _safe_hline(_top_sep_win, 0, 4, curses.ACS_UARROW, _N_SCROLL_ARROWS) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Add the 'mainmenu' text as the title, centered at the top | 
					
						
							|  |  |  |     _safe_addstr(_top_sep_win, | 
					
						
							|  |  |  |                  0, max((term_width - len(_kconf.mainmenu_text))//2, 0), | 
					
						
							|  |  |  |                  _kconf.mainmenu_text) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _top_sep_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Note: The menu path at the top is deliberately updated last. See below. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update the symbol window | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _menu_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw the _shown nodes starting from index _menu_scroll up to either as | 
					
						
							|  |  |  |     # many as fit in the window, or to the end of _shown | 
					
						
							|  |  |  |     for i in range(_menu_scroll, | 
					
						
							|  |  |  |                    min(_menu_scroll + _height(_menu_win), len(_shown))): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         node = _shown[i] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # The 'not _show_all' test avoids showing invisible items in red | 
					
						
							|  |  |  |         # outside show-all mode, which could look confusing/broken. Invisible | 
					
						
							|  |  |  |         # symbols show up outside show-all mode if an invisible symbol has | 
					
						
							|  |  |  |         # visible children in an implicit (indented) menu. | 
					
						
							|  |  |  |         if _visible(node) or not _show_all: | 
					
						
							|  |  |  |             style = _style["selection" if i == _sel_node_i else "list"] | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             style = _style["inv-selection" if i == _sel_node_i else "inv-list"] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         _safe_addstr(_menu_win, i - _menu_scroll, 0, _node_str(node), style) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _menu_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update the bottom separator window | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _bot_sep_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw arrows pointing down if the symbol window is scrolled up | 
					
						
							|  |  |  |     if _menu_scroll < _max_scroll(_shown, _menu_win): | 
					
						
							|  |  |  |         _safe_hline(_bot_sep_win, 0, 4, curses.ACS_DARROW, _N_SCROLL_ARROWS) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Indicate when show-name/show-help/show-all mode is enabled | 
					
						
							|  |  |  |     enabled_modes = [] | 
					
						
							|  |  |  |     if _show_help: | 
					
						
							|  |  |  |         enabled_modes.append("show-help (toggle with [F])") | 
					
						
							|  |  |  |     if _show_name: | 
					
						
							|  |  |  |         enabled_modes.append("show-name") | 
					
						
							|  |  |  |     if _show_all: | 
					
						
							|  |  |  |         enabled_modes.append("show-all") | 
					
						
							|  |  |  |     if enabled_modes: | 
					
						
							|  |  |  |         s = " and ".join(enabled_modes) + " mode enabled" | 
					
						
							|  |  |  |         _safe_addstr(_bot_sep_win, 0, max(term_width - len(s) - 2, 0), s) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _bot_sep_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update the help window, which shows either key bindings or help texts | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _help_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _show_help: | 
					
						
							|  |  |  |         node = _shown[_sel_node_i] | 
					
						
							|  |  |  |         if isinstance(node.item, (Symbol, Choice)) and node.help: | 
					
						
							|  |  |  |             help_lines = textwrap.wrap(node.help, _width(_help_win)) | 
					
						
							|  |  |  |             for i in range(min(_height(_help_win), len(help_lines))): | 
					
						
							|  |  |  |                 _safe_addstr(_help_win, i, 0, help_lines[i]) | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             _safe_addstr(_help_win, 0, 0, "(no help)") | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         for i, line in enumerate(_MAIN_HELP_LINES): | 
					
						
							|  |  |  |             _safe_addstr(_help_win, i, 0, line) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _help_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update the top row with the menu path. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Doing this last leaves the cursor on the top row, which avoids some minor | 
					
						
							|  |  |  |     # annoying jumpiness in gnome-terminal when reducing the height of the | 
					
						
							|  |  |  |     # terminal. It seems to happen whenever the row with the cursor on it | 
					
						
							|  |  |  |     # disappears. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _path_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw the menu path ("(Top) -> Menu -> Submenu -> ...") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     menu_prompts = [] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     menu = _cur_menu | 
					
						
							|  |  |  |     while menu is not _kconf.top_node: | 
					
						
							|  |  |  |         # Promptless choices can be entered in show-all mode. Use | 
					
						
							|  |  |  |         # standard_sc_expr_str() for them, so they show up as | 
					
						
							|  |  |  |         # '<choice (name if any)>'. | 
					
						
							|  |  |  |         menu_prompts.append(menu.prompt[0] if menu.prompt else | 
					
						
							|  |  |  |                             standard_sc_expr_str(menu.item)) | 
					
						
							|  |  |  |         menu = menu.parent | 
					
						
							|  |  |  |     menu_prompts.append("(Top)") | 
					
						
							|  |  |  |     menu_prompts.reverse() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Hack: We can't put ACS_RARROW directly in the string. Temporarily | 
					
						
							|  |  |  |     # represent it with NULL. | 
					
						
							|  |  |  |     menu_path_str = " \0 ".join(menu_prompts) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Scroll the menu path to the right if needed to make the current menu's | 
					
						
							|  |  |  |     # title visible | 
					
						
							|  |  |  |     if len(menu_path_str) > term_width: | 
					
						
							|  |  |  |         menu_path_str = menu_path_str[len(menu_path_str) - term_width:] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Print the path with the arrows reinserted | 
					
						
							|  |  |  |     split_path = menu_path_str.split("\0") | 
					
						
							|  |  |  |     _safe_addstr(_path_win, split_path[0]) | 
					
						
							|  |  |  |     for s in split_path[1:]: | 
					
						
							|  |  |  |         _safe_addch(_path_win, curses.ACS_RARROW) | 
					
						
							|  |  |  |         _safe_addstr(_path_win, s) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _path_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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 _shown_nodes(menu): | 
					
						
							|  |  |  |     # Returns the list of menu nodes from 'menu' (see _parent_menu()) that | 
					
						
							|  |  |  |     # would be shown when entering it | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     def rec(node): | 
					
						
							|  |  |  |         res = [] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         while node: | 
					
						
							|  |  |  |             if _visible(node) or _show_all: | 
					
						
							|  |  |  |                 res.append(node) | 
					
						
							|  |  |  |                 if node.list and not node.is_menuconfig: | 
					
						
							|  |  |  |                     # Nodes from implicit menu created from dependencies. Will | 
					
						
							|  |  |  |                     # be shown indented. Note that is_menuconfig is True for | 
					
						
							|  |  |  |                     # menus and choices as well as 'menuconfig' symbols. | 
					
						
							|  |  |  |                     res += rec(node.list) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             elif node.list and isinstance(node.item, Symbol): | 
					
						
							|  |  |  |                 # Show invisible symbols 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. Note | 
					
						
							|  |  |  |                 # that it applies to both 'config' and 'menuconfig' symbols. | 
					
						
							|  |  |  |                 shown_children = rec(node.list) | 
					
						
							|  |  |  |                 if shown_children: | 
					
						
							|  |  |  |                     res.append(node) | 
					
						
							|  |  |  |                     if not node.is_menuconfig: | 
					
						
							|  |  |  |                         res += shown_children | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             node = node.next | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         return res | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if isinstance(menu.item, Choice): | 
					
						
							|  |  |  |         # For named choices defined in multiple locations, entering the choice | 
					
						
							|  |  |  |         # at a particular menu node would normally only show the choice symbols | 
					
						
							|  |  |  |         # defined there (because that's what the MenuNode tree looks like). | 
					
						
							|  |  |  |         # | 
					
						
							|  |  |  |         # That might look confusing, and makes extending choices by defining | 
					
						
							|  |  |  |         # them in multiple locations less useful. Instead, gather all the child | 
					
						
							|  |  |  |         # menu nodes for all the choices whenever a choice is entered. That | 
					
						
							|  |  |  |         # makes all choice symbols visible at all locations. | 
					
						
							|  |  |  |         # | 
					
						
							|  |  |  |         # Choices can contain non-symbol items (people do all sorts of weird | 
					
						
							|  |  |  |         # stuff with them), hence the generality here. We really need to | 
					
						
							|  |  |  |         # preserve the menu tree at each choice location. | 
					
						
							|  |  |  |         # | 
					
						
							|  |  |  |         # Note: Named choices are pretty broken in the C tools, and this is | 
					
						
							|  |  |  |         # super obscure, so you probably won't find much that relies on this. | 
					
						
							|  |  |  |         # This whole 'if' could be deleted if you don't care about defining | 
					
						
							|  |  |  |         # choices in multiple locations to add symbols (which will still work, | 
					
						
							|  |  |  |         # just with things being displayed in a way that might be unexpected). | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # Do some additional work to avoid listing choice symbols twice if all | 
					
						
							|  |  |  |         # or part of the choice is copied in multiple locations (e.g. by | 
					
						
							|  |  |  |         # including some Kconfig file multiple times). We give the prompts at | 
					
						
							|  |  |  |         # the current location precedence. | 
					
						
							|  |  |  |         seen_syms = {node.item for node in rec(menu.list) | 
					
						
							|  |  |  |                      if isinstance(node.item, Symbol)} | 
					
						
							|  |  |  |         res = [] | 
					
						
							|  |  |  |         for choice_node in menu.item.nodes: | 
					
						
							|  |  |  |             for node in rec(choice_node.list): | 
					
						
							|  |  |  |                 # 'choice_node is menu' checks if we're dealing with the | 
					
						
							|  |  |  |                 # current location | 
					
						
							|  |  |  |                 if node.item not in seen_syms or choice_node is menu: | 
					
						
							|  |  |  |                     res.append(node) | 
					
						
							|  |  |  |                     if isinstance(node.item, Symbol): | 
					
						
							|  |  |  |                         seen_syms.add(node.item) | 
					
						
							|  |  |  |         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 _change_node(node): | 
					
						
							|  |  |  |     # Changes the value of the menu node 'node' if it is a symbol. Bools and | 
					
						
							|  |  |  |     # tristates are toggled, while other symbol types pop up a text entry | 
					
						
							|  |  |  |     # dialog. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Returns False if the value of 'node' can't be changed. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if not _changeable(node): | 
					
						
							|  |  |  |         return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # sc = symbol/choice | 
					
						
							|  |  |  |     sc = node.item | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if sc.orig_type in (INT, HEX, STRING): | 
					
						
							|  |  |  |         s = sc.str_value | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         while True: | 
					
						
							|  |  |  |             s = _input_dialog( | 
					
						
							|  |  |  |                 "{} ({})".format(node.prompt[0], TYPE_TO_STR[sc.orig_type]), | 
					
						
							|  |  |  |                 s, _range_info(sc)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             if s is None: | 
					
						
							|  |  |  |                 break | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             if sc.orig_type in (INT, HEX): | 
					
						
							|  |  |  |                 s = s.strip() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 # 'make menuconfig' does this too. Hex values not starting with | 
					
						
							|  |  |  |                 # '0x' are accepted when loading .config files though. | 
					
						
							|  |  |  |                 if sc.orig_type == HEX and not s.startswith(("0x", "0X")): | 
					
						
							|  |  |  |                     s = "0x" + s | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             if _check_valid(sc, s): | 
					
						
							|  |  |  |                 _set_val(sc, s) | 
					
						
							|  |  |  |                 break | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     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]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # 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)]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _is_y_mode_choice_sym(sc) and not 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() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return True | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _changeable(node): | 
					
						
							|  |  |  |     # Returns True if the value if 'node' 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 _set_sel_node_tri_val(tri_val): | 
					
						
							|  |  |  |     # Sets the value of the currently selected menu entry to 'tri_val', if that | 
					
						
							|  |  |  |     # value can be assigned | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     sc = _shown[_sel_node_i].item | 
					
						
							|  |  |  |     if isinstance(sc, (Symbol, Choice)) and tri_val in sc.assignable: | 
					
						
							|  |  |  |         _set_val(sc, tri_val) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _set_val(sc, val): | 
					
						
							|  |  |  |     # Wrapper around Symbol/Choice.set_value() for updating the menu state and | 
					
						
							|  |  |  |     # _conf_changed | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _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: | 
					
						
							|  |  |  |         sc.set_value(val) | 
					
						
							|  |  |  |         _conf_changed = True | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # Changing the value of the symbol might have changed what items in the | 
					
						
							|  |  |  |         # current menu are visible. Recalculate the state. | 
					
						
							|  |  |  |         _update_menu() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _update_menu(): | 
					
						
							|  |  |  |     # Updates the current menu after the value of a symbol or choice has been | 
					
						
							|  |  |  |     # changed. Changing a value might change which items in the menu are | 
					
						
							|  |  |  |     # visible. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # If possible, preserves the location of the cursor on the screen when | 
					
						
							|  |  |  |     # items are added/removed above the selected item. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _shown | 
					
						
							|  |  |  |     global _sel_node_i | 
					
						
							|  |  |  |     global _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Row on the screen the cursor was on | 
					
						
							|  |  |  |     old_row = _sel_node_i - _menu_scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     sel_node = _shown[_sel_node_i] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # New visible nodes | 
					
						
							|  |  |  |     _shown = _shown_nodes(_cur_menu) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # New index of selected node | 
					
						
							|  |  |  |     _sel_node_i = _shown.index(sel_node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Try to make the cursor stay on the same row in the menu window. This | 
					
						
							|  |  |  |     # might be impossible if too many nodes have disappeared above the node. | 
					
						
							|  |  |  |     _menu_scroll = max(_sel_node_i - old_row, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _input_dialog(title, initial_text, info_text=None): | 
					
						
							|  |  |  |     # Pops up a dialog that prompts the user for a string | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # title: | 
					
						
							|  |  |  |     #   Title to display at the top of the dialog window's border | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # initial_text: | 
					
						
							|  |  |  |     #   Initial text to prefill the input field with | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # info_text: | 
					
						
							|  |  |  |     #   String to show next to the input field. If None, just the input field | 
					
						
							|  |  |  |     #   is shown. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win = _styled_win("body") | 
					
						
							|  |  |  |     win.keypad(True) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     info_lines = info_text.split("\n") if info_text else [] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Give the input dialog its initial size | 
					
						
							|  |  |  |     _resize_input_dialog(win, title, info_lines) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _safe_curs_set(2) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Input field text | 
					
						
							|  |  |  |     s = initial_text | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Cursor position | 
					
						
							|  |  |  |     i = len(initial_text) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     def edit_width(): | 
					
						
							|  |  |  |         return _width(win) - 4 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Horizontal scroll offset | 
					
						
							|  |  |  |     hscroll = max(i - edit_width() + 1, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         # Draw the "main" display with the menu, etc., so that resizing still | 
					
						
							|  |  |  |         # works properly. This is like a stack of windows, only hardcoded for | 
					
						
							|  |  |  |         # now. | 
					
						
							|  |  |  |         _draw_main() | 
					
						
							|  |  |  |         _draw_input_dialog(win, title, info_lines, s, i, hscroll) | 
					
						
							|  |  |  |         curses.doupdate() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         c = _getch_compat(win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if c == curses.KEY_RESIZE: | 
					
						
							|  |  |  |             # Resize the main display too. The dialog floats above it. | 
					
						
							|  |  |  |             _resize_main() | 
					
						
							|  |  |  |             _resize_input_dialog(win, title, info_lines) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "\n": | 
					
						
							|  |  |  |             _safe_curs_set(0) | 
					
						
							|  |  |  |             return s | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "\x1B":  # \x1B = ESC | 
					
						
							|  |  |  |             _safe_curs_set(0) | 
					
						
							|  |  |  |             return None | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             s, i, hscroll = _edit_text(c, s, i, hscroll, edit_width()) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _resize_input_dialog(win, title, info_lines): | 
					
						
							|  |  |  |     # Resizes the input dialog to a size appropriate for the terminal size | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     screen_height, screen_width = _stdscr.getmaxyx() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win_height = 5 | 
					
						
							|  |  |  |     if info_lines: | 
					
						
							|  |  |  |         win_height += len(info_lines) + 1 | 
					
						
							|  |  |  |     win_height = min(win_height, screen_height) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win_width = max(_INPUT_DIALOG_MIN_WIDTH, | 
					
						
							|  |  |  |                     len(title) + 4, | 
					
						
							|  |  |  |                     *(len(line) + 4 for line in info_lines)) | 
					
						
							|  |  |  |     win_width = min(win_width, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.resize(win_height, win_width) | 
					
						
							|  |  |  |     win.mvwin((screen_height - win_height)//2, | 
					
						
							|  |  |  |               (screen_width - win_width)//2) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _draw_input_dialog(win, title, info_lines, s, i, hscroll): | 
					
						
							|  |  |  |     edit_width = _width(win) - 4 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Note: Perhaps having a separate window for the input field would be nicer | 
					
						
							|  |  |  |     visible_s = s[hscroll:hscroll + edit_width] | 
					
						
							|  |  |  |     _safe_addstr(win, 2, 2, visible_s + " "*(edit_width - len(visible_s)), | 
					
						
							|  |  |  |                  _style["edit"]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     for linenr, line in enumerate(info_lines): | 
					
						
							|  |  |  |         _safe_addstr(win, 4 + linenr, 2, line) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw the frame last so that it overwrites the body text for small windows | 
					
						
							|  |  |  |     _draw_frame(win, title) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _safe_move(win, 2, 2 + i - hscroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _load_dialog(): | 
					
						
							|  |  |  |     # Dialog for loading a new configuration | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     global _conf_changed | 
					
						
							|  |  |  |     global _conf_filename | 
					
						
							|  |  |  |     global _show_all | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _conf_changed: | 
					
						
							|  |  |  |         c = _key_dialog( | 
					
						
							|  |  |  |             "Load", | 
					
						
							|  |  |  |             "You have unsaved changes. Load new\n" | 
					
						
							|  |  |  |             "configuration anyway?\n" | 
					
						
							|  |  |  |             "\n" | 
					
						
							|  |  |  |             "         (O)K  (C)ancel", | 
					
						
							|  |  |  |             "oc") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if c is None or c == "c": | 
					
						
							|  |  |  |             return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     filename = _conf_filename | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         filename = _input_dialog("File to load", filename, _load_save_info()) | 
					
						
							|  |  |  |         if filename is None: | 
					
						
							|  |  |  |             return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         filename = os.path.expanduser(filename) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if _try_load(filename): | 
					
						
							|  |  |  |             _conf_filename = filename | 
					
						
							|  |  |  |             _conf_changed = _needs_save() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             # Turn on show-all mode if the selected node is not visible after | 
					
						
							|  |  |  |             # loading the new configuration. _shown still holds the old state. | 
					
						
							|  |  |  |             if _shown[_sel_node_i] not in _shown_nodes(_cur_menu): | 
					
						
							|  |  |  |                 _show_all = True | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             _update_menu() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             # The message dialog indirectly updates the menu display, so _msg() | 
					
						
							|  |  |  |             # must be called after the new state has been initialized | 
					
						
							|  |  |  |             _msg("Success", "Loaded " + filename) | 
					
						
							|  |  |  |             return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _try_load(filename): | 
					
						
							|  |  |  |     # Tries to load a configuration file. Pops up an error and returns False on | 
					
						
							|  |  |  |     # failure. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # filename: | 
					
						
							|  |  |  |     #   Configuration file to load | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         _kconf.load_config(filename) | 
					
						
							|  |  |  |         return True | 
					
						
							|  |  |  |     except EnvironmentError as e: | 
					
						
							|  |  |  |         _error("Error loading '{}'\n\n{} (errno: {})" | 
					
						
							|  |  |  |                .format(filename, e.strerror, errno.errorcode[e.errno])) | 
					
						
							|  |  |  |         return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _save_dialog(save_fn, default_filename, description): | 
					
						
							|  |  |  |     # Dialog for saving the current configuration | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # save_fn: | 
					
						
							|  |  |  |     #   Function to call with 'filename' to save the file | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # default_filename: | 
					
						
							|  |  |  |     #   Prefilled filename in the input field | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # description: | 
					
						
							|  |  |  |     #   String describing the thing being saved | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Return value: | 
					
						
							|  |  |  |     #   The path to the saved file, or None if no file was saved | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     filename = default_filename | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         filename = _input_dialog("Filename to save {} to".format(description), | 
					
						
							|  |  |  |                                  filename, _load_save_info()) | 
					
						
							|  |  |  |         if filename is None: | 
					
						
							|  |  |  |             return None | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         filename = os.path.expanduser(filename) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         msg = _try_save(save_fn, filename, description) | 
					
						
							|  |  |  |         if msg: | 
					
						
							|  |  |  |             _msg("Success", msg) | 
					
						
							|  |  |  |             return filename | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _try_save(save_fn, filename, description): | 
					
						
							|  |  |  |     # Tries to save a configuration file. Returns a message to print on | 
					
						
							|  |  |  |     # success. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # save_fn: | 
					
						
							|  |  |  |     #   Function to call with 'filename' to save the file | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # description: | 
					
						
							|  |  |  |     #   String describing the thing being saved | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Return value: | 
					
						
							|  |  |  |     #   A message to print on success, and None on failure | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         # save_fn() returns a message to print | 
					
						
							|  |  |  |         return save_fn(filename) | 
					
						
							|  |  |  |     except EnvironmentError as e: | 
					
						
							|  |  |  |         _error("Error saving {} to '{}'\n\n{} (errno: {})" | 
					
						
							|  |  |  |                .format(description, e.filename, e.strerror, | 
					
						
							|  |  |  |                        errno.errorcode[e.errno])) | 
					
						
							|  |  |  |         return None | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _key_dialog(title, text, keys): | 
					
						
							|  |  |  |     # Pops up a dialog that can be closed by pressing a key | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # title: | 
					
						
							|  |  |  |     #   Title to display at the top of the dialog window's border | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # text: | 
					
						
							|  |  |  |     #   Text to show in the dialog | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # keys: | 
					
						
							|  |  |  |     #   List of keys that will close the dialog. Other keys (besides ESC) are | 
					
						
							|  |  |  |     #   ignored. The caller is responsible for providing a hint about which | 
					
						
							|  |  |  |     #   keys can be pressed in 'text'. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Return value: | 
					
						
							|  |  |  |     #   The key that was pressed to close the dialog. Uppercase characters are | 
					
						
							|  |  |  |     #   converted to lowercase. ESC will always close the dialog, and returns | 
					
						
							|  |  |  |     #   None. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win = _styled_win("body") | 
					
						
							|  |  |  |     win.keypad(True) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _resize_key_dialog(win, text) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         # See _input_dialog() | 
					
						
							|  |  |  |         _draw_main() | 
					
						
							|  |  |  |         _draw_key_dialog(win, title, text) | 
					
						
							|  |  |  |         curses.doupdate() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         c = _getch_compat(win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if c == curses.KEY_RESIZE: | 
					
						
							|  |  |  |             # Resize the main display too. The dialog floats above it. | 
					
						
							|  |  |  |             _resize_main() | 
					
						
							|  |  |  |             _resize_key_dialog(win, text) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "\x1B":  # \x1B = ESC | 
					
						
							|  |  |  |             return None | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif isinstance(c, str): | 
					
						
							|  |  |  |             c = c.lower() | 
					
						
							|  |  |  |             if c in keys: | 
					
						
							|  |  |  |                 return c | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _resize_key_dialog(win, text): | 
					
						
							|  |  |  |     # Resizes the key dialog to a size appropriate for the terminal size | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     screen_height, screen_width = _stdscr.getmaxyx() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     lines = text.split("\n") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win_height = min(len(lines) + 4, screen_height) | 
					
						
							|  |  |  |     win_width = min(max(len(line) for line in lines) + 4, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.resize(win_height, win_width) | 
					
						
							|  |  |  |     win.mvwin((screen_height - win_height)//2, | 
					
						
							|  |  |  |               (screen_width - win_width)//2) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _draw_key_dialog(win, title, text): | 
					
						
							|  |  |  |     win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     for i, line in enumerate(text.split("\n")): | 
					
						
							|  |  |  |         _safe_addstr(win, 2 + i, 2, line) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw the frame last so that it overwrites the body text for small windows | 
					
						
							|  |  |  |     _draw_frame(win, title) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _draw_frame(win, title): | 
					
						
							|  |  |  |     # Draw a frame around the inner edges of 'win', with 'title' at the top | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win_height, win_width = win.getmaxyx() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.attron(_style["frame"]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw top/bottom edge | 
					
						
							|  |  |  |     _safe_hline(win,              0, 0, " ", win_width) | 
					
						
							|  |  |  |     _safe_hline(win, win_height - 1, 0, " ", win_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw left/right edge | 
					
						
							|  |  |  |     _safe_vline(win, 0,             0, " ", win_height) | 
					
						
							|  |  |  |     _safe_vline(win, 0, win_width - 1, " ", win_height) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw title | 
					
						
							|  |  |  |     _safe_addstr(win, 0, max((win_width - len(title))//2, 0), title) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.attroff(_style["frame"]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _jump_to_dialog(): | 
					
						
							|  |  |  |     # Implements the jump-to dialog, where symbols can be looked up via | 
					
						
							|  |  |  |     # incremental search and jumped to. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Returns True if the user jumped to a symbol, and False if the dialog was | 
					
						
							|  |  |  |     # canceled. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     s = ""  # Search text | 
					
						
							|  |  |  |     prev_s = None  # Previous search text | 
					
						
							|  |  |  |     s_i = 0  # Search text cursor position | 
					
						
							|  |  |  |     hscroll = 0  # Horizontal scroll offset | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     sel_node_i = 0  # Index of selected row | 
					
						
							|  |  |  |     scroll = 0  # Index in 'matches' of the top row of the list | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Edit box at the top | 
					
						
							|  |  |  |     edit_box = _styled_win("jump-edit") | 
					
						
							|  |  |  |     edit_box.keypad(True) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # List of matches | 
					
						
							|  |  |  |     matches_win = _styled_win("list") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Bottom separator, with arrows pointing down | 
					
						
							|  |  |  |     bot_sep_win = _styled_win("separator") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Help window with instructions at the bottom | 
					
						
							|  |  |  |     help_win = _styled_win("help") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Give windows their initial size | 
					
						
							|  |  |  |     _resize_jump_to_dialog(edit_box, matches_win, bot_sep_win, help_win, | 
					
						
							|  |  |  |                            sel_node_i, scroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _safe_curs_set(2) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Logic duplication with _select_{next,prev}_menu_entry(), except we do a | 
					
						
							|  |  |  |     # functional variant that returns the new (sel_node_i, scroll) values to | 
					
						
							|  |  |  |     # avoid 'nonlocal'. TODO: Can this be factored out in some nice way? | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     def select_next_match(): | 
					
						
							|  |  |  |         if sel_node_i == len(matches) - 1: | 
					
						
							|  |  |  |             return sel_node_i, scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if sel_node_i + 1 >= scroll + _height(matches_win) - _SCROLL_OFFSET \ | 
					
						
							|  |  |  |            and scroll < _max_scroll(matches, matches_win): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             return sel_node_i + 1, scroll + 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         return sel_node_i + 1, scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     def select_prev_match(): | 
					
						
							|  |  |  |         if sel_node_i == 0: | 
					
						
							|  |  |  |             return sel_node_i, scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if sel_node_i - 1 < scroll + _SCROLL_OFFSET: | 
					
						
							|  |  |  |             return sel_node_i - 1, max(scroll - 1, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         return sel_node_i - 1, scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         if s != prev_s: | 
					
						
							|  |  |  |             # The search text changed. Find new matching nodes. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             prev_s = s | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             try: | 
					
						
							|  |  |  |                 # We could use re.IGNORECASE here instead of lower(), but this | 
					
						
							|  |  |  |                 # is noticeably less jerky while inputting regexes like | 
					
						
							|  |  |  |                 # '.*debug$' (though the '.*' is redundant there). Those | 
					
						
							|  |  |  |                 # probably have bad interactions with re.search(), which | 
					
						
							|  |  |  |                 # matches anywhere in the string. | 
					
						
							|  |  |  |                 # | 
					
						
							|  |  |  |                 # It's not horrible either way. Just a bit smoother. | 
					
						
							|  |  |  |                 regex_searches = [re.compile(regex).search | 
					
						
							|  |  |  |                                   for regex in s.lower().split()] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 # No exception thrown, so the regexes are okay | 
					
						
							|  |  |  |                 bad_re = None | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 # List of matching nodes | 
					
						
							|  |  |  |                 matches = [] | 
					
						
							|  |  |  |                 add_match = matches.append | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 # Search symbols and choices | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 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 (sc.name and search(sc.name.lower()) 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 | 
					
						
							|  |  |  |                             break | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                     else: | 
					
						
							|  |  |  |                         add_match(node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 # Search menus and comments | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 for node in _sorted_menu_comment_nodes(): | 
					
						
							|  |  |  |                     for search in regex_searches: | 
					
						
							|  |  |  |                         if not search(node.prompt[0].lower()): | 
					
						
							|  |  |  |                             break | 
					
						
							|  |  |  |                     else: | 
					
						
							|  |  |  |                         add_match(node) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             except re.error as e: | 
					
						
							|  |  |  |                 # Bad regex. Remember the error message so we can show it. | 
					
						
							|  |  |  |                 bad_re = "Bad regular expression" | 
					
						
							|  |  |  |                 # re.error.msg was added in Python 3.5 | 
					
						
							|  |  |  |                 if hasattr(e, "msg"): | 
					
						
							|  |  |  |                     bad_re += ": " + e.msg | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 matches = [] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             # Reset scroll and jump to the top of the list of matches | 
					
						
							|  |  |  |             sel_node_i = scroll = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         _draw_jump_to_dialog(edit_box, matches_win, bot_sep_win, help_win, | 
					
						
							|  |  |  |                              s, s_i, hscroll, | 
					
						
							|  |  |  |                              bad_re, matches, sel_node_i, scroll) | 
					
						
							|  |  |  |         curses.doupdate() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         c = _getch_compat(edit_box) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if c == "\n": | 
					
						
							|  |  |  |             if matches: | 
					
						
							|  |  |  |                 _jump_to(matches[sel_node_i]) | 
					
						
							|  |  |  |                 _safe_curs_set(0) | 
					
						
							|  |  |  |                 return True | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "\x1B":  # \x1B = ESC | 
					
						
							|  |  |  |             _safe_curs_set(0) | 
					
						
							|  |  |  |             return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == curses.KEY_RESIZE: | 
					
						
							|  |  |  |             # We adjust the scroll so that the selected node stays visible in | 
					
						
							|  |  |  |             # the list when the terminal is resized, hence the 'scroll' | 
					
						
							|  |  |  |             # assignment | 
					
						
							|  |  |  |             scroll = _resize_jump_to_dialog( | 
					
						
							|  |  |  |                 edit_box, matches_win, bot_sep_win, help_win, | 
					
						
							|  |  |  |                 sel_node_i, scroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "\x06":  # \x06 = Ctrl-F | 
					
						
							|  |  |  |             if matches: | 
					
						
							|  |  |  |                 _safe_curs_set(0) | 
					
						
							|  |  |  |                 _info_dialog(matches[sel_node_i], True) | 
					
						
							|  |  |  |                 _safe_curs_set(2) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 scroll = _resize_jump_to_dialog( | 
					
						
							|  |  |  |                     edit_box, matches_win, bot_sep_win, help_win, | 
					
						
							|  |  |  |                     sel_node_i, scroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == curses.KEY_DOWN: | 
					
						
							|  |  |  |             sel_node_i, scroll = select_next_match() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == curses.KEY_UP: | 
					
						
							|  |  |  |             sel_node_i, scroll = select_prev_match() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         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): | 
					
						
							|  |  |  |                 sel_node_i, scroll = select_next_match() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # Page Up (no Ctrl-U, as it's already used by the edit box) | 
					
						
							|  |  |  |         elif c == curses.KEY_PPAGE: | 
					
						
							|  |  |  |             for _ in range(_PG_JUMP): | 
					
						
							|  |  |  |                 sel_node_i, scroll = select_prev_match() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == curses.KEY_END: | 
					
						
							|  |  |  |             sel_node_i = len(matches) - 1 | 
					
						
							|  |  |  |             scroll = _max_scroll(matches, matches_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == curses.KEY_HOME: | 
					
						
							|  |  |  |             sel_node_i = scroll = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             s, s_i, hscroll = _edit_text(c, s, s_i, hscroll, | 
					
						
							|  |  |  |                                          _width(edit_box) - 2) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # 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: sym.name): | 
					
						
							|  |  |  |             # += is in-place for lists | 
					
						
							|  |  |  |             cached_nodes += sym.nodes | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # Add choice nodes | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         choices = sorted(_kconf.unique_choices, | 
					
						
							|  |  |  |                          key=lambda choice: choice.name 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 _resize_jump_to_dialog(edit_box, matches_win, bot_sep_win, help_win, | 
					
						
							|  |  |  |                            sel_node_i, scroll): | 
					
						
							|  |  |  |     # Resizes the jump-to dialog to fill the terminal. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Returns the new scroll index. We adjust the scroll if needed so that the | 
					
						
							|  |  |  |     # selected node stays visible. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     screen_height, screen_width = _stdscr.getmaxyx() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     bot_sep_win.resize(1, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     help_win_height = len(_JUMP_TO_HELP_LINES) | 
					
						
							|  |  |  |     matches_win_height = screen_height - help_win_height - 4 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if matches_win_height >= 1: | 
					
						
							|  |  |  |         edit_box.resize(3, screen_width) | 
					
						
							|  |  |  |         matches_win.resize(matches_win_height, screen_width) | 
					
						
							|  |  |  |         help_win.resize(help_win_height, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         matches_win.mvwin(3, 0) | 
					
						
							|  |  |  |         bot_sep_win.mvwin(3 + matches_win_height, 0) | 
					
						
							|  |  |  |         help_win.mvwin(3 + matches_win_height + 1, 0) | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # Degenerate case. Give up on nice rendering and just prevent errors. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         matches_win_height = 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         edit_box.resize(screen_height, screen_width) | 
					
						
							|  |  |  |         matches_win.resize(1, screen_width) | 
					
						
							|  |  |  |         help_win.resize(1, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         for win in matches_win, bot_sep_win, help_win: | 
					
						
							|  |  |  |             win.mvwin(0, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Adjust the scroll so that the selected row is still within the window, if | 
					
						
							|  |  |  |     # needed | 
					
						
							|  |  |  |     if sel_node_i - scroll >= matches_win_height: | 
					
						
							|  |  |  |         return sel_node_i - matches_win_height + 1 | 
					
						
							|  |  |  |     return scroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _draw_jump_to_dialog(edit_box, matches_win, bot_sep_win, help_win, | 
					
						
							|  |  |  |                          s, s_i, hscroll, | 
					
						
							|  |  |  |                          bad_re, matches, sel_node_i, scroll): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     edit_width = _width(edit_box) - 2 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update list of matches | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     matches_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if matches: | 
					
						
							|  |  |  |         for i in range(scroll, | 
					
						
							|  |  |  |                        min(scroll + _height(matches_win), len(matches))): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             node = matches[i] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             if isinstance(node.item, (Symbol, Choice)): | 
					
						
							|  |  |  |                 node_str = _name_and_val_str(node.item) | 
					
						
							|  |  |  |                 if node.prompt: | 
					
						
							|  |  |  |                     node_str += ' "{}"'.format(node.prompt[0]) | 
					
						
							|  |  |  |             elif node.item == MENU: | 
					
						
							|  |  |  |                 node_str = 'menu "{}"'.format(node.prompt[0]) | 
					
						
							|  |  |  |             else:  # node.item == COMMENT | 
					
						
							|  |  |  |                 node_str = 'comment "{}"'.format(node.prompt[0]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             _safe_addstr(matches_win, i - scroll, 0, node_str, | 
					
						
							|  |  |  |                          _style["selection" if i == sel_node_i else "list"]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # bad_re holds the error message from the re.error exception on errors | 
					
						
							|  |  |  |         _safe_addstr(matches_win, 0, 0, bad_re or "No matches") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     matches_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update bottom separator line | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     bot_sep_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw arrows pointing down if the symbol list is scrolled up | 
					
						
							|  |  |  |     if scroll < _max_scroll(matches, matches_win): | 
					
						
							|  |  |  |         _safe_hline(bot_sep_win, 0, 4, curses.ACS_DARROW, _N_SCROLL_ARROWS) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     bot_sep_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update help window at bottom | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     help_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     for i, line in enumerate(_JUMP_TO_HELP_LINES): | 
					
						
							|  |  |  |         _safe_addstr(help_win, i, 0, line) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     help_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update edit box. We do this last since it makes it handy to position the | 
					
						
							|  |  |  |     # cursor. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     edit_box.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _draw_frame(edit_box, "Jump to symbol/choice/menu/comment") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw arrows pointing up if the symbol list is scrolled down | 
					
						
							|  |  |  |     if scroll > 0: | 
					
						
							|  |  |  |         # TODO: Bit ugly that _style["frame"] is repeated here | 
					
						
							|  |  |  |         _safe_hline(edit_box, 2, 4, curses.ACS_UARROW, _N_SCROLL_ARROWS, | 
					
						
							|  |  |  |                     _style["frame"]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     visible_s = s[hscroll:hscroll + edit_width] | 
					
						
							|  |  |  |     _safe_addstr(edit_box, 1, 1, visible_s) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _safe_move(edit_box, 1, 1 + s_i - hscroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     edit_box.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _info_dialog(node, from_jump_to_dialog): | 
					
						
							|  |  |  |     # Shows a fullscreen window with information about 'node'. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # If 'from_jump_to_dialog' is True, the information dialog was opened from | 
					
						
							|  |  |  |     # within the jump-to-dialog. In this case, we make '/' from within the | 
					
						
							|  |  |  |     # information dialog just return, to avoid a confusing recursive invocation | 
					
						
							|  |  |  |     # of the jump-to-dialog. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Top row, with title and arrows point up | 
					
						
							|  |  |  |     top_line_win = _styled_win("separator") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Text display | 
					
						
							|  |  |  |     text_win = _styled_win("text") | 
					
						
							|  |  |  |     text_win.keypad(True) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Bottom separator, with arrows pointing down | 
					
						
							|  |  |  |     bot_sep_win = _styled_win("separator") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Help window with keys at the bottom | 
					
						
							|  |  |  |     help_win = _styled_win("help") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Give windows their initial size | 
					
						
							|  |  |  |     _resize_info_dialog(top_line_win, text_win, bot_sep_win, help_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Get lines of help text | 
					
						
							|  |  |  |     lines = _info_str(node).split("\n") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Index of first row in 'lines' to show | 
					
						
							|  |  |  |     scroll = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     while True: | 
					
						
							|  |  |  |         _draw_info_dialog(node, lines, scroll, top_line_win, text_win, | 
					
						
							|  |  |  |                           bot_sep_win, help_win) | 
					
						
							|  |  |  |         curses.doupdate() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         c = _getch_compat(text_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if c == curses.KEY_RESIZE: | 
					
						
							|  |  |  |             _resize_info_dialog(top_line_win, text_win, bot_sep_win, help_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_DOWN, "j", "J"): | 
					
						
							|  |  |  |             if scroll < _max_scroll(lines, text_win): | 
					
						
							|  |  |  |                 scroll += 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_NPAGE, "\x04"):  # Page Down/Ctrl-D | 
					
						
							|  |  |  |             scroll = min(scroll + _PG_JUMP, _max_scroll(lines, text_win)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_PPAGE, "\x15"):  # Page Up/Ctrl-U | 
					
						
							|  |  |  |             scroll = max(scroll - _PG_JUMP, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_END, "G"): | 
					
						
							|  |  |  |             scroll = _max_scroll(lines, text_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_HOME, "g"): | 
					
						
							|  |  |  |             scroll = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_UP, "k", "K"): | 
					
						
							|  |  |  |             if scroll > 0: | 
					
						
							|  |  |  |                 scroll -= 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c == "/": | 
					
						
							|  |  |  |             # Support starting a search from within the information dialog | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             if from_jump_to_dialog: | 
					
						
							|  |  |  |                 return  # Avoid recursion | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             if _jump_to_dialog(): | 
					
						
							|  |  |  |                 return  # Jumped to a symbol. Cancel the information dialog. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             # Stay in the information dialog if the jump-to dialog was | 
					
						
							|  |  |  |             # canceled. Resize it in case the terminal was resized while the | 
					
						
							|  |  |  |             # fullscreen jump-to dialog was open. | 
					
						
							|  |  |  |             _resize_info_dialog(top_line_win, text_win, bot_sep_win, help_win) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         elif c in (curses.KEY_LEFT, curses.KEY_BACKSPACE, _ERASE_CHAR, | 
					
						
							|  |  |  |                    "\x1B",  # \x1B = ESC | 
					
						
							|  |  |  |                    "q", "Q", "h", "H"): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _resize_info_dialog(top_line_win, text_win, bot_sep_win, help_win): | 
					
						
							|  |  |  |     # Resizes the info dialog to fill the terminal | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     screen_height, screen_width = _stdscr.getmaxyx() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     top_line_win.resize(1, screen_width) | 
					
						
							|  |  |  |     bot_sep_win.resize(1, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     help_win_height = len(_INFO_HELP_LINES) | 
					
						
							|  |  |  |     text_win_height = screen_height - help_win_height - 2 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if text_win_height >= 1: | 
					
						
							|  |  |  |         text_win.resize(text_win_height, screen_width) | 
					
						
							|  |  |  |         help_win.resize(help_win_height, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         text_win.mvwin(1, 0) | 
					
						
							|  |  |  |         bot_sep_win.mvwin(1 + text_win_height, 0) | 
					
						
							|  |  |  |         help_win.mvwin(1 + text_win_height + 1, 0) | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         # Degenerate case. Give up on nice rendering and just prevent errors. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         text_win.resize(1, screen_width) | 
					
						
							|  |  |  |         help_win.resize(1, screen_width) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         for win in text_win, bot_sep_win, help_win: | 
					
						
							|  |  |  |             win.mvwin(0, 0) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _draw_info_dialog(node, lines, scroll, top_line_win, text_win, | 
					
						
							|  |  |  |                       bot_sep_win, help_win): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     text_win_height, text_win_width = text_win.getmaxyx() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Note: The top row is deliberately updated last. See _draw_main(). | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update text display | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     text_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     for i, line in enumerate(lines[scroll:scroll + text_win_height]): | 
					
						
							|  |  |  |         _safe_addstr(text_win, i, 0, line) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     text_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update bottom separator line | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     bot_sep_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw arrows pointing down if the symbol window is scrolled up | 
					
						
							|  |  |  |     if scroll < _max_scroll(lines, text_win): | 
					
						
							|  |  |  |         _safe_hline(bot_sep_win, 0, 4, curses.ACS_DARROW, _N_SCROLL_ARROWS) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     bot_sep_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update help window at bottom | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     help_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     for i, line in enumerate(_INFO_HELP_LINES): | 
					
						
							|  |  |  |         _safe_addstr(help_win, i, 0, line) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     help_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Update top row | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     top_line_win.erase() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Draw arrows pointing up if the information window is scrolled down. Draw | 
					
						
							|  |  |  |     # them before drawing the title, so the title ends up on top for small | 
					
						
							|  |  |  |     # windows. | 
					
						
							|  |  |  |     if scroll > 0: | 
					
						
							|  |  |  |         _safe_hline(top_line_win, 0, 4, curses.ACS_UARROW, _N_SCROLL_ARROWS) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     title = ("Symbol" if isinstance(node.item, Symbol) else | 
					
						
							|  |  |  |              "Choice" if isinstance(node.item, Choice) else | 
					
						
							|  |  |  |              "Menu"   if node.item == MENU else | 
					
						
							|  |  |  |              "Comment") + " information" | 
					
						
							|  |  |  |     _safe_addstr(top_line_win, 0, max((text_win_width - len(title))//2, 0), | 
					
						
							|  |  |  |                  title) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     top_line_win.noutrefresh() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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) + | 
					
						
							|  |  |  |             _prompt_info(sym) + | 
					
						
							|  |  |  |             "Type: {}\n".format(TYPE_TO_STR[sym.type]) + | 
					
						
							|  |  |  |             _value_info(sym) + | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |             _help_info(sym) | 
					
						
							|  |  |  |             #_direct_dep_info(sym) + | 
					
						
							|  |  |  |             #_defaults_info(sym) + | 
					
						
							|  |  |  |             #_select_imply_info(sym) + | 
					
						
							|  |  |  |             #_kconfig_def_info(sym) | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |         ) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if isinstance(node.item, Choice): | 
					
						
							|  |  |  |         choice = node.item | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         return ( | 
					
						
							|  |  |  |             _name_info(choice) + | 
					
						
							|  |  |  |             _prompt_info(choice) + | 
					
						
							|  |  |  |             "Type: {}\n".format(TYPE_TO_STR[choice.type]) + | 
					
						
							|  |  |  |             'Mode: {}\n'.format(choice.str_value) + | 
					
						
							|  |  |  |             _help_info(choice) + | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |             _choice_syms_info(choice) | 
					
						
							|  |  |  |             #_direct_dep_info(choice) + | 
					
						
							|  |  |  |             #_defaults_info(choice) + | 
					
						
							|  |  |  |             #_kconfig_def_info(choice) | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |         ) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return _kconfig_def_info(node)  # node.item in (MENU, COMMENT) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _name_info(sc): | 
					
						
							|  |  |  |     # Returns a string with the name of the symbol/choice. Names are optional | 
					
						
							|  |  |  |     # for choices. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return "Name: {}\n".format(sc.name) if sc.name else "" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _prompt_info(sc): | 
					
						
							|  |  |  |     # Returns a string listing the prompts of 'sc' (Symbol or Choice) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     s = "" | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |     found = [] | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  | 
 | 
					
						
							|  |  |  |     for node in sc.nodes: | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |         if node.prompt and node.prompt[0] not in found: | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |             s += "Prompt: {}\n".format(node.prompt[0]) | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |             found.append(node.prompt[0]) | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  | 
 | 
					
						
							|  |  |  |     return s | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _value_info(sym): | 
					
						
							|  |  |  |     # Returns a string showing 'sym's value | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Only put quotes around the value for string symbols | 
					
						
							|  |  |  |     return "Value: {}\n".format( | 
					
						
							|  |  |  |         '"{}"'.format(sym.str_value) | 
					
						
							|  |  |  |         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 += "  - " + sym.name | 
					
						
							|  |  |  |         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 = "\n" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     for node in sc.nodes: | 
					
						
							|  |  |  |         if node.help is not None: | 
					
						
							|  |  |  |             s += "Help:\n\n{}\n\n".format(_indent(node.help, 2)) | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-19 11:32:58 -05:00
										 |  |  |     if s == "\n": | 
					
						
							|  |  |  |         s = "\nHelp: (No help available)\n\n" | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-11-18 20:26:58 -05:00
										 |  |  |     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' \ | 
					
						
							|  |  |  |         .format(TRI_TO_STR[expr_value(sc.direct_dep)], | 
					
						
							|  |  |  |                 _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)]) | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             # Don't print the value next to the symbol name for choice | 
					
						
							|  |  |  |             # defaults, as it looks a bit confusing | 
					
						
							|  |  |  |             s += val.name | 
					
						
							|  |  |  |         s += "\n" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         if cond is not _kconf.y: | 
					
						
							|  |  |  |             s += "    Condition (={}):\n{}" \ | 
					
						
							|  |  |  |                  .format(TRI_TO_STR[expr_value(cond)], | 
					
						
							|  |  |  |                          _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 = "&&" | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         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, | 
					
						
							|  |  |  |                               _expr_str(term)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         # 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, | 
					
						
							|  |  |  |                      _include_path_info(node), | 
					
						
							|  |  |  |                      _menu_path_info(node), | 
					
						
							|  |  |  |                      _indent(node.custom_str(_name_and_val_str), 2)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     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 _indent(s, n): | 
					
						
							|  |  |  |     # Returns 's' with each line indented 'n' spaces. textwrap.indent() is not | 
					
						
							|  |  |  |     # available in Python 2 (it's 3.3+). | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return "\n".join(n*" " + line for line in s.split("\n")) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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(sc.name): | 
					
						
							|  |  |  |         if not sc.nodes: | 
					
						
							|  |  |  |             # Undefined symbol reference | 
					
						
							|  |  |  |             return "{}(undefined/n)".format(sc.name) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         return '{}(={})'.format(sc.name, 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 _styled_win(style): | 
					
						
							|  |  |  |     # Returns a new curses window with style 'style' and space as the fill | 
					
						
							|  |  |  |     # character. The initial dimensions are (1, 1), so the window needs to be | 
					
						
							|  |  |  |     # sized and positioned separately. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win = curses.newwin(1, 1) | 
					
						
							|  |  |  |     _set_style(win, style) | 
					
						
							|  |  |  |     return win | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _set_style(win, style): | 
					
						
							|  |  |  |     # Changes the style of an existing window | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     win.bkgdset(" ", _style[style]) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _max_scroll(lst, win): | 
					
						
							|  |  |  |     # Assuming 'lst' is a list of items to be displayed in 'win', | 
					
						
							|  |  |  |     # returns the maximum number of steps 'win' can be scrolled down. | 
					
						
							|  |  |  |     # We stop scrolling when the bottom item is visible. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return max(0, len(lst) - _height(win)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _edit_text(c, s, i, hscroll, width): | 
					
						
							|  |  |  |     # Implements text editing commands for edit boxes. Takes a character (which | 
					
						
							|  |  |  |     # could also be e.g. curses.KEY_LEFT) and the edit box state, and returns | 
					
						
							|  |  |  |     # the new state after the character has been processed. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # c: | 
					
						
							|  |  |  |     #   Character from user | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # s: | 
					
						
							|  |  |  |     #   Current contents of string | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # i: | 
					
						
							|  |  |  |     #   Current cursor index in string | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # hscroll: | 
					
						
							|  |  |  |     #   Index in s of the leftmost character in the edit box, for horizontal | 
					
						
							|  |  |  |     #   scrolling | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # width: | 
					
						
							|  |  |  |     #   Width in characters of the edit box | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Return value: | 
					
						
							|  |  |  |     #   An (s, i, hscroll) tuple for the new state | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if c == curses.KEY_LEFT: | 
					
						
							|  |  |  |         if i > 0: | 
					
						
							|  |  |  |             i -= 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c == curses.KEY_RIGHT: | 
					
						
							|  |  |  |         if i < len(s): | 
					
						
							|  |  |  |             i += 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c in (curses.KEY_HOME, "\x01"):  # \x01 = CTRL-A | 
					
						
							|  |  |  |         i = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c in (curses.KEY_END, "\x05"):  # \x05 = CTRL-E | 
					
						
							|  |  |  |         i = len(s) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c in (curses.KEY_BACKSPACE, _ERASE_CHAR): | 
					
						
							|  |  |  |         if i > 0: | 
					
						
							|  |  |  |             s = s[:i-1] + s[i:] | 
					
						
							|  |  |  |             i -= 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c == curses.KEY_DC: | 
					
						
							|  |  |  |         s = s[:i] + s[i+1:] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c == "\x17":  # \x17 = CTRL-W | 
					
						
							|  |  |  |         # The \W removes characters like ',' one at a time | 
					
						
							|  |  |  |         new_i = re.search(r"(?:\w*|\W)\s*$", s[:i]).start() | 
					
						
							|  |  |  |         s = s[:new_i] + s[i:] | 
					
						
							|  |  |  |         i = new_i | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c == "\x0B":  # \x0B = CTRL-K | 
					
						
							|  |  |  |         s = s[:i] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif c == "\x15":  # \x15 = CTRL-U | 
					
						
							|  |  |  |         s = s[i:] | 
					
						
							|  |  |  |         i = 0 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     elif isinstance(c, str): | 
					
						
							|  |  |  |         # Insert character | 
					
						
							|  |  |  |         s = s[:i] + c + s[i:] | 
					
						
							|  |  |  |         i += 1 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Adjust the horizontal scroll so that the cursor never touches the left or | 
					
						
							|  |  |  |     # right edges of the edit box, except when it's at the beginning or the end | 
					
						
							|  |  |  |     # of the string | 
					
						
							|  |  |  |     if i < hscroll + _SCROLL_OFFSET: | 
					
						
							|  |  |  |         hscroll = max(i - _SCROLL_OFFSET, 0) | 
					
						
							|  |  |  |     elif i >= hscroll + width - _SCROLL_OFFSET: | 
					
						
							|  |  |  |         max_scroll = max(len(s) - width + 1, 0) | 
					
						
							|  |  |  |         hscroll = min(i - width + _SCROLL_OFFSET + 1, max_scroll) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return s, i, hscroll | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _load_save_info(): | 
					
						
							|  |  |  |     # Returns an information string for load/save dialog boxes | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return "(Relative to {})\n\nRefer to your home directory with ~" \ | 
					
						
							|  |  |  |            .format(os.path.join(os.getcwd(), "")) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _msg(title, text): | 
					
						
							|  |  |  |     # Pops up a message dialog that can be dismissed with Space/Enter/ESC | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _key_dialog(title, text, " \n") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _error(text): | 
					
						
							|  |  |  |     # Pops up an error dialog that can be dismissed with Space/Enter/ESC | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     _msg("Error", text) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _node_str(node): | 
					
						
							|  |  |  |     # Returns the complete menu entry text for a menu node. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Example return value: "[*] Support for X" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Calculate the indent to print the item with by checking how many levels | 
					
						
							|  |  |  |     # above it the closest 'menuconfig' item is (this includes menus and | 
					
						
							|  |  |  |     # choices as well as menuconfig symbols) | 
					
						
							|  |  |  |     indent = 0 | 
					
						
							|  |  |  |     parent = node.parent | 
					
						
							|  |  |  |     while not parent.is_menuconfig: | 
					
						
							|  |  |  |         indent += _SUBMENU_INDENT | 
					
						
							|  |  |  |         parent = parent.parent | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # This approach gives nice alignment for empty string symbols ("()  Foo") | 
					
						
							|  |  |  |     s = "{:{}}".format(_value_str(node), 3 + indent) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _should_show_name(node): | 
					
						
							|  |  |  |         if isinstance(node.item, Symbol): | 
					
						
							|  |  |  |             s += " <{}>".format(node.item.name) | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             # For choices, use standard_sc_expr_str(). That way they show up as | 
					
						
							|  |  |  |             # '<choice (name if any)>'. | 
					
						
							|  |  |  |             s += " " + standard_sc_expr_str(node.item) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if node.prompt: | 
					
						
							|  |  |  |         if node.item == COMMENT: | 
					
						
							|  |  |  |             s += " *** {} ***".format(node.prompt[0]) | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             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.orig_type and \ | 
					
						
							|  |  |  |                not (sym.choice and sym.choice.tri_value == 2): | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |                 s += " (NEW)" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if 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]) | 
					
						
							|  |  |  |                     break | 
					
						
							|  |  |  |             else: | 
					
						
							|  |  |  |                 # 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]) | 
					
						
							|  |  |  |                         break | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # 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 node.is_menuconfig: | 
					
						
							|  |  |  |         s += "  --->" if _shown_nodes(node) else "  ----" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return s | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _should_show_name(node): | 
					
						
							|  |  |  |     # Returns True if 'node' is a symbol or choice whose name should shown (if | 
					
						
							|  |  |  |     # any, as names are optional for choices) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # The 'not node.prompt' case only hits in show-all mode, for promptless | 
					
						
							|  |  |  |     # symbols and choices | 
					
						
							|  |  |  |     return not node.prompt or \ | 
					
						
							|  |  |  |            (_show_name and isinstance(node.item, (Symbol, Choice))) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _value_str(node): | 
					
						
							|  |  |  |     # Returns the value part ("[*]", "<M>", "(foo)" etc.) of a menu node | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     item = node.item | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if item in (MENU, COMMENT): | 
					
						
							|  |  |  |         return "" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Wouldn't normally happen, and generates a warning | 
					
						
							|  |  |  |     if not item.orig_type: | 
					
						
							|  |  |  |         return "" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if item.orig_type in (STRING, INT, HEX): | 
					
						
							|  |  |  |         return "({})".format(item.str_value) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # BOOL or TRISTATE | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _is_y_mode_choice_sym(item): | 
					
						
							|  |  |  |         return "(X)" if item.choice.selection is item else "( )" | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     tri_val_str = (" ", "M", "*")[item.tri_value] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if len(item.assignable) <= 1: | 
					
						
							|  |  |  |         # Pinned to a single value | 
					
						
							|  |  |  |         return "" if isinstance(item, Choice) else "-{}-".format(tri_val_str) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if item.type == BOOL: | 
					
						
							|  |  |  |         return "[{}]".format(tri_val_str) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # item.type == TRISTATE | 
					
						
							|  |  |  |     if item.assignable == (1, 2): | 
					
						
							|  |  |  |         return "{{{}}}".format(tri_val_str)  # {M}/{*} | 
					
						
							|  |  |  |     return "<{}>".format(tri_val_str) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 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 _check_valid(sym, s): | 
					
						
							|  |  |  |     # Returns True if the string 's' is a well-formed value for 'sym'. | 
					
						
							|  |  |  |     # Otherwise, displays an error and returns False. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if sym.orig_type not in (INT, HEX): | 
					
						
							|  |  |  |         return True  # Anything goes for non-int/hex symbols | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     base = 10 if sym.orig_type == INT else 16 | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         int(s, base) | 
					
						
							|  |  |  |     except ValueError: | 
					
						
							|  |  |  |         _error("'{}' is a malformed {} value" | 
					
						
							|  |  |  |                .format(s, TYPE_TO_STR[sym.orig_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): | 
					
						
							|  |  |  |                 _error("{} is outside the range {}-{}" | 
					
						
							|  |  |  |                        .format(s, low_s, high_s)) | 
					
						
							|  |  |  |                 return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |             break | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     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.orig_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 _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. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         int(name) | 
					
						
							|  |  |  |     except ValueError: | 
					
						
							|  |  |  |         if not name.startswith(("0x", "0X")): | 
					
						
							|  |  |  |             return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         try: | 
					
						
							|  |  |  |             int(name, 16) | 
					
						
							|  |  |  |         except ValueError: | 
					
						
							|  |  |  |             return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return True | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _getch_compat(win): | 
					
						
							|  |  |  |     # Uses get_wch() if available (Python 3.3+) and getch() otherwise. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Also falls back on getch() if get_wch() raises curses.error, to work | 
					
						
							|  |  |  |     # around an issue when resizing the terminal on at least macOS Catalina. | 
					
						
							|  |  |  |     # See https://github.com/ulfalizer/Kconfiglib/issues/84. | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # Also handles a PDCurses resizing quirk. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         c = win.get_wch() | 
					
						
							|  |  |  |     except (AttributeError, curses.error): | 
					
						
							|  |  |  |         c = win.getch() | 
					
						
							|  |  |  |         if 0 <= c <= 255: | 
					
						
							|  |  |  |             c = chr(c) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Decent resizing behavior on PDCurses requires calling resize_term(0, 0) | 
					
						
							|  |  |  |     # after receiving KEY_RESIZE, while ncurses (usually) handles terminal | 
					
						
							|  |  |  |     # resizing automatically in get(_w)ch() (see the end of the | 
					
						
							|  |  |  |     # resizeterm(3NCURSES) man page). | 
					
						
							|  |  |  |     # | 
					
						
							|  |  |  |     # resize_term(0, 0) reliably fails and does nothing on ncurses, so this | 
					
						
							|  |  |  |     # hack gives ncurses/PDCurses compatibility for resizing. I don't know | 
					
						
							|  |  |  |     # whether it would cause trouble for other implementations. | 
					
						
							|  |  |  |     if c == curses.KEY_RESIZE: | 
					
						
							|  |  |  |         try: | 
					
						
							|  |  |  |             curses.resize_term(0, 0) | 
					
						
							|  |  |  |         except curses.error: | 
					
						
							|  |  |  |             pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     return c | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _warn(*args): | 
					
						
							|  |  |  |     # Temporarily returns from curses to shell mode and prints a warning to | 
					
						
							|  |  |  |     # stderr. The warning would get lost in curses mode. | 
					
						
							|  |  |  |     curses.endwin() | 
					
						
							|  |  |  |     print("menuconfig warning: ", end="", file=sys.stderr) | 
					
						
							|  |  |  |     print(*args, file=sys.stderr) | 
					
						
							|  |  |  |     curses.doupdate() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # Ignore exceptions from some functions that might fail, e.g. for small | 
					
						
							|  |  |  | # windows. They usually do reasonable things anyway. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _safe_curs_set(visibility): | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         curses.curs_set(visibility) | 
					
						
							|  |  |  |     except curses.error: | 
					
						
							|  |  |  |         pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _safe_addstr(win, *args): | 
					
						
							|  |  |  |     # Clip the line to avoid wrapping to the next line, which looks glitchy. | 
					
						
							|  |  |  |     # addchstr() would do it for us, but it's not available in the 'curses' | 
					
						
							|  |  |  |     # module. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     attr = None | 
					
						
							|  |  |  |     if isinstance(args[0], str): | 
					
						
							|  |  |  |         y, x = win.getyx() | 
					
						
							|  |  |  |         s = args[0] | 
					
						
							|  |  |  |         if len(args) == 2: | 
					
						
							|  |  |  |             attr = args[1] | 
					
						
							|  |  |  |     else: | 
					
						
							|  |  |  |         y, x, s = args[:3] | 
					
						
							|  |  |  |         if len(args) == 4: | 
					
						
							|  |  |  |             attr = args[3] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     maxlen = _width(win) - x | 
					
						
							|  |  |  |     s = s.expandtabs() | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         # The 'curses' module uses wattr_set() internally if you pass 'attr', | 
					
						
							|  |  |  |         # overwriting the background style, so setting 'attr' to 0 in the first | 
					
						
							|  |  |  |         # case won't do the right thing | 
					
						
							|  |  |  |         if attr is None: | 
					
						
							|  |  |  |             win.addnstr(y, x, s, maxlen) | 
					
						
							|  |  |  |         else: | 
					
						
							|  |  |  |             win.addnstr(y, x, s, maxlen, attr) | 
					
						
							|  |  |  |     except curses.error: | 
					
						
							|  |  |  |         pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _safe_addch(win, *args): | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         win.addch(*args) | 
					
						
							|  |  |  |     except curses.error: | 
					
						
							|  |  |  |         pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _safe_hline(win, *args): | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         win.hline(*args) | 
					
						
							|  |  |  |     except curses.error: | 
					
						
							|  |  |  |         pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _safe_vline(win, *args): | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         win.vline(*args) | 
					
						
							|  |  |  |     except curses.error: | 
					
						
							|  |  |  |         pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _safe_move(win, *args): | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         win.move(*args) | 
					
						
							|  |  |  |     except curses.error: | 
					
						
							|  |  |  |         pass | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def _change_c_lc_ctype_to_utf8(): | 
					
						
							|  |  |  |     # See _CHANGE_C_LC_CTYPE_TO_UTF8 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     if _IS_WINDOWS: | 
					
						
							|  |  |  |         # Windows rarely has issues here, and the PEP 538 implementation avoids | 
					
						
							|  |  |  |         # changing the locale on it. None of the UTF-8 locales below were | 
					
						
							|  |  |  |         # supported from some quick testing either. Play it safe. | 
					
						
							|  |  |  |         return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     def try_set_locale(loc): | 
					
						
							|  |  |  |         try: | 
					
						
							|  |  |  |             locale.setlocale(locale.LC_CTYPE, loc) | 
					
						
							|  |  |  |             return True | 
					
						
							|  |  |  |         except locale.Error: | 
					
						
							|  |  |  |             return False | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     # Is LC_CTYPE set to the C locale? | 
					
						
							|  |  |  |     if locale.setlocale(locale.LC_CTYPE) == "C": | 
					
						
							|  |  |  |         # This list was taken from the PEP 538 implementation in the CPython | 
					
						
							|  |  |  |         # code, in Python/pylifecycle.c | 
					
						
							|  |  |  |         for loc in "C.UTF-8", "C.utf8", "UTF-8": | 
					
						
							|  |  |  |             if try_set_locale(loc): | 
					
						
							|  |  |  |                 # LC_CTYPE successfully changed | 
					
						
							|  |  |  |                 return | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | if __name__ == "__main__": | 
					
						
							|  |  |  |     _main() |