Send patches - preferably formatted by git format-patch - to patches at archlinux32 dot org.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--archinstall/__init__.py2
-rw-r--r--archinstall/lib/menu/list_manager.py269
-rw-r--r--archinstall/lib/menu/menu.py20
3 files changed, 285 insertions, 6 deletions
diff --git a/archinstall/__init__.py b/archinstall/__init__.py
index 8c64a1f3..6a41bd49 100644
--- a/archinstall/__init__.py
+++ b/archinstall/__init__.py
@@ -34,6 +34,8 @@ from .lib.storage import *
from .lib.systemd import *
from .lib.user_interaction import *
from .lib.menu import Menu
+from .lib.menu.list_manager import ListManager
+from .lib.menu.text_input import TextInput
from .lib.menu.selection_menu import (
GlobalMenu,
Selector,
diff --git a/archinstall/lib/menu/list_manager.py b/archinstall/lib/menu/list_manager.py
new file mode 100644
index 00000000..e307e41f
--- /dev/null
+++ b/archinstall/lib/menu/list_manager.py
@@ -0,0 +1,269 @@
+#!/usr/bin/python
+"""
+# Purpose
+ListManager is a widget based on `menu` which allows the handling of repetitive operations in a list.
+Imagine you have a list and want to add/copy/edit/delete their elements. With this widget you will be shown the list
+```
+Vamos alla
+
+Use ESC to skip
+
+
+> uno : 1
+dos : 2
+tres : 3
+cuatro : 4
+==>
+Confirm and exit
+Cancel
+(Press "/" to search)
+```
+Once you select one of the elements of the list, you will be promted with the action to be done to the selected element
+```
+
+uno : 1
+dos : 2
+> tres : 3
+cuatro : 4
+==>
+Confirm and exit
+Cancel
+(Press "/" to search)
+
+Select an action for < {'tres': 3} >
+
+
+Add
+Copy
+Edit
+Delete
+> Cancel
+```
+You execute the action for this element (which might or not involve user interaction) and return to the list main page
+till you call one of the options `confirm and exit` which returns the modified list or `cancel` which returns the original list unchanged.
+If the list is empty one action can be defined as default (usually Add). We call it **null_action**
+YOu can also define a **default_action** which will appear below the separator, not tied to any element of the list. Barring explicit definition, default_action will be the null_action
+```
+==>
+Add
+Confirm and exit
+Cancel
+(Press "/" to search)
+```
+The default implementation can handle simple lists and a key:value dictionary. The default actions are the shown above.
+A sample of basic usage is included at the end of the source.
+
+More sophisticaded uses can be achieved by
+* changing the action list and the null_action during intialization
+```
+ opciones = ListManager('Vamos alla',opciones,[str(_('Add')),str(_('Delete'))],_('Add')).run()
+```
+* And using following methods to overwrite/define user actions and other details:
+* * `reformat`. To change the appearance of the list elements
+* * `action_list`. To modify the content of the action list once an element is defined. F.i. to avoid Delete to appear for certain elements, or to add/modify action based in the value of the element.
+* * `exec_action` which contains the actual code to be executed when an action is selected
+
+The contents in the base class of this methods serve for a very basic usage, and are to be taken as samples. Thus the best use of this class would be to subclass in your code
+
+```
+ class ObjectList(archinstall.ListManager):
+ def __init__(prompt,list):
+ self.ObjectAction = [... list of actions ...]
+ self.ObjectNullAction = one ObjectAction
+ super().__init__(prompt,list,ObjectActions,ObjectNullAction)
+ def reformat(self):
+ ... beautfy the output of the list
+ def action_list(self):
+ ... if you need some changes to the action list based on self.target
+ def exec_action(self):
+ if self.action == self.ObjectAction[0]:
+ performFirstAction(self.target, ...)
+
+ ...
+ resultList = ObjectList(prompt,originallist).run()
+```
+
+"""
+
+from .text_input import TextInput
+from .menu import Menu
+from ..general import RequirementError
+from os import system
+from copy import copy
+
+class ListManager:
+ def __init__(self,prompt :str, base_list :list ,base_actions :list = None,null_action :str = None, default_action :str = None):
+ """
+ param :prompt Text which will appear at the header
+ type param: string | DeferredTranslation
+
+ param :base:_list list/dict of option to be shown / mainpulated
+ type param: list | dict
+
+ param base_actions an alternate list of actions to the items of the object
+ type param: list
+
+ param: null_action action which will be taken (if any) when base_list is empty
+ type param: string
+
+ param: default_action action which will be presented at the bottom of the list. Shouldn't need a target. If not present, null_action is set there.
+ Both Null and Default actions can be defined outside the base_actions list, as long as they are launched in exec_action
+ type param: string
+ """
+
+ if not null_action and len(base_list) == 0:
+ raise RequirementError('Data list for ListManager can not be empty if there is no null_action')
+
+ self.prompt = prompt if prompt else _('Choose an object from the list')
+ self.null_action = str(null_action)
+ if not default_action:
+ self.default_action = self.null_action
+ else:
+ self.default_action = str(default_action)
+ self.cancel_action = str(_('Cancel'))
+ self.confirm_action = str(_('Confirm and exit'))
+ self.separator = '==>'
+ self.bottom_list = [self.confirm_action,self.cancel_action]
+ self.bottom_item = [self.cancel_action]
+ self.base_actions = base_actions if base_actions else [str(_('Add')),str(_('Copy')),str(_('Edit')),str(_('Delete'))]
+
+ self.base_data = base_list
+ self.data = copy(base_list) # as refs, changes are immediate
+ # default values for the null case
+ self.target = None
+ self.action = self.null_action
+ if len(self.data) == 0:
+ self.exec_action()
+
+ def run(self):
+ while True:
+ self.data_formatted = self.reformat()
+ options = self.data_formatted + [self.separator]
+ if self.default_action:
+ options += [self.default_action]
+ options += self.bottom_list
+ system('clear')
+ target = Menu(self.prompt,
+ options,
+ sort=False,
+ clear_screen=False,
+ clear_menu_on_exit=False).run()
+
+ if not target or target in self.bottom_list:
+ break
+ if target and target == self.separator:
+ continue
+ if target and target == self.default_action:
+ target = None
+ self.target = None
+ self.action = self.default_action
+ self.exec_action()
+ continue
+ if isinstance(self.data,dict):
+ key = list(self.data.keys())[self.data_formatted.index(target)]
+ self.target = {key: self.data[key]}
+ else:
+ self.target = self.data[self.data_formatted.index(target)]
+ # Possible enhacement. If run_actions returns false a message line indicating the failure
+ self.run_actions(target)
+
+ if not target or target == self.cancel_action: # TODO dubious
+ return self.base_data # return the original list
+ else:
+ return self.data
+
+ def run_actions(self,prompt_data=None):
+ options = self.action_list() + self.bottom_item
+ prompt = _("Select an action for < {} >").format(prompt_data if prompt_data else self.target)
+ self.action = Menu(prompt,
+ options,
+ sort=False,
+ skip=False,
+ clear_screen=False,
+ clear_menu_on_exit=False,
+ preset_values=self.bottom_item,
+ show_search_hint=False).run()
+ if self.action == self.cancel_action:
+ return False
+ else:
+ return self.exec_action()
+ """
+ The following methods are expected to be overwritten by the user if the needs of the list are beyond the simple case
+ """
+
+ def reformat(self):
+ """
+ method to get the data in a format suitable to be shown
+ It is executed once for run loop and processes the whole self.data structure
+ """
+ if isinstance(self.data,dict):
+ return list(map(lambda x:f"{x} : {self.data[x]}",self.data))
+ else:
+ return list(map(lambda x:str(x),self.data))
+
+ def action_list(self):
+ """
+ can define alternate action list or customize the list for each item.
+ Executed after any item is selected, contained in self.target
+ """
+ return self.base_actions
+
+ def exec_action(self):
+ """
+ what's executed one an item (self.target) and one action (self.action) is selected.
+ Should be overwritten by the user
+ The result is expected to update self.data in this routine, else it is ignored
+ The basic code is useful for simple lists and dictionaries (key:value pairs, both strings)
+ """
+ # TODO guarantee unicity
+
+ if isinstance(self.data,list):
+ if self.action == str(_('Add')):
+ self.target = TextInput(_('Add :'),None).run()
+ self.data.append(self.target)
+ if self.action == str(_('Copy')):
+ while True:
+ target = TextInput(_('Copy to :'),self.target).run()
+ if target != self.target:
+ self.data.append(self.target)
+ break
+ elif self.action == str(_('Edit')):
+ tgt = self.target
+ idx = self.data.index(self.target)
+ result = TextInput(_('Edite :'),tgt).run()
+ self.data[idx] = result
+ elif self.action == str(_('Delete')):
+ del self.data[self.data.index(self.target)]
+ elif isinstance(self.data,dict):
+ # allows overwrites
+ if self.target:
+ origkey,origval = list(self.target.items())[0]
+ else:
+ origkey = None
+ origval = None
+ if self.action == str(_('Add')):
+ key = TextInput(_('Key :'),None).run()
+ value = TextInput(_('Value :'),None).run()
+ self.data[key] = value
+ if self.action == str(_('Copy')):
+ while True:
+ key = TextInput(_('Copy to new key:'),origkey).run()
+ if key != origkey:
+ self.data[key] = origval
+ break
+ elif self.action == str(_('Edit')):
+ value = TextInput(_(f'Edit {origkey} :'),origval).run()
+ self.data[origkey] = value
+ elif self.action == str(_('Delete')):
+ del self.data[origkey]
+
+ return True
+
+
+if __name__ == "__main__":
+ # opciones = ['uno','dos','tres','cuatro']
+ # opciones = archinstall.list_mirrors()
+ opciones = {'uno':1,'dos':2,'tres':3,'cuatro':4}
+ # acciones = ['editar','borrar','aƱadir']
+ opciones = ListManager('Vamos alla',opciones,None,_('Add')).run()
+ print(opciones)
diff --git a/archinstall/lib/menu/menu.py b/archinstall/lib/menu/menu.py
index 1d5d497e..d7b1605d 100644
--- a/archinstall/lib/menu/menu.py
+++ b/archinstall/lib/menu/menu.py
@@ -1,6 +1,7 @@
from typing import Dict, List, Union, Any, TYPE_CHECKING
from archinstall.lib.menu.simple_menu import TerminalMenu
+
from ..exceptions import RequirementError
from ..output import log
@@ -22,7 +23,8 @@ class Menu(TerminalMenu):
default_option :str = None,
sort :bool = True,
preset_values :Union[str, List[str]] = None,
- cursor_index :int = None
+ cursor_index :int = None,
+ **kwargs
):
"""
Creates a new menu
@@ -51,6 +53,8 @@ class Menu(TerminalMenu):
:param cursor_index: The position where the cursor will be located. If it is not in range (number of elements of the menu) it goes to the first position
:type cursor_index: int
+
+ :param kwargs : any SimpleTerminal parameter
"""
# we guarantee the inmutability of the options outside the class.
# an unknown number of iterables (.keys(),.values(),generator,...) can't be directly copied, in this case
@@ -103,19 +107,23 @@ class Menu(TerminalMenu):
cursor = "> "
main_menu_cursor_style = ("fg_cyan", "bold")
main_menu_style = ("bg_blue", "fg_gray")
-
+ # defaults that can be changed up the stack
+ kwargs['clear_screen'] = kwargs.get('clear_screen',True)
+ kwargs['show_search_hint'] = kwargs.get('show_search_hint',True)
+ kwargs['cycle_cursor'] = kwargs.get('cycle_cursor',True)
super().__init__(
menu_entries=self.menu_options,
title=menu_title,
menu_cursor=cursor,
menu_cursor_style=main_menu_cursor_style,
menu_highlight_style=main_menu_style,
- cycle_cursor=True,
- clear_screen=True,
+ # cycle_cursor=True,
+ # clear_screen=True,
multi_select=multi,
- show_search_hint=True,
+ # show_search_hint=True,
preselected_entries=self.preset_values,
- cursor_index=self.cursor_index
+ cursor_index=self.cursor_index,
+ **kwargs,
)
def _show(self):