      """ A read only text widget that redirects a standard tk.Text widget's insert and delete
      attributes.
      Source: https://stackoverflow.com/questions/3842155
      """
      def __init__(self, *args, **kwargs):
          super().__init__(*args, **kwargs)
          self.redirector = WidgetRedirector(self)
          self.insert = self.redirector.register("insert", lambda *args, **kw: "break")
          self.delete = self.redirector.register("delete", lambda *args, **kw: "break")
  
  
  class ConsoleOut(ttk.Frame):  # pylint: disable=too-many-ancestors
      """ The Console out section of the GUI """
  
      def __init__(self, parent, debug):
          logger.debug("Initializing %s: (parent: %s, debug: %s)",
                       self.__class__.__name__, parent, debug)
          ttk.Frame.__init__(self, parent)
          self.pack(side=tk.TOP, anchor=tk.W, padx=10, pady=(2, 0),
                    fill=tk.BOTH, expand=True)
          self.console = ReadOnlyText(self)
          rc_menu = ContextMenu(self.console)
          rc_menu.cm_bind()
          self.console_clear = get_config().tk_vars['consoleclear']
          self.set_console_clear_var_trace()
          self.debug = debug
          self.build_console()
          self.add_tags()
          logger.debug("Initialized %s", self.__class__.__name__)
  
      def set_console_clear_var_trace(self):
          """ Set the trigger actions for the clear console var
              when it has been triggered from elsewhere """
 
</s> remove class ReadOnlyText(tk.Text):  # pylint: disable=too-many-ancestors
    """ A read only text widget that redirects a standard tk.Text widget's insert and delete
    attributes.
    Source: https://stackoverflow.com/questions/3842155
 </s> add class Config():
    """ The centralized configuration class for holding items that should be made available to all
    parts of the GUI.

    This class should be initialized on GUI startup through :func:`initialize_config`. Any further
    access to this class should be through :func:`get_config`.

    Parameters
    ----------
    root: :class:`tkinter.Tk`
        The root Tkinter object
    cli_opts: :class:`lib.gui.options.CliOpts`
        The command line options object
    statusbar: :class:`lib.gui.custom_widgets.StatusBar`
        The GUI Status bar
    session: :class:`lib.gui.stats.Session`
        The current training Session </s> remove 
        self.previewtrain[name][1] = ImageTk.PhotoImage(displayimg)
 </s> add         self._previewtrain[name][1] = ImageTk.PhotoImage(displayimg) </s> remove     def set_console_clear_var_trace(self):
        """ Set the trigger actions for the clear console var
            when it has been triggered from elsewhere """
        logger.debug("Set clear trace")
        self.console_clear.trace("w", self.clear)

    def build_console(self):
        """ Build and place the console """
        logger.debug("Build console")
        self.console.config(width=100, height=6, bg="gray90", fg="black")
        self.console.pack(side=tk.LEFT, anchor=tk.N, fill=tk.BOTH, expand=True)

        scrollbar = ttk.Scrollbar(self, command=self.console.yview)
        scrollbar.pack(side=tk.LEFT, fill="y")
        self.console.configure(yscrollcommand=scrollbar.set)

        self.redirect_console()
        logger.debug("Built console")

    def add_tags(self):
        """ Add tags to text widget to color based on output """
        logger.debug("Adding text color tags")
        self.console.tag_config("default", foreground="#1E1E1E")
        self.console.tag_config("stderr", foreground="#E25056")
        self.console.tag_config("info", foreground="#2B445E")
        self.console.tag_config("verbose", foreground="#008140")
        self.console.tag_config("warning", foreground="#F77B00")
        self.console.tag_config("critical", foreground="red")
        self.console.tag_config("error", foreground="red")

    def redirect_console(self):
        """ Redirect stdout/stderr to console frame """
        logger.debug("Redirect console")
        if self.debug:
            logger.info("Console debug activated. Outputting to main terminal")
        else:
            sys.stdout = SysOutRouter(console=self.console, out_type="stdout")
            sys.stderr = SysOutRouter(console=self.console, out_type="stderr")
        logger.debug("Redirected console")

    def clear(self, *args):  # pylint: disable=unused-argument
        """ Clear the console output screen """
        logger.debug("Clear console")
        if not self.console_clear.get():
            logger.debug("Console not set for clearing. Skipping")
            return
        self.console.delete(1.0, tk.END)
        self.console_clear.set(False)
        logger.debug("Cleared console")
 </s> add     # Constants
    @property
    def root(self):
        """ :class:`tkinter.Tk`: The root tkinter window. """
        return self._constants["root"] </s> remove     """ A container object that autofills columns """
 </s> add     """ A container object that auto-fills columns """ </s> remove     def __init__(self, console=None, out_type=None):
        logger.debug("Initializing %s: (console: %s, out_type: '%s')",
                     self.__class__.__name__, console, out_type)
        self.console = console
        self.out_type = out_type
        self.recolor = re.compile(r".+?(\s\d+:\d+:\d+\s)(?P<lvl>[A-Z]+)\s")
        logger.debug("Initialized %s", self.__class__.__name__)
 </s> add     # GUI Objects
    @property
    def cli_opts(self):
        """ :class:`lib.gui.options.CliOptions`: The command line options for this GUI Session. """
        return self._gui_objects["cli_opts"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
      """ A read only text widget that redirects a standard tk.Text widget's insert and delete
      attributes.
      Source: https://stackoverflow.com/questions/3842155
      """
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
    def __init__(self, root, cli_opts, statusbar, session):
        logger.debug("Initializing %s: (root %s, cli_opts: %s, statusbar: %s, session: %s)",
                     self.__class__.__name__, root, cli_opts, statusbar, session)
        self._constants = dict(
            root=root,
            scaling_factor=self._get_scaling(root),
            default_font=tk.font.nametofont("TkDefaultFont").configure()["family"])
        self._gui_objects = dict(
            cli_opts=cli_opts,
            tk_vars=self._set_tk_vars(),
            project=Project(self, FileHandler),
            tasks=Tasks(self, FileHandler),
            status_bar=statusbar,
            command_notebook=None)  # set in command.py
        self._user_config = UserConfig(None)
        self.session = session
        self._default_font = tk.font.nametofont("TkDefaultFont").configure()["family"]
          logger.debug("Initialized %s", self.__class__.__name__)
  
      def set_console_clear_var_trace(self):
          """ Set the trigger actions for the clear console var
              when it has been triggered from elsewhere """
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 GUI Updates (#940)

* lib.gui: Update icons
* tools.cli: Add video filetype flag to mask input
* lib.gui.popup_configure: Refresh GUI on config save
* lib.gui._config: Add Icon size and load last session options
* lib.gui.control_helper - Add control modification tracking
* lib.gui - Add Projects and Last Session
- Main root title handled by projects
- Add Hotkeys
- Create projects module
- split fsw and fst filetypes
- Add last_session saving

* lib.project
- Documentation
- Ask confirm on closing unsaved project
-Fixups

* Track model folder changes
- Shuffle some globals
- Activate System Verbosity for GUI

* lib.gui.utils - Documentation and clean up
- lib.gui.custom_widgets - Create and document

* Add GUI config option to disable auto loading model stats 
lib/gui/utils.py