feat: generic prompts

[ctrlaltf24]

Works on all three UIs offers a generic function to ask a question that platform independent. If the user fails to offer a response, the installer will terminate.

In the GUI this still works, however it may not be desirable to prompt the user for each question. So long as we don't attempt to access the variable before the user has had a chance to put in their preferences it will not prompt them Changed the GUI to gray out the other widgets if the product is not selected. start_ensure_config is called AFTER product is set, if it's called before it attempts to figure out which platform it's on, prompting the user with an additional dialog (not ideal, but acceptable)

Screenshots

GUI Sample

TUI Sample

CLI Sample

GUI behavior

Before Product is selected

After product is selected

This is meant as a demonstration, we should expand the scope if we decide to go this direction

Fixes: #147

[thw26]

To my knowledge, I need to wait on self.product_e.wait() as if not, the TUI charges through the installer process; should this way now be handled by the TUI's implementation of app._hook_product_update()?

[ctrlaltf24]

Surprisingly enough it didn't charge through - it waited for the question to be answered before going to the next screen probably because we have two main threads in the TUI:

1. The input processing thread (main, don't block me)
2. When events are triggered they're spawned on a new thread (this is the installation thread). Since the ask call is blocking, this gets stopped while the user is inputting their value (which the processing is done on the first thread)

Then if you notice in TUI's ask implementation there is an event wait to communicate between the two threads

[thw26]

Comments on Demonstration

Thanks for this! The framework you have here looks great.

The TUI is a Frankenstein of my own thought, so anything that simplifies it and makes it less bloated is great—I do like seeing lines of code removed.

As mentioned to Nate, I see tui_screen.py as a library that could feasibly be used outside of our project, so also the same with certain aspects of the display code in tui_app.py, say lines 1–350.

LogosLinuxInstaller/ou_dedetai/tui_app.py

Lines 1 to 350 in 0def2e5

	import logging
	import os
	import signal
	import threading
	import time
	import curses
	from pathlib import Path
	from queue import Queue
	from . import config
	from . import control
	from . import installer
	from . import logos
	from . import msg
	from . import network
	from . import system
	from . import tui_curses
	from . import tui_screen
	from . import utils
	from . import wine
	console_message = ""
	# TODO: Fix hitting cancel in Dialog Screens; currently crashes program.
	class TUI:
	def __init__(self, stdscr):
	self.stdscr = stdscr
	# if config.current_logos_version is not None:
	self.title = f"Welcome to {config.name_app} {config.LLI_CURRENT_VERSION} ({config.lli_release_channel})" # noqa: E501
	self.subtitle = f"Logos Version: {config.current_logos_version} ({config.logos_release_channel})" # noqa: E501
	# else:
	# self.title = f"Welcome to {config.name_app} ({config.LLI_CURRENT_VERSION})" # noqa: E501
	self.console_message = "Starting TUI…"
	self.llirunning = True
	self.active_progress = False
	self.logos = logos.LogosManager(app=self)
	self.tmp = ""
	# Queues
	self.main_thread = threading.Thread()
	self.get_q = Queue()
	self.get_e = threading.Event()
	self.input_q = Queue()
	self.input_e = threading.Event()
	self.status_q = Queue()
	self.status_e = threading.Event()
	self.progress_q = Queue()
	self.progress_e = threading.Event()
	self.todo_q = Queue()
	self.todo_e = threading.Event()
	self.screen_q = Queue()
	self.choice_q = Queue()
	self.switch_q = Queue()
	# Install and Options
	self.product_q = Queue()
	self.product_e = threading.Event()
	self.version_q = Queue()
	self.version_e = threading.Event()
	self.releases_q = Queue()
	self.releases_e = threading.Event()
	self.release_q = Queue()
	self.release_e = threading.Event()
	self.manualinstall_q = Queue()
	self.manualinstall_e = threading.Event()
	self.installdeps_q = Queue()
	self.installdeps_e = threading.Event()
	self.installdir_q = Queue()
	self.installdir_e = threading.Event()
	self.wines_q = Queue()
	self.wine_e = threading.Event()
	self.tricksbin_q = Queue()
	self.tricksbin_e = threading.Event()
	self.deps_q = Queue()
	self.deps_e = threading.Event()
	self.finished_q = Queue()
	self.finished_e = threading.Event()
	self.config_q = Queue()
	self.config_e = threading.Event()
	self.confirm_q = Queue()
	self.confirm_e = threading.Event()
	self.password_q = Queue()
	self.password_e = threading.Event()
	self.appimage_q = Queue()
	self.appimage_e = threading.Event()
	self.install_icu_q = Queue()
	self.install_icu_e = threading.Event()
	self.install_logos_q = Queue()
	self.install_logos_e = threading.Event()
	# Window and Screen Management
	self.tui_screens = []
	self.menu_options = []
	self.window_height = self.window_width = self.console = self.menu_screen = self.active_screen = None
	self.main_window_ratio = self.main_window_ratio = self.menu_window_ratio = self.main_window_min = None
	self.menu_window_min = self.main_window_height = self.menu_window_height = self.main_window = None
	self.menu_window = self.resize_window = None
	self.set_window_dimensions()
	def set_window_dimensions(self):
	self.update_tty_dimensions()
	curses.resizeterm(self.window_height, self.window_width)
	self.main_window_ratio = 0.25
	if config.console_log:
	min_console_height = len(tui_curses.wrap_text(self, config.console_log[-1]))
	else:
	min_console_height = 2
	self.main_window_min = len(tui_curses.wrap_text(self, self.title)) + len(
	tui_curses.wrap_text(self, self.subtitle)) + min_console_height
	self.menu_window_ratio = 0.75
	self.menu_window_min = 3
	self.main_window_height = max(int(self.window_height * self.main_window_ratio), self.main_window_min)
	self.menu_window_height = max(self.window_height - self.main_window_height, int(self.window_height * self.menu_window_ratio), self.menu_window_min)
	config.console_log_lines = max(self.main_window_height - self.main_window_min, 1)
	config.options_per_page = max(self.window_height - self.main_window_height - 6, 1)
	self.main_window = curses.newwin(self.main_window_height, curses.COLS, 0, 0)
	self.menu_window = curses.newwin(self.menu_window_height, curses.COLS, self.main_window_height + 1, 0)
	resize_lines = tui_curses.wrap_text(self, "Screen too small.")
	self.resize_window = curses.newwin(len(resize_lines) + 1, curses.COLS, 0, 0)
	@staticmethod
	def set_curses_style():
	curses.start_color()
	curses.use_default_colors()
	curses.init_color(curses.COLOR_BLUE, 0, 510, 1000) # Logos Blue
	curses.init_color(curses.COLOR_CYAN, 906, 906, 906) # Logos Gray
	curses.init_color(curses.COLOR_WHITE, 988, 988, 988) # Logos White
	curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_CYAN)
	curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_WHITE)
	curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLUE)
	curses.init_pair(4, curses.COLOR_WHITE, curses.COLOR_BLUE)
	curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_BLUE)
	curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_WHITE)
	curses.init_pair(7, curses.COLOR_WHITE, curses.COLOR_BLACK)
	def set_curses_colors_logos(self):
	self.stdscr.bkgd(' ', curses.color_pair(3))
	self.main_window.bkgd(' ', curses.color_pair(3))
	self.menu_window.bkgd(' ', curses.color_pair(3))
	def set_curses_colors_light(self):
	self.stdscr.bkgd(' ', curses.color_pair(6))
	self.main_window.bkgd(' ', curses.color_pair(6))
	self.menu_window.bkgd(' ', curses.color_pair(6))
	def set_curses_colors_dark(self):
	self.stdscr.bkgd(' ', curses.color_pair(7))
	self.main_window.bkgd(' ', curses.color_pair(7))
	self.menu_window.bkgd(' ', curses.color_pair(7))
	def change_color_scheme(self):
	if config.curses_colors == "Logos":
	config.curses_colors = "Light"
	self.set_curses_colors_light()
	elif config.curses_colors == "Light":
	config.curses_colors = "Dark"
	self.set_curses_colors_dark()
	else:
	config.curses_colors = "Logos"
	config.curses_colors = "Logos"
	self.set_curses_colors_logos()
	def update_windows(self):
	if isinstance(self.active_screen, tui_screen.CursesScreen):
	self.main_window.erase()
	self.menu_window.erase()
	self.stdscr.timeout(100)
	self.console.display()
	def clear(self):
	self.stdscr.clear()
	self.main_window.clear()
	self.menu_window.clear()
	self.resize_window.clear()
	def refresh(self):
	self.main_window.noutrefresh()
	self.menu_window.noutrefresh()
	self.resize_window.noutrefresh()
	curses.doupdate()
	def init_curses(self):
	try:
	if curses.has_colors():
	if config.curses_colors is None or config.curses_colors == "Logos":
	config.curses_colors = "Logos"
	self.set_curses_style()
	self.set_curses_colors_logos()
	elif config.curses_colors == "Light":
	config.curses_colors = "Light"
	self.set_curses_style()
	self.set_curses_colors_light()
	elif config.curses_colors == "Dark":
	config.curses_colors = "Dark"
	self.set_curses_style()
	self.set_curses_colors_dark()
	curses.curs_set(0)
	curses.noecho()
	curses.cbreak()
	self.stdscr.keypad(True)
	self.console = tui_screen.ConsoleScreen(self, 0, self.status_q, self.status_e, self.title, self.subtitle, 0)
	self.menu_screen = tui_screen.MenuScreen(self, 0, self.status_q, self.status_e,
	"Main Menu", self.set_tui_menu_options(dialog=False))
	#self.menu_screen = tui_screen.MenuDialog(self, 0, self.status_q, self.status_e, "Main Menu",
	# self.set_tui_menu_options(dialog=True))
	self.refresh()
	except curses.error as e:
	logging.error(f"Curses error in init_curses: {e}")
	except Exception as e:
	self.end_curses()
	logging.error(f"An error occurred in init_curses(): {e}")
	raise
	def end_curses(self):
	try:
	self.stdscr.keypad(False)
	curses.nocbreak()
	curses.echo()
	except curses.error as e:
	logging.error(f"Curses error in end_curses: {e}")
	raise
	except Exception as e:
	logging.error(f"An error occurred in end_curses(): {e}")
	raise
	def end(self, signal, frame):
	logging.debug("Exiting…")
	self.llirunning = False
	curses.endwin()
	def update_main_window_contents(self):
	self.clear()
	self.title = f"Welcome to {config.name_app} {config.LLI_CURRENT_VERSION} ({config.lli_release_channel})" # noqa: E501
	self.subtitle = f"Logos Version: {config.current_logos_version} ({config.logos_release_channel})" # noqa: E501
	self.console = tui_screen.ConsoleScreen(self, 0, self.status_q, self.status_e, self.title, self.subtitle, 0) # noqa: E501
	self.menu_screen.set_options(self.set_tui_menu_options(dialog=False))
	# self.menu_screen.set_options(self.set_tui_menu_options(dialog=True))
	self.switch_q.put(1)
	self.refresh()
	# ERR: On a sudden resize, the Curses menu is not properly resized,
	# and we are not currently dynamically passing the menu options based
	# on the current screen, but rather always passing the tui menu options.
	# To replicate, open Terminator, run LLI full screen, then his Ctrl+A.
	# The menu should survive, but the size does not resize to the new screen,
	# even though the resize signal is sent. See tui_curses, line #251 and
	# tui_screen, line #98.
	def resize_curses(self):
	config.resizing = True
	curses.endwin()
	self.update_tty_dimensions()
	self.set_window_dimensions()
	self.clear()
	self.init_curses()
	self.refresh()
	msg.status("Window resized.", self)
	config.resizing = False
	def signal_resize(self, signum, frame):
	self.resize_curses()
	self.choice_q.put("resize")
	if config.use_python_dialog:
	if isinstance(self.active_screen, tui_screen.TextDialog) and self.active_screen.text == "Screen Too Small":
	self.choice_q.put("Return to Main Menu")
	else:
	if self.active_screen.get_screen_id == 14:
	self.update_tty_dimensions()
	if self.window_height > 9:
	self.switch_q.put(1)
	elif self.window_width > 34:
	self.switch_q.put(1)
	def draw_resize_screen(self):
	self.clear()
	if self.window_width > 10:
	margin = config.margin
	else:
	margin = 0
	resize_lines = tui_curses.wrap_text(self, "Screen too small.")
	self.resize_window = curses.newwin(len(resize_lines) + 1, curses.COLS, 0, 0)
	for i, line in enumerate(resize_lines):
	if i < self.window_height:
	tui_curses.write_line(self, self.resize_window, i, margin, line, self.window_width - config.margin, curses.A_BOLD)
	self.refresh()
	def display(self):
	signal.signal(signal.SIGWINCH, self.signal_resize)
	signal.signal(signal.SIGINT, self.end)
	msg.initialize_tui_logging()
	msg.status(self.console_message, self)
	self.active_screen = self.menu_screen
	last_time = time.time()
	self.logos.monitor()
	while self.llirunning:
	if self.window_height >= 10 and self.window_width >= 35:
	config.margin = 2
	if not config.resizing:
	self.update_windows()
	self.active_screen.display()
	if self.choice_q.qsize() > 0:
	self.choice_processor(
	self.menu_window,
	self.active_screen.get_screen_id(),
	self.choice_q.get())
	if self.screen_q.qsize() > 0:
	self.screen_q.get()
	self.switch_q.put(1)
	if self.switch_q.qsize() > 0:
	self.switch_q.get()
	self.switch_screen(config.use_python_dialog)
	if len(self.tui_screens) == 0:
	self.active_screen = self.menu_screen
	else:
	self.active_screen = self.tui_screens[-1]
	if not isinstance(self.active_screen, tui_screen.DialogScreen):
	run_monitor, last_time = utils.stopwatch(last_time, 2.5)
	if run_monitor:
	self.logos.monitor()
	self.task_processor(self, task="PID")
	if isinstance(self.active_screen, tui_screen.CursesScreen):
	self.refresh()
	elif self.window_width >= 10:
	if self.window_width < 10:
	config.margin = 1 # Avoid drawing errors on very small screens
	self.draw_resize_screen()
	elif self.window_width < 10:
	config.margin = 0 # Avoid drawing errors on very small screens
	def run(self):
	try:
	self.init_curses()
	self.display()
	except KeyboardInterrupt:
	self.end_curses()
	signal.signal(signal.SIGINT, self.end)
	finally:
	self.end_curses()
	signal.signal(signal.SIGINT, self.end)

(Given the hope of simplifying our queue/event code, many of these lines could be squashed/removed.) The task processor code in tui_app and in gui_app could also be brought into the abstract class. I would also hope that the choice_processor code in tui_app.py might find its way there.

@n8marti has handled the GUI, so I will leave that to him. (Given your review, you might be the third person we've needed: someone who understands both the TUI and the GUI, haha.)

I originally tried to code for the various UIs particularly in msg.py. This eventually got away from me and found its way back in msg.status(). There's likely a fair chunk of room for messaging to be brought into the abstract class given how much code is relatively unused in that module and how msg.status is accounting for each UI. The abstract class lets us do that without all the if/elif.

General Comments

I had also tried this in installer, but the GUI needed enough odds and ends to be separated at the time. Now that we have our working base, I think it'd be great to try to reel in the various odd bits and make these more united, all in the spirit of #147.

As mentioned elsewhere, this would also be helpful for #2 and #87, and for drastically improving code reusability/maintenance. Given your further comments about the suggested config changes, that would go well with #187. While I think all these issues are too much for one PR, I do think we could lump #147 and #187 into this PR's scope as a way of refactoring our code.

Thinking Out Loud

This framework might enable me to further simplify the various calls within tui_app to tui_screen. tui_curses and tui_dialog are fairly static at this point. There are some parts of tui_screen that need to be abstracted, particularly in the console_screen. I've also considered changing the tui_screen class to utilize a method of the tui_app that flags the need for tui_app.refresh to be run again.