1207 lines
44 KiB
Python
1207 lines
44 KiB
Python
# SPDX-License-Identifier: ISC
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
Overview
|
|
========
|
|
|
|
pymenuconfig is a small and simple frontend to Kconfiglib that's written
|
|
entirely in Python using Tkinter as its GUI toolkit.
|
|
|
|
Motivation
|
|
==========
|
|
|
|
Kconfig is a nice and powerful framework for build-time configuration and lots
|
|
of projects already benefit from using it. Kconfiglib allows to utilize power of
|
|
Kconfig by using scripts written in pure Python, without requiring one to build
|
|
Linux kernel tools written in C (this can be quite tedious on anything that's
|
|
not *nix). The aim of this project is to implement simple and small Kconfiglib
|
|
GUI frontend that runs on as much systems as possible.
|
|
|
|
Tkinter GUI toolkit is a natural choice if portability is considered, as it's
|
|
a part of Python standard library and is available virtually in every CPython
|
|
installation.
|
|
|
|
|
|
User interface
|
|
==============
|
|
|
|
I've tried to replicate look and fill of Linux kernel 'menuconfig' tool that
|
|
many users are used to, including keyboard-oriented control and textual
|
|
representation of menus with fixed-width font.
|
|
|
|
|
|
Usage
|
|
=====
|
|
|
|
The pymenuconfig module is executable and parses command-line args, so the
|
|
most simple way to run menuconfig is to execute script directly:
|
|
|
|
python pymenuconfig.py --kconfig Kconfig
|
|
|
|
As with most command-line tools list of options can be obtained with '--help':
|
|
|
|
python pymenuconfig.py --help
|
|
|
|
If installed with setuptools, one can run it like this:
|
|
|
|
python -m pymenuconfig --kconfig Kconfig
|
|
|
|
In case you're making a wrapper around menuconfig, you can either call main():
|
|
|
|
import pymenuconfig
|
|
pymenuconfig.main(['--kconfig', 'Kconfig'])
|
|
|
|
Or import MenuConfig class, instantiate it and manually run Tkinter's mainloop:
|
|
|
|
import tkinter
|
|
import kconfiglib
|
|
from pymenuconfig import MenuConfig
|
|
|
|
kconfig = kconfiglib.Kconfig()
|
|
mconf = MenuConfig(kconfig)
|
|
tkinter.mainloop()
|
|
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
import os
|
|
import sys
|
|
import argparse
|
|
import kconfiglib
|
|
|
|
# Tk is imported differently depending on python major version
|
|
if sys.version_info[0] < 3:
|
|
import Tkinter as tk
|
|
import tkFont as font
|
|
import tkFileDialog as filedialog
|
|
import tkMessageBox as messagebox
|
|
else:
|
|
import tkinter as tk
|
|
from tkinter import font
|
|
from tkinter import filedialog
|
|
from tkinter import messagebox
|
|
|
|
|
|
class ListEntry(object):
|
|
"""
|
|
Represents visible menu node and holds all information related to displaying
|
|
menu node in a Listbox.
|
|
|
|
Instances of this class also handle all interaction with main window.
|
|
A node is displayed as a single line of text:
|
|
PREFIX INDENT BODY POSTFIX
|
|
- The PREFIX is always 3 characters or more and can take following values:
|
|
' ' comment, menu, bool choice, etc.
|
|
Inside menus:
|
|
'< >' bool symbol has value 'n'
|
|
'<*>' bool symbol has value 'y'
|
|
'[ ]' tristate symbol has value 'n'
|
|
'[M]' tristate symbol has value 'm'
|
|
'[*]' tristate symbol has value 'y'
|
|
'- -' symbol has value 'n' that's not editable
|
|
'-M-' symbol has value 'm' that's not editable
|
|
'-*-' symbol has value 'y' that's not editable
|
|
'(M)' tristate choice has value 'm'
|
|
'(*)' tristate choice has value 'y'
|
|
'(some value)' value of non-bool/tristate symbols
|
|
Inside choices:
|
|
'( )' symbol has value 'n'
|
|
'(M)' symbol has value 'm'
|
|
'(*)' symbol has value 'y'
|
|
- INDENT is a sequence of space characters. It's used in implicit menus, and
|
|
adds 2 spaces for each nesting level
|
|
- BODY is a menu node prompt. '***' is added if node is a comment
|
|
- POSTFIX adds '(NEW)', '--->' and selected choice symbol where applicable
|
|
|
|
Attributes:
|
|
|
|
node:
|
|
MenuNode instance this ListEntry is created for.
|
|
|
|
visible:
|
|
Whether entry should be shown in main window.
|
|
|
|
text:
|
|
String to display in a main window's Listbox.
|
|
|
|
refresh():
|
|
Updates .visible and .text attribute values.
|
|
|
|
set_tristate_value():
|
|
Set value for bool/tristate symbols, value should be one of 0,1,2 or None.
|
|
Usually it's called when user presses 'y', 'n', 'm' key.
|
|
|
|
set_str_value():
|
|
Set value for non-bool/tristate symbols, value is a string. Usually called
|
|
with a value returned by one of MenuConfig.ask_for_* methods.
|
|
|
|
toggle():
|
|
Toggle bool/tristate symbol value. Called when '<Space>' key is pressed in
|
|
a main window. Also selects choice value.
|
|
|
|
select():
|
|
Called when '<Return>' key is pressed in a main window with 'SELECT'
|
|
action selected. Displays submenu, choice selection menu, or just selects
|
|
choice value. For non-bool/tristate symbols asks MenuConfig window to
|
|
handle value input via one of MenuConfig.ask_for_* methods.
|
|
|
|
show_help():
|
|
Called when '<Return>' key is pressed in a main window with 'HELP' action
|
|
selected. Prepares text help and calls MenuConfig.show_text() to display
|
|
text window.
|
|
"""
|
|
|
|
# How to display value of BOOL and TRISTATE symbols
|
|
TRI_TO_DISPLAY = {
|
|
0: ' ',
|
|
1: 'M',
|
|
2: '*'
|
|
}
|
|
|
|
def __init__(self, mconf, node, indent):
|
|
self.indent = indent
|
|
self.node = node
|
|
self.menuconfig = mconf
|
|
self.visible = False
|
|
self.text = None
|
|
|
|
def __str__(self):
|
|
return self.text
|
|
|
|
def _is_visible(self):
|
|
node = self.node
|
|
v = True
|
|
v = v and node.prompt is not None
|
|
# It should be enough to check if prompt expression is not false and
|
|
# for menu nodes whether 'visible if' is not false
|
|
v = v and kconfiglib.expr_value(node.prompt[1]) > 0
|
|
if node.item == kconfiglib.MENU:
|
|
v = v and kconfiglib.expr_value(node.visibility) > 0
|
|
# If node references Symbol, then we also account for symbol visibility
|
|
# TODO: need to re-think whether this is needed
|
|
if isinstance(node.item, kconfiglib.Symbol):
|
|
if node.item.type in (kconfiglib.BOOL, kconfiglib.TRISTATE):
|
|
v = v and len(node.item.assignable) > 0
|
|
else:
|
|
v = v and node.item.visibility > 0
|
|
return v
|
|
|
|
def _get_text(self):
|
|
"""
|
|
Compute textual representation of menu node (a line in ListView)
|
|
"""
|
|
node = self.node
|
|
item = node.item
|
|
# Determine prefix
|
|
prefix = ' '
|
|
if (isinstance(item, kconfiglib.Symbol) and item.choice is None or
|
|
isinstance(item, kconfiglib.Choice) and item.type is kconfiglib.TRISTATE):
|
|
# The node is for either a symbol outside of choice statement
|
|
# or a tristate choice
|
|
if item.type in (kconfiglib.BOOL, kconfiglib.TRISTATE):
|
|
value = ListEntry.TRI_TO_DISPLAY[item.tri_value]
|
|
if len(item.assignable) > 1:
|
|
# Symbol is editable
|
|
if 1 in item.assignable:
|
|
prefix = '<{}>'.format(value)
|
|
else:
|
|
prefix = '[{}]'.format(value)
|
|
else:
|
|
# Symbol is not editable
|
|
prefix = '-{}-'.format(value)
|
|
else:
|
|
prefix = '({})'.format(item.str_value)
|
|
elif isinstance(item, kconfiglib.Symbol) and item.choice is not None:
|
|
# The node is for symbol inside choice statement
|
|
if item.type in (kconfiglib.BOOL, kconfiglib.TRISTATE):
|
|
value = ListEntry.TRI_TO_DISPLAY[item.tri_value]
|
|
if len(item.assignable) > 0:
|
|
# Symbol is editable
|
|
prefix = '({})'.format(value)
|
|
else:
|
|
# Symbol is not editable
|
|
prefix = '-{}-'.format(value)
|
|
else:
|
|
prefix = '({})'.format(item.str_value)
|
|
|
|
# Prefix should be at least 3 chars long
|
|
if len(prefix) < 3:
|
|
prefix += ' ' * (3 - len(prefix))
|
|
# Body
|
|
body = ''
|
|
if node.prompt is not None:
|
|
if item is kconfiglib.COMMENT:
|
|
body = '*** {} ***'.format(node.prompt[0])
|
|
else:
|
|
body = node.prompt[0]
|
|
# Suffix
|
|
is_menu = False
|
|
is_new = False
|
|
if (item is kconfiglib.MENU
|
|
or isinstance(item, kconfiglib.Symbol) and node.is_menuconfig
|
|
or isinstance(item, kconfiglib.Choice)):
|
|
is_menu = True
|
|
if isinstance(item, kconfiglib.Symbol) and item.user_value is None:
|
|
is_new = True
|
|
# For symbol inside choice that has 'y' value, '(NEW)' is not displayed
|
|
if (isinstance(item, kconfiglib.Symbol)
|
|
and item.choice and item.choice.tri_value == 2):
|
|
is_new = False
|
|
# Choice selection - displayed only for choices which have 'y' value
|
|
choice_selection = None
|
|
if isinstance(item, kconfiglib.Choice) and node.item.str_value == 'y':
|
|
choice_selection = ''
|
|
if item.selection is not None:
|
|
sym = item.selection
|
|
if sym.nodes and sym.nodes[0].prompt is not None:
|
|
choice_selection = sym.nodes[0].prompt[0]
|
|
text = ' {prefix} {indent}{body}{choice}{new}{menu}'.format(
|
|
prefix=prefix,
|
|
indent=' ' * self.indent,
|
|
body=body,
|
|
choice='' if choice_selection is None else ' ({})'.format(
|
|
choice_selection
|
|
),
|
|
new=' (NEW)' if is_new else '',
|
|
menu=' --->' if is_menu else ''
|
|
)
|
|
return text
|
|
|
|
def refresh(self):
|
|
self.visible = self._is_visible()
|
|
self.text = self._get_text()
|
|
|
|
def set_tristate_value(self, value):
|
|
"""
|
|
Call to change value of BOOL, TRISTATE symbols
|
|
|
|
It's preferred to use this instead of item.set_value as it handles
|
|
all necessary interaction with MenuConfig window when symbol value
|
|
changes
|
|
|
|
None value is accepted but ignored
|
|
"""
|
|
item = self.node.item
|
|
if (isinstance(item, (kconfiglib.Symbol, kconfiglib.Choice))
|
|
and item.type in (kconfiglib.BOOL, kconfiglib.TRISTATE)
|
|
and value is not None):
|
|
if value in item.assignable:
|
|
item.set_value(value)
|
|
elif value == 2 and 1 in item.assignable:
|
|
print(
|
|
'Symbol {} value is limited to \'m\'. Setting value \'m\' instead of \'y\''.format(item.name),
|
|
file=sys.stderr
|
|
)
|
|
item.set_value(1)
|
|
self.menuconfig.mark_as_changed()
|
|
self.menuconfig.refresh_display()
|
|
|
|
def set_str_value(self, value):
|
|
"""
|
|
Call to change value of HEX, INT, STRING symbols
|
|
|
|
It's preferred to use this instead of item.set_value as it handles
|
|
all necessary interaction with MenuConfig window when symbol value
|
|
changes
|
|
|
|
None value is accepted but ignored
|
|
"""
|
|
item = self.node.item
|
|
if (isinstance(item, kconfiglib.Symbol)
|
|
and item.type in (kconfiglib.INT, kconfiglib.HEX, kconfiglib.STRING)
|
|
and value is not None):
|
|
item.set_value(value)
|
|
self.menuconfig.mark_as_changed()
|
|
self.menuconfig.refresh_display()
|
|
|
|
def toggle(self):
|
|
"""
|
|
Called when <space> key is pressed
|
|
"""
|
|
item = self.node.item
|
|
if (isinstance(item, (kconfiglib.Symbol, kconfiglib.Choice))
|
|
and item.type in (kconfiglib.BOOL, kconfiglib.TRISTATE)):
|
|
value = item.tri_value
|
|
# Find next value in Symbol/Choice.assignable, or use assignable[0]
|
|
try:
|
|
it = iter(item.assignable)
|
|
while value != next(it):
|
|
pass
|
|
self.set_tristate_value(next(it))
|
|
except StopIteration:
|
|
self.set_tristate_value(item.assignable[0])
|
|
|
|
def select(self):
|
|
"""
|
|
Called when <Return> key is pressed and SELECT action is selected
|
|
"""
|
|
item = self.node.item
|
|
# - Menu: dive into submenu
|
|
# - INT, HEX, STRING symbol: raise prompt to enter symbol value
|
|
# - BOOL, TRISTATE symbol inside 'y'-valued Choice: set 'y' value
|
|
if (item is kconfiglib.MENU
|
|
or isinstance(item, kconfiglib.Symbol) and self.node.is_menuconfig
|
|
or isinstance(item, kconfiglib.Choice)):
|
|
# Dive into submenu
|
|
self.menuconfig.show_submenu(self.node)
|
|
elif (isinstance(item, kconfiglib.Symbol) and item.type in
|
|
(kconfiglib.INT, kconfiglib.HEX, kconfiglib.STRING)):
|
|
# Raise prompt to enter symbol value
|
|
ident = self.node.prompt[0] if self.node.prompt is not None else None
|
|
title = 'Symbol: {}'.format(item.name)
|
|
if item.type is kconfiglib.INT:
|
|
# Find enabled ranges
|
|
ranges = [
|
|
(int(start.str_value), int(end.str_value))
|
|
for start, end, expr in item.ranges
|
|
if kconfiglib.expr_value(expr) > 0
|
|
]
|
|
# Raise prompt
|
|
self.set_str_value(str(self.menuconfig.ask_for_int(
|
|
ident=ident,
|
|
title=title,
|
|
value=item.str_value,
|
|
ranges=ranges
|
|
)))
|
|
elif item.type is kconfiglib.HEX:
|
|
# Find enabled ranges
|
|
ranges = [
|
|
(int(start.str_value, base=16), int(end.str_value, base=16))
|
|
for start, end, expr in item.ranges
|
|
if kconfiglib.expr_value(expr) > 0
|
|
]
|
|
# Raise prompt
|
|
self.set_str_value(hex(self.menuconfig.ask_for_hex(
|
|
ident=ident,
|
|
title=title,
|
|
value=item.str_value,
|
|
ranges=ranges
|
|
)))
|
|
elif item.type is kconfiglib.STRING:
|
|
# Raise prompt
|
|
self.set_str_value(self.menuconfig.ask_for_string(
|
|
ident=ident,
|
|
title=title,
|
|
value=item.str_value
|
|
))
|
|
elif (isinstance(item, kconfiglib.Symbol)
|
|
and item.choice is not None and item.choice.tri_value == 2):
|
|
# Symbol inside choice -> set symbol value to 'y'
|
|
self.set_tristate_value(2)
|
|
|
|
def show_help(self):
|
|
node = self.node
|
|
item = self.node.item
|
|
if isinstance(item, (kconfiglib.Symbol, kconfiglib.Choice)):
|
|
title = 'Help for symbol: {}'.format(item.name)
|
|
if node.help:
|
|
help = node.help
|
|
else:
|
|
help = 'There is no help available for this option.\n'
|
|
lines = []
|
|
lines.append(help)
|
|
lines.append(
|
|
'Symbol: {} [={}]'.format(
|
|
item.name if item.name else '<UNNAMED>', item.str_value
|
|
)
|
|
)
|
|
lines.append('Type : {}'.format(kconfiglib.TYPE_TO_STR[item.type]))
|
|
for n in item.nodes:
|
|
lines.append('Prompt: {}'.format(n.prompt[0] if n.prompt else '<EMPTY>'))
|
|
lines.append(' Defined at {}:{}'.format(n.filename, n.linenr))
|
|
lines.append(' Depends on: {}'.format(kconfiglib.expr_str(n.dep)))
|
|
text = '\n'.join(lines)
|
|
else:
|
|
title = 'Help'
|
|
text = 'Help not available for this menu node.\n'
|
|
self.menuconfig.show_text(text, title)
|
|
self.menuconfig.refresh_display()
|
|
|
|
|
|
class EntryDialog(object):
|
|
"""
|
|
Creates modal dialog (top-level Tk window) with labels, entry box and two
|
|
buttons: OK and CANCEL.
|
|
"""
|
|
def __init__(self, master, text, title, ident=None, value=None):
|
|
self.master = master
|
|
dlg = self.dlg = tk.Toplevel(master)
|
|
self.dlg.withdraw() #hiden window
|
|
dlg.title(title)
|
|
# Identifier label
|
|
if ident is not None:
|
|
self.label_id = tk.Label(dlg, anchor=tk.W, justify=tk.LEFT)
|
|
self.label_id['font'] = font.nametofont('TkFixedFont')
|
|
self.label_id['text'] = '# {}'.format(ident)
|
|
self.label_id.pack(fill=tk.X, padx=2, pady=2)
|
|
# Label
|
|
self.label = tk.Label(dlg, anchor=tk.W, justify=tk.LEFT)
|
|
self.label['font'] = font.nametofont('TkFixedFont')
|
|
self.label['text'] = text
|
|
self.label.pack(fill=tk.X, padx=10, pady=4)
|
|
# Entry box
|
|
self.entry = tk.Entry(dlg)
|
|
self.entry['font'] = font.nametofont('TkFixedFont')
|
|
self.entry.pack(fill=tk.X, padx=2, pady=2)
|
|
# Frame for buttons
|
|
self.frame = tk.Frame(dlg)
|
|
self.frame.pack(padx=2, pady=2)
|
|
# Button
|
|
self.btn_accept = tk.Button(self.frame, text='< Ok >', command=self.accept)
|
|
self.btn_accept['font'] = font.nametofont('TkFixedFont')
|
|
self.btn_accept.pack(side=tk.LEFT, padx=2)
|
|
self.btn_cancel = tk.Button(self.frame, text='< Cancel >', command=self.cancel)
|
|
self.btn_cancel['font'] = font.nametofont('TkFixedFont')
|
|
self.btn_cancel.pack(side=tk.LEFT, padx=2)
|
|
# Bind Enter and Esc keys
|
|
self.dlg.bind('<Return>', self.accept)
|
|
self.dlg.bind('<Escape>', self.cancel)
|
|
# Dialog is resizable only by width
|
|
self.dlg.resizable(1, 0)
|
|
# Set supplied value (if any)
|
|
if value is not None:
|
|
self.entry.insert(0, value)
|
|
self.entry.selection_range(0, tk.END)
|
|
# By default returned value is None. To caller this means that entry
|
|
# process was cancelled
|
|
self.value = None
|
|
# Modal dialog
|
|
dlg.transient(master)
|
|
dlg.grab_set()
|
|
# Center dialog window
|
|
_center_window_above_parent(master, dlg)
|
|
self.dlg.deiconify() # show window
|
|
# Focus entry field
|
|
self.entry.focus_set()
|
|
|
|
def accept(self, ev=None):
|
|
self.value = self.entry.get()
|
|
self.dlg.destroy()
|
|
|
|
def cancel(self, ev=None):
|
|
self.dlg.destroy()
|
|
|
|
|
|
class TextDialog(object):
|
|
def __init__(self, master, text, title):
|
|
self.master = master
|
|
dlg = self.dlg = tk.Toplevel(master)
|
|
self.dlg.withdraw() #hiden window
|
|
dlg.title(title)
|
|
dlg.minsize(600,400)
|
|
# Text
|
|
self.text = tk.Text(dlg, height=1)
|
|
self.text['font'] = font.nametofont('TkFixedFont')
|
|
self.text.insert(tk.END, text)
|
|
# Make text read-only
|
|
self.text['state'] = tk.DISABLED
|
|
self.text.pack(fill=tk.BOTH, expand=1, padx=4, pady=4)
|
|
# Frame for buttons
|
|
self.frame = tk.Frame(dlg)
|
|
self.frame.pack(padx=2, pady=2)
|
|
# Button
|
|
self.btn_accept = tk.Button(self.frame, text='< Ok >', command=self.accept)
|
|
self.btn_accept['font'] = font.nametofont('TkFixedFont')
|
|
self.btn_accept.pack(side=tk.LEFT, padx=2)
|
|
# Bind Enter and Esc keys
|
|
self.dlg.bind('<Return>', self.accept)
|
|
self.dlg.bind('<Escape>', self.cancel)
|
|
# Modal dialog
|
|
dlg.transient(master)
|
|
dlg.grab_set()
|
|
# Center dialog window
|
|
_center_window_above_parent(master, dlg)
|
|
self.dlg.deiconify() # show window
|
|
# Focus entry field
|
|
self.text.focus_set()
|
|
|
|
def accept(self, ev=None):
|
|
self.dlg.destroy()
|
|
|
|
def cancel(self, ev=None):
|
|
self.dlg.destroy()
|
|
|
|
|
|
class MenuConfig(object):
|
|
(
|
|
ACTION_SELECT,
|
|
ACTION_EXIT,
|
|
ACTION_HELP,
|
|
ACTION_LOAD,
|
|
ACTION_SAVE,
|
|
ACTION_SAVE_AS
|
|
) = range(6)
|
|
|
|
ACTIONS = (
|
|
('Select', ACTION_SELECT),
|
|
('Exit', ACTION_EXIT),
|
|
('Help', ACTION_HELP),
|
|
('Load', ACTION_LOAD),
|
|
('Save', ACTION_SAVE),
|
|
('Save as', ACTION_SAVE_AS),
|
|
)
|
|
|
|
def __init__(self, kconfig, __silent=None):
|
|
self.kconfig = kconfig
|
|
self.__silent = __silent
|
|
if self.__silent is True:
|
|
return
|
|
|
|
# Instantiate Tk widgets
|
|
self.root = tk.Tk()
|
|
self.root.withdraw() #hiden window
|
|
dlg = self.root
|
|
|
|
# Window title
|
|
dlg.title('pymenuconfig')
|
|
# Some empirical window size
|
|
dlg.minsize(500, 300)
|
|
dlg.geometry('800x600')
|
|
|
|
# Label that shows position in menu tree
|
|
self.label_position = tk.Label(
|
|
dlg,
|
|
anchor=tk.W,
|
|
justify=tk.LEFT,
|
|
font=font.nametofont('TkFixedFont')
|
|
)
|
|
self.label_position.pack(fill=tk.X, padx=2)
|
|
|
|
# 'Tip' frame and text
|
|
self.frame_tip = tk.LabelFrame(
|
|
dlg,
|
|
text='Tip'
|
|
)
|
|
self.label_tip = tk.Label(
|
|
self.frame_tip,
|
|
anchor=tk.W,
|
|
justify=tk.LEFT,
|
|
font=font.nametofont('TkFixedFont')
|
|
)
|
|
self.label_tip['text'] = '\n'.join([
|
|
'Arrow keys navigate the menu. <Enter> performs selected operation (set of buttons at the bottom)',
|
|
'Pressing <Y> includes, <N> excludes, <M> modularizes features',
|
|
'Press <Esc> to go one level up. Press <Esc> at top level to exit',
|
|
'Legend: [*] built-in [ ] excluded <M> module < > module capable'
|
|
])
|
|
self.label_tip.pack(fill=tk.BOTH, expand=1, padx=4, pady=4)
|
|
self.frame_tip.pack(fill=tk.X, padx=2)
|
|
|
|
# Main ListBox where all the magic happens
|
|
self.list = tk.Listbox(
|
|
dlg,
|
|
selectmode=tk.SINGLE,
|
|
activestyle=tk.NONE,
|
|
font=font.nametofont('TkFixedFont'),
|
|
height=1,
|
|
)
|
|
self.list['foreground'] = 'Blue'
|
|
self.list['background'] = 'Gray95'
|
|
# Make selection invisible
|
|
self.list['selectbackground'] = self.list['background']
|
|
self.list['selectforeground'] = self.list['foreground']
|
|
self.list.pack(fill=tk.BOTH, expand=1, padx=20, ipadx=2)
|
|
|
|
# Frame with radio buttons
|
|
self.frame_radio = tk.Frame(dlg)
|
|
self.radio_buttons = []
|
|
self.tk_selected_action = tk.IntVar()
|
|
for text, value in MenuConfig.ACTIONS:
|
|
btn = tk.Radiobutton(
|
|
self.frame_radio,
|
|
variable=self.tk_selected_action,
|
|
value=value
|
|
)
|
|
btn['text'] = '< {} >'.format(text)
|
|
btn['font'] = font.nametofont('TkFixedFont')
|
|
btn['indicatoron'] = 0
|
|
btn.pack(side=tk.LEFT)
|
|
self.radio_buttons.append(btn)
|
|
self.frame_radio.pack(anchor=tk.CENTER, pady=4)
|
|
# Label with status information
|
|
self.tk_status = tk.StringVar()
|
|
self.label_status = tk.Label(
|
|
dlg,
|
|
textvariable=self.tk_status,
|
|
anchor=tk.W,
|
|
justify=tk.LEFT,
|
|
font=font.nametofont('TkFixedFont')
|
|
)
|
|
self.label_status.pack(fill=tk.X, padx=4, pady=4)
|
|
# Center window
|
|
_center_window(self.root, dlg)
|
|
self.root.deiconify() # show window
|
|
# Disable keyboard focus on all widgets ...
|
|
self._set_option_to_all_children(dlg, 'takefocus', 0)
|
|
# ... except for main ListBox
|
|
self.list['takefocus'] = 1
|
|
self.list.focus_set()
|
|
# Bind keys
|
|
dlg.bind('<Escape>', self.handle_keypress)
|
|
dlg.bind('<space>', self.handle_keypress)
|
|
dlg.bind('<Return>', self.handle_keypress)
|
|
dlg.bind('<Right>', self.handle_keypress)
|
|
dlg.bind('<Left>', self.handle_keypress)
|
|
dlg.bind('<Up>', self.handle_keypress)
|
|
dlg.bind('<Down>', self.handle_keypress)
|
|
dlg.bind('n', self.handle_keypress)
|
|
dlg.bind('m', self.handle_keypress)
|
|
dlg.bind('y', self.handle_keypress)
|
|
# Register callback that's called when window closes
|
|
dlg.wm_protocol('WM_DELETE_WINDOW', self._close_window)
|
|
# Init fields
|
|
self.node = None
|
|
self.node_stack = []
|
|
self.all_entries = []
|
|
self.shown_entries = []
|
|
self.config_path = None
|
|
self.unsaved_changes = False
|
|
self.status_string = 'NEW CONFIG'
|
|
self.update_status()
|
|
# Display first child of top level node (the top level node is 'mainmenu')
|
|
self.show_node(self.kconfig.top_node)
|
|
|
|
def _set_option_to_all_children(self, widget, option, value):
|
|
widget[option] = value
|
|
for n,c in widget.children.items():
|
|
self._set_option_to_all_children(c, option, value)
|
|
|
|
def _invert_colors(self, idx):
|
|
self.list.itemconfig(idx, {'bg' : self.list['foreground']})
|
|
self.list.itemconfig(idx, {'fg' : self.list['background']})
|
|
|
|
@property
|
|
def _selected_entry(self):
|
|
# type: (...) -> ListEntry
|
|
active_idx = self.list.index(tk.ACTIVE)
|
|
if active_idx >= 0 and active_idx < len(self.shown_entries):
|
|
return self.shown_entries[active_idx]
|
|
return None
|
|
|
|
def _select_node(self, node):
|
|
# type: (kconfiglib.MenuNode) -> None
|
|
"""
|
|
Attempts to select entry that corresponds to given MenuNode in main listbox
|
|
"""
|
|
idx = None
|
|
for i, e in enumerate(self.shown_entries):
|
|
if e.node is node:
|
|
idx = i
|
|
break
|
|
if idx is not None:
|
|
self.list.activate(idx)
|
|
self.list.see(idx)
|
|
self._invert_colors(idx)
|
|
|
|
def handle_keypress(self, ev):
|
|
keysym = ev.keysym
|
|
if keysym == 'Left':
|
|
self._select_action(prev=True)
|
|
elif keysym == 'Right':
|
|
self._select_action(prev=False)
|
|
elif keysym == 'Up':
|
|
self.refresh_display(reset_selection=False)
|
|
elif keysym == 'Down':
|
|
self.refresh_display(reset_selection=False)
|
|
elif keysym == 'space':
|
|
self._selected_entry.toggle()
|
|
elif keysym in ('n', 'm', 'y'):
|
|
self._selected_entry.set_tristate_value(kconfiglib.STR_TO_TRI[keysym])
|
|
elif keysym == 'Return':
|
|
action = self.tk_selected_action.get()
|
|
if action == self.ACTION_SELECT:
|
|
self._selected_entry.select()
|
|
elif action == self.ACTION_EXIT:
|
|
self._action_exit()
|
|
elif action == self.ACTION_HELP:
|
|
self._selected_entry.show_help()
|
|
elif action == self.ACTION_LOAD:
|
|
if self.prevent_losing_changes():
|
|
self.open_config()
|
|
elif action == self.ACTION_SAVE:
|
|
self.save_config()
|
|
elif action == self.ACTION_SAVE_AS:
|
|
self.save_config(force_file_dialog=True)
|
|
elif keysym == 'Escape':
|
|
self._action_exit()
|
|
pass
|
|
|
|
def _close_window(self):
|
|
if self.prevent_losing_changes():
|
|
print('Exiting..')
|
|
if self.__silent is True:
|
|
return
|
|
self.root.destroy()
|
|
|
|
def _action_exit(self):
|
|
if self.node_stack:
|
|
self.show_parent()
|
|
else:
|
|
self._close_window()
|
|
|
|
def _select_action(self, prev=False):
|
|
# Determine the radio button that's activated
|
|
action = self.tk_selected_action.get()
|
|
if prev:
|
|
action -= 1
|
|
else:
|
|
action += 1
|
|
action %= len(MenuConfig.ACTIONS)
|
|
self.tk_selected_action.set(action)
|
|
|
|
def _collect_list_entries(self, start_node, indent=0):
|
|
"""
|
|
Given first MenuNode of nodes list at some level in menu hierarchy,
|
|
collects nodes that may be displayed when viewing and editing that
|
|
hierarchy level. Includes implicit menu nodes, i.e. the ones dependent
|
|
on 'config' entry via 'if' statement which are internally represented
|
|
as children of their dependency
|
|
"""
|
|
entries = []
|
|
n = start_node
|
|
while n is not None:
|
|
entries.append(ListEntry(self, n, indent))
|
|
# If node refers to a symbol (X) and has children, it is either
|
|
# 'config' or 'menuconfig'. The children are items inside 'if X'
|
|
# block that immediately follows 'config' or 'menuconfig' entry.
|
|
# If it's a 'menuconfig' then corresponding MenuNode is shown as a
|
|
# regular menu entry. But if it's a 'config', then its children need
|
|
# to be shown in the same list with their texts indented
|
|
if (n.list is not None
|
|
and isinstance(n.item, kconfiglib.Symbol)
|
|
and n.is_menuconfig == False):
|
|
entries.extend(
|
|
self._collect_list_entries(n.list, indent=indent + 1)
|
|
)
|
|
n = n.next
|
|
return entries
|
|
|
|
def refresh_display(self, reset_selection=False):
|
|
# Refresh list entries' attributes
|
|
for e in self.all_entries:
|
|
e.refresh()
|
|
# Try to preserve selection upon refresh
|
|
selected_entry = self._selected_entry
|
|
# Also try to preserve listbox scroll offset
|
|
# If not preserved, the see() method will make wanted item to appear
|
|
# at the bottom of the list, even if previously it was in center
|
|
scroll_offset = self.list.yview()[0]
|
|
# Show only visible entries
|
|
self.shown_entries = [e for e in self.all_entries if e.visible]
|
|
# Refresh listbox contents
|
|
self.list.delete(0, tk.END)
|
|
self.list.insert(0, *self.shown_entries)
|
|
if selected_entry and not reset_selection:
|
|
# Restore scroll position
|
|
self.list.yview_moveto(scroll_offset)
|
|
# Activate previously selected node
|
|
self._select_node(selected_entry.node)
|
|
else:
|
|
# Select the topmost entry
|
|
self.list.activate(0)
|
|
self._invert_colors(0)
|
|
# Select ACTION_SELECT on each refresh (mimic C menuconfig)
|
|
self.tk_selected_action.set(self.ACTION_SELECT)
|
|
# Display current location in configuration tree
|
|
pos = []
|
|
for n in self.node_stack + [self.node]:
|
|
pos.append(n.prompt[0] if n.prompt else '[none]')
|
|
self.label_position['text'] = u'# ' + u' -> '.join(pos)
|
|
|
|
def show_node(self, node):
|
|
self.node = node
|
|
if node.list is not None:
|
|
self.all_entries = self._collect_list_entries(node.list)
|
|
else:
|
|
self.all_entries = []
|
|
self.refresh_display(reset_selection=True)
|
|
|
|
def show_submenu(self, node):
|
|
self.node_stack.append(self.node)
|
|
self.show_node(node)
|
|
|
|
def show_parent(self):
|
|
if self.node_stack:
|
|
select_node = self.node
|
|
parent_node = self.node_stack.pop()
|
|
self.show_node(parent_node)
|
|
# Restore previous selection
|
|
self._select_node(select_node)
|
|
self.refresh_display(reset_selection=False)
|
|
|
|
def ask_for_string(self, ident=None, title='Enter string', value=None):
|
|
"""
|
|
Raises dialog with text entry widget and asks user to enter string
|
|
|
|
Return:
|
|
- str - user entered string
|
|
- None - entry was cancelled
|
|
"""
|
|
text = 'Please enter a string value\n' \
|
|
'User <Enter> key to accept the value\n' \
|
|
'Use <Esc> key to cancel entry\n'
|
|
d = EntryDialog(self.root, text, title, ident=ident, value=value)
|
|
self.root.wait_window(d.dlg)
|
|
self.list.focus_set()
|
|
return d.value
|
|
|
|
def ask_for_int(self, ident=None, title='Enter integer value', value=None, ranges=()):
|
|
"""
|
|
Raises dialog with text entry widget and asks user to enter decimal number
|
|
Ranges should be iterable of tuples (start, end),
|
|
where 'start' and 'end' specify allowed value range (inclusively)
|
|
|
|
Return:
|
|
- int - when valid number that falls within any one of specified ranges is entered
|
|
- None - invalid number or entry was cancelled
|
|
"""
|
|
text = 'Please enter a decimal value. Fractions will not be accepted\n' \
|
|
'User <Enter> key to accept the value\n' \
|
|
'Use <Esc> key to cancel entry\n'
|
|
d = EntryDialog(self.root, text, title, ident=ident, value=value)
|
|
self.root.wait_window(d.dlg)
|
|
self.list.focus_set()
|
|
ivalue = None
|
|
if d.value:
|
|
try:
|
|
ivalue = int(d.value)
|
|
except ValueError:
|
|
messagebox.showerror('Bad value', 'Entered value \'{}\' is not an integer'.format(d.value))
|
|
if ivalue is not None and ranges:
|
|
allowed = False
|
|
for start, end in ranges:
|
|
allowed = allowed or start <= ivalue and ivalue <= end
|
|
if not allowed:
|
|
messagebox.showerror(
|
|
'Bad value',
|
|
'Entered value \'{:d}\' is out of range\n'
|
|
'Allowed:\n{}'.format(
|
|
ivalue,
|
|
'\n'.join([' {:d} - {:d}'.format(s,e) for s,e in ranges])
|
|
)
|
|
)
|
|
ivalue = None
|
|
return ivalue
|
|
|
|
def ask_for_hex(self, ident=None, title='Enter hexadecimal value', value=None, ranges=()):
|
|
"""
|
|
Raises dialog with text entry widget and asks user to enter decimal number
|
|
Ranges should be iterable of tuples (start, end),
|
|
where 'start' and 'end' specify allowed value range (inclusively)
|
|
|
|
Return:
|
|
- int - when valid number that falls within any one of specified ranges is entered
|
|
- None - invalid number or entry was cancelled
|
|
"""
|
|
text = 'Please enter a hexadecimal value\n' \
|
|
'User <Enter> key to accept the value\n' \
|
|
'Use <Esc> key to cancel entry\n'
|
|
d = EntryDialog(self.root, text, title, ident=ident, value=value)
|
|
self.root.wait_window(d.dlg)
|
|
self.list.focus_set()
|
|
hvalue = None
|
|
if d.value:
|
|
try:
|
|
hvalue = int(d.value, base=16)
|
|
except ValueError:
|
|
messagebox.showerror('Bad value', 'Entered value \'{}\' is not a hexadecimal value'.format(d.value))
|
|
if hvalue is not None and ranges:
|
|
allowed = False
|
|
for start, end in ranges:
|
|
allowed = allowed or start <= hvalue and hvalue <= end
|
|
if not allowed:
|
|
messagebox.showerror(
|
|
'Bad value',
|
|
'Entered value \'0x{:x}\' is out of range\n'
|
|
'Allowed:\n{}'.format(
|
|
hvalue,
|
|
'\n'.join([' 0x{:x} - 0x{:x}'.format(s,e) for s,e in ranges])
|
|
)
|
|
)
|
|
hvalue = None
|
|
return hvalue
|
|
|
|
def show_text(self, text, title='Info'):
|
|
"""
|
|
Raises dialog with read-only text view that contains supplied text
|
|
"""
|
|
d = TextDialog(self.root, text, title)
|
|
self.root.wait_window(d.dlg)
|
|
self.list.focus_set()
|
|
|
|
def mark_as_changed(self):
|
|
"""
|
|
Marks current config as having unsaved changes
|
|
Should be called whenever config value is changed
|
|
"""
|
|
self.unsaved_changes = True
|
|
self.update_status()
|
|
|
|
def set_status_string(self, status):
|
|
"""
|
|
Sets status string displayed at the bottom of the window
|
|
"""
|
|
self.status_string = status
|
|
self.update_status()
|
|
|
|
def update_status(self):
|
|
"""
|
|
Updates status bar display
|
|
Status bar displays:
|
|
- unsaved status
|
|
- current config path
|
|
- status string (see set_status_string())
|
|
"""
|
|
if self.__silent is True:
|
|
return
|
|
self.tk_status.set('{} [{}] {}'.format(
|
|
'<UNSAVED>' if self.unsaved_changes else '',
|
|
self.config_path if self.config_path else '',
|
|
self.status_string
|
|
))
|
|
|
|
def _check_is_visible(self, node):
|
|
v = True
|
|
v = v and node.prompt is not None
|
|
# It should be enough to check if prompt expression is not false and
|
|
# for menu nodes whether 'visible if' is not false
|
|
v = v and kconfiglib.expr_value(node.prompt[1]) > 0
|
|
if node.item == kconfiglib.MENU:
|
|
v = v and kconfiglib.expr_value(node.visibility) > 0
|
|
# If node references Symbol, then we also account for symbol visibility
|
|
# TODO: need to re-think whether this is needed
|
|
if isinstance(node.item, kconfiglib.Symbol):
|
|
if node.item.type in (kconfiglib.BOOL, kconfiglib.TRISTATE):
|
|
v = v and len(node.item.assignable) > 0
|
|
else:
|
|
v = v and node.item.visibility > 0
|
|
return v
|
|
|
|
def config_is_changed(self):
|
|
is_changed = False
|
|
node = self.kconfig.top_node.list
|
|
if not node:
|
|
# Empty configuration
|
|
return is_changed
|
|
|
|
while 1:
|
|
item = node.item
|
|
if isinstance(item, kconfiglib.Symbol) and item.user_value is None and self._check_is_visible(node):
|
|
is_changed = True
|
|
print("Config \"# {}\" has changed, need save config file\n".format(node.prompt[0]))
|
|
break;
|
|
|
|
# Iterative tree walk using parent pointers
|
|
|
|
if node.list:
|
|
node = node.list
|
|
elif node.next:
|
|
node = node.next
|
|
else:
|
|
while node.parent:
|
|
node = node.parent
|
|
if node.next:
|
|
node = node.next
|
|
break
|
|
else:
|
|
break
|
|
return is_changed
|
|
|
|
def prevent_losing_changes(self):
|
|
"""
|
|
Checks if there are unsaved changes and asks user to save or discard them
|
|
This routine should be called whenever current config is going to be discarded
|
|
|
|
Raises the usual 'Yes', 'No', 'Cancel' prompt.
|
|
|
|
Return:
|
|
- True: caller may safely drop current config state
|
|
- False: user needs to continue work on current config ('Cancel' pressed or saving failed)
|
|
"""
|
|
if self.config_is_changed() == True:
|
|
self.mark_as_changed()
|
|
if not self.unsaved_changes:
|
|
return True
|
|
|
|
if self.__silent:
|
|
saved = self.save_config()
|
|
return saved
|
|
res = messagebox.askyesnocancel(
|
|
parent=self.root,
|
|
title='Unsaved changes',
|
|
message='Config has unsaved changes. Do you want to save them?'
|
|
)
|
|
if res is None:
|
|
return False
|
|
elif res is False:
|
|
return True
|
|
# Otherwise attempt to save config and succeed only if config has been saved successfully
|
|
saved = self.save_config()
|
|
return saved
|
|
|
|
def open_config(self, path=None):
|
|
if path is None:
|
|
# Create open dialog. Either existing file is selected or no file is selected as a result
|
|
path = filedialog.askopenfilename(
|
|
parent=self.root,
|
|
title='Open config..',
|
|
initialdir=os.path.dirname(self.config_path) if self.config_path else os.getcwd(),
|
|
filetypes=(('.config files', '*.config'), ('All files', '*.*'))
|
|
)
|
|
if not path or not os.path.isfile(path):
|
|
return False
|
|
path = os.path.abspath(path)
|
|
print('Loading config: \'{}\''.format(path))
|
|
# Try to open given path
|
|
# If path does not exist, we still set current config path to it but don't load anything
|
|
self.unsaved_changes = False
|
|
self.config_path = path
|
|
if not os.path.exists(path):
|
|
self.set_status_string('New config')
|
|
self.mark_as_changed()
|
|
return True
|
|
# Load config and set status accordingly
|
|
try:
|
|
self.kconfig.load_config(path)
|
|
except IOError as e:
|
|
self.set_status_string('Failed to load: \'{}\''.format(path))
|
|
if not self.__silent:
|
|
self.refresh_display()
|
|
print('Failed to load config \'{}\': {}'.format(path, e))
|
|
return False
|
|
self.set_status_string('Opened config')
|
|
if not self.__silent:
|
|
self.refresh_display()
|
|
return True
|
|
|
|
def save_config(self, force_file_dialog=False):
|
|
path = self.config_path
|
|
if path is None or force_file_dialog:
|
|
path = filedialog.asksaveasfilename(
|
|
parent=self.root,
|
|
title='Save config as..',
|
|
initialdir=os.path.dirname(self.config_path) if self.config_path else os.getcwd(),
|
|
initialfile=os.path.basename(self.config_path) if self.config_path else None,
|
|
defaultextension='.config',
|
|
filetypes=(('.config files', '*.config'), ('All files', '*.*'))
|
|
)
|
|
if not path:
|
|
return False
|
|
path = os.path.abspath(path)
|
|
print('Saving config: \'{}\''.format(path))
|
|
# Try to save config to selected path
|
|
try:
|
|
self.kconfig.write_config(path, header="#\n# Automatically generated file; DO NOT EDIT.\n")
|
|
self.unsaved_changes = False
|
|
self.config_path = path
|
|
self.set_status_string('Saved config')
|
|
except IOError as e:
|
|
self.set_status_string('Failed to save: \'{}\''.format(path))
|
|
print('Save failed: {}'.format(e), file=sys.stderr)
|
|
return False
|
|
return True
|
|
|
|
|
|
def _center_window(root, window):
|
|
# type: (tk.Tk, tk.Toplevel) -> None
|
|
"""
|
|
Attempts to center window on screen
|
|
"""
|
|
root.update_idletasks()
|
|
# root.eval('tk::PlaceWindow {!s} center'.format(
|
|
# window.winfo_pathname(window.winfo_id())
|
|
# ))
|
|
w = window.winfo_width()
|
|
h = window.winfo_height()
|
|
ws = window.winfo_screenwidth()
|
|
hs = window.winfo_screenheight()
|
|
x = (ws / 2) - (w / 2)
|
|
y = (hs / 2) - (h / 2)
|
|
window.geometry('+{:d}+{:d}'.format(int(x), int(y)))
|
|
window.lift()
|
|
window.focus_force()
|
|
|
|
|
|
def _center_window_above_parent(root, window):
|
|
# type: (tk.Tk, tk.Toplevel) -> None
|
|
"""
|
|
Attempts to center window above its parent window
|
|
"""
|
|
# root.eval('tk::PlaceWindow {!s} center'.format(
|
|
# window.winfo_pathname(window.winfo_id())
|
|
# ))
|
|
root.update_idletasks()
|
|
parent = window.master
|
|
w = window.winfo_width()
|
|
h = window.winfo_height()
|
|
px = parent.winfo_rootx()
|
|
py = parent.winfo_rooty()
|
|
pw = parent.winfo_width()
|
|
ph = parent.winfo_height()
|
|
x = px + (pw / 2) - (w / 2)
|
|
y = py + (ph / 2) - (h / 2)
|
|
window.geometry('+{:d}+{:d}'.format(int(x), int(y)))
|
|
window.lift()
|
|
window.focus_force()
|
|
|
|
|
|
def main(argv=None):
|
|
if argv is None:
|
|
argv = sys.argv[1:]
|
|
# Instantiate cmd options parser
|
|
parser = argparse.ArgumentParser(
|
|
description='Interactive Kconfig configuration editor'
|
|
)
|
|
parser.add_argument(
|
|
'--kconfig',
|
|
metavar='FILE',
|
|
type=str,
|
|
default='Kconfig',
|
|
help='path to root Kconfig file'
|
|
)
|
|
parser.add_argument(
|
|
'--config',
|
|
metavar='FILE',
|
|
type=str,
|
|
help='path to .config file to load'
|
|
)
|
|
if "--silent" in argv:
|
|
parser.add_argument(
|
|
'--silent',
|
|
dest = '_silent_',
|
|
type=str,
|
|
help='silent mode, not show window'
|
|
)
|
|
args = parser.parse_args(argv)
|
|
kconfig_path = args.kconfig
|
|
config_path = args.config
|
|
# Verify that Kconfig file exists
|
|
if not os.path.isfile(kconfig_path):
|
|
raise RuntimeError('\'{}\': no such file'.format(kconfig_path))
|
|
|
|
# Parse Kconfig files
|
|
kconf = kconfiglib.Kconfig(filename=kconfig_path)
|
|
|
|
if "--silent" not in argv:
|
|
print("In normal mode. Will show menuconfig window.")
|
|
mc = MenuConfig(kconf)
|
|
# If config file was specified, load it
|
|
if config_path:
|
|
mc.open_config(config_path)
|
|
|
|
print("Enter mainloop. Waiting...")
|
|
tk.mainloop()
|
|
else:
|
|
print("In silent mode. Don`t show menuconfig window.")
|
|
mc = MenuConfig(kconf, True)
|
|
# If config file was specified, load it
|
|
if config_path:
|
|
mc.open_config(config_path)
|
|
mc._close_window()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|