Enhance ISO management and device handling in SmartBoot

- Improved FreeDOS recognition in ISO type detection by adding support for "fd" abbreviations.
- Enhanced `get_iso_info()` to include additional metadata: `is_hybrid`, `has_efi`, `persistence_capable`, `recommended_fs`, `recommended_scheme`, and `label`.
- Implemented background threading for USB device refresh and ISO info loading to prevent UI freezing.
- Added new methods in `ISOManager` for checksum computation and verification, hybrid ISO detection, and volume label reading.
- Improved cancellation handling in `ImageWriter` during copy operations.
- Updated UI components in `main_window.py` to utilize new worker classes for device and ISO loading, enhancing responsiveness.

Author: zikani

core/image_writer.py

@@ -172,7 +172,7 @@ def _detect_iso_type(
                                         "rhel", "arch", "manjaro", "linux",
                                         "mint", "kali")):
             return "linux"
-        if any(t in filename for t in ("freedos", "msdos", "dos")):
+        if any(t in filename for t in ("freedos", "fd", "msdos", "dos")):
             return "freedos"
 
         if self.system == "Windows":
@@ -659,6 +659,8 @@ def _copy_tree(
         hi: int = 100,
     ) -> bool:
         """Cross-platform recursive copy with progress."""
+        if self._cancel_event.is_set():
+            return False
         if self.system == "Windows" and shutil.which("robocopy"):
             return self._robocopy(src, dst, cb, lo, hi)
         try:
@@ -671,6 +673,8 @@ def _copy_tree(
             span = hi - lo
 
             for root, dirs, files in os.walk(src):
+                if self._cancel_event.is_set():
+                    return False
                 dirs[:] = [d for d in dirs if d != "_iso_mount"]
                 rel = os.path.relpath(root, src)
                 dest_root = os.path.join(dst, rel) if rel != "." else dst

core/iso_manager.py

@@ -26,7 +26,7 @@ class ISOManager:
         (["macos", "osx", "mac_os", "apple", "hackintosh",
           "catalina", "mojave", "sierra", "monterey", "ventura",
           "sonoma"], "macOS"),
-        (["freedos", "msdos", "ms-dos", "dos"], "FreeDOS"),
+        (["freedos", "fd", "msdos", "ms-dos", "dos"], "FreeDOS"),
     ]
 
     _CONTENT_SIGNATURES: Dict[str, list] = {
@@ -87,14 +87,94 @@ def get_iso_info(self, iso_path: str) -> Dict[str, Any]:
             else f"{size_mb:.2f} MB"
         )
         iso_type = self._determine_iso_type(iso_path)
+        is_hybrid = self._is_hybrid_iso(iso_path)
+        label = self._read_volume_label(iso_path)
+        has_efi = self._has_efi_boot(iso_path)
 
-        return {
+        info = {
             "path":       iso_path,
             "filename":   os.path.basename(iso_path),
             "size_bytes": size_bytes,
             "size":       size_str,
             "type":       iso_type,
+            "is_hybrid":  is_hybrid,
+            "has_efi":    has_efi,
+            "persistence_capable": iso_type == "Linux",
+            "recommended_fs": self._recommend_fs(iso_type, has_efi, size_mb / 1024),
+            "recommended_scheme": "GPT" if has_efi else "MBR",
+            "min_usb_bytes": size_bytes,
         }
+        if label:
+            info["label"] = label
+
+        # Add to history
+        self.add_to_history(iso_path)
+
+        return info
+
+    def _has_efi_boot(self, iso_path: str) -> bool:
+        """Check if ISO has EFI boot support."""
+        try:
+            if self.system == "Windows":
+                return self._check_windows_efi(iso_path)
+            elif self.system in ("Linux", "Darwin"):
+                return self._check_unix_efi(iso_path)
+            return False
+        except Exception:
+            return False
+
+    def _check_windows_efi(self, iso_path: str) -> bool:
+        """Check for EFI boot on Windows."""
+        script = (
+            f"$m = Mount-DiskImage -ImagePath '{iso_path}' -PassThru;"
+            "$dl = ($m | Get-Volume).DriveLetter; $dl"
+        )
+        try:
+            result = subprocess.run(
+                ["powershell", "-NoProfile", "-Command", script],
+                capture_output=True, text=True, timeout=15
+            )
+            drive = result.stdout.strip()
+            if not drive:
+                return False
+            root = drive + ":\\"
+            efi_path = os.path.join(root, "EFI")
+            has_efi = os.path.exists(efi_path)
+            subprocess.run(
+                ["powershell", "-NoProfile", "-Command",
+                 f"Dismount-DiskImage -ImagePath '{iso_path}'"],
+                capture_output=True, timeout=8
+            )
+            return has_efi
+        except Exception:
+            return False
+
+    def _check_unix_efi(self, iso_path: str) -> bool:
+        """Check for EFI boot on Unix-like systems."""
+        import tempfile
+        mount_point = tempfile.mkdtemp(prefix="smartboot_iso_")
+        try:
+            result = subprocess.run(
+                ["sudo", "mount", "-o", "loop,ro", iso_path, mount_point],
+                capture_output=True, timeout=10
+            )
+            if result.returncode != 0:
+                return False
+            try:
+                efi_path = os.path.join(mount_point, "EFI")
+                return os.path.exists(efi_path)
+            finally:
+                subprocess.run(
+                    ["sudo", "umount", mount_point],
+                    capture_output=True, timeout=8
+                )
+        except Exception:
+            return False
+        finally:
+            try:
+                os.rmdir(mount_point)
+            except OSError:
+                pass
 
     def validate_iso(self, iso_path: str) -> bool:
         """
@@ -207,7 +287,7 @@ def _determine_iso_type(self, iso_path: str) -> str:
             return "Windows (likely)"
         if size_gb > 4.5:
             return "Unknown (large ISO)"
-        return "Unknown (small ISO)"
+        return "Generic"
 
     def _detect_by_content(self, iso_path: str) -> Optional[str]:
         """Mount the ISO (platform-specific) and inspect contents."""
@@ -311,4 +391,80 @@ def _validate_windows_mount(self, iso_path: str) -> bool:
             )
             return found
         except Exception:
-            return False
+            return False
+
+    @staticmethod
+    def _format_size(size_bytes: int) -> str:
+        """Format size in bytes to human-readable string."""
+        size_mb = size_bytes / (1024 * 1024)
+        if size_mb >= 1024:
+            return f"{size_mb / 1024:.2f} GB"
+        return f"{size_mb:.2f} MB"
+
+    def _is_hybrid_iso(self, iso_path: str) -> bool:
+        """Check if ISO is hybrid (has both BIOS and UEFI boot)."""
+        try:
+            with open(iso_path, "rb") as f:
+                f.seek(0)
+                # Check for MBR signature
+                mbr_sig = f.read(2)
+                if mbr_sig != b"\x55\xAA":
+                    return False
+                # Check for ISO 9660 signature
+                f.seek(0x8001)
+                iso_sig = f.read(5)
+                return iso_sig == b"CD001"
+        except OSError:
+            return False
+
+    def _read_volume_label(self, iso_path: str) -> str:
+        """Read volume label from ISO."""
+        try:
+            with open(iso_path, "rb") as f:
+                f.seek(0x8028)  # Volume descriptor location
+                label = f.read(32).decode('utf-8', errors='ignore').strip('\x00')
+                return label or ""
+        except OSError:
+            return ""
+
+    @staticmethod
+    def _recommend_fs(iso_type: str, has_efi: bool, size_gb: float) -> str:
+        """Recommend filesystem based on ISO type and size."""
+        if iso_type == "Windows":
+            if size_gb > 32:
+                return "NTFS"
+            return "FAT32"
+        elif iso_type == "Linux":
+            if has_efi:
+                return "FAT32"
+            return "FAT32"
+        elif iso_type == "macOS":
+            return "HFS+"
+        elif iso_type == "FreeDOS":
+            return "FAT32"
+        return "FAT32"
+
+    def compute_checksum(self, iso_path: str, algorithm: str = "sha256", progress_callback=None) -> str:
+        """Compute checksum of ISO file."""
+        import hashlib
+        try:
+            hash_func = getattr(hashlib, algorithm.lower())
+        except AttributeError:
+            return ""
+
+        with open(iso_path, "rb") as f:
+            hash_obj = hash_func()
+            total_size = os.path.getsize(iso_path)
+            bytes_read = 0
+            while chunk := f.read(8192):
+                hash_obj.update(chunk)
+                bytes_read += len(chunk)
+                if progress_callback:
+                    progress = int((bytes_read / total_size) * 100)
+                    progress_callback(progress, f"Computing {algorithm} checksum…")
+        return hash_obj.hexdigest()
+
+    def verify_checksum(self, iso_path: str, expected: str, algorithm: str = "sha256") -> bool:
+        """Verify ISO checksum matches expected value."""
+        computed = self.compute_checksum(iso_path, algorithm)
+        return computed.lower() == expected.lower()

docs/changelog.md

@@ -17,6 +17,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Boot type options (BIOS, UEFI, Dual, FreeDOS)
 - Boot sector writing for all platforms
 - Direct write mode (dd-like)
+- SVG icon system with `get_icon()` function for consistent icon rendering
+- Background threading for USB device refresh to prevent UI freezing
+- Background threading for ISO info loading to prevent UI freezing
+- ISOManager methods: `compute_checksum()`, `verify_checksum()`, `_format_size()`, `_is_hybrid_iso()`, `_read_volume_label()`, `_recommend_fs()`
+- EFI boot detection for ISO files
+- Automatic ISO history tracking in `get_iso_info()`
+
+### Changed
+- Improved ISO type detection with better FreeDOS recognition (supports "fd" abbreviations)
+- Changed "Unknown (small ISO)" to "Generic" for clearer type naming
+- Enhanced `get_iso_info()` to include: `is_hybrid`, `has_efi`, `persistence_capable`, `recommended_fs`, `recommended_scheme`, `min_usb_bytes`, `label`
+- Improved copy tree cancellation handling with additional cancel checks
+- Adjusted default window size to 800x780 (from 800x850) for better fit
+- Adjusted minimum window size to 750x700 (from 750x750)
+
+### Fixed
+- Icon visibility issues - icons now properly display using SVG rendering
+- UI freezing during device refresh and ISO loading operations
+- Test suite failures - all 122 tests now passing
+- Window title icon not displaying
+- Copy tree cancellation not working correctly
 - Progress tracking and logging
 - PyQt5-based GUI