cs2tracker 2.1.13__py3-none-any.whl → 2.1.15__py3-none-any.whl

cs2tracker/app/editor_frame.py

@@ -4,24 +4,25 @@ from shutil import copy
 from subprocess import PIPE, STDOUT
 from threading import Thread
 from tkinter import messagebox, ttk
-from urllib.parse import unquote
 
 from nodejs import node
 from ttk_text import ThemedText
 
+from cs2tracker.config import get_config
 from cs2tracker.constants import (
     CONFIG_FILE,
     CONFIG_FILE_BACKUP,
+    DATA_DIR,
     INVENTORY_IMPORT_FILE,
     INVENTORY_IMPORT_SCRIPT,
 )
-from cs2tracker.util import get_config
+from cs2tracker.util.tkinter import centered, size_info
 
 ADD_CUSTOM_ITEM_TITLE = "Add Custom Item"
-ADD_CUSTOM_ITEM_SIZE = "500x220"
+ADD_CUSTOM_ITEM_SIZE = "500x230"
 
 IMPORT_INVENTORY_TITLE = "Import Steam Inventory"
-IMPORT_INVENTORY_SIZE = "500x450"
+IMPORT_INVENTORY_SIZE = "700x350"
 
 IMPORT_INVENTORY_PROCESS_TITLE = "Importing Steam Inventory..."
 IMPORT_INVENTORY_PROCESS_SIZE = "700x500"
@@ -30,15 +31,18 @@ config = get_config()
 
 
 class ConfigEditorFrame(ttk.Frame):
-    def __init__(self, parent):
+    def __init__(self, window):
         """Initialize the configuration editor frame that allows users to view and edit
         the configuration options.
         """
-        super().__init__(parent, padding=15)
+        super().__init__(window, padding=15)
 
-        self.parent = parent
+        self.window = window
+        self.edit_entry = None
         self._add_widgets()
 
+        self.tree.focus_set()
+
     def _add_widgets(self):
         """Configure the main editor frame which displays the configuration options in a
         structured way.
@@ -46,82 +50,176 @@ class ConfigEditorFrame(ttk.Frame):
         self._configure_treeview()
         self.tree.pack(expand=True, fill="both")
 
-        button_frame = ConfigEditorButtonFrame(self, self.tree)
+        button_frame = ConfigEditorButtonFrame(self)
         button_frame.pack(side="bottom", padx=10, pady=(0, 10))
 
-    def _set_cell_value(self, event):
+    def save_config(self):
+        """Save the current configuration from the treeview to the config file."""
+        config.delete_display_sections()
+        for section in self.tree.get_children():
+            config.add_section(section)
+            for item in self.tree.get_children(section):
+                item_name = self.tree.item(item, "text")
+                if section not in ("App Settings", "User Settings"):
+                    config_option = config.name_to_option(item_name, href=True)
+                else:
+                    config_option = config.name_to_option(item_name)
+                value = self.tree.item(item, "values")[0]
+                config.set(section, config_option, value)
+
+        config.write_to_file()
+        if not config.valid:
+            config.load_from_file()
+            self.reload_config_into_tree()
+            messagebox.showerror(
+                "Config Error",
+                f"The configuration is invalid. ({config.last_error})",
+                parent=self.window,
+            )
+        self.window.focus_set()
+        self.tree.focus_set()
+
+    def _save_edit(self, event, row, column):
+        """Save the edited value in the treeview and destroy the entry widget."""
+        self.tree.set(row, column=column, value=event.widget.get())
+        self.save_config()
+        event.widget.destroy()
+
+    def _set_cell_value(self, event, row=None, column=None):
         """
-        Set the value of a cell in the treeview to be editable when double- clicked.
+        Set the value of a cell in the treeview to be editable when double-clicked.
 
         Source: https://stackoverflow.com/questions/75787251/create-an-editable-tkinter-treeview-with-keyword-connection
         """
+        try:
+            if not row or not column:
+                row = self.tree.identify_row(event.y)
+                column = self.tree.identify_column(event.x)
 
-        def save_edit(event):
-            self.tree.set(row, column=column, value=event.widget.get())
-            event.widget.destroy()
+            item_text = self.tree.item(row, "text")
+            if column == "#0" or any(item_text == section for section in config.sections()):
+                return
+            item_value = self.tree.item(row, "values")[0]
 
-        try:
-            row = self.tree.identify_row(event.y)
-            column = self.tree.identify_column(event.x)
-            item_text = self.tree.set(row, column)
-            if item_text.strip() == "":
-                left_item_text = self.tree.item(row, "text")
-                # Don't allow editing of section headers
-                if any(left_item_text == section for section in config.sections()):
-                    return
             x, y, w, h = self.tree.bbox(row, column)
-            entryedit = ttk.Entry(self)
-            entryedit.place(x=x, y=y, width=w, height=h + 3)  # type: ignore
-            entryedit.insert("end", item_text)
-            entryedit.bind("<Return>", save_edit)
-            entryedit.focus_set()
-            entryedit.grab_set()
+            self.edit_entry = ttk.Entry(self, justify="center", font=("Helvetica", 11))
+            self.edit_entry.place(x=x, y=y, width=w, height=h + 3)  # type: ignore
+            self.edit_entry.insert("end", item_value)
+            self.edit_entry.bind("<Return>", lambda e: self._save_edit(e, row, column))
+            self.edit_entry.focus_set()
+            self.edit_entry.grab_set()
         except Exception:
-            pass
+            return
+
+    def _set_selection_value(self, _):
+        """Set the value of the currently selected cell in the treeview to be
+        editable.
+        """
+        selected = self.tree.selection()
+        if selected:
+            row = selected[0]
+            column = "#1"
+            self._set_cell_value(None, row=row, column=column)
 
-    def _destroy_entries(self, _):
+    def _delete_selection_value(self, _):
+        """
+        Delete the value of the currently selected cell in the treeview.
+
+        This only works for custom items, as other sections are not editable.
+        """
+        selected = self.tree.selection()
+        if selected:
+            item = selected[0]
+            section_name = self.tree.parent(item)
+            if section_name in ("Stickers", "Skins"):
+                next_option = self.tree.next(item)
+                self.tree.delete(item)
+                self.save_config()
+                if next_option:
+                    self.tree.focus(next_option)
+                    self.tree.selection_set(next_option)
+                else:
+                    self.tree.focus(section_name)
+                    self.tree.selection_set(section_name)
+
+    def _destroy_entry(self, _):
         """Destroy any entry widgets in the treeview on an event, such as a mouse wheel
         movement.
         """
-        for widget in self.winfo_children():
-            if isinstance(widget, ttk.Entry):
-                widget.destroy()
-
-    def _destroy_entry(self, event):
-        """Destroy the entry widget on an even targeting it."""
-        if isinstance(event.widget, ttk.Entry):
-            event.widget.destroy()
+        if self.edit_entry:
+            self.edit_entry.destroy()
+            self.edit_entry = None
+            self.tree.focus_set()
 
     def _make_tree_editable(self):
         """Add a binding to the treeview that allows double-clicking on a cell to edit
         its value.
         """
         self.tree.bind("<Double-1>", self._set_cell_value)
-        self.parent.bind("<MouseWheel>", self._destroy_entries)  # type: ignore
-        self.parent.bind("<Button-1>", self._destroy_entry)  # type: ignore
+        self.tree.bind("<Return>", self._set_selection_value)
+        self.tree.bind("<BackSpace>", self._delete_selection_value)
+        self.window.bind("<MouseWheel>", self._destroy_entry)
+        self.window.bind("<Escape>", self._destroy_entry)
 
     def _load_config_into_tree(self):
         """Load the configuration options into the treeview for display and editing."""
         for section in config.sections():
+            # App Settings are internal and shouldn't be displayed to the user
             if section == "App Settings":
                 continue
+
             section_level = self.tree.insert("", "end", iid=section, text=section)
-            for config_option, value in config.items(section):
-                if section == "Custom Items":
-                    custom_item_name = unquote(config_option.split("/")[-1])
-                    self.tree.insert(section_level, "end", text=custom_item_name, values=[value])
+
+            # Items in the Stickers, Cases, and Skins sections should be displayed alphabetically sorted
+            section_items = config.items(section)
+            if section in ("Stickers", "Cases", "Skins"):
+                section_items = sorted(section_items)
+
+            for config_option, value in section_items:
+                if section not in ("User Settings", "App Settings"):
+                    option_name = config.option_to_name(config_option, href=True)
+                    self.tree.insert(
+                        section_level,
+                        "end",
+                        iid=f"{section}-{option_name}",
+                        text=option_name,
+                        values=[value],
+                    )
                 else:
-                    option_name = config_option.replace("_", " ").title()
-                    self.tree.insert(section_level, "end", text=option_name, values=[value])
+                    option_name = config.option_to_name(config_option)
+                    self.tree.insert(
+                        section_level,
+                        "end",
+                        iid=f"{section}-{option_name}",
+                        text=option_name,
+                        values=[value],
+                    )
+
+        self.tree.focus("User Settings")
+        self.tree.selection_set("User Settings")
 
     def reload_config_into_tree(self):
-        """Reload the configuration options into the treeview for display and
-        editing.
+        """Reload the configuration options into the treeview for display and editing
+        and maintain the users current selection.
         """
+        selected = self.tree.selection()
+        selected_text, selected_section = None, None
+        if selected:
+            selected_text = self.tree.item(selected[0], "text")
+            selected_section = self.tree.parent(selected[0])
+
         for item in self.tree.get_children():
             self.tree.delete(item)
         self._load_config_into_tree()
 
+        if selected_section:
+            self.tree.item(selected_section, open=True)
+            self.tree.focus(f"{selected_section}-{selected_text}")
+            self.tree.selection_set(f"{selected_section}-{selected_text}")
+        elif selected:
+            self.tree.focus(selected_text)
+            self.tree.selection_set(selected_text)  # type: ignore
+
     def _configure_treeview(self):
         """Configure a treeview to display and edit configuration options."""
         scrollbar = ttk.Scrollbar(self)
@@ -146,14 +244,13 @@ class ConfigEditorFrame(ttk.Frame):
 
 
 class ConfigEditorButtonFrame(ttk.Frame):
-    def __init__(self, parent, tree):
+    def __init__(self, editor_frame):
         """Initialize the button frame that contains buttons for saving the updated
         configuration and adding custom items.
         """
-        super().__init__(parent, padding=10)
+        super().__init__(editor_frame, padding=10)
 
-        self.parent = parent
-        self.tree = tree
+        self.editor_frame = editor_frame
         self.custom_item_dialog = None
 
         self._add_widgets()
@@ -162,13 +259,10 @@ class ConfigEditorButtonFrame(ttk.Frame):
         """Add buttons to the button frame for saving the configuration and adding
         custom items.
         """
-        save_button = ttk.Button(self, text="Save", command=self._save_config)
-        save_button.pack(side="left", expand=True, padx=5)
-
         reset_button = ttk.Button(self, text="Reset", command=self._reset_config)
         reset_button.pack(side="left", expand=True, padx=5)
 
-        custom_item_button = ttk.Button(self, text="Add Custom Item", command=self._add_custom_item)
+        custom_item_button = ttk.Button(self, text="Add Item", command=self._add_custom_item)
         custom_item_button.pack(side="left", expand=True, padx=5)
 
         import_inventory_button = ttk.Button(
@@ -176,72 +270,66 @@ class ConfigEditorButtonFrame(ttk.Frame):
         )
         import_inventory_button.pack(side="left", expand=True, padx=5)
 
-    def _save_config(self):
-        """Save the current configuration from the treeview to the config file."""
-        for child in self.tree.get_children():
-            for item in self.tree.get_children(child):
-                title_option = self.tree.item(item, "text")
-                config_option = title_option.lower().replace(" ", "_")
-                value = self.tree.item(item, "values")[0]
-                section = self.tree.parent(item)
-                section_name = self.tree.item(section, "text")
-                if section_name == "Custom Items":
-                    # custom items are already saved upon creation (Saving them again would result in duplicates)
-                    continue
-                config.set(section_name, config_option, value)
-
-        config.write_to_file()
-        if config.valid:
-            messagebox.showinfo("Config Saved", "The configuration has been saved successfully.")
-        else:
-            config.load()
-            self.parent.reload_config_into_tree()
-            messagebox.showerror(
-                "Config Error",
-                f"The configuration is invalid. ({config.last_error})",
-            )
-
     def _reset_config(self):
         """Reset the configuration file to its default state."""
         confirm = messagebox.askokcancel(
-            "Reset Config", "Are you sure you want to reset the configuration?"
+            "Reset Config",
+            "Are you sure you want to reset the configuration?",
+            parent=self.editor_frame,
         )
         if confirm:
             copy(CONFIG_FILE_BACKUP, CONFIG_FILE)
-            config.load()
-            self.parent.reload_config_into_tree()
+            config.load_from_file()
+            self.editor_frame.reload_config_into_tree()
+        self.editor_frame.focus_set()
+        self.editor_frame.tree.focus_set()
 
     def _add_custom_item(self):
         """Open a window to add a new custom item."""
-        custom_item_window = tk.Toplevel(self.parent)
+        custom_item_window = tk.Toplevel(self.editor_frame)
         custom_item_window.title(ADD_CUSTOM_ITEM_TITLE)
-        custom_item_window.geometry(ADD_CUSTOM_ITEM_SIZE)
+        custom_item_window.geometry(centered(custom_item_window, ADD_CUSTOM_ITEM_SIZE))
+        custom_item_window.minsize(*size_info(ADD_CUSTOM_ITEM_SIZE))
+        custom_item_window.focus_set()
 
-        custom_item_frame = CustomItemFrame(custom_item_window, self.parent, self.tree)
+        def on_close():
+            custom_item_window.destroy()
+            self.editor_frame.tree.focus_set()
+
+        custom_item_window.protocol("WM_DELETE_WINDOW", on_close)
+
+        custom_item_frame = CustomItemFrame(custom_item_window, self.editor_frame)
         custom_item_frame.pack(expand=True, fill="both", padx=15, pady=15)
 
     def _import_steam_inventory(self):
         """Open a window to import the user's Steam inventory."""
-        steam_inventory_window = tk.Toplevel(self.parent)
+        steam_inventory_window = tk.Toplevel(self.editor_frame)
         steam_inventory_window.title(IMPORT_INVENTORY_TITLE)
-        steam_inventory_window.geometry(IMPORT_INVENTORY_SIZE)
+        steam_inventory_window.geometry(centered(steam_inventory_window, IMPORT_INVENTORY_SIZE))
+        steam_inventory_window.minsize(*size_info(IMPORT_INVENTORY_SIZE))
+        steam_inventory_window.focus_set()
+
+        def on_close():
+            steam_inventory_window.destroy()
+            self.editor_frame.tree.focus_set()
 
-        steam_inventory_frame = InventoryImportFrame(steam_inventory_window, self)
+        steam_inventory_window.protocol("WM_DELETE_WINDOW", on_close)
+
+        steam_inventory_frame = InventoryImportFrame(steam_inventory_window, self.editor_frame)
         steam_inventory_frame.pack(expand=True, fill="both", padx=15, pady=15)
 
 
 class CustomItemFrame(ttk.Frame):
-    def __init__(self, parent, grandparent, tree):
+    def __init__(self, window, editor_frame):
         """Initialize the custom item frame that allows users to add custom items."""
-        super().__init__(parent, style="Card.TFrame", padding=15)
-        self.parent = parent
-        self.grandparent = grandparent
-        self.tree = tree
+        super().__init__(window, style="Card.TFrame", padding=15)
+        self.window = window
+        self.editor_frame = editor_frame
         self._add_widgets()
 
     def _add_widgets(self):
         """Add widgets to the custom item frame for entering item details."""
-        ttk.Label(self, text="Item URL:").pack(pady=5)
+        ttk.Label(self, text="Steam Market Listing URL:").pack(pady=5)
         item_url_entry = ttk.Entry(self)
         item_url_entry.pack(fill="x", padx=10)
 
@@ -255,92 +343,155 @@ class CustomItemFrame(ttk.Frame):
             command=lambda: self._add_custom_item(item_url_entry.get(), item_owned_entry.get()),
         )
         add_button.pack(pady=10)
+        self.window.bind("<Return>", lambda _: add_button.invoke())
+
+    def _update_existing(self, section, item_name, item_owned):
+        """
+        Try to update an item in the treeview with the new item details.
 
-    def _add_custom_item(self, item_url, item_owned):
+        :return: True if the item was updated, False if it was not found.
+        """
+        for existing_item in self.editor_frame.tree.get_children(section):
+            existing_item_name = self.editor_frame.tree.item(existing_item, "text")
+            if item_name == existing_item_name:
+                self.editor_frame.tree.set(existing_item, column="#1", value=item_owned)
+                self.editor_frame.focus_set()
+                self.editor_frame.save_config()
+                self.window.destroy()
+                return True
+        return False
+
+    def _get_insert_index(self, item_name, section):
+        """Get the index to insert the new item in alphabetical order."""
+        insert_index = "end"
+        for existing_item_index, existing_item in enumerate(
+            self.editor_frame.tree.get_children(section)
+        ):
+            existing_item_name = self.editor_frame.tree.item(existing_item, "text")
+            if item_name < existing_item_name:
+                insert_index = existing_item_index
+                break
+        return insert_index
+
+    def _add_custom_item(self, item_href, item_owned):
         """Add a custom item to the configuration."""
-        if not item_url or not item_owned:
-            messagebox.showerror("Input Error", "All fields must be filled out.")
+        if not item_href or not item_owned:
+            messagebox.showerror(
+                "Input Error", "All fields must be filled out.", parent=self.window
+            )
+            return
+        if config.option_exists(item_href, exclude_sections=("Stickers", "Skins")):
+            messagebox.showerror(
+                "Item Exists", "This item already exists in another section.", parent=self.window
+            )
             return
+
         try:
-            if int(item_owned) < 0:
-                raise ValueError("Owned count must be a non-negative integer.")
+            item_name = config.option_to_name(item_href, href=True)
         except ValueError as error:
-            messagebox.showerror("Input Error", f"Invalid owned count: {error}")
+            messagebox.showerror("Invalid URL", str(error), parent=self.window)
             return
 
-        config.set("Custom Items", item_url, item_owned)
-        config.write_to_file()
-        if config.valid:
-            config.load()
-            self.grandparent.reload_config_into_tree()
-            self.parent.destroy()
-        else:
-            config.remove_option("Custom Items", item_url)
-            messagebox.showerror(
-                "Config Error",
-                f"The configuration is invalid. ({config.last_error})",
-            )
+        if self._update_existing("Stickers", item_name, item_owned):
+            return
+        if self._update_existing("Skins", item_name, item_owned):
+            return
+
+        section = "Stickers" if item_name.startswith("Sticker") else "Skins"
+        insert_index = self._get_insert_index(item_name, section)
+        self.editor_frame.tree.insert(
+            section,
+            insert_index,
+            iid=f"{section}-{item_name}",
+            text=item_name,
+            values=[item_owned],
+        )
+        self.editor_frame.save_config()
+        self.window.destroy()
 
 
 class InventoryImportFrame(ttk.Frame):
     # pylint: disable=too-many-instance-attributes
-    def __init__(self, parent, grandparent):
+    def __init__(self, window, editor_frame):
         """Initialize the inventory import frame that allows users to import their Steam
         inventory.
         """
-        super().__init__(parent, style="Card.TFrame", padding=10)
-        self.parent = parent
-        self.grandparent = grandparent
+        super().__init__(window, padding=10)
+        self.window = window
+        self.editor_frame = editor_frame
         self._add_widgets()
 
     def _add_widgets(self):
         """Add widgets to the inventory import frame."""
+        self._configure_entries()
+        self.user_name_label.pack(pady=5)
+        self.user_name_entry.pack(fill="x", expand=True, padx=10)
+        self.password_label.pack(pady=5)
+        self.password_entry.pack(fill="x", expand=True, padx=10)
+        self.two_factor_label.pack(pady=5)
+        self.two_factor_entry.pack(fill="x", expand=True, padx=10)
+        self.import_button.pack(pady=10)
+        self.entry_frame.pack(side="left", padx=10, pady=(0, 20), fill="both", expand=True)
+
         self._configure_checkboxes()
+        self.storage_units_checkbox.pack(anchor="w", padx=10, pady=5)
+        self.regular_inventory_checkbox.pack(anchor="w", padx=10, pady=5)
         self.import_cases_checkbox.pack(anchor="w", padx=10, pady=5)
         self.import_sticker_capsules_checkbox.pack(anchor="w", padx=10, pady=5)
         self.import_stickers_checkbox.pack(anchor="w", padx=10, pady=5)
         self.import_others_checkbox.pack(anchor="w", padx=10, pady=5)
-
-        self._configure_entries()
-        self.user_name_label.pack(pady=10)
-        self.user_name_entry.pack(fill="x", padx=50)
-        self.password_label.pack(pady=10)
-        self.password_entry.pack(fill="x", padx=50)
-        self.two_factor_label.pack(pady=10)
-        self.two_factor_entry.pack(fill="x", padx=50)
-
-        self.import_button = ttk.Button(self, text="Import", command=self._import_inventory)
-        self.import_button.pack(pady=10)
+        self.checkbox_frame.pack(side="left", padx=10, pady=(0, 20), fill="both", expand=True)
 
     def _configure_checkboxes(self):
         # pylint: disable=attribute-defined-outside-init
         """Configure the checkboxes for selecting what to import from the Steam
         inventory.
         """
+        self.checkbox_frame = ttk.LabelFrame(self, text="Import Settings", padding=15)
+
+        self.regular_inventory_value = tk.BooleanVar(value=False)
+        self.regular_inventory_checkbox = ttk.Checkbutton(
+            self.checkbox_frame,
+            text="Regular Inventory",
+            variable=self.regular_inventory_value,
+            style="Switch.TCheckbutton",
+        )
+
+        self.storage_units_value = tk.BooleanVar(value=True)
+        self.storage_units_checkbox = ttk.Checkbutton(
+            self.checkbox_frame,
+            text="Storage Units",
+            variable=self.storage_units_value,
+            style="Switch.TCheckbutton",
+        )
+
         self.import_cases_value = tk.BooleanVar(value=True)
         self.import_cases_checkbox = ttk.Checkbutton(
-            self, text="Import Cases", variable=self.import_cases_value, style="Switch.TCheckbutton"
+            self.checkbox_frame,
+            text="Import Cases",
+            variable=self.import_cases_value,
+            style="Switch.TCheckbutton",
         )
 
         self.import_sticker_capsules_value = tk.BooleanVar(value=True)
         self.import_sticker_capsules_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Import Sticker Capsules",
             variable=self.import_sticker_capsules_value,
             style="Switch.TCheckbutton",
         )
 
-        self.import_stickers_value = tk.BooleanVar(value=True)
+        self.import_stickers_value = tk.BooleanVar(value=False)
         self.import_stickers_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Import Stickers",
             variable=self.import_stickers_value,
             style="Switch.TCheckbutton",
         )
 
-        self.import_others_value = tk.BooleanVar(value=True)
+        self.import_others_value = tk.BooleanVar(value=False)
         self.import_others_checkbox = ttk.Checkbutton(
-            self,
+            self.checkbox_frame,
             text="Import Other Items",
             variable=self.import_others_value,
             style="Switch.TCheckbutton",
@@ -351,14 +502,37 @@ class InventoryImportFrame(ttk.Frame):
         """Configure the entry fields for Steam username, password, and two-factor
         code.
         """
-        self.user_name_label = ttk.Label(self, text="Steam Username:")
-        self.user_name_entry = ttk.Entry(self)
+        self.entry_frame = ttk.Frame(self, style="Card.TFrame", padding=15)
+
+        self.user_name_label = ttk.Label(self.entry_frame, text="Steam Username:")
+        self.user_name_entry = ttk.Entry(self.entry_frame, justify="center", font=("Helvetica", 11))
 
-        self.password_label = ttk.Label(self, text="Steam Password:")
-        self.password_entry = ttk.Entry(self, show="*")
+        self.password_label = ttk.Label(self.entry_frame, text="Steam Password:")
+        self.password_entry = ttk.Entry(
+            self.entry_frame, show="*", justify="center", font=("Helvetica", 11)
+        )
 
-        self.two_factor_label = ttk.Label(self, text="Steam Guard Code (if enabled):")
-        self.two_factor_entry = ttk.Entry(self)
+        self.two_factor_label = ttk.Label(self.entry_frame, text="Steam Guard Code:")
+        self.two_factor_entry = ttk.Entry(
+            self.entry_frame, justify="center", font=("Helvetica", 11)
+        )
+
+        self.import_button = ttk.Button(
+            self.entry_frame, text="Import", command=self._import_inventory, state="disabled"
+        )
+
+        def check_form(_):
+            if (
+                len(self.user_name_entry.get().strip()) > 0
+                and len(self.password_entry.get().strip()) > 0
+                and len(self.two_factor_entry.get().strip()) > 0
+            ):
+                self.import_button.configure(state="normal")
+            else:
+                self.import_button.configure(state="disabled")
+
+        self.window.bind("<KeyRelease>", check_form)
+        self.window.bind("<Return>", lambda _: self.import_button.invoke())
 
     def _import_inventory(self):
         """
@@ -367,6 +541,9 @@ class InventoryImportFrame(ttk.Frame):
         This will also install the necessary npm packages if they are not already
         installed.
         """
+        regular_inventory = self.regular_inventory_value.get()
+        storage_units = self.storage_units_value.get()
+
         import_cases = self.import_cases_value.get()
         import_sticker_capsules = self.import_sticker_capsules_value.get()
         import_stickers = self.import_stickers_value.get()
@@ -380,6 +557,8 @@ class InventoryImportFrame(ttk.Frame):
             [
                 INVENTORY_IMPORT_SCRIPT,
                 INVENTORY_IMPORT_FILE,
+                str(regular_inventory),
+                str(storage_units),
                 str(import_cases),
                 str(import_sticker_capsules),
                 str(import_stickers),
@@ -390,26 +569,37 @@ class InventoryImportFrame(ttk.Frame):
             ]
         )
 
-        self.parent.destroy()
+        self.window.destroy()
 
     def _display_node_subprocess(self, node_cmd):
-        text_window = tk.Toplevel(self.grandparent)
-        text_window.title(IMPORT_INVENTORY_PROCESS_TITLE)
-        text_window.geometry(IMPORT_INVENTORY_PROCESS_SIZE)
+        console_window = tk.Toplevel(self.editor_frame)
+        console_window.title(IMPORT_INVENTORY_PROCESS_TITLE)
+        console_window.geometry(centered(console_window, IMPORT_INVENTORY_PROCESS_SIZE))
+        console_window.minsize(*size_info(IMPORT_INVENTORY_PROCESS_SIZE))
+        console_window.focus_force()
+
+        def on_close():
+            console_window.destroy()
+            config.read_from_inventory_file()
+            self.editor_frame.reload_config_into_tree()
+            self.editor_frame.tree.focus_set()
+
+        console_window.protocol("WM_DELETE_WINDOW", on_close)
 
-        process_frame = InventoryImportProcessFrame(text_window)
+        process_frame = InventoryImportProcessFrame(console_window, self.editor_frame)
         process_frame.pack(expand=True, fill="both", padx=15, pady=15)
+        process_frame.console.focus_force()
         process_frame.start(node_cmd)
-        process_frame.console.focus_set()
 
 
 class InventoryImportProcessFrame(ttk.Frame):
     # pylint: disable=attribute-defined-outside-init
     # Source: https://stackoverflow.com/questions/27327886/issues-intercepting-subprocess-output-in-real-time
-    def __init__(self, parent):
+    def __init__(self, window, editor_frame):
         """Initialize the frame that displays the output of the subprocess."""
-        super().__init__(parent)
-        self.parent = parent
+        super().__init__(window)
+        self.window = window
+        self.editor_frame = editor_frame
         self._add_widgets()
 
     def _add_widgets(self):
@@ -419,6 +609,7 @@ class InventoryImportProcessFrame(ttk.Frame):
 
         self.console = ThemedText(self, wrap="word", yscrollcommand=self.scrollbar.set)
         self.console.config(state="disabled")
+        self.console.tag_configure("error", foreground="red")
         self.console.pack(expand=True, fill="both", padx=10, pady=10)
 
         self.scrollbar.config(command=self.console.yview)
@@ -438,28 +629,31 @@ class InventoryImportProcessFrame(ttk.Frame):
             stdin=PIPE,
             stderr=STDOUT,
             text=True,
-            bufsize=1,
             encoding="utf-8",
+            shell=True,
+            cwd=DATA_DIR,
         )
         self.queue = Queue()
         self.thread = Thread(target=self._read_lines, args=(self.process, self.queue), daemon=True)
         self.thread.start()
-
-        self.after(100, self._update_lines)
+        self._update_lines()
 
     def _update_lines(self):
         """Update the text widget with lines from the subprocess output."""
         try:
             line = self.queue.get(block=False)
             self.console.config(state="normal")
-            self.console.insert("end", line)
+            if "[ERROR]" in line:
+                self.console.insert("end", line, "error")
+            else:
+                self.console.insert("end", line)
             self.console.config(state="disabled")
             self.console.yview("end")
         except Empty:
             pass
 
         if self.process.poll() is None or not self.queue.empty():
-            self.after(100, self._update_lines)
+            self.after(35, self._update_lines)
         else:
             self._cleanup()
 
@@ -467,8 +661,10 @@ class InventoryImportProcessFrame(ttk.Frame):
         """Clean up the process and thread after completion and trigger a config update
         from the newly written inventory file.
         """
-        config.read_from_inventory_file()
-        self.parent.master.master.reload_config_into_tree()
-
         self.process.wait()
         self.thread.join()
+
+        config.read_from_inventory_file()
+        self.editor_frame.reload_config_into_tree()
+        self.editor_frame.tree.focus_set()
+        self.window.destroy()