Customizing Anaconda

• Extract Red Hat Enterprise Linux ISO.
• Create a new boot image containing your customizations.

• Customize the default options.
• Add more options.
• Change the visual style (color and background).

• menuentry - Defines the title of the entry. It is specified in single or double quotes (' or "). You can use the --class option to group menu entries into different classes, which can then be styled differently using GRUB2 themes.

  Note

  You must enclose each menu entry definition in curly braces ({}).

• linux - Defines the kernel that boots (/images/pxeboot/vmlinuz in the example) and the other additional options, if any. You can customize these options to change the behavior of the boot entry. For details about the options that are applicable to Anaconda, see Automatically installing RHEL. One of the notable options is inst.ks= that allows you to specify a location of a Kickstart file. You can place a Kickstart file on the boot ISO image and use the inst.ks= option to specify its location; for example, you can place a kickstart.ks file into the image’s root directory and use inst.ks=hd:LABEL=RHEL-10-0-BaseOS-x86_64:/kickstart.ks. You can also use dracut options which are listed on the dracut.cmdline(7) man page.

  Important

  When using a disk label to refer to a certain drive, for example, inst.stage2=hd:LABEL=RHEL-10-0-BaseOS-x86_64, replace all spaces with \x20.

• initrd - Location of the initial RAM disk (initrd) image to be loaded. Other options used in the grub.cfg configuration file are:

  • set timeout - determines how long is the boot menu displayed before the default menu entry is automatically used. The default value is 60, which means the menu is displayed for 60 seconds. Setting this value to -1 disables the timeout completely.

    Note

    Setting the timeout to 0 is useful when performing a headless installation, because this setting immediately activates the default boot entry.

• submenu - A submenu block allows you to create a sub-menu and group some entries under it, instead of displaying them in the main menu. The Troubleshooting submenu in the default configuration contains entries for rescuing an existing system. The title of the entry is in single or double quotes (' or "). The submenu block contains one or more menuentry definitions as described above, and the entire block is enclosed in curly braces ({}). For example:

  submenu 'Submenu title' {
    menuentry 'Submenu option 1' {
      linux /images/pxeboot/vmlinuz inst.stage2=hd:LABEL=RHEL-10-0-BaseOS-x86_64 nomodeset quiet
      initrd /images/pxeboot/initrd.img
    }
    menuentry 'Submenu option 2' {
      linux /images/pxeboot/vmlinuz inst.stage2=hd:LABEL=RHEL-10-0-BaseOS-x86_64 inst.rescue quiet
      initrd /images/pxeboot/initrd.img
    }
  }

  Copy to Clipboard Toggle word wrap
• set default - Determines the default entry. The entry numbers start from 0. If you want to make the third entry the default one, use set default=2 and so on.
• theme - Determines the directory which contains GRUB2 theme files. You can use the themes to customize visual aspects of the boot loader - background, fonts, and colors of specific elements.

• menuentry - Defines the title of the entry. It is specified in single or double quotes (' or "). You can use the --class option to group menu entries into different classes, which can then be styled differently by using GRUB2 themes.

  Note

  As shown in the above example, you must enclose each menu entry definition in curly braces ({}).

• linuxefi - Defines the kernel that boots (/images/pxeboot/vmlinuz from the example) and the other additional options, if any.

  You can customize these options to change the behavior of the boot entry.

  One of the notable options is inst.ks=, which allows you to specify a location of a Kickstart file. You can place a Kickstart file on the boot ISO image and use the inst.ks= option to specify its location; for example, you can place a kickstart.ks file into the image’s root directory and use inst.ks=hd:LABEL=RHEL-10-0-BaseOS-x86_64:/kickstart.ks.

  You can also use dracut options which are listed on the dracut.cmdline(7) man page on your system.

  Important

  When using a disk label to refer to a certain drive, for example, inst.stage2=hd:LABEL=RHEL-10-BaseOS-x86_64, replace all spaces with \x20.

• initrdefi - Location of the initial RAM disk (initrd) image to be loaded.

• set timeout - Determines how long is the boot menu displayed before the default menu entry is automatically used. The default value is 60, which means the menu is displayed for 60 seconds. Setting this value to -1 disables the timeout completely.

  Note

  Setting the timeout to 0 is useful when performing a headless installation, because this setting immediately activates the default boot entry.

• submenu - A submenu block allows you to create a sub-menu and group some entries under it, instead of displaying them in the main menu. The Troubleshooting submenu in the default configuration contains entries for rescuing an existing system.

  The title of the entry is in single or double quotes (' or ").

  The submenu block contains one or more menuentry definitions as described above, and the entire block is enclosed in curly braces ({}) For example:

  submenu 'Submenu title' {
    menuentry 'Submenu option 1' {
      linuxefi /images/pxeboot/vmlinuz inst.stage2=hd:LABEL=RHEL-10-0-BaseOS-x86_64 nomodeset quiet
      initrdefi /images/pxeboot/initrd.img
    }
    menuentry 'Submenu option 2' {
      linuxefi /images/pxeboot/vmlinuz inst.stage2=hd:LABEL=RHEL-10-0-BaseOS-x86_64 inst.rescue quiet
      initrdefi /images/pxeboot/initrd.img
    }
  }

  Copy to Clipboard Toggle word wrap
• set default - Determines the default entry. The entry numbers start from 0. If you want to make the third entry the default one, use set default=2 and so on.
• theme - Determines the directory which contains GRUB2 theme files. You can use the themes to customize visual aspects of the boot loader - background, fonts, and colors of specific elements.

• You have downloaded and extracted the ISO image.

• You have created your own branding material.

  For information about downloading and extracting boot images, see Extracting Red Hat Enterprise Linux boot images.

• pykickstart - parses and validates the Kickstart files. Also, provides data structure that stores values that drive the installation.
• dnf - the package manager that installs packages and resolves dependencies
• blivet - handles all activities related to storage management
• pyanaconda - contains the user interface and modules for Anaconda, such as keyboard and timezone selection, network configuration, and user creation. Also provides various utilities to perform system-oriented functions
• python-meh - contains an exception handler that gathers and stores additional system information in case of a crash and passes this information to the libreport library, which itself is a part of the ABRT Project
• dasbus - enables communication between the D-Bus library with modules of anaconda and with external components
• python-simpleline - text UI framework library to manage user interaction in the Anaconda text mode
• gtk - the Gnome toolkit library for creating and managing GUI

• Boss - manages the internal module discovery, lifecycle, and coordination
• Localization - manages locales
• Network - handles network
• Payloads - handles data for installation in different formats, such as rpm, ostree, tar and other installation formats. Payloads manage the sources of data for installation; sources can vary in format such as CD-ROM, HDD, NFS, URLs, and other sources
• Security - manages security related aspects
• Services - handles services
• Storage - manages storage by using blivet
• Subscription - handles the subscription-manager tool and Red Hat Lightspeed.
• Timezone - deals with time, date, zones, and time synchronization.
• Users - creates users and groups.

• Flexibility to follow the installer screens.
• Flexibility to retain the default settings.
• Provides an overview of the configured values.
• Supports extensibility. You can add hubs without the need to reorder anything and can resolve some complex ordering dependencies.
• Supports installation in graphical and text mode.

• ready - states whether or not you can visit a spoke. For example, when the installer is configuring a package source, the spoke is colored in gray, and you cannot access it until the configuration is complete.
• completed - marks whether or not the spoke is complete (all required values are set).
• mandatory - determines whether you must visit the spoke before continuing the installation; for example, you must visit the Installation Destination spoke, even if you want to use automatic disk partitioning
• status - provides a short summary of values configured within the spoke (displayed under the spoke name in the hub)

• program with asynchronous calls and return handlers
• A program with synchronous calls that makes the caller wait until the call is complete.

• Support for each interface (graphical interface and text interface) is available in a separate subpackage and these subpackages are named gui for the graphical interface and tui for the text-based interface.
• The gui and tui packages contain a spokes subpackage. ^[1]
• Modules contained in the packages have an arbitrary name.
• The gui/ and tui/ directories contain Python modules with any name.
• There is a service that performs the actual work of the addon. This service can be written in Python or any other language.
• The service implements support for D-Bus and Kickstart.
• The addon contains files that enable automatic startup of the service.

• builderObjects - lists all top-level objects from the spoke’s .glade file that should be exposed to the spoke with their children objects (recursively). In case everything should be exposed to the spoke, the list should be empty.
• mainWidgetName - contains the id of the main window widget (Add Link) as defined in the .glade file.
• uiFile - contains the name of the .glade file.
• category - contains the class of the category the spoke belongs to.
• icon - contains the identifier of the icon that will be used for the spoke on the hub.
• title - defines the title that will be used for the spoke on the hub.

Prerequisites

• Your add-on includes support for Kickstart. See Anaconda add-on structure.
• Install the anaconda-widgets and anaconda-widgets-devel packages, which contain Gtk widgets specific for Anaconda, such as SpokeWindow.

Procedure

• Create the following modules with all required definitions to add support for the Add-on graphical user interface (GUI), according to the following examples.

  # will never be translated
  _ = lambda x: x
  N_ = lambda x: x
  
  # the path to addons is in sys.path so we can import things from org_fedora_hello_world
  from org_fedora_hello_world.gui.categories.hello_world import HelloWorldCategory
  from pyanaconda.ui.gui.spokes import NormalSpoke
  
  # export only the spoke, no helper functions, classes or constants
  all = ["HelloWorldSpoke"]
  
  class HelloWorldSpoke(FirstbootSpokeMixIn, NormalSpoke):
      """
      Class for the Hello world spoke. This spoke will be in the Hello world
      category and thus on the Summary hub. It is a very simple example of a unit
      for the Anaconda's graphical user interface. Since it is also inherited form
      the FirstbootSpokeMixIn, it will also appear in the Initial Setup (successor
      of the Firstboot tool).
  
      :see: pyanaconda.ui.common.UIObject
      :see: pyanaconda.ui.common.Spoke
      :see: pyanaconda.ui.gui.GUIObject
      :see: pyanaconda.ui.common.FirstbootSpokeMixIn
      :see: pyanaconda.ui.gui.spokes.NormalSpoke
  
      """
  
      # class attributes defined by API #
  
      # list all top-level objects from the .glade file that should be exposed
      # to the spoke or leave empty to extract everything
      builderObjects = ["helloWorldSpokeWindow", "buttonImage"]
  
      # the name of the main window widget
      mainWidgetName = "helloWorldSpokeWindow"
  
      # name of the .glade file in the same directory as this source
      uiFile = "hello_world.glade"
  
      # category this spoke belongs to
      category = HelloWorldCategory
  
      # spoke icon (will be displayed on the hub)
      # preferred are the -symbolic icons as these are used in Anaconda's spokes
      icon = "face-cool-symbolic"
  
      # title of the spoke (will be displayed on the hub)
      title = N_("_HELLO WORLD")

  Copy to Clipboard Toggle word wrap

  The __all__ attribute exports the spoke class, followed by the first lines of its definition including definitions of attributes previously mentioned in GUI Add-on basic features. These attribute values are referencing widgets defined in the com_example_hello_world/gui/spokes/hello.glade file. Two other notable attributes are present:

• category, which has its value imported from the HelloWorldCategory class from the com_example_hello_world.gui.categories module. The HelloWorldCategory that the path to add-ons is in sys.path so that values can be imported from the com_example_hello_world package. The category attribute is part of the N_ function name, which marks the string for translation; but returns the non-translated version of the string, as the translation happens in a later stage.

• title, which contains one underscore in its definition. The title attribute underscore marks the beginning of the title itself and makes the spoke reachable by using the Alt+H keyboard shortcut.

  What usually follows the header of the class definition and the class attributes definitions is the constructor that initializes an instance of the class. In case of the Anaconda graphical interface objects, there are two methods initializing a new instance: the __init__ method and the initialize method.

  The reason behind two such functions is that the GUI objects may be created in memory at one time and fully initialized at a different time, as the spoke initialization could be time consuming. Therefore, the __init__ method should only call the parent’s __init__ method and, for example, initialize non-GUI attributes. On the other hand, the initialize method that is called when the installer’s graphical user interface initializes should finish the full initialization of the spoke.

  In the Hello World add-on example, define these two methods as follows. Note the number and description of the arguments passed to the __init__ method. For example:

  def __init__(self, data, storage, payload):
      """
      :see: pyanaconda.ui.common.Spoke.init
      :param data: data object passed to every spoke to load/store data
      from/to it
      :type data: pykickstart.base.BaseHandler
      :param storage: object storing storage-related information
      (disks, partitioning, boot loader, etc.)
      :type storage: blivet.Blivet
      :param payload: object storing packaging-related information
      :type payload: pyanaconda.packaging.Payload
  
      """
  
      NormalSpoke.init(self, data, storage, payload)
      self._hello_world_module = HELLO_WORLD.get_proxy()
  
  def initialize(self):
      """
      The initialize method that is called after the instance is created.
      The difference between init and this method is that this may take
      a long time and thus could be called in a separate thread.
      :see: pyanaconda.ui.common.UIObject.initialize
      """
      NormalSpoke.initialize(self)
      self._entry = self.builder.get_object("textLines")
      self._reverse = self.builder.get_object("reverseCheckButton")

  Copy to Clipboard Toggle word wrap

  The data parameter passed to the __init__ method is the in-memory tree-like representation of the Kickstart file where all data is stored. In one of the ancestors' __init__ methods it is stored in the self.data attribute, which allows all other methods in the class to read and modify the structure.

  Note

  The storage object is no longer usable as of RHEL10. If your add-on needs to interact with storage configuration, use the Storage DBus module.

  Because the HelloWorldData class has already been defined in The Hello World addon example, there already is a subtree in self.data for this add-on. Its root, an instance of the class, is available as self.data.addons.com_example_hello_world.

  Another action that an ancestor’s __init__ does is initializing an instance of the GtkBuilder with the spoke’s .glade file and storing it as self.builder. The initialize method uses this to get the GtkTextEntry used to show and modify the text from the Kickstart file’s %addon section.

  The __init__ and initialize methods are both important when the spoke is created. However, the main role of the spoke is to be visited by a user who wants to change or review the spoke’s values shows and sets. To enable this, three other methods are available:

• refresh - called when the spoke is about to be visited; this method refreshes the state of the spoke, mainly its UI elements, to ensure that the displayed data matches internal data structures and, with that, to ensure that current values stored in the self.data structure are displayed.
• apply - called when the spoke is left and used to store values from UI elements back into the self.data structure.

• execute - called when users leave the spoke and used to perform any runtime changes based on the new state of the spoke.

  These functions are implemented in the sample Hello World add-on in the following way:

  def refresh(self):
      """
      The refresh method that is called every time the spoke is displayed.
      It should update the UI elements according to the contents of
      internal data structures.
      :see: pyanaconda.ui.common.UIObject.refresh
      """
      lines = self._hello_world_module.Lines
      self._entry.get_buffer().set_text("".join(lines))
      reverse = self._hello_world_module.Reverse
      self._reverse.set_active(reverse)
  
  def apply(self):
      """
      The apply method that is called when user leaves the spoke. It should
      update the D-Bus service with values set in the GUI elements.
      """
      buf = self._entry.get_buffer()
      text = buf.get_text(buf.get_start_iter(),
                          buf.get_end_iter(),
                          True)
      lines = text.splitlines(True)
      self._hello_world_module.SetLines(lines)
  
      self._hello_world_module.SetReverse(self._reverse.get_active())
  
  def execute(self):
    """
    The execute method that is called when the spoke is exited. It is
    supposed to do all changes to the runtime environment according to
    the values set in the GUI elements.
  
    """
  
    # nothing to do here
    pass

  Copy to Clipboard Toggle word wrap

  You can use several additional methods to control the spoke’s state:

• ready - determines whether the spoke is ready to be visited; if the value is "False", the spoke is not accessible, for example, the Package Selection spoke before a package source is configured.
• completed - determines if the spoke has been completed.

• mandatory - determines if the spoke is mandatory or not, for example, the Installation Destination spoke, which must always be visited, even if you want to use automatic partitioning.

  All of these attributes need to be dynamically determined based on the current state of the installation process. Below is a sample implementation of these methods in the Hello World add-on, which requires a certain value to be set in the text attribute of the HelloWorldData class:

  @property
  def ready(self):
      """
      The ready property reports whether the spoke is ready, that is, can be visited
      or not. The spoke is made (in)sensitive based on the returned value of the ready
      property.
  
      :rtype: bool
  
      """
  
      # this spoke is always ready
      return True
  
  
  @property
  def mandatory(self):
      """
      The mandatory property that tells whether the spoke is mandatory to be
      completed to continue in the installation process.
  
      :rtype: bool
  
      """
  
      # this is an optional spoke that is not mandatory to be completed
      return False

  Copy to Clipboard Toggle word wrap

  After these properties are defined, the spoke can control its accessibility and completeness, but it cannot provide a summary of the values configured within - you must visit the spoke to see how it is configured, which may not be desired. For this reason, an additional property called status exists. This property contains a single line of text with a short summary of configured values, which can then be displayed in the hub under the spoke title.

  The status property is defined in the Hello World example add-on as follows:

  @property
  def status(self):
      """
      The status property that is a brief string describing the state of the
      spoke. It should describe whether all values are set and if possible
      also the values themselves. The returned value will appear on the hub
      below the spoke's title.
      :rtype: str
      """
      lines = self._hello_world_module.Lines
      if not lines:
          return _("No text added")
      elif self._hello_world_module.Reverse:
          return _("Text set with {} lines to reverse").format(len(lines))
      else:
          return _("Text set with {} lines").format(len(lines))

  Copy to Clipboard Toggle word wrap

  After defining all properties described in the examples, the add-on has full support for showing a graphical user interface (GUI) as well as Kickstart.

  Note

  The example demonstrated here is very simple and does not contain any controls; knowledge of Python Gtk programming is required to develop a functional, interactive spoke in the GUI.

  One notable restriction is that each spoke must have its own main window - an instance of the SpokeWindow widget. This widget, along with other widgets specific to Anaconda, is found in the anaconda-widgets package. You can find other files required for development of add-ons with GUI support, such as Glade definitions, in the anaconda-widgets-devel package.

  Once your graphical interface support module contains all necessary methods you can continue with the following section to add support for the text-based user interface.

• Does not support cursor movement - instead, it acts like a line printer.
• Does not support any visual enhancements, such as using different colors or fonts, for example.

• title - determines the title of the spoke, similar to the title argument in the GUI.
• category - determines the category of the spoke as a string; the category name is not displayed anywhere, it is only used for grouping.

Prerequisites

• You have created a new set of subpackages under the tui directory as described in Anaconda add-on structure.

Procedure

• Create modules with all required definitions to add support for the add-on text user interface (TUI), according to the following examples:

  class HelloWorldSpoke(NormalTUISpoke):
      # category this spoke belongs to
      category = HelloWorldCategory
  
  def init(self, *args, kwargs): """ Create the representation of the spoke. :see: simpleline.render.screen.UIScreen """ super().init(*args, kwargs)
      self.title = N_("Hello World")
      self._hello_world_module = HELLO_WORLD.get_proxy()
      self._container = None
      self._reverse = False
      self._lines = ""
  
  def initialize(self):
      """
      The initialize method that is called after the instance is created.
      The difference between init and this method is that this may take
      a long time and thus could be called in a separated thread.
  
      :see: pyanaconda.ui.common.UIObject.initialize
      """
      # nothing to do here
      super().initialize()
  
  def setup(self, args=None):
      """
      The setup method that is called right before the spoke is entered.
      It should update its state according to the contents of DBus modules.
  
      :see: simpleline.render.screen.UIScreen.setup
      """
      super().setup(args)
  
      self._reverse = self._hello_world_module.Reverse
      self._lines = self._hello_world_module.Lines
  
      return True
  
  def refresh(self, args=None):
      """
      The refresh method that is called every time the spoke is displayed.
      It should generate the UI elements according to its state.
  
      :see: pyanaconda.ui.common.UIObject.refresh
      :see: simpleline.render.screen.UIScreen.refresh
      """
      super().refresh(args)
  
      self._container = ListColumnContainer(
          columns=1
      )
      self._container.add(
          CheckboxWidget(
              title="Reverse",
              completed=self._reverse
          ),
          callback=self._change_reverse
      )
      self._container.add(
          EntryWidget(
              title="Hello world text",
              value="".join(self._lines)
          ),
          callback=self._change_lines
      )
  
      self.window.add_with_separator(self._container)
  
  def _change_reverse(self, data):
      """
      Callback when user wants to switch checkbox.
      Flip state of the "reverse" parameter which is boolean.
      """
      self._reverse = not self._reverse
  
  def _change_lines(self, data):
      """
      Callback when user wants to input new lines.
      Show a dialog and save the provided lines.
      """
      dialog = Dialog("Lines")
      result = dialog.run()
      self._lines = result.splitlines(True)
  
  def input(self, args, key):
      """
      The input method that is called by the main loop on user's input.
  
      * If the input should not be handled here, return it.
      * If the input is invalid, return InputState.DISCARDED.
      * If the input is handled and the current screen should be refreshed,
        return InputState.PROCESSED_AND_REDRAW.
      * If the input is handled and the current screen should be closed,
        return InputState.PROCESSED_AND_CLOSE.
  
      :see: simpleline.render.screen.UIScreen.input
      """
      if self._container.process_user_input(key):
          return InputState.PROCESSED_AND_REDRAW
  
      if key.lower() == Prompt.CONTINUE:
          self.apply()
          self.execute()
          return InputState.PROCESSED_AND_CLOSE
  
      return super().input(args, key)
  
  def apply(self):
      """
      The apply method is not called automatically for TUI. It should be called
      in input() if required. It should update the contents of internal data
      structures with values set in the spoke.
      """
      self._hello_world_module.SetReverse(self._reverse)
      self._hello_world_module.SetLines(self._lines)
  
  def execute(self):
      """
      The execute method is not called automatically for TUI. It should be called
      in input() if required. It is supposed to do all changes to the runtime
      environment according to the values set in the spoke.
      """
      # nothing to do here
      pass

  Copy to Clipboard Toggle word wrap

  For more details and latest code, see the Hello World Anaconda Addon - GitHub Repository.

  Note

  It is not necessary to override the init method if it only calls the ancestor’s init, but the comments in the example describe the arguments passed to constructors of spoke classes in an understandable way.

  In the previous example:

• The setup method sets up a default value for the internal attribute of the spoke on every entry, which is then displayed by the refresh method, updated by the input method and used by the apply method to update internal data structures.
• The execute method has the same purpose as the equivalent method in the GUI; in this case, the method has no effect.
• The input method is specific to the text interface; there are no equivalents in Kickstart or GUI. The input methods are responsible for user interaction.
• The input method processes the entered string and takes action depending on its type and value. The above example asks for any value and then stores it as an internal attribute (key). In more complex add-ons, you typically need to perform some non-trivial actions, such as parse letters as actions, convert numbers into integers, show additional screens or toggle boolean values.

• The return value of the input class must be either the InputState enum or the input string itself, in case this input should be processed by a different screen. In contrast to the graphical mode, the apply and execute methods are not called automatically when leaving the spoke; they must be called explicitly from the input method. The same applies to closing (hiding) the spoke’s screen: it must be called explicitly from the close method.

  To show another screen, for example if you need additional information that was entered in a different spoke, you can instantiate another TUIObject and use ScreenHandler.push_screen_modal() to show it.

  Due to restrictions of the text-based interface, TUI spokes tend to have a very similar structure, that consists of a list of checkboxes or entries that should be checked or unchecked and populated by the user.

Prerequisites

• You have added a new set of subpackages under the TUI directory, as described in Anaconda add-on structure.

Procedure

• Create modules with all required definitions to add support for the Add-on text user interface (TUI), according to the following examples.

  class HelloWorldEditSpoke(NormalTUISpoke):
      """Example class demonstrating usage of editing in TUI"""
      category = HelloWorldCategory
  
      def init(self, data, storage, payload):
          """
          :see: simpleline.render.screen.UIScreen
          :param data: data object passed to every spoke to load/store data
                       from/to it
          :type data: pykickstart.base.BaseHandler
          :param storage: object storing storage-related information
                          (disks, partitioning, boot loader, etc.)
          :type storage: blivet.Blivet
          :param payload: object storing packaging-related information
          :type payload: pyanaconda.packaging.Payload
          """
          super().init(self, *args, **Kwargs)
  
          self.title = N_("Hello World Edit")
          self._container = None
  
          # values for user to set
          self._checked = False
          self._unconditional_input = ""
          self._conditional_input = ""
  
      def refresh(self, args=None):
          """
          The refresh method that is called every time the spoke is displayed.
          It should update the UI elements according to the contents of self.data.
          :see: pyanaconda.ui.common.UIObject.refresh
          :see: simpleline.render.screen.UIScreen.refresh
          :param args: optional argument that may be used when the screen is
                       scheduled
          :type args: anything
          """
          super().refresh(args)
          self._container = ListColumnContainer(columns=1)
  
          # add ListColumnContainer to window (main window container)
          # this will automatically add numbering and will call callbacks when required
          self.window.add(self._container)
  
          self._container.add(CheckboxWidget(title="Simple checkbox", completed=self._checked),
                              callback=self._checkbox_called)
          self._container.add(EntryWidget(title="Unconditional text input",
                                          value=self._unconditional_input),
                              callback=self._get_unconditional_input)
  
          # show conditional input only if the checkbox is checked
          if self._checked:
              self._container.add(EntryWidget(title="Conditional password input",
                                              value="Password set" if self._conditional_input
                                              else ""),
                                  callback=self._get_conditional_input)
  
          self.window.add_with_separator(self._container)
  
      def _checkbox_called(self, data):  # pylint: disable=unused-argument
          """Callback when user wants to switch checkbox.
  
          :param data: can be passed when adding callback in container (not used here)
          :type data: anything
          """
          self._checked = not self._checked
  
      def _get_unconditional_input(self, data):  # pylint: disable=unused-argument
          """Callback when the user wants to set unconditional input.
  
          :param data: can be passed when adding callback in container (not used here)
          :type data: anything
          """
          dialog = Dialog(
              "Unconditional input",
              conditions=[self._check_user_input]
          )
          self._unconditional_input = dialog.run()
  
      def _get_conditional_input(self, data):  # pylint: disable=unused-argument
          """Callback when the user wants to set conditional input.
  
          :param data: can be passed when adding callback in container (not used here)
          :type data: anything
          """
          dialog = PasswordDialog(
              "Unconditional password input",
              policy_name=PASSWORD_POLICY_ROOT
          )
          self._conditional_input = dialog.run()
  
      def _check_user_input(self, user_input, report_func):
          """Check if the user has written a valid value.
  
          :param user_input: user input for validation
          :type user_input: str
  
          :param report_func: function for reporting errors on user input
          :type report_func: func with one param
          """
          if re.match(r'^\w+$', user_input):
              return True
          else:
              report_func("You must set at least one word")
              return False
  
      def input(self, args, key):
          """
          The input method that is called by the main loop on user's input.
  
          :param args: optional argument that may be used when the screen is
                       scheduled
          :type args: anything
          :param key: user's input
          :type key: unicode
          :return: if the input should not be handled here, return it, otherwise
                   return InputState.PROCESSED or InputState.DISCARDED if the input was
                   processed successfully or not respectively
          :rtype: enum InputState
          """
          if self._container.process_user_input(key):
              return InputState.PROCESSED_AND_REDRAW
          else:
              return super().input(args, key)
  
  
      @property
      def completed(self):
          # completed if user entered something non-empty to the Conditioned input
          return bool(self._conditional_input)
  
      @property
      def status(self):
          return "Hidden input %s" % ("entered" if self._conditional_input
                                      else "not entered")
  
      def apply(self):
          # nothing needed here, values are set in the self.args tree
          pass

  Copy to Clipboard Toggle word wrap

  For more details and latest code, see the Hello World NormalTUISpoke - GitHub Repository.

Prerequisites

• You created an Add-on.
• You have access to your D-Bus files.
• You have installed the lorax package.