ui: add multiline checkbox to field template editor

src/tagstudio/core/library/alchemy/library.py

@@ -30,6 +30,7 @@ from sqlalchemy import (
     Engine,
     NullPool,
     ScalarResult,
+    Update,
     and_,
     asc,
     create_engine,
@@ -1313,6 +1314,114 @@ class Library:
 
             return direct_tags, descendant_tags
 
+    def add_field_template(self, field_template: BaseFieldTemplate) -> BaseFieldTemplate | None:
+        """Add a new field template to the library."""
+        if not (isinstance(field_template, (TextFieldTemplate, DatetimeFieldTemplate))):
+            logger.error("[Library] BaseFieldTemplate attempted to be added to the library.")
+            return None
+
+        with Session(self.engine) as session:
+            try:
+                session.add(field_template)
+                session.flush()
+                make_transient(field_template)
+                session.commit()
+                return field_template
+            except IntegrityError as e:
+                logger.error(e)
+                session.rollback()
+                return None
+
+    def update_field_template(self, old_field_type: str, field_template: BaseFieldTemplate) -> bool:
+        """Update a field template in the library.
+
+        old_field_class:str
+        field_template: BaseFieldTemplate
+        """
+        with Session(self.engine) as session:
+            logger.warning(f"Updating old type {old_field_type} to new {field_template.class_name}")
+            is_same_type: bool = old_field_type == field_template.class_name
+            try:
+                update_stmt: Update | None = None
+                # If the template is changing type, remove the old one and add the updated
+                # template to the proper table.
+                if not is_same_type:
+                    old_template: BaseFieldTemplate | None = None
+                    if old_field_type == "TextFieldTemplate":
+                        old_template = session.scalar(
+                            select(TextFieldTemplate)
+                            .where(TextFieldTemplate.id == field_template.id)
+                            .limit(1)
+                        )
+                    elif old_field_type == "DatetimeFieldTemplate":
+                        old_template = session.scalar(
+                            select(DatetimeFieldTemplate)
+                            .where(DatetimeFieldTemplate.id == field_template.id)
+                            .limit(1)
+                        )
+                    if old_template is None:
+                        logger.error("[Library] old_template is None")
+                        return False
+                    session.delete(old_template)
+                    session.flush()
+                    field_template.id = None  # The id should not transfer between tables
+                    session.add(field_template)
+                    session.commit()
+                # Otherwise, update the existing template in-place
+                elif isinstance(field_template, TextFieldTemplate):
+                    update_stmt = (
+                        update(TextFieldTemplate)
+                        .where(TextFieldTemplate.id == field_template.id)
+                        .values(name=field_template.name, is_multiline=field_template.is_multiline)
+                    )
+                elif isinstance(field_template, DatetimeFieldTemplate):
+                    update_stmt = (
+                        update(DatetimeFieldTemplate)
+                        .where(DatetimeFieldTemplate.id == field_template.id)
+                        .values(name=field_template.name)
+                    )
+                if is_same_type:
+                    if update_stmt is None:
+                        return False
+                    session.execute(update_stmt)
+                    session.commit()
+
+            except IntegrityError as e:
+                logger.error(e)
+                session.rollback()
+                return False
+
+        return True
+
+    def remove_field_template(self, field_template: BaseFieldTemplate) -> bool:
+        """Remove a field template from the library."""
+        with Session(self.engine) as session:
+            try:
+                session_item: BaseFieldTemplate | None = None
+                if isinstance(field_template, TextFieldTemplate):
+                    session_item = session.scalar(
+                        select(TextFieldTemplate)
+                        .where(TextFieldTemplate.id == field_template.id)
+                        .limit(1)
+                    )
+                elif isinstance(field_template, DatetimeFieldTemplate):
+                    session_item = session.scalar(
+                        select(DatetimeFieldTemplate)
+                        .where(DatetimeFieldTemplate.id == field_template.id)
+                        .limit(1)
+                    )
+
+                if session_item is not None:
+                    session.delete(session_item)
+                    session.commit()
+
+            except IntegrityError as e:
+                logger.error(e)
+                session.rollback()
+                return False
+
+        return True
+
     def search_field_templates(self, name: str | None, limit: int = 100) -> list[BaseFieldTemplate]:
         """Return field template rows matching the query, detached from the session."""
         if limit <= 0:
@@ -1320,7 +1429,7 @@ class Library:
 
         search_query: str = name.lower() if name else ""
 
-        def sort_key(template: BaseFieldTemplate) -> tuple:
+        def sort_key(template: BaseFieldTemplate) -> tuple[str] | tuple[bool, int, str]:
             text = template.name.lower()
             if not search_query:
                 return (text,)
@@ -1431,7 +1540,12 @@ class Library:
             session.commit()
 
     def update_text_field(
-        self, entry_ids: list[int] | int, field: TextField, value: str, is_multiline: bool
+        self,
+        entry_ids: list[int] | int,
+        field: TextField,
+        name: str,
+        value: str,
+        is_multiline: bool,
     ):
         """Update a TextField field on one or more Entries."""
         if isinstance(entry_ids, int):
@@ -1443,7 +1557,7 @@ class Library:
             update_stmt = (
                 update(field_type)
                 .where(and_(field_type.id == field.id, field_type.entry_id.in_(entry_ids)))
-                .values(value=value, is_multiline=is_multiline)
+                .values(name=name, value=value, is_multiline=is_multiline)
             )
 
             session.execute(update_stmt)
@@ -1453,6 +1567,7 @@ class Library:
         self,
         entry_ids: list[int] | int,
         field: DatetimeField,
+        name: str,
         value: datetime,
     ):
         """Update a DatetimeField field on one or more Entries."""
@@ -1465,7 +1580,7 @@ class Library:
             update_stmt = (
                 update(field_type)
                 .where(and_(field_type.id == field.id, field_type.entry_id.in_(entry_ids)))
-                .values(value=value)
+                .values(name=name, value=value)
             )
 
             session.execute(update_stmt)

src/tagstudio/qt/controllers/clickable_label.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
-from typing import override
+from typing import Any, override
 
 from PySide6.QtCore import Signal
 from PySide6.QtGui import QMouseEvent
@@ -14,8 +14,8 @@ class ClickableLabel(QLabel):
 
     clicked = Signal()
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args: Any, **kwarg: Any):  # pyright: ignore[reportExplicitAny]
+        super().__init__(*args, **kwarg)
 
     @override
     def mousePressEvent(self, ev: QMouseEvent):

src/tagstudio/qt/controllers/edit_field_template_modal.py

@@ -0,0 +1,119 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import structlog
+
+from tagstudio.core.library.alchemy.fields import (
+    BaseFieldTemplate,
+    DatetimeFieldTemplate,
+    TextFieldTemplate,
+)
+from tagstudio.qt.models.palette import ColorType, UiColor, get_ui_color
+from tagstudio.qt.translations import Translations
+from tagstudio.qt.views.edit_field_template_modal_view import EditFieldTemplateModalView
+
+logger = structlog.get_logger(__name__)
+
+
+class EditFieldTemplateModal(EditFieldTemplateModalView):
+    field_type_map: dict[str, str] = {
+        "TextFieldTemplate": Translations["field_type.text"],
+        "DatetimeFieldTemplate": Translations["field_type.datetime"],
+    }
+    DEFAULT_TYPE_INDEX = 0
+
+    def __init__(self, field_template: BaseFieldTemplate | None = None) -> None:
+        super().__init__()
+        self.__field_id: int | None = field_template.id if field_template else None
+        self.__field_name: str = ""
+        self.__field_type: str | None = field_template.class_name if field_template else None
+        self.old_field_type: str = ""
+
+        for k, v in EditFieldTemplateModal.field_type_map.items():
+            self._type_combobox.addItem(v, k)
+
+        self.__connect_callbacks()
+        self.set_field_template(field_template)
+        self.__on_type_changed(EditFieldTemplateModal.DEFAULT_TYPE_INDEX)
+
+    def __connect_callbacks(self) -> None:
+        self.name_field.textChanged.connect(self.__on_name_changed)
+        self._type_combobox.currentIndexChanged.connect(self.__on_type_changed)
+
+    def set_field_template(self, field_template: BaseFieldTemplate | None = None) -> None:
+        """Populate the modal with pre-existing field template values, or fallback to defaults."""
+        logger.info("[EditFieldTemplate] Setting Field Template", field_template=field_template)
+
+        # Indicates a new template, set default values
+        if field_template is None:
+            self.__field_name = Translations["field_template.new"]
+            self.__field_type = list(EditFieldTemplateModal.field_type_map.keys())[
+                EditFieldTemplateModal.DEFAULT_TYPE_INDEX
+            ]
+            return
+        # Populate common values for any field type
+        else:
+            self.__field_name = field_template.name
+            self.__field_type = field_template.class_name
+            self.old_field_type = field_template.class_name  # Only set on init
+
+        # Update widgets
+        self.name_field.setText(self.__field_name)
+        self._type_combobox.setCurrentIndex(
+            list(EditFieldTemplateModal.field_type_map.keys()).index(field_template.class_name)
+        )
+
+        # Populate values for specific field types
+        if isinstance(field_template, TextFieldTemplate):
+            self._multiline_checkbox.setChecked(field_template.is_multiline)
+
+    def __on_name_changed(self):
+        is_empty = not self.name_field.text().strip()
+
+        self.name_field.setStyleSheet(
+            f"border: 1px solid {get_ui_color(ColorType.PRIMARY, UiColor.RED)}; border-radius: 2px"
+            if is_empty
+            else ""
+        )
+
+        if self.panel_save_button is not None:
+            self.panel_save_button.setDisabled(is_empty)
+
+    def __on_type_changed(self, index: int):
+        old_type = self.__field_type
+        self.__field_type = list(EditFieldTemplateModal.field_type_map.keys())[index]
+
+        if old_type == self.__field_type:
+            logger.info(f"old type {old_type}, new type {self.__field_type}")
+            return
+
+        if old_type == "TextFieldTemplate":
+            self._text_field_attributes_widget.hide()
+        # NOTE: Future options specific to other type will go here.
+
+        if self.__field_type == "TextFieldTemplate":
+            self._text_field_attributes_widget.show()
+
+    def build_field_template(self) -> BaseFieldTemplate:
+        if self.__field_type == "TextFieldTemplate":
+            return TextFieldTemplate(
+                id=self.__field_id,
+                name=self.name_field.text(),
+                is_multiline=self._multiline_checkbox.isChecked(),
+            )
+        elif self.__field_type == "DatetimeFieldTemplate":
+            return DatetimeFieldTemplate(
+                id=self.__field_id,
+                name=self.name_field.text(),
+            )
+        else:
+            logger.warning(
+                "[EditFieldTemplateModal] Unknown field, falling back to TextFieldTemplate",
+                field_type=self.__field_type,
+                example=TextFieldTemplate,
+            )
+            return TextFieldTemplate(
+                name=self.name_field.text(),
+                is_multiline=self._multiline_checkbox.isChecked(),
+            )

src/tagstudio/qt/controllers/edit_text_controller.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from typing import override
+
+import structlog
+
+from tagstudio.qt.views.edit_text_view import EditTextView
+
+logger = structlog.get_logger(__name__)
+
+
+class EditText(EditTextView):
+    def __init__(self, name: str, text: str | None, is_multiline: bool = False):
+        super().__init__()
+        self.name_field.setText(name)
+
+        self.text = text
+        self.is_multiline: bool = is_multiline
+
+        self.multiline_checkbox.setChecked(is_multiline)
+        self.multiline_checkbox.clicked.connect(lambda checked: self.on_multiline_checked(checked))
+
+        if self.is_multiline:
+            self.text_line.hide()
+            self.text_line_stretch.hide()
+            self.text_box.setPlainText(self.text or "")
+        else:
+            self.text_box.hide()
+            self.text_line.setText(self.text or "")
+
+    def on_multiline_checked(self, checked: bool):
+        was_multiline = self.is_multiline
+        self.is_multiline = checked
+
+        if was_multiline:
+            self.text = self.text_box.toPlainText()
+            self.text_box.hide()
+            self.text_line.setText(self.text)
+            self.text_line.show()
+            self.text_line_stretch.show()
+        else:
+            self.text = self.text_line.text()
+            self.text_line.hide()
+            self.text_line_stretch.hide()
+            self.text_box.setPlainText(self.text)
+            self.text_box.show()
+
+    @override
+    def parent_post_init(self):
+        if self.is_multiline:
+            self.text_box.setFocus()
+        else:
+            self.text_line.setFocus()
+
+    @override
+    def saved_data(self) -> dict[str, str | bool]:
+        return {
+            "name": self.name_field.text(),
+            "value": self.text_box.toPlainText() if self.is_multiline else self.text_line.text(),
+            "is_multiline": self.is_multiline,
+        }
+
+    @override
+    def reset(self):
+        self.text_box.setPlainText(self.text or "")

src/tagstudio/qt/controllers/field_template_search_panel_controller.py

@@ -2,13 +2,16 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
+from typing import override
 from warnings import catch_warnings
 
 import structlog
 from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QMessageBox
 
 from tagstudio.core.library.alchemy.fields import BaseFieldTemplate
 from tagstudio.core.library.alchemy.library import Library
+from tagstudio.qt.controllers.edit_field_template_modal import EditFieldTemplateModal
 from tagstudio.qt.controllers.field_template_widget_controller import FieldTemplateWidget
 from tagstudio.qt.controllers.search_panel_controller import SearchPanel
 from tagstudio.qt.translations import Translations
@@ -23,9 +26,7 @@ class FieldTemplateSearchModal(PanelModal):
         self,
         library: Library,
         is_field_template_chooser: bool = True,
-        done_callback=None,
-        save_callback=None,
-        has_save=False,
+        has_save: bool = False,
     ) -> None:
         self.search_panel: FieldTemplateSearchPanel = FieldTemplateSearchPanel(
             library,
@@ -35,9 +36,7 @@ class FieldTemplateSearchModal(PanelModal):
         super().__init__(
             self.search_panel,
             Translations["field.add.plural"],
-            done_callback=done_callback,
-            save_callback=save_callback,
-            has_save=has_save,
+            is_savable=has_save,
         )
 
 
@@ -60,34 +59,81 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
         self._unlimited_limit_item_label = Translations["field_template.all_field_templates"]
         self._create_and_add_button_label_key = "field_template.create_add"
 
+    @override
     def _get_max_limit(self) -> int:
         return len(self.__lib.field_templates)
 
-    def on_item_create(self) -> None:
-        # TODO: Allow creation of field templates
-        pass
+    @override
+    def on_item_create(self, add_to_entry: bool = False) -> None:
+        """Opens panel to create a new field template and optionally add it to an entry.
 
+        Populates name field using current search query.
+
+        Args:
+            add_to_entry (bool): Should this item be added to currently selected entries?
+        """
+        query: str = self.get_search_query()
+        logger.info("[FieldTemplateSearch] Create and Add Field Template", name=query)
+
+        panel: EditFieldTemplateModal = EditFieldTemplateModal()
+        modal: PanelModal = PanelModal(
+            panel,
+            Translations["field_template.new"],
+            Translations["field_template.add"]
+            if add_to_entry
+            else Translations["field_template.new"],
+            is_savable=True,
+        )
+
+        if query.strip():
+            panel.name_field.setText(query)
+
+        modal.saved.connect(lambda: self.create_item(panel, choose_item=add_to_entry))
+        modal.show()
+
+    @override
     def on_item_edit(self, item: BaseFieldTemplate) -> None:
-        # TODO: Allow creation of field templates
-        pass
 
+        panel: EditFieldTemplateModal = EditFieldTemplateModal(item)
+        modal: PanelModal = PanelModal(
+            panel,
+            item.name,
+            Translations["field_template.edit"],
+            is_savable=True,
+        )
+
+        modal.saved.connect(lambda: self.edit_item(panel))
+        modal.show()
+
+    @override
     def _on_item_remove(self, item: BaseFieldTemplate) -> None:
         if self.is_chooser:
             return
 
-        # TODO: Allow creation of field templates
-        pass
+        message_box = QMessageBox(
+            QMessageBox.Icon.Question,
+            Translations["field_template.delete"],
+            Translations.format("field_template.confirm_delete", field_template_name=item.name),
+            QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel,
+        )
 
-    def on_item_create_and_add(self) -> None:
-        # TODO: Allow creation of field templates
-        pass
+        result = message_box.exec()
 
+        if result != QMessageBox.StandardButton.Ok:
+            return
+
+        self.__lib.remove_field_template(item)
+        self.update_items(self.get_search_query())
+
+    @override
     def _on_item_chosen(self, item: BaseFieldTemplate) -> None:
         self.field_template_chosen.emit(item)
 
+    @override
     def search_items(self, query: str) -> tuple[list[BaseFieldTemplate], list[BaseFieldTemplate]]:
         return self.__lib.search_field_templates(name=query, limit=self._get_limit()[1]), []
 
+    @override
     def set_item_widget(self, item: BaseFieldTemplate | None, index: int) -> None:
         """Set the field template of a field template widget at a specific index."""
         field_template_widget: FieldTemplateWidget = self.get_item_widget(index, self.__lib)
@@ -97,25 +143,41 @@ class FieldTemplateSearchPanel(SearchPanel[BaseFieldTemplate]):
         if item is None:
             return
 
-        # field_template_widget.has_remove = not self.is_chooser
+        field_template_widget.has_remove = not self.is_chooser
 
         # Disconnect previous callbacks
         with catch_warnings(record=True):
-            # tag_widget.on_edit.disconnect()
-            # tag_widget.on_remove.disconnect()
+            field_template_widget.on_edit.disconnect()
+            field_template_widget.on_remove.disconnect()
             field_template_widget.on_click.disconnect()
 
         # Connect callbacks
-        # tag_widget.on_edit.connect(lambda edit_tag=item: self.on_item_edit(edit_tag))
-        # tag_widget.on_remove.connect(lambda remove_tag=item: self._on_item_remove(remove_tag))
+        field_template_widget.on_edit.connect(lambda item_=item: self.on_item_edit(item_))
+        field_template_widget.on_remove.connect(lambda item_=item: self._on_item_remove(item_))
         field_template_widget.on_click.connect(
-            lambda checked=False, tag=item: self._on_item_chosen(tag)
+            lambda checked=False, item_=item: self._on_item_chosen(item_)
         )
 
-    def create_item(self, build_item_modal: PanelModal, choose_item: bool = False) -> None:
-        # TODO: Allow creation of field templates
-        pass
+    @override
+    def create_item(self, edit_item_panel: PanelWidget, choose_item: bool = False) -> None:
 
+        if isinstance(edit_item_panel, EditFieldTemplateModal):
+            template: BaseFieldTemplate = edit_item_panel.build_field_template()
+            self.__lib.add_field_template(template)
+
+            if choose_item:
+                self._on_item_chosen(template)
+                self.clear_search_query()
+
+        edit_item_panel.hide()
+        self.on_search_query_changed(self.get_search_query())
+
+    @override
     def edit_item(self, edit_item_panel: PanelWidget) -> None:
-        # TODO: Allow creation of field templates
-        pass
+        if not isinstance(edit_item_panel, EditFieldTemplateModal):
+            return
+
+        self.__lib.update_field_template(
+            edit_item_panel.old_field_type, edit_item_panel.build_field_template()
+        )
+        self.update_items(self.search_field.text())

src/tagstudio/qt/controllers/field_template_widget_controller.py

@@ -1,6 +1,11 @@
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 
+from typing import override
+
+from PySide6.QtCore import QEvent, Qt
+from PySide6.QtGui import QAction, QEnterEvent
+
 from tagstudio.core.library.alchemy.fields import BaseFieldTemplate
 from tagstudio.qt.translations import FIELD_TYPE_KEYS, Translations
 from tagstudio.qt.views.field_template_widget_view import FieldTemplateWidgetView
@@ -11,6 +16,15 @@ class FieldTemplateWidget(FieldTemplateWidgetView):
         super().__init__()
 
         self.__field_template: BaseFieldTemplate | None = None
+        self.has_remove: bool = False
+
+        # Add actions
+        edit_action = QAction(self)
+        edit_action.setText(Translations["generic.edit"])
+        edit_action.triggered.connect(self.on_edit.emit)
+        self.addAction(edit_action)
+
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.ActionsContextMenu)
 
     def set_field_template(self, field_template: BaseFieldTemplate | None) -> None:
         self.__field_template = field_template
@@ -20,3 +34,17 @@ class FieldTemplateWidget(FieldTemplateWidgetView):
 
         field_name_key: str = FIELD_TYPE_KEYS.get(field_template.class_name, "field_type.unknown")
         self._bg_button.setText(f"{field_template.name} ({Translations[field_name_key]})")
+
+    @override
+    def enterEvent(self, event: QEnterEvent) -> None:
+        if self.has_remove:
+            self._delete_button.setHidden(False)
+        self.update()
+        return super().enterEvent(event)
+
+    @override
+    def leaveEvent(self, event: QEvent) -> None:
+        if self.has_remove:
+            self._delete_button.setHidden(True)
+        self.update()
+        return super().leaveEvent(event)

src/tagstudio/qt/controllers/preview_panel_controller.py

@@ -42,11 +42,11 @@ class PreviewPanel(PreviewPanelView):
         self.__add_tag_modal.tsp.item_chosen.connect(self._add_tag_to_selected)
 
     def _add_field_to_selected(self, template: BaseFieldTemplate) -> None:
-        self._fields.add_field_to_selected(template)
+        self._containers.add_field_to_selected(template)
         if len(self._selected) == 1:
-            self._fields.update_from_entry(self._selected[0])
+            self._containers.update_from_entry(self._selected[0])
 
     def _add_tag_to_selected(self, tag_id: int) -> None:
-        self._fields.add_tags_to_selected(tag_id)
+        self._containers.add_tags_to_selected(tag_id)
         if len(self._selected) == 1:
-            self._fields.update_from_entry(self._selected[0])
+            self._containers.update_from_entry(self._selected[0])

src/tagstudio/qt/controllers/search_panel_controller.py

@@ -2,16 +2,17 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, override
 
 import structlog
 from PySide6 import QtCore, QtGui
 from PySide6.QtCore import Signal
 from PySide6.QtGui import QShowEvent
-from PySide6.QtWidgets import QVBoxLayout
+from PySide6.QtWidgets import QVBoxLayout, QWidget
 
+from tagstudio.core.library.alchemy.library import Library
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.panel_modal import PanelModal, PanelWidget
+from tagstudio.qt.views.panel_modal import PanelWidget
 from tagstudio.qt.views.search_panel_view import SearchPanelView
 
 logger = structlog.get_logger(__name__)
@@ -22,7 +23,7 @@ if TYPE_CHECKING:
 
 
 def _item_id(item: object) -> int:
-    item_id: Any = getattr(item, "id")  # noqa: B009
+    item_id: Any = getattr(item, "id")  # noqa: B009  # pyright: ignore[reportExplicitAny]
 
     if isinstance(item_id, int):
         return item_id
@@ -31,7 +32,7 @@ def _item_id(item: object) -> int:
 
 
 def _item_name(item: object) -> str:
-    item_name: Any = getattr(item, "name")  # noqa: B009
+    item_name: Any = getattr(item, "name")  # noqa: B009  # pyright: ignore[reportExplicitAny]
 
     if isinstance(item_name, str):
         return item_name
@@ -93,15 +94,13 @@ class SearchPanel[T](PanelWidget):
     def clear_search_query(self) -> None:
         self.view.clear_search_query()
 
-    def get_item_widget(self, index: int, library: Any):
+    def get_item_widget(self, index: int, library: Library):
         return self.view.get_item_widget(index, library)
 
     def set_driver(self, driver: "QtDriver") -> None:
         self._driver = driver
 
     def on_limit_changed(self, index: int) -> None:
-        logger.info("[SearchPanel] Updating limit")
-
         # Method was called outside the limit_combobox callback
         if index != self.view.get_limit_index():
             self.view.set_limit_index(index)
@@ -130,33 +129,30 @@ class SearchPanel[T](PanelWidget):
         # Focus search field if no query
         if not query:
             self.search_field.setFocus()
-            parent = self.parentWidget()
-            if parent is not None:
+            parent: QWidget | None = self.parentWidget()
+            if parent is not None:  # pyright: ignore[reportUnnecessaryComparison]
                 parent.hide()
             return
 
         # Create and add item if no search results
         if len(self._search_results) <= 0:
-            self.on_item_create_and_add()
+            self.on_item_create(add_to_entry=True)
         elif self.is_chooser:
             self._on_item_chosen(self._search_results[0])
 
         self.clear_search_query()
         self.update_items()
 
-    def on_item_create(self) -> None:
+    def on_item_create(self, add_to_entry: bool = False) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
-    def on_item_edit(self, item: T) -> None:
+    def on_item_edit(self, item: T) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
-    def _on_item_remove(self, item: T) -> None:
+    def _on_item_remove(self, item: T) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
-    def on_item_create_and_add(self) -> None:
-        raise NotImplementedError()
-
-    def _on_item_chosen(self, item: T) -> None:
+    def _on_item_chosen(self, item: T) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
     def _is_excluded(self, item: T) -> bool:
@@ -215,18 +211,20 @@ class SearchPanel[T](PanelWidget):
         if query and query.strip():
             self.view.add_create_and_add_button()
 
-    def search_items(self, query: str) -> tuple[list[T], list[T]]:
+    def search_items(self, query: str) -> tuple[list[T], list[T]]:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
-    def set_item_widget(self, item: T | None, index: int) -> None:
+    def set_item_widget(self, item: T | None, index: int) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
+    @override
     def showEvent(self, event: QShowEvent) -> None:  # noqa N802
         self.update_items()
         self.view.scroll_to(0)
         self.view.clear_search_query()
         return super().showEvent(event)
 
+    @override
     def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:  # noqa N802
         # When Escape is pressed, focus back on the search box.
         # If focus is already on the search box, close the modal.
@@ -236,8 +234,8 @@ class SearchPanel[T](PanelWidget):
             else:
                 self.view.focus_search_box(select_all=True)
 
-    def create_item(self, build_item_modal: PanelModal, choose_item: bool = False) -> None:
+    def create_item(self, edit_item_panel: PanelWidget, choose_item: bool = False) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()
 
-    def edit_item(self, edit_item_panel: PanelWidget) -> None:
+    def edit_item(self, edit_item_panel: PanelWidget) -> None:  # pyright: ignore[reportUnusedParameter]
         raise NotImplementedError()

src/tagstudio/qt/controllers/tag_box_controller.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
+from functools import partial
 from typing import TYPE_CHECKING, override
 
 import structlog
@@ -77,20 +78,20 @@ class TagBoxWidget(TagBoxWidgetView):
             build_tag_panel,
             self.__driver.lib.tag_display_name(tag),
             "Edit Tag",
-            done_callback=self.on_update.emit,
-            has_save=True,
-        )
-        # TODO - this was update_tag()
-        edit_modal.saved.connect(
-            lambda: self.__driver.lib.update_tag(
-                build_tag_panel.build_tag(),
-                parent_ids=set(build_tag_panel.parent_ids),
-                alias_names=set(build_tag_panel.alias_names),
-                alias_ids=set(build_tag_panel.alias_ids),
-            )
+            is_savable=True,
         )
+        edit_modal.saved.connect(partial(self._update_tag_callback, build_tag_panel))
         edit_modal.show()
 
+    def _update_tag_callback(self, build_tag_panel: BuildTagPanel):
+        self.__driver.lib.update_tag(
+            build_tag_panel.build_tag(),
+            parent_ids=set(build_tag_panel.parent_ids),
+            alias_names=set(build_tag_panel.alias_names),
+            alias_ids=set(build_tag_panel.alias_ids),
+        )
+        self.on_update.emit()
+
     @override
     def _on_search(self, tag: Tag) -> None:
         self.__driver.main_window.search_field.setText(f"tag_id:{tag.id}")

src/tagstudio/qt/controllers/tag_search_panel_controller.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, override
 from warnings import catch_warnings
 
 import structlog
@@ -33,9 +33,7 @@ class TagSearchModal(PanelModal):
         library: Library,
         exclude: list[int] | None = None,
         is_tag_chooser: bool = True,
-        done_callback=None,
-        save_callback=None,
-        has_save=False,
+        has_save: bool = False,
     ):
         self.tsp = TagSearchPanel(
             library,
@@ -46,9 +44,7 @@ class TagSearchModal(PanelModal):
         super().__init__(
             self.tsp,
             Translations["tag.add.plural"],
-            done_callback=done_callback,
-            save_callback=save_callback,
-            has_save=has_save,
+            is_savable=has_save,
         )
 
 
@@ -70,28 +66,39 @@ class TagSearchPanel(SearchPanel[Tag]):
         self._unlimited_limit_item_label = Translations["tag.all_tags"]
         self._create_and_add_button_label_key = "tag.create_add"
 
+    @override
     def _get_max_limit(self) -> int:
         return len(self.__lib.tags)
 
-    def on_item_create(self) -> None:
+    @override
+    def on_item_create(self, add_to_entry: bool = False) -> None:
+        """Opens panel to create a new tag and optionally add it to an entry.
+
+        Populates name field using current search query.
+
+        Args:
+            add_to_entry (bool): Should this item be added to currently selected entries?
+        """
         # TODO: Move this to a top-level import
         from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports
 
         query: str = self.get_search_query()
 
-        build_tag_panel: BuildTagPanel = BuildTagPanel(self.__lib)
-        build_tag_modal: PanelModal = PanelModal(
-            build_tag_panel,
+        panel: BuildTagPanel = BuildTagPanel(self.__lib)
+        modal: PanelModal = PanelModal(
+            panel,
             Translations["tag.new"],
-            has_save=True,
+            Translations["tag.add"] if add_to_entry else Translations["tag.new"],
+            is_savable=True,
         )
 
         if query.strip():
-            build_tag_panel.name_field.setText(query)
+            panel.name_field.setText(query)
 
-        build_tag_modal.saved.connect(lambda: self.create_item(build_tag_modal))
-        build_tag_modal.show()
+        modal.saved.connect(lambda: self.create_item(panel, choose_item=add_to_entry))
+        modal.show()
 
+    @override
     def on_item_edit(self, item: Tag) -> None:
         # TODO: Move this to a top-level import
         from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports
@@ -101,12 +108,13 @@ class TagSearchPanel(SearchPanel[Tag]):
             edit_tag_panel,
             self.__lib.tag_display_name(item),
             Translations["tag.edit"],
-            has_save=True,
+            is_savable=True,
         )
 
         edit_tag_modal.saved.connect(lambda: self.edit_item(edit_tag_panel))
         edit_tag_modal.show()
 
+    @override
     def _on_item_remove(self, item: Tag) -> None:
         if self.is_chooser:
             return
@@ -115,49 +123,29 @@ class TagSearchPanel(SearchPanel[Tag]):
             return
 
         message_box = QMessageBox(
-            QMessageBox.Question,  # type: ignore
+            QMessageBox.Icon.Question,
             Translations["tag.remove"],
             Translations.format("tag.confirm_delete", tag_name=self.__lib.tag_display_name(item)),
-            QMessageBox.Ok | QMessageBox.Cancel,  # type: ignore
+            QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel,
         )
 
         result = message_box.exec()
 
-        if result != QMessageBox.Ok:  # type: ignore
+        if result != QMessageBox.StandardButton.Ok:
             return
 
         self.__lib.remove_tag(item.id)
         self.update_items(self.get_search_query())
 
-    def on_item_create_and_add(self) -> None:
-        """Opens "Create Tag" panel to create and add a new tag with given name."""
-        # TODO: Move this to a top-level import
-        from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports
-
-        query: str = self.get_search_query()
-
-        logger.info("Create and Add Tag", name=query)
-
-        build_tag_panel: BuildTagPanel = BuildTagPanel(self.__lib)
-        build_tag_modal: PanelModal = PanelModal(
-            build_tag_panel,
-            Translations["tag.new"],
-            Translations["tag.add"],
-            has_save=True,
-        )
-
-        if query.strip():
-            build_tag_panel.name_field.setText(query)
-
-        build_tag_modal.saved.connect(lambda: self.create_item(build_tag_modal, choose_item=True))
-        build_tag_modal.show()
-
+    @override
     def _on_item_chosen(self, item: Tag) -> None:
         self.item_chosen.emit(item.id)
 
+    @override
     def search_items(self, query: str) -> tuple[list[Tag], list[Tag]]:
         return self.__lib.search_tags(name=query, limit=self._get_limit()[1])
 
+    @override
     def set_item_widget(self, item: Tag | None, index: int) -> None:
         """Set the tag of a tag widget at a specific index."""
         tag_widget: TagWidget = self.get_item_widget(index, self.__lib)
@@ -195,39 +183,41 @@ class TagSearchPanel(SearchPanel[Tag]):
         else:
             tag_widget.search_for_tag_action.setEnabled(False)
 
-    def create_item(self, build_item_modal: PanelModal, choose_item: bool = False) -> None:
+    @override
+    def create_item(self, edit_item_panel: PanelWidget, choose_item: bool = False) -> None:
         # TODO: Move this to a top-level import
         from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports
 
-        if isinstance(build_item_modal.widget, BuildTagPanel):
-            tag: Tag = build_item_modal.widget.build_tag()
+        if isinstance(edit_item_panel, BuildTagPanel):
+            tag: Tag = edit_item_panel.build_tag()
             self.__lib.add_tag(
                 tag,
-                parent_ids=build_item_modal.widget.parent_ids,
-                alias_names=build_item_modal.widget.alias_names,
-                alias_ids=build_item_modal.widget.alias_ids,
+                parent_ids=edit_item_panel.parent_ids,
+                alias_names=edit_item_panel.alias_names,
+                alias_ids=edit_item_panel.alias_ids,
             )
 
             if choose_item:
                 self._on_item_chosen(tag)
                 self.clear_search_query()
 
-        build_item_modal.hide()
+        edit_item_panel.hide()
         self.on_search_query_changed(self.get_search_query())
 
+    @override
     def edit_item(self, edit_item_panel: PanelWidget) -> None:
         # TODO: Move this to a top-level import
         from tagstudio.qt.mixed.build_tag import BuildTagPanel  # here due to circular imports
 
         if not isinstance(edit_item_panel, BuildTagPanel):
             return
+
         self.__lib.update_tag(
             tag=edit_item_panel.build_tag(),
             parent_ids=edit_item_panel.parent_ids,
             alias_names=edit_item_panel.alias_names,
             alias_ids=edit_item_panel.alias_ids,
         )
-
         self.update_items(self.search_field.text())
 
     def search_for_tag(self, tag_id: int) -> None:

src/tagstudio/qt/mixed/build_color.py

@@ -32,6 +32,7 @@ from tagstudio.qt.mixed.tag_widget import (
 from tagstudio.qt.models.palette import ColorType, UiColor, get_tag_color, get_ui_color
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.views.panel_modal import PanelWidget
+from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style
 
 logger = structlog.get_logger(__name__)
 
@@ -135,37 +136,7 @@ class BuildColorPanel(PanelWidget):
         self.border_layout.addWidget(self.border_checkbox)
         self.border_label = QLabel(Translations["color.color_border"])
         self.border_layout.addWidget(self.border_label)
-
-        primary_color = QColor(get_tag_color(ColorType.PRIMARY, TagColorEnum.DEFAULT))
-        border_color = get_border_color(primary_color)
-        highlight_color = get_highlight_color(primary_color)
-        text_color: QColor = get_text_color(primary_color, highlight_color)
-        self.border_checkbox.setStyleSheet(
-            f"QCheckBox{{"
-            f"background: rgba{primary_color.toTuple()};"
-            f"color: rgba{text_color.toTuple()};"
-            f"border-color: rgba{border_color.toTuple()};"
-            f"border-radius: 6px;"
-            f"border-style:solid;"
-            f"border-width: 2px;"
-            f"}}"
-            f"QCheckBox::indicator{{"
-            f"width: 10px;"
-            f"height: 10px;"
-            f"border-radius: 2px;"
-            f"margin: 4px;"
-            f"}}"
-            f"QCheckBox::indicator:checked{{"
-            f"background: rgba{text_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::hover{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::focus{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"outline:none;"
-            f"}}"
-        )
+        self.border_checkbox.setStyleSheet(checkbox_style())
 
         # Add Widgets to Layout ================================================
         self.root_layout.addWidget(self.preview_widget)

src/tagstudio/qt/mixed/build_tag.py

@@ -3,6 +3,7 @@
 
 
 import sys
+from collections.abc import Callable
 from typing import cast, override
 
 import structlog
@@ -24,7 +25,6 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from tagstudio.core.library.alchemy.enums import TagColorEnum
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Tag, TagColorGroup
 from tagstudio.core.utils.types import unwrap
@@ -38,22 +38,29 @@ from tagstudio.qt.mixed.tag_widget import (
     get_primary_color,
     get_text_color,
 )
-from tagstudio.qt.models.palette import ColorType, UiColor, get_tag_color, get_ui_color
+from tagstudio.qt.models.palette import ColorType, UiColor, get_ui_color
 from tagstudio.qt.translations import Translations
 from tagstudio.qt.views.panel_modal import PanelModal, PanelWidget
+from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style
 from tagstudio.qt.views.tag_search_panel_view import TagSearchPanelView
 
 logger = structlog.get_logger(__name__)
 
 
 class CustomTableItem(QLineEdit):
-    def __init__(self, text, on_return, on_backspace, parent=None):
+    def __init__(
+        self,
+        text: str,
+        on_return: Callable[..., None],
+        on_backspace: Callable[..., None],
+        parent: QWidget | None = None,
+    ):
         super().__init__(parent)
         self.setText(text)
-        self.on_return = on_return
-        self.on_backspace = on_backspace
+        self.on_return: Callable[..., None] = on_return
+        self.on_backspace: Callable[..., None] = on_backspace
 
-    def set_id(self, id):
+    def set_id(self, id: int):
         self.id = id
 
     @override
@@ -194,9 +201,9 @@ class BuildTagPanel(PanelWidget):
             self.tag_color_selection,
             chose_tag_color_title,
             chose_tag_color_title,
-            done_callback=lambda: self.choose_color_callback(
-                self.tag_color_selection.selected_color
-            ),
+        )
+        self.choose_color_modal.done.connect(
+            lambda: self.choose_color_callback(self.tag_color_selection.selected_color)
         )
         self.color_button.button.clicked.connect(self.choose_color_modal.show)
         self.color_layout.addWidget(self.color_button)
@@ -211,38 +218,7 @@ class BuildTagPanel(PanelWidget):
         self.cat_title = QLabel(Translations["tag.is_category"])
         self.cat_checkbox = QCheckBox()
         self.cat_checkbox.setFixedSize(22, 22)
-
-        primary_color = QColor(get_tag_color(ColorType.PRIMARY, TagColorEnum.DEFAULT))
-        border_color = get_border_color(primary_color)
-        highlight_color = get_highlight_color(primary_color)
-        text_color: QColor = get_text_color(primary_color, highlight_color)
-
-        self.cat_checkbox.setStyleSheet(
-            f"QCheckBox{{"
-            f"background: rgba{primary_color.toTuple()};"
-            f"color: rgba{text_color.toTuple()};"
-            f"border-color: rgba{border_color.toTuple()};"
-            f"border-radius: 6px;"
-            f"border-style:solid;"
-            f"border-width: 2px;"
-            f"}}"
-            f"QCheckBox::indicator{{"
-            f"width: 10px;"
-            f"height: 10px;"
-            f"border-radius: 2px;"
-            f"margin: 4px;"
-            f"}}"
-            f"QCheckBox::indicator:checked{{"
-            f"background: rgba{text_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::hover{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::focus{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"outline:none;"
-            f"}}"
-        )
+        self.cat_checkbox.setStyleSheet(checkbox_style())
         self.cat_layout.addWidget(self.cat_checkbox)
         self.cat_layout.addWidget(self.cat_title)
 
@@ -256,33 +232,7 @@ class BuildTagPanel(PanelWidget):
         self.hidden_title = QLabel(Translations["tag.is_hidden"])
         self.hidden_checkbox = QCheckBox()
         self.hidden_checkbox.setFixedSize(22, 22)
-
-        self.hidden_checkbox.setStyleSheet(
-            f"QCheckBox{{"
-            f"background: rgba{primary_color.toTuple()};"
-            f"color: rgba{text_color.toTuple()};"
-            f"border-color: rgba{border_color.toTuple()};"
-            f"border-radius: 6px;"
-            f"border-style:solid;"
-            f"border-width: 2px;"
-            f"}}"
-            f"QCheckBox::indicator{{"
-            f"width: 10px;"
-            f"height: 10px;"
-            f"border-radius: 2px;"
-            f"margin: 4px;"
-            f"}}"
-            f"QCheckBox::indicator:checked{{"
-            f"background: rgba{text_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::hover{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::focus{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"outline:none;"
-            f"}}"
-        )
+        self.hidden_checkbox.setStyleSheet(checkbox_style())
         self.hidden_layout.addWidget(self.hidden_checkbox)
         self.hidden_layout.addWidget(self.hidden_title)
 
@@ -301,7 +251,7 @@ class BuildTagPanel(PanelWidget):
         self.parent_ids: set[int] = set()
         self.alias_ids: list[int] = []
         self.alias_names: list[str] = []
-        self.new_alias_names: dict = {}
+        self.new_alias_names: dict[int, str] = {}
         self.new_item_id = sys.maxsize
 
         self.set_tag(tag or Tag(name=Translations["tag.new"]))
@@ -317,7 +267,7 @@ class BuildTagPanel(PanelWidget):
             item = self.aliases_table.cellWidget(i, 1)
             if (
                 isinstance(item, CustomTableItem)
-                and cast(CustomTableItem, item).id == cast(CustomTableItem, focused_widget).id
+                and item.id == cast(CustomTableItem, focused_widget).id
             ):
                 cast(QPushButton, self.aliases_table.cellWidget(i, 0)).click()
                 remove_row = i
@@ -359,7 +309,7 @@ class BuildTagPanel(PanelWidget):
         item = self.aliases_table.cellWidget(row, 1)
         item.setFocus()
 
-    def remove_alias_callback(self, alias_name: str, alias_id: int):
+    def remove_alias_callback(self, alias_id: int):
         logger.info("remove_alias_callback")
 
         self.alias_ids.remove(alias_id)
@@ -530,7 +480,7 @@ class BuildTagPanel(PanelWidget):
         for alias_id in self.alias_ids:
             alias = self.lib.get_alias(self.tag.id, alias_id)
 
-            alias_name = alias.name if alias else self.new_alias_names[alias_id]
+            alias_name: str = alias.name if alias else self.new_alias_names[alias_id]
 
             # handel when an alias name changes
             if alias_id in self.new_alias_names:
@@ -539,9 +489,7 @@ class BuildTagPanel(PanelWidget):
             self.alias_names.append(alias_name)
 
             remove_btn = QPushButton("-")
-            remove_btn.clicked.connect(
-                lambda a=alias_name, id=alias_id: self.remove_alias_callback(a, id)
-            )
+            remove_btn.clicked.connect(lambda id=alias_id: self.remove_alias_callback(id))
 
             row = self.aliases_table.rowCount()
             new_item = CustomTableItem(alias_name, self.enter, self.backspace)
@@ -619,6 +567,7 @@ class BuildTagPanel(PanelWidget):
         logger.info("built tag", tag=tag)
         return tag
 
+    @override
     def parent_post_init(self):
         self.setTabOrder(self.name_field, self.shorthand_field)
         self.setTabOrder(self.shorthand_field, self.aliases_add_button)

src/tagstudio/qt/mixed/color_box.py

@@ -134,7 +134,7 @@ class ColorBoxWidget(FieldWidget):
         self.edit_modal = PanelModal(
             build_color_panel,
             "Edit Color",
-            has_save=True,
+            is_savable=True,
         )
 
         self.edit_modal.saved.connect(

src/tagstudio/qt/mixed/datetime_picker.py

@@ -3,12 +3,11 @@
 
 
 import typing
-from collections.abc import Callable
 from datetime import datetime as dt
-from typing import cast
+from typing import cast, override
 
 from PySide6.QtCore import QDateTime
-from PySide6.QtWidgets import QDateTimeEdit, QVBoxLayout
+from PySide6.QtWidgets import QDateTimeEdit, QLineEdit, QVBoxLayout
 
 from tagstudio.qt.views.panel_modal import PanelWidget
 
@@ -40,11 +39,16 @@ def qdtf2dtf(dtf: str) -> str:
 
 
 class DatetimePicker(PanelWidget):
-    def __init__(self, driver: "QtDriver", datetime: dt | str):
+    def __init__(self, driver: "QtDriver", name: str, datetime: dt | str):
         super().__init__()
+        self.setMinimumSize(300, 60)
         self.root_layout = QVBoxLayout(self)
         self.root_layout.setContentsMargins(6, 0, 6, 0)
 
+        self.name_field = QLineEdit()
+        self.name_field.setStyleSheet("font-weight:bold;font-size:14px;padding-top:6px")
+        self.name_field.setText(name)
+
         if isinstance(datetime, str):
             datetime = DatetimePicker.string2dt(datetime)
         self.datetime_edit = QDateTimeEdit()
@@ -55,20 +59,24 @@ class DatetimePicker(PanelWidget):
         self.datetime_edit.setDisplayFormat(qdtf2dtf(driver.settings.datetime_format))
 
         self.initial_value = datetime
+        self.root_layout.addWidget(self.name_field)
         self.root_layout.addWidget(self.datetime_edit)
 
-    def get_content(self):
-        return DatetimePicker.dt2string(DatetimePicker.qdt2dt(self.datetime_edit.dateTime()))
+    @override
+    def saved_data(self) -> dict[str, str]:
+        return {
+            "name": self.name_field.text(),
+            "value": DatetimePicker.dt2string(DatetimePicker.qdt2dt(self.datetime_edit.dateTime())),
+        }
 
+    @override
+    def parent_post_init(self):
+        self.datetime_edit.setFocus()
+
+    @override
     def reset(self):
         self.datetime_edit.setDateTime(DatetimePicker.dt2qdt(self.initial_value))
 
-    def add_callback(self, callback: Callable, event: str = "returnPressed"):
-        if event == "returnPressed":
-            pass
-        else:
-            raise ValueError(f"unknown event type: {event}")
-
     @staticmethod
     def qdt2dt(qdt: QDateTime) -> dt:
         return cast(dt, qdt.toPython())

src/tagstudio/qt/mixed/field_containers.py

@@ -2,10 +2,10 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
-import sys
 import typing
 from collections.abc import Callable
 from datetime import datetime as dt
+from functools import partial
 from warnings import catch_warnings
 
 import structlog
@@ -31,13 +31,12 @@ from tagstudio.core.library.alchemy.fields import (
 from tagstudio.core.library.alchemy.library import Library
 from tagstudio.core.library.alchemy.models import Entry, Tag
 from tagstudio.core.utils.types import unwrap
+from tagstudio.qt.controllers.edit_text_controller import EditText
 from tagstudio.qt.controllers.tag_box_controller import TagBoxWidget
 from tagstudio.qt.mixed.datetime_picker import DatetimePicker
 from tagstudio.qt.mixed.field_widget import FieldContainer
-from tagstudio.qt.mixed.text_field import TextWidget
+from tagstudio.qt.mixed.text_field import TextContainerWidget
 from tagstudio.qt.translations import FIELD_TYPE_KEYS, Translations
-from tagstudio.qt.views.edit_text_box_modal import EditTextBox
-from tagstudio.qt.views.edit_text_line_modal import EditTextLine
 from tagstudio.qt.views.panel_modal import PanelModal
 
 if typing.TYPE_CHECKING:
@@ -47,7 +46,7 @@ logger = structlog.get_logger(__name__)
 
 
 class FieldContainers(QWidget):
-    """The Preview Panel Widget."""
+    """Widget for the tag and field containers displayed inside the Preview Panel."""
 
     def __init__(self, library: Library, driver: "QtDriver") -> None:
         super().__init__()
@@ -102,6 +101,11 @@ class FieldContainers(QWidget):
         root_layout.setContentsMargins(0, 0, 0, 0)
         root_layout.addWidget(self.scroll_area)
 
+    @property
+    def top_entry_id(self) -> int:
+        """Get the topmost entry ID in the (cached) selected entries."""
+        return self.cached_entries[0].id
+
     def update_from_entry(self, entry_id: int, update_badges: bool = True) -> None:
         """Update tags and fields from a single Entry source."""
         logger.warning("[FieldContainers] Updating Selection", entry_id=entry_id)
@@ -130,7 +134,7 @@ class FieldContainers(QWidget):
 
         # Write field container(s)
         for index, field in enumerate(entry_fields, start=container_index):
-            self.write_container(index, field, is_mixed=False)
+            self.write_field_container(index, field, is_mixed=False)
 
         # Hide leftover container(s)
         if len(self.containers) > container_len:
@@ -233,36 +237,142 @@ class FieldContainers(QWidget):
                 )
                 self.lib.add_field_to_entries(entry_id, field_template.to_field())
 
-    def add_tags_to_selected(self, tags: int | list[int]) -> None:
+    def add_tags_to_selected(self, tag_ids: int | list[int]) -> None:
         """Add list of tags to one or more selected items.
 
         Uses the current driver selection, NOT the field containers cache.
         """
-        if isinstance(tags, int):
-            tags = [tags]
+        if isinstance(tag_ids, int):
+            tag_ids = [tag_ids]
         logger.info(
             "[FieldContainers][add_tags_to_selected]",
             selected=self.driver.selected,
-            tags=tags,
+            tag_ids=tag_ids,
         )
-        self.driver.add_tags_to_selected_callback(tags)
+        self.driver.add_tags_to_selected_callback(tag_ids)
 
-    def write_container(self, index: int, field: BaseField, is_mixed: bool = False) -> None:
-        """Update/Create data for a FieldContainer.
+    def write_field_container(self, index: int, field: BaseField, is_mixed: bool = False) -> None:
+        """Update/Create data for a field FieldContainer.
 
         Args:
             index(int): The container index.
-            field(BaseField): The type of field to write to.
+            field(BaseField): The field to write in this container.
             is_mixed(bool): Relevant when multiple items are selected.
-
-            If True, field is not present in all selected items.
+                If True, field is not present in all selected items.
         """
+
+        def update_text_field_callback(
+            field: TextField, entry_id: int, content: dict[str, str | bool]
+        ) -> None:
+            """Callback called when a text field has updated data."""
+            self._update_text_field(
+                field, str(content["name"]), str(content["value"]), bool(content["is_multiline"])
+            )
+            self.update_from_entry(entry_id)
+
+        def update_datetime_field_callback(
+            field: DatetimeField, entry_id: int, content: dict[str, str]
+        ) -> None:
+            """Callback called when a datetime field has updated data."""
+            self.update_datetime_field(field, str(content["name"]), str(content["value"]))
+            self.update_from_entry(entry_id)
+
+        def remove_field_callback(field: BaseField, entry_id: int) -> None:
+            """Callback called when a field needs to be removed from an entry."""
+            self._remove_field(field)
+            self.update_from_entry(entry_id)
+
+        def write_text_container(
+            container: FieldContainer, field: TextField, title: str, is_mixed: bool
+        ):
+            container.set_title(field.name)
+
+            # Normalize line endings in any text content.
+            if not is_mixed:
+                assert isinstance(field.value, str | type(None))
+                text = (field.value or "").replace("\r", "\n")
+            else:
+                text = f"<i>{Translations['field.mixed_data']}</i>"
+
+            inner_widget = TextContainerWidget(title, text)
+            container.set_inner_widget(inner_widget)
+
+            if not is_mixed:
+                edit_modal = PanelModal(
+                    EditText(field.name, field.value, field.is_multiline),
+                    window_title=f"{Translations['field.edit']} ({Translations[field_name_key]})",
+                    is_savable=True,
+                    inline_title=False,
+                )
+                edit_modal.saved_data.connect(
+                    partial(update_text_field_callback, field, self.top_entry_id)
+                )
+
+                container.set_edit_callback(edit_modal.show)
+                container.set_remove_callback(
+                    lambda: self.remove_message_box(
+                        prompt=self.remove_field_prompt(title),
+                        callback=partial(remove_field_callback, field, self.top_entry_id),
+                    )
+                )
+
+        def write_datetime_container(
+            container: FieldContainer, field: DatetimeField, title: str, is_mixed: bool
+        ):
+            container.set_title(field.name)
+
+            if not is_mixed:
+                try:
+                    assert field.value is not None
+                    text = self.driver.settings.format_datetime(
+                        DatetimePicker.string2dt(field.value)
+                    )
+                except (ValueError, AssertionError):
+                    text = str(field.value)
+            else:
+                text = f"<i>{Translations['field.mixed_data']}</i>"
+
+            inner_widget = TextContainerWidget(title, text)
+            container.set_inner_widget(inner_widget)
+
+            if not is_mixed:
+                edit_modal = PanelModal(
+                    DatetimePicker(self.driver, field.name, field.value or dt.now()),
+                    window_title=f"{Translations['field.edit']} ({Translations[field_name_key]})",
+                    is_savable=True,
+                    inline_title=False,
+                )
+                edit_modal.saved_data.connect(
+                    partial(update_datetime_field_callback, field, self.top_entry_id)
+                )
+
+                container.set_edit_callback(edit_modal.show)
+                container.set_remove_callback(
+                    lambda: self.remove_message_box(
+                        prompt=self.remove_field_prompt(field.name),
+                        callback=partial(remove_field_callback, field, self.top_entry_id),
+                    )
+                )
+
+        def write_unknown_container():
+            container.set_title(field.name)
+            inner_widget = TextContainerWidget(title, field.name)
+            container.set_inner_widget(inner_widget)
+            container.set_remove_callback(
+                lambda: self.remove_message_box(
+                    prompt=self.remove_field_prompt(field.name),
+                    callback=partial(remove_field_callback, field, self.top_entry_id),
+                )
+            )
+
         logger.info(
             "[FieldContainers][write_container]",
             index=index,
             name=field.name,
             type=field.class_name,
         )
+
+        # Create new containers if necessary
         if len(self.containers) < (index + 1):
             container = FieldContainer()
             self.containers.append(container)
@@ -274,156 +384,27 @@ class FieldContainers(QWidget):
         field_name_key: str = FIELD_TYPE_KEYS.get(field.class_name, "field_type.unknown")
         title = f"{field.name} ({Translations[field_name_key]})"
 
-        # Single-line Text
-        if type(field) is TextField and not field.is_multiline:
-            container.set_title(field.name)
-            container.set_inline(False)
-
-            # Normalize line endings in any text content.
-            if not is_mixed:
-                assert isinstance(field.value, str | type(None))
-                text = field.value or ""
-            else:
-                text = "<i>Mixed Data</i>"  # TODO: Localize this
-
-            inner_widget = TextWidget(title, text)
-            container.set_inner_widget(inner_widget)
-            if not is_mixed:
-                modal = PanelModal(
-                    EditTextLine(field.value),
-                    title=title,
-                    window_title=f"Edit {field.name}",  # TODO: Localize this
-                    save_callback=(  # pyright: ignore[reportArgumentType]
-                        lambda content: (
-                            self.update_text_field(field, content, is_multiline=False),
-                            self.update_from_entry(self.cached_entries[0].id),
-                        )
-                    ),
-                )
-                if "pytest" in sys.modules:
-                    # for better testability
-                    container.modal = modal  # pyright: ignore[reportAttributeAccessIssue]
-
-                container.set_edit_callback(modal.show)
-                container.set_remove_callback(
-                    lambda: self.remove_message_box(
-                        prompt=self.remove_field_prompt(title),
-                        callback=lambda: (
-                            self.remove_field(field),
-                            self.update_from_entry(self.cached_entries[0].id),
-                        ),
-                    )
-                )
-
-        # Multiline Text
-        elif type(field) is TextField and field.is_multiline:
-            container.set_title(field.name)
-            container.set_inline(False)
-            # Normalize line endings in any text content.
-            if not is_mixed:
-                assert isinstance(field.value, str | type(None))
-                text = (field.value or "").replace("\r", "\n")
-            else:
-                text = "<i>Mixed Data</i>"  # TODO: Localize this
-            inner_widget = TextWidget(title, text)
-            container.set_inner_widget(inner_widget)
-            if not is_mixed:
-                modal = PanelModal(
-                    EditTextBox(field.value),
-                    title=title,
-                    window_title=f"Edit {field.name}",  # TODO: Localize this
-                    save_callback=(  # pyright: ignore[reportArgumentType]
-                        lambda content: (
-                            self.update_text_field(field, content, is_multiline=True),
-                            self.update_from_entry(self.cached_entries[0].id),
-                        )
-                    ),
-                )
-                container.set_edit_callback(modal.show)
-                container.set_remove_callback(
-                    lambda: self.remove_message_box(
-                        prompt=self.remove_field_prompt(field.name),
-                        callback=lambda: (
-                            self.remove_field(field),
-                            self.update_from_entry(self.cached_entries[0].id),
-                        ),
-                    )
-                )
-
+        # Write containers
+        if type(field) is TextField:
+            write_text_container(container, field, title, is_mixed)
         elif type(field) is DatetimeField:
-            logger.info("[FieldContainers][write_container] Datetime Field", field=field)
-            if not is_mixed:
-                container.set_title(field.name)
-                container.set_inline(False)
-
-                try:
-                    assert field.value is not None
-                    text = self.driver.settings.format_datetime(
-                        DatetimePicker.string2dt(field.value)
-                    )
-                except (ValueError, AssertionError):
-                    text = str(field.value)
-
-                inner_widget = TextWidget(title, text)
-                container.set_inner_widget(inner_widget)
-
-                modal = PanelModal(
-                    DatetimePicker(self.driver, field.value or dt.now()),
-                    title=f"Edit {field.name}",
-                    save_callback=(  # pyright: ignore[reportArgumentType]
-                        lambda content: (
-                            self.update_datetime_field(field, content),
-                            self.update_from_entry(self.cached_entries[0].id),
-                        )
-                    ),
-                )
-
-                container.set_edit_callback(modal.show)
-                container.set_remove_callback(
-                    lambda: self.remove_message_box(
-                        prompt=self.remove_field_prompt(field.name),
-                        callback=lambda: (
-                            self.remove_field(field),
-                            self.update_from_entry(self.cached_entries[0].id),
-                        ),
-                    )
-                )
-            else:
-                text = "<i>Mixed Data</i>"  # TODO: Localize this
-                inner_widget = TextWidget(title, text)
-                container.set_inner_widget(inner_widget)
+            write_datetime_container(container, field, title, is_mixed)
         else:
-            logger.warning(
-                "[FieldContainers][write_container] Unknown Field", field=field
-            )  # TODO: Localize this
-            container.set_title(field.name)
-            container.set_inline(False)
-            inner_widget = TextWidget(title, field.name)
-            container.set_inner_widget(inner_widget)
-            container.set_remove_callback(
-                lambda: self.remove_message_box(
-                    prompt=self.remove_field_prompt(field.name),
-                    callback=lambda: (
-                        self.remove_field(field),
-                        self.update_from_entry(self.cached_entries[0].id),
-                    ),
-                )
-            )
+            write_unknown_container()
 
         container.setHidden(False)
 
     def write_tag_container(
         self, index: int, tags: set[Tag], category_tag: Tag | None = None, is_mixed: bool = False
     ) -> None:
-        """Update/Create tag data for a FieldContainer.
+        """Update/Create tag data for a tag FieldContainer.
 
         Args:
             index(int): The container index.
             tags(set[Tag]): The list of tags for this container.
             category_tag(Tag|None): The category tag this container represents.
             is_mixed(bool): Relevant when multiple items are selected.
-
-            If True, field is not present in all selected items.
+                If True, field is not present in all selected items.
         """
         logger.info("[FieldContainers][write_tag_container]", index=index)
         if len(self.containers) < (index + 1):
@@ -433,10 +414,7 @@ class FieldContainers(QWidget):
         else:
             container = self.containers[index]
 
-        container.set_title(
-            "Tags" if not category_tag else category_tag.name
-        )  # TODO: Localize this
-        container.set_inline(False)
+        container.set_title(Translations["entries.tags"] if not category_tag else category_tag.name)
 
         if not is_mixed:
             inner_widget = container.get_inner_widget()
@@ -446,10 +424,7 @@ class FieldContainers(QWidget):
                     inner_widget.on_update.disconnect()
 
             else:
-                inner_widget = TagBoxWidget(
-                    "Tags",  # TODO: Localize this
-                    self.driver,
-                )
+                inner_widget = TagBoxWidget(Translations["entries.tags"], self.driver)
                 container.set_inner_widget(inner_widget)
             inner_widget.set_entries([e.id for e in self.cached_entries])
             inner_widget.set_tags(tags)
@@ -458,15 +433,15 @@ class FieldContainers(QWidget):
                 lambda: self.update_from_entry(self.cached_entries[0].id, update_badges=True)
             )
         else:
-            text = "<i>Mixed Data</i>"
-            inner_widget = TextWidget("Mixed Tags", text)
+            text = f"<i>{Translations['field.mixed_data']}</i>"
+            inner_widget = TextContainerWidget("Mixed Tags", text)
             container.set_inner_widget(inner_widget)
 
         container.set_edit_callback()
         container.set_remove_callback()
         container.setHidden(False)
 
-    def remove_field(self, field: BaseField) -> None:
+    def _remove_field(self, field: BaseField) -> None:
         """Remove a field from all selected Entries."""
         logger.info(
             "[FieldContainers] Removing Field",
@@ -476,24 +451,26 @@ class FieldContainers(QWidget):
         entry_ids = [e.id for e in self.cached_entries]
         self.lib.remove_entry_field(field, entry_ids)
 
-    def update_text_field(self, field: TextField, value: str, is_multiline: bool) -> None:
+    def _update_text_field(
+        self, field: TextField, name: str, value: str, is_multiline: bool
+    ) -> None:
         """Update a text field across selected entries."""
         entry_ids = [e.id for e in self.cached_entries]
         assert entry_ids, "No entries selected"
 
-        self.lib.update_text_field(entry_ids, field, value, is_multiline)
+        self.lib.update_text_field(entry_ids, field, name, value, is_multiline)
 
-    def update_datetime_field(self, field: DatetimeField, value: str) -> None:
+    def update_datetime_field(self, field: DatetimeField, name: str, value: str) -> None:
         """Update a datetime field across selected entries."""
         entry_ids = [e.id for e in self.cached_entries]
         assert entry_ids, "No entries selected"
 
-        self.lib.update_datetime_field(entry_ids, field, dt.fromisoformat(value))
+        self.lib.update_datetime_field(entry_ids, field, name, dt.fromisoformat(value))
 
-    def remove_message_box(self, prompt: str, callback: Callable) -> None:
+    def remove_message_box(self, prompt: str, callback: Callable[..., None]) -> None:
         remove_mb = QMessageBox()
         remove_mb.setText(prompt)
-        remove_mb.setWindowTitle("Remove Field")  # TODO: Localize
+        remove_mb.setWindowTitle(Translations["Remove Field"])
         remove_mb.setIcon(QMessageBox.Icon.Warning)
         cancel_button = remove_mb.addButton(
             Translations["generic.cancel_alt"], QMessageBox.ButtonRole.DestructiveRole

src/tagstudio/qt/mixed/field_widget.py

@@ -53,7 +53,6 @@ class FieldContainer(QWidget):
         super().__init__()
         self.setObjectName("fieldContainer")
         self.title: str = title
-        self.inline: bool = inline
         self.copy_callback: Callable[[], None] | None = None
         self.edit_callback: Callable[[], None] | None = None
         self.remove_callback: Callable[[], None] | None = None
@@ -170,9 +169,6 @@ class FieldContainer(QWidget):
         self.title = self.title = f"<h4>{title}</h4>"
         self.title_widget.setText(self.title)
 
-    def set_inline(self, inline: bool) -> None:
-        self.inline = inline
-
     @override
     def enterEvent(self, event: QEnterEvent) -> None:
         # NOTE: You could pass the hover event to the FieldWidget if needed.

src/tagstudio/qt/mixed/landing.py

@@ -12,9 +12,9 @@ from PySide6.QtCore import QEasingCurve, QPoint, QPropertyAnimation, Qt
 from PySide6.QtGui import QPixmap
 from PySide6.QtWidgets import QLabel, QPushButton, QVBoxLayout, QWidget
 
+from tagstudio.qt.controllers.clickable_label import ClickableLabel
 from tagstudio.qt.helpers.color_overlay import gradient_overlay, theme_fg_overlay
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.clickable_label import ClickableLabel
 
 # Only import for type checking/autocompletion, will not be imported at runtime.
 if typing.TYPE_CHECKING:

src/tagstudio/qt/mixed/settings_panel.py

@@ -356,9 +356,9 @@ class SettingsPanel(PanelWidget):
         modal = PanelModal(
             widget=settings_panel,
             window_title=Translations["settings.title"],
-            done_callback=lambda: settings_panel.update_settings(driver),
-            has_save=True,
+            is_savable=True,
         )
+        modal.done.connect(lambda: settings_panel.update_settings(driver))
         modal.title_widget.setVisible(False)
 
         return modal

src/tagstudio/qt/mixed/tag_color_manager.py

@@ -176,7 +176,7 @@ class TagColorManager(QWidget):
         self.create_namespace_modal = PanelModal(
             build_namespace_panel,
             Translations["namespace.create.title"],
-            has_save=True,
+            is_savable=True,
         )
 
         self.create_namespace_modal.saved.connect(

src/tagstudio/qt/mixed/tag_widget.py

@@ -156,15 +156,15 @@ class TagWidget(QWidget):
         self.inner_layout.setObjectName("innerLayout")
         self.inner_layout.setContentsMargins(0, 0, 0, 0)
 
-        self.remove_button = QPushButton(self)
-        self.remove_button.setFlat(True)
-        self.remove_button.setText("–")
-        self.remove_button.setHidden(True)
-        self.remove_button.setMinimumSize(22, 22)
-        self.remove_button.setMaximumSize(22, 22)
-        self.remove_button.clicked.connect(self.on_remove.emit)
-        self.remove_button.setHidden(True)
-        self.inner_layout.addWidget(self.remove_button)
+        self._delete_button = QPushButton(self)
+        self._delete_button.setFlat(True)
+        self._delete_button.setText("–")
+        self._delete_button.setHidden(True)
+        self._delete_button.setMinimumSize(22, 22)
+        self._delete_button.setMaximumSize(22, 22)
+        self._delete_button.clicked.connect(self.on_remove.emit)
+        self._delete_button.setHidden(True)
+        self.inner_layout.addWidget(self._delete_button)
         self.inner_layout.addStretch(1)
 
         self.bg_button.setLayout(self.inner_layout)
@@ -236,7 +236,7 @@ class TagWidget(QWidget):
             f"}}"
         )
 
-        self.remove_button.setStyleSheet(
+        self._delete_button.setStyleSheet(
             f"QPushButton{{"
             f"color: rgba{primary_color.toTuple()};"
             f"background: rgba{text_color.toTuple()};"
@@ -275,14 +275,14 @@ class TagWidget(QWidget):
     @override
     def enterEvent(self, event: QEnterEvent) -> None:
         if self.has_remove:
-            self.remove_button.setHidden(False)
+            self._delete_button.setHidden(False)
         self.update()
         return super().enterEvent(event)
 
     @override
     def leaveEvent(self, event: QEvent) -> None:
         if self.has_remove:
-            self.remove_button.setHidden(True)
+            self._delete_button.setHidden(True)
         self.update()
         return super().leaveEvent(event)
 

src/tagstudio/qt/mixed/text_field.py

@@ -10,8 +10,8 @@ from PySide6.QtWidgets import QHBoxLayout, QLabel
 from tagstudio.qt.mixed.field_widget import FieldWidget
 
 
-class TextWidget(FieldWidget):
-    def __init__(self, title, text: str) -> None:
+class TextContainerWidget(FieldWidget):
+    def __init__(self, title: str, text: str) -> None:
         super().__init__(title)
         self.setObjectName("textBox")
         self.base_layout = QHBoxLayout()

src/tagstudio/qt/translations.py

@@ -83,7 +83,7 @@ class Translator:
             for k, v in self._strings.items():
                 self._strings[k] = remove_mnemonic_marker(v)
 
-    def __format(self, text: str, **kwargs) -> str:
+    def __format(self, text: str, **kwargs: ...) -> str:
         try:
             return text.format(**kwargs)
         except (KeyError, ValueError):
@@ -93,11 +93,11 @@ class Translator:
                 kwargs=kwargs,
                 language=self.__lang,
             )
-            params: defaultdict[str, Any] = defaultdict(lambda: "{unknown_key}")
+            params: defaultdict[str, Any] = defaultdict(lambda: "{unknown_key}")  # pyright: ignore[reportExplicitAny]
             params.update(kwargs)
             return text.format_map(params)
 
-    def format(self, key: str, **kwargs) -> str:
+    def format(self, key: str, **kwargs: ...) -> str:
         return self.__format(self[key], **kwargs)
 
     def __getitem__(self, key: str) -> str:

src/tagstudio/qt/ts_qt.py

@@ -24,7 +24,7 @@ from typing import TypeVar
 from warnings import catch_warnings
 
 import structlog
-from humanfriendly import format_size, format_timespan
+from humanfriendly import format_size, format_timespan  # pyright: ignore[reportUnknownVariableType]
 from PySide6.QtCore import QObject, QSettings, Qt, QThread, QThreadPool, QTimer, Signal
 from PySide6.QtGui import (
     QColor,
@@ -45,7 +45,8 @@ from PySide6.QtWidgets import (
     QScrollArea,
 )
 
-import tagstudio.qt.resources_rc  # noqa: F401
+# This import has side-effect of importing PySide resources
+import tagstudio.qt.resources_rc  # noqa: F401  # pyright: ignore[reportUnusedImport]
 from tagstudio.core.constants import TAG_ARCHIVED, TAG_FAVORITE, VERSION, VERSION_BRANCH
 from tagstudio.core.driver import DriverMixin
 from tagstudio.core.enums import MacroID, SettingItems, ShowFilepathOption
@@ -64,11 +65,7 @@ from tagstudio.core.utils.str_formatting import is_version_outdated
 from tagstudio.core.utils.types import unwrap
 from tagstudio.qt.cache_manager import CacheManager
 from tagstudio.qt.controllers.ffmpeg_missing_message_box import FfmpegMissingMessageBox
-from tagstudio.qt.controllers.field_template_search_panel_controller import (
-    FieldTemplateSearchPanel,
-)
-
-# this import has side-effect of import PySide resources
+from tagstudio.qt.controllers.field_template_search_panel_controller import FieldTemplateSearchPanel
 from tagstudio.qt.controllers.fix_ignored_modal_controller import FixIgnoredEntriesModal
 from tagstudio.qt.controllers.ignore_modal_controller import IgnoreModal
 from tagstudio.qt.controllers.library_info_window_controller import LibraryInfoWindow
@@ -376,10 +373,12 @@ class QtDriver(DriverMixin, QObject):
                 view=TagSearchPanelView(is_tag_chooser=False),
             ),
             title=Translations["tag_manager.title"],
-            done_callback=lambda checked=False: self.main_window.preview_panel.set_selection(
+            is_savable=False,
+        )
+        self.tag_manager_panel.done.connect(
+            lambda checked=False: self.main_window.preview_panel.set_selection(
                 self.selected, update_preview=False
-            ),
-            has_save=False,
+            )
         )
 
         # Initialize the Color Group Manager panel
@@ -393,10 +392,12 @@ class QtDriver(DriverMixin, QObject):
                 view=FieldTemplateSearchPanelView(is_field_template_chooser=False),
             ),
             title=Translations["field_template_manager.title"],
-            done_callback=lambda checked=False: self.main_window.preview_panel.set_selection(
+            is_savable=False,
+        )
+        self.field_template_manager_panel.done.connect(
+            lambda checked=False: self.main_window.preview_panel.set_selection(
                 self.selected, update_preview=False
-            ),
-            has_save=False,
+            )
         )
 
         # Initialize the Tag Search panel
@@ -741,7 +742,7 @@ class QtDriver(DriverMixin, QObject):
         self.ignore_modal = PanelModal(
             panel,
             Translations["menu.edit.ignore_files"],
-            has_save=True,
+            is_savable=True,
         )
         self.ignore_modal.saved.connect(panel.save)
         self.main_window.menu_bar.ignore_modal_action.triggered.connect(self.ignore_modal.show)
@@ -880,7 +881,7 @@ class QtDriver(DriverMixin, QObject):
             panel,
             Translations["tag.new"],
             Translations["tag.add"],
-            has_save=True,
+            is_savable=True,
         )
 
         self.modal.saved.connect(

src/tagstudio/qt/views/edit_field_template_modal_view.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+import structlog
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from tagstudio.qt.controllers.clickable_label import ClickableLabel
+from tagstudio.qt.translations import Translations
+from tagstudio.qt.views.panel_modal import PanelWidget
+from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style
+
+logger = structlog.get_logger(__name__)
+
+
+class EditFieldTemplateModalView(PanelWidget):
+    def __init__(self) -> None:
+        super().__init__()
+
+        # Layout Init
+        self.setMinimumSize(460, 200)
+        self.root_layout = QVBoxLayout(self)
+        self.root_layout.setContentsMargins(6, 0, 6, 0)
+        self.root_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+
+        # Field Name
+        self._name_widget = QWidget()
+        self._name_layout = QVBoxLayout(self._name_widget)
+        self._name_layout.setStretch(1, 1)
+        self._name_layout.setContentsMargins(0, 0, 0, 0)
+        self._name_layout.setSpacing(0)
+        self._name_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        self._name_title = QLabel(Translations["field.name"])
+        self._name_layout.addWidget(self._name_title)
+        self.name_field = QLineEdit()
+        self.name_field.setFixedHeight(24)
+        self.name_field.setPlaceholderText(Translations["field.field_name_required"])
+        self._name_layout.addWidget(self.name_field)
+
+        # Field Type
+        self._type_widget = QWidget()
+        self._type_layout = QVBoxLayout(self._type_widget)
+        self._type_layout.setStretch(1, 1)
+        self._type_layout.setContentsMargins(0, 0, 0, 0)
+        self._type_layout.setSpacing(0)
+        self._type_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        self._type_title = QLabel(Translations["field.type"])
+        self._type_layout.addWidget(self._type_title)
+        self._type_combobox = QComboBox()
+        self._type_combobox.setMinimumWidth(120)
+        self._type_layout.addWidget(self._type_combobox)
+
+        # Text Field Attributes --------------------------------------------------------------------
+        self._text_field_attributes_widget = QWidget()
+        self._text_field_attributes_layout = QHBoxLayout(self._text_field_attributes_widget)
+        self._text_field_attributes_layout.setStretch(1, 1)
+        self._text_field_attributes_layout.setContentsMargins(0, 0, 0, 0)
+        self._text_field_attributes_layout.setSpacing(6)
+
+        # Is Multiline
+        self._multiline_widget = QWidget()
+        self._multiline_layout = QHBoxLayout(self._multiline_widget)
+        self._multiline_layout.setStretch(1, 1)
+        self._multiline_layout.setContentsMargins(0, 0, 0, 0)
+        self._multiline_layout.setSpacing(6)
+        self._multiline_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        self._multiline_title = ClickableLabel(Translations["field.text.is_multiline"])
+        self._multiline_checkbox = QCheckBox()
+        self._multiline_checkbox.setFixedSize(22, 22)
+        self._multiline_checkbox.setStyleSheet(checkbox_style())
+        self._multiline_title.clicked.connect(self._multiline_checkbox.click)
+        self._multiline_layout.addWidget(self._multiline_checkbox)
+        self._multiline_layout.addWidget(self._multiline_title)
+        self._text_field_attributes_layout.addWidget(self._multiline_widget)
+
+        # NOTE: Future options specific to other type will go in their own sections,
+        # following the pattern with text fields above.
+
+        # Add Widgets to Layout ====================================================================
+        self.root_layout.addWidget(self._name_widget)
+        self.root_layout.addWidget(self._type_widget)
+        self.root_layout.addWidget(self._text_field_attributes_widget)

src/tagstudio/qt/views/edit_text_box_modal.py

@@ -1,25 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-
-from PySide6.QtWidgets import QPlainTextEdit, QVBoxLayout
-
-from tagstudio.qt.views.panel_modal import PanelWidget
-
-
-class EditTextBox(PanelWidget):
-    def __init__(self, text):
-        super().__init__()
-        self.setMinimumSize(480, 480)
-        self.root_layout = QVBoxLayout(self)
-        self.root_layout.setContentsMargins(6, 0, 6, 0)
-        self.text = text
-        self.text_edit = QPlainTextEdit()
-        self.text_edit.setPlainText(text)
-        self.root_layout.addWidget(self.text_edit)
-
-    def get_content(self) -> str:
-        return self.text_edit.toPlainText()
-
-    def reset(self):
-        self.text_edit.setPlainText(self.text)

src/tagstudio/qt/views/edit_text_line_modal.py

@@ -1,33 +0,0 @@
-# SPDX-FileCopyrightText: (c) TagStudio Contributors
-# SPDX-License-Identifier: GPL-3.0-only
-
-
-from collections.abc import Callable
-
-from PySide6.QtWidgets import QLineEdit, QVBoxLayout
-
-from tagstudio.qt.views.panel_modal import PanelWidget
-
-
-class EditTextLine(PanelWidget):
-    def __init__(self, text):
-        super().__init__()
-        self.setMinimumWidth(480)
-        self.root_layout = QVBoxLayout(self)
-        self.root_layout.setContentsMargins(6, 0, 6, 0)
-        self.text = text
-        self.text_edit = QLineEdit()
-        self.text_edit.setText(text)
-        self.root_layout.addWidget(self.text_edit)
-
-    def get_content(self) -> str:
-        return self.text_edit.text()
-
-    def reset(self):
-        self.text_edit.setText(self.text)
-
-    def add_callback(self, callback: Callable, event: str = "returnPressed"):
-        if event == "returnPressed":
-            self.text_edit.returnPressed.connect(callback)
-        else:
-            raise ValueError(f"unknown event type: {event}")

src/tagstudio/qt/views/edit_text_view.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+
+from PySide6.QtGui import Qt
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QHBoxLayout,
+    QLineEdit,
+    QPlainTextEdit,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from tagstudio.qt.controllers.clickable_label import ClickableLabel
+from tagstudio.qt.translations import Translations
+from tagstudio.qt.views.panel_modal import PanelWidget
+from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style
+
+
+class EditTextView(PanelWidget):
+    def __init__(self):
+        super().__init__()
+        self.setMinimumSize(480, 240)
+        self.root_layout = QVBoxLayout(self)
+        self.root_layout.setContentsMargins(6, 0, 6, 0)
+
+        self.name_field = QLineEdit()
+        self.name_field.setStyleSheet("font-weight:bold;font-size:14px;padding-top:6px")
+
+        self.text_box = QPlainTextEdit()
+        self.text_line = QLineEdit()
+        self.text_line_stretch = QWidget()
+        self.text_line_stretch.setSizePolicy(
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
+        )
+
+        # Is Multiline
+        self.multiline_widget = QWidget()
+        self.multiline_layout = QHBoxLayout(self.multiline_widget)
+        self.multiline_layout.setStretch(1, 1)
+        self.multiline_layout.setContentsMargins(0, 0, 0, 0)
+        self.multiline_layout.setSpacing(6)
+        self.multiline_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        self.multiline_title = ClickableLabel(Translations["field.text.is_multiline"])
+        self.multiline_checkbox = QCheckBox()
+        self.multiline_checkbox.setFixedSize(22, 22)
+        self.multiline_checkbox.setStyleSheet(checkbox_style())
+        self.multiline_title.clicked.connect(self.multiline_checkbox.click)
+        self.multiline_layout.addWidget(self.multiline_checkbox)
+        self.multiline_layout.addWidget(self.multiline_title)
+
+        self.root_layout.addWidget(self.name_field)
+        self.root_layout.addWidget(self.text_box)
+        self.root_layout.setStretch(2, 1)
+        self.root_layout.addWidget(self.text_line)
+        self.root_layout.addWidget(self.text_line_stretch)
+        self.root_layout.setStretch(4, 1)
+        self.root_layout.addWidget(self.multiline_widget)

src/tagstudio/qt/views/field_template_search_panel_view.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 
+from typing import override
+
 from PySide6.QtWidgets import QWidget
 
 from tagstudio.core.library.alchemy.library import Library
@@ -16,6 +18,7 @@ class FieldTemplateSearchPanelView(SearchPanelView):
         self.search_field.setPlaceholderText(Translations["home.search_field_templates"])
         self.create_button.setText(Translations["field_template.create"])
 
+    @override
     def get_item_widget(self, index: int, library: Library | None) -> FieldTemplateWidget:
         """Gets the item widget at a specific index."""
         # Create any new item widgets needed up to the given index

src/tagstudio/qt/views/field_template_widget_view.py

@@ -72,18 +72,18 @@ class FieldTemplateWidgetView(QWidget):
         self.__inner_layout.setContentsMargins(0, 0, 0, 0)
 
         # Remove button
-        self.__remove_button = QPushButton(self)
-        self.__remove_button.setFlat(True)
-        self.__remove_button.setText("–")
-        self.__remove_button.setHidden(True)
-        self.__remove_button.setMinimumSize(22, 22)
-        self.__remove_button.setMaximumSize(22, 22)
+        self._delete_button = QPushButton(self)
+        self._delete_button.setFlat(True)
+        self._delete_button.setText("–")
+        self._delete_button.setHidden(True)
+        self._delete_button.setMinimumSize(22, 22)
+        self._delete_button.setMaximumSize(22, 22)
 
-        self.__inner_layout.addWidget(self.__remove_button)
+        self.__inner_layout.addWidget(self._delete_button)
         self.__inner_layout.addStretch(1)
 
         self.__connect_callbacks()
 
     def __connect_callbacks(self) -> None:
         self._bg_button.clicked.connect(self.on_click.emit)
-        self.__remove_button.clicked.connect(self.on_remove.emit)
+        self._delete_button.clicked.connect(self.on_remove.emit)

src/tagstudio/qt/views/main_window.py

@@ -10,7 +10,7 @@ import structlog
 from PIL import Image, ImageQt
 from PySide6 import QtCore
 from PySide6.QtCore import QMetaObject, QSize, QStringListModel, Qt
-from PySide6.QtGui import QAction, QColor, QPixmap
+from PySide6.QtGui import QAction, QPixmap
 from PySide6.QtWidgets import (
     QCheckBox,
     QComboBox,
@@ -35,18 +35,17 @@ from PySide6.QtWidgets import (
 )
 
 from tagstudio.core.enums import ShowFilepathOption
-from tagstudio.core.library.alchemy.enums import SortingModeEnum, TagColorEnum
+from tagstudio.core.library.alchemy.enums import SortingModeEnum
 from tagstudio.qt.controllers.preview_panel_controller import PreviewPanel
 from tagstudio.qt.helpers.color_overlay import theme_fg_overlay
 from tagstudio.qt.mixed.landing import LandingWidget
 from tagstudio.qt.mixed.pagination import Pagination
-from tagstudio.qt.mixed.tag_widget import get_border_color, get_highlight_color, get_text_color
 from tagstudio.qt.mnemonics import assign_mnemonics
-from tagstudio.qt.models.palette import ColorType, get_tag_color
 from tagstudio.qt.platform_strings import trash_term
 from tagstudio.qt.resource_manager import ResourceManager
 from tagstudio.qt.thumb_grid_layout import ThumbGridLayout
 from tagstudio.qt.translations import Translations
+from tagstudio.qt.views.stylesheets.stylesheets import checkbox_style
 
 # Only import for type checking/autocompletion, will not be imported at runtime.
 if typing.TYPE_CHECKING:
@@ -589,11 +588,6 @@ class MainWindow(QMainWindow):
         self.extra_input_layout = QHBoxLayout()
         self.extra_input_layout.setObjectName("extra_input_layout")
 
-        primary_color = QColor(get_tag_color(ColorType.PRIMARY, TagColorEnum.DEFAULT))
-        border_color = get_border_color(primary_color)
-        highlight_color = get_highlight_color(primary_color)
-        text_color: QColor = get_text_color(primary_color, highlight_color)
-
         ## Show hidden entries checkbox
         self.show_hidden_entries_widget = QWidget()
         self.show_hidden_entries_layout = QHBoxLayout(self.show_hidden_entries_widget)
@@ -604,33 +598,7 @@ class MainWindow(QMainWindow):
         self.show_hidden_entries_title = QLabel(Translations["home.show_hidden_entries"])
         self.show_hidden_entries_checkbox = QCheckBox()
         self.show_hidden_entries_checkbox.setFixedSize(22, 22)
-
-        self.show_hidden_entries_checkbox.setStyleSheet(
-            f"QCheckBox{{"
-            f"background: rgba{primary_color.toTuple()};"
-            f"color: rgba{text_color.toTuple()};"
-            f"border-color: rgba{border_color.toTuple()};"
-            f"border-radius: 6px;"
-            f"border-style:solid;"
-            f"border-width: 2px;"
-            f"}}"
-            f"QCheckBox::indicator{{"
-            f"width: 10px;"
-            f"height: 10px;"
-            f"border-radius: 2px;"
-            f"margin: 4px;"
-            f"}}"
-            f"QCheckBox::indicator:checked{{"
-            f"background: rgba{text_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::hover{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"}}"
-            f"QCheckBox::focus{{"
-            f"border-color: rgba{highlight_color.toTuple()};"
-            f"outline:none;"
-            f"}}"
-        )
+        self.show_hidden_entries_checkbox.setStyleSheet(checkbox_style())
 
         self.show_hidden_entries_checkbox.setChecked(False)  # Default: No
 

src/tagstudio/qt/views/panel_modal.py

@@ -2,8 +2,8 @@
 # SPDX-License-Identifier: GPL-3.0-only
 
 
-from collections.abc import Callable
-from typing import override
+import contextlib
+from typing import Any, override
 
 import structlog
 from PySide6 import QtCore, QtGui
@@ -16,18 +16,19 @@ logger = structlog.get_logger(__name__)
 
 
 class PanelModal(QWidget):
-    saved = Signal()
+    """A generic reusable modal panel widget."""
+
+    done = Signal()
+    saved = Signal()
+    saved_data = Signal(type(Any))
 
-    # TODO: Separate callbacks from the buttons you want, and just generally
-    # figure out what you want from this.
     def __init__(
         self,
         widget: "PanelWidget",
         title: str = "",
         window_title: str | None = None,
-        done_callback: Callable[[], None] | None = None,
-        save_callback: Callable[[str], None] | None = None,
-        has_save: bool = False,
+        is_savable: bool = False,
+        inline_title: bool = True,
     ):
         # [Done]
         # - OR -
@@ -37,37 +38,24 @@ class PanelModal(QWidget):
         self.setWindowTitle(title if window_title is None else window_title)
         self.setWindowModality(Qt.WindowModality.ApplicationModal)
         self.root_layout = QVBoxLayout(self)
-        self.root_layout.setContentsMargins(6, 0, 6, 6)
-
-        self.title_widget = QLabel()
-        self.title_widget.setObjectName("fieldTitle")
-        self.title_widget.setWordWrap(True)
-        self.title_widget.setStyleSheet("font-weight:bold;font-size:14px;padding-top: 6px")
-        self.title_widget.setText(title)
-        self.title_widget.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.root_layout.setContentsMargins(6, 0 if inline_title else 12, 6, 6)
 
         self.button_container = QWidget()
         self.button_layout = QHBoxLayout(self.button_container)
         self.button_layout.setContentsMargins(6, 6, 6, 6)
         self.button_layout.addStretch(1)
 
-        # self.cancel_button = QPushButton()
-        # self.cancel_button.setText('Cancel')
-
-        if not (save_callback or has_save):
+        if not is_savable:
             self.done_button = QPushButton(Translations["generic.done"])
             self.done_button.setAutoDefault(True)
             self.done_button.clicked.connect(self.hide)
-            if done_callback:
-                self.done_button.clicked.connect(done_callback)
+            self.done_button.clicked.connect(self.done.emit)
             self.widget.panel_done_button = self.done_button
             self.button_layout.addWidget(self.done_button)
-
-        if save_callback or has_save:
+        else:
             self.cancel_button = QPushButton(Translations["generic.cancel"])
             self.cancel_button.clicked.connect(self.hide)
             self.cancel_button.clicked.connect(widget.reset)
-            # self.cancel_button.clicked.connect(cancel_callback)
             self.widget.panel_cancel_button = self.cancel_button
             self.button_layout.addWidget(self.cancel_button)
 
@@ -75,23 +63,19 @@ class PanelModal(QWidget):
             self.save_button.setAutoDefault(True)
             self.save_button.clicked.connect(self.hide)
             self.save_button.clicked.connect(self.saved.emit)
+            self.save_button.clicked.connect(lambda: self.saved_data.emit(widget.saved_data()))
             self.widget.panel_save_button = self.save_button
-
-            if done_callback:
-                self.save_button.clicked.connect(done_callback)
-
-            if save_callback:
-                self.save_button.clicked.connect(lambda: save_callback(widget.get_content()))
-
             self.button_layout.addWidget(self.save_button)
 
-            # trigger save button actions when pressing enter in the widget
-            self.widget.add_callback(lambda: self.save_button.click())
+        if inline_title:
+            self.title_widget = QLabel()
+            self.title_widget.setObjectName("fieldTitle")
+            self.title_widget.setWordWrap(True)
+            self.title_widget.setStyleSheet("font-weight:bold;font-size:14px;padding-top:6px")
+            self.title_widget.setText(title)
+            self.title_widget.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            self.root_layout.addWidget(self.title_widget)
 
-        if save_callback is not None:
-            widget.done.connect(lambda: save_callback(widget.get_content()))
-
-        self.root_layout.addWidget(self.title_widget)
         self.root_layout.addWidget(widget)
         widget.parent_modal = self
         self.root_layout.setStretch(1, 2)
@@ -100,9 +84,9 @@ class PanelModal(QWidget):
 
     @override
     def closeEvent(self, event: QtGui.QCloseEvent) -> None:
-        if self.cancel_button:
+        with contextlib.suppress(AttributeError):
             self.cancel_button.click()
-        elif self.done_button:
+        with contextlib.suppress(AttributeError):
             self.done_button.click()
         event.accept()
 
@@ -110,7 +94,6 @@ class PanelModal(QWidget):
 class PanelWidget(QWidget):
     """Used for widgets that go in a modal panel, ex. for editing or searching."""
 
-    done = Signal()
     parent_modal: PanelModal | None = None
     panel_save_button: QPushButton | None = None
     panel_cancel_button: QPushButton | None = None
@@ -119,8 +102,8 @@ class PanelWidget(QWidget):
     def __init__(self):
         super().__init__()
 
-    def get_content(self) -> str:
-        return ""
+    def saved_data(self) -> Any:  # pyright: ignore[reportExplicitAny]
+        return None
 
     def reset(self) -> None:
         pass
@@ -128,9 +111,6 @@ class PanelWidget(QWidget):
     def parent_post_init(self) -> None:
         pass
 
-    def add_callback(self, callback: Callable[[], None], event: str = "returnPressed"):
-        logger.warning(f"[PanelModal] add_callback not implemented for {self.__class__.__name__}")
-
     @override
     def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
         if event.key() == QtCore.Qt.Key.Key_Escape:

src/tagstudio/qt/views/preview_panel_view.py

@@ -67,7 +67,7 @@ class PreviewPanelView(QWidget):
 
         self.__thumb = PreviewThumb(self.lib, driver)
         self.__file_attrs = FileAttributes(self.lib, driver)
-        self._fields = FieldContainers(
+        self._containers = FieldContainers(
             self.lib, driver
         )  # TODO: this should be name mangled, but is still needed on the controller side atm
 
@@ -107,7 +107,7 @@ class PreviewPanelView(QWidget):
 
         preview_layout.addWidget(self.__thumb)
         info_layout.addWidget(self.__file_attrs)
-        info_layout.addWidget(self._fields)
+        info_layout.addWidget(self._containers)
 
         splitter.addWidget(preview_section)
         splitter.addWidget(info_section)
@@ -148,7 +148,7 @@ class PreviewPanelView(QWidget):
                 self.__thumb.hide_preview()
                 self.__file_attrs.update_stats()
                 self.__file_attrs.update_date_label()
-                self._fields.hide_containers()
+                self._containers.hide_containers()
 
                 self.add_buttons_enabled = False
 
@@ -163,7 +163,7 @@ class PreviewPanelView(QWidget):
                     stats: FileAttributeData = self.__thumb.display_file(filepath)
                     self.__file_attrs.update_stats(filepath, stats)
                 self.__file_attrs.update_date_label(filepath)
-                self._fields.update_from_entry(entry_id)
+                self._containers.update_from_entry(entry_id)
 
                 self._set_selection_callback()
 
@@ -175,7 +175,7 @@ class PreviewPanelView(QWidget):
                 self.__thumb.hide_preview()  # TODO: Render mixed selection
                 self.__file_attrs.update_multi_selection(len(selected))
                 self.__file_attrs.update_date_label()
-                self._fields.hide_containers()  # TODO: Allow for mixed editing
+                self._containers.hide_containers()  # TODO: Allow for mixed editing
 
                 self._set_selection_callback()
 
@@ -205,7 +205,7 @@ class PreviewPanelView(QWidget):
     @property
     def field_containers_widget(self) -> FieldContainers:  # needed for the tests
         """Getter for the field containers widget."""
-        return self._fields
+        return self._containers
 
     @property
     def preview_thumb(self) -> PreviewThumb:

src/tagstudio/qt/views/preview_thumb_view.py

@@ -19,7 +19,7 @@ from tagstudio.qt.mixed.media_player import MediaPlayer
 from tagstudio.qt.platform_strings import open_file_str, trash_term
 from tagstudio.qt.previews.renderer import ThumbRenderer
 from tagstudio.qt.translations import Translations
-from tagstudio.qt.views.styles.rounded_pixmap_style import RoundedPixmapStyle
+from tagstudio.qt.views.stylesheets.rounded_pixmap_style import RoundedPixmapStyle
 
 if TYPE_CHECKING:
     from tagstudio.qt.ts_qt import QtDriver

src/tagstudio/qt/views/search_panel_view.py

@@ -130,7 +130,7 @@ class SearchPanelView(PanelWidget):
     def scroll_area(self) -> QScrollArea:
         return self.__scroll_area
 
-    def connect_callbacks(self, controller: "SearchPanel[Any]") -> None:
+    def connect_callbacks(self, controller: "SearchPanel[Any]") -> None:  # pyright: ignore[reportExplicitAny]
         self.limit_combobox.currentIndexChanged.connect(controller.on_limit_changed)
 
         self.search_field.textChanged.connect(controller.on_search_query_changed)
@@ -139,7 +139,9 @@ class SearchPanelView(PanelWidget):
         )
 
         self.create_button.clicked.connect(controller.on_item_create)
-        self.create_and_add_button.clicked.connect(controller.on_item_create_and_add)
+        self.create_and_add_button.clicked.connect(
+            lambda: controller.on_item_create(add_to_entry=True)
+        )
 
     def set_limit_items(self, limit_items: list[tuple[str, int]]) -> None:
         # Remove existing limit items
@@ -171,7 +173,7 @@ class SearchPanelView(PanelWidget):
     def scroll_to(self, position: int) -> None:
         self.__scroll_area.verticalScrollBar().setValue(position)
 
-    def get_item_widget(self, index: int, library: Library | None) -> Any:
+    def get_item_widget(self, index: int, library: Library | None) -> Any:  # pyright: ignore[reportUnusedParameter, reportExplicitAny]
         raise NotImplementedError()
 
     def add_create_and_add_button(self) -> None:

src/tagstudio/qt/views/stylesheets/stylesheets.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: GPL-3.0-only
+
+from PySide6.QtGui import QColor
+
+from tagstudio.core.library.alchemy.enums import TagColorEnum
+from tagstudio.qt.mixed.tag_widget import get_border_color, get_highlight_color, get_text_color
+from tagstudio.qt.models.palette import ColorType, get_tag_color
+
+
+def checkbox_style() -> str:
+    primary_color = QColor(get_tag_color(ColorType.PRIMARY, TagColorEnum.DEFAULT))
+    border_color = get_border_color(primary_color)
+    highlight_color = get_highlight_color(primary_color)
+    text_color: QColor = get_text_color(primary_color, highlight_color)
+    return (
+        f"QCheckBox{{"
+        f"background: rgba{primary_color.toTuple()};"
+        f"color: rgba{text_color.toTuple()};"
+        f"border-color: rgba{border_color.toTuple()};"
+        f"border-radius: 6px;"
+        f"border-style:solid;"
+        f"border-width: 2px;"
+        f"}}"
+        f"QCheckBox::indicator{{"
+        f"width: 10px;"
+        f"height: 10px;"
+        f"border-radius: 2px;"
+        f"margin: 4px;"
+        f"}}"
+        f"QCheckBox::indicator:checked{{"
+        f"background: rgba{text_color.toTuple()};"
+        f"}}"
+        f"QCheckBox::hover{{"
+        f"border-color: rgba{highlight_color.toTuple()};"
+        f"}}"
+        f"QCheckBox::focus{{"
+        f"border-color: rgba{highlight_color.toTuple()};"
+        f"outline:none;"
+        f"}}"
+    )

src/tagstudio/resources/translations/en.json

@@ -9,6 +9,7 @@
     "app.git": "Git Commit",
     "app.pre_release": "Pre-Release",
     "app.title": "{base_title} - Library '{library_dir}'",
+    "color_manager.title": "Manage Tag Colors",
     "color.color_border": "Use Secondary Color for Border",
     "color.confirm_delete": "Are you sure you want to delete the color \"{color_name}\"?",
     "color.delete": "Delete Tag",
@@ -22,7 +23,6 @@
     "color.primary_required": "Primary Color (Required)",
     "color.secondary": "Secondary Color",
     "color.title.no_color": "No Color",
-    "color_manager.title": "Manage Tag Colors",
     "dependency.missing.title": "{dependency} Not Found",
     "drop_import.description": "The following files match file paths that already exist in the library",
     "drop_import.duplicates_choice.plural": "The following {count} files match file paths that already exist in the library.",
@@ -34,7 +34,6 @@
     "drop_import.title": "Conflicting File(s)",
     "edit.color_manager": "Manage Tag Colors",
     "edit.copy_fields": "Copy Fields",
-    "edit.field_template_manager": "Manage Field Templates",
     "edit.paste_fields": "Paste Fields",
     "edit.tag_manager": "Manage Tags",
     "entries.duplicate.merge": "Merge Duplicate Entries",
@@ -72,21 +71,29 @@
     "entries.unlinked.unlinked_count": "Unlinked Entries: {count}",
     "ffmpeg.missing.description": "FFmpeg and/or FFprobe were not found. FFmpeg is required for multimedia playback and thumbnails.",
     "ffmpeg.missing.status": "{ffmpeg}: {ffmpeg_status}<br>{ffprobe}: {ffprobe_status}",
+    "field_template_manager.title": "Library Field Templates",
+    "field_template.all_field_templates": "All Field Templates",
+    "field_template.confirm_delete": "Are you sure you want to delete the field template \"{field_template_name}\"?",
+    "field_template.create": "Create Field Template",
+    "field_template.create_add": "Create && Add \"{query}\"",
+    "field_template.delete": "Delete Field Template",
+    "field_template.edit": "Edit Field Template",
+    "field_template.new": "New Field Template",
+    "field_type.datetime": "Datetime",
+    "field_type.text": "Text",
+    "field_type.unknown": "Unknown Type",
     "field.add": "Add Field",
     "field.add.plural": "Add Fields",
     "field.confirm_remove": "Are you sure you want to remove this \"{name}\" field?",
     "field.copy": "Copy Field",
     "field.edit": "Edit Field",
+    "field.field_name_required": "Field Name (Required)",
     "field.mixed_data": "Mixed Data",
+    "field.name": "Name",
     "field.paste": "Paste Field",
     "field.remove": "Remove Field",
-    "field_template.all_field_templates": "All Field Templates",
-    "field_template.create": "Create Field Template",
-    "field_template.create_add": "Create && Add \"{query}\"",
-    "field_template_manager.title": "Library Field Templates",
-    "field_type.datetime": "Datetime",
-    "field_type.text": "Text",
-    "field_type.unknown": "Unknown Type",
+    "field.text.is_multiline": "Multiline",
+    "field.type": "Type",
     "file.date_added": "Date Added",
     "file.date_created": "Date Created",
     "file.date_modified": "Date Modified",
@@ -100,8 +107,8 @@
     "file.duplicates.fix": "Fix Duplicate Files",
     "file.duplicates.matches": "Duplicate File Matches: {count}",
     "file.duplicates.matches_uninitialized": "Duplicate File Matches: N/A",
-    "file.duplicates.mirror.description": "Mirror the Entry data across each duplicate match set, combining all data while not removing or duplicating fields. This operation will not delete any files or data.",
     "file.duplicates.mirror_entries": "&Mirror Entries",
+    "file.duplicates.mirror.description": "Mirror the Entry data across each duplicate match set, combining all data while not removing or duplicating fields. This operation will not delete any files or data.",
     "file.duration": "Length",
     "file.not_found": "File Not Found",
     "file.open_file": "Open file",
@@ -150,11 +157,11 @@
     "generic.skip_alt": "&Skip",
     "generic.yes": "Yes",
     "home.search": "Search",
-    "home.search.view_limit": "View Limit:",
     "home.search_entries": "Search Entries",
     "home.search_field_templates": "Search Field Templates",
     "home.search_library": "Search Library",
     "home.search_tags": "Search Tags",
+    "home.search.view_limit": "View Limit:",
     "home.show_hidden_entries": "Show Hidden Entries",
     "home.thumbnail_size": "Thumbnail Size",
     "home.thumbnail_size.extra_large": "Extra Large Thumbnails",
@@ -187,13 +194,6 @@
     "json_migration.title.new_lib": "<h2>v9.5+ Library</h2>",
     "json_migration.title.old_lib": "<h2>v9.4 Library</h2>",
     "landing.open_create_library": "Open/Create Library {shortcut}",
-    "library.missing": "Library Location is Missing",
-    "library.name": "Library",
-    "library.refresh.scanning.plural": "Scanning Directories for New Files...\n{searched_count} Files Searched, {found_count} New Files Found",
-    "library.refresh.scanning.singular": "Scanning Directories for New Files...\n{searched_count} File Searched, {found_count} New Files Found",
-    "library.refresh.scanning_preparing": "Scanning Directories for New Files...\nPreparing...",
-    "library.refresh.title": "Refreshing Directories",
-    "library.scan_library.title": "Scanning Library",
     "library_info.cleanup": "Cleanup",
     "library_info.cleanup.backups": "Library Backups:",
     "library_info.cleanup.dupe_files": "Duplicate Files:",
@@ -213,6 +213,13 @@
     "library_object.name_required": "Name (Required)",
     "library_object.slug": "ID Slug",
     "library_object.slug_required": "ID Slug (Required)",
+    "library.missing": "Library Location is Missing",
+    "library.name": "Library",
+    "library.refresh.scanning_preparing": "Scanning Directories for New Files...\nPreparing...",
+    "library.refresh.scanning.plural": "Scanning Directories for New Files...\n{searched_count} Files Searched, {found_count} New Files Found",
+    "library.refresh.scanning.singular": "Scanning Directories for New Files...\n{searched_count} File Searched, {found_count} New Files Found",
+    "library.refresh.title": "Refreshing Directories",
+    "library.scan_library.title": "Scanning Library",
     "macros.running.dialog.new_entries": "Running Configured Macros on {count}/{total} New File Entries...",
     "macros.running.dialog.title": "Running Macros on New Entries",
     "media_player.autoplay": "Autoplay",
@@ -323,11 +330,12 @@
     "status.library_version_found": "Found:",
     "status.library_version_mismatch": "Library Version Mismatch!",
     "status.results": "Results",
-    "status.results.invalid_syntax": "Invalid Search Syntax:",
     "status.results_found": "{count} Results Found ({time_span})",
+    "status.results.invalid_syntax": "Invalid Search Syntax:",
+    "tag_manager.title": "Library Tags",
     "tag.add": "Add Tag",
-    "tag.add.plural": "Add Tags",
     "tag.add_to_search": "Add to Search",
+    "tag.add.plural": "Add Tags",
     "tag.aliases": "Aliases",
     "tag.all_tags": "All Tags",
     "tag.choose_color": "Choose Tag Color",
@@ -348,7 +356,6 @@
     "tag.search_for_tag": "Search for Tag",
     "tag.shorthand": "Shorthand",
     "tag.tag_name_required": "Tag Name (Required)",
-    "tag_manager.title": "Library Tags",
     "trash.context.ambiguous": "Move file(s) to {trash_term}",
     "trash.context.plural": "Move files to {trash_term}",
     "trash.context.singular": "Move file to {trash_term}",

tests/qt/test_build_tag_panel.py

@@ -80,7 +80,7 @@ def test_build_tag_panel_remove_alias_callback(
 
     alias: TagAlias = unwrap(library.get_alias(tag.id, tag.alias_ids[0]))
 
-    panel.remove_alias_callback(alias.name, alias.id)
+    panel.remove_alias_callback(alias.id)
 
     assert len(panel.alias_ids) == 1
     assert len(panel.alias_names) == 1

tests/test_library.py

@@ -225,7 +225,9 @@ def test_remove_text_field_entry_with_multiple_fields(library: Library, entry_fu
 def test_update_entry_field(library: Library, entry_full: Entry):
     title_field = entry_full.text_fields[0]
 
-    library.update_text_field(entry_full.id, title_field, "new value", title_field.is_multiline)
+    library.update_text_field(
+        entry_full.id, title_field, title_field.name, "new value", title_field.is_multiline
+    )
 
     entry = next(library.all_entries(with_joins=True))
     assert entry.text_fields[0].value == "new value"
@@ -241,7 +243,9 @@ def test_update_entry_with_multiple_identical_text_fields(library: Library, entr
     library.add_field_to_entries(entry_full.id, field=empty_title)
 
     # update one of the fields
-    library.update_text_field(entry_full.id, title_field, "new value", title_field.is_multiline)
+    library.update_text_field(
+        entry_full.id, title_field, title_field.name, "new value", title_field.is_multiline
+    )
 
     # Then only one should be updated
     entry = next(library.all_entries(with_joins=True))