feat(tags): add tag merging (#322)

* added merge tag context menu option, created modal, and created merge_tag logic

* forgot to close out the modal

* added ability to re-assign current tag

* ruff/mypy checks

CONTRIBUTING.md

@@ -64,10 +64,10 @@ _Learn more about setting up a virtual environment [here](https://docs.python.or
 
   - Run the "TagStudio.sh" script and the program should launch! (Make sure that the script is marked as executable if on Linux). Note that launching from the script from outside of a terminal will not launch a terminal window with any debug or crash information. If you wish to see this information, just launch the shell script directly from your terminal with `./TagStudio.sh`.
 
-  - **NixOS** (TagStudio.sh)
+  - **NixOS** (Nix Flake)
     > [!WARNING]
     > Support for NixOS is still a work in progress.
-    - Use the provided `flake.nix` file to create and enter a working environment by running `nix develop`. Then, run the `TagStudio.sh` script.
+    - Use the provided [Flake](https://nixos.wiki/wiki/Flakes) to create and enter a working environment by running `nix develop`. Then, run the program via `python3 tagstudio/tag_studio.py` from the root directory.
 
 - **Any** (No Scripts)
 

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1717602782,
-        "narHash": "sha256-pL9jeus5QpX5R+9rsp3hhZ+uplVHscNJh8n8VpqscM0=",
+        "lastModified": 1718318537,
+        "narHash": "sha256-4Zu0RYRcAY/VWuu6awwq4opuiD//ahpc2aFHg2CWqFY=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "e8057b67ebf307f01bdcc8fba94d94f75039d1f6",
+        "rev": "e9ee548d90ff586a6471b4ae80ae9cfcbceb3420",
         "type": "github"
       },
       "original": {
@@ -18,17 +18,17 @@
     },
     "qt6Nixpkgs": {
       "locked": {
-        "lastModified": 1711460435,
-        "narHash": "sha256-Qb/J9NFk2Qemg7vTl8EDCto6p3Uf/GGORkGhTQJLj9U=",
+        "lastModified": 1716287118,
+        "narHash": "sha256-iUTrXABmJAkPRhwPB8GEP7k52OWHVSRtMzlKQ2kIrz4=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f862bd46d3020bcfe7195b3dad638329271b0524",
+        "rev": "47da0aee5616a063015f10ea593688646f2377e4",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f862bd46d3020bcfe7195b3dad638329271b0524",
+        "rev": "47da0aee5616a063015f10ea593688646f2377e4",
         "type": "github"
       }
     },

flake.nix

@@ -1,10 +1,12 @@
 {
+  description = "Tag Studio Development Environment";
+
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
 
     qt6Nixpkgs = {
-      # Commit bumping to qt6.6.3
-      url = "github:NixOS/nixpkgs/f862bd46d3020bcfe7195b3dad638329271b0524"; 
+      # Commit bumping to qt6.7.1
+      url = "github:NixOS/nixpkgs/47da0aee5616a063015f10ea593688646f2377e4";
     };
   };
 
@@ -15,6 +17,9 @@
     qt6Pkgs = qt6Nixpkgs.legacyPackages.x86_64-linux;
   in {
     devShells.x86_64-linux.default = pkgs.mkShell {
+      name = "Tag Studio Virtual Environment";
+      venvDir = "./.venv";
+
       LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [
         pkgs.gcc-unwrapped
         pkgs.zlib
@@ -35,18 +40,19 @@
         qt6Pkgs.qt6.full
         qt6Pkgs.qt6.qtbase
       ];
+
       buildInputs = with pkgs; [
         cmake
         gdb
         zstd
-        python312Packages.pip
         python312Full
-        python312Packages.virtualenv # run virtualenv .
+        python312Packages.pip
         python312Packages.pyusb # fixes the pyusb 'No backend available' when installed directly via pip
+        python312Packages.venvShellHook # Initializes a venv in $venvDir
+        ruff # Ruff cannot be installed via pip
+        mypy # MyPy cannot be installed via pip
 
         libgcc
-        makeWrapper
-        bashInteractive
         glib
         libxkbcommon
         freetype
@@ -70,14 +76,34 @@
         # this is for the shellhook portion
         qt6Pkgs.qt6.wrapQtAppsHook
       ];
+
+      # Run after the virtual environment is created
+      postVenvCreation = ''
+        unset SOURCE_DATE_EPOCH
+
+        echo Installing dependencies into virtual environment
+        pip install -r requirements.txt
+        pip install -r requirements-dev.txt
+        # Hacky solution to not fight with other dev deps
+        # May show failure if skipped due to same version with nixpkgs
+        pip uninstall -y mypy ruff
+      '';
+
       # set the environment variables that Qt apps expect
-      shellHook = ''
-        export QT_QPA_PLATFORM=wayland
+      postShellHook = ''
+        unset SOURCE_DATE_EPOCH
+
+        export QT_QPA_PLATFORM="wayland;xcb"
         export LIBRARY_PATH=/usr/lib:/usr/lib64:$LIBRARY_PATH
         # export LD_LIBRARY_PATH=${pkgs.stdenv.cc.cc.lib}/lib/:/run/opengl-driver/lib/
         export QT_PLUGIN_PATH=${pkgs.qt6.qtbase}/${pkgs.qt6.qtbase.qtPluginPrefix}
         bashdir=$(mktemp -d)
         makeWrapper "$(type -p bash)" "$bashdir/bash" "''${qtWrapperArgs[@]}"
+
+        echo Activating Virtual Environment
+        source $venvDir/bin/activate
+        export PYTHONPATH=$PWD/$venvDir/${pkgs.python312Full.sitePackages}:$PYTHONPATH
+
         exec "$bashdir/bash"
       '';
     };

requirements.txt

@@ -10,3 +10,8 @@ numpy==1.26.4
 rawpy==0.21.0
 pillow-heif==0.16.0
 chardet==5.2.0
+pydub==0.25.1
+mutagen==1.47.0
+numpy==1.26.4
+ffmpeg-python==0.2.0
+Send2Trash==1.8.3

tagstudio/src/core/constants.py

@@ -1,4 +1,4 @@
-VERSION: str = "9.3.2"  # Major.Minor.Patch
+VERSION: str = "9.4.0"  # Major.Minor.Patch
 VERSION_BRANCH: str = ""  # Usually "" or "Pre-Release"
 
 # The folder & file names where TagStudio keeps its data relative to a library.
@@ -7,118 +7,10 @@ BACKUP_FOLDER_NAME: str = "backups"
 COLLAGE_FOLDER_NAME: str = "collages"
 LIBRARY_FILENAME: str = "ts_library.json"
 
-# TODO: Turn this whitelist into a user-configurable blacklist.
-IMAGE_TYPES: list[str] = [
-    ".png",
-    ".jpg",
-    ".jpeg",
-    ".jpg_large",
-    ".jpeg_large",
-    ".jfif",
-    ".gif",
-    ".tif",
-    ".tiff",
-    ".heic",
-    ".heif",
-    ".webp",
-    ".bmp",
-    ".svg",
-    ".avif",
-    ".apng",
-    ".jp2",
-    ".j2k",
-    ".jpg2",
-]
-RAW_IMAGE_TYPES: list[str] = [
-    ".raw",
-    ".dng",
-    ".rw2",
-    ".nef",
-    ".arw",
-    ".crw",
-    ".cr2",
-    ".cr3",
-]
-VIDEO_TYPES: list[str] = [
-    ".mp4",
-    ".webm",
-    ".mov",
-    ".hevc",
-    ".mkv",
-    ".avi",
-    ".wmv",
-    ".flv",
-    ".gifv",
-    ".m4p",
-    ".m4v",
-    ".3gp",
-]
-AUDIO_TYPES: list[str] = [
-    ".mp3",
-    ".mp4",
-    ".mpeg4",
-    ".m4a",
-    ".aac",
-    ".wav",
-    ".flac",
-    ".alac",
-    ".wma",
-    ".ogg",
-    ".aiff",
-]
-DOC_TYPES: list[str] = [
-    ".txt",
-    ".rtf",
-    ".md",
-    ".doc",
-    ".docx",
-    ".pdf",
-    ".tex",
-    ".odt",
-    ".pages",
-]
-PLAINTEXT_TYPES: list[str] = [
-    ".txt",
-    ".md",
-    ".css",
-    ".html",
-    ".xml",
-    ".json",
-    ".js",
-    ".ts",
-    ".ini",
-    ".htm",
-    ".csv",
-    ".php",
-    ".sh",
-    ".bat",
-]
-SPREADSHEET_TYPES: list[str] = [".csv", ".xls", ".xlsx", ".numbers", ".ods"]
-PRESENTATION_TYPES: list[str] = [".ppt", ".pptx", ".key", ".odp"]
-ARCHIVE_TYPES: list[str] = [
-    ".zip",
-    ".rar",
-    ".tar",
-    ".tar",
-    ".gz",
-    ".tgz",
-    ".7z",
-    ".s7z",
-]
-PROGRAM_TYPES: list[str] = [".exe", ".app"]
-SHORTCUT_TYPES: list[str] = [".lnk", ".desktop", ".url"]
-
-ALL_FILE_TYPES: list[str] = (
-    IMAGE_TYPES
-    + VIDEO_TYPES
-    + AUDIO_TYPES
-    + DOC_TYPES
-    + SPREADSHEET_TYPES
-    + PRESENTATION_TYPES
-    + ARCHIVE_TYPES
-    + PROGRAM_TYPES
-    + SHORTCUT_TYPES
+FONT_SAMPLE_TEXT: str = (
+    """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!?@$%(){}[]"""
 )
+FONT_SAMPLE_SIZES: list[int] = [10, 15, 20]
 
 BOX_FIELDS = ["tag_box", "text_box"]
 TEXT_FIELDS = ["text_line", "text_box"]
@@ -163,6 +55,5 @@ TAG_COLORS = [
     "cool gray",
     "olive",
 ]
-
 TAG_FAVORITE = 1
 TAG_ARCHIVED = 0

tagstudio/src/core/enums.py

@@ -12,7 +12,9 @@ class SettingItems(str, enum.Enum):
 
 
 class Theme(str, enum.Enum):
-    COLOR_BG = "#65000000"
+    COLOR_BG_DARK = "#65000000"
+    COLOR_BG_LIGHT = "#22000000"
+    COLOR_DARK_LABEL = "#DD000000"
     COLOR_HOVER = "#65AAAAAA"
     COLOR_PRESSED = "#65EEEEEE"
     COLOR_DISABLED = "#65F39CAA"

tagstudio/src/core/library.py

@@ -1895,6 +1895,31 @@ class Library:
         for t in self.tags:
             self._map_tag_strings_to_tag_id(t)
 
+    def merge_tag(self, source_tag: Tag, target_tag: Tag) -> None:
+        source_tag_id: int = source_tag.id
+        target_tag_id: int = target_tag.id
+
+        if source_tag.name not in target_tag.aliases:
+            target_tag.aliases.append(source_tag.name)
+
+        for alias in source_tag.aliases:
+            if alias not in target_tag.aliases:
+                target_tag.aliases.append(alias)
+
+        for subtag_id in source_tag.subtag_ids:
+            if subtag_id not in target_tag.subtag_ids:
+                target_tag.subtag_ids.append(subtag_id)
+
+        for entry in self.entries:
+            for field in entry.fields:
+                if self.get_field_attr(field, "type") == "tag_box":
+                    if source_tag_id in self.get_field_attr(field, "content"):
+                        self.get_field_attr(field, "content").remove(source_tag_id)
+                        if target_tag_id not in self.get_field_attr(field, "content"):
+                            self.get_field_attr(field, "content").append(target_tag_id)
+
+        self.remove_tag(source_tag_id)
+
     def get_tag_ref_count(self, tag_id: int) -> tuple[int, int]:
         """Returns an int tuple (entry_ref_count, subtag_ref_count) of Tag reference counts."""
         entry_ref_count: int = 0

tagstudio/src/core/media_types.py

@@ -0,0 +1,460 @@
+# Copyright (C) 2024 Travis Abendshien (CyanVoxel).
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+import logging
+import mimetypes
+from enum import Enum
+from pathlib import Path
+
+logging.basicConfig(format="%(message)s", level=logging.INFO)
+
+
+class MediaType(str, Enum):
+    """Names of media types."""
+
+    ADOBE_PHOTOSHOP: str = "adobe_photoshop"
+    AFFINITY_PHOTO: str = "affinity_photo"
+    ARCHIVE: str = "archive"
+    AUDIO_MIDI: str = "audio_midi"
+    AUDIO: str = "audio"
+    BLENDER: str = "blender"
+    DATABASE: str = "database"
+    DISK_IMAGE: str = "disk_image"
+    DOCUMENT: str = "document"
+    FONT: str = "font"
+    IMAGE_ANIMATED: str = "image_animated"
+    IMAGE_RAW: str = "image_raw"
+    IMAGE_VECTOR: str = "image_vector"
+    IMAGE: str = "image"
+    INSTALLER: str = "installer"
+    MATERIAL: str = "material"
+    MODEL: str = "model"
+    PACKAGE: str = "package"
+    PDF: str = "pdf"
+    PLAINTEXT: str = "plaintext"
+    PRESENTATION: str = "presentation"
+    PROGRAM: str = "program"
+    SHORTCUT: str = "shortcut"
+    SPREADSHEET: str = "spreadsheet"
+    TEXT: str = "text"
+    VIDEO: str = "video"
+
+
+class MediaCategory:
+    """An object representing a category of media. Includes a MediaType identifier,
+    extensions set, and IANA status flag.
+
+    Args:
+        media_type (MediaType): The MediaType Enum representing this category.
+
+        extensions (set[str]): The set of file extensions associated with this category.
+            Includes leading ".", all lowercase, and does not need to be unique to this category.
+
+        is_iana (bool): Represents whether or not this is an IANA registered category.
+    """
+
+    def __init__(
+        self,
+        media_type: MediaType,
+        extensions: set[str],
+        is_iana: bool = False,
+    ) -> None:
+        self.media_type: MediaType = media_type
+        self.extensions: set[str] = extensions
+        self.is_iana: bool = is_iana
+
+
+class MediaCategories:
+    """Contains pre-made MediaCategory objects as well as methods to interact with them."""
+
+    # These sets are used either individually or together to form the final sets
+    # for the MediaCategory(s).
+    # These sets may be combined and are NOT 1:1 with the final categories.
+    _ADOBE_PHOTOSHOP_SET: set[str] = {
+        ".pdd",
+        ".psb",
+        ".psd",
+    }
+    _AFFINITY_PHOTO_SET: set[str] = {".afphoto"}
+    _ARCHIVE_SET: set[str] = {
+        ".7z",
+        ".gz",
+        ".rar",
+        ".s7z",
+        ".tar",
+        ".tgz",
+        ".zip",
+    }
+    _AUDIO_MIDI_SET: set[str] = {
+        ".mid",
+        ".midi",
+    }
+    _AUDIO_SET: set[str] = {
+        ".aac",
+        ".aif",
+        ".aiff",
+        ".alac",
+        ".flac",
+        ".m4a",
+        ".m4p",
+        ".mp3",
+        ".mpeg4",
+        ".ogg",
+        ".wav",
+        ".wma",
+    }
+    _BLENDER_SET: set[str] = {
+        ".blen_tc",
+        ".blend",
+        ".blend1",
+        ".blend10",
+        ".blend11",
+        ".blend12",
+        ".blend13",
+        ".blend14",
+        ".blend15",
+        ".blend16",
+        ".blend17",
+        ".blend18",
+        ".blend19",
+        ".blend2",
+        ".blend20",
+        ".blend21",
+        ".blend22",
+        ".blend23",
+        ".blend24",
+        ".blend25",
+        ".blend26",
+        ".blend27",
+        ".blend28",
+        ".blend29",
+        ".blend3",
+        ".blend30",
+        ".blend31",
+        ".blend32",
+        ".blend4",
+        ".blend5",
+        ".blend6",
+        ".blend7",
+        ".blend8",
+        ".blend9",
+    }
+    _DATABASE_SET: set[str] = {
+        ".accdb",
+        ".mdb",
+        ".sqlite",
+    }
+    _DISK_IMAGE_SET: set[str] = {".bios", ".dmg", ".iso"}
+    _DOCUMENT_SET: set[str] = {
+        ".doc",
+        ".docm",
+        ".docx",
+        ".dot",
+        ".dotm",
+        ".dotx",
+        ".odt",
+        ".pages",
+        ".pdf",
+        ".rtf",
+        ".tex",
+        ".wpd",
+        ".wps",
+    }
+    _FONT_SET: set[str] = {
+        ".fon",
+        ".otf",
+        ".ttc",
+        ".ttf",
+        ".woff",
+        ".woff2",
+    }
+    _IMAGE_ANIMATED_SET: set[str] = {
+        ".apng",
+        ".gif",
+        ".webp",
+        ".jxl",
+    }
+    _IMAGE_RAW_SET: set[str] = {
+        ".arw",
+        ".cr2",
+        ".cr3",
+        ".crw",
+        ".dng",
+        ".nef",
+        ".raw",
+        ".rw2",
+    }
+    _IMAGE_VECTOR_SET: set[str] = {".svg"}
+    _IMAGE_SET: set[str] = {
+        ".apng",
+        ".avif",
+        ".bmp",
+        ".exr",
+        ".gif",
+        ".heic",
+        ".heif",
+        ".j2k",
+        ".jfif",
+        ".jp2",
+        ".jpeg_large",
+        ".jpeg",
+        ".jpg_large",
+        ".jpg",
+        ".jpg2",
+        ".jxl",
+        ".png",
+        ".psb",
+        ".psd",
+        ".tif",
+        ".tiff",
+        ".webp",
+    }
+    _INSTALLER_SET: set[str] = {".appx", ".msi", ".msix"}
+    _MATERIAL_SET: set[str] = {".mtl"}
+    _MODEL_SET: set[str] = {".3ds", ".fbx", ".obj", ".stl"}
+    _PACKAGE_SET: set[str] = {
+        ".aab",
+        ".akp",
+        ".apk",
+        ".apkm",
+        ".apks",
+        ".pkg",
+        ".xapk",
+    }
+    _PDF_SET: set[str] = {
+        ".pdf",
+    }
+    _PLAINTEXT_SET: set[str] = {
+        ".bat",
+        ".css",
+        ".csv",
+        ".htm",
+        ".html",
+        ".ini",
+        ".js",
+        ".json",
+        ".jsonc",
+        ".md",
+        ".php",
+        ".plist",
+        ".prefs",
+        ".sh",
+        ".ts",
+        ".txt",
+        ".xml",
+    }
+    _PRESENTATION_SET: set[str] = {
+        ".key",
+        ".odp",
+        ".ppt",
+        ".pptx",
+    }
+    _PROGRAM_SET: set[str] = {".app", ".exe"}
+    _SHORTCUT_SET: set[str] = {".desktop", ".lnk", ".url"}
+    _SPREADSHEET_SET: set[str] = {
+        ".csv",
+        ".numbers",
+        ".ods",
+        ".xls",
+        ".xlsx",
+    }
+    _VIDEO_SET: set[str] = {
+        ".3gp",
+        ".avi",
+        ".flv",
+        ".gifv",
+        ".hevc",
+        ".m4p",
+        ".m4v",
+        ".mkv",
+        ".mov",
+        ".mp4",
+        ".webm",
+        ".wmv",
+    }
+
+    ADOBE_PHOTOSHOP_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.ADOBE_PHOTOSHOP,
+        extensions=_ADOBE_PHOTOSHOP_SET,
+        is_iana=False,
+    )
+    AFFINITY_PHOTO_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.AFFINITY_PHOTO,
+        extensions=_AFFINITY_PHOTO_SET,
+        is_iana=False,
+    )
+    ARCHIVE_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.ARCHIVE,
+        extensions=_ARCHIVE_SET,
+        is_iana=False,
+    )
+    AUDIO_MIDI_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.AUDIO_MIDI,
+        extensions=_AUDIO_MIDI_SET,
+        is_iana=False,
+    )
+    AUDIO_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.AUDIO,
+        extensions=_AUDIO_SET | _AUDIO_MIDI_SET,
+        is_iana=True,
+    )
+    BLENDER_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.BLENDER,
+        extensions=_BLENDER_SET,
+        is_iana=False,
+    )
+    DATABASE_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.DATABASE,
+        extensions=_DATABASE_SET,
+        is_iana=False,
+    )
+    DISK_IMAGE_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.DISK_IMAGE,
+        extensions=_DISK_IMAGE_SET,
+        is_iana=False,
+    )
+    DOCUMENT_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.DOCUMENT,
+        extensions=_DOCUMENT_SET,
+        is_iana=False,
+    )
+    FONT_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.FONT,
+        extensions=_FONT_SET,
+        is_iana=True,
+    )
+    IMAGE_ANIMATED_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.IMAGE_ANIMATED,
+        extensions=_IMAGE_ANIMATED_SET,
+        is_iana=False,
+    )
+    IMAGE_RAW_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.IMAGE_RAW,
+        extensions=_IMAGE_RAW_SET,
+        is_iana=False,
+    )
+    IMAGE_VECTOR_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.IMAGE_VECTOR,
+        extensions=_IMAGE_VECTOR_SET,
+        is_iana=False,
+    )
+    IMAGE_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.IMAGE,
+        extensions=_IMAGE_SET | _IMAGE_RAW_SET | _IMAGE_VECTOR_SET,
+        is_iana=True,
+    )
+    INSTALLER_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.INSTALLER,
+        extensions=_INSTALLER_SET,
+        is_iana=False,
+    )
+    MATERIAL_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.MATERIAL,
+        extensions=_MATERIAL_SET,
+        is_iana=False,
+    )
+    MODEL_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.MODEL,
+        extensions=_MODEL_SET,
+        is_iana=True,
+    )
+    PACKAGE_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.PACKAGE,
+        extensions=_PACKAGE_SET,
+        is_iana=False,
+    )
+    PDF_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.PDF,
+        extensions=_PDF_SET,
+        is_iana=False,
+    )
+    PLAINTEXT_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.PLAINTEXT,
+        extensions=_PLAINTEXT_SET,
+        is_iana=False,
+    )
+    PRESENTATION_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.PRESENTATION,
+        extensions=_PRESENTATION_SET,
+        is_iana=False,
+    )
+    PROGRAM_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.PROGRAM,
+        extensions=_PROGRAM_SET,
+        is_iana=False,
+    )
+    SHORTCUT_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.SHORTCUT,
+        extensions=_SHORTCUT_SET,
+        is_iana=False,
+    )
+    SPREADSHEET_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.SPREADSHEET,
+        extensions=_SPREADSHEET_SET,
+        is_iana=False,
+    )
+    TEXT_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.TEXT,
+        extensions=_DOCUMENT_SET | _PLAINTEXT_SET,
+        is_iana=True,
+    )
+    VIDEO_TYPES: MediaCategory = MediaCategory(
+        media_type=MediaType.VIDEO,
+        extensions=_VIDEO_SET,
+        is_iana=True,
+    )
+
+    ALL_CATEGORIES: list[MediaCategory] = [
+        ADOBE_PHOTOSHOP_TYPES,
+        AFFINITY_PHOTO_TYPES,
+        ARCHIVE_TYPES,
+        AUDIO_MIDI_TYPES,
+        AUDIO_TYPES,
+        BLENDER_TYPES,
+        DATABASE_TYPES,
+        DISK_IMAGE_TYPES,
+        DOCUMENT_TYPES,
+        FONT_TYPES,
+        IMAGE_ANIMATED_TYPES,
+        IMAGE_RAW_TYPES,
+        IMAGE_TYPES,
+        IMAGE_VECTOR_TYPES,
+        INSTALLER_TYPES,
+        MATERIAL_TYPES,
+        MODEL_TYPES,
+        PACKAGE_TYPES,
+        PDF_TYPES,
+        PLAINTEXT_TYPES,
+        PRESENTATION_TYPES,
+        PROGRAM_TYPES,
+        SHORTCUT_TYPES,
+        SPREADSHEET_TYPES,
+        TEXT_TYPES,
+        VIDEO_TYPES,
+    ]
+
+    @staticmethod
+    def get_types(ext: str, mime_fallback: bool = False) -> set[MediaType]:
+        """Returns a set of MediaTypes given a file extension.
+
+        Args:
+            ext (str): File extension with a leading "." and in all lowercase.
+            mime_fallback (bool): Flag to guess MIME type if no set matches are made.
+        """
+        types: set[MediaType] = set()
+        mime_guess: bool = False
+
+        for cat in MediaCategories.ALL_CATEGORIES:
+            if ext in cat.extensions:
+                types.add(cat.media_type)
+            elif mime_fallback and cat.is_iana:
+                type: str = mimetypes.guess_type(Path("x" + ext), strict=False)[0]
+                if type and type.startswith(cat.media_type.value):
+                    types.add(cat.media_type)
+                    mime_guess = True
+
+        # logging.info(
+        #     f"({ext}) Media Categories Found: {[x.value for x in types]}{' (MIME)' if mime_guess else ''}"
+        # )
+        return types

tagstudio/src/core/palette.py

@@ -13,7 +13,7 @@ class ColorType(int, Enum):
     DARK_ACCENT = 4
 
 
-_TAG_COLORS = {
+_TAG_COLORS: dict = {
     "": {
         ColorType.PRIMARY: "#1e1e1e",
         ColorType.TEXT: ColorType.LIGHT_ACCENT,
@@ -277,6 +277,45 @@ _TAG_COLORS = {
     },
 }
 
+_UI_COLORS: dict = {
+    "": {
+        ColorType.PRIMARY: "#333333",
+        ColorType.BORDER: "#555555",
+        ColorType.LIGHT_ACCENT: "#FFFFFF",
+        ColorType.DARK_ACCENT: "#1e1e1e",
+    },
+    "green": {
+        ColorType.PRIMARY: "#28bb48",
+        ColorType.BORDER: "#43c568",
+        ColorType.LIGHT_ACCENT: "#DDFFCC",
+        ColorType.DARK_ACCENT: "#0d3828",
+    },
+    "purple": {
+        ColorType.PRIMARY: "#C76FF3",
+        ColorType.BORDER: "#c364f2",
+        ColorType.LIGHT_ACCENT: "#EFD4FB",
+        ColorType.DARK_ACCENT: "#3E1555",
+    },
+    "red": {
+        ColorType.PRIMARY: "#e22c3c",
+        ColorType.BORDER: "#e54252",
+        ColorType.LIGHT_ACCENT: "#f39caa",
+        ColorType.DARK_ACCENT: "#440d12",
+    },
+    "theme_dark": {
+        ColorType.PRIMARY: "#333333",
+        ColorType.BORDER: "#555555",
+        ColorType.LIGHT_ACCENT: "#FFFFFF",
+        ColorType.DARK_ACCENT: "#1e1e1e",
+    },
+    "theme_light": {
+        ColorType.PRIMARY: "#FFFFFF",
+        ColorType.BORDER: "#333333",
+        ColorType.LIGHT_ACCENT: "#999999",
+        ColorType.DARK_ACCENT: "#888888",
+    },
+}
+
 
 def get_tag_color(type, color):
     color = color.lower()
@@ -287,3 +326,9 @@ def get_tag_color(type, color):
             return _TAG_COLORS[color][type]
     except KeyError:
         return "#FF00FF"
+
+
+def get_ui_color(type: ColorType, color: str):
+    """Returns a hex value given a color name and ColorType."""
+    color = color.lower()
+    return _UI_COLORS.get(color).get(type)

tagstudio/src/qt/helpers/blender_thumbnailer.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+
+## This file is a modified script that gets the thumbnail data stored in a blend file
+
+
+import struct
+from PIL import (
+    Image,
+    ImageOps,
+)
+import gzip
+import os
+
+
+def blend_extract_thumb(path):
+    REND = b"REND"
+    TEST = b"TEST"
+
+    blendfile = open(path, "rb")
+
+    head = blendfile.read(12)
+
+    if head[0:2] == b"\x1f\x8b":  # gzip magic
+        blendfile.close()
+        blendfile = gzip.GzipFile("", "rb", 0, open(path, "rb"))
+        head = blendfile.read(12)
+
+    if not head.startswith(b"BLENDER"):
+        blendfile.close()
+        return None, 0, 0
+
+    is_64_bit = head[7] == b"-"[0]
+
+    # true for PPC, false for X86
+    is_big_endian = head[8] == b"V"[0]
+
+    # blender pre 2.5 had no thumbs
+    if head[9:11] <= b"24":
+        return None, 0, 0
+
+    sizeof_bhead = 24 if is_64_bit else 20
+    int_endian = ">i" if is_big_endian else "<i"
+    int_endian_pair = int_endian + "i"
+
+    while True:
+        bhead = blendfile.read(sizeof_bhead)
+
+        if len(bhead) < sizeof_bhead:
+            return None, 0, 0
+
+        code = bhead[:4]
+        length = struct.unpack(int_endian, bhead[4:8])[0]  # 4 == sizeof(int)
+
+        if code == REND:
+            blendfile.seek(length, os.SEEK_CUR)
+        else:
+            break
+
+    if code != TEST:
+        return None, 0, 0
+
+    try:
+        x, y = struct.unpack(int_endian_pair, blendfile.read(8))  # 8 == sizeof(int) * 2
+    except struct.error:
+        return None, 0, 0
+
+    length -= 8  # sizeof(int) * 2
+
+    if length != x * y * 4:
+        return None, 0, 0
+
+    image_buffer = blendfile.read(length)
+
+    if len(image_buffer) != length:
+        return None, 0, 0
+
+    return image_buffer, x, y
+
+
+def blend_thumb(file_in):
+    buf, width, height = blend_extract_thumb(file_in)
+    image = Image.frombuffer(
+        "RGBA",
+        (width, height),
+        buf,
+    )
+    image = ImageOps.flip(image)
+    return image

tagstudio/src/qt/helpers/color_overlay.py

@@ -10,23 +10,28 @@ from src.qt.helpers.gradient import linear_gradient
 
 # TODO: Consolidate the built-in QT theme values with the values
 # here, in enums.py, and in palette.py.
-_THEME_DARK_FG: str = "#FFFFFF55"
+_THEME_DARK_FG: str = "#FFFFFF77"
 _THEME_LIGHT_FG: str = "#000000DD"
+_THEME_DARK_BG: str = "#000000DD"
+_THEME_LIGHT_BG: str = "#FFFFFF55"
 
 
-def theme_fg_overlay(image: Image.Image) -> Image.Image:
+def theme_fg_overlay(image: Image.Image, use_alpha: bool = True) -> Image.Image:
     """
     Overlay the foreground theme color onto an image.
 
     Args:
         image (Image): The PIL Image object to apply an overlay to.
     """
+    dark_fg: str = _THEME_DARK_FG[:-2] if not use_alpha else _THEME_DARK_FG
+    light_fg: str = _THEME_LIGHT_FG[:-2] if not use_alpha else _THEME_LIGHT_FG
 
     overlay_color = (
-        _THEME_DARK_FG
+        dark_fg
         if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
-        else _THEME_LIGHT_FG
+        else light_fg
     )
+
     im = Image.new(mode="RGBA", size=image.size, color=overlay_color)
     return _apply_overlay(image, im)
 

tagstudio/src/qt/helpers/file_deleter.py

@@ -0,0 +1,30 @@
+# Copyright (C) 2024 Travis Abendshien (CyanVoxel).
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+import logging
+from pathlib import Path
+
+from send2trash import send2trash
+
+logging.basicConfig(format="%(message)s", level=logging.INFO)
+
+
+def delete_file(path: str | Path) -> bool:
+    """Sends a file to the system trash.
+
+    Args:
+        path (str | Path): The path of the file to delete.
+    """
+    _path = Path(path)
+    try:
+        logging.info(f"[delete_file] Sending to Trash: {_path}")
+        send2trash(_path)
+        return True
+    except PermissionError as e:
+        logging.error(f"[delete_file][ERROR] PermissionError: {e}")
+    except FileNotFoundError:
+        logging.error(f"[delete_file][ERROR] File Not Found: {_path}")
+    except Exception as e:
+        logging.error(e)
+    return False

tagstudio/src/qt/helpers/file_tester.py

@@ -0,0 +1,29 @@
+# Copyright (C) 2024 Travis Abendshien (CyanVoxel).
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+
+import ffmpeg
+from pathlib import Path
+
+
+def is_readable_video(filepath: Path | str):
+    """Test if a video is in a readable format. Examples of unreadable videos
+    include files with undetermined codecs and DRM-protected content.
+
+    Args:
+        filepath (Path | str):
+    """
+    try:
+        probe = ffmpeg.probe(Path(filepath))
+        for stream in probe["streams"]:
+            # DRM check
+            if stream.get("codec_tag_string") in [
+                "drma",
+                "drms",
+                "drmi",
+            ]:
+                return False
+    except ffmpeg.Error:
+        return False
+    return True

tagstudio/src/qt/helpers/gradient.py

@@ -2,21 +2,21 @@
 # Licensed under the GPL-3.0 License.
 # Created for TagStudio: https://github.com/CyanVoxel/TagStudio
 
-from PIL import Image, ImageEnhance, ImageChops
+from PIL import Image
 
 
-def four_corner_gradient_background(
-    image: Image.Image, adj_size, mask, hl
+def four_corner_gradient(
+    image: Image.Image, size: tuple[int, int], mask: Image.Image
 ) -> Image.Image:
-    if image.size != (adj_size, adj_size):
+    if image.size != size:
         # Old 1 color method.
         # bg_col = image.copy().resize((1, 1)).getpixel((0,0))
-        # bg = Image.new(mode='RGB',size=(adj_size,adj_size),color=bg_col)
+        # bg = Image.new(mode='RGB',size=size,color=bg_col)
         # bg.thumbnail((1, 1))
-        # bg = bg.resize((adj_size,adj_size), resample=Image.Resampling.NEAREST)
+        # bg = bg.resize(size, resample=Image.Resampling.NEAREST)
 
         # Small gradient background. Looks decent, and is only a one-liner.
-        # bg = image.copy().resize((2, 2), resample=Image.Resampling.BILINEAR).resize((adj_size,adj_size),resample=Image.Resampling.BILINEAR)
+        # bg = image.copy().resize((2, 2), resample=Image.Resampling.BILINEAR).resize(size,resample=Image.Resampling.BILINEAR)
 
         # Four-Corner Gradient Background.
         # Not exactly a one-liner, but it's (subjectively) really cool.
@@ -29,26 +29,31 @@ def four_corner_gradient_background(
         bg.paste(tr, (1, 0, 2, 2))
         bg.paste(bl, (0, 1, 2, 2))
         bg.paste(br, (1, 1, 2, 2))
-        bg = bg.resize((adj_size, adj_size), resample=Image.Resampling.BICUBIC)
-
+        bg = bg.resize(size, resample=Image.Resampling.BICUBIC)
         bg.paste(
             image,
             box=(
-                (adj_size - image.size[0]) // 2,
-                (adj_size - image.size[1]) // 2,
+                (size[0] - image.size[0]) // 2,
+                (size[1] - image.size[1]) // 2,
             ),
         )
 
-        bg.putalpha(mask)
-        final = bg
+        final = Image.new("RGBA", bg.size, (0, 0, 0, 0))
+        final.paste(bg, mask=mask.getchannel(0))
+
+        # bg.putalpha(mask)
+        # final = bg
 
     else:
-        image.putalpha(mask)
-        final = image
+        # image.putalpha(mask)
+        # final = image
+
+        final = Image.new("RGBA", size, (0, 0, 0, 0))
+        final.paste(image, mask=mask.getchannel(0))
+
+    if final.mode != "RGBA":
+        final = final.convert("RGBA")
 
-    hl_soft = hl.copy()
-    hl_soft.putalpha(ImageEnhance.Brightness(hl.getchannel(3)).enhance(0.5))
-    final.paste(ImageChops.soft_light(final, hl_soft), mask=hl_soft.getchannel(3))
     return final
 
 

tagstudio/src/qt/helpers/rounded_pixmap_style.py

@@ -0,0 +1,31 @@
+# Based on the implementation by eyllanesc:
+# https://stackoverflow.com/questions/54230005/qmovie-with-border-radius
+# Licensed under the Creative Commons CC BY-SA 4.0 License:
+# https://creativecommons.org/licenses/by-sa/4.0/
+# Modified for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+from PySide6.QtGui import QPixmap, QPainter, QBrush
+from PySide6.QtWidgets import (
+    QProxyStyle,
+)
+
+
+class RoundedPixmapStyle(QProxyStyle):
+    def __init__(self, radius=8):
+        super().__init__()
+        self._radius = radius
+
+    def drawItemPixmap(self, painter, rectangle, alignment, pixmap):
+        painter.save()
+        pix = QPixmap(pixmap.size())
+        pix.fill("#00000000")
+        p = QPainter(pix)
+        p.setBrush(QBrush(pixmap))
+        p.setPen("#00000000")
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        p.drawRoundedRect(pixmap.rect(), self._radius, self._radius)
+        p.end()
+        super(RoundedPixmapStyle, self).drawItemPixmap(
+            painter, rectangle, alignment, pix
+        )
+        painter.restore()

tagstudio/src/qt/helpers/text_wrapper.py

@@ -0,0 +1,51 @@
+# Copyright (C) 2024 Travis Abendshien (CyanVoxel).
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+from PIL import Image, ImageDraw, ImageFont
+
+
+def wrap_line(  # type: ignore
+    text: str,
+    font: ImageFont.ImageFont,
+    width: int = 256,
+    draw: ImageDraw.ImageDraw = None,
+) -> int:
+    """
+    Takes in a single line and returns the index it should be broken up at but
+    it only splits one Time
+    """
+    if draw is None:
+        bg = Image.new("RGB", (width, width), color="#1e1e1e")
+        draw = ImageDraw.Draw(bg)
+    if draw.textlength(text, font=font) > width:
+        for i in range(
+            int(len(text) / int(draw.textlength(text, font=font)) * width) - 2,
+            0,
+            -1,
+        ):
+            if draw.textlength(text[:i], font=font) < width:
+                return i
+    else:
+        return -1
+
+
+def wrap_full_text(
+    text: str,
+    font: ImageFont.ImageFont,
+    width: int = 256,
+    draw: ImageDraw.ImageDraw = None,
+) -> str:
+    """
+    Takes in a string and breaks it up to fit in the canvas given accounts for kerning and font size etc.
+    """
+    lines = []
+    i = 0
+    last_i = 0
+    while wrap_line(text[i:], font=font, width=width, draw=draw) > 0:
+        i = wrap_line(text[i:], font=font, width=width, draw=draw) + last_i
+        lines.append(text[last_i:i])
+        last_i = i
+    lines.append(text[last_i:])
+    text_wrapped = "\n".join(lines)
+    return text_wrapped

tagstudio/src/qt/main_window.py

@@ -66,7 +66,7 @@ class Ui_MainWindow(QMainWindow):
         self.horizontalLayout = QHBoxLayout()
         self.horizontalLayout.setObjectName(u"horizontalLayout")
   
-        # ComboBox goup for search type and thumbnail size
+        # ComboBox group for search type and thumbnail size
         self.horizontalLayout_3 = QHBoxLayout()
         self.horizontalLayout_3.setObjectName("horizontalLayout_3")
   
@@ -83,17 +83,17 @@ class Ui_MainWindow(QMainWindow):
         self.horizontalLayout_3.addWidget(self.comboBox_2)
   
         # Thumbnail Size placeholder
-        self.comboBox = QComboBox(self.centralwidget)
-        self.comboBox.setObjectName(u"comboBox")
+        self.thumb_size_combobox = QComboBox(self.centralwidget)
+        self.thumb_size_combobox.setObjectName(u"thumbSizeComboBox")
         sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
         sizePolicy.setHorizontalStretch(0)
         sizePolicy.setVerticalStretch(0)
         sizePolicy.setHeightForWidth(
-            self.comboBox.sizePolicy().hasHeightForWidth())
-        self.comboBox.setSizePolicy(sizePolicy)
-        self.comboBox.setMinimumWidth(128)
-        self.comboBox.setMaximumWidth(128)
-        self.horizontalLayout_3.addWidget(self.comboBox)
+            self.thumb_size_combobox.sizePolicy().hasHeightForWidth())
+        self.thumb_size_combobox.setSizePolicy(sizePolicy)
+        self.thumb_size_combobox.setMinimumWidth(128)
+        self.thumb_size_combobox.setMaximumWidth(352)
+        self.horizontalLayout_3.addWidget(self.thumb_size_combobox)
         self.gridLayout.addLayout(self.horizontalLayout_3, 5, 0, 1, 1)
 
         self.splitter = QSplitter()
@@ -212,10 +212,10 @@ class Ui_MainWindow(QMainWindow):
         # Search type selector
         self.comboBox_2.setItemText(0, QCoreApplication.translate("MainWindow", "And (Includes All Tags)"))
         self.comboBox_2.setItemText(1, QCoreApplication.translate("MainWindow", "Or (Includes Any Tag)"))
-        self.comboBox.setCurrentText("")
+        self.thumb_size_combobox.setCurrentText("")
   
         # Thumbnail size selector
-        self.comboBox.setPlaceholderText(
+        self.thumb_size_combobox.setPlaceholderText(
             QCoreApplication.translate("MainWindow", u"Thumbnail Size", None))
     # retranslateUi
 

tagstudio/src/qt/modals/add_field.py

@@ -10,14 +10,14 @@ from PySide6.QtWidgets import (
     QHBoxLayout,
     QLabel,
     QPushButton,
-    QComboBox,
+    QListWidget,
 )
 
 from src.core.library import Library
 
 
 class AddFieldModal(QWidget):
-    done = Signal(int)
+    done = Signal(list)
 
     def __init__(self, library: "Library"):
         # [Done]
@@ -38,31 +38,25 @@ class AddFieldModal(QWidget):
         self.title_widget.setStyleSheet(
             # 'background:blue;'
             # 'text-align:center;'
-            "font-weight:bold;" "font-size:14px;" "padding-top: 6px" ""
+            "font-weight:bold;" "font-size:14px;" "padding-top: 6px"
         )
         self.title_widget.setText("Add Field")
         self.title_widget.setAlignment(Qt.AlignmentFlag.AlignCenter)
 
-        self.combo_box = QComboBox()
-        self.combo_box.setEditable(False)
-        # self.combo_box.setMaxVisibleItems(5)
-        self.combo_box.setStyleSheet("combobox-popup:0;")
-        self.combo_box.view().setVerticalScrollBarPolicy(
-            Qt.ScrollBarPolicy.ScrollBarAsNeeded
-        )
+        self.list_widget = QListWidget()
+        self.list_widget.setSelectionMode(QListWidget.SelectionMode.ExtendedSelection)
+
+        items = []
         for df in self.lib.default_fields:
-            self.combo_box.addItem(
-                f'{df["name"]} ({df["type"].replace("_", " ").title()})'
-            )
+            items.append(f'{df["name"]} ({df["type"].replace("_", " ").title()})')
+
+        self.list_widget.addItems(items)
 
         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')
-
         self.cancel_button = QPushButton()
         self.cancel_button.setText("Cancel")
         self.cancel_button.clicked.connect(self.hide)
@@ -75,17 +69,11 @@ class AddFieldModal(QWidget):
         self.save_button.setDefault(True)
         self.save_button.clicked.connect(self.hide)
         self.save_button.clicked.connect(
-            lambda: self.done.emit(self.combo_box.currentIndex())
+            lambda: self.done.emit(self.list_widget.selectedIndexes())
         )
-        # self.save_button.clicked.connect(lambda: save_callback(widget.get_content()))
         self.button_layout.addWidget(self.save_button)
 
-        # self.returnPressed.connect(lambda: self.done.emit(self.combo_box.currentIndex()))
-
-        # self.done.connect(lambda x: callback(x))
-
         self.root_layout.addWidget(self.title_widget)
-        self.root_layout.addWidget(self.combo_box)
-        # self.root_layout.setStretch(1,2)
-        self.root_layout.addStretch(1)
+        self.root_layout.addWidget(self.list_widget)
+
         self.root_layout.addWidget(self.button_container)

tagstudio/src/qt/modals/drop_import.py

@@ -0,0 +1,246 @@
+# Licensed under the GPL-3.0 License.
+# Created for TagStudio: https://github.com/CyanVoxel/TagStudio
+
+from pathlib import Path
+import shutil
+import typing
+
+from PySide6.QtCore import QThreadPool
+from PySide6.QtGui import QDropEvent, QDragEnterEvent, QDragMoveEvent
+from PySide6.QtWidgets import QMessageBox
+from src.qt.widgets.progress import ProgressWidget
+from src.qt.helpers.custom_runnable import CustomRunnable
+from src.qt.helpers.function_iterator import FunctionIterator
+
+if typing.TYPE_CHECKING:
+    from src.qt.ts_qt import QtDriver
+
+import logging
+
+
+class DropImport:
+    def __init__(self, driver: "QtDriver"):
+        self.driver = driver
+
+    def dropEvent(self, event: QDropEvent):
+        if (
+            event.source() is self.driver
+        ):  # change that if you want to drop something originating from tagstudio, for moving or so
+            return
+
+        if not event.mimeData().hasUrls():
+            return
+
+        self.urls = event.mimeData().urls()
+        self.import_files()
+
+    def dragEnterEvent(self, event: QDragEnterEvent):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dragMoveEvent(self, event: QDragMoveEvent):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            logging.info(self.driver.selected)
+            event.ignore()
+
+    def import_files(self):
+        self.files: list[Path] = []
+        self.dirs_in_root: list[Path] = []
+        self.duplicate_files: list[Path] = []
+
+        def displayed_text(x):
+            text = f"Searching New Files...\n{x[0]+1} File{'s' if x[0]+1 != 1 else ''} Found."
+            if x[1] == 0:
+                return text
+            return text + f" {x[1]} Already exist in the library folders"
+
+        create_progress_bar(
+            self.collect_files_to_import,
+            "Searching Files",
+            "Searching New Files...\nPreparing...",
+            displayed_text,
+            self.ask_user,
+        )
+
+    def collect_files_to_import(self):
+        for url in self.urls:
+            if not url.isLocalFile():
+                continue
+
+            file = Path(url.toLocalFile())
+
+            if file.is_dir():
+                for f in self.get_files_in_folder(file):
+                    if f.is_dir():
+                        continue
+                    self.files.append(f)
+                    if (
+                        self.driver.lib.library_dir / self.get_relative_path(file)
+                    ).exists():
+                        self.duplicate_files.append(f)
+                    yield [len(self.files), len(self.duplicate_files)]
+
+                self.dirs_in_root.append(file.parent)
+            else:
+                self.files.append(file)
+
+                if file.parent not in self.dirs_in_root:
+                    self.dirs_in_root.append(
+                        file.parent
+                    )  # to create relative path of files not in folder
+
+                if (Path(self.driver.lib.library_dir) / file.name).exists():
+                    self.duplicate_files.append(file)
+
+                yield [len(self.files), len(self.duplicate_files)]
+
+    def copy_files(self):
+        fileCount = 0
+        duplicated_files_progress = 0
+        for file in self.files:
+            if file.is_dir():
+                continue
+
+            dest_file = self.get_relative_path(file)
+
+            if file in self.duplicate_files:
+                duplicated_files_progress += 1
+                if self.choice == 0:  # skip duplicates
+                    continue
+
+                if self.choice == 2:  # rename
+                    new_name = self.get_renamed_duplicate_filename_in_lib(dest_file)
+                    dest_file = dest_file.with_name(new_name)
+                    self.driver.lib.files_not_in_library.append(dest_file)
+            else:  # override is simply copying but not adding a new entry
+                self.driver.lib.files_not_in_library.append(dest_file)
+
+            (self.driver.lib.library_dir / dest_file).parent.mkdir(
+                parents=True, exist_ok=True
+            )
+            shutil.copyfile(file, self.driver.lib.library_dir / dest_file)
+
+            fileCount += 1
+            yield [fileCount, duplicated_files_progress]
+
+    def ask_user(self):
+        self.choice = -1
+
+        if len(self.duplicate_files) > 0:
+            self.choice = self.duplicates_choice()
+
+            if self.choice == 3:  # cancel
+                return
+
+        def displayed_text(x):
+            dupes_choice_text = (
+                "Skipped"
+                if self.choice == 0
+                else ("Overridden" if self.choice == 1 else "Renamed")
+            )
+
+            text = f"Importing New Files...\n{x[0]+1} File{'s' if x[0]+1 != 1 else ''} Imported."
+            if x[1] == 0:
+                return text
+            return text + f" {x[1]} {dupes_choice_text}"
+
+        create_progress_bar(
+            self.copy_files,
+            "Import Files",
+            "Importing New Files...\nPreparing...",
+            displayed_text,
+            self.driver.add_new_files_runnable,
+            len(self.files),
+        )
+
+    def duplicates_choice(self) -> int:
+        display_limit: int = 5
+        msgBox = QMessageBox()
+        msgBox.setWindowTitle(
+            f"File Conflict{'s' if len(self.duplicate_files) > 1 else ''}"
+        )
+
+        dupes_to_show = self.duplicate_files
+        if len(self.duplicate_files) > display_limit:
+            dupes_to_show = dupes_to_show[0:display_limit]
+
+        dupes_str = "\n    ".join(map(lambda path: str(path), dupes_to_show))
+        dupes_more = (
+            f"\nand {len(self.duplicate_files)-display_limit} more "
+            if len(self.duplicate_files) > display_limit
+            else "\n"
+        )
+
+        msgBox.setText(
+            f"The following files:\n    {dupes_str}{dupes_more}have filenames that already exist in the library folder."
+        )
+        msgBox.addButton("Skip", QMessageBox.ButtonRole.YesRole)
+        msgBox.addButton("Override", QMessageBox.ButtonRole.DestructiveRole)
+        msgBox.addButton("Rename", QMessageBox.ButtonRole.DestructiveRole)
+        msgBox.addButton("Cancel", QMessageBox.ButtonRole.NoRole)
+        return msgBox.exec()
+
+    def get_files_exists_in_library(self, path: Path) -> list[Path]:
+        exists: list[Path] = []
+        if not path.is_dir():
+            return exists
+
+        files = self.get_files_in_folder(path)
+        for file in files:
+            if file.is_dir():
+                exists += self.get_files_exists_in_library(file)
+            elif (self.driver.lib.library_dir / self.get_relative_path(file)).exists():
+                exists.append(file)
+        return exists
+
+    def get_relative_paths(self, paths: list[Path]) -> list[Path]:
+        relative_paths = []
+        for file in paths:
+            relative_paths.append(self.get_relative_path(file))
+        return relative_paths
+
+    def get_relative_path(self, path: Path) -> Path:
+        for dir in self.dirs_in_root:
+            if path.is_relative_to(dir):
+                return path.relative_to(dir)
+        return Path(path.name)
+
+    def get_files_in_folder(self, path: Path) -> list[Path]:
+        files = []
+        for file in path.glob("**/*"):
+            files.append(file)
+        return files
+
+    def get_renamed_duplicate_filename_in_lib(self, filePath: Path) -> str:
+        index = 2
+        o_filename = filePath.name
+        dot_idx = o_filename.index(".")
+        while (self.driver.lib.library_dir / filePath).exists():
+            filePath = filePath.with_name(
+                o_filename[:dot_idx] + f" ({index})" + o_filename[dot_idx:]
+            )
+            index += 1
+        return filePath.name
+
+
+def create_progress_bar(
+    function, title: str, text: str, update_label_callback, done_callback, max=0
+):
+    iterator = FunctionIterator(function)
+    pw = ProgressWidget(
+        window_title=title,
+        label_text=text,
+        cancel_button_text=None,
+        minimum=0,
+        maximum=max,
+    )
+    pw.show()
+    iterator.value.connect(lambda x: pw.update_progress(x[0] + 1))
+    iterator.value.connect(lambda x: pw.update_label(update_label_callback(x)))
+    r = CustomRunnable(lambda: iterator.run())
+    r.done.connect(lambda: (pw.hide(), done_callback()))  # type: ignore
+    QThreadPool.globalInstance().start(r)

tagstudio/src/qt/modals/merge_tag.py

@@ -0,0 +1,63 @@
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QLabel, QComboBox, QPushButton
+from PySide6.QtCore import Qt
+import logging
+
+
+class MergeTagModal(QDialog):
+    def __init__(self, library, current_tag):
+        super().__init__()
+        self.lib = library
+        self.current_tag = current_tag
+        self.init_ui()
+
+    def init_ui(self):
+        layout = QVBoxLayout()
+
+        layout.addWidget(QLabel("Selected tag:"))
+        self.selected_tag_dropdown = QComboBox(self)
+        for tag in self.lib.tags:
+            self.selected_tag_dropdown.addItem(tag.display_name(self.lib), tag)
+        self.selected_tag_dropdown.setCurrentIndex(self.find_current_tag_index())
+        self.selected_tag_dropdown.currentIndexChanged.connect(self.update_current_tag)
+        layout.addWidget(self.selected_tag_dropdown)
+
+        arrow_label = QLabel("↓")
+        arrow_label.setAlignment(Qt.AlignCenter)
+        layout.addWidget(arrow_label)
+
+        layout.addWidget(QLabel("Select tag to merge with:"))
+        self.tag2_dropdown = QComboBox(self)
+        self.update_tag2_dropdown()
+        layout.addWidget(self.tag2_dropdown)
+
+        self.merge_button = QPushButton("Merge", self)
+        layout.addWidget(self.merge_button)
+
+        self.merge_button.clicked.connect(self.merge_tags)
+
+        self.setLayout(layout)
+
+    def find_current_tag_index(self):
+        for index in range(self.selected_tag_dropdown.count()):
+            if self.selected_tag_dropdown.itemData(index) == self.current_tag:
+                return index
+        return 0
+
+    def update_current_tag(self):
+        self.current_tag = self.selected_tag_dropdown.currentData()
+        self.update_tag2_dropdown()
+
+    def update_tag2_dropdown(self):
+        self.tag2_dropdown.clear()
+        for tag in self.lib.tags:
+            if tag.id != self.current_tag.id:
+                self.tag2_dropdown.addItem(tag.display_name(self.lib), tag)
+
+    def merge_tags(self):
+        target_tag = self.tag2_dropdown.currentData()
+        if target_tag and self.current_tag != target_tag:
+            self.lib.merge_tag(self.current_tag, target_tag)
+            self.accept()
+        else:
+            logging.error("MergeTagModal: Invalid tag selection.")
+            self.reject()

tagstudio/src/qt/modals/tag_database.py

@@ -12,6 +12,7 @@ from PySide6.QtWidgets import (
     QFrame,
 )
 
+from src.core.constants import TAG_COLORS
 from src.core.library import Library
 from src.qt.widgets.panel import PanelWidget, PanelModal
 from src.qt.widgets.tag import TagWidget
@@ -103,8 +104,28 @@ class TagDatabasePanel(PanelWidget):
             # Get tag ids to keep this behaviorally identical
             tags = [t.id for t in self.lib.tags]
 
+        if query:
+            # sort tags by whether the tag's name is the text that's matching the search, alphabetically, and then by color
+            sorted_tags = sorted(
+                tags,
+                key=lambda tag_id: (
+                    not self.lib.get_tag(tag_id).name.lower().startswith(query.lower()),
+                    self.lib.get_tag(tag_id).display_name(self.lib),
+                    TAG_COLORS.index(self.lib.get_tag(tag_id).color.lower()),
+                ),
+            )
+        else:
+            # sort tags by color and then alphabetically
+            sorted_tags = sorted(
+                tags,
+                key=lambda tag_id: (
+                    TAG_COLORS.index(self.lib.get_tag(tag_id).color.lower()),
+                    self.lib.get_tag(tag_id).display_name(self.lib),
+                ),
+            )
+
         first_id_set = False
-        for tag_id in tags:
+        for tag_id in sorted_tags:
             if not first_id_set:
                 self.first_tag_id = tag_id
                 first_id_set = True

tagstudio/src/qt/modals/tag_search.py

@@ -17,6 +17,7 @@ from PySide6.QtWidgets import (
     QFrame,
 )
 
+from src.core.constants import TAG_COLORS
 from src.core.library import Library
 from src.core.palette import ColorType, get_tag_color
 from src.qt.widgets.panel import PanelWidget
@@ -111,7 +112,27 @@ class TagSearchPanel(PanelWidget):
         found_tags = self.lib.search_tags(query, include_cluster=True)[: self.tag_limit]
         self.first_tag_id = found_tags[0] if found_tags else None
 
-        for tag_id in found_tags:
+        if query:
+            # sort tags by whether the tag's name is the text that's matching the search, alphabetically, and then by color
+            sorted_tags = sorted(
+                found_tags,
+                key=lambda tag_id: (
+                    not self.lib.get_tag(tag_id).name.lower().startswith(query.lower()),
+                    self.lib.get_tag(tag_id).display_name(self.lib),
+                    TAG_COLORS.index(self.lib.get_tag(tag_id).color.lower()),
+                ),
+            )
+        else:
+            # sort tags by color and then alphabetically
+            sorted_tags = sorted(
+                found_tags,
+                key=lambda tag_id: (
+                    TAG_COLORS.index(self.lib.get_tag(tag_id).color.lower()),
+                    self.lib.get_tag(tag_id).display_name(self.lib),
+                ),
+            )
+
+        for tag_id in sorted_tags:
             c = QWidget()
             l = QHBoxLayout(c)
             l.setContentsMargins(0, 0, 0, 0)

tagstudio/src/qt/resource_manager.py

@@ -5,6 +5,7 @@
 import logging
 from pathlib import Path
 from typing import Any
+from PIL import Image
 
 import ujson
 
@@ -30,6 +31,20 @@ class ResourceManager:
                 )
             ResourceManager._initialized = True
 
+    @staticmethod
+    def get_path(id: str) -> Path | None:
+        """Get a resource's path from the ResourceManager.
+        Args:
+            id (str): The name of the resource.
+
+        Returns:
+            Path: The resource path if found, else None.
+        """
+        res: dict = ResourceManager._map.get(id)
+        if res:
+            return Path(__file__).parents[2] / "resources" / res.get("path")
+        return None
+
     def get(self, id: str) -> Any:
         """Get a resource from the ResourceManager.
         This can include resources inside and outside of QResources, and will return
@@ -46,19 +61,30 @@ class ResourceManager:
             return cached_res
         else:
             res: dict = ResourceManager._map.get(id)
-            if res.get("mode") in ["r", "rb"]:
-                with open(
-                    (Path(__file__).parents[2] / "resources" / res.get("path")),
-                    res.get("mode"),
-                ) as f:
-                    data = f.read()
-                    if res.get("mode") == "rb":
-                        data = bytes(data)
-                    ResourceManager._cache[id] = data
+            try:
+                if res and res.get("mode") in ["r", "rb"]:
+                    with open(
+                        (Path(__file__).parents[2] / "resources" / res.get("path")),
+                        res.get("mode"),
+                    ) as f:
+                        data = f.read()
+                        if res.get("mode") == "rb":
+                            data = bytes(data)
+                        ResourceManager._cache[id] = data
+                        return data
+                elif res and res.get("mode") == "pil":
+                    data = Image.open(
+                        Path(__file__).parents[2] / "resources" / res.get("path")
+                    )
                     return data
-            elif res.get("mode") in ["qt"]:
-                # TODO: Qt resource loading logic
-                pass
+                elif res and res.get("mode") in ["qt"]:
+                    # TODO: Qt resource loading logic
+                    pass
+            except FileNotFoundError:
+                logging.error(
+                    f"[ResourceManager][ERROR]: Could not find resource: {Path(__file__).parents[2] / "resources" / res.get("path")}"
+                )
+                return None
 
     def __getattr__(self, __name: str) -> Any:
         attr = self.get(__name)

tagstudio/src/qt/resources.json

@@ -14,5 +14,85 @@
   "volume_mute_icon": {
     "path": "qt/images/volume_mute.svg",
     "mode": "rb"
+  },
+  "broken_link_icon": {
+    "path": "qt/images/broken_link_icon.png",
+    "mode": "pil"
+  },
+  "adobe_illustrator": {
+    "path": "qt/images/file_icons/adobe_illustrator.png",
+    "mode": "pil"
+  },
+  "adobe_photoshop": {
+    "path": "qt/images/file_icons/adobe_photoshop.png",
+    "mode": "pil"
+  },
+  "affinity_photo": {
+    "path": "qt/images/file_icons/affinity_photo.png",
+    "mode": "pil"
+  },
+  "audio": {
+    "path": "qt/images/file_icons/audio.png",
+    "mode": "pil"
+  },
+  "blender": {
+    "path": "qt/images/file_icons/blender.png",
+    "mode": "pil"
+  },
+  "document": {
+    "path": "qt/images/file_icons/document.png",
+    "mode": "pil"
+  },
+  "file_generic": {
+    "path": "qt/images/file_icons/file_generic.png",
+    "mode": "pil"
+  },
+  "font": {
+    "path": "qt/images/file_icons/font.png",
+    "mode": "pil"
+  },
+  "image": {
+    "path": "qt/images/file_icons/image.png",
+    "mode": "pil"
+  },
+  "image_vector": {
+    "path": "qt/images/file_icons/image_vector.png",
+    "mode": "pil"
+  },
+  "material": {
+    "path": "qt/images/file_icons/material.png",
+    "mode": "pil"
+  },
+  "model": {
+    "path": "qt/images/file_icons/model.png",
+    "mode": "pil"
+  },
+  "presentation": {
+    "path": "qt/images/file_icons/presentation.png",
+    "mode": "pil"
+  },
+  "program": {
+    "path": "qt/images/file_icons/program.png",
+    "mode": "pil"
+  },
+  "spreadsheet": {
+    "path": "qt/images/file_icons/spreadsheet.png",
+    "mode": "pil"
+  },
+  "text": {
+    "path": "qt/images/file_icons/text.png",
+    "mode": "pil"
+  },
+  "video": {
+    "path": "qt/images/file_icons/video.png",
+    "mode": "pil"
+  },
+  "thumb_loading": {
+    "path": "qt/images/thumb_loading.png",
+    "mode": "pil"
+  },
+  "placeholder_mp4": {
+    "path": "qt/videos/placeholder.mp4",
+    "mode": "rb"
   }
 }

tagstudio/src/qt/ts_qt.py

@@ -8,9 +8,11 @@
 """A Qt driver for TagStudio."""
 
 import ctypes
+import copy
 import logging
 import math
 import os
+import platform
 import sys
 import time
 import typing
@@ -52,6 +54,7 @@ from PySide6.QtWidgets import (
     QMenu,
     QMenuBar,
     QComboBox,
+    QMessageBox,
 )
 from humanfriendly import format_timespan
 
@@ -64,12 +67,15 @@ from src.core.constants import (
     TS_FOLDER_NAME,
     VERSION_BRANCH,
     VERSION,
+    TEXT_FIELDS,
     TAG_FAVORITE,
     TAG_ARCHIVED,
 )
+from src.core.palette import ColorType, get_ui_color
 from src.core.utils.web import strip_web_protocol
 from src.qt.flowlayout import FlowLayout
 from src.qt.main_window import Ui_MainWindow
+from src.qt.helpers.file_deleter import delete_file
 from src.qt.helpers.function_iterator import FunctionIterator
 from src.qt.helpers.custom_runnable import CustomRunnable
 from src.qt.resource_manager import ResourceManager
@@ -85,6 +91,7 @@ from src.qt.modals.file_extension import FileExtensionModal
 from src.qt.modals.fix_unlinked import FixUnlinkedEntriesModal
 from src.qt.modals.fix_dupes import FixDupeFilesModal
 from src.qt.modals.folders_to_tags import FoldersToTagsModal
+from src.qt.modals.drop_import import DropImport
 
 # this import has side-effect of import PySide resources
 import src.qt.resources_rc  # pylint: disable=unused-import
@@ -269,6 +276,11 @@ class QtDriver(QObject):
         # 	f'QScrollBar::{{background:red;}}'
         # 	)
 
+        self.drop_import = DropImport(self)
+        self.main_window.dragEnterEvent = self.drop_import.dragEnterEvent  # type: ignore
+        self.main_window.dropEvent = self.drop_import.dropEvent  # type: ignore
+        self.main_window.dragMoveEvent = self.drop_import.dragMoveEvent  # type: ignore
+
         # # self.main_window.windowFlags() &
         # # self.main_window.setWindowFlag(Qt.WindowType.FramelessWindowHint, True)
         # self.main_window.setWindowFlag(Qt.WindowType.NoDropShadowWindowHint, True)
@@ -293,6 +305,9 @@ class QtDriver(QObject):
             icon.addFile(str(icon_path))
             app.setWindowIcon(icon)
 
+        self.copied_fields: list[dict] = []
+        self.is_buffer_merged: bool = False
+
         menu_bar = QMenuBar(self.main_window)
         self.main_window.setMenuBar(menu_bar)
         menu_bar.setNativeMenuBar(True)
@@ -386,6 +401,36 @@ class QtDriver(QObject):
 
         edit_menu.addSeparator()
 
+        # NOTE: Name is set in update_clipboard_actions()
+        self.copy_entry_fields_action = QAction(menu_bar)
+        self.copy_entry_fields_action.triggered.connect(
+            lambda: self.copy_entry_fields_callback()
+        )
+        self.copy_entry_fields_action.setShortcut(
+            QtCore.QKeyCombination(
+                QtCore.Qt.KeyboardModifier(QtCore.Qt.KeyboardModifier.ControlModifier),
+                QtCore.Qt.Key.Key_C,
+            )
+        )
+        self.copy_entry_fields_action.setToolTip("Ctrl+C")
+        edit_menu.addAction(self.copy_entry_fields_action)
+
+        # NOTE: Name is set in update_clipboard_actions()
+        self.paste_entry_fields_action = QAction(menu_bar)
+        self.paste_entry_fields_action.triggered.connect(
+            self.paste_entry_fields_callback
+        )
+        self.paste_entry_fields_action.setShortcut(
+            QtCore.QKeyCombination(
+                QtCore.Qt.KeyboardModifier(QtCore.Qt.KeyboardModifier.ControlModifier),
+                QtCore.Qt.Key.Key_V,
+            )
+        )
+        self.paste_entry_fields_action.setToolTip("Ctrl+V")
+        edit_menu.addAction(self.paste_entry_fields_action)
+
+        edit_menu.addSeparator()
+
         select_all_action = QAction("Select All", menu_bar)
         select_all_action.triggered.connect(self.select_all_action_callback)
         select_all_action.setShortcut(
@@ -405,6 +450,15 @@ class QtDriver(QObject):
 
         edit_menu.addSeparator()
 
+        self.delete_file_action = QAction("Delete Selected File(s)", menu_bar)
+        self.delete_file_action.triggered.connect(
+            lambda f="": self.delete_files_callback(f)
+        )
+        self.delete_file_action.setShortcut(QtCore.Qt.Key.Key_Delete)
+        edit_menu.addAction(self.delete_file_action)
+
+        edit_menu.addSeparator()
+
         manage_file_extensions_action = QAction("Manage File Extensions", menu_bar)
         manage_file_extensions_action.triggered.connect(
             lambda: self.show_file_extension_modal()
@@ -491,13 +545,15 @@ class QtDriver(QObject):
         folders_to_tags_action.triggered.connect(lambda: ftt_modal.show())
         macros_menu.addAction(folders_to_tags_action)
 
-        # Help Menu ==========================================================
+        # Help Menu ============================================================
         self.repo_action = QAction("Visit GitHub Repository", menu_bar)
         self.repo_action.triggered.connect(
             lambda: webbrowser.open("https://github.com/TagStudioDev/TagStudio")
         )
         help_menu.addAction(self.repo_action)
-        self.set_macro_menu_viability()
+        self.set_menu_action_viability()
+
+        self.update_clipboard_actions()
 
         menu_bar.addMenu(file_menu)
         menu_bar.addMenu(edit_menu)
@@ -506,6 +562,9 @@ class QtDriver(QObject):
         menu_bar.addMenu(window_menu)
         menu_bar.addMenu(help_menu)
 
+        # ======================================================================
+
+        # Preview Panel --------------------------------------------------------
         self.preview_panel = PreviewPanel(self.lib, self)
         l: QHBoxLayout = self.main_window.splitter
         l.addWidget(self.preview_panel)
@@ -514,11 +573,17 @@ class QtDriver(QObject):
             str(Path(__file__).parents[2] / "resources/qt/fonts/Oxanium-Bold.ttf")
         )
 
+        self.thumb_sizes: list[tuple[str, int]] = [
+            ("Extra Large Thumbnails", 256),
+            ("Large Thumbnails", 192),
+            ("Medium Thumbnails", 128),
+            ("Small Thumbnails", 96),
+            ("Mini Thumbnails", 76),
+        ]
         self.thumb_size = 128
         self.max_results = 500
         self.item_thumbs: list[ItemThumb] = []
         self.thumb_renderers: list[ThumbRenderer] = []
-        self.collation_thumb_size = math.ceil(self.thumb_size * 2)
 
         self.init_library_window()
 
@@ -553,23 +618,35 @@ class QtDriver(QObject):
         self.shutdown()
 
     def init_library_window(self):
-        # self._init_landing_page() # Taken care of inside the widget now
-        self._init_thumb_grid()
-
         # TODO: Put this into its own method that copies the font file(s) into memory
         # so the resource isn't being used, then store the specific size variations
         # in a global dict for methods to access for different DPIs.
         # adj_font_size = math.floor(12 * self.main_window.devicePixelRatio())
         # self.ext_font = ImageFont.truetype(os.path.normpath(f'{Path(__file__).parents[2]}/resources/qt/fonts/Oxanium-Bold.ttf'), adj_font_size)
 
+        # Search Button
         search_button: QPushButton = self.main_window.searchButton
         search_button.clicked.connect(
             lambda: self.filter_items(self.main_window.searchField.text())
         )
+
+        # Search Field
         search_field: QLineEdit = self.main_window.searchField
         search_field.returnPressed.connect(
             lambda: self.filter_items(self.main_window.searchField.text())
         )
+
+        # Thumbnail Size ComboBox
+        thumb_size_combobox: QComboBox = self.main_window.thumb_size_combobox
+        for size in self.thumb_sizes:
+            thumb_size_combobox.addItem(size[0])
+        thumb_size_combobox.setCurrentIndex(2)  # Default: Medium
+        thumb_size_combobox.currentIndexChanged.connect(
+            lambda: self.thumb_size_callback(thumb_size_combobox.currentIndex())
+        )
+        self._init_thumb_grid()
+
+        # Search Type ComboBox
         search_type_selector: QComboBox = self.main_window.comboBox_2
         search_type_selector.currentIndexChanged.connect(
             lambda: self.set_search_type(
@@ -688,11 +765,16 @@ class QtDriver(QObject):
             self.lib.clear_internal_vars()
             title_text = f"{self.base_title}"
             self.main_window.setWindowTitle(title_text)
+            self.main_window.setAcceptDrops(False)
 
             self.nav_frames = []
             self.cur_frame_idx = -1
             self.cur_query = ""
             self.selected.clear()
+            self.copied_fields.clear()
+            self.is_buffer_merged = False
+            self.update_clipboard_actions()
+            self.set_menu_action_viability()
             self.preview_panel.update_widgets()
             self.filter_items()
             self.main_window.toggle_landing_page(True)
@@ -730,7 +812,7 @@ class QtDriver(QObject):
                 self.selected.append((item.mode, item.item_id))
                 item.thumb_button.set_selected(True)
 
-        self.set_macro_menu_viability()
+        self.set_menu_action_viability()
         self.preview_panel.update_widgets()
 
     def clear_select_action_callback(self):
@@ -738,7 +820,7 @@ class QtDriver(QObject):
         for item in self.item_thumbs:
             item.thumb_button.set_selected(False)
 
-        self.set_macro_menu_viability()
+        self.set_menu_action_viability()
         self.preview_panel.update_widgets()
 
     def show_tag_database(self):
@@ -758,6 +840,112 @@ class QtDriver(QObject):
         self.modal.saved.connect(lambda: (panel.save(), self.filter_items("")))
         self.modal.show()
 
+    def delete_files_callback(self, origin_path: str | Path):
+        """Callback to send on or more files to the system trash.
+
+        If 0-1 items are currently selected, the origin_path is used to delete the file
+        from the originating context menu item.
+        If there are currently multiple items selected,
+        then the selection buffer is used to determine the files to be deleted.
+
+        Args:
+            origin_path(str): The file path associated with the widget making the call.
+                May or may not be the file targeted, depending on the selection rules.
+        """
+        entry = None
+        pending: list[Path] = []
+        deleted_count: int = 0
+
+        if len(self.selected) <= 1 and origin_path:
+            pending.append(Path(origin_path))
+        elif (len(self.selected) > 1) or (len(self.selected) <= 1 and not origin_path):
+            for i, item_pair in enumerate(self.selected):
+                if item_pair[0] == ItemType.ENTRY:
+                    entry = self.lib.get_entry(item_pair[1])
+                    filepath: Path = self.lib.library_dir / entry.path / entry.filename
+                    pending.append(filepath)
+
+        if pending:
+            if self.delete_file_confirmation(len(pending), pending[0]) == 3:
+                for i, f in enumerate(pending):
+                    if (origin_path == f) or (not origin_path):
+                        self.preview_panel.stop_file_use()
+                    if delete_file(f):
+                        self.main_window.statusbar.showMessage(
+                            f'Deleting file [{i}/{len(pending)}]: "{f}"...'
+                        )
+                        self.main_window.statusbar.repaint()
+
+                        entry_id = self.lib.get_entry_id_from_filepath(f)
+                        self.lib.remove_entry(entry_id)
+                        self.purge_item_from_navigation(ItemType.ENTRY, entry_id)
+                        deleted_count += 1
+                self.selected.clear()
+
+        if deleted_count > 0:
+            self.filter_items()
+            self.preview_panel.update_widgets()
+
+        if len(self.selected) <= 1 and deleted_count == 0:
+            self.main_window.statusbar.showMessage(
+                "No files deleted. Check if any of the files are currently in use."
+            )
+        elif len(self.selected) <= 1 and deleted_count == 1:
+            self.main_window.statusbar.showMessage(f"Deleted {deleted_count} file!")
+        elif len(self.selected) > 1 and deleted_count == 0:
+            self.main_window.statusbar.showMessage(
+                "No files deleted! Check if any of the files are currently in use."
+            )
+        elif len(self.selected) > 1 and deleted_count < len(self.selected):
+            self.main_window.statusbar.showMessage(
+                f"Only deleted {deleted_count} file{'' if deleted_count == 1 else 's'}! Check if any of the files are currently in use"
+            )
+        elif len(self.selected) > 1 and deleted_count == len(self.selected):
+            self.main_window.statusbar.showMessage(f"Deleted {deleted_count} files!")
+        self.main_window.statusbar.repaint()
+
+    def delete_file_confirmation(self, count: int, filename: Path | None = None) -> int:
+        """A confirmation dialogue box for deleting files.
+
+        Args:
+            count(int): The number of files to be deleted.
+            filename(Path | None): The filename to show if only one file is to be deleted.
+        """
+        trash_term: str = "Trash"
+        perm_warning: str = ""
+        if platform.system() == "Windows":
+            trash_term = "Recycle Bin"
+            # NOTE: Windows + send2trash will PERMANENTLY delete files which cannot be moved to the Recycle Bin.
+            # This is done without any warning, so this message is currently the best way I've got to inform the user.
+            # https://github.com/arsenetar/send2trash/issues/28
+            perm_warning = (
+                f"<h4 style='color: {get_ui_color(ColorType.PRIMARY, 'red')}'>"
+                f"<b>WARNING!</b> If this file can't be moved to the Recycle Bin, "
+                f"</b>it will be <b>permanently deleted!</b></h4>"
+            )
+
+        msg = QMessageBox()
+        msg.setTextFormat(Qt.TextFormat.RichText)
+        msg.setWindowTitle("Delete File" if count == 1 else "Delete Files")
+        msg.setIcon(QMessageBox.Icon.Warning)
+        if count <= 1:
+            msg.setText(
+                f"<h3>Are you sure you want to move this file to the {trash_term}?</h3>"
+                "<h4>This will remove it from TagStudio <i>AND</i> your file system!</h4>"
+                f"{filename if filename else ''}"
+                f"{perm_warning}<br>"
+            )
+        elif count > 1:
+            msg.setText(
+                f"<h3>Are you sure you want to move these {count} files to the {trash_term}?</h3>"
+                "<h4>This will remove them from TagStudio <i>AND</i> your file system!</h4>"
+                f"{perm_warning}<br>"
+            )
+        msg.addButton("&No", QMessageBox.ButtonRole.NoRole)
+        msg.addButton("&Yes", QMessageBox.ButtonRole.YesRole)
+
+        return msg.exec()
+
     def add_new_files_callback(self):
         """Runs when user initiates adding new files to the Library."""
         # # if self.lib.files_not_in_library:
@@ -943,6 +1131,141 @@ class QtDriver(QObject):
                             mode="replace",
                         )
 
+    def copy_entry_fields_callback(self):
+        """Copies fields from selected Entries into to buffer."""
+        merged_fields: list[dict] = []
+        merged_count: int = 0
+        for item_type, item_id in self.selected:
+            if item_type == ItemType.ENTRY:
+                entry = self.lib.get_entry(item_id)
+
+                if len(entry.fields) > 0:
+                    merged_count += 1
+
+                for field in entry.fields:
+                    field_id: int = self.lib.get_field_attr(field, "id")
+                    content = self.lib.get_field_attr(field, "content")
+
+                    if self.lib.get_field_obj(int(field_id))["type"] == "tag_box":
+                        existing_fields: list[int] = self.lib.get_field_index_in_entry(
+                            entry, field_id
+                        )
+                        if existing_fields and merged_fields:
+                            for i in content:
+                                field_index = copy.deepcopy(existing_fields[0])
+                                if i not in merged_fields[field_index][field_id]:
+                                    merged_fields[field_index][field_id].append(
+                                        copy.deepcopy(i)
+                                    )
+                        else:
+                            merged_fields.append(copy.deepcopy({field_id: content}))
+
+                    if self.lib.get_field_obj(int(field_id))["type"] in TEXT_FIELDS:
+                        if {field_id: content} not in merged_fields:
+                            merged_fields.append(copy.deepcopy({field_id: content}))
+
+        # Only set merged state to True if multiple Entries with actual field data were copied.
+        if merged_count > 1:
+            self.is_buffer_merged = True
+        else:
+            self.is_buffer_merged = False
+
+        self.copied_fields = merged_fields
+        self.update_clipboard_actions()
+
+    def paste_entry_fields_callback(self):
+        """Pastes buffered fields into currently selected Entries."""
+        # Code ported from ts_cli.py
+        if self.copied_fields:
+            for item_type, item_id in self.selected:
+                if item_type == ItemType.ENTRY:
+                    entry = self.lib.get_entry(item_id)
+
+                    for field in self.copied_fields:
+                        field_id: int = self.lib.get_field_attr(field, "id")
+                        content = self.lib.get_field_attr(field, "content")
+
+                        if self.lib.get_field_obj(int(field_id))["type"] == "tag_box":
+                            existing_fields: list[int] = (
+                                self.lib.get_field_index_in_entry(entry, field_id)
+                            )
+                            if existing_fields:
+                                self.lib.update_entry_field(
+                                    item_id, existing_fields[0], content, "append"
+                                )
+                            else:
+                                self.lib.add_field_to_entry(item_id, field_id)
+                                self.lib.update_entry_field(
+                                    item_id, -1, content, "append"
+                                )
+
+                        if self.lib.get_field_obj(int(field_id))["type"] in TEXT_FIELDS:
+                            if not self.lib.does_field_content_exist(
+                                item_id, field_id, content
+                            ):
+                                self.lib.add_field_to_entry(item_id, field_id)
+                                self.lib.update_entry_field(
+                                    item_id, -1, content, "replace"
+                                )
+
+            self.preview_panel.update_widgets()
+            self.update_badges()
+        self.update_clipboard_actions()
+
+    def update_clipboard_actions(self):
+        """Updates the text and enabled state of the field copy & paste actions."""
+        # Buffer State Dependant
+        if self.copied_fields:
+            self.paste_entry_fields_action.setDisabled(False)
+        else:
+            self.paste_entry_fields_action.setDisabled(True)
+            self.paste_entry_fields_action.setText("&Paste Fields")
+
+        # Selection Count Dependant
+        if len(self.selected) <= 0:
+            self.copy_entry_fields_action.setDisabled(True)
+            self.paste_entry_fields_action.setDisabled(True)
+            self.copy_entry_fields_action.setText("&Copy Fields")
+        if len(self.selected) == 1:
+            self.copy_entry_fields_action.setDisabled(False)
+            self.copy_entry_fields_action.setText("&Copy Fields")
+        elif len(self.selected) > 1:
+            self.copy_entry_fields_action.setDisabled(False)
+            self.copy_entry_fields_action.setText("&Copy Combined Fields")
+
+        # Merged State Dependant
+        if self.is_buffer_merged:
+            self.paste_entry_fields_action.setText("&Paste Combined Fields")
+        else:
+            self.paste_entry_fields_action.setText("&Paste Fields")
+
+    def thumb_size_callback(self, index: int):
+        """
+        Performs actions needed when the thumbnail size selection is changed.
+
+        Args:
+            index (int): The index of the item_thumbs/ComboBox list to use.
+        """
+        # Index 2 is the default (Medium)
+        if index < len(self.thumb_sizes) and index >= 0:
+            self.thumb_size = self.thumb_sizes[index][1]
+        else:
+            logging.error(
+                f"ERROR: Invalid thumbnail size index ({index}). Defaulting to 128px."
+            )
+            self.thumb_size = 128
+
+        self.update_thumbs()
+        blank_icon: QIcon = QIcon()
+        for it in self.item_thumbs:
+            it.thumb_button.setIcon(blank_icon)
+            it.resize(self.thumb_size, self.thumb_size)
+            it.thumb_size = (self.thumb_size, self.thumb_size)
+            it.setMinimumSize(self.thumb_size, self.thumb_size)
+            it.setMaximumSize(self.thumb_size, self.thumb_size)
+            it.thumb_button.thumb_size = (self.thumb_size, self.thumb_size)
+        self.flow_container.layout().setSpacing(min(self.thumb_size // 10, 12))
+
     def mouse_navigation(self, event: QMouseEvent):
         # print(event.button())
         if event.button() == Qt.MouseButton.ForwardButton:
@@ -1110,6 +1433,7 @@ class QtDriver(QObject):
             item_thumb = ItemThumb(
                 None, self.lib, self.preview_panel, (self.thumb_size, self.thumb_size)
             )
+
             layout.addWidget(item_thumb)
             self.item_thumbs.append(item_thumb)
 
@@ -1188,16 +1512,19 @@ class QtDriver(QObject):
                 if it.mode == type and it.item_id == id:
                     self.preview_panel.set_tags_updated_slot(it.update_badges)
 
-        self.set_macro_menu_viability()
+        self.set_menu_action_viability()
+        self.update_clipboard_actions()
         self.preview_panel.update_widgets()
 
-    def set_macro_menu_viability(self):
+    def set_menu_action_viability(self):
         if len([x[1] for x in self.selected if x[0] == ItemType.ENTRY]) == 0:
             self.autofill_action.setDisabled(True)
             self.sort_fields_action.setDisabled(True)
+            self.delete_file_action.setDisabled(True)
         else:
             self.autofill_action.setDisabled(False)
             self.sort_fields_action.setDisabled(False)
+            self.delete_file_action.setDisabled(False)
 
     def update_thumbs(self):
         """Updates search thumbnails."""
@@ -1246,12 +1573,20 @@ class QtDriver(QObject):
 
         for i, item_thumb in enumerate(self.item_thumbs, start=0):
             if i < len(self.nav_frames[self.cur_frame_idx].contents):
-                filepath = ""
+                filepath: Path = None  # Initialize
                 if self.nav_frames[self.cur_frame_idx].contents[i][0] == ItemType.ENTRY:
                     entry = self.lib.get_entry(
                         self.nav_frames[self.cur_frame_idx].contents[i][1]
                     )
-                    filepath = self.lib.library_dir / entry.path / entry.filename
+                    filepath: Path = self.lib.library_dir / entry.path / entry.filename
+
+                    try:
+                        item_thumb.delete_action.triggered.disconnect()
+                    except RuntimeWarning:
+                        pass
+                    item_thumb.delete_action.triggered.connect(
+                        lambda checked=False, f=filepath: self.delete_files_callback(f)
+                    )
 
                     item_thumb.set_item_id(entry.id)
                     item_thumb.assign_archived(entry.has_tag(self.lib, TAG_ARCHIVED))
@@ -1296,7 +1631,9 @@ class QtDriver(QObject):
                         else collation.e_ids_and_pages[0][0]
                     )
                     cover_e = self.lib.get_entry(cover_id)
-                    filepath = self.lib.library_dir / cover_e.path / cover_e.filename
+                    filepath: Path = (
+                        self.lib.library_dir / cover_e.path / cover_e.filename
+                    )
                     item_thumb.set_count(str(len(collation.e_ids_and_pages)))
                     item_thumb.update_clickable(
                         clickable=(
@@ -1461,6 +1798,7 @@ class QtDriver(QObject):
         self.update_libs_list(path)
         title_text = f"{self.base_title} - Library '{self.lib.library_dir}'"
         self.main_window.setWindowTitle(title_text)
+        self.main_window.setAcceptDrops(True)
 
         self.nav_frames = []
         self.cur_frame_idx = -1

tagstudio/src/qt/widgets/collage_icon.py

@@ -24,7 +24,8 @@ from PySide6.QtCore import (
 )
 
 from src.core.library import Library
-from src.core.constants import DOC_TYPES, VIDEO_TYPES, IMAGE_TYPES
+from src.core.media_types import MediaCategories, MediaType
+from src.qt.helpers.file_tester import is_readable_video
 
 
 ERROR = f"[ERROR]"
@@ -93,7 +94,8 @@ class CollageIconRenderer(QObject):
                 )
                 # sys.stdout.write(f'\r{INFO} Combining [{i+1}/{len(self.lib.entries)}]: {self.get_file_color(file_type)}{entry.path}{os.sep}{entry.filename}{RESET}')
                 # sys.stdout.flush()
-                if filepath.suffix.lower() in IMAGE_TYPES:
+                ext: str = filepath.suffix.lower()
+                if MediaType.IMAGE in MediaCategories.get_types(ext):
                     try:
                         with Image.open(
                             str(self.lib.library_dir / entry.path / entry.filename)
@@ -111,31 +113,32 @@ class CollageIconRenderer(QObject):
                             self.rendered.emit(pic)
                     except DecompressionBombError as e:
                         logging.info(f"[ERROR] One of the images was too big ({e})")
-                elif filepath.suffix.lower() in VIDEO_TYPES:
-                    video = cv2.VideoCapture(str(filepath))
-                    video.set(
-                        cv2.CAP_PROP_POS_FRAMES,
-                        (video.get(cv2.CAP_PROP_FRAME_COUNT) // 2),
-                    )
-                    success, frame = video.read()
-                    if not success:
-                        # Depending on the video format, compression, and frame
-                        # count, seeking halfway does not work and the thumb
-                        # must be pulled from the earliest available frame.
-                        video.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                elif MediaType.VIDEO in MediaCategories.get_types(ext):
+                    if is_readable_video(filepath):
+                        video = cv2.VideoCapture(str(filepath), cv2.CAP_FFMPEG)
+                        video.set(
+                            cv2.CAP_PROP_POS_FRAMES,
+                            (video.get(cv2.CAP_PROP_FRAME_COUNT) // 2),
+                        )
                         success, frame = video.read()
-                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    with Image.fromarray(frame, mode="RGB") as pic:
-                        if keep_aspect:
-                            pic.thumbnail(size)
-                        else:
-                            pic = pic.resize(size)
-                        if data_tint_mode and color:
-                            pic = ImageChops.hard_light(
-                                pic, Image.new("RGB", size, color)
-                            )
-                        # collage.paste(pic, (y*thumb_size, x*thumb_size))
-                        self.rendered.emit(pic)
+                        if not success:
+                            # Depending on the video format, compression, and frame
+                            # count, seeking halfway does not work and the thumb
+                            # must be pulled from the earliest available frame.
+                            video.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                            success, frame = video.read()
+                        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                        with Image.fromarray(frame, mode="RGB") as pic:
+                            if keep_aspect:
+                                pic.thumbnail(size)
+                            else:
+                                pic = pic.resize(size)
+                            if data_tint_mode and color:
+                                pic = ImageChops.hard_light(
+                                    pic, Image.new("RGB", size, color)
+                                )
+                            # collage.paste(pic, (y*thumb_size, x*thumb_size))
+                            self.rendered.emit(pic)
         except (UnidentifiedImageError, FileNotFoundError):
             logging.info(
                 f"\n{ERROR} Couldn't read {entry.path}{os.sep}{entry.filename}"
@@ -167,14 +170,16 @@ class CollageIconRenderer(QObject):
         self.done.emit()
         # logging.info('Done!')
 
+    # NOTE: Depreciated
     def get_file_color(self, ext: str):
-        if ext.lower().replace(".", "", 1) == "gif":
+        _ext = ext.lower().replace(".", "", 1)
+        if _ext == "gif":
             return "\033[93m"
-        if ext.lower().replace(".", "", 1) in IMAGE_TYPES:
+        elif MediaType.IMAGE in MediaCategories.get_types(_ext):
             return "\033[37m"
-        elif ext.lower().replace(".", "", 1) in VIDEO_TYPES:
+        elif MediaType.VIDEO in MediaCategories.get_types(_ext):
             return "\033[96m"
-        elif ext.lower().replace(".", "", 1) in DOC_TYPES:
+        elif MediaType.DOCUMENT in MediaCategories.get_types(_ext):
             return "\033[92m"
         else:
             return "\033[97m"

tagstudio/src/qt/widgets/fields.py

@@ -14,6 +14,7 @@ from PySide6.QtCore import Qt, QEvent
 from PySide6.QtGui import QPixmap, QEnterEvent
 from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton
 from src.qt.helpers.qbutton_wrapper import QPushButtonWrapper
+from src.qt.helpers.color_overlay import theme_fg_overlay
 
 
 class FieldContainer(QWidget):
@@ -47,6 +48,10 @@ class FieldContainer(QWidget):
         button_size = 24
         # self.setStyleSheet('border-style:solid;border-color:#1e1a33;border-radius:8px;border-width:2px;')
 
+        self.clipboard_icon_128 = theme_fg_overlay(FieldContainer.clipboard_icon_128)
+        self.edit_icon_128 = theme_fg_overlay(FieldContainer.edit_icon_128)
+        self.trash_icon_128 = theme_fg_overlay(FieldContainer.trash_icon_128)
+
         self.root_layout = QVBoxLayout(self)
         self.root_layout.setObjectName("baseLayout")
         self.root_layout.setContentsMargins(0, 0, 0, 0)
@@ -127,6 +132,7 @@ class FieldContainer(QWidget):
     def set_copy_callback(self, callback: Optional[MethodType]):
         if self.copy_button.is_connected:
             self.copy_button.clicked.disconnect()
+            self.copy_button.is_connected = False
 
         self.copy_callback = callback
         self.copy_button.clicked.connect(callback)
@@ -136,6 +142,7 @@ class FieldContainer(QWidget):
     def set_edit_callback(self, callback: Optional[MethodType]):
         if self.edit_button.is_connected:
             self.edit_button.clicked.disconnect()
+            self.edit_button.is_connected = False
 
         self.edit_callback = callback
         self.edit_button.clicked.connect(callback)
@@ -145,10 +152,12 @@ class FieldContainer(QWidget):
     def set_remove_callback(self, callback: Optional[Callable]):
         if self.remove_button.is_connected:
             self.remove_button.clicked.disconnect()
+            self.remove_button.is_connected = False
 
         self.remove_callback = callback
         self.remove_button.clicked.connect(callback)
-        self.remove_button.is_connected = True
+        if callback is not None:
+            self.remove_button.is_connected = True
 
     def set_inner_widget(self, widget: "FieldWidget"):
         # widget.setStyleSheet('background-color:green;')

tagstudio/src/qt/widgets/item_thumb.py

@@ -8,10 +8,11 @@ import time
 import typing
 from pathlib import Path
 from typing import Optional
+import platform
 
 from PIL import Image, ImageQt
-from PySide6.QtCore import Qt, QSize, QEvent
-from PySide6.QtGui import QPixmap, QEnterEvent, QAction
+from PySide6.QtCore import Qt, QSize, QEvent, QMimeData, QUrl
+from PySide6.QtGui import QPixmap, QEnterEvent, QAction, QDrag
 from PySide6.QtWidgets import (
     QWidget,
     QVBoxLayout,
@@ -24,12 +25,10 @@ from PySide6.QtWidgets import (
 from src.core.enums import FieldID
 from src.core.library import ItemType, Library, Entry
 from src.core.constants import (
-    AUDIO_TYPES,
-    VIDEO_TYPES,
-    IMAGE_TYPES,
     TAG_FAVORITE,
     TAG_ARCHIVED,
 )
+from src.core.media_types import MediaCategories, MediaType
 from src.qt.flowlayout import FlowWidget
 from src.qt.helpers.file_opener import FileOpenerHelper
 from src.qt.widgets.thumb_renderer import ThumbRenderer
@@ -64,27 +63,29 @@ class ItemThumb(FlowWidget):
     tag_group_icon_128.load()
 
     small_text_style = (
-        f"background-color:rgba(0, 0, 0, 192);"
-        f"font-family:Oxanium;"
-        f"font-weight:bold;"
-        f"font-size:12px;"
-        f"border-radius:3px;"
-        f"padding-top: 4px;"
-        f"padding-right: 1px;"
-        f"padding-bottom: 1px;"
-        f"padding-left: 1px;"
+        "background-color:rgba(0, 0, 0, 192);"
+        "color:#FFFFFF;"
+        "font-family:Oxanium;"
+        "font-weight:bold;"
+        "font-size:12px;"
+        "border-radius:3px;"
+        "padding-top: 4px;"
+        "padding-right: 1px;"
+        "padding-bottom: 1px;"
+        "padding-left: 1px;"
     )
 
     med_text_style = (
-        f"background-color:rgba(0, 0, 0, 192);"
-        f"font-family:Oxanium;"
-        f"font-weight:bold;"
-        f"font-size:18px;"
-        f"border-radius:3px;"
-        f"padding-top: 4px;"
-        f"padding-right: 1px;"
-        f"padding-bottom: 1px;"
-        f"padding-left: 1px;"
+        "background-color:rgba(0, 0, 0, 192);"
+        "color:#FFFFFF;"
+        "font-family:Oxanium;"
+        "font-weight:bold;"
+        "font-size:18px;"
+        "border-radius:3px;"
+        "padding-top: 4px;"
+        "padding-right: 1px;"
+        "padding-bottom: 1px;"
+        "padding-left: 1px;"
     )
 
     def __init__(
@@ -105,6 +106,7 @@ class ItemThumb(FlowWidget):
         self.thumb_size: tuple[int, int] = thumb_size
         self.setMinimumSize(*thumb_size)
         self.setMaximumSize(*thumb_size)
+        self.setMouseTracking(True)
         check_size = 24
         # self.setStyleSheet('background-color:red;')
 
@@ -196,8 +198,15 @@ class ItemThumb(FlowWidget):
         open_file_action.triggered.connect(self.opener.open_file)
         open_explorer_action = QAction("Open file in explorer", self)
         open_explorer_action.triggered.connect(self.opener.open_explorer)
+
+        trash_term: str = "Trash"
+        if platform.system() == "Windows":
+            trash_term = "Recycle Bin"
+        self.delete_action = QAction(f"Send file to {trash_term}", self)
+
         self.thumb_button.addAction(open_file_action)
         self.thumb_button.addAction(open_explorer_action)
+        self.thumb_button.addAction(self.delete_action)
 
         # Static Badges ========================================================
 
@@ -357,10 +366,27 @@ class ItemThumb(FlowWidget):
     def set_extension(self, ext: str) -> None:
         if ext and ext.startswith(".") is False:
             ext = "." + ext
-        if ext and ext not in IMAGE_TYPES or ext in [".gif", ".apng"]:
+        if (
+            ext
+            and (MediaType.IMAGE not in MediaCategories.get_types(ext))
+            or (MediaType.IMAGE_RAW in MediaCategories.get_types(ext))
+            or (MediaType.IMAGE_VECTOR in MediaCategories.get_types(ext))
+            or (MediaType.ADOBE_PHOTOSHOP in MediaCategories.get_types(ext))
+            or ext
+            in [
+                ".apng",
+                ".avif",
+                ".exr",
+                ".gif",
+                ".jxl",
+                ".webp",
+            ]
+        ):
             self.ext_badge.setHidden(False)
             self.ext_badge.setText(ext.upper()[1:])
-            if ext in VIDEO_TYPES + AUDIO_TYPES:
+            if (MediaType.VIDEO in MediaCategories.get_types(ext)) or (
+                MediaType.AUDIO in MediaCategories.get_types(ext)
+            ):
                 self.count_badge.setHidden(False)
         else:
             if self.mode == ItemType.ENTRY:
@@ -499,3 +525,26 @@ class ItemThumb(FlowWidget):
         if self.panel.isOpen:
             self.panel.update_widgets()
         self.panel.driver.update_badges()
+
+    def mouseMoveEvent(self, event):
+        if event.buttons() is not Qt.MouseButton.LeftButton:
+            return
+
+        drag = QDrag(self.panel.driver)
+        paths = []
+        mimedata = QMimeData()
+
+        selected_ids = list(map(lambda x: x[1], self.panel.driver.selected))
+        if self.item_id not in selected_ids:
+            selected_ids = [self.item_id]
+
+        for id in selected_ids:
+            entry = self.lib.get_entry(id)
+            url = QUrl.fromLocalFile(
+                Path(self.lib.library_dir) / entry.path / entry.filename
+            )
+            paths.append(url)
+
+        mimedata.setUrls(paths)
+        drag.setMimeData(mimedata)
+        drag.exec(Qt.DropAction.CopyAction)

tagstudio/src/qt/widgets/preview_panel.py

@@ -4,16 +4,16 @@
 
 import logging
 from pathlib import Path
+import platform
 import time
 import typing
 from datetime import datetime as dt
-
 import cv2
 import rawpy
-from PIL import Image, UnidentifiedImageError
+from PIL import Image, UnidentifiedImageError, ImageFont
 from PIL.Image import DecompressionBombError
-from PySide6.QtCore import Signal, Qt, QSize
-from PySide6.QtGui import QResizeEvent, QAction
+from PySide6.QtCore import QModelIndex, Signal, Qt, QSize, QByteArray, QBuffer
+from PySide6.QtGui import QGuiApplication, QResizeEvent, QAction, QMovie
 from PySide6.QtWidgets import (
     QWidget,
     QVBoxLayout,
@@ -27,10 +27,13 @@ from PySide6.QtWidgets import (
     QMessageBox,
 )
 from humanfriendly import format_size
-
 from src.core.enums import SettingItems, Theme
 from src.core.library import Entry, ItemType, Library
-from src.core.constants import VIDEO_TYPES, IMAGE_TYPES, RAW_IMAGE_TYPES, TS_FOLDER_NAME
+from src.core.constants import (
+    TS_FOLDER_NAME,
+)
+from src.core.media_types import MediaCategories, MediaType
+from src.qt.helpers.rounded_pixmap_style import RoundedPixmapStyle
 from src.qt.helpers.file_opener import FileOpenerLabel, FileOpenerHelper, open_file
 from src.qt.modals.add_field import AddFieldModal
 from src.qt.widgets.thumb_renderer import ThumbRenderer
@@ -42,6 +45,8 @@ from src.qt.widgets.text_box_edit import EditTextBox
 from src.qt.widgets.text_line_edit import EditTextLine
 from src.qt.helpers.qbutton_wrapper import QPushButtonWrapper
 from src.qt.widgets.video_player import VideoPlayer
+from src.qt.helpers.file_tester import is_readable_video
+from src.qt.resource_manager import ResourceManager
 
 
 # Only import for type checking/autocompletion, will not be imported at runtime.
@@ -78,22 +83,49 @@ class PreviewPanel(QWidget):
         self.img_button_size: tuple[int, int] = (266, 266)
         self.image_ratio: float = 1.0
 
+        self.label_bg_color = (
+            Theme.COLOR_BG_DARK.value
+            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+            else Theme.COLOR_DARK_LABEL.value
+        )
+        self.panel_bg_color = (
+            Theme.COLOR_BG_DARK.value
+            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+            else Theme.COLOR_BG_LIGHT.value
+        )
+
         self.image_container = QWidget()
         image_layout = QHBoxLayout(self.image_container)
         image_layout.setContentsMargins(0, 0, 0, 0)
 
         self.open_file_action = QAction("Open file", self)
         self.open_explorer_action = QAction("Open file in explorer", self)
+        self.trash_term: str = "Trash"
+        if platform.system() == "Windows":
+            self.trash_term = "Recycle Bin"
+        self.delete_action = QAction(f"Send file to {self.trash_term}", self)
 
         self.preview_img = QPushButtonWrapper()
         self.preview_img.setMinimumSize(*self.img_button_size)
         self.preview_img.setFlat(True)
         self.preview_img.setContextMenuPolicy(Qt.ContextMenuPolicy.ActionsContextMenu)
-
         self.preview_img.addAction(self.open_file_action)
         self.preview_img.addAction(self.open_explorer_action)
+        self.preview_img.addAction(self.delete_action)
+
+        self.preview_gif = QLabel()
+        self.preview_gif.setMinimumSize(*self.img_button_size)
+        self.preview_gif.setContextMenuPolicy(Qt.ContextMenuPolicy.ActionsContextMenu)
+        self.preview_gif.setCursor(Qt.CursorShape.ArrowCursor)
+        self.preview_gif.addAction(self.open_file_action)
+        self.preview_gif.addAction(self.open_explorer_action)
+        self.preview_gif.addAction(self.delete_action)
+        self.preview_gif.hide()
+        self.gif_buffer: QBuffer = QBuffer()
+
         self.preview_vid = VideoPlayer(driver)
         self.preview_vid.hide()
+        self.preview_vid.addAction(self.delete_action)
         self.thumb_renderer = ThumbRenderer()
         self.thumb_renderer.updated.connect(
             lambda ts, i, s: (self.preview_img.setIcon(i))
@@ -113,6 +145,8 @@ class PreviewPanel(QWidget):
 
         image_layout.addWidget(self.preview_img)
         image_layout.setAlignment(self.preview_img, Qt.AlignmentFlag.AlignCenter)
+        image_layout.addWidget(self.preview_gif)
+        image_layout.setAlignment(self.preview_gif, Qt.AlignmentFlag.AlignCenter)
         image_layout.addWidget(self.preview_vid)
         image_layout.setAlignment(self.preview_vid, Qt.AlignmentFlag.AlignCenter)
         self.image_container.setMinimumSize(*self.img_button_size)
@@ -129,15 +163,16 @@ class PreviewPanel(QWidget):
         # 	Qt.TextInteractionFlag.TextSelectableByMouse)
 
         properties_style = (
-            f"background-color:{Theme.COLOR_BG.value};"
-            f"font-family:Oxanium;"
-            f"font-weight:bold;"
-            f"font-size:12px;"
-            f"border-radius:6px;"
-            f"padding-top: 4px;"
-            f"padding-right: 1px;"
-            f"padding-bottom: 1px;"
-            f"padding-left: 1px;"
+            f"background-color:{self.label_bg_color};"
+            "color:#FFFFFF;"
+            "font-family:Oxanium;"
+            "font-weight:bold;"
+            "font-size:12px;"
+            "border-radius:3px;"
+            "padding-top: 4px;"
+            "padding-right: 1px;"
+            "padding-bottom: 1px;"
+            "padding-left: 1px;"
         )
 
         self.dimensions_label.setStyleSheet(properties_style)
@@ -168,9 +203,10 @@ class PreviewPanel(QWidget):
         # background and NOT the scroll container background, so that the
         # rounded corners are maintained when scrolling. I was unable to
         # find the right trick to only select that particular element.
+
         scroll_area.setStyleSheet(
             "QWidget#entryScrollContainer{"
-            f"background: {Theme.COLOR_BG.value};"
+            f"background:{self.panel_bg_color};"
             "border-radius:6px;"
             "}"
         )
@@ -275,6 +311,7 @@ class PreviewPanel(QWidget):
         clear_layout(layout)
 
         label = QLabel("Recent Libraries")
+        label.setStyleSheet("font-weight:bold;")
         label.setAlignment(Qt.AlignCenter)  # type: ignore
 
         row_layout = QHBoxLayout()
@@ -285,11 +322,9 @@ class PreviewPanel(QWidget):
             btn: QPushButtonWrapper | QPushButton, extras: list[str] | None = None
         ):
             base_style = [
-                f"background-color:{Theme.COLOR_BG.value};",
+                f"background-color:{self.panel_bg_color};",
                 "border-radius:6px;",
-                "text-align: left;",
                 "padding-top: 3px;",
-                "padding-left: 6px;",
                 "padding-bottom: 4px;",
             ]
 
@@ -320,11 +355,11 @@ class PreviewPanel(QWidget):
                 return lambda: self.driver.open_library(Path(path))
 
             button.clicked.connect(open_library_button_clicked(full_val))
-            set_button_style(button)
-            button_remove = QPushButton("➖")
+            set_button_style(button, ["padding-left: 6px;", "text-align: left;"])
+            button_remove = QPushButton("—")
             button_remove.setCursor(Qt.CursorShape.PointingHandCursor)
-            button_remove.setFixedWidth(30)
-            set_button_style(button_remove)
+            button_remove.setFixedWidth(24)
+            set_button_style(button_remove, ["font-weight:bold;", "text-align:center;"])
 
             def remove_recent_library_clicked(key: str):
                 return lambda: (
@@ -393,20 +428,14 @@ class PreviewPanel(QWidget):
         self.preview_vid.resizeVideo(adj_size)
         self.preview_vid.setMaximumSize(adj_size)
         self.preview_vid.setMinimumSize(adj_size)
-        # self.preview_img.setMinimumSize(adj_size)
-
-        # if self.preview_img.iconSize().toTuple()[0] < self.preview_img.size().toTuple()[0] + 10:
-        # 	if type(self.item) == Entry:
-        # 		filepath = os.path.normpath(f'{self.lib.library_dir}/{self.item.path}/{self.item.filename}')
-        # 		self.thumb_renderer.render(time.time(), filepath, self.preview_img.size().toTuple(), self.devicePixelRatio(),update_on_ratio_change=True)
-
-        # logging.info(f' Img Aspect Ratio: {self.image_ratio}')
-        # logging.info(f'  Max Button Size: {size}')
-        # logging.info(f'Container Size: {(self.image_container.size().width(), self.image_container.size().height())}')
-        # logging.info(f'Final Button Size: {(adj_width, adj_height)}')
-        # logging.info(f'')
-        # logging.info(f'  Icon Size: {self.preview_img.icon().actualSize().toTuple()}')
-        # logging.info(f'Button Size: {self.preview_img.size().toTuple()}')
+        self.preview_gif.setMaximumSize(adj_size)
+        self.preview_gif.setMinimumSize(adj_size)
+        proxy_style = RoundedPixmapStyle(radius=8)
+        self.preview_gif.setStyle(proxy_style)
+        self.preview_vid.setStyle(proxy_style)
+        m = self.preview_gif.movie()
+        if m:
+            m.setScaledSize(adj_size)
 
     def place_add_field_button(self):
         self.scroll_layout.addWidget(self.afb_container)
@@ -426,13 +455,13 @@ class PreviewPanel(QWidget):
         self.afm.is_connected = True
         self.add_field_button.clicked.connect(self.afm.show)
 
-    def add_field_to_selected(self, field_id: int):
-        """Adds an entry field to one or more selected items."""
-        added = set()
-        for item_pair in self.selected:
-            if item_pair[0] == ItemType.ENTRY and item_pair[1] not in added:
-                self.lib.add_field_to_entry(item_pair[1], field_id)
-                added.add(item_pair[1])
+    def add_field_to_selected(self, field_list: list[QModelIndex]):
+        """Add list of entry fields to one or more selected items."""
+        for item_type, item_id in self.selected:
+            if item_type != ItemType.ENTRY:
+                continue
+            for field_item in field_list:
+                self.lib.add_field_to_entry(item_id, field_item.row())
 
     # def update_widgets(self, item: Union[Entry, Collation, Tag]):
     def update_widgets(self):
@@ -471,11 +500,20 @@ class PreviewPanel(QWidget):
                 )
                 if self.preview_img.is_connected:
                     self.preview_img.clicked.disconnect()
+                    self.preview_img.is_connected = False
+
+                try:
+                    self.delete_action.triggered.disconnect()
+                except RuntimeWarning:
+                    pass
+                self.delete_action.setEnabled(False)
+
                 for i, c in enumerate(self.containers):
                     c.setHidden(True)
             self.preview_img.show()
             self.preview_vid.stop()
             self.preview_vid.hide()
+            self.preview_gif.hide()
             self.selected = list(self.driver.selected)
             self.add_field_button.setHidden(True)
 
@@ -486,6 +524,7 @@ class PreviewPanel(QWidget):
                 self.preview_img.show()
                 self.preview_vid.stop()
                 self.preview_vid.hide()
+                self.preview_gif.hide()
                 item: Entry = self.lib.get_entry(self.driver.selected[0][1])
                 # If a new selection is made, update the thumbnail and filepath.
                 if not self.selected or self.selected != self.driver.selected:
@@ -508,18 +547,63 @@ class PreviewPanel(QWidget):
                     )
                     self.preview_img.setCursor(Qt.CursorShape.PointingHandCursor)
 
+                    try:
+                        self.delete_action.triggered.disconnect()
+                    except RuntimeError:
+                        pass
+                    self.delete_action.setText(f"Send file to {self.trash_term}")
+                    self.delete_action.triggered.connect(
+                        lambda checked=False,
+                        f=filepath: self.driver.delete_files_callback(f)
+                    )
+                    self.delete_action.setEnabled(True)
+
                     self.opener = FileOpenerHelper(filepath)
                     self.open_file_action.triggered.connect(self.opener.open_file)
                     self.open_explorer_action.triggered.connect(
                         self.opener.open_explorer
                     )
 
-                    # TODO: Do this somewhere else, this is just here temporarily.
+                    # TODO: Do this all somewhere else, this is just here temporarily.
+                    ext: str = filepath.suffix.lower()
                     try:
-                        image = None
-                        if filepath.suffix.lower() in IMAGE_TYPES:
+                        if filepath.suffix.lower() in [".gif"]:
+                            with open(filepath, mode="rb") as f:
+                                if self.preview_gif.movie():
+                                    self.preview_gif.movie().stop()
+                                    self.gif_buffer.close()
+
+                                ba = f.read()
+                                self.gif_buffer.setData(ba)
+                                movie = QMovie(self.gif_buffer, QByteArray())
+                                self.preview_gif.setMovie(movie)
+                                movie.start()
+
                             image = Image.open(str(filepath))
-                        elif filepath.suffix.lower() in RAW_IMAGE_TYPES:
+                            self.resizeEvent(
+                                QResizeEvent(
+                                    QSize(image.width, image.height),
+                                    QSize(image.width, image.height),
+                                )
+                            )
+                            self.preview_img.hide()
+                            self.preview_vid.hide()
+                            self.preview_gif.show()
+
+                        image = None
+                        if (
+                            (MediaType.IMAGE in MediaCategories.get_types(ext))
+                            and (
+                                MediaType.IMAGE_RAW
+                                not in MediaCategories.get_types(ext)
+                            )
+                            and (
+                                MediaType.IMAGE_VECTOR
+                                not in MediaCategories.get_types(ext)
+                            )
+                        ):
+                            image = Image.open(str(filepath))
+                        elif MediaType.IMAGE_RAW in MediaCategories.get_types(ext):
                             try:
                                 with rawpy.imread(str(filepath)) as raw:
                                     rgb = raw.postprocess()
@@ -531,50 +615,71 @@ class PreviewPanel(QWidget):
                                 rawpy._rawpy.LibRawFileUnsupportedError,
                             ):
                                 pass
-                        elif filepath.suffix.lower() in VIDEO_TYPES:
-                            video = cv2.VideoCapture(str(filepath))
-                            if video.get(cv2.CAP_PROP_FRAME_COUNT) <= 0:
-                                raise cv2.error("File is invalid or has 0 frames")
-                            video.set(cv2.CAP_PROP_POS_FRAMES, 0)
-                            success, frame = video.read()
-                            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                            image = Image.fromarray(frame)
-                            if success:
-                                self.preview_img.hide()
-                                self.preview_vid.play(
-                                    filepath, QSize(image.width, image.height)
+                        elif MediaType.VIDEO in MediaCategories.get_types(ext):
+                            if is_readable_video(filepath):
+                                video = cv2.VideoCapture(str(filepath), cv2.CAP_FFMPEG)
+                                video.set(
+                                    cv2.CAP_PROP_POS_FRAMES,
+                                    (video.get(cv2.CAP_PROP_FRAME_COUNT) // 2),
                                 )
-                                self.resizeEvent(
-                                    QResizeEvent(
-                                        QSize(image.width, image.height),
-                                        QSize(image.width, image.height),
+                                success, frame = video.read()
+                                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                                image = Image.fromarray(frame)
+                                if success:
+                                    self.preview_img.hide()
+                                    self.preview_vid.play(
+                                        filepath, QSize(image.width, image.height)
                                     )
-                                )
-                                self.preview_vid.show()
+                                    self.resizeEvent(
+                                        QResizeEvent(
+                                            QSize(image.width, image.height),
+                                            QSize(image.width, image.height),
+                                        )
+                                    )
+                                    self.preview_vid.show()
 
                         # Stats for specific file types are displayed here.
-                        if image and filepath.suffix.lower() in (
-                            IMAGE_TYPES + VIDEO_TYPES + RAW_IMAGE_TYPES
+                        if image and (
+                            (MediaType.IMAGE in MediaCategories.get_types(ext))
+                            or (MediaType.VIDEO in MediaCategories.get_types(ext, True))
+                            or (
+                                MediaType.IMAGE_RAW
+                                in MediaCategories.get_types(ext, True)
+                            )
                         ):
                             self.dimensions_label.setText(
-                                f"{filepath.suffix.upper()[1:]}  •  {format_size(filepath.stat().st_size)}\n{image.width} x {image.height} px"
+                                f"{ext.upper()[1:]}  •  {format_size(filepath.stat().st_size)}\n{image.width} x {image.height} px"
                             )
+                        elif MediaType.FONT in MediaCategories.get_types(ext, True):
+                            try:
+                                font = ImageFont.truetype(filepath)
+                                self.dimensions_label.setText(
+                                    f"{ext.upper()[1:]} •  {format_size(filepath.stat().st_size)}\n{font.getname()[0]} ({font.getname()[1]}) "
+                                )
+                            except OSError:
+                                self.dimensions_label.setText(
+                                    f"{ext.upper()[1:]}  •  {format_size(filepath.stat().st_size)}"
+                                )
+                                logging.info(
+                                    f"[PreviewPanel][ERROR] Couldn't read font file: {filepath}"
+                                )
                         else:
+                            self.dimensions_label.setText(f"{ext.upper()[1:]}")
                             self.dimensions_label.setText(
-                                f"{filepath.suffix.upper()[1:]}  •  {format_size(filepath.stat().st_size)}"
+                                f"{ext.upper()[1:]}  •  {format_size(filepath.stat().st_size)}"
                             )
 
                         if not filepath.is_file():
                             raise FileNotFoundError
 
                     except FileNotFoundError as e:
-                        self.dimensions_label.setText(f"{filepath.suffix.upper()[1:]}")
+                        self.dimensions_label.setText(f"{ext.upper()[1:]}")
                         logging.info(
                             f"[PreviewPanel][ERROR] Couldn't Render thumbnail for {filepath} (because of {e})"
                         )
 
                     except (FileNotFoundError, cv2.error) as e:
-                        self.dimensions_label.setText(f"{filepath.suffix.upper()}")
+                        self.dimensions_label.setText(f"{ext.upper()[1:]}")
                         logging.info(
                             f"[PreviewPanel][ERROR] Couldn't Render thumbnail for {filepath} (because of {e})"
                         )
@@ -583,14 +688,16 @@ class PreviewPanel(QWidget):
                         DecompressionBombError,
                     ) as e:
                         self.dimensions_label.setText(
-                            f"{filepath.suffix.upper()[1:]}  •  {format_size(filepath.stat().st_size)}"
+                            f"{ext.upper()[1:]}  •  {format_size(filepath.stat().st_size)}"
                         )
                         logging.info(
                             f"[PreviewPanel][ERROR] Couldn't Render thumbnail for {filepath} (because of {e})"
                         )
 
+                    # TODO: Implement a clickable label to use for the GIF preview.
                     if self.preview_img.is_connected:
                         self.preview_img.clicked.disconnect()
+                        self.preview_img.is_connected = False
                     self.preview_img.clicked.connect(
                         lambda checked=False, filepath=filepath: open_file(filepath)
                     )
@@ -618,6 +725,7 @@ class PreviewPanel(QWidget):
         # Multiple Selected Items
         elif len(self.driver.selected) > 1:
             self.preview_img.show()
+            self.preview_gif.hide()
             self.preview_vid.stop()
             self.preview_vid.hide()
             if self.selected != self.driver.selected:
@@ -631,6 +739,16 @@ class PreviewPanel(QWidget):
                 )
                 self.preview_img.setCursor(Qt.CursorShape.ArrowCursor)
 
+                try:
+                    self.delete_action.triggered.disconnect()
+                except RuntimeError:
+                    pass
+                self.delete_action.setText(f"Send files to {self.trash_term}")
+                self.delete_action.triggered.connect(
+                    lambda checked=False, f=None: self.driver.delete_files_callback(f)
+                )
+                self.delete_action.setEnabled(True)
+
                 ratio: float = self.devicePixelRatio()
                 self.thumb_renderer.render(
                     time.time(),
@@ -1070,3 +1188,26 @@ class PreviewPanel(QWidget):
         # logging.info(result)
         if result == 3:
             callback()
+
+    def stop_file_use(self):
+        """Stops the use of the currently previewed file. Used to release file permissions."""
+        logging.info("[PreviewPanel] Stopping file use in video playback...")
+        # This swaps the video out for a placeholder so the previous video's file
+        # is no longer in use by this object.
+        self.preview_vid.play(ResourceManager.get_path("placeholder_mp4"), QSize(8, 8))
+        self.preview_vid.hide()
+
+        # NOTE: I'm keeping this here until #357 is merged in the case it still needs to be used.
+        # logging.info("[PreviewPanel] Stopping file use for animated image playback...")
+        # logging.info(self.preview_gif.movie())
+        # if self.preview_gif.movie():
+        #     self.preview_gif.movie().stop()
+        # with open(ResourceManager.get_path("placeholder_gif"), mode="rb") as f:
+        #     ba = f.read()
+        #     self.gif_buffer.setData(ba)
+        #     movie = QMovie(self.gif_buffer, QByteArray())
+        #     self.preview_gif.setMovie(movie)
+        #     movie.start()
+
+        # self.preview_gif.hide()
+        # logging.info(self.preview_gif.movie())

tagstudio/src/qt/widgets/tag.py

@@ -15,6 +15,7 @@ from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton
 
 from src.core.library import Library, Tag
 from src.core.palette import ColorType, get_tag_color
+from src.qt.modals.merge_tag import MergeTagModal
 
 
 ERROR = f"[ERROR]"
@@ -77,6 +78,10 @@ class TagWidget(QWidget):
         add_to_search_action = QAction("Add to Search", self)
         self.bg_button.addAction(add_to_search_action)
 
+        merge_tag_action = QAction("Merge Tag", self)
+        merge_tag_action.triggered.connect(self.show_merge_tag_modal)
+        self.bg_button.addAction(merge_tag_action)
+
         self.inner_layout = QHBoxLayout()
         self.inner_layout.setObjectName("innerLayout")
         self.inner_layout.setContentsMargins(2, 2, 2, 2)
@@ -234,6 +239,9 @@ class TagWidget(QWidget):
     # 		pass
     # 	# self.bg.clicked.connect(lambda checked=False, filepath=filepath: open_file(filepath))
     # 	# self.bg.clicked.connect(function)
+    def show_merge_tag_modal(self):
+        modal = MergeTagModal(self.lib, self.tag)
+        modal.exec_()
 
     def enterEvent(self, event: QEnterEvent) -> None:
         if self.has_remove:

tagstudio/src/qt/widgets/tag_box.py

@@ -9,6 +9,7 @@ import typing
 
 from PySide6.QtCore import Signal, Qt
 from PySide6.QtWidgets import QPushButton
+from PySide6.QtGui import QGuiApplication
 
 from src.core.constants import TAG_FAVORITE, TAG_ARCHIVED
 from src.core.library import Library, Tag
@@ -49,6 +50,22 @@ class TagBoxWidget(FieldWidget):
         self.base_layout.setContentsMargins(0, 0, 0, 0)
         self.setLayout(self.base_layout)
 
+        bg_color: str = (
+            "#1E1E1E"
+            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+            else "#EEEEEE"
+        )
+        fg_color: str = (
+            "#FFFFFF"
+            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+            else "#444444"
+        )
+        ol_color: str = (
+            "#333333"
+            if QGuiApplication.styleHints().colorScheme() is Qt.ColorScheme.Dark
+            else "#F5F5F5"
+        )
+
         self.add_button = QPushButton()
         self.add_button.setCursor(Qt.CursorShape.PointingHandCursor)
         self.add_button.setMinimumSize(23, 23)
@@ -56,10 +73,10 @@ class TagBoxWidget(FieldWidget):
         self.add_button.setText("+")
         self.add_button.setStyleSheet(
             f"QPushButton{{"
-            f"background: #1e1e1e;"
-            f"color: #FFFFFF;"
+            f"background: {bg_color};"
+            f"color: {fg_color};"
             f"font-weight: bold;"
-            f"border-color: #333333;"
+            f"border-color: {ol_color};"
             f"border-radius: 6px;"
             f"border-style:solid;"
             f"border-width:{math.ceil(1*self.devicePixelRatio())}px;"

tagstudio/src/qt/widgets/thumb_button.py

@@ -5,7 +5,15 @@
 
 from PySide6 import QtCore
 from PySide6.QtCore import QEvent
-from PySide6.QtGui import QEnterEvent, QPainter, QColor, QPen, QPainterPath, QPaintEvent
+from PySide6.QtGui import (
+    QEnterEvent,
+    QPainter,
+    QColor,
+    QPen,
+    QPainterPath,
+    QPaintEvent,
+    QPalette,
+)
 from PySide6.QtWidgets import QWidget
 from src.qt.helpers.qbutton_wrapper import QPushButtonWrapper
 
@@ -17,7 +25,31 @@ class ThumbButton(QPushButtonWrapper):
         self.hovered = False
         self.selected = False
 
-        # self.clicked.connect(lambda checked: self.set_selected(True))
+        self.select_color: QColor = QPalette.color(
+            self.palette(),
+            QPalette.ColorGroup.Active,
+            QPalette.ColorRole.Accent,
+        )
+
+        self.select_color_faded: QColor = QColor(self.select_color)
+        self.select_color_faded.setHsl(
+            self.select_color_faded.hslHue(),
+            self.select_color_faded.hslSaturation(),
+            max(self.select_color_faded.lightness(), 127),
+            127,
+        )
+
+        self.hover_color: QColor = QPalette.color(
+            self.palette(),
+            QPalette.ColorGroup.Active,
+            QPalette.ColorRole.Accent,
+        )
+        self.hover_color.setHsl(
+            self.hover_color.hslHue(),
+            self.hover_color.hslSaturation(),
+            min(self.hover_color.lightness() + 80, 255),
+            self.hover_color.alpha(),
+        )
 
     def paintEvent(self, event: QPaintEvent) -> None:
         super().paintEvent(event)
@@ -25,7 +57,6 @@ class ThumbButton(QPushButtonWrapper):
             painter = QPainter()
             painter.begin(self)
             painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-            # painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source)
             path = QPainterPath()
             width = 3
             radius = 6
@@ -40,27 +71,21 @@ class ThumbButton(QPushButtonWrapper):
                 radius,
             )
 
-            # color = QColor('#bb4ff0') if self.selected else QColor('#55bbf6')
-            # pen = QPen(color, width)
-            # painter.setPen(pen)
-            # # brush.setColor(fill)
-            # painter.drawPath(path)
-
             if self.selected:
                 painter.setCompositionMode(
                     QPainter.CompositionMode.CompositionMode_HardLight
                 )
-                color = QColor("#bb4ff0")
-                color.setAlphaF(0.5)
-                pen = QPen(color, width)
+                pen = QPen(self.select_color_faded, width)
                 painter.setPen(pen)
-                painter.fillPath(path, color)
+                painter.fillPath(path, self.select_color_faded)
                 painter.drawPath(path)
 
                 painter.setCompositionMode(
                     QPainter.CompositionMode.CompositionMode_Source
                 )
-                color = QColor("#bb4ff0") if not self.hovered else QColor("#55bbf6")
+                color: QColor = (
+                    self.select_color if not self.hovered else self.hover_color
+                )
                 pen = QPen(color, width)
                 painter.setPen(pen)
                 painter.drawPath(path)
@@ -68,10 +93,10 @@ class ThumbButton(QPushButtonWrapper):
                 painter.setCompositionMode(
                     QPainter.CompositionMode.CompositionMode_Source
                 )
-                color = QColor("#55bbf6")
-                pen = QPen(color, width)
+                pen = QPen(self.hover_color, width)
                 painter.setPen(pen)
                 painter.drawPath(path)
+
             painter.end()
 
     def enterEvent(self, event: QEnterEvent) -> None:

tagstudio/tag_studio.py

@@ -17,14 +17,9 @@ def main():
 
     # Parse arguments.
     parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--open",
-        dest="open",
-        type=str,
-        help="Path to a TagStudio Library folder to open on start.",
-    )
     parser.add_argument(
         "-o",
+        "--open",
         dest="open",
         type=str,
         help="Path to a TagStudio Library folder to open on start.",