-
-
-
-```
-
-### 2. Key Observations
-
-#### Native HTML5 Drag ist DEAKTIVIERT
-```html
-draggable="false"
-```
-
-**Bedeutung:**
-- Kein Zugriff auf native `dragstart`, `drag`, `dragend` Events
-- Kein `event.dataTransfer` API verfügbar
-- Angular CDK simuliert Drag & Drop komplett in JavaScript
-- Daten werden NICHT über natives Clipboard/DataTransfer übertragen
-
-#### Angular CDK Direktiven
-- `cdkdroplistgroup` - Gruppiert mehrere Drop-Zonen
-- `cdkdroplist` - Markiert Drop-Bereiche (Collections, Clipboard)
-- `cdkdrag` - Markiert draggbare Elemente (Assets)
-- `cdkdroplistsortingdisabled` - Sortierung deaktiviert
-
-#### Asset Identifikation
-```html
-
-
-
-
-
- 
-
-
-
-
-
-
-
-
-![weiss_ORIGINAL]()
-```
-
-## Impact on WebDrop Bridge
-
-### ❌ Bisheriger Ansatz funktioniert NICHT
-
-Unser aktueller Ansatz basiert auf:
-1. Interception von nativen Drag-Events
-2. Manipulation von `event.dataTransfer.effectAllowed` und `.dropEffect`
-3. Setzen von URLs im DataTransfer
-
-**Das funktioniert NICHT mit Angular CDK**, da:
-- Angular CDK das native Drag & Drop komplett umgeht
-- Keine nativen Events gefeuert werden
-- DataTransfer API nicht verwendet wird
-
-### ✅ Mögliche Lösungsansätze
-
-#### Ansatz 1: JavaScript Injection zur Laufzeit
-Injiziere JavaScript-Code, der Angular CDK Events abfängt:
-
-```javascript
-// Überwache Angular CDK Event-Handler
-document.addEventListener('cdkDragStarted', (event) => {
- const assetId = event.source.element.nativeElement.id;
- const assetName = event.source.element.nativeElement.querySelector('img')?.alt;
-
- // Sende an Qt WebChannel
- bridge.handleDragStart(assetId, assetName);
-});
-
-document.addEventListener('cdkDragDropped', (event) => {
- // Verhindere das Standard-Verhalten
- event.preventDefault();
-
- // Starte nativen Drag von Qt aus
- bridge.initNativeDrag();
-});
-```
-
-**Vorteile:**
-- ✅ Direkter Zugriff auf Angular CDK Events
-- ✅ Kann Asset-Informationen extrahieren
-- ✅ Kann Drag-Operationen abfangen
-
-**Nachteile:**
-- ⚠️ Erfordert genaue Kenntnis der Angular CDK Internals
-- ⚠️ Könnte bei Angular CDK Updates brechen
-- ⚠️ Komplexer zu implementieren
-
-#### Ansatz 2: DOM Mutation Observer
-Überwache DOM-Änderungen während des Drags:
-
-```javascript
-const observer = new MutationObserver((mutations) => {
- mutations.forEach((mutation) => {
- // Suche nach CDK Drag-Elementen mit bestimmten Klassen
- const dragElement = document.querySelector('.cdk-drag-preview');
- if (dragElement) {
- const assetId = dragElement.querySelector('[id^="a"]')?.id;
- bridge.handleDrag(assetId);
- }
- });
-});
-
-observer.observe(document.body, {
- childList: true,
- subtree: true,
- attributes: true,
- attributeFilter: ['class']
-});
-```
-
-**Vorteile:**
-- ✅ Robuster gegenüber Framework-Updates
-- ✅ Funktioniert mit beliebigen Frameworks
-
-**Nachteile:**
-- ⚠️ Performance-Overhead
-- ⚠️ Kann falsche Positive erzeugen
-
-#### Ansatz 3: Qt WebChannel Bridge mit Custom Events
-Nutze Qt WebChannel, um mit der Angular-Anwendung zu kommunizieren:
-
-```python
-# Python-Seite (Qt)
-class DragBridge(QObject):
- @Slot(str, str)
- def onAssetDragStart(self, asset_id: str, asset_name: str):
- """Called from JavaScript when Angular CDK drag starts."""
- logger.info(f"Asset drag started: {asset_id} ({asset_name})")
- self.convert_and_drag(asset_id, asset_name)
-```
-
-```javascript
-// JavaScript-Seite (injiziert via QWebEngineScript)
-new QWebChannel(qt.webChannelTransport, (channel) => {
- const dragBridge = channel.objects.dragBridge;
-
- // Monkey-patch Angular CDK's DragRef
- const originalStartDraggingSequence = CdkDrag.prototype._startDraggingSequence;
- CdkDrag.prototype._startDraggingSequence = function(event) {
- const assetElement = this.element.nativeElement;
- const assetId = assetElement.id;
- const assetName = assetElement.querySelector('img')?.alt;
-
- // Benachrichtige Qt
- dragBridge.onAssetDragStart(assetId, assetName);
-
- // Rufe original Angular CDK Methode auf
- return originalStartDraggingSequence.call(this, event);
- };
-});
-```
-
-**Vorteile:**
-- ✅ Saubere Kommunikation zwischen Qt und Web
-- ✅ Kann Asset-Informationen zuverlässig extrahieren
-- ✅ Typensicher (Qt Signals/Slots)
-
-**Nachteile:**
-- ⚠️ Erfordert Monkey-Patching von Angular CDK
-- ⚠️ Kann bei CDK Updates brechen
-
-#### Ansatz 4: Browser DevTools Protocol (Chrome DevTools)
-Nutze Chrome DevTools Protocol für tiefere Integration:
-
-```python
-from PySide6.QtWebEngineCore import QWebEngineProfile
-
-profile = QWebEngineProfile.defaultProfile()
-profile.setRequestInterceptor(...)
-
-# Intercepte Netzwerk-Requests und injiziere Header
-# Überwache JavaScript-Execution via CDP
-```
-
-**Vorteile:**
-- ✅ Sehr mächtig, kann JavaScript-Execution überwachen
-- ✅ Kann Events auf niedrigerer Ebene abfangen
-
-**Nachteile:**
-- ⚠️ Sehr komplex
-- ⚠️ Erfordert Chrome DevTools Protocol Kenntnisse
-- ⚠️ Performance-Overhead
-
-## Empfohlener Ansatz
-
-### **Ansatz 3: Qt WebChannel Bridge** (BEVORZUGT)
-
-**Begründung:**
-1. ✅ Saubere Architektur mit klarer Trennung
-2. ✅ Typsicher durch Qt Signals/Slots
-3. ✅ Kann Asset-IDs und -Namen zuverlässig extrahieren
-4. ✅ Funktioniert auch wenn Angular CDK interne Änderungen hat
-5. ✅ Ermöglicht bidirektionale Kommunikation
-
-**Implementierungsschritte:**
-
-### Phase 1: Asset-Informationen extrahieren
-1. JavaScript via QWebEngineScript injizieren
-2. Qt WebChannel setuppen
-3. Angular CDK Events überwachen (ohne Monkey-Patching als Test)
-4. Asset-IDs und Namen an Qt senden
-
-### Phase 2: Native Drag initiieren
-1. Bei CDK Drag-Start: Extrahiere Asset-Informationen
-2. Sende Asset-ID an Backend/API
-3. Erhalte lokalen Dateipfad oder Azure Blob URL
-4. Konvertiere zu lokalem Pfad (wie aktuell)
-5. Initiiere nativen Drag mit QDrag
-
-### Phase 3: Drag-Feedback
-1. Zeige Drag-Preview in Qt (optional)
-2. Update Cursor während Drag
-3. Cleanup nach Drag-Ende
-
-## Asset-ID zu Dateipfad Mapping
-
-Die Anwendung verwendet Asset-IDs in mehreren Formaten:
-
-```javascript
-// Asset-ID: anPGZszKzgKaSz1SIx2HFgduy
-
-// Mögliche URL-Konstruktion:
-const assetUrl = `https://dev.agravity.io/api/assets/${assetId}`;
-const downloadUrl = `https://dev.agravity.io/api/assets/${assetId}/download`;
-const blobUrl = `https://static.agravity.io/${workspaceId}/${assetId}/${filename}`;
-```
-
-**Für WebDrop Bridge:**
-- Asset-ID aus DOM extrahieren
-- Asset-Metadaten via API abrufen (falls verfügbar)
-- Blob-URL konstruieren
-- URL Converter nutzen (bereits implementiert!)
-
-## Next Steps
-
-1. **Proof of Concept**: Qt WebChannel mit einfachem Event-Logger
-2. **Asset-ID Extraction**: JavaScript Injection testen
-3. **API Research**: GlobalDAM API untersuchen (Asset-Metadaten)
-4. **Integration**: Mit bestehendem URLConverter verbinden
-5. **Testing**: Mit echten Assets testen
-
-## Hinweise
-
-- Angular CDK Version kann sich unterscheiden - Code muss robust sein
-- Asset-IDs scheinen eindeutig zu sein (Base64-ähnlich)
-- Die Anwendung nutzt Azure Blob Storage (basierend auf bisherigen URLs)
-- Custom Components (`ay-*`) deuten auf eine eigene Component Library hin
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 48c4636..2ac38c4 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -1,5 +1,9 @@
# Architecture Guide
+## Related Docs
+
+- [Translations Guide (i18n)](TRANSLATIONS_GUIDE.md)
+
## High-Level Design
```
@@ -36,10 +40,11 @@
**Key Components:**
-- `validator.py`: Path validation against whitelist
-- `drag_interceptor.py`: Drag event handling and conversion
-- `config.py`: Configuration management
-- `errors.py`: Custom exception classes
+- `validator.py`: Path validation against whitelist with security checks
+- `drag_interceptor.py`: Drag event handling and native drag operations
+- `config_manager.py`: Configuration loading from files and caching
+- `url_converter.py`: Azure Blob Storage URL → local path conversion
+- `updater.py`: Update checking via Forgejo API
**Dependencies**: None (only stdlib + pathlib)
@@ -49,9 +54,12 @@
**Key Components:**
-- `main_window.py`: Main application window
-- `widgets.py`: Reusable custom widgets
-- `styles.py`: UI styling and themes
+- `main_window.py`: Main application window with web engine integration
+- `restricted_web_view.py`: Hardened QWebEngineView with security policies
+- `settings_dialog.py`: Settings UI for configuration
+- `update_manager_ui.py`: Update checking and notification UI
+- `bridge_script_intercept.js`: JavaScript drag interception and WebChannel bridge for Qt communication
+- `download_interceptor.js`: Download handling for web content
**Dependencies**: PySide6, core/
@@ -61,9 +69,7 @@
**Key Components:**
-- `logging.py`: Logging configuration
-- `constants.py`: Application constants
-- `helpers.py`: General-purpose helper functions
+- `logging.py`: Logging configuration (console + file with rotation)
**Dependencies**: stdlib only
@@ -72,34 +78,57 @@
### Drag-and-Drop Operation
```
-User in Web App
+User in Web App (browser)
↓
-[dragstart event] → JavaScript sets dataTransfer.text = "Z:\path\file.txt"
+[dragstart event] → bridge_script_intercept.js detects drag
+ ├─ Checks if content is convertible (file path or Azure URL)
+ ├─ Calls window.bridge.start_file_drag(url)
+ └─ preventDefault() → Blocks normal browser drag
+
↓
-[dragend event] → Drag leaves WebEngine widget
+JavaScript → QWebChannel Bridge
↓
-DragInterceptor.dragEnterEvent() triggered
+_DragBridge.start_file_drag(path_text) [main_window.py]
+ ├─ Defers execution via QTimer (drag manager safety)
+ └─ Calls DragInterceptor.handle_drag()
+
↓
-Extract text from QMimeData
+DragInterceptor.handle_drag() [core/drag_interceptor.py]
+ ├─ Check if Azure URL: Use URLConverter → local path
+ ├─ Else: Treat as direct file path
+ └─ Validate with PathValidator
+
↓
-PathValidator.is_valid_file(path)
- ├─ is_allowed(path) → Check whitelist
- └─ path.exists() and path.is_file() → File system check
+PathValidator.validate(path)
+ ├─ Resolve to absolute path
+ ├─ Check file exists (if configured)
+ ├─ Check is regular file (not directory)
+ └─ Check path within allowed_roots (whitelist)
+
↓
If valid:
→ Create QUrl.fromLocalFile(path)
- → Create new QMimeData with URLs
- → QDrag.exec() → Native file drag
+ → Create QMimeData with file URL
+ → QDrag.exec(Qt.CopyAction) → Native file drag
+ → Emit drag_started signal
↓
If invalid:
- → event.ignore()
- → Log warning
+ → Emit drag_failed signal with error
+ → Log validation error
↓
OS receives native file drag
↓
-InDesign/Word receives file handle
+Target application (InDesign/Word) receives file handle
```
+**Key Components in Data Flow:**
+
+1. **bridge_script_intercept.js**: Opens a WebChannel to Qt's _DragBridge
+2. **_DragBridge**: Exposes `start_file_drag()` slot to JavaScript
+3. **DragInterceptor**: Handles validation and native drag creation
+4. **URLConverter**: Maps Azure Blob Storage URLs to local paths via config
+5. **PathValidator**: Security-critical validation against whitelist
+
## Security Model
### Path Validation Strategy
diff --git a/docs/BRANDING_AND_RELEASES.md b/docs/BRANDING_AND_RELEASES.md
new file mode 100644
index 0000000..4354dc3
--- /dev/null
+++ b/docs/BRANDING_AND_RELEASES.md
@@ -0,0 +1,488 @@
+# Branding, Builds, and Releases
+
+This document describes how branded builds work in this repository, how to add or edit a brand, how to build the default and branded variants, and how to publish releases.
+
+## Overview
+
+The project supports one default product and any number of branded variants from the same codebase.
+
+- The default product is defined by built-in defaults in `build/scripts/brand_config.py`.
+- The default product identifier is `webdrop_bridge`.
+- Additional brands are defined by JSON manifests in `build/brands/`.
+- Runtime behavior can also be branded through application config values such as `brand_id`, `config_dir_name`, `app_name`, and update settings.
+- Windows and macOS installers are built as separate artifacts per brand.
+- Releases are shared by version. A single Forgejo release can contain installers for the default product and multiple brands.
+
+## Branding Model
+
+There are two layers to branding:
+
+1. Packaging identity
+ Controls installer name, executable/app bundle name, product display name, bundle identifier, MSI upgrade code, installer artwork, and related metadata.
+
+2. Runtime configuration
+ Controls app name shown in the UI, config directory name, update feed settings, URL mappings, allowed roots, and similar application behavior.
+
+Packaging identity lives in `build/brands/.json`.
+
+Runtime configuration lives in app config files loaded by the application. See `config.example.json` for the current branded example.
+
+## Important Files
+
+- `build/scripts/brand_config.py`: central helper for brand metadata, artifact naming, and release manifest generation
+- `build/brands/agravity.json`: example branded manifest
+- `build/scripts/build_windows.py`: Windows build entrypoint
+- `build/scripts/build_macos.sh`: macOS build entrypoint
+- `build/scripts/create_release.ps1`: Windows release uploader
+- `build/scripts/create_release.sh`: macOS release uploader
+- `config.example.json`: example runtime branding config
+
+## Create a New Brand
+
+To create a new brand, add a new manifest file under `build/brands/`.
+
+Example:
+
+1. Copy `build/brands/template.jsonc` to `build/brands/.json`.
+2. Update the values for the new brand.
+3. Add any brand-specific assets if you do not want to reuse the default icons/license assets.
+
+Minimal example:
+
+```json
+{
+ "brand_id": "customerx",
+ "display_name": "Customer X Bridge",
+ "asset_prefix": "CustomerXBridge",
+ "exe_name": "CustomerXBridge",
+ "manufacturer": "Customer X",
+ "install_dir_name": "Customer X Bridge",
+ "shortcut_description": "Customer X drag-and-drop bridge",
+ "bundle_identifier": "com.customerx.bridge",
+ "config_dir_name": "customerx_bridge",
+ "msi_upgrade_code": "PUT-A-NEW-GUID-HERE",
+ "update_channel": "stable",
+ "icon_ico": "resources/icons/app.ico",
+ "icon_icns": "resources/icons/app.icns",
+ "dialog_bmp": "resources/icons/background.bmp",
+ "banner_bmp": "resources/icons/banner.bmp",
+ "license_rtf": "resources/license.rtf"
+}
+```
+
+### Required Fields
+
+- `brand_id`: internal identifier used for build output folders and release manifest entries
+- `display_name`: user-facing product name
+- `asset_prefix`: base name for installer artifacts and app bundle name
+- `exe_name`: executable name for Windows and app bundle name base for macOS
+- `manufacturer`: MSI manufacturer string
+- `install_dir_name`: installation directory name shown to the OS
+- `shortcut_description`: Windows shortcut description
+- `bundle_identifier`: macOS bundle identifier
+- `config_dir_name`: local app config/log/cache directory name
+- `msi_upgrade_code`: stable GUID for Windows upgrades
+- `update_channel`: currently typically `stable`
+
+Generate a new `msi_upgrade_code` for a new brand once and keep it stable afterwards.
+
+Examples:
+
+```powershell
+New-Guid
+```
+
+```bash
+uuidgen
+```
+
+### Asset Fields
+
+These can point at brand-specific files or default shared files:
+
+- `icon_ico`
+- `icon_icns`
+- `dialog_bmp`
+- `banner_bmp`
+- `license_rtf`
+
+Optional toolbar icon overrides:
+
+- `toolbar_icon_home`
+- `toolbar_icon_reload`
+- `toolbar_icon_open`
+- `toolbar_icon_openwith`
+
+If a referenced asset path does not exist, the helper falls back to the default asset defined in `build/scripts/brand_config.py`.
+
+For toolbar icons, the runtime looks for the configured paths in packaged and development layouts. If an icon is missing:
+
+- Home falls back to a standard Qt home icon
+- Reload/Open/OpenWith keep their existing icon behavior
+
+### Identity Rules
+
+Treat these values as long-lived product identity once a brand has shipped:
+
+- `brand_id`
+- `asset_prefix`
+- `exe_name`
+- `bundle_identifier`
+- `config_dir_name`
+- `msi_upgrade_code`
+
+Changing them later can break one or more of the following:
+
+- Windows upgrade behavior
+- macOS app identity
+- auto-update asset selection
+- local config/log/cache continuity
+- installer and artifact naming consistency
+
+If the product is already in use, only change these values deliberately and with migration planning.
+
+## Edit an Existing Brand
+
+To edit a shipped or in-progress brand:
+
+1. Update the brand manifest in `build/brands/.json`.
+2. If needed, update brand-specific assets referenced by that manifest.
+3. If runtime behavior should also change, update the relevant application config values.
+4. Rebuild the affected platform artifacts.
+5. Validate the result with a dry-run release before publishing.
+
+Safe edits after release usually include:
+
+- `display_name`
+- `shortcut_description`
+- artwork paths
+- license text
+- update channel, if release policy changes
+
+High-risk edits after release are the identity fields listed above.
+
+## Runtime Branding Configuration
+
+Packaging branding alone is not enough if the app should also present a different name, use different local storage, or point to different update settings.
+
+Relevant runtime config keys include:
+
+- `brand_id`
+- `config_dir_name`
+- `app_name`
+- `update_base_url`
+- `update_repo`
+- `update_channel`
+- `update_manifest_name`
+
+Toolbar icon env overrides (useful for packaged branding):
+
+- `TOOLBAR_ICON_HOME`
+- `TOOLBAR_ICON_RELOAD`
+- `TOOLBAR_ICON_OPEN`
+- `TOOLBAR_ICON_OPENWITH`
+
+The current example in `config.example.json` shows the Agravity runtime setup.
+
+When adding a new brand, make sure the runtime config matches the packaging manifest at least for:
+
+- `brand_id`
+- `config_dir_name`
+- `app_name`
+
+## Build the Default Product
+
+### Windows
+
+Build the default executable only:
+
+```powershell
+python .\build\scripts\build_windows.py
+```
+
+Build the default Windows MSI:
+
+```powershell
+python .\build\scripts\build_windows.py --msi
+```
+
+Build with a specific `.env` file:
+
+```powershell
+python .\build\scripts\build_windows.py --msi --env-file .\.env
+```
+
+### macOS
+
+Build the default macOS app and DMG:
+
+```bash
+bash build/scripts/build_macos.sh
+```
+
+Build with a specific `.env` file:
+
+```bash
+bash build/scripts/build_macos.sh --env-file .env
+```
+
+## Build a Brand
+
+### Windows
+
+Build a branded executable only:
+
+```powershell
+python .\build\scripts\build_windows.py --brand agravity
+```
+
+Build a branded MSI:
+
+```powershell
+python .\build\scripts\build_windows.py --brand agravity --msi
+```
+
+### macOS
+
+Build a branded macOS app and DMG:
+
+```bash
+bash build/scripts/build_macos.sh --brand agravity
+```
+
+## Build Output Locations
+
+Windows artifacts are written to:
+
+- `build/dist/windows/webdrop_bridge/` for the default product
+- `build/dist/windows//` for branded products
+
+macOS artifacts are written to:
+
+- `build/dist/macos/webdrop_bridge/` for the default product
+- `build/dist/macos//` for branded products
+
+Typical artifact names:
+
+- Windows MSI: `--win-x64.msi`
+- Windows checksum: `--win-x64.msi.sha256`
+- macOS DMG: `--macos-universal.dmg`
+- macOS checksum: `--macos-universal.dmg.sha256`
+
+## Create a Release
+
+Releases are shared by version. The release scripts scan local build outputs on the current machine and upload every artifact they find for that platform.
+
+This means:
+
+- a Windows machine can upload all locally built MSIs for the current version
+- a macOS machine can later upload all locally built DMGs for the same version
+- both runs contribute to the same Forgejo release tag
+- `release-manifest.json` is merged so later runs do not wipe earlier platform entries
+
+### Windows Release
+
+Dry run first:
+
+```powershell
+.\build\scripts\create_release.ps1 -DryRun
+```
+
+Publish all locally built Windows variants for the current version:
+
+```powershell
+.\build\scripts\create_release.ps1
+```
+
+Publish only selected brands:
+
+```powershell
+.\build\scripts\create_release.ps1 -Brands agravity
+```
+
+Publish only the default product:
+
+```powershell
+.\build\scripts\create_release.ps1 -Brands webdrop_bridge
+```
+
+Publish a specific version:
+
+```powershell
+.\build\scripts\create_release.ps1 -Version 0.8.4
+```
+
+### macOS Release
+
+Dry run first:
+
+```bash
+bash build/scripts/create_release.sh --dry-run
+```
+
+Publish all locally built macOS variants for the current version:
+
+```bash
+bash build/scripts/create_release.sh
+```
+
+Publish only selected brands:
+
+```bash
+bash build/scripts/create_release.sh --brand agravity
+```
+
+Publish only the default product:
+
+```bash
+bash build/scripts/create_release.sh --brand webdrop_bridge
+```
+
+Publish a specific version:
+
+```bash
+bash build/scripts/create_release.sh --version 0.8.4
+```
+
+### Credentials
+
+Both release scripts use Forgejo credentials from environment variables when available:
+
+- `FORGEJO_USER`
+- `FORGEJO_PASS`
+
+If they are not set and you are not in dry-run mode, the script prompts for them.
+
+Both scripts also support clearing credentials from the current shell session:
+
+- Windows: `-ClearCredentials`
+- macOS: `--clear-credentials`
+
+## Dry Run Behavior
+
+Dry-run mode is the preferred validation step before publishing.
+
+Dry-run mode:
+
+- discovers the local artifacts exactly like a real release run
+- prints the release tag and target release URL
+- prints the brands that were discovered locally
+- prints the artifact paths that would be uploaded
+- writes a local manifest preview to `build/dist/release-manifest.json`
+- does not prompt for credentials
+- does not perform network requests
+- does not delete or upload assets
+
+## Release Manifest
+
+The release scripts generate and upload `release-manifest.json`.
+
+This file is used by the updater to select the correct installer and checksum for a given brand and platform.
+
+Current platform keys are:
+
+- `windows-x64`
+- `macos-universal`
+
+The manifest is built from local artifacts and merged with any existing manifest already attached to the release.
+
+## First Manual Download (Before Auto-Update)
+
+After creating a release, a user can manually download the first installer directly from Forgejo. Once installed, auto-update handles later versions.
+
+Base repository URL:
+
+- `https://git.him-tools.de/HIM-public/webdrop-bridge`
+
+Release page pattern:
+
+- `https://git.him-tools.de/HIM-public/webdrop-bridge/releases/tag/v`
+
+Direct asset download pattern:
+
+- `https://git.him-tools.de/HIM-public/webdrop-bridge/releases/download/v/`
+
+Example asset names:
+
+- `WebDropBridge-0.8.4-win-x64.msi`
+- `WebDropBridge-0.8.4-macos-universal.dmg`
+- `AgravityBridge-0.8.4-win-x64.msi`
+- `AgravityBridge-0.8.4-macos-universal.dmg`
+
+### wget Examples
+
+```bash
+# Default Windows installer
+wget "https://git.him-tools.de/HIM-public/webdrop-bridge/releases/download/v0.8.4/WebDropBridge-0.8.4-win-x64.msi"
+
+# Agravity macOS installer
+wget "https://git.him-tools.de/HIM-public/webdrop-bridge/releases/download/v0.8.4/AgravityBridge-0.8.4-macos-universal.dmg"
+```
+
+### curl Examples
+
+```bash
+# Default macOS installer
+curl -L -o WebDropBridge-0.8.4-macos-universal.dmg \
+ "https://git.him-tools.de/HIM-public/webdrop-bridge/releases/download/v0.8.4/WebDropBridge-0.8.4-macos-universal.dmg"
+
+# Agravity Windows installer
+curl -L -o AgravityBridge-0.8.4-win-x64.msi \
+ "https://git.him-tools.de/HIM-public/webdrop-bridge/releases/download/v0.8.4/AgravityBridge-0.8.4-win-x64.msi"
+```
+
+### PowerShell Example
+
+```powershell
+Invoke-WebRequest `
+ -Uri "https://git.him-tools.de/HIM-public/webdrop-bridge/releases/download/v0.8.4/WebDropBridge-0.8.4-win-x64.msi" `
+ -OutFile "WebDropBridge-0.8.4-win-x64.msi"
+```
+
+You can inspect `release-manifest.json` on the release to see the exact file names for each brand and platform.
+
+## Recommended Workflow for a New Brand
+
+1. Create `build/brands/.json`.
+2. Add or update brand-specific assets if needed.
+3. Prepare matching runtime config values.
+4. Build the brand on Windows and/or macOS.
+5. Run the release script in dry-run mode.
+6. Verify artifact names, discovered brands, and manifest contents.
+7. Run the actual release script.
+8. Validate update behavior against the shared release.
+
+## Troubleshooting Notes
+
+### Brand not discovered by release script
+
+Check that:
+
+- the build completed successfully
+- the artifact is under the expected platform folder
+- the artifact name matches the `asset_prefix` and current version
+- the version used by the release script matches the built artifact version
+
+### Windows upgrade behavior is wrong
+
+Check that the brand has its own stable `msi_upgrade_code`. Reusing or changing it incorrectly will break expected MSI upgrade semantics.
+
+### App uses the wrong local config folder
+
+Check that runtime config uses the intended `config_dir_name`, and that it matches the packaging brand you expect.
+
+### Auto-update downloads the wrong installer
+
+Check that:
+
+- the release contains the correct installer files
+- `release-manifest.json` includes the correct brand and platform entry
+- runtime update settings point to the expected repo/channel/manifest
+
+## Current Example Brand
+
+The first branded variant currently in the repository is:
+
+- `build/brands/agravity.json`
+
+Use it as the template for future branded variants.
\ No newline at end of file
diff --git a/docs/CONFIGURATION_BUILD.md b/docs/CONFIGURATION_BUILD.md
index c9d1212..d69abfa 100644
--- a/docs/CONFIGURATION_BUILD.md
+++ b/docs/CONFIGURATION_BUILD.md
@@ -12,7 +12,7 @@ The configuration file must be named `.env` and contains settings like:
```dotenv
APP_NAME=WebDrop Bridge
-APP_VERSION=0.1.0
+APP_VERSION=0.7.1
WEBAPP_URL=https://example.com
ALLOWED_ROOTS=Z:/,C:/Users/Public
ALLOWED_URLS=
diff --git a/docs/DRAG_DROP_PROBLEM_ANALYSIS.md b/docs/DRAG_DROP_PROBLEM_ANALYSIS.md
index 7e6906d..1219a8c 100644
--- a/docs/DRAG_DROP_PROBLEM_ANALYSIS.md
+++ b/docs/DRAG_DROP_PROBLEM_ANALYSIS.md
@@ -1,8 +1,28 @@
# Drag & Drop Problem Analysis - File Drop + Web App Popup
-## Das Kernproblem
+**Status**: Phase 1 (File Drop) ✅ Implemented | Phase 2 (Popup Trigger) ⏸️ Planned
+**Last Updated**: March 3, 2026
-**Ziel**: Bei ALT-Drag soll:
+## Overview
+
+### Current Implementation Status
+
+✅ **Phase 1 - File Drop (IMPLEMENTED)**
+- JavaScript in `bridge_script_intercept.js` intercepts drag events
+- Calls `window.bridge.start_file_drag(url)` via QWebChannel to Qt
+- Validates path against whitelist via `PathValidator`
+- Converts Azure Storage URLs to local paths via `URLConverter`
+- Creates and executes native Qt file drag operation
+- Target application (InDesign, Word, etc.) successfully receives file
+
+⏸️ **Phase 2 - Programmatic Popup Trigger (PLANNED)**
+- Would require reverse-engineering the web app's popup trigger mechanism
+- Could be implemented by calling JavaScript function after successful drop
+- Currently: Applications handle popups manually or separately from file drops
+
+---
+
+## Das Kernproblem
1. ✅ File gedroppt werden (Z:\ Laufwerk) → Native File-Drop
2. ✅ Web-App Popup erscheinen (Auschecken-Dialog) → Web-App Drop-Event
@@ -250,28 +270,39 @@ Object.defineProperty(DataTransfer.prototype, 'types', {
## 📝 Empfehlung
-**Sofortige Maßnahmen:**
+### Current Status (as of March 2026)
-1. ✅ **Lösung A Phase 1 ist bereits implementiert** (File-Drop funktioniert)
+✅ **Phase 1 Complete:**
+- File-drop via native Qt drag operations is fully functional
+- JavaScript bridge (`bridge_script_intercept.js`) successfully intercepts and converts drags
+- Path validation and Azure URL mapping working
+- Tested with real applications (InDesign, Word, etc.)
-2. 🔍 **Reverse-Engineering durchführen:**
- - GlobalDAM JRI im Browser öffnen
- - DevTools öffnen (F12)
- - ALT-Drag+Drop durchführen
- - Beobachten:
- - Network-Tab → API-Calls?
- - Console → Fehler/Logs?
- - Angular DevTools → Component-Events?
+### For Future Enhancement (Phase 2 - Popup Trigger)
-3. 🛠️ **Popup-Trigger implementieren:**
- - Sobald bekannt WIE Popup ausgelöst wird
- - JavaScript-Funktion `trigger_checkout_popup()` erstellen
- - Von Qt aus nach erfolgreichem Drop aufrufen
+**If popup trigger integration is needed:**
-4. 🧪 **Testen:**
- - ALT-Drag eines Assets
- - File-Drop sollte funktionieren
- - Popup sollte erscheinen
+1. 🔍 **Reverse-Engineering the Target Web App:**
+ - Identify how popups are triggered (API call, component method, event, etc.)
+ - Use browser DevTools:
+ - Network tab → Monitor API calls
+ - Console → Check for JavaScript errors/logs
+ - Elements → Inspect component structure
+ - Angular/Vue DevTools if applicable
-**Fallback:**
-Falls Reverse-Engineering zu komplex ist → **Lösung B** verwenden (Kein Drag, nur Copy nach Popup-Bestätigung)
+2. 🛠️ **Implement Popup Trigger:**
+ - Create JavaScript hook function (e.g., `window.trigger_popup(assetId)`)
+ - Connect to drop success signal from Qt
+ - Call popup trigger after successful file drop
+
+3. 🧪 **Test Integration:**
+ - Verify file drops successfully
+ - Verify popup appears after drop
+ - Test with real assets/files
+
+**Alternative Approaches:**
+
+- **Lösung B (Manual)**: Keep file drop and popup as separate user actions
+- **Lösung C (Complex)**: Use overlay window approach (more involved)
+
+Current implementation uses **Phase 1 of Lösung A** and is production-ready.
diff --git a/docs/HOVER_EFFECTS_ANALYSIS.md b/docs/HOVER_EFFECTS_ANALYSIS.md
new file mode 100644
index 0000000..869027b
--- /dev/null
+++ b/docs/HOVER_EFFECTS_ANALYSIS.md
@@ -0,0 +1,194 @@
+# Hover Effects Analysis - Qt WebEngineView Limitation
+
+## Executive Summary
+
+**Status**: Hover effects partially functional in Qt WebEngineView, with a clear Qt limitation identified.
+
+- ✅ **Checkbox hover**: Works correctly
+- ✅ **Event detection**: Polling-based detection functional
+- ❌ **Menu expansion via :hover**: Does NOT work (Qt limitation)
+- ❌ **Tailwind CSS :hover-based effects**: Do NOT work in Qt
+
+## Investigation Results
+
+### Test Environment
+- **Framework**: PySide6 QWebEngineView
+- **Web App**: Angular + Tailwind CSS
+- **Browser Test**: Google Chrome (reference)
+- **Test Date**: March 4, 2026
+
+### Chrome Browser Results
+Both menu expansion and checkbox hover work perfectly in Chrome browser. This confirms the issue is **Qt-specific**, not a web application problem.
+
+### Qt WebEngineView Results
+
+#### What Works ✅
+1. **Checkbox hover effects**
+ - Checkboxes appear on hover
+ - CSS-based simulation via `.__mouse_hover` class works correctly
+ - `input[type="checkbox"].__mouse_hover` CSS selector successfully applied
+
+2. **Event detection**
+ - Mouse position tracking: Working
+ - `document.elementFromPoint()` polling: Working (50ms interval)
+ - `mouseover`, `mouseenter`, `mouseleave`, `mousemove` event dispatching: Working
+ - Angular event listeners: Receiving dispatched events correctly
+
+3. **DOM element access**
+ - Menu element found with `querySelectorAll()`
+ - Event listeners identified: `{click: Array(1)}`
+ - Not in Shadow DOM (accessible from JavaScript)
+
+#### What Doesn't Work ❌
+1. **Menu expansion via Tailwind :hover**
+ - Menu element: `.group` class with `hover:bg-neutral-300`
+ - Menu children have: `.group-hover:w-full` (Tailwind pattern)
+ - Expected behavior: `.group:hover > .group-hover:w-full` triggers on hover
+ - Actual behavior: No expansion (`:hover` pseudo-selector not activated)
+
+2. **Tailwind CSS :hover-based styles**
+ - Pattern: `.group:hover > .group-hover:*` (Tailwind generated)
+ - Root cause: Qt doesn't properly set `:hover` pseudo-selector state for dispatched events
+ - Impact: Any CSS rule depending on `:hover` pseudo-selector won't work
+
+## Technical Analysis
+
+### The Core Issue
+
+Qt WebEngineView doesn't forward native mouse events to JavaScript in a way that properly triggers the CSS `:hover` pseudo-selector. When we dispatch synthetic events:
+
+```javascript
+element.dispatchEvent(new MouseEvent("mouseover", {...}));
+element.dispatchEvent(new MouseEvent("mouseenter", {...}));
+```
+
+The browser's CSS engine **does not** update the `:hover` pseudo-selector state. This is different from a native browser, where:
+
+1. User moves mouse
+2. Browser kernel detects native hover
+3. `:hover` pseudo-selector activates
+4. CSS rules matching `:hover` are applied
+
+### Evidence
+
+**Chrome DevTools inspection** revealed:
+```
+Event Listeners: {click: Array(1)} // Only CLICK handler, NO hover handlers
+Menu element className: "flex h-14 w-full items-center p-2 transition-colors hover:bg-neutral-300 ... group"
+```
+
+The Angular app handles UI in two ways:
+1. **Click events**: Directly handled by JavaScript listeners → Works
+2. **Hover effects**: Rely on CSS `:hover` pseudo-selector → Doesn't work in Qt
+
+### Why This Is a Limitation
+
+This is not fixable by JavaScript injection because:
+
+1. **JavaScript can't activate CSS `:hover`**: The `:hover` pseudo-selector is a browser-native feature that only CSS engines can modify. JavaScript can't directly trigger it.
+
+2. **Tailwind CSS is static**: Tailwind generates CSS rules like `.group:hover > .group-hover:w-full { width: 11rem; }`. These rules expect the `:hover` pseudo-selector to be active—JavaScript can't force them to apply.
+
+3. **Qt engine limitation**: Qt WebEngineView's Chromium engine doesn't properly handle `:hover` for non-native events.
+
+### What We Tried
+
+| Approach | Result | Notes |
+|----------|--------|-------|
+| Direct CSS class injection | ❌ Failed | `.group.__mouse_hover` doesn't trigger Tailwind rules |
+| PointerEvent dispatch | ❌ Failed | Modern API didn't help |
+| JavaScript style manipulation | ❌ Failed | Can't force Tailwind CSS rules via JS |
+| Polling + synthetic mouse events | ⚠️ Partial | Works for custom handlers, not for `:hover` |
+
+## Implementation Status
+
+### Current Solution
+File: [mouse_event_emulator.js](../src/webdrop_bridge/ui/mouse_event_emulator.js)
+
+**What it does:**
+1. Polls `document.elementFromPoint()` every 50ms to detect element changes
+2. Dispatches `mouseover`, `mouseenter`, `mouseleave`, `mousemove` events
+3. Applies `.__mouse_hover` CSS class for custom hover simulation
+4. Works for elements with JavaScript event handlers
+
+**What it doesn't do:**
+1. Cannot activate `:hover` pseudo-selector
+2. Cannot trigger Tailwind CSS hover-based rules
+3. Cannot fix Qt's limitation
+
+### Performance
+- CPU overhead: Minimal (polling every 50ms on idle)
+- Startup impact: Negligible
+- Memory footprint: ~2KB script size
+
+## Verification Steps
+
+To verify this limitation exists in your Qt environment:
+
+### Chrome Test
+1. Open web app in Chrome
+2. Hover over menu → Menu expands ✅
+3. Hover over checkbox → Checkbox appears ✅
+
+### Qt Test
+1. Run application in Qt
+2. Hover over menu → Menu does NOT expand ❌ (known limitation)
+3. Hover over checkbox → Checkbox appears ✅ (works via CSS class)
+
+### Debug Verification (if needed)
+In Chrome DevTools console:
+
+```javascript
+// Find menu element
+const menuGroup = document.querySelector('[class*="group"]');
+console.log("Menu group:", menuGroup?.className);
+
+// Check for Shadow DOM
+const inShadow = menuGroup?.getRootNode() !== document;
+console.log("In Shadow DOM:", inShadow); // Should be false
+
+// Check event listeners
+console.log("Event Listeners:", getEventListeners(menuGroup)); // Shows if handlers exist
+```
+
+Results:
+- Menu element: Found
+- Shadow DOM: No
+- Event listeners: `{click: Array(1)}` (only click, no hover handlers)
+
+## Recommendations
+
+### What Developers Should Know
+1. **Don't expect :hover effects to work in Qt WebEngineView**
+ - This is a known limitation, not a bug in WebDrop Bridge
+ - The application itself works correctly in Chrome
+
+2. **Workarounds for your web app**
+ - Replace `:hover` with JavaScript click handlers
+ - Add click-to-toggle functionality instead of hover
+ - This is outside the scope of WebDrop Bridge
+
+3. **For similar Qt projects**
+ - Be aware of this `:hover` pseudo-selector limitation when embedding web content
+ - Consider detecting Qt environment and serving alternative UI
+ - Test web apps in actual Chrome browser before embedding in Qt
+
+### Future Improvements (Not Feasible)
+The following would require Qt framework modifications:
+- Improving QWebEngineView's `:hover` pseudo-selector support
+- Better mouse event forwarding to browser CSS engine
+- Custom CSS selector handling in embedded browser
+
+None of these are achievable through application-level code.
+
+## Summary
+
+WebDrop Bridge successfully emulates hover behavior for elements with JavaScript event handlers (like checkboxes). However, Tailwind CSS and other frameworks that rely on the CSS `:hover` pseudo-selector will not work fully in Qt WebEngineView due to an inherent limitation in how Qt forwards mouse events to the browser's CSS engine.
+
+This is not a defect in WebDrop Bridge, but rather a limitation of embedding web content in Qt applications. The web application works perfectly in standard browsers like Chrome.
+
+---
+
+**Status**: Issue Closed - Limitation Documented
+**Last Updated**: March 4, 2026
+**Severity**: Low (UI-only, core functionality unaffected)
diff --git a/docs/PACKAGE_MANAGER_SUPPORT.md b/docs/PACKAGE_MANAGER_SUPPORT.md
new file mode 100644
index 0000000..e49d914
--- /dev/null
+++ b/docs/PACKAGE_MANAGER_SUPPORT.md
@@ -0,0 +1,391 @@
+# Package Manager Support for WebDropBridge
+
+This document explains how to build and publish WebDropBridge to package managers like Chocolatey (Windows) and Homebrew (macOS).
+
+## Overview
+
+WebDropBridge supports installation via package managers, making it easier for users to install, update, and manage the application.
+
+| Package Manager | OS | Status | Directory |
+|-----------------|-----|--------|-----------|
+| **Chocolatey** | Windows | Supported | `build/chocolatey/` |
+| **Homebrew** | macOS | Supported | `build/homebrew/` |
+| **Winget** | Windows | Optional | Future |
+
+## Quick Start: Simplest Approach (Direct Distribution)
+
+**No infrastructure or accounts needed** - just build once and share:
+
+```powershell
+# 1. Build the Chocolatey package
+cd build/chocolatey
+python ../../build/scripts/build_windows.py --msi
+certutil -hashfile "../../build/dist/windows/WebDropBridge_Setup.msi" SHA256
+# Update checksum in tools/chocolateyInstall.ps1
+choco pack webdrop-bridge.nuspec
+
+# 2. Share webdrop-bridge.0.8.0.nupkg
+# File share: \\server\packages\
+# USB drive, email, Forgejo releases, etc.
+
+# 3. Users install it
+# choco install webdrop-bridge.0.8.0.nupkg -s "\\server\packages"
+```
+
+**Advantages:**
+- ✅ No accounts or external infrastructure
+- ✅ Works in air-gapped/offline environments
+- ✅ Simple one-time setup
+- ✅ Version management through file shares
+
+**For centralized distribution**, see Options 1-3 below.
+
+---
+
+## Chocolatey (Windows)
+
+### Prerequisites
+
+- Chocolatey installed: https://chocolatey.org/install
+- (Only for public community repo) Chocolatey maintainer account at chocolatey.org
+
+### Building the Chocolatey Package
+
+```bash
+# 1. Build MSI installer first
+python build/scripts/build_windows.py --msi
+
+# 2. Calculate SHA256 checksum of the MSI
+certutil -hashfile "build/dist/windows/WebDropBridge_Setup.msi" SHA256
+
+# 3. Update the checksum in build/chocolatey/tools/chocolateyInstall.ps1
+# Replace: $Checksum = ''
+# With: $Checksum = 'YOUR_SHA256_HASH'
+
+# 4. Update version in chocolatey/webdrop-bridge.nuspec
+# 0.8.0
+
+# 5. Create the package
+cd build/chocolatey
+choco pack webdrop-bridge.nuspec
+```
+
+This creates `webdrop-bridge.0.8.0.nupkg`
+
+### Publishing to Chocolatey
+
+**Option 1: Internal NuGet Repository (Recommended for HIM)**
+
+Host on your own NuGet server (Azure Artifacts, Artifactory, ProGet, etc.):
+
+```powershell
+# Configure Chocolatey to use internal repository
+choco source add -n=internal-repo -s "https://your-artifactory.internal/nuget/chocolatey/"
+
+# Push package to internal repo
+nuget push webdrop-bridge.0.8.0.nupkg -Source https://your-artifactory.internal/nuget/chocolatey/ -ApiKey YOUR_API_KEY
+
+# Users install from internal repo (already configured)
+choco install webdrop-bridge
+```
+
+**Option 2: Community Repository (chocolatey.org)**
+
+If you want public distribution (requires community maintainer account):
+
+```bash
+# Push to community repo
+choco push webdrop-bridge.0.8.0.nupkg --api-key YOUR_CHOCOLATEY_API_KEY
+```
+
+**Option 3: No Repository (Direct Distribution)**
+
+Share the `.nupkg` file directly, users install locally:
+
+```powershell
+# User downloads webdrop-bridge.0.8.0.nupkg and runs:
+choco install webdrop-bridge.0.8.0.nupkg -s C:\path\to\package\folder
+```
+
+### User Installation
+
+Depending on your chosen distribution:
+
+```powershell
+# If using internal repository
+choco install webdrop-bridge
+
+# If using community repo (chocolatey.org)
+choco install webdrop-bridge
+
+# If distributing directly
+choco install webdrop-bridge.0.8.0.nupkg -s "\\network\share\packages"
+```
+
+## Homebrew (macOS)
+
+### Prerequisites
+
+- Homebrew installed: https://brew.sh
+- GitHub or Gitea account for hosting tap repository
+
+### Two Approaches
+
+#### Option A: Local Tap (Recommended for HIM)
+
+Create a custom tap repository to distribute your formula without submitting to official Homebrew.
+
+**Setup:**
+
+```bash
+# Create tap repository
+mkdir homebrew-webdrop-bridge
+cd homebrew-webdrop-bridge
+
+# Create structure
+mkdir -p Formula
+cp ../build/homebrew/webdrop-bridge.rb Formula/
+
+# Initialize git repo and push to Forgejo
+git init
+git add .
+git commit -m "Add webdrop-bridge formula"
+git remote add origin https://git.him-tools.de/HIM-public/homebrew-webdrop-bridge.git
+git push -u origin main
+```
+
+**User Installation:**
+
+```bash
+# Add tap
+brew tap HIM-public/webdrop-bridge https://git.him-tools.de/HIM-public/homebrew-webdrop-bridge.git
+
+# Install
+brew install webdrop-bridge
+
+# Upgrade
+brew upgrade webdrop-bridge
+```
+
+#### Option B: Official Homebrew Repository
+
+Submit to `homebrew/casks` (requires more maintenance but no separate tap):
+
+1. Fork https://github.com/Homebrew/homebrew-casks
+2. Create pull request with Cask file
+3. Homebrew maintainers review and merge
+4. Users install via `brew install --cask webdrop-bridge`
+
+### Building the Homebrew Package (Locally)
+
+```bash
+# 1. Build DMG installer
+bash build/scripts/build_macos.sh
+
+# 2. Calculate SHA256 checksum
+shasum -a 256 "build/dist/macos/WebDropBridge_Setup.dmg"
+
+# 3. Update formula with checksum and URL
+# build/homebrew/webdrop-bridge.rb
+# - url: https://git.him-tools.de/...releases/download/vX.X.X/WebDropBridge_Setup.dmg
+# - sha256: YOUR_SHA256_HASH
+```
+
+### Testing Homebrew Formula Locally
+
+```bash
+# Validate formula syntax
+brew audit --formula build/homebrew/webdrop-bridge.rb
+
+# Install from local formula
+brew install build/homebrew/webdrop-bridge.rb
+
+# Verify installation
+brew list webdrop-bridge
+webdrop-bridge --version # If CLI exists, or check Applications folder
+```
+
+## Publishing Workflow
+
+### Step 1: Build Release
+
+```bash
+# Release v0.8.0
+
+# Windows MSI
+python build/scripts/build_windows.py --msi
+
+# macOS DMG
+bash build/scripts/build_macos.sh
+```
+
+### Step 2: Create Forgejo Release
+
+Tag and upload installers to Forgejo:
+
+```bash
+git tag -a v0.8.0 -m "Release 0.8.0"
+git push upstream v0.8.0
+
+# Upload MSI and DMG to Forgejo release page
+```
+
+### Step 3: Calculate Checksums
+
+```bash
+# Windows
+certutil -hashfile WebDropBridge_Setup.msi SHA256
+
+# macOS
+shasum -a 256 WebDropBridge_Setup.dmg
+```
+
+### Step 4: Update Package Manager Files
+
+**Chocolatey** (`build/chocolatey/tools/chocolateyInstall.ps1`):
+```powershell
+$Checksum = 'WINDOWS_SHA256_HASH'
+```
+
+**Homebrew** (`build/homebrew/webdrop-bridge.rb`):
+```ruby
+sha256 "MACOS_SHA256_HASH"
+```
+
+### Step 5: Test Package Installation
+
+**Chocolatey:**
+```powershell
+cd build/chocolatey
+choco pack
+choco install webdrop-bridge.0.8.0.nupkg -s .
+```
+
+**Homebrew (with tap):**
+```bash
+brew install ./build/homebrew/webdrop-bridge.rb
+```
+
+### Step 6: Publish
+
+**Chocolatey:**
+```powershell
+choco push webdrop-bridge.0.8.0.nupkg --api-key YOUR_KEY
+```
+
+**Homebrew:**
+- If using local tap: Push to Forgejo repository
+- If using official: Submit pull request to homebrew-casks
+
+## Update Workflow
+
+### For Subsequent Releases (e.g., v0.9.0)
+
+1. Build new installers (MSI/DMG)
+2. Create Forgejo release with new version
+3. Calculate new checksums
+4. Update version and checksums in:
+ - `build/chocolatey/webdrop-bridge.nuspec`
+ - `build/chocolatey/tools/chocolateyInstall.ps1`
+ - `build/homebrew/webdrop-bridge.rb`
+5. Test locally
+6. Publish to package managers
+
+## Configuration in Package Managers
+
+### Chocolatey
+
+Located in: `build/chocolatey/tools/chocolateyInstall.ps1`
+
+Key variables to update per release:
+- `$Version` - Application version
+- `$Url` - Download URL (Forgejo release)
+- `$Checksum` - SHA256 hash of MSI
+- `$ChecksumType` - Type of hash (sha256)
+
+### Homebrew
+
+Located in: `build/homebrew/webdrop-bridge.rb`
+
+Key variables to update per release:
+- `version` - Application version
+- `url` - Download URL (Forgejo release)
+- `sha256` - SHA256 hash of DMG
+
+## Automatic Updates
+
+### Via Package Managers
+
+When users install via Chocolatey/Homebrew, they receive updates through:
+
+```bash
+# Chocolatey
+choco upgrade webdrop-bridge
+
+# Homebrew
+brew upgrade webdrop-bridge
+```
+
+### Built-in Auto-Update (Fallback)
+
+WebDropBridge also includes built-in auto-update mechanism that:
+1. Checks Forgejo releases API on startup
+2. Notifies user of available updates
+3. Downloads and installs directly (bypasses package manager)
+
+This works for:
+- Direct downloads via wget
+- Standalone installer use
+- Users who skip package manager route
+
+## Troubleshooting
+
+### Chocolatey Issues
+
+**Package won't install:**
+- Verify checksum: `certutil -hashfile WebDropBridge_Setup.msi SHA256`
+- Check MSI exists at URL: `wget URL`
+- Verify SHA256 matches in `chocolateyInstall.ps1`
+
+**Uninstall fails:**
+- Try manual uninstall first
+- Then recreate the Chocolatey package
+
+### Homebrew Issues
+
+**Formula won't install:**
+- Validate syntax: `brew audit --formula webdrop-bridge.rb`
+- Check URL is accessible: `curl -I URL`
+- Verify SHA256: `shasum -a 256 WebDropBridge_Setup.dmg`
+
+**Upgrade fails:**
+- Remove old version: `brew uninstall webdrop-bridge`
+- Reinstall: `brew install webdrop-bridge`
+
+## References
+
+- **Chocolatey Documentation**: https://docs.chocolatey.org/
+- **Homebrew Formula Reference**: https://docs.brew.sh/Formula-Cookbook
+- **Homebrew Cask**: https://docs.brew.sh/Cask-Cookbook
+- **Forgejo Releases**: https://git.him-tools.de/HIM-public/webdrop-bridge/releases
+
+---
+
+**Distribution Strategy Options for HIM:**
+
+1. **Easiest: Direct Distribution** ✅
+ - Share `.nupkg` file via file share or email
+ - Users: `choco install webdrop-bridge.0.8.0.nupkg -s "\\share\packages"`
+ - No infrastructure needed
+ - No maintainer account required
+
+2. **Better: Internal NuGet Repository** ✅ (Recommended)
+ - Host on Azure Artifacts or Artifactory
+ - Professional package management
+ - Automatic updates with `choco upgrade`
+ - Users: `choco install webdrop-bridge` (pre-configured)
+
+3. **Public: Chocolatey Community** (Optional)
+ - Publish to chocolatey.org (requires maintainer account + vetting)
+ - Widest distribution
+ - Public users: `choco install webdrop-bridge`
diff --git a/docs/TRANSLATIONS_GUIDE.md b/docs/TRANSLATIONS_GUIDE.md
new file mode 100644
index 0000000..7896c88
--- /dev/null
+++ b/docs/TRANSLATIONS_GUIDE.md
@@ -0,0 +1,205 @@
+# Translations Guide (i18n)
+
+This document explains how to:
+- add a new language
+- edit an existing language
+- update translations when new text is added in the app
+
+The app uses JSON-based translations loaded from:
+- resources/translations/
+
+## 1. Translation System Overview
+
+Main components:
+- src/webdrop_bridge/utils/i18n.py
+ - Loads language JSON files
+ - Provides tr("key", **kwargs)
+ - Falls back to English if a key is missing
+- src/webdrop_bridge/main.py
+ - Initializes i18n at app startup
+- src/webdrop_bridge/config.py
+ - Stores selected language in config (language field)
+- src/webdrop_bridge/ui/settings_dialog.py
+ - Language selector in Settings -> General
+
+Current language files:
+- resources/translations/en.json
+- resources/translations/de.json
+- resources/translations/fr.json
+- resources/translations/it.json
+- resources/translations/ru.json
+- resources/translations/zh.json
+
+## 2. Add a New Language
+
+Example: add Spanish (es).
+
+1. Create a new file:
+ - resources/translations/es.json
+
+2. Copy the full structure from English:
+ - Copy resources/translations/en.json to resources/translations/es.json
+
+3. Translate all values in es.json:
+ - Keep all keys exactly the same
+ - Only change text values
+ - Keep placeholders unchanged, for example:
+ - {name}
+ - {version}
+ - {error}
+
+4. Add language display name in i18n helper:
+ - Edit src/webdrop_bridge/utils/i18n.py
+ - In Translator.BUILTIN_LANGUAGES add:
+ - "es": "Español"
+
+5. Start app and test:
+ - Choose language in Settings -> General
+ - Restart app when prompted
+ - Verify tooltips, dialogs, status texts, settings labels, update dialogs
+
+## 3. Edit an Existing Language
+
+1. Open the language file, for example:
+ - resources/translations/de.json
+
+2. Update only text values.
+
+3. Do not:
+ - remove keys
+ - rename keys
+ - change placeholder names
+
+4. Validate JSON formatting:
+ - Must be valid JSON
+ - Keep UTF-8 encoding
+
+5. Test in app:
+ - Select language in Settings
+ - Restart and verify changed text appears
+
+## 4. When New Text Is Added in the App
+
+Whenever new UI text is introduced in code, follow this process.
+
+### Step A: Add a new translation key in code
+
+Instead of hardcoded text, use tr("...") with a key.
+
+Example:
+- Before: QLabel("Check for Updates")
+- After: QLabel(tr("toolbar.tooltip.check_updates"))
+
+If dynamic text is needed:
+- tr("update.status.available", version=release.version)
+
+### Step B: Add the key to English first
+
+1. Add the new key in:
+ - resources/translations/en.json
+
+2. Use clear key naming by area, for example:
+- toolbar.tooltip.*
+- dialog.*
+- settings.*
+- update.*
+- status.*
+- worker.*
+
+### Step C: Add the same key to all other language files
+
+Update each file in resources/translations:
+- de.json
+- fr.json
+- it.json
+- ru.json
+- zh.json
+- and any new language file
+
+If translation is not ready yet, copy English temporarily (better than missing key text in UI).
+
+### Step D: Test fallback and real translations
+
+1. Run app in English and verify new text.
+2. Run app in other languages and verify translated text.
+3. Confirm no raw key appears in UI (for example: dialog.my_new_key).
+
+## 5. Placeholder Rules
+
+Placeholders must match exactly between code and translation values.
+
+If code uses:
+- tr("status.opened", name=file_name)
+
+Then translation must contain:
+- "status.opened": "Opened: {name}"
+
+Common mistakes:
+- wrong placeholder name ({filename} vs {name})
+- missing placeholder
+- extra placeholder not passed by code
+
+## 6. Recommended Workflow for Translation Updates
+
+1. Implement UI text with tr("key") in code.
+2. Add key to en.json.
+3. Copy key to all language files.
+4. Run tests.
+5. Smoke test manually in app.
+
+Useful test command:
+- python -m pytest tests/unit/test_i18n.py -q
+
+Recommended additional checks when UI changed:
+- python -m pytest tests/unit/test_settings_dialog.py tests/unit/test_update_manager_ui.py tests/unit/test_startup_check.py -q
+
+## 7. Troubleshooting
+
+### Problem: Language changed in settings but UI language did not change
+
+Expected behavior:
+- language is applied after restart
+
+Check:
+- language value saved in config file
+- restart prompt appears after changing language
+- selected language JSON file exists and is valid
+
+### Problem: UI shows translation key text instead of real text
+
+Example shown in UI:
+- settings.title
+
+Cause:
+- key missing in selected language and missing in en.json fallback
+
+Fix:
+- add key to en.json
+- add key to selected language file
+
+### Problem: Text formatting errors
+
+Cause:
+- placeholder mismatch
+
+Fix:
+- compare tr(...) arguments in code with placeholders in translation string
+
+## 8. Best Practices
+
+- Keep en.json as complete source of truth.
+- Keep key names stable once released.
+- Group keys by feature area.
+- Prefer short, user-friendly text in UI.
+- Use formal, consistent tone per language.
+- Review non-Latin languages (RU/ZH) with a native speaker when possible.
+
+## 9. Quick Checklist
+
+When adding new text:
+- Add tr("new.key") in code
+- Add key in en.json
+- Add key in all other language files
+- Verify placeholders
+- Run i18n and impacted UI tests
+- Manual in-app check with at least one non-English language
diff --git a/resources/icons/home.ico b/resources/icons/home.ico
new file mode 100644
index 0000000..e080469
Binary files /dev/null and b/resources/icons/home.ico differ
diff --git a/resources/icons/open.ico b/resources/icons/open.ico
new file mode 100644
index 0000000..1b6fed8
Binary files /dev/null and b/resources/icons/open.ico differ
diff --git a/resources/icons/openwith.ico b/resources/icons/openwith.ico
new file mode 100644
index 0000000..3facabc
Binary files /dev/null and b/resources/icons/openwith.ico differ
diff --git a/resources/icons/reload.ico b/resources/icons/reload.ico
new file mode 100644
index 0000000..1f1023d
Binary files /dev/null and b/resources/icons/reload.ico differ
diff --git a/resources/translations/de.json b/resources/translations/de.json
new file mode 100644
index 0000000..d37c9a8
--- /dev/null
+++ b/resources/translations/de.json
@@ -0,0 +1,172 @@
+{
+ "toolbar.tooltip.open_drop": "Datei hier ablegen, um sie mit der Standardanwendung zu \u00f6ffnen",
+ "toolbar.tooltip.open_with_drop": "Datei hier ablegen, um die \u00d6ffnen-mit-App auszuw\u00e4hlen",
+ "toolbar.tooltip.home": "Startseite",
+ "toolbar.tooltip.about": "\u00dcber WebDrop Bridge",
+ "toolbar.tooltip.settings": "Einstellungen",
+ "toolbar.tooltip.check_updates": "Nach Updates suchen",
+ "toolbar.tooltip.clear_cache": "Cache und Cookies l\u00f6schen",
+ "toolbar.tooltip.open_log": "Protokolldatei \u00f6ffnen",
+ "toolbar.tooltip.dev_tools": "Entwicklerwerkzeuge (F12)",
+
+ "status.ready": "Bereit",
+ "status.opened": "Ge\u00f6ffnet: {name}",
+ "status.choose_app": "App ausw\u00e4hlen f\u00fcr: {name}",
+ "status.download_started": "\ud83d\udce5 Download: {filename}",
+ "status.download_completed": "Download abgeschlossen: {name}",
+ "status.download_cancelled": "\u26a0\ufe0f Download abgebrochen: {name}",
+ "status.download_failed": "\u274c Download fehlgeschlagen: {name}",
+ "status.download_error": "Downloadfehler: {error}",
+
+ "update.status.checking": "Suche nach Updates",
+ "update.status.ready": "Bereit",
+ "update.status.available": "Update verf\u00fcgbar: v{version}",
+ "update.status.deferred": "Update verschoben",
+ "update.status.downloading": "Lade v{version} herunter",
+ "update.status.verifying": "Pr\u00fcfe Download",
+ "update.status.download_failed": "Download fehlgeschlagen",
+ "update.status.verification_failed": "Pr\u00fcfung fehlgeschlagen",
+ "update.status.timed_out": "Zeitüberschreitung",
+ "update.status.ready_to_install": "Bereit zur Installation",
+ "update.status.installation_started": "Installation gestartet",
+ "update.status.installation_failed": "Installation fehlgeschlagen",
+ "update.status.check_timed_out": "Zeitüberschreitung \u2013 keine Serverantwort",
+ "update.status.check_failed": "Fehler: {error}",
+ "update.status.download_timed_out": "Zeitüberschreitung beim Download",
+
+ "dialog.error.title": "Fehler",
+ "dialog.log_not_found.title": "Protokolldatei nicht gefunden",
+ "dialog.log_not_found.msg": "Keine Protokolldatei gefunden unter:\n{log_file}",
+ "dialog.cache_cleared.title": "Cache geleert",
+ "dialog.cache_cleared.msg": "Browser-Cache und Cookies wurden erfolgreich geleert.\n\nBitte laden Sie die Seite neu oder starten Sie die Anwendung neu, damit die \u00c4nderungen wirksam werden.",
+ "dialog.cache_clear_failed.title": "Fehler",
+ "dialog.cache_clear_failed.msg": "Fehler beim Leeren von Cache und Cookies: {error}",
+ "dialog.drag_error.title": "Drag-and-Drop-Fehler",
+ "dialog.drag_error.msg": "Der Drag-and-Drop-Vorgang konnte nicht abgeschlossen werden.\n\nFehler: {error}",
+ "dialog.open_file_error.title": "Fehler beim \u00d6ffnen",
+ "dialog.open_file_error.msg": "Die Datei konnte nicht mit der Standardanwendung ge\u00f6ffnet werden.\n\nDatei: {file_path}\nFehler: {error}",
+ "dialog.open_with_error.title": "\u00d6ffnen mit \u2013 Fehler",
+ "dialog.open_with_error.msg": "Auf dieser Plattform konnte kein Anwendungsauswahldialog ge\u00f6ffnet werden.",
+ "dialog.dev_tools.window_title": "\ud83d\udd27 Entwicklerwerkzeuge",
+ "dialog.dev_tools.error_title": "Entwicklerwerkzeuge",
+ "dialog.dev_tools.error_msg": "Entwicklerwerkzeuge konnten nicht ge\u00f6ffnet werden:\n{error}",
+ "dialog.domain_changed.title": "Domain ge\u00e4ndert \u2013 Neustart empfohlen",
+ "dialog.domain_changed.msg": "Die Web-Anwendungs-Domain wurde ge\u00e4ndert\n\nSie haben zu einer anderen Domain gewechselt. F\u00fcr maximale Stabilit\u00e4t und korrekte Authentifizierung sollte die Anwendung neu gestartet werden.\n\nProfil und Cache wurden geleert, aber ein Neustart wird empfohlen.",
+ "dialog.domain_changed.restart_now": "Jetzt neu starten",
+ "dialog.domain_changed.restart_later": "Sp\u00e4ter neu starten",
+ "dialog.language_changed.title": "Sprache ge\u00e4ndert",
+ "dialog.language_changed.msg": "Die Spracheinstellung wurde aktualisiert. Starten Sie jetzt neu, um die ausgew\u00e4hlte Sprache \u00fcberall anzuwenden.",
+ "dialog.language_changed.restart_now": "Jetzt neu starten",
+ "dialog.language_changed.restart_later": "Sp\u00e4ter neu starten",
+ "dialog.restart_failed.title": "Neustart fehlgeschlagen",
+ "dialog.restart_failed.msg": "Die Anwendung konnte nicht automatisch neu gestartet werden:\n\n{error}\n\nBitte starten Sie manuell neu.",
+ "dialog.update_timeout.title": "Zeitüberschreitung bei der Update-Pr\u00fcfung",
+ "dialog.update_timeout.msg": "Der Server hat nicht innerhalb von 30 Sekunden geantwortet.\n\nM\u00f6glicherweise liegt ein Netzwerkproblem oder eine Serverunavailability vor.\n\nBitte \u00fcberpr\u00fcfen Sie Ihre Verbindung und versuchen Sie es erneut.",
+ "dialog.update_failed.title": "Update-Pr\u00fcfung fehlgeschlagen",
+ "dialog.update_failed.msg": "Updates konnten nicht gepr\u00fcft werden:\n\n{error}\n\nBitte versuchen Sie es sp\u00e4ter erneut.",
+ "dialog.download_failed.title": "Download fehlgeschlagen",
+ "dialog.download_failed.msg": "Das Update konnte nicht heruntergeladen werden:\n\n{error}\n\nBitte versuchen Sie es sp\u00e4ter erneut.",
+ "dialog.checkout.title": "Asset auschecken",
+ "dialog.checkout.msg": "M\u00f6chten Sie dieses Asset auschecken?\n\n{filename}",
+
+ "about.title": "\u00dcber {app_name}",
+ "about.version": "Version: {version}",
+ "about.description": "Verbindet webbasierte Drag-and-Drop-Workflows mit nativen Dateioperationen f\u00fcr professionelle Desktop-Anwendungen.",
+ "about.drop_zones_title": "Toolbar-Ablagezonen:",
+ "about.open_icon_desc": "\u00d6ffnen-Symbol: \u00d6ffnet abgelegte Dateien mit der Standard-App.",
+ "about.open_with_icon_desc": "\u00d6ffnen-mit-Symbol: Zeigt einen App-Auswahldialog f\u00fcr abgelegte Dateien.",
+ "about.product_of": "Ein Produkt von:",
+ "about.rights": "\u00a9 2026 h\u00f6rl Information Management GmbH. Alle Rechte vorbehalten.",
+
+ "settings.title": "Einstellungen",
+ "settings.tab.web_source": "Web-Quelle",
+ "settings.tab.paths": "Pfade",
+ "settings.tab.urls": "URLs",
+ "settings.tab.logging": "Protokollierung",
+ "settings.tab.window": "Fenster",
+ "settings.tab.profiles": "Profile",
+ "settings.tab.general": "Allgemein",
+ "settings.web_url.label": "Web-Anwendungs-URL:",
+ "settings.web_url.placeholder": "z.B. http://localhost:8080 oder file:///./webapp/index.html",
+ "settings.web_url.open_btn": "\u00d6ffnen",
+ "settings.url_mappings.label": "URL-Zuordnungen (Azure Blob Storage \u2192 Lokale Pfade):",
+ "settings.url_mappings.col_prefix": "URL-Pr\u00e4fix",
+ "settings.url_mappings.col_path": "Lokaler Pfad",
+ "settings.url_mappings.add_btn": "Zuordnung hinzuf\u00fcgen",
+ "settings.url_mappings.edit_btn": "Auswahl bearbeiten",
+ "settings.url_mappings.remove_btn": "Auswahl entfernen",
+ "settings.paths.label": "Erlaubte Stammverzeichnisse f\u00fcr den Dateizugriff:",
+ "settings.paths.add_btn": "Pfad hinzuf\u00fcgen",
+ "settings.paths.remove_btn": "Auswahl entfernen",
+ "settings.urls.label": "Erlaubte Web-URLs (unterst\u00fctzt Platzhalter wie http://*.example.com):",
+ "settings.urls.add_btn": "URL hinzuf\u00fcgen",
+ "settings.urls.remove_btn": "Auswahl entfernen",
+ "settings.log_level.label": "Protokollstufe:",
+ "settings.log_file.label": "Protokolldatei (optional):",
+ "settings.log_file.browse_btn": "Durchsuchen...",
+ "settings.window.width_label": "Fensterbreite:",
+ "settings.window.height_label": "Fensterh\u00f6he:",
+ "settings.profiles.label": "Gespeicherte Konfigurationsprofile:",
+ "settings.profiles.save_btn": "Als Profil speichern",
+ "settings.profiles.load_btn": "Profil laden",
+ "settings.profiles.delete_btn": "Profil l\u00f6schen",
+ "settings.profiles.export_btn": "Konfiguration exportieren",
+ "settings.profiles.import_btn": "Konfiguration importieren",
+ "settings.general.language_label": "Sprache:",
+ "settings.general.language_auto": "Systemstandard (Auto)",
+ "settings.general.language_restart_note": "Sprach\u00e4nderung wirksam nach Neustart.",
+ "settings.add_mapping.url_title": "URL-Zuordnung hinzuf\u00fcgen",
+ "settings.add_mapping.url_prompt": "Azure Blob Storage URL-Pr\u00e4fix eingeben:\n(z.B. https://myblob.blob.core.windows.net/container/)",
+ "settings.add_mapping.path_prompt": "Lokalen Dateisystempfad eingeben:\n(z.B. C:\\Freigabe oder /mnt/share)",
+ "settings.edit_mapping.title": "URL-Zuordnung bearbeiten",
+ "settings.edit_mapping.url_prompt": "Azure Blob Storage URL-Pr\u00e4fix eingeben:",
+ "settings.edit_mapping.path_prompt": "Lokalen Dateisystempfad eingeben:",
+ "settings.add_url.title": "URL hinzuf\u00fcgen",
+ "settings.add_url.prompt": "URL-Muster eingeben (z.B. http://example.com oder http://*.example.com):",
+ "settings.profile.save.title": "Profil speichern",
+ "settings.profile.save.prompt": "Profilnamen eingeben (z.B. Arbeit, Privat):",
+ "settings.select_directory.title": "Verzeichnis ausw\u00e4hlen",
+ "settings.select_log_file.title": "Protokolldatei ausw\u00e4hlen",
+ "settings.export_config.title": "Konfiguration exportieren",
+ "settings.import_config.title": "Konfiguration importieren",
+ "settings.error.select_mapping": "Bitte w\u00e4hlen Sie eine Zuordnung zur Bearbeitung aus",
+ "settings.error.select_profile_load": "Bitte w\u00e4hlen Sie ein Profil zum Laden aus",
+ "settings.error.select_profile_delete": "Bitte w\u00e4hlen Sie ein Profil zum L\u00f6schen aus",
+
+ "update.checking.title": "Update-Pr\u00fcfung",
+ "update.checking.label": "Suche nach Updates...",
+ "update.checking.timeout_info": "Dies kann bis zu 10 Sekunden dauern",
+ "update.available.title": "Update verf\u00fcgbar",
+ "update.available.header": "WebDrop Bridge v{version} ist verf\u00fcgbar",
+ "update.available.changelog_label": "Versionshinweise:",
+ "update.available.update_now_btn": "Jetzt aktualisieren",
+ "update.available.later_btn": "Sp\u00e4ter",
+ "update.downloading.title": "Update wird heruntergeladen",
+ "update.downloading.header": "Update wird heruntergeladen...",
+ "update.downloading.preparing": "Download wird vorbereitet",
+ "update.downloading.filename": "Lade herunter: {filename}",
+ "update.downloading.cancel_btn": "Abbrechen",
+ "update.install.title": "Update installieren",
+ "update.install.header": "Bereit zur Installation",
+ "update.install.message": "Das Update ist zur Installation bereit. Die Anwendung wird neu gestartet.",
+ "update.install.warning": "\u26a0\ufe0f Bitte speichern Sie alle nicht gespeicherten Arbeiten vor dem Fortfahren.\nDie Anwendung wird geschlossen und neu gestartet.",
+ "update.install.now_btn": "Jetzt installieren",
+ "update.install.cancel_btn": "Abbrechen",
+ "update.no_update.title": "Keine Updates verf\u00fcgbar",
+ "update.no_update.message": "\u2713 Sie verwenden die neueste Version",
+ "update.no_update.info": "WebDrop Bridge ist auf dem neuesten Stand.",
+ "update.no_update.ok_btn": "OK",
+ "update.error.title": "Update fehlgeschlagen",
+ "update.error.header": "\u26a0\ufe0f Update fehlgeschlagen",
+ "update.error.info": "Bitte versuchen Sie es erneut oder besuchen Sie die Website, um das Update manuell herunterzuladen.",
+ "update.error.retry_btn": "Wiederholen",
+ "update.error.manual_btn": "Manuell herunterladen",
+ "update.error.cancel_btn": "Abbrechen",
+
+ "worker.server_not_responding": "Server antwortet nicht \u2013 bitte sp\u00e4ter erneut pr\u00fcfen",
+ "worker.no_installer": "Kein Installationspaket in der Version gefunden",
+ "worker.checksum_failed": "Pr\u00fcfsummenverifizierung fehlgeschlagen",
+ "worker.download_timed_out": "Zeitüberschreitung beim Download oder der Verifizierung",
+ "worker.download_error": "Downloadfehler: {error}",
+ "worker.check_failed": "Pr\u00fcfung fehlgeschlagen: {error}"
+}
diff --git a/resources/translations/en.json b/resources/translations/en.json
new file mode 100644
index 0000000..27cfa09
--- /dev/null
+++ b/resources/translations/en.json
@@ -0,0 +1,172 @@
+{
+ "toolbar.tooltip.open_drop": "Drop a file here to open it with its default application",
+ "toolbar.tooltip.open_with_drop": "Drop a file here to choose which app should open it",
+ "toolbar.tooltip.home": "Home",
+ "toolbar.tooltip.about": "About WebDrop Bridge",
+ "toolbar.tooltip.settings": "Settings",
+ "toolbar.tooltip.check_updates": "Check for Updates",
+ "toolbar.tooltip.clear_cache": "Clear Cache and Cookies",
+ "toolbar.tooltip.open_log": "Open Log File",
+ "toolbar.tooltip.dev_tools": "Developer Tools (F12)",
+
+ "status.ready": "Ready",
+ "status.opened": "Opened: {name}",
+ "status.choose_app": "Choose app for: {name}",
+ "status.download_started": "\ud83d\udce5 Download: {filename}",
+ "status.download_completed": "Download completed: {name}",
+ "status.download_cancelled": "\u26a0\ufe0f Download cancelled: {name}",
+ "status.download_failed": "\u274c Download failed: {name}",
+ "status.download_error": "Download error: {error}",
+
+ "update.status.checking": "Checking for updates",
+ "update.status.ready": "Ready",
+ "update.status.available": "Update available: v{version}",
+ "update.status.deferred": "Update deferred",
+ "update.status.downloading": "Downloading v{version}",
+ "update.status.verifying": "Verifying download",
+ "update.status.download_failed": "Download failed",
+ "update.status.verification_failed": "Verification failed",
+ "update.status.timed_out": "Operation timed out",
+ "update.status.ready_to_install": "Ready to install",
+ "update.status.installation_started": "Installation started",
+ "update.status.installation_failed": "Installation failed",
+ "update.status.check_timed_out": "Check timed out - no server response",
+ "update.status.check_failed": "Check failed: {error}",
+ "update.status.download_timed_out": "Download timed out - no server response",
+
+ "dialog.error.title": "Error",
+ "dialog.log_not_found.title": "Log File Not Found",
+ "dialog.log_not_found.msg": "No log file found at:\n{log_file}",
+ "dialog.cache_cleared.title": "Cache Cleared",
+ "dialog.cache_cleared.msg": "Browser cache and cookies have been cleared successfully.\n\nYou may need to reload the page or restart the application for changes to take effect.",
+ "dialog.cache_clear_failed.title": "Error",
+ "dialog.cache_clear_failed.msg": "Failed to clear cache and cookies: {error}",
+ "dialog.drag_error.title": "Drag-and-Drop Error",
+ "dialog.drag_error.msg": "Could not complete the drag-and-drop operation.\n\nError: {error}",
+ "dialog.open_file_error.title": "Open File Error",
+ "dialog.open_file_error.msg": "Could not open the file with its default application.\n\nFile: {file_path}\nError: {error}",
+ "dialog.open_with_error.title": "Open With Error",
+ "dialog.open_with_error.msg": "Could not open an application chooser for this file on your platform.",
+ "dialog.dev_tools.window_title": "\ud83d\udd27 Developer Tools",
+ "dialog.dev_tools.error_title": "Developer Tools",
+ "dialog.dev_tools.error_msg": "Could not open Developer Tools:\n{error}",
+ "dialog.domain_changed.title": "Domain Changed - Restart Recommended",
+ "dialog.domain_changed.msg": "Web Application Domain Has Changed\n\nYou've switched to a different domain. For maximum stability and to ensure proper authentication, the application should be restarted.\n\nThe profile and cache have been cleared, but we recommend restarting.",
+ "dialog.domain_changed.restart_now": "Restart Now",
+ "dialog.domain_changed.restart_later": "Restart Later",
+ "dialog.language_changed.title": "Language Changed",
+ "dialog.language_changed.msg": "The language setting was updated. Restart now to apply the selected language everywhere.",
+ "dialog.language_changed.restart_now": "Restart Now",
+ "dialog.language_changed.restart_later": "Restart Later",
+ "dialog.restart_failed.title": "Restart Failed",
+ "dialog.restart_failed.msg": "Could not automatically restart the application:\n\n{error}\n\nPlease restart manually.",
+ "dialog.update_timeout.title": "Update Check Timeout",
+ "dialog.update_timeout.msg": "The server did not respond within 30 seconds.\n\nThis may be due to a network issue or server unavailability.\n\nPlease check your connection and try again.",
+ "dialog.update_failed.title": "Update Check Failed",
+ "dialog.update_failed.msg": "Could not check for updates:\n\n{error}\n\nPlease try again later.",
+ "dialog.download_failed.title": "Download Failed",
+ "dialog.download_failed.msg": "Could not download the update:\n\n{error}\n\nPlease try again later.",
+ "dialog.checkout.title": "Checkout Asset",
+ "dialog.checkout.msg": "Do you want to check out this asset?\n\n{filename}",
+
+ "about.title": "About {app_name}",
+ "about.version": "Version: {version}",
+ "about.description": "Bridges web-based drag-and-drop workflows with native file operations for professional desktop applications.",
+ "about.drop_zones_title": "Toolbar Drop Zones:",
+ "about.open_icon_desc": "Open icon: Opens dropped files with the system default app.",
+ "about.open_with_icon_desc": "Open-with icon: Shows an app chooser for dropped files.",
+ "about.product_of": "Product of:",
+ "about.rights": "\u00a9 2026 h\u00f6rl Information Management GmbH. All rights reserved.",
+
+ "settings.title": "Settings",
+ "settings.tab.web_source": "Web Source",
+ "settings.tab.paths": "Paths",
+ "settings.tab.urls": "URLs",
+ "settings.tab.logging": "Logging",
+ "settings.tab.window": "Window",
+ "settings.tab.profiles": "Profiles",
+ "settings.tab.general": "General",
+ "settings.web_url.label": "Web Application URL:",
+ "settings.web_url.placeholder": "e.g., http://localhost:8080 or file:///./webapp/index.html",
+ "settings.web_url.open_btn": "Open",
+ "settings.url_mappings.label": "URL Mappings (Azure Blob Storage \u2192 Local Paths):",
+ "settings.url_mappings.col_prefix": "URL Prefix",
+ "settings.url_mappings.col_path": "Local Path",
+ "settings.url_mappings.add_btn": "Add Mapping",
+ "settings.url_mappings.edit_btn": "Edit Selected",
+ "settings.url_mappings.remove_btn": "Remove Selected",
+ "settings.paths.label": "Allowed root directories for file access:",
+ "settings.paths.add_btn": "Add Path",
+ "settings.paths.remove_btn": "Remove Selected",
+ "settings.urls.label": "Allowed web URLs (supports wildcards like http://*.example.com):",
+ "settings.urls.add_btn": "Add URL",
+ "settings.urls.remove_btn": "Remove Selected",
+ "settings.log_level.label": "Log Level:",
+ "settings.log_file.label": "Log File (optional):",
+ "settings.log_file.browse_btn": "Browse...",
+ "settings.window.width_label": "Window Width:",
+ "settings.window.height_label": "Window Height:",
+ "settings.profiles.label": "Saved Configuration Profiles:",
+ "settings.profiles.save_btn": "Save as Profile",
+ "settings.profiles.load_btn": "Load Profile",
+ "settings.profiles.delete_btn": "Delete Profile",
+ "settings.profiles.export_btn": "Export Configuration",
+ "settings.profiles.import_btn": "Import Configuration",
+ "settings.general.language_label": "Language:",
+ "settings.general.language_auto": "System Default (Auto)",
+ "settings.general.language_restart_note": "Language change takes effect after restart.",
+ "settings.add_mapping.url_title": "Add URL Mapping",
+ "settings.add_mapping.url_prompt": "Enter Azure Blob Storage URL prefix:\n(e.g., https://myblob.blob.core.windows.net/container/)",
+ "settings.add_mapping.path_prompt": "Enter local file system path:\n(e.g., C:\\Share or /mnt/share)",
+ "settings.edit_mapping.title": "Edit URL Mapping",
+ "settings.edit_mapping.url_prompt": "Enter Azure Blob Storage URL prefix:",
+ "settings.edit_mapping.path_prompt": "Enter local file system path:",
+ "settings.add_url.title": "Add URL",
+ "settings.add_url.prompt": "Enter URL pattern (e.g., http://example.com or http://*.example.com):",
+ "settings.profile.save.title": "Save Profile",
+ "settings.profile.save.prompt": "Enter profile name (e.g., work, personal):",
+ "settings.select_directory.title": "Select Directory to Allow",
+ "settings.select_log_file.title": "Select Log File",
+ "settings.export_config.title": "Export Configuration",
+ "settings.import_config.title": "Import Configuration",
+ "settings.error.select_mapping": "Please select a mapping to edit",
+ "settings.error.select_profile_load": "Please select a profile to load",
+ "settings.error.select_profile_delete": "Please select a profile to delete",
+
+ "update.checking.title": "Checking for Updates",
+ "update.checking.label": "Checking for updates...",
+ "update.checking.timeout_info": "This may take up to 10 seconds",
+ "update.available.title": "Update Available",
+ "update.available.header": "WebDrop Bridge v{version} is available",
+ "update.available.changelog_label": "Release Notes:",
+ "update.available.update_now_btn": "Update Now",
+ "update.available.later_btn": "Later",
+ "update.downloading.title": "Downloading Update",
+ "update.downloading.header": "Downloading update...",
+ "update.downloading.preparing": "Preparing download",
+ "update.downloading.filename": "Downloading: {filename}",
+ "update.downloading.cancel_btn": "Cancel",
+ "update.install.title": "Install Update",
+ "update.install.header": "Ready to Install",
+ "update.install.message": "The update is ready to install. The application will restart.",
+ "update.install.warning": "\u26a0\ufe0f Please save any unsaved work before continuing.\nThe application will close and restart.",
+ "update.install.now_btn": "Install Now",
+ "update.install.cancel_btn": "Cancel",
+ "update.no_update.title": "No Updates Available",
+ "update.no_update.message": "\u2713 You're using the latest version",
+ "update.no_update.info": "WebDrop Bridge is up to date.",
+ "update.no_update.ok_btn": "OK",
+ "update.error.title": "Update Failed",
+ "update.error.header": "\u26a0\ufe0f Update Failed",
+ "update.error.info": "Please try again or visit the website to download the update manually.",
+ "update.error.retry_btn": "Retry",
+ "update.error.manual_btn": "Download Manually",
+ "update.error.cancel_btn": "Cancel",
+
+ "worker.server_not_responding": "Server not responding - check again later",
+ "worker.no_installer": "No installer found in release",
+ "worker.checksum_failed": "Checksum verification failed",
+ "worker.download_timed_out": "Download or verification timed out (no response from server)",
+ "worker.download_error": "Download error: {error}",
+ "worker.check_failed": "Check failed: {error}"
+}
diff --git a/resources/translations/fr.json b/resources/translations/fr.json
new file mode 100644
index 0000000..62d631d
--- /dev/null
+++ b/resources/translations/fr.json
@@ -0,0 +1,172 @@
+{
+ "toolbar.tooltip.open_drop": "D\u00e9posez un fichier ici pour l'ouvrir avec son application par d\u00e9faut",
+ "toolbar.tooltip.open_with_drop": "D\u00e9posez un fichier ici pour choisir l'application qui doit l'ouvrir",
+ "toolbar.tooltip.home": "Accueil",
+ "toolbar.tooltip.about": "\u00c0 propos de WebDrop Bridge",
+ "toolbar.tooltip.settings": "Param\u00e8tres",
+ "toolbar.tooltip.check_updates": "Rechercher des mises \u00e0 jour",
+ "toolbar.tooltip.clear_cache": "Vider le cache et les cookies",
+ "toolbar.tooltip.open_log": "Ouvrir le fichier journal",
+ "toolbar.tooltip.dev_tools": "Outils de d\u00e9veloppement (F12)",
+
+ "status.ready": "Pr\u00eat",
+ "status.opened": "Ouvert\u00a0: {name}",
+ "status.choose_app": "Choisir une app pour\u00a0: {name}",
+ "status.download_started": "\ud83d\udce5 T\u00e9l\u00e9chargement\u00a0: {filename}",
+ "status.download_completed": "T\u00e9l\u00e9chargement termin\u00e9\u00a0: {name}",
+ "status.download_cancelled": "\u26a0\ufe0f T\u00e9l\u00e9chargement annul\u00e9\u00a0: {name}",
+ "status.download_failed": "\u274c T\u00e9l\u00e9chargement \u00e9chou\u00e9\u00a0: {name}",
+ "status.download_error": "Erreur de t\u00e9l\u00e9chargement\u00a0: {error}",
+
+ "update.status.checking": "Recherche de mises \u00e0 jour",
+ "update.status.ready": "Pr\u00eat",
+ "update.status.available": "Mise \u00e0 jour disponible\u00a0: v{version}",
+ "update.status.deferred": "Mise \u00e0 jour diff\u00e9r\u00e9e",
+ "update.status.downloading": "T\u00e9l\u00e9chargement de v{version}",
+ "update.status.verifying": "V\u00e9rification du t\u00e9l\u00e9chargement",
+ "update.status.download_failed": "\u00c9chec du t\u00e9l\u00e9chargement",
+ "update.status.verification_failed": "\u00c9chec de la v\u00e9rification",
+ "update.status.timed_out": "D\u00e9lai d'attente d\u00e9pass\u00e9",
+ "update.status.ready_to_install": "Pr\u00eat \u00e0 installer",
+ "update.status.installation_started": "Installation d\u00e9marr\u00e9e",
+ "update.status.installation_failed": "\u00c9chec de l'installation",
+ "update.status.check_timed_out": "D\u00e9lai d\u00e9pass\u00e9 \u2013 aucune r\u00e9ponse du serveur",
+ "update.status.check_failed": "\u00c9chec\u00a0: {error}",
+ "update.status.download_timed_out": "D\u00e9lai d\u00e9pass\u00e9 lors du t\u00e9l\u00e9chargement",
+
+ "dialog.error.title": "Erreur",
+ "dialog.log_not_found.title": "Fichier journal introuvable",
+ "dialog.log_not_found.msg": "Aucun fichier journal trouv\u00e9 \u00e0\u00a0:\n{log_file}",
+ "dialog.cache_cleared.title": "Cache vid\u00e9",
+ "dialog.cache_cleared.msg": "Le cache et les cookies du navigateur ont \u00e9t\u00e9 vid\u00e9s avec succ\u00e8s.\n\nVous devrez peut-\u00eatre recharger la page ou red\u00e9marrer l'application pour que les modifications prennent effet.",
+ "dialog.cache_clear_failed.title": "Erreur",
+ "dialog.cache_clear_failed.msg": "Impossible de vider le cache et les cookies\u00a0: {error}",
+ "dialog.drag_error.title": "Erreur de glisser-d\u00e9poser",
+ "dialog.drag_error.msg": "Impossible de terminer l'op\u00e9ration de glisser-d\u00e9poser.\n\nErreur\u00a0: {error}",
+ "dialog.open_file_error.title": "Erreur d'ouverture",
+ "dialog.open_file_error.msg": "Impossible d'ouvrir le fichier avec son application par d\u00e9faut.\n\nFichier\u00a0: {file_path}\nErreur\u00a0: {error}",
+ "dialog.open_with_error.title": "Erreur Ouvrir avec",
+ "dialog.open_with_error.msg": "Impossible d'ouvrir un s\u00e9lecteur d'application sur cette plate-forme.",
+ "dialog.dev_tools.window_title": "\ud83d\udd27 Outils de d\u00e9veloppement",
+ "dialog.dev_tools.error_title": "Outils de d\u00e9veloppement",
+ "dialog.dev_tools.error_msg": "Impossible d'ouvrir les outils de d\u00e9veloppement\u00a0:\n{error}",
+ "dialog.domain_changed.title": "Domaine modifi\u00e9 \u2013 Red\u00e9marrage recommand\u00e9",
+ "dialog.domain_changed.msg": "Le domaine de l'application web a chang\u00e9\n\nVous avez chang\u00e9 de domaine. Pour une stabilit\u00e9 maximale et une authentification correcte, il est recommand\u00e9 de red\u00e9marrer l'application.\n\nLe profil et le cache ont \u00e9t\u00e9 vid\u00e9s, mais un red\u00e9marrage est recommand\u00e9.",
+ "dialog.domain_changed.restart_now": "Red\u00e9marrer maintenant",
+ "dialog.domain_changed.restart_later": "Red\u00e9marrer plus tard",
+ "dialog.language_changed.title": "Langue modifi\u00e9e",
+ "dialog.language_changed.msg": "Le param\u00e8tre de langue a \u00e9t\u00e9 mis \u00e0 jour. Red\u00e9marrez maintenant pour appliquer la langue s\u00e9lectionn\u00e9e partout.",
+ "dialog.language_changed.restart_now": "Red\u00e9marrer maintenant",
+ "dialog.language_changed.restart_later": "Red\u00e9marrer plus tard",
+ "dialog.restart_failed.title": "\u00c9chec du red\u00e9marrage",
+ "dialog.restart_failed.msg": "Impossible de red\u00e9marrer automatiquement l'application\u00a0:\n\n{error}\n\nVeuillez red\u00e9marrer manuellement.",
+ "dialog.update_timeout.title": "D\u00e9lai de v\u00e9rification des mises \u00e0 jour d\u00e9pass\u00e9",
+ "dialog.update_timeout.msg": "Le serveur n'a pas r\u00e9pondu dans les 30 secondes.\n\nCela peut \u00eatre d\u00fb \u00e0 un probl\u00e8me r\u00e9seau ou \u00e0 une indisponibilit\u00e9 du serveur.\n\nV\u00e9rifiez votre connexion et r\u00e9essayez.",
+ "dialog.update_failed.title": "\u00c9chec de la v\u00e9rification des mises \u00e0 jour",
+ "dialog.update_failed.msg": "Impossible de v\u00e9rifier les mises \u00e0 jour\u00a0:\n\n{error}\n\nVeuillez r\u00e9essayer plus tard.",
+ "dialog.download_failed.title": "\u00c9chec du t\u00e9l\u00e9chargement",
+ "dialog.download_failed.msg": "Impossible de t\u00e9l\u00e9charger la mise \u00e0 jour\u00a0:\n\n{error}\n\nVeuillez r\u00e9essayer plus tard.",
+ "dialog.checkout.title": "Extraire l'actif",
+ "dialog.checkout.msg": "Voulez-vous extraire cet actif\u00a0?\n\n{filename}",
+
+ "about.title": "\u00c0 propos de {app_name}",
+ "about.version": "Version\u00a0: {version}",
+ "about.description": "Connecte les flux de travail de glisser-d\u00e9poser web aux op\u00e9rations de fichiers natives pour les applications de bureau professionnelles.",
+ "about.drop_zones_title": "Zones de d\u00e9p\u00f4t de la barre d'outils\u00a0:",
+ "about.open_icon_desc": "Ic\u00f4ne Ouvrir\u00a0: ouvre les fichiers d\u00e9pos\u00e9s avec l'application par d\u00e9faut.",
+ "about.open_with_icon_desc": "Ic\u00f4ne Ouvrir avec\u00a0: affiche un s\u00e9lecteur d'application pour les fichiers d\u00e9pos\u00e9s.",
+ "about.product_of": "Un produit de\u00a0:",
+ "about.rights": "\u00a9 2026 h\u00f6rl Information Management GmbH. Tous droits r\u00e9serv\u00e9s.",
+
+ "settings.title": "Param\u00e8tres",
+ "settings.tab.web_source": "Source web",
+ "settings.tab.paths": "Chemins",
+ "settings.tab.urls": "URLs",
+ "settings.tab.logging": "Journalisation",
+ "settings.tab.window": "Fen\u00eatre",
+ "settings.tab.profiles": "Profils",
+ "settings.tab.general": "G\u00e9n\u00e9ral",
+ "settings.web_url.label": "URL de l'application web\u00a0:",
+ "settings.web_url.placeholder": "p.ex. http://localhost:8080 ou file:///./webapp/index.html",
+ "settings.web_url.open_btn": "Ouvrir",
+ "settings.url_mappings.label": "Mappages d'URL (Azure Blob Storage \u2192 Chemins locaux)\u00a0:",
+ "settings.url_mappings.col_prefix": "Pr\u00e9fixe URL",
+ "settings.url_mappings.col_path": "Chemin local",
+ "settings.url_mappings.add_btn": "Ajouter un mappage",
+ "settings.url_mappings.edit_btn": "Modifier la s\u00e9lection",
+ "settings.url_mappings.remove_btn": "Supprimer la s\u00e9lection",
+ "settings.paths.label": "R\u00e9pertoires racines autoris\u00e9s pour l'acc\u00e8s aux fichiers\u00a0:",
+ "settings.paths.add_btn": "Ajouter un chemin",
+ "settings.paths.remove_btn": "Supprimer la s\u00e9lection",
+ "settings.urls.label": "URLs web autoris\u00e9es (prise en charge des caract\u00e8res g\u00e9n\u00e9riques comme http://*.example.com)\u00a0:",
+ "settings.urls.add_btn": "Ajouter une URL",
+ "settings.urls.remove_btn": "Supprimer la s\u00e9lection",
+ "settings.log_level.label": "Niveau de journalisation\u00a0:",
+ "settings.log_file.label": "Fichier journal (facultatif)\u00a0:",
+ "settings.log_file.browse_btn": "Parcourir...",
+ "settings.window.width_label": "Largeur de la fen\u00eatre\u00a0:",
+ "settings.window.height_label": "Hauteur de la fen\u00eatre\u00a0:",
+ "settings.profiles.label": "Profils de configuration enregistr\u00e9s\u00a0:",
+ "settings.profiles.save_btn": "Enregistrer comme profil",
+ "settings.profiles.load_btn": "Charger le profil",
+ "settings.profiles.delete_btn": "Supprimer le profil",
+ "settings.profiles.export_btn": "Exporter la configuration",
+ "settings.profiles.import_btn": "Importer la configuration",
+ "settings.general.language_label": "Langue\u00a0:",
+ "settings.general.language_auto": "Par d\u00e9faut du syst\u00e8me (Auto)",
+ "settings.general.language_restart_note": "Le changement de langue prend effet apr\u00e8s red\u00e9marrage.",
+ "settings.add_mapping.url_title": "Ajouter un mappage d'URL",
+ "settings.add_mapping.url_prompt": "Entrez le pr\u00e9fixe URL Azure Blob Storage\u00a0:\n(p.ex. https://myblob.blob.core.windows.net/container/)",
+ "settings.add_mapping.path_prompt": "Entrez le chemin du syst\u00e8me de fichiers local\u00a0:\n(p.ex. C:\\Partage ou /mnt/partage)",
+ "settings.edit_mapping.title": "Modifier le mappage d'URL",
+ "settings.edit_mapping.url_prompt": "Entrez le pr\u00e9fixe URL Azure Blob Storage\u00a0:",
+ "settings.edit_mapping.path_prompt": "Entrez le chemin du syst\u00e8me de fichiers local\u00a0:",
+ "settings.add_url.title": "Ajouter une URL",
+ "settings.add_url.prompt": "Entrez le mod\u00e8le d'URL (p.ex. http://example.com ou http://*.example.com)\u00a0:",
+ "settings.profile.save.title": "Enregistrer le profil",
+ "settings.profile.save.prompt": "Entrez le nom du profil (p.ex. travail, personnel)\u00a0:",
+ "settings.select_directory.title": "S\u00e9lectionner un r\u00e9pertoire autoris\u00e9",
+ "settings.select_log_file.title": "S\u00e9lectionner le fichier journal",
+ "settings.export_config.title": "Exporter la configuration",
+ "settings.import_config.title": "Importer la configuration",
+ "settings.error.select_mapping": "Veuillez s\u00e9lectionner un mappage \u00e0 modifier",
+ "settings.error.select_profile_load": "Veuillez s\u00e9lectionner un profil \u00e0 charger",
+ "settings.error.select_profile_delete": "Veuillez s\u00e9lectionner un profil \u00e0 supprimer",
+
+ "update.checking.title": "V\u00e9rification des mises \u00e0 jour",
+ "update.checking.label": "Recherche de mises \u00e0 jour...",
+ "update.checking.timeout_info": "Cela peut prendre jusqu'\u00e0 10 secondes",
+ "update.available.title": "Mise \u00e0 jour disponible",
+ "update.available.header": "WebDrop Bridge v{version} est disponible",
+ "update.available.changelog_label": "Notes de version\u00a0:",
+ "update.available.update_now_btn": "Mettre \u00e0 jour maintenant",
+ "update.available.later_btn": "Plus tard",
+ "update.downloading.title": "T\u00e9l\u00e9chargement de la mise \u00e0 jour",
+ "update.downloading.header": "T\u00e9l\u00e9chargement en cours...",
+ "update.downloading.preparing": "Pr\u00e9paration du t\u00e9l\u00e9chargement",
+ "update.downloading.filename": "T\u00e9l\u00e9chargement\u00a0: {filename}",
+ "update.downloading.cancel_btn": "Annuler",
+ "update.install.title": "Installer la mise \u00e0 jour",
+ "update.install.header": "Pr\u00eat \u00e0 installer",
+ "update.install.message": "La mise \u00e0 jour est pr\u00eate \u00e0 \u00eatre install\u00e9e. L'application va red\u00e9marrer.",
+ "update.install.warning": "\u26a0\ufe0f Veuillez enregistrer tout travail non sauvegard\u00e9 avant de continuer.\nL'application va se fermer et red\u00e9marrer.",
+ "update.install.now_btn": "Installer maintenant",
+ "update.install.cancel_btn": "Annuler",
+ "update.no_update.title": "Aucune mise \u00e0 jour disponible",
+ "update.no_update.message": "\u2713 Vous utilisez la derni\u00e8re version",
+ "update.no_update.info": "WebDrop Bridge est \u00e0 jour.",
+ "update.no_update.ok_btn": "OK",
+ "update.error.title": "\u00c9chec de la mise \u00e0 jour",
+ "update.error.header": "\u26a0\ufe0f \u00c9chec de la mise \u00e0 jour",
+ "update.error.info": "Veuillez r\u00e9essayer ou visiter le site web pour t\u00e9l\u00e9charger la mise \u00e0 jour manuellement.",
+ "update.error.retry_btn": "R\u00e9essayer",
+ "update.error.manual_btn": "T\u00e9l\u00e9charger manuellement",
+ "update.error.cancel_btn": "Annuler",
+
+ "worker.server_not_responding": "Le serveur ne r\u00e9pond pas \u2013 v\u00e9rifiez plus tard",
+ "worker.no_installer": "Aucun programme d'installation trouv\u00e9 dans la version",
+ "worker.checksum_failed": "\u00c9chec de la v\u00e9rification de la somme de contr\u00f4le",
+ "worker.download_timed_out": "D\u00e9lai d\u00e9pass\u00e9 lors du t\u00e9l\u00e9chargement ou de la v\u00e9rification",
+ "worker.download_error": "Erreur de t\u00e9l\u00e9chargement\u00a0: {error}",
+ "worker.check_failed": "\u00c9chec de la v\u00e9rification\u00a0: {error}"
+}
diff --git a/resources/translations/it.json b/resources/translations/it.json
new file mode 100644
index 0000000..cccde66
--- /dev/null
+++ b/resources/translations/it.json
@@ -0,0 +1,172 @@
+{
+ "toolbar.tooltip.open_drop": "Trascina qui un file per aprirlo con l'app predefinita",
+ "toolbar.tooltip.open_with_drop": "Trascina qui un file per scegliere con quale app aprirlo",
+ "toolbar.tooltip.home": "Home",
+ "toolbar.tooltip.about": "Informazioni su WebDrop Bridge",
+ "toolbar.tooltip.settings": "Impostazioni",
+ "toolbar.tooltip.check_updates": "Controlla aggiornamenti",
+ "toolbar.tooltip.clear_cache": "Cancella cache e cookie",
+ "toolbar.tooltip.open_log": "Apri file di log",
+ "toolbar.tooltip.dev_tools": "Strumenti sviluppatore (F12)",
+
+ "status.ready": "Pronto",
+ "status.opened": "Aperto: {name}",
+ "status.choose_app": "Scegli app per: {name}",
+ "status.download_started": "📥 Download: {filename}",
+ "status.download_completed": "Download completato: {name}",
+ "status.download_cancelled": "⚠️ Download annullato: {name}",
+ "status.download_failed": "❌ Download non riuscito: {name}",
+ "status.download_error": "Errore download: {error}",
+
+ "update.status.checking": "Controllo aggiornamenti",
+ "update.status.ready": "Pronto",
+ "update.status.available": "Aggiornamento disponibile: v{version}",
+ "update.status.deferred": "Aggiornamento rimandato",
+ "update.status.downloading": "Download v{version}",
+ "update.status.verifying": "Verifica download",
+ "update.status.download_failed": "Download non riuscito",
+ "update.status.verification_failed": "Verifica non riuscita",
+ "update.status.timed_out": "Operazione scaduta",
+ "update.status.ready_to_install": "Pronto per l'installazione",
+ "update.status.installation_started": "Installazione avviata",
+ "update.status.installation_failed": "Installazione non riuscita",
+ "update.status.check_timed_out": "Controllo scaduto - nessuna risposta dal server",
+ "update.status.check_failed": "Controllo non riuscito: {error}",
+ "update.status.download_timed_out": "Download scaduto - nessuna risposta dal server",
+
+ "dialog.error.title": "Errore",
+ "dialog.log_not_found.title": "File di log non trovato",
+ "dialog.log_not_found.msg": "Nessun file di log trovato in:\n{log_file}",
+ "dialog.cache_cleared.title": "Cache cancellata",
+ "dialog.cache_cleared.msg": "Cache del browser e cookie cancellati con successo.\n\nPotrebbe essere necessario ricaricare la pagina o riavviare l'applicazione.",
+ "dialog.cache_clear_failed.title": "Errore",
+ "dialog.cache_clear_failed.msg": "Impossibile cancellare cache e cookie: {error}",
+ "dialog.drag_error.title": "Errore drag-and-drop",
+ "dialog.drag_error.msg": "Impossibile completare l'operazione drag-and-drop.\n\nErrore: {error}",
+ "dialog.open_file_error.title": "Errore apertura file",
+ "dialog.open_file_error.msg": "Impossibile aprire il file con l'applicazione predefinita.\n\nFile: {file_path}\nErrore: {error}",
+ "dialog.open_with_error.title": "Errore Apri con",
+ "dialog.open_with_error.msg": "Impossibile aprire un selettore applicazioni su questa piattaforma.",
+ "dialog.dev_tools.window_title": "🔧 Strumenti sviluppatore",
+ "dialog.dev_tools.error_title": "Strumenti sviluppatore",
+ "dialog.dev_tools.error_msg": "Impossibile aprire gli Strumenti sviluppatore:\n{error}",
+ "dialog.domain_changed.title": "Dominio cambiato - riavvio consigliato",
+ "dialog.domain_changed.msg": "Il dominio dell'app web è cambiato\n\nHai cambiato dominio. Per massima stabilità e corretta autenticazione, è consigliato riavviare l'applicazione.\n\nProfilo e cache sono stati puliti, ma consigliamo il riavvio.",
+ "dialog.domain_changed.restart_now": "Riavvia ora",
+ "dialog.domain_changed.restart_later": "Riavvia più tardi",
+ "dialog.language_changed.title": "Lingua cambiata",
+ "dialog.language_changed.msg": "La lingua è stata aggiornata. Riavvia ora per applicarla ovunque.",
+ "dialog.language_changed.restart_now": "Riavvia ora",
+ "dialog.language_changed.restart_later": "Riavvia più tardi",
+ "dialog.restart_failed.title": "Riavvio non riuscito",
+ "dialog.restart_failed.msg": "Impossibile riavviare automaticamente l'applicazione:\n\n{error}\n\nRiavvia manualmente.",
+ "dialog.update_timeout.title": "Timeout controllo aggiornamenti",
+ "dialog.update_timeout.msg": "Il server non ha risposto entro 30 secondi.\n\nPotrebbe trattarsi di un problema di rete o indisponibilità del server.\n\nControlla la connessione e riprova.",
+ "dialog.update_failed.title": "Controllo aggiornamenti non riuscito",
+ "dialog.update_failed.msg": "Impossibile controllare gli aggiornamenti:\n\n{error}\n\nRiprova più tardi.",
+ "dialog.download_failed.title": "Download non riuscito",
+ "dialog.download_failed.msg": "Impossibile scaricare l'aggiornamento:\n\n{error}\n\nRiprova più tardi.",
+ "dialog.checkout.title": "Checkout asset",
+ "dialog.checkout.msg": "Vuoi eseguire il checkout di questo asset?\n\n{filename}",
+
+ "about.title": "Informazioni su {app_name}",
+ "about.version": "Versione: {version}",
+ "about.description": "Collega i flussi drag-and-drop web alle operazioni file native per applicazioni desktop professionali.",
+ "about.drop_zones_title": "Zone di rilascio barra strumenti:",
+ "about.open_icon_desc": "Icona Apri: apre i file rilasciati con l'app predefinita.",
+ "about.open_with_icon_desc": "Icona Apri con: mostra un selettore app per i file rilasciati.",
+ "about.product_of": "Prodotto di:",
+ "about.rights": "© 2026 hörl Information Management GmbH. Tutti i diritti riservati.",
+
+ "settings.title": "Impostazioni",
+ "settings.tab.web_source": "Sorgente web",
+ "settings.tab.paths": "Percorsi",
+ "settings.tab.urls": "URL",
+ "settings.tab.logging": "Log",
+ "settings.tab.window": "Finestra",
+ "settings.tab.profiles": "Profili",
+ "settings.tab.general": "Generale",
+ "settings.web_url.label": "URL applicazione web:",
+ "settings.web_url.placeholder": "es. http://localhost:8080 o file:///./webapp/index.html",
+ "settings.web_url.open_btn": "Apri",
+ "settings.url_mappings.label": "Mappature URL (Azure Blob Storage → Percorsi locali):",
+ "settings.url_mappings.col_prefix": "Prefisso URL",
+ "settings.url_mappings.col_path": "Percorso locale",
+ "settings.url_mappings.add_btn": "Aggiungi mappatura",
+ "settings.url_mappings.edit_btn": "Modifica selezionato",
+ "settings.url_mappings.remove_btn": "Rimuovi selezionato",
+ "settings.paths.label": "Directory radice consentite per accesso file:",
+ "settings.paths.add_btn": "Aggiungi percorso",
+ "settings.paths.remove_btn": "Rimuovi selezionato",
+ "settings.urls.label": "URL web consentiti (supporta wildcard come http://*.example.com):",
+ "settings.urls.add_btn": "Aggiungi URL",
+ "settings.urls.remove_btn": "Rimuovi selezionato",
+ "settings.log_level.label": "Livello log:",
+ "settings.log_file.label": "File log (opzionale):",
+ "settings.log_file.browse_btn": "Sfoglia...",
+ "settings.window.width_label": "Larghezza finestra:",
+ "settings.window.height_label": "Altezza finestra:",
+ "settings.profiles.label": "Profili configurazione salvati:",
+ "settings.profiles.save_btn": "Salva come profilo",
+ "settings.profiles.load_btn": "Carica profilo",
+ "settings.profiles.delete_btn": "Elimina profilo",
+ "settings.profiles.export_btn": "Esporta configurazione",
+ "settings.profiles.import_btn": "Importa configurazione",
+ "settings.general.language_label": "Lingua:",
+ "settings.general.language_auto": "Predefinita sistema (Auto)",
+ "settings.general.language_restart_note": "La modifica lingua si applica dopo il riavvio.",
+ "settings.add_mapping.url_title": "Aggiungi mappatura URL",
+ "settings.add_mapping.url_prompt": "Inserisci prefisso URL Azure Blob Storage:\n(es. https://myblob.blob.core.windows.net/container/)",
+ "settings.add_mapping.path_prompt": "Inserisci percorso file system locale:\n(es. C:\\Share o /mnt/share)",
+ "settings.edit_mapping.title": "Modifica mappatura URL",
+ "settings.edit_mapping.url_prompt": "Inserisci prefisso URL Azure Blob Storage:",
+ "settings.edit_mapping.path_prompt": "Inserisci percorso file system locale:",
+ "settings.add_url.title": "Aggiungi URL",
+ "settings.add_url.prompt": "Inserisci pattern URL (es. http://example.com o http://*.example.com):",
+ "settings.profile.save.title": "Salva profilo",
+ "settings.profile.save.prompt": "Inserisci nome profilo (es. lavoro, personale):",
+ "settings.select_directory.title": "Seleziona directory da consentire",
+ "settings.select_log_file.title": "Seleziona file di log",
+ "settings.export_config.title": "Esporta configurazione",
+ "settings.import_config.title": "Importa configurazione",
+ "settings.error.select_mapping": "Seleziona una mappatura da modificare",
+ "settings.error.select_profile_load": "Seleziona un profilo da caricare",
+ "settings.error.select_profile_delete": "Seleziona un profilo da eliminare",
+
+ "update.checking.title": "Controllo aggiornamenti",
+ "update.checking.label": "Controllo aggiornamenti...",
+ "update.checking.timeout_info": "Può richiedere fino a 10 secondi",
+ "update.available.title": "Aggiornamento disponibile",
+ "update.available.header": "È disponibile WebDrop Bridge v{version}",
+ "update.available.changelog_label": "Note di rilascio:",
+ "update.available.update_now_btn": "Aggiorna ora",
+ "update.available.later_btn": "Più tardi",
+ "update.downloading.title": "Download aggiornamento",
+ "update.downloading.header": "Download aggiornamento...",
+ "update.downloading.preparing": "Preparazione download",
+ "update.downloading.filename": "Download: {filename}",
+ "update.downloading.cancel_btn": "Annulla",
+ "update.install.title": "Installa aggiornamento",
+ "update.install.header": "Pronto per installare",
+ "update.install.message": "L'aggiornamento è pronto per l'installazione. L'applicazione verrà riavviata.",
+ "update.install.warning": "⚠️ Salva eventuale lavoro non salvato prima di continuare.\nL'applicazione verrà chiusa e riavviata.",
+ "update.install.now_btn": "Installa ora",
+ "update.install.cancel_btn": "Annulla",
+ "update.no_update.title": "Nessun aggiornamento disponibile",
+ "update.no_update.message": "✓ Stai usando l'ultima versione",
+ "update.no_update.info": "WebDrop Bridge è aggiornato.",
+ "update.no_update.ok_btn": "OK",
+ "update.error.title": "Aggiornamento non riuscito",
+ "update.error.header": "⚠️ Aggiornamento non riuscito",
+ "update.error.info": "Riprova o visita il sito per scaricare manualmente l'aggiornamento.",
+ "update.error.retry_btn": "Riprova",
+ "update.error.manual_btn": "Scarica manualmente",
+ "update.error.cancel_btn": "Annulla",
+
+ "worker.server_not_responding": "Il server non risponde - riprova più tardi",
+ "worker.no_installer": "Nessun installer trovato nella release",
+ "worker.checksum_failed": "Verifica checksum non riuscita",
+ "worker.download_timed_out": "Download o verifica scaduti (nessuna risposta dal server)",
+ "worker.download_error": "Errore download: {error}",
+ "worker.check_failed": "Controllo non riuscito: {error}"
+}
diff --git a/resources/translations/ru.json b/resources/translations/ru.json
new file mode 100644
index 0000000..94d3a74
--- /dev/null
+++ b/resources/translations/ru.json
@@ -0,0 +1,172 @@
+{
+ "toolbar.tooltip.open_drop": "Перетащите файл сюда, чтобы открыть его приложением по умолчанию",
+ "toolbar.tooltip.open_with_drop": "Перетащите файл сюда, чтобы выбрать приложение для его открытия",
+ "toolbar.tooltip.home": "Главная",
+ "toolbar.tooltip.about": "О WebDrop Bridge",
+ "toolbar.tooltip.settings": "Настройки",
+ "toolbar.tooltip.check_updates": "Проверить обновления",
+ "toolbar.tooltip.clear_cache": "Очистить кэш и cookie",
+ "toolbar.tooltip.open_log": "Открыть файл журнала",
+ "toolbar.tooltip.dev_tools": "Инструменты разработчика (F12)",
+
+ "status.ready": "Готово",
+ "status.opened": "Открыто: {name}",
+ "status.choose_app": "Выберите приложение для: {name}",
+ "status.download_started": "📥 Загрузка: {filename}",
+ "status.download_completed": "Загрузка завершена: {name}",
+ "status.download_cancelled": "⚠️ Загрузка отменена: {name}",
+ "status.download_failed": "❌ Ошибка загрузки: {name}",
+ "status.download_error": "Ошибка загрузки: {error}",
+
+ "update.status.checking": "Проверка обновлений",
+ "update.status.ready": "Готово",
+ "update.status.available": "Доступно обновление: v{version}",
+ "update.status.deferred": "Обновление отложено",
+ "update.status.downloading": "Загрузка v{version}",
+ "update.status.verifying": "Проверка загрузки",
+ "update.status.download_failed": "Ошибка загрузки",
+ "update.status.verification_failed": "Ошибка проверки",
+ "update.status.timed_out": "Время ожидания истекло",
+ "update.status.ready_to_install": "Готово к установке",
+ "update.status.installation_started": "Установка начата",
+ "update.status.installation_failed": "Ошибка установки",
+ "update.status.check_timed_out": "Проверка прервана по таймауту - нет ответа сервера",
+ "update.status.check_failed": "Ошибка проверки: {error}",
+ "update.status.download_timed_out": "Загрузка прервана по таймауту - нет ответа сервера",
+
+ "dialog.error.title": "Ошибка",
+ "dialog.log_not_found.title": "Файл журнала не найден",
+ "dialog.log_not_found.msg": "Файл журнала не найден по пути:\n{log_file}",
+ "dialog.cache_cleared.title": "Кэш очищен",
+ "dialog.cache_cleared.msg": "Кэш браузера и файлы cookie успешно очищены.\n\nВозможно, потребуется перезагрузить страницу или перезапустить приложение.",
+ "dialog.cache_clear_failed.title": "Ошибка",
+ "dialog.cache_clear_failed.msg": "Не удалось очистить кэш и файлы cookie: {error}",
+ "dialog.drag_error.title": "Ошибка drag-and-drop",
+ "dialog.drag_error.msg": "Не удалось завершить операцию drag-and-drop.\n\nОшибка: {error}",
+ "dialog.open_file_error.title": "Ошибка открытия файла",
+ "dialog.open_file_error.msg": "Не удалось открыть файл приложением по умолчанию.\n\nФайл: {file_path}\nОшибка: {error}",
+ "dialog.open_with_error.title": "Ошибка «Открыть с помощью»",
+ "dialog.open_with_error.msg": "Невозможно открыть выбор приложения на этой платформе.",
+ "dialog.dev_tools.window_title": "🔧 Инструменты разработчика",
+ "dialog.dev_tools.error_title": "Инструменты разработчика",
+ "dialog.dev_tools.error_msg": "Не удалось открыть инструменты разработчика:\n{error}",
+ "dialog.domain_changed.title": "Домен изменен — рекомендуется перезапуск",
+ "dialog.domain_changed.msg": "Домен веб-приложения изменился\n\nВы переключились на другой домен. Для максимальной стабильности и корректной аутентификации рекомендуется перезапустить приложение.\n\nПрофиль и кэш очищены, но перезапуск по-прежнему рекомендуется.",
+ "dialog.domain_changed.restart_now": "Перезапустить сейчас",
+ "dialog.domain_changed.restart_later": "Перезапустить позже",
+ "dialog.language_changed.title": "Язык изменен",
+ "dialog.language_changed.msg": "Настройка языка обновлена. Перезапустите сейчас, чтобы применить язык везде.",
+ "dialog.language_changed.restart_now": "Перезапустить сейчас",
+ "dialog.language_changed.restart_later": "Перезапустить позже",
+ "dialog.restart_failed.title": "Сбой перезапуска",
+ "dialog.restart_failed.msg": "Не удалось автоматически перезапустить приложение:\n\n{error}\n\nПерезапустите вручную.",
+ "dialog.update_timeout.title": "Таймаут проверки обновлений",
+ "dialog.update_timeout.msg": "Сервер не ответил в течение 30 секунд.\n\nВозможна проблема сети или недоступность сервера.\n\nПроверьте соединение и попробуйте снова.",
+ "dialog.update_failed.title": "Ошибка проверки обновлений",
+ "dialog.update_failed.msg": "Не удалось проверить обновления:\n\n{error}\n\nПовторите позже.",
+ "dialog.download_failed.title": "Ошибка загрузки",
+ "dialog.download_failed.msg": "Не удалось скачать обновление:\n\n{error}\n\nПовторите позже.",
+ "dialog.checkout.title": "Выдача ресурса",
+ "dialog.checkout.msg": "Выполнить выдачу этого ресурса?\n\n{filename}",
+
+ "about.title": "О программе {app_name}",
+ "about.version": "Версия: {version}",
+ "about.description": "Связывает веб-сценарии drag-and-drop с нативными файловыми операциями для профессиональных настольных приложений.",
+ "about.drop_zones_title": "Зоны перетаскивания на панели:",
+ "about.open_icon_desc": "Иконка «Открыть»: открывает перетащенные файлы приложением по умолчанию.",
+ "about.open_with_icon_desc": "Иконка «Открыть с помощью»: показывает выбор приложения для перетащенных файлов.",
+ "about.product_of": "Продукт компании:",
+ "about.rights": "© 2026 hörl Information Management GmbH. Все права защищены.",
+
+ "settings.title": "Настройки",
+ "settings.tab.web_source": "Веб-источник",
+ "settings.tab.paths": "Пути",
+ "settings.tab.urls": "URL",
+ "settings.tab.logging": "Логирование",
+ "settings.tab.window": "Окно",
+ "settings.tab.profiles": "Профили",
+ "settings.tab.general": "Общие настройки",
+ "settings.web_url.label": "URL веб-приложения:",
+ "settings.web_url.placeholder": "например, http://localhost:8080 или file:///./webapp/index.html",
+ "settings.web_url.open_btn": "Открыть",
+ "settings.url_mappings.label": "Сопоставления URL (Azure Blob Storage → локальные пути):",
+ "settings.url_mappings.col_prefix": "Префикс URL",
+ "settings.url_mappings.col_path": "Локальный путь",
+ "settings.url_mappings.add_btn": "Добавить сопоставление",
+ "settings.url_mappings.edit_btn": "Изменить выбранное",
+ "settings.url_mappings.remove_btn": "Удалить выбранное",
+ "settings.paths.label": "Разрешенные корневые каталоги для доступа к файлам:",
+ "settings.paths.add_btn": "Добавить путь",
+ "settings.paths.remove_btn": "Удалить выбранное",
+ "settings.urls.label": "Разрешенные веб URL (поддержка масок, напр. http://*.example.com):",
+ "settings.urls.add_btn": "Добавить URL",
+ "settings.urls.remove_btn": "Удалить выбранное",
+ "settings.log_level.label": "Уровень логирования:",
+ "settings.log_file.label": "Файл журнала (необязательно):",
+ "settings.log_file.browse_btn": "Обзор...",
+ "settings.window.width_label": "Ширина окна:",
+ "settings.window.height_label": "Высота окна:",
+ "settings.profiles.label": "Сохраненные профили конфигурации:",
+ "settings.profiles.save_btn": "Сохранить как профиль",
+ "settings.profiles.load_btn": "Загрузить профиль",
+ "settings.profiles.delete_btn": "Удалить профиль",
+ "settings.profiles.export_btn": "Экспорт конфигурации",
+ "settings.profiles.import_btn": "Импорт конфигурации",
+ "settings.general.language_label": "Язык:",
+ "settings.general.language_auto": "Системный язык (авто)",
+ "settings.general.language_restart_note": "Изменение языка вступает в силу после перезапуска.",
+ "settings.add_mapping.url_title": "Добавить сопоставление URL",
+ "settings.add_mapping.url_prompt": "Введите префикс URL Azure Blob Storage:\n(например, https://myblob.blob.core.windows.net/container/)",
+ "settings.add_mapping.path_prompt": "Введите локальный путь файловой системы:\n(например, C:\\Share или /mnt/share)",
+ "settings.edit_mapping.title": "Изменить сопоставление URL",
+ "settings.edit_mapping.url_prompt": "Введите префикс URL Azure Blob Storage:",
+ "settings.edit_mapping.path_prompt": "Введите локальный путь файловой системы:",
+ "settings.add_url.title": "Добавить URL",
+ "settings.add_url.prompt": "Введите шаблон URL (например, http://example.com или http://*.example.com):",
+ "settings.profile.save.title": "Сохранить профиль",
+ "settings.profile.save.prompt": "Введите имя профиля (например, работа, личный):",
+ "settings.select_directory.title": "Выберите разрешенную папку",
+ "settings.select_log_file.title": "Выберите файл журнала",
+ "settings.export_config.title": "Экспорт конфигурации",
+ "settings.import_config.title": "Импорт конфигурации",
+ "settings.error.select_mapping": "Выберите сопоставление для редактирования",
+ "settings.error.select_profile_load": "Выберите профиль для загрузки",
+ "settings.error.select_profile_delete": "Выберите профиль для удаления",
+
+ "update.checking.title": "Проверка обновлений",
+ "update.checking.label": "Проверка обновлений...",
+ "update.checking.timeout_info": "Это может занять до 10 секунд",
+ "update.available.title": "Доступно обновление",
+ "update.available.header": "Доступна версия WebDrop Bridge v{version}",
+ "update.available.changelog_label": "Примечания к релизу:",
+ "update.available.update_now_btn": "Обновить сейчас",
+ "update.available.later_btn": "Позже",
+ "update.downloading.title": "Загрузка обновления",
+ "update.downloading.header": "Загрузка обновления...",
+ "update.downloading.preparing": "Подготовка загрузки",
+ "update.downloading.filename": "Загрузка: {filename}",
+ "update.downloading.cancel_btn": "Отмена",
+ "update.install.title": "Установить обновление",
+ "update.install.header": "Готово к установке",
+ "update.install.message": "Обновление готово к установке. Приложение будет перезапущено.",
+ "update.install.warning": "⚠️ Сохраните несохраненные данные перед продолжением.\nПриложение будет закрыто и перезапущено.",
+ "update.install.now_btn": "Установить сейчас",
+ "update.install.cancel_btn": "Отмена",
+ "update.no_update.title": "Обновлений нет",
+ "update.no_update.message": "✓ У вас установлена последняя версия",
+ "update.no_update.info": "WebDrop Bridge уже обновлен.",
+ "update.no_update.ok_btn": "OK",
+ "update.error.title": "Ошибка обновления",
+ "update.error.header": "⚠️ Ошибка обновления",
+ "update.error.info": "Повторите попытку или загрузите обновление вручную с сайта.",
+ "update.error.retry_btn": "Повторить",
+ "update.error.manual_btn": "Скачать вручную",
+ "update.error.cancel_btn": "Отмена",
+
+ "worker.server_not_responding": "Сервер не отвечает — попробуйте позже",
+ "worker.no_installer": "В релизе не найден установщик",
+ "worker.checksum_failed": "Проверка контрольной суммы не пройдена",
+ "worker.download_timed_out": "Таймаут загрузки или проверки (нет ответа сервера)",
+ "worker.download_error": "Ошибка загрузки: {error}",
+ "worker.check_failed": "Ошибка проверки: {error}"
+}
diff --git a/resources/translations/zh.json b/resources/translations/zh.json
new file mode 100644
index 0000000..532e027
--- /dev/null
+++ b/resources/translations/zh.json
@@ -0,0 +1,172 @@
+{
+ "toolbar.tooltip.open_drop": "将文件拖到此处以使用默认应用打开",
+ "toolbar.tooltip.open_with_drop": "将文件拖到此处以选择用于打开的应用",
+ "toolbar.tooltip.home": "主页",
+ "toolbar.tooltip.about": "关于 WebDrop Bridge",
+ "toolbar.tooltip.settings": "设置",
+ "toolbar.tooltip.check_updates": "检查更新",
+ "toolbar.tooltip.clear_cache": "清除缓存和 Cookie",
+ "toolbar.tooltip.open_log": "打开日志文件",
+ "toolbar.tooltip.dev_tools": "开发者工具 (F12)",
+
+ "status.ready": "就绪",
+ "status.opened": "已打开: {name}",
+ "status.choose_app": "为此文件选择应用: {name}",
+ "status.download_started": "📥 下载: {filename}",
+ "status.download_completed": "下载完成: {name}",
+ "status.download_cancelled": "⚠️ 下载已取消: {name}",
+ "status.download_failed": "❌ 下载失败: {name}",
+ "status.download_error": "下载错误: {error}",
+
+ "update.status.checking": "正在检查更新",
+ "update.status.ready": "就绪",
+ "update.status.available": "有可用更新: v{version}",
+ "update.status.deferred": "更新已延后",
+ "update.status.downloading": "正在下载 v{version}",
+ "update.status.verifying": "正在验证下载",
+ "update.status.download_failed": "下载失败",
+ "update.status.verification_failed": "验证失败",
+ "update.status.timed_out": "操作超时",
+ "update.status.ready_to_install": "准备安装",
+ "update.status.installation_started": "已开始安装",
+ "update.status.installation_failed": "安装失败",
+ "update.status.check_timed_out": "检查超时 - 服务器无响应",
+ "update.status.check_failed": "检查失败: {error}",
+ "update.status.download_timed_out": "下载超时 - 服务器无响应",
+
+ "dialog.error.title": "错误",
+ "dialog.log_not_found.title": "未找到日志文件",
+ "dialog.log_not_found.msg": "在以下位置未找到日志文件:\n{log_file}",
+ "dialog.cache_cleared.title": "缓存已清除",
+ "dialog.cache_cleared.msg": "浏览器缓存和 Cookie 已成功清除。\n\n你可能需要刷新页面或重启应用以使更改生效。",
+ "dialog.cache_clear_failed.title": "错误",
+ "dialog.cache_clear_failed.msg": "清除缓存和 Cookie 失败: {error}",
+ "dialog.drag_error.title": "拖放错误",
+ "dialog.drag_error.msg": "无法完成拖放操作。\n\n错误: {error}",
+ "dialog.open_file_error.title": "打开文件错误",
+ "dialog.open_file_error.msg": "无法使用默认应用打开该文件。\n\n文件: {file_path}\n错误: {error}",
+ "dialog.open_with_error.title": "“打开方式”错误",
+ "dialog.open_with_error.msg": "当前平台无法打开应用选择器。",
+ "dialog.dev_tools.window_title": "🔧 开发者工具",
+ "dialog.dev_tools.error_title": "开发者工具",
+ "dialog.dev_tools.error_msg": "无法打开开发者工具:\n{error}",
+ "dialog.domain_changed.title": "域名已变更 - 建议重启",
+ "dialog.domain_changed.msg": "Web 应用域名已变更\n\n你已切换到其他域名。为保证稳定性与认证正确性，建议重启应用。\n\n配置与缓存已清理，但仍建议重启。",
+ "dialog.domain_changed.restart_now": "立即重启",
+ "dialog.domain_changed.restart_later": "稍后重启",
+ "dialog.language_changed.title": "语言已更改",
+ "dialog.language_changed.msg": "语言设置已更新。立即重启可在所有界面生效。",
+ "dialog.language_changed.restart_now": "立即重启",
+ "dialog.language_changed.restart_later": "稍后重启",
+ "dialog.restart_failed.title": "重启失败",
+ "dialog.restart_failed.msg": "无法自动重启应用:\n\n{error}\n\n请手动重启。",
+ "dialog.update_timeout.title": "更新检查超时",
+ "dialog.update_timeout.msg": "服务器在 30 秒内未响应。\n\n可能是网络问题或服务器不可用。\n\n请检查连接后重试。",
+ "dialog.update_failed.title": "更新检查失败",
+ "dialog.update_failed.msg": "无法检查更新:\n\n{error}\n\n请稍后重试。",
+ "dialog.download_failed.title": "下载失败",
+ "dialog.download_failed.msg": "无法下载更新:\n\n{error}\n\n请稍后重试。",
+ "dialog.checkout.title": "签出资产",
+ "dialog.checkout.msg": "是否签出该资产？\n\n{filename}",
+
+ "about.title": "关于 {app_name}",
+ "about.version": "版本: {version}",
+ "about.description": "将基于 Web 的拖放流程与桌面原生文件操作无缝衔接。",
+ "about.drop_zones_title": "工具栏拖放区域:",
+ "about.open_icon_desc": "打开图标: 使用系统默认应用打开拖入文件。",
+ "about.open_with_icon_desc": "打开方式图标: 为拖入文件显示应用选择器。",
+ "about.product_of": "产品提供方:",
+ "about.rights": "© 2026 hörl Information Management GmbH. 保留所有权利。",
+
+ "settings.title": "设置",
+ "settings.tab.web_source": "Web 来源",
+ "settings.tab.paths": "路径",
+ "settings.tab.urls": "URL",
+ "settings.tab.logging": "日志",
+ "settings.tab.window": "窗口",
+ "settings.tab.profiles": "配置档案",
+ "settings.tab.general": "通用",
+ "settings.web_url.label": "Web 应用 URL:",
+ "settings.web_url.placeholder": "例如: http://localhost:8080 或 file:///./webapp/index.html",
+ "settings.web_url.open_btn": "打开",
+ "settings.url_mappings.label": "URL 映射（Azure Blob Storage → 本地路径）:",
+ "settings.url_mappings.col_prefix": "URL 前缀",
+ "settings.url_mappings.col_path": "本地路径",
+ "settings.url_mappings.add_btn": "添加映射",
+ "settings.url_mappings.edit_btn": "编辑所选",
+ "settings.url_mappings.remove_btn": "删除所选",
+ "settings.paths.label": "允许访问文件的根目录:",
+ "settings.paths.add_btn": "添加路径",
+ "settings.paths.remove_btn": "删除所选",
+ "settings.urls.label": "允许的 Web URL（支持通配符，例如 http://*.example.com）:",
+ "settings.urls.add_btn": "添加 URL",
+ "settings.urls.remove_btn": "删除所选",
+ "settings.log_level.label": "日志级别:",
+ "settings.log_file.label": "日志文件（可选）:",
+ "settings.log_file.browse_btn": "浏览...",
+ "settings.window.width_label": "窗口宽度:",
+ "settings.window.height_label": "窗口高度:",
+ "settings.profiles.label": "已保存配置档案:",
+ "settings.profiles.save_btn": "保存为档案",
+ "settings.profiles.load_btn": "加载档案",
+ "settings.profiles.delete_btn": "删除档案",
+ "settings.profiles.export_btn": "导出配置",
+ "settings.profiles.import_btn": "导入配置",
+ "settings.general.language_label": "语言:",
+ "settings.general.language_auto": "跟随系统（自动）",
+ "settings.general.language_restart_note": "语言更改将在重启后生效。",
+ "settings.add_mapping.url_title": "添加 URL 映射",
+ "settings.add_mapping.url_prompt": "输入 Azure Blob Storage URL 前缀:\n(例如: https://myblob.blob.core.windows.net/container/)",
+ "settings.add_mapping.path_prompt": "输入本地文件系统路径:\n(例如: C:\\Share 或 /mnt/share)",
+ "settings.edit_mapping.title": "编辑 URL 映射",
+ "settings.edit_mapping.url_prompt": "输入 Azure Blob Storage URL 前缀:",
+ "settings.edit_mapping.path_prompt": "输入本地文件系统路径:",
+ "settings.add_url.title": "添加 URL",
+ "settings.add_url.prompt": "输入 URL 模式（例如: http://example.com 或 http://*.example.com）:",
+ "settings.profile.save.title": "保存档案",
+ "settings.profile.save.prompt": "输入配置档案名称（例如: 工作, 个人）:",
+ "settings.select_directory.title": "选择允许目录",
+ "settings.select_log_file.title": "选择日志文件",
+ "settings.export_config.title": "导出配置",
+ "settings.import_config.title": "导入配置",
+ "settings.error.select_mapping": "请选择要编辑的映射",
+ "settings.error.select_profile_load": "请选择要加载的档案",
+ "settings.error.select_profile_delete": "请选择要删除的档案",
+
+ "update.checking.title": "检查更新",
+ "update.checking.label": "正在检查更新...",
+ "update.checking.timeout_info": "这可能需要最多 10 秒",
+ "update.available.title": "有可用更新",
+ "update.available.header": "检测到可用版本：WebDrop Bridge v{version}",
+ "update.available.changelog_label": "更新说明:",
+ "update.available.update_now_btn": "立即更新",
+ "update.available.later_btn": "稍后",
+ "update.downloading.title": "正在下载更新",
+ "update.downloading.header": "正在下载更新...",
+ "update.downloading.preparing": "准备下载",
+ "update.downloading.filename": "正在下载: {filename}",
+ "update.downloading.cancel_btn": "取消",
+ "update.install.title": "安装更新",
+ "update.install.header": "准备安装",
+ "update.install.message": "更新已准备好安装。应用将重启。",
+ "update.install.warning": "⚠️ 继续前请保存未保存的工作。\n应用将关闭并重启。",
+ "update.install.now_btn": "立即安装",
+ "update.install.cancel_btn": "取消",
+ "update.no_update.title": "无可用更新",
+ "update.no_update.message": "✓ 你正在使用最新版本",
+ "update.no_update.info": "WebDrop Bridge 已为最新版本。",
+ "update.no_update.ok_btn": "确定",
+ "update.error.title": "更新失败",
+ "update.error.header": "⚠️ 更新失败",
+ "update.error.info": "请重试，或前往网站手动下载更新包。",
+ "update.error.retry_btn": "重试",
+ "update.error.manual_btn": "手动下载",
+ "update.error.cancel_btn": "取消",
+
+ "worker.server_not_responding": "服务器无响应，请稍后再试",
+ "worker.no_installer": "发布包中未找到安装程序",
+ "worker.checksum_failed": "校验和验证失败",
+ "worker.download_timed_out": "下载或验证超时（服务器无响应）",
+ "worker.download_error": "下载错误: {error}",
+ "worker.check_failed": "检查失败: {error}"
+}
diff --git a/src/webdrop_bridge/__init__.py b/src/webdrop_bridge/__init__.py
index b6a4335..604705f 100644
--- a/src/webdrop_bridge/__init__.py
+++ b/src/webdrop_bridge/__init__.py
@@ -1,6 +1,6 @@
"""WebDrop Bridge - Qt-based desktop application for intelligent drag-and-drop file handling."""
-__version__ = "0.6.0"
+__version__ = "0.8.6"
__author__ = "WebDrop Team"
__license__ = "MIT"
diff --git a/src/webdrop_bridge/config.py b/src/webdrop_bridge/config.py
index d744945..12bdeb7 100644
--- a/src/webdrop_bridge/config.py
+++ b/src/webdrop_bridge/config.py
@@ -3,6 +3,7 @@
import json
import logging
import os
+import sys
from dataclasses import dataclass, field
from pathlib import Path
from typing import List
@@ -11,6 +12,13 @@ from dotenv import load_dotenv
logger = logging.getLogger(__name__)
+DEFAULT_BRAND_ID = "webdrop_bridge"
+DEFAULT_CONFIG_DIR_NAME = "webdrop_bridge"
+DEFAULT_UPDATE_BASE_URL = "https://git.him-tools.de"
+DEFAULT_UPDATE_REPO = "HIM-public/webdrop-bridge"
+DEFAULT_UPDATE_CHANNEL = "stable"
+DEFAULT_UPDATE_MANIFEST_NAME = "release-manifest.json"
+
class ConfigurationError(Exception):
"""Raised when configuration is invalid."""
@@ -58,6 +66,14 @@ class Config:
window_height: Initial window height in pixels
window_title: Main window title (default: "{app_name} v{app_version}")
enable_logging: Whether to write logs to file
+ enable_checkout: Whether to check asset checkout status and show checkout dialog
+ on drag. Disabled by default as checkout support is optional.
+ brand_id: Stable brand identifier used for packaging and update selection
+ config_dir_name: AppData/config directory name for this branded variant
+ update_base_url: Base Forgejo URL used for release checks
+ update_repo: Forgejo repository containing shared releases
+ update_channel: Update channel name used by release manifest selection
+ update_manifest_name: Asset name of the shared release manifest
Raises:
ConfigurationError: If configuration values are invalid
@@ -78,6 +94,14 @@ class Config:
window_height: int = 768
window_title: str = ""
enable_logging: bool = True
+ enable_checkout: bool = False
+ language: str = "auto"
+ brand_id: str = DEFAULT_BRAND_ID
+ config_dir_name: str = DEFAULT_CONFIG_DIR_NAME
+ update_base_url: str = DEFAULT_UPDATE_BASE_URL
+ update_repo: str = DEFAULT_UPDATE_REPO
+ update_channel: str = DEFAULT_UPDATE_CHANNEL
+ update_manifest_name: str = DEFAULT_UPDATE_MANIFEST_NAME
@classmethod
def from_file(cls, config_path: Path) -> "Config":
@@ -106,10 +130,7 @@ class Config:
# Parse URL mappings
mappings = [
- URLMapping(
- url_prefix=m["url_prefix"],
- local_path=m["local_path"]
- )
+ URLMapping(url_prefix=m["url_prefix"], local_path=m["local_path"])
for m in data.get("url_mappings", [])
]
@@ -123,6 +144,9 @@ class Config:
elif not root.is_dir():
raise ConfigurationError(f"Allowed root is not a directory: {root}")
+ brand_id = data.get("brand_id", DEFAULT_BRAND_ID)
+ config_dir_name = data.get("config_dir_name", cls._slugify_config_dir_name(brand_id))
+
# Get log file path
log_file = None
if data.get("enable_logging", True):
@@ -131,18 +155,19 @@ class Config:
log_file = Path(log_file_str)
# If relative path, resolve relative to app data directory instead of cwd
if not log_file.is_absolute():
- log_file = Config.get_default_log_dir() / log_file
+ log_file = Config.get_default_log_dir(config_dir_name) / log_file
else:
# Use default log path in app data
- log_file = Config.get_default_log_path()
+ log_file = Config.get_default_log_path(config_dir_name)
app_name = data.get("app_name", "WebDrop Bridge")
stored_window_title = data.get("window_title", "")
-
+
# Regenerate default window titles on version upgrade
# If the stored title matches the pattern "{app_name} v{version}", regenerate it
# with the current version. This ensures the title updates automatically on upgrades.
import re
+
version_pattern = re.compile(rf"^{re.escape(app_name)}\s+v[\d.]+$")
if stored_window_title and version_pattern.match(stored_window_title):
# Detected a default-pattern title with old version, regenerate
@@ -170,6 +195,14 @@ class Config:
window_height=data.get("window_height", 768),
window_title=window_title,
enable_logging=data.get("enable_logging", True),
+ enable_checkout=data.get("enable_checkout", False),
+ language=data.get("language", "auto"),
+ brand_id=brand_id,
+ config_dir_name=config_dir_name,
+ update_base_url=data.get("update_base_url", DEFAULT_UPDATE_BASE_URL),
+ update_repo=data.get("update_repo", DEFAULT_UPDATE_REPO),
+ update_channel=data.get("update_channel", DEFAULT_UPDATE_CHANNEL),
+ update_manifest_name=data.get("update_manifest_name", DEFAULT_UPDATE_MANIFEST_NAME),
)
@classmethod
@@ -195,8 +228,11 @@ class Config:
app_name = os.getenv("APP_NAME", "WebDrop Bridge")
# Version always comes from __init__.py for consistency
from webdrop_bridge import __version__
+
app_version = __version__
-
+ brand_id = os.getenv("BRAND_ID", DEFAULT_BRAND_ID)
+ config_dir_name = os.getenv("APP_CONFIG_DIR_NAME", cls._slugify_config_dir_name(brand_id))
+
log_level = os.getenv("LOG_LEVEL", "INFO").upper()
log_file_str = os.getenv("LOG_FILE", None)
allowed_roots_str = os.getenv("ALLOWED_ROOTS", "Z:/,C:/Users/Public")
@@ -208,13 +244,18 @@ class Config:
default_title = f"{app_name} v{app_version}"
window_title = os.getenv("WINDOW_TITLE", default_title)
enable_logging = os.getenv("ENABLE_LOGGING", "true").lower() == "true"
+ enable_checkout = os.getenv("ENABLE_CHECKOUT", "false").lower() == "true"
+ language = os.getenv("LANGUAGE", "auto")
+ update_base_url = os.getenv("UPDATE_BASE_URL", DEFAULT_UPDATE_BASE_URL)
+ update_repo = os.getenv("UPDATE_REPO", DEFAULT_UPDATE_REPO)
+ update_channel = os.getenv("UPDATE_CHANNEL", DEFAULT_UPDATE_CHANNEL)
+ update_manifest_name = os.getenv("UPDATE_MANIFEST_NAME", DEFAULT_UPDATE_MANIFEST_NAME)
# Validate log level
valid_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
if log_level not in valid_levels:
raise ConfigurationError(
- f"Invalid LOG_LEVEL: {log_level}. "
- f"Must be one of: {', '.join(valid_levels)}"
+ f"Invalid LOG_LEVEL: {log_level}. " f"Must be one of: {', '.join(valid_levels)}"
)
# Validate and parse allowed roots
@@ -225,9 +266,7 @@ class Config:
if not root_path.exists():
logger.warning(f"Allowed root does not exist: {p.strip()}")
elif not root_path.is_dir():
- raise ConfigurationError(
- f"Allowed root '{p.strip()}' is not a directory"
- )
+ raise ConfigurationError(f"Allowed root '{p.strip()}' is not a directory")
else:
allowed_roots.append(root_path)
except ConfigurationError:
@@ -240,8 +279,7 @@ class Config:
# Validate window dimensions
if window_width <= 0 or window_height <= 0:
raise ConfigurationError(
- f"Window dimensions must be positive: "
- f"{window_width}x{window_height}"
+ f"Window dimensions must be positive: " f"{window_width}x{window_height}"
)
# Create log file path if logging enabled
@@ -251,20 +289,21 @@ class Config:
log_file = Path(log_file_str)
# If relative path, resolve relative to app data directory instead of cwd
if not log_file.is_absolute():
- log_file = Config.get_default_log_dir() / log_file
+ log_file = Config.get_default_log_dir(config_dir_name) / log_file
else:
# Use default log path in app data
- log_file = Config.get_default_log_path()
+ log_file = Config.get_default_log_path(config_dir_name)
# Validate webapp URL is not empty
if not webapp_url:
raise ConfigurationError("WEBAPP_URL cannot be empty")
# Parse allowed URLs (empty string = no restriction)
- allowed_urls = [
- url.strip() for url in allowed_urls_str.split(",")
- if url.strip()
- ] if allowed_urls_str else []
+ allowed_urls = (
+ [url.strip() for url in allowed_urls_str.split(",") if url.strip()]
+ if allowed_urls_str
+ else []
+ )
# Parse URL mappings (Azure Blob Storage → Local Paths)
# Format: url_prefix1=local_path1;url_prefix2=local_path2
@@ -282,10 +321,7 @@ class Config:
)
url_prefix, local_path_str = mapping.split("=", 1)
url_mappings.append(
- URLMapping(
- url_prefix=url_prefix.strip(),
- local_path=local_path_str.strip()
- )
+ URLMapping(url_prefix=url_prefix.strip(), local_path=local_path_str.strip())
)
except (ValueError, OSError) as e:
raise ConfigurationError(
@@ -305,6 +341,14 @@ class Config:
window_height=window_height,
window_title=window_title,
enable_logging=enable_logging,
+ enable_checkout=enable_checkout,
+ language=language,
+ brand_id=brand_id,
+ config_dir_name=config_dir_name,
+ update_base_url=update_base_url,
+ update_repo=update_repo,
+ update_channel=update_channel,
+ update_manifest_name=update_manifest_name,
)
def to_file(self, config_path: Path) -> None:
@@ -312,18 +356,14 @@ class Config:
Args:
config_path: Path to save configuration to
-
+
Creates parent directories if they don't exist.
"""
data = {
"app_name": self.app_name,
"webapp_url": self.webapp_url,
"url_mappings": [
- {
- "url_prefix": m.url_prefix,
- "local_path": m.local_path
- }
- for m in self.url_mappings
+ {"url_prefix": m.url_prefix, "local_path": m.local_path} for m in self.url_mappings
],
"allowed_roots": [str(p) for p in self.allowed_roots],
"allowed_urls": self.allowed_urls,
@@ -336,6 +376,14 @@ class Config:
"window_height": self.window_height,
"window_title": self.window_title,
"enable_logging": self.enable_logging,
+ "enable_checkout": self.enable_checkout,
+ "language": self.language,
+ "brand_id": self.brand_id,
+ "config_dir_name": self.config_dir_name,
+ "update_base_url": self.update_base_url,
+ "update_repo": self.update_repo,
+ "update_channel": self.update_channel,
+ "update_manifest_name": self.update_manifest_name,
}
config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -343,23 +391,74 @@ class Config:
json.dump(data, f, indent=2)
@staticmethod
- def get_default_config_path() -> Path:
+ def load_bootstrap_env(env_file: str | None = None) -> Path | None:
+ """Load a bootstrap .env before configuration path lookup.
+
+ This lets branded builds decide their config directory before the main
+ config file is loaded.
+
+ Args:
+ env_file: Optional explicit .env path
+
+ Returns:
+ Path to the loaded .env file, or None if nothing was loaded
+ """
+ candidate_paths: list[Path] = []
+ if env_file:
+ candidate_paths.append(Path(env_file).resolve())
+ else:
+ if getattr(sys, "frozen", False):
+ exe_dir = Path(sys.executable).resolve().parent
+ # One-folder fallback: some packagers place data files in _internal.
+ candidate_paths.append(exe_dir / ".env")
+ candidate_paths.append(exe_dir / "_internal" / ".env")
+
+ # PyInstaller runtime extraction directory (one-file and one-folder).
+ meipass = getattr(sys, "_MEIPASS", None)
+ if meipass:
+ candidate_paths.append(Path(meipass).resolve() / ".env")
+
+ candidate_paths.append(Path.cwd() / ".env")
+ candidate_paths.append(Path(__file__).resolve().parents[2] / ".env")
+
+ for path in candidate_paths:
+ if path.exists():
+ load_dotenv(path, override=False)
+ logger.debug(f"Loaded bootstrap environment from {path}")
+ return path
+
+ return None
+
+ @staticmethod
+ def _slugify_config_dir_name(value: str) -> str:
+ """Convert brand-like identifiers into a filesystem-safe directory name."""
+ sanitized = "".join(c.lower() if c.isalnum() else "_" for c in value).strip("_")
+ return sanitized or DEFAULT_CONFIG_DIR_NAME
+
+ @staticmethod
+ def get_default_config_dir_name() -> str:
+ """Get the default config directory name from environment or fallback."""
+ return os.getenv("APP_CONFIG_DIR_NAME", DEFAULT_CONFIG_DIR_NAME)
+
+ @staticmethod
+ def get_default_config_path(config_dir_name: str | None = None) -> Path:
"""Get the default configuration file path.
Returns:
Path to default config file in user's AppData/Roaming
"""
import platform
+
if platform.system() == "Windows":
base = Path.home() / "AppData" / "Roaming"
else:
base = Path.home() / ".config"
- return base / "webdrop_bridge" / "config.json"
+ return base / (config_dir_name or Config.get_default_config_dir_name()) / "config.json"
@staticmethod
- def get_default_log_dir() -> Path:
+ def get_default_log_dir(config_dir_name: str | None = None) -> Path:
"""Get the default directory for log files.
-
+
Always uses user's AppData directory to ensure permissions work
correctly in both development and installed scenarios.
@@ -367,25 +466,36 @@ class Config:
Path to default logs directory in user's AppData/Roaming
"""
import platform
+
if platform.system() == "Windows":
base = Path.home() / "AppData" / "Roaming"
else:
base = Path.home() / ".local" / "share"
- return base / "webdrop_bridge" / "logs"
+ return base / (config_dir_name or Config.get_default_config_dir_name()) / "logs"
@staticmethod
- def get_default_log_path() -> Path:
+ def get_default_log_path(config_dir_name: str | None = None) -> Path:
"""Get the default log file path.
Returns:
Path to default log file in user's AppData/Roaming/webdrop_bridge/logs
"""
- return Config.get_default_log_dir() / "webdrop_bridge.log"
+ dir_name = config_dir_name or Config.get_default_config_dir_name()
+ return Config.get_default_log_dir(dir_name) / f"{dir_name}.log"
+
+ def get_config_path(self) -> Path:
+ """Get the default config file path for this configured brand."""
+ return self.get_default_config_path(self.config_dir_name)
+
+ def get_cache_dir(self) -> Path:
+ """Get the update/cache directory for this configured brand."""
+ return self.get_default_config_path(self.config_dir_name).parent / "cache"
def __repr__(self) -> str:
"""Return developer-friendly representation."""
return (
f"Config(app={self.app_name} v{self.app_version}, "
+ f"brand={self.brand_id}, "
f"log_level={self.log_level}, "
f"allowed_roots={len(self.allowed_roots)} dirs, "
f"window={self.window_width}x{self.window_height})"
diff --git a/src/webdrop_bridge/core/config_manager.py b/src/webdrop_bridge/core/config_manager.py
index 3b0f313..4c4be27 100644
--- a/src/webdrop_bridge/core/config_manager.py
+++ b/src/webdrop_bridge/core/config_manager.py
@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
class ConfigValidator:
"""Validates configuration values against schema.
-
+
Provides detailed error messages for invalid configurations.
"""
@@ -33,10 +33,10 @@ class ConfigValidator:
@staticmethod
def validate(config_dict: Dict[str, Any]) -> List[str]:
"""Validate configuration dictionary.
-
+
Args:
config_dict: Configuration dictionary to validate
-
+
Returns:
List of validation error messages (empty if valid)
"""
@@ -53,7 +53,9 @@ class ConfigValidator:
# Check type
expected_type = rules.get("type")
if expected_type and not isinstance(value, expected_type):
- errors.append(f"{field}: expected {expected_type.__name__}, got {type(value).__name__}")
+ errors.append(
+ f"{field}: expected {expected_type.__name__}, got {type(value).__name__}"
+ )
continue
# Check allowed values
@@ -84,10 +86,10 @@ class ConfigValidator:
@staticmethod
def validate_or_raise(config_dict: Dict[str, Any]) -> None:
"""Validate configuration and raise error if invalid.
-
+
Args:
config_dict: Configuration dictionary to validate
-
+
Raises:
ConfigurationError: If configuration is invalid
"""
@@ -98,33 +100,32 @@ class ConfigValidator:
class ConfigProfile:
"""Manages named configuration profiles.
-
- Profiles are stored in ~/.webdrop-bridge/profiles/ directory as JSON files.
+
+ Profiles are stored in the brand-specific app config directory.
"""
- PROFILES_DIR = Path.home() / ".webdrop-bridge" / "profiles"
-
- def __init__(self):
+ def __init__(self, config_dir_name: str = "webdrop_bridge") -> None:
"""Initialize profile manager."""
- self.PROFILES_DIR.mkdir(parents=True, exist_ok=True)
+ self.profiles_dir = Config.get_default_config_path(config_dir_name).parent / "profiles"
+ self.profiles_dir.mkdir(parents=True, exist_ok=True)
def save_profile(self, profile_name: str, config: Config) -> Path:
"""Save configuration as a named profile.
-
+
Args:
profile_name: Name of the profile (e.g., "work", "personal")
config: Config object to save
-
+
Returns:
Path to the saved profile file
-
+
Raises:
ConfigurationError: If profile name is invalid
"""
if not profile_name or "/" in profile_name or "\\" in profile_name:
raise ConfigurationError(f"Invalid profile name: {profile_name}")
- profile_path = self.PROFILES_DIR / f"{profile_name}.json"
+ profile_path = self.profiles_dir / f"{profile_name}.json"
config_data = {
"app_name": config.app_name,
@@ -148,17 +149,17 @@ class ConfigProfile:
def load_profile(self, profile_name: str) -> Dict[str, Any]:
"""Load configuration from a named profile.
-
+
Args:
profile_name: Name of the profile to load
-
+
Returns:
Configuration dictionary
-
+
Raises:
ConfigurationError: If profile not found or invalid
"""
- profile_path = self.PROFILES_DIR / f"{profile_name}.json"
+ profile_path = self.profiles_dir / f"{profile_name}.json"
if not profile_path.exists():
raise ConfigurationError(f"Profile not found: {profile_name}")
@@ -173,25 +174,25 @@ class ConfigProfile:
def list_profiles(self) -> List[str]:
"""List all available profiles.
-
+
Returns:
List of profile names (without .json extension)
"""
- if not self.PROFILES_DIR.exists():
+ if not self.profiles_dir.exists():
return []
- return sorted([p.stem for p in self.PROFILES_DIR.glob("*.json")])
+ return sorted([p.stem for p in self.profiles_dir.glob("*.json")])
def delete_profile(self, profile_name: str) -> None:
"""Delete a profile.
-
+
Args:
profile_name: Name of the profile to delete
-
+
Raises:
ConfigurationError: If profile not found
"""
- profile_path = self.PROFILES_DIR / f"{profile_name}.json"
+ profile_path = self.profiles_dir / f"{profile_name}.json"
if not profile_path.exists():
raise ConfigurationError(f"Profile not found: {profile_name}")
@@ -209,11 +210,11 @@ class ConfigExporter:
@staticmethod
def export_to_json(config: Config, output_path: Path) -> None:
"""Export configuration to JSON file.
-
+
Args:
config: Config object to export
output_path: Path to write JSON file
-
+
Raises:
ConfigurationError: If export fails
"""
@@ -240,13 +241,13 @@ class ConfigExporter:
@staticmethod
def import_from_json(input_path: Path) -> Dict[str, Any]:
"""Import configuration from JSON file.
-
+
Args:
input_path: Path to JSON file to import
-
+
Returns:
Configuration dictionary
-
+
Raises:
ConfigurationError: If import fails or validation fails
"""
diff --git a/src/webdrop_bridge/core/drag_interceptor.py b/src/webdrop_bridge/core/drag_interceptor.py
index f00eae2..6f37ce5 100644
--- a/src/webdrop_bridge/core/drag_interceptor.py
+++ b/src/webdrop_bridge/core/drag_interceptor.py
@@ -2,7 +2,7 @@
import logging
from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Union
from PySide6.QtCore import QMimeData, Qt, QUrl, Signal
from PySide6.QtGui import QDrag
@@ -21,14 +21,18 @@ class DragInterceptor(QWidget):
Intercepts drag events from web content, converts Azure Blob Storage URLs
to local paths, validates them, and initiates native Qt drag operations.
+ Supports both single and multiple file drag operations.
+
Signals:
drag_started: Emitted when a drag operation begins successfully
+ (source_urls_or_paths: str, local_paths: str - comma-separated for multiple)
drag_failed: Emitted when drag initiation fails
+ (source_urls_or_paths: str, error_message: str)
"""
# Signals with string parameters
- drag_started = Signal(str, str) # (url_or_path, local_path)
- drag_failed = Signal(str, str) # (url_or_path, error_message)
+ drag_started = Signal(str, str) # (source_urls_or_paths, local_paths)
+ drag_failed = Signal(str, str) # (source_urls_or_paths, error_message)
def __init__(self, config: Config, parent: Optional[QWidget] = None):
"""Initialize the drag interceptor.
@@ -40,83 +44,123 @@ class DragInterceptor(QWidget):
super().__init__(parent)
self.config = config
self._validator = PathValidator(
- config.allowed_roots,
- check_file_exists=config.check_file_exists
+ config.allowed_roots, check_file_exists=config.check_file_exists
)
self._url_converter = URLConverter(config)
- def handle_drag(self, text: str) -> bool:
- """Handle drag event from web view.
+ def handle_drag(self, text_or_list: Union[str, List[str]]) -> bool:
+ """Handle drag event from web view (single or multiple files).
- Determines if the text is an Azure URL or file path, converts if needed,
+ Determines if the text/list contains Azure URLs or file paths, converts if needed,
validates, and initiates native drag operation.
+ Supports:
+ - Single string (backward compatible)
+ - List of strings (multiple drag support)
+
Args:
- text: Azure Blob Storage URL or file path from web drag
+ text_or_list: Azure URL/file path (str) or list of URLs/paths (List[str])
Returns:
True if native drag was initiated, False otherwise
"""
- if not text or not text.strip():
+ # Normalize input to list
+ if isinstance(text_or_list, str):
+ text_list = [text_or_list]
+ elif isinstance(text_or_list, (list, tuple)):
+ text_list = list(text_or_list)
+ else:
+ error_msg = f"Unexpected drag data type: {type(text_or_list)}"
+ logger.error(error_msg)
+ self.drag_failed.emit("", error_msg)
+ return False
+
+ # Validate that we have content
+ if not text_list or all(not t or not str(t).strip() for t in text_list):
error_msg = "Empty drag text"
logger.warning(error_msg)
self.drag_failed.emit("", error_msg)
return False
- text = text.strip()
- logger.debug(f"Handling drag for text: {text}")
+ # Clean up text items
+ text_list = [str(t).strip() for t in text_list if str(t).strip()]
+ logger.debug(f"Handling drag for {len(text_list)} item(s)")
- # Check if it's an Azure URL and convert to local path
- if self._url_converter.is_azure_url(text):
- local_path = self._url_converter.convert_url_to_path(text)
- if local_path is None:
- error_msg = "No mapping found for URL"
- logger.warning(f"{error_msg}: {text}")
+ # Convert each text to local path
+ local_paths = []
+ source_texts = []
+
+ for text in text_list:
+ # Check if it's an Azure URL and convert to local path
+ if self._url_converter.is_azure_url(text):
+ local_path = self._url_converter.convert_url_to_path(text)
+ if local_path is None:
+ error_msg = f"No mapping found for URL: {text}"
+ logger.warning(error_msg)
+ self.drag_failed.emit(text, error_msg)
+ return False
+ source_texts.append(text)
+ else:
+ # Treat as direct file path
+ local_path = Path(text)
+ source_texts.append(text)
+
+ # Validate the path
+ try:
+ self._validator.validate(local_path)
+ except ValidationError as e:
+ error_msg = str(e)
+ logger.warning(f"Validation failed for {local_path}: {error_msg}")
self.drag_failed.emit(text, error_msg)
return False
- source_text = text
- else:
- # Treat as direct file path
- local_path = Path(text)
- source_text = text
- # Validate the path
- try:
- self._validator.validate(local_path)
- except ValidationError as e:
- error_msg = str(e)
- logger.warning(f"Validation failed for {local_path}: {error_msg}")
- self.drag_failed.emit(source_text, error_msg)
- return False
+ local_paths.append(local_path)
- logger.info(f"Initiating drag for: {local_path}")
+ logger.info(
+ f"Initiating drag for {len(local_paths)} file(s): {[str(p) for p in local_paths]}"
+ )
- # Create native file drag
- success = self._create_native_drag(local_path)
+ # Create native file drag with all paths
+ success = self._create_native_drag(local_paths)
if success:
- self.drag_started.emit(source_text, str(local_path))
+ source_str = " | ".join(source_texts) if len(source_texts) > 1 else source_texts[0]
+ paths_str = (
+ " | ".join(str(p) for p in local_paths)
+ if len(local_paths) > 1
+ else str(local_paths[0])
+ )
+ self.drag_started.emit(source_str, paths_str)
else:
error_msg = "Failed to create native drag operation"
logger.error(error_msg)
- self.drag_failed.emit(source_text, error_msg)
+ source_str = " | ".join(source_texts) if len(source_texts) > 1 else source_texts[0]
+ self.drag_failed.emit(source_str, error_msg)
return success
- def _create_native_drag(self, file_path: Path) -> bool:
+ def _create_native_drag(self, file_paths: Union[Path, List[Path]]) -> bool:
"""Create a native file system drag operation.
Args:
- file_path: Local file path to drag
+ file_paths: Single local file path or list of local file paths
Returns:
True if drag was created successfully
"""
try:
- # Create MIME data with file URL
+ # Normalize to list
+ if isinstance(file_paths, Path):
+ paths_list = [file_paths]
+ else:
+ paths_list = list(file_paths)
+
+ # Create MIME data with file URLs
mime_data = QMimeData()
- file_url = QUrl.fromLocalFile(str(file_path))
- mime_data.setUrls([file_url])
+ file_urls = [QUrl.fromLocalFile(str(p)) for p in paths_list]
+ mime_data.setUrls(file_urls)
+
+ logger.debug(f"Creating drag with {len(file_urls)} file(s)")
# Create and execute drag
drag = QDrag(self)
diff --git a/src/webdrop_bridge/core/updater.py b/src/webdrop_bridge/core/updater.py
index 3de4b9f..c235caa 100644
--- a/src/webdrop_bridge/core/updater.py
+++ b/src/webdrop_bridge/core/updater.py
@@ -5,9 +5,11 @@ verifying checksums from Forgejo releases.
"""
import asyncio
+import fnmatch
import hashlib
import json
import logging
+import platform
import socket
from dataclasses import dataclass
from datetime import datetime, timedelta
@@ -34,7 +36,16 @@ class Release:
class UpdateManager:
"""Manages auto-updates via Forgejo releases API."""
- def __init__(self, current_version: str, config_dir: Optional[Path] = None):
+ def __init__(
+ self,
+ current_version: str,
+ config_dir: Optional[Path] = None,
+ brand_id: str = "webdrop_bridge",
+ forgejo_url: str = "https://git.him-tools.de",
+ repo: str = "HIM-public/webdrop-bridge",
+ update_channel: str = "stable",
+ manifest_name: str = "release-manifest.json",
+ ):
"""Initialize update manager.
Args:
@@ -42,18 +53,163 @@ class UpdateManager:
config_dir: Directory for storing update cache. Defaults to temp.
"""
self.current_version = current_version
- self.forgejo_url = "https://git.him-tools.de"
- self.repo = "HIM-public/webdrop-bridge"
- self.api_endpoint = (
- f"{self.forgejo_url}/api/v1/repos/{self.repo}/releases/latest"
- )
-
+ self.brand_id = brand_id
+ self.forgejo_url = forgejo_url.rstrip("/")
+ self.repo = repo
+ self.update_channel = update_channel
+ self.manifest_name = manifest_name
+ self.api_endpoint = f"{self.forgejo_url}/api/v1/repos/{self.repo}/releases/latest"
+
# Cache management
self.cache_dir = config_dir or Path.home() / ".webdrop-bridge"
self.cache_dir.mkdir(parents=True, exist_ok=True)
self.cache_file = self.cache_dir / "update_check.json"
self.cache_ttl = timedelta(hours=24)
+ def _get_platform_key(self) -> str:
+ """Return the release-manifest platform key for the current system."""
+ system = platform.system()
+ machine = platform.machine().lower()
+
+ if system == "Windows":
+ arch = "x64" if machine in {"amd64", "x86_64"} else machine
+ return f"windows-{arch}"
+ if system == "Darwin":
+ return "macos-universal"
+ return f"{system.lower()}-{machine}"
+
+ def _find_asset(self, assets: list[dict], asset_name: str) -> Optional[dict]:
+ """Find an asset by exact name."""
+ for asset in assets:
+ if asset.get("name") == asset_name:
+ return asset
+ return None
+
+ def _find_manifest_asset(self, release: Release) -> Optional[dict]:
+ """Find the shared release manifest asset if present."""
+ return self._find_asset(release.assets, self.manifest_name)
+
+ def _download_json_asset(self, url: str) -> Optional[dict]:
+ """Download and parse a JSON asset from a release."""
+ try:
+ with urlopen(url, timeout=10) as response:
+ # Some release pipelines may upload JSON files with UTF-8 BOM.
+ # Use utf-8-sig to transparently handle both BOM and non-BOM files.
+ return json.loads(response.read().decode("utf-8-sig"))
+ except (URLError, json.JSONDecodeError) as e:
+ logger.error(f"Failed to download JSON asset: {e}")
+ return None
+
+ async def _load_release_manifest(self, release: Release) -> Optional[dict]:
+ """Load the shared release manifest if present."""
+ manifest_asset = self._find_manifest_asset(release)
+ if not manifest_asset:
+ return None
+
+ loop = asyncio.get_event_loop()
+ return await asyncio.wait_for(
+ loop.run_in_executor(
+ None, self._download_json_asset, manifest_asset["browser_download_url"]
+ ),
+ timeout=15,
+ )
+
+ def _resolve_assets_from_manifest(
+ self, release: Release, manifest: dict
+ ) -> tuple[Optional[dict], Optional[dict]]:
+ """Resolve installer and checksum assets from a shared release manifest."""
+ if manifest.get("channel") not in {None, "", self.update_channel}:
+ logger.info(
+ "Release manifest channel %s does not match configured channel %s",
+ manifest.get("channel"),
+ self.update_channel,
+ )
+ return None, None
+
+ brand_entry = manifest.get("brands", {}).get(self.brand_id, {})
+ platform_entry = brand_entry.get(self._get_platform_key(), {})
+ installer_name = platform_entry.get("installer")
+ checksum_name = platform_entry.get("checksum")
+
+ if not installer_name:
+ logger.warning(
+ "No installer entry found for brand=%s platform=%s in release manifest",
+ self.brand_id,
+ self._get_platform_key(),
+ )
+ return None, None
+
+ return self._find_asset(release.assets, installer_name), self._find_asset(
+ release.assets, checksum_name
+ )
+
+ def _resolve_assets_legacy(self, release: Release) -> tuple[Optional[dict], Optional[dict]]:
+ """Resolve installer and checksum assets using legacy filename matching."""
+ is_windows = platform.system() == "Windows"
+ extension = ".msi" if is_windows else ".dmg"
+ brand_prefix = f"{self.brand_id}-*"
+
+ installer_asset = None
+
+ # Prefer brand-specific naming when possible.
+ if self.brand_id == "webdrop_bridge":
+ preferred_patterns = ["webdropbridge-*.msi", "webdropbridge*.msi"]
+ else:
+ preferred_patterns = [f"{self.brand_id.lower()}-*.msi", f"{self.brand_id.lower()}*.msi"]
+
+ # 1) Try strict brand-pattern match first
+ for asset in release.assets:
+ asset_name = asset.get("name", "")
+ asset_name_lower = asset_name.lower()
+ if not asset_name_lower.endswith(extension):
+ continue
+ if any(fnmatch.fnmatch(asset_name_lower, pattern) for pattern in preferred_patterns):
+ installer_asset = asset
+ break
+
+ # 2) Fallback: preserve previous behavior (first installer for platform)
+ for asset in release.assets:
+ if installer_asset:
+ break
+ asset_name = asset.get("name", "")
+ if not asset_name.endswith(extension):
+ continue
+
+ if self.brand_id != "webdrop_bridge" and fnmatch.fnmatch(
+ asset_name.lower(), brand_prefix.lower()
+ ):
+ installer_asset = asset
+ break
+
+ if self.brand_id == "webdrop_bridge":
+ installer_asset = asset
+ break
+
+ if not installer_asset:
+ return None, None
+
+ checksum_asset = self._find_asset(release.assets, f"{installer_asset['name']}.sha256")
+ return installer_asset, checksum_asset
+
+ async def _resolve_release_assets(
+ self, release: Release
+ ) -> tuple[Optional[dict], Optional[dict]]:
+ """Resolve installer and checksum assets for the configured brand."""
+ try:
+ manifest = await self._load_release_manifest(release)
+ except asyncio.TimeoutError:
+ logger.warning(
+ "Timed out while loading release manifest, falling back to legacy lookup"
+ )
+ manifest = None
+
+ if manifest:
+ installer_asset, checksum_asset = self._resolve_assets_from_manifest(release, manifest)
+ if installer_asset:
+ return installer_asset, checksum_asset
+
+ return self._resolve_assets_legacy(release)
+
def _parse_version(self, version_str: str) -> tuple[int, int, int]:
"""Parse semantic version string to tuple.
@@ -68,7 +224,7 @@ class UpdateManager:
"""
# Remove 'v' prefix if present
version_str = version_str.lstrip("v")
-
+
try:
parts = version_str.split(".")
if len(parts) != 3:
@@ -146,44 +302,45 @@ class UpdateManager:
Release object if newer version available, None otherwise
"""
logger.debug(f"check_for_updates() called, current version: {self.current_version}")
-
- # Try cache first
- logger.debug("Checking cache...")
+
+ # Only use cache when a pending update was already found (avoids
+ # showing the update dialog on every start). "No update" is never
+ # cached so that a freshly published release is visible immediately.
+ logger.debug("Checking cache for pending update...")
cached = self._load_cache()
if cached:
- logger.debug("Found cached release")
release_data = cached.get("release")
if release_data:
version = release_data["tag_name"].lstrip("v")
- if not self._is_newer_version(version):
- logger.info("No newer version available (cached)")
- return None
- return Release(**release_data)
+ logger.debug(f"Cached pending update version: {version}")
+ if self._is_newer_version(version):
+ logger.info(f"Returning cached pending update: {version}")
+ return Release(**release_data)
+ else:
+ # Current version is >= cached release (e.g. already updated)
+ logger.debug("Cached release is no longer newer — discarding cache")
+ self.cache_file.unlink(missing_ok=True)
- # Fetch from API
+ # Always fetch fresh from API so new releases are seen immediately
logger.debug("Fetching from API...")
try:
logger.info(f"Checking for updates from {self.api_endpoint}")
-
- # Run in thread pool with aggressive timeout
+
loop = asyncio.get_event_loop()
response = await asyncio.wait_for(
- loop.run_in_executor(
- None, self._fetch_release
- ),
- timeout=8 # Timeout after network call also has timeout
+ loop.run_in_executor(None, self._fetch_release),
+ timeout=8,
)
-
+
if not response:
return None
- # Check if newer version
version = response["tag_name"].lstrip("v")
if not self._is_newer_version(version):
logger.info(f"Latest version {version} is not newer than {self.current_version}")
- self._save_cache(response)
return None
+ # Cache the found update so repeated starts don't hammer the API
logger.info(f"New version available: {version}")
release = Release(**response)
self._save_cache(response)
@@ -204,11 +361,11 @@ class UpdateManager:
"""
try:
logger.debug(f"Fetching release from {self.api_endpoint}")
-
+
# Set socket timeout to prevent hanging
old_timeout = socket.getdefaulttimeout()
socket.setdefaulttimeout(5)
-
+
try:
logger.debug("Opening URL connection...")
with urlopen(self.api_endpoint, timeout=5) as response:
@@ -227,21 +384,19 @@ class UpdateManager:
}
finally:
socket.setdefaulttimeout(old_timeout)
-
+
except socket.timeout as e:
logger.error(f"Socket timeout (5s) connecting to {self.api_endpoint}")
return None
- except TimeoutError as e:
- logger.error(f"Timeout error: {e}")
- return None
except Exception as e:
logger.error(f"Failed to fetch release: {type(e).__name__}: {e}")
import traceback
+
logger.debug(traceback.format_exc())
return None
async def download_update(
- self, release: Release, output_dir: Optional[Path] = None
+ self, release: Release, output_dir: Optional[Path] = None, progress_callback=None
) -> Optional[Path]:
"""Download installer from release assets.
@@ -256,12 +411,7 @@ class UpdateManager:
logger.error("No assets found in release")
return None
- # Find .msi or .dmg file
- installer_asset = None
- for asset in release.assets:
- if asset["name"].endswith((".msi", ".dmg")):
- installer_asset = asset
- break
+ installer_asset, _ = await self._resolve_release_assets(release)
if not installer_asset:
logger.error("No installer found in release assets")
@@ -273,7 +423,7 @@ class UpdateManager:
try:
logger.info(f"Downloading {installer_asset['name']}")
-
+
# Run in thread pool with 5-minute timeout for large files
loop = asyncio.get_event_loop()
success = await asyncio.wait_for(
@@ -282,10 +432,11 @@ class UpdateManager:
self._download_file,
installer_asset["browser_download_url"],
output_file,
+ progress_callback,
),
- timeout=300
+ timeout=300,
)
-
+
if success:
logger.info(f"Downloaded to {output_file}")
return output_file
@@ -302,12 +453,13 @@ class UpdateManager:
output_file.unlink()
return None
- def _download_file(self, url: str, output_path: Path) -> bool:
+ def _download_file(self, url: str, output_path: Path, progress_callback=None) -> bool:
"""Download file from URL (blocking).
Args:
url: URL to download from
output_path: Path to save file
+ progress_callback: Optional callable(bytes_downloaded, total_bytes)
Returns:
True if successful, False otherwise
@@ -315,17 +467,28 @@ class UpdateManager:
try:
logger.debug(f"Downloading from {url}")
with urlopen(url, timeout=300) as response: # 5 min timeout
+ total = int(response.headers.get("Content-Length", 0))
+ downloaded = 0
+ chunk_size = 65536 # 64 KB chunks
with open(output_path, "wb") as f:
- f.write(response.read())
+ while True:
+ chunk = response.read(chunk_size)
+ if not chunk:
+ break
+ f.write(chunk)
+ downloaded += len(chunk)
+ if progress_callback:
+ try:
+ progress_callback(downloaded, total)
+ except Exception:
+ pass # Never let progress errors abort the download
logger.debug(f"Downloaded {output_path.stat().st_size} bytes")
return True
except URLError as e:
logger.error(f"Download failed: {e}")
return False
- async def verify_checksum(
- self, file_path: Path, release: Release
- ) -> bool:
+ async def verify_checksum(self, file_path: Path, release: Release) -> bool:
"""Verify file checksum against release checksum file.
Args:
@@ -335,12 +498,11 @@ class UpdateManager:
Returns:
True if checksum matches, False otherwise
"""
- # Find .sha256 file in release assets
- checksum_asset = None
- for asset in release.assets:
- if asset["name"].endswith(".sha256"):
- checksum_asset = asset
- break
+ installer_asset, checksum_asset = await self._resolve_release_assets(release)
+ installer_name = installer_asset["name"] if installer_asset else file_path.name
+
+ if not checksum_asset:
+ checksum_asset = self._find_asset(release.assets, f"{installer_name}.sha256")
if not checksum_asset:
logger.warning("No checksum file found in release")
@@ -348,7 +510,7 @@ class UpdateManager:
try:
logger.info("Verifying checksum...")
-
+
# Download checksum file with 30 second timeout
loop = asyncio.get_event_loop()
checksum_content = await asyncio.wait_for(
@@ -357,7 +519,7 @@ class UpdateManager:
self._download_checksum,
checksum_asset["browser_download_url"],
),
- timeout=30
+ timeout=30,
)
if not checksum_content:
@@ -377,9 +539,7 @@ class UpdateManager:
logger.info("Checksum verification passed")
return True
else:
- logger.error(
- f"Checksum mismatch: {file_checksum} != {expected_checksum}"
- )
+ logger.error(f"Checksum mismatch: {file_checksum} != {expected_checksum}")
return False
except asyncio.TimeoutError:
@@ -426,9 +586,12 @@ class UpdateManager:
import subprocess
if platform.system() == "Windows":
- # Windows: Run MSI installer
+ # Windows: MSI files must be launched via msiexec
logger.info(f"Launching installer: {installer_path}")
- subprocess.Popen([str(installer_path)])
+ if str(installer_path).lower().endswith(".msi"):
+ subprocess.Popen(["msiexec.exe", "/i", str(installer_path)])
+ else:
+ subprocess.Popen([str(installer_path)])
return True
elif platform.system() == "Darwin":
# macOS: Mount DMG and run installer
diff --git a/src/webdrop_bridge/main.py b/src/webdrop_bridge/main.py
index d63ad97..1194d69 100644
--- a/src/webdrop_bridge/main.py
+++ b/src/webdrop_bridge/main.py
@@ -1,11 +1,22 @@
"""WebDrop Bridge - Application entry point."""
+import os
import sys
+# Force Chromium to treat hover as primary input method and disable touch detection
+# This ensures CSS media queries (hover: hover) evaluate correctly for desktop applications
+os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = "--touch-events=disabled"
+
+# Enable Qt WebEngine Remote Debugging Protocol (Chromium Developer Tools)
+# Allows debugging via browser DevTools at http://localhost:9222 or edge://inspect
+os.environ["QTWEBENGINE_REMOTE_DEBUGGING"] = "9222"
+
from PySide6.QtWidgets import QApplication
from webdrop_bridge.config import Config, ConfigurationError
from webdrop_bridge.ui.main_window import MainWindow
+from webdrop_bridge.utils.i18n import get_translations_dir
+from webdrop_bridge.utils.i18n import initialize as i18n_init
from webdrop_bridge.utils.logging import get_logger, setup_logging
@@ -19,6 +30,8 @@ def main() -> int:
int: Exit code (0 for success, non-zero for error)
"""
try:
+ Config.load_bootstrap_env()
+
# Load configuration from file if it exists, otherwise from environment
config_path = Config.get_default_config_path()
if config_path.exists():
@@ -41,6 +54,11 @@ def main() -> int:
logger.info(f"Starting {config.app_name} v{config.app_version}")
logger.debug(f"Configuration: {config}")
+ # Initialize internationalization
+ translations_dir = get_translations_dir()
+ i18n_init(config.language, translations_dir)
+ logger.debug(f"i18n initialized: language={config.language}, dir={translations_dir}")
+
except ConfigurationError as e:
print(f"Configuration error: {e}", file=sys.stderr)
return 1
@@ -57,7 +75,7 @@ def main() -> int:
window.show()
logger.info("Main window opened successfully")
-
+
# Check for updates on startup (non-blocking, async)
window.check_for_updates_startup()
diff --git a/src/webdrop_bridge/ui/bridge_script_intercept.js b/src/webdrop_bridge/ui/bridge_script_intercept.js
index b3c2f52..53e28f0 100644
--- a/src/webdrop_bridge/ui/bridge_script_intercept.js
+++ b/src/webdrop_bridge/ui/bridge_script_intercept.js
@@ -11,40 +11,45 @@
console.log('%c[WebDrop Intercept] Script loaded - INTERCEPT_ENABLED=' + INTERCEPT_ENABLED, 'background: #2196F3; color: white; font-weight: bold; padding: 4px 8px;');
- var currentDragUrl = null;
+ var currentDragUrls = []; // Array to support multiple URLs
var angularDragHandlers = [];
var originalAddEventListener = EventTarget.prototype.addEventListener;
var listenerPatchActive = true;
+ var dragHandlerInstalled = false;
- // Capture Authorization token from XHR requests
+ // Capture Authorization token from XHR requests (only if checkout is enabled)
window.capturedAuthToken = null;
- var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
- XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
- if (header === 'Authorization' && value.startsWith('Bearer ')) {
- window.capturedAuthToken = value;
- console.log('[Intercept] Captured auth token');
- }
- return originalXHRSetRequestHeader.apply(this, arguments);
- };
-
- // ============================================================================
- // PART 1: Intercept Angular's dragstart listener registration
- // ============================================================================
-
- EventTarget.prototype.addEventListener = function(type, listener, options) {
- if (listenerPatchActive && type === 'dragstart' && listener) {
- // Store Angular's dragstart handler instead of registering it
- console.log('[Intercept] Storing Angular dragstart listener for', this.tagName || this.constructor.name);
- angularDragHandlers.push({
- target: this,
- listener: listener,
- options: options
- });
- return; // Don't actually register it yet
+ if (window.webdropConfig && window.webdropConfig.enableCheckout) {
+ console.log('[Intercept] Auth token capture enabled (checkout feature active)');
+ var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+ XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
+ if (header === 'Authorization' && value.startsWith('Bearer ')) {
+ window.capturedAuthToken = value;
+ console.log('[Intercept] Captured auth token');
+ }
+ return originalXHRSetRequestHeader.apply(this, arguments);
+ };
+ } else {
+ console.log('[Intercept] Auth token capture disabled (checkout feature inactive)');
}
- // All other events: use original
- return originalAddEventListener.call(this, type, listener, options);
- };
+
+ // Only patch addEventListener for dragstart events
+ // This minimizes impact on other event listeners (mouseover, mouseenter, etc.)
+ EventTarget.prototype.addEventListener = function(type, listener, options) {
+ if (listenerPatchActive && type === 'dragstart' && listener) {
+ // Store Angular's dragstart handler instead of registering it
+ console.log('[Intercept] Storing Angular dragstart listener for', this.tagName || this.constructor.name);
+ angularDragHandlers.push({
+ target: this,
+ listener: listener,
+ options: options
+ });
+ return; // Don't actually register it yet
+ }
+ // All other events (mouseover, mouseenter, mousedown, etc.): use original
+ // This is critical to ensure mouseover/hover events work properly
+ return originalAddEventListener.call(this, type, listener, options);
+ };
// ============================================================================
// PART 2: Intercept DataTransfer.setData to capture URL
@@ -54,8 +59,14 @@
DataTransfer.prototype.setData = function(format, data) {
if (format === 'text/plain' || format === 'text/uri-list') {
- currentDragUrl = data;
- console.log('%c[Intercept] Captured URL:', 'color: #4CAF50; font-weight: bold;', data.substring(0, 80));
+ // text/uri-list contains newline-separated URLs
+ // text/plain may be single URL or multiple newline-separated URLs
+ currentDragUrls = data.trim().split('\n').filter(function(url) {
+ return url.trim().length > 0;
+ }).map(function(url) {
+ return url.trim();
+ });
+ console.log('%c[Intercept] Captured ' + currentDragUrls.length + ' URL(s)', 'color: #4CAF50; font-weight: bold;', currentDragUrls[0].substring(0, 60));
}
return originalSetData.call(this, format, data);
};
@@ -75,14 +86,20 @@
return;
}
- // Stop intercepting addEventListener
- listenerPatchActive = false;
+ // Only install once, even if called multiple times
+ if (dragHandlerInstalled) {
+ console.log('[Intercept] Handler already installed, skipping');
+ return;
+ }
+
+ dragHandlerInstalled = true;
+
+ // NOTE: Keep listenerPatchActive = true to catch new Angular handlers registered later
+ // This is important for page reloads where Angular might register handlers at different times
// Register OUR handler in capture phase
originalAddEventListener.call(document, 'dragstart', function(e) {
- currentDragUrl = null; // Reset
-
- console.log('%c[Intercept] dragstart', 'background: #FF9800; color: white; padding: 2px 6px;', 'ALT:', e.altKey);
+ currentDragUrls = []; // Reset
// Call Angular's handlers first to let them set the data
var handled = 0;
@@ -99,32 +116,41 @@
}
}
- console.log('[Intercept] Called', handled, 'Angular handlers, URL:', currentDragUrl ? currentDragUrl.substring(0, 60) : 'none');
+ console.log('[Intercept] Called', handled, 'Angular handlers, URLs:', currentDragUrls.length, 'URL(s)', currentDragUrls.length > 0 ? currentDragUrls[0].substring(0, 60) : 'none');
// NOW check if we should intercept
- if (e.altKey && currentDragUrl) {
+ // Intercept any drag with URLs that match our configured mappings
+ if (currentDragUrls.length > 0) {
var shouldIntercept = false;
- // Check against configured URL mappings
+ // Check each URL against configured URL mappings
+ // Intercept if ANY URL matches
if (window.webdropConfig && window.webdropConfig.urlMappings) {
- for (var j = 0; j < window.webdropConfig.urlMappings.length; j++) {
- var mapping = window.webdropConfig.urlMappings[j];
- if (currentDragUrl.toLowerCase().startsWith(mapping.url_prefix.toLowerCase())) {
- shouldIntercept = true;
- console.log('[Intercept] URL matches mapping for:', mapping.local_path);
- break;
+ for (var k = 0; k < currentDragUrls.length; k++) {
+ var dragUrl = currentDragUrls[k];
+ for (var j = 0; j < window.webdropConfig.urlMappings.length; j++) {
+ var mapping = window.webdropConfig.urlMappings[j];
+ if (dragUrl.toLowerCase().startsWith(mapping.url_prefix.toLowerCase())) {
+ shouldIntercept = true;
+ console.log('[Intercept] URL #' + (k+1) + ' matches mapping for:', mapping.local_path);
+ break;
+ }
}
+ if (shouldIntercept) break;
}
} else {
// Fallback: Check for legacy Z: drive pattern if no config available
- shouldIntercept = /^z:/i.test(currentDragUrl);
- if (shouldIntercept) {
- console.warn('[Intercept] Using fallback Z: drive pattern (no URL mappings configured)');
+ for (var k = 0; k < currentDragUrls.length; k++) {
+ if (/^z:/i.test(currentDragUrls[k])) {
+ shouldIntercept = true;
+ console.warn('[Intercept] Using fallback Z: drive pattern (no URL mappings configured)');
+ break;
+ }
}
}
if (shouldIntercept) {
- console.log('%c[Intercept] PREVENTING browser drag, using Qt',
+ console.log('%c[Intercept] PREVENTING browser drag, using Qt for ' + currentDragUrls.length + ' file(s)',
'background: #F44336; color: white; font-weight: bold; padding: 4px 8px;');
e.preventDefault();
@@ -132,14 +158,15 @@
ensureChannel(function() {
if (window.bridge && typeof window.bridge.start_file_drag === 'function') {
- console.log('%c[Intercept] → Qt: start_file_drag', 'color: #9C27B0; font-weight: bold;');
- window.bridge.start_file_drag(currentDragUrl);
+ console.log('%c[Intercept] → Qt: start_file_drag with ' + currentDragUrls.length + ' file(s)', 'color: #9C27B0; font-weight: bold;');
+ // Pass as JSON string to avoid Qt WebChannel array conversion issues
+ window.bridge.start_file_drag(JSON.stringify(currentDragUrls));
} else {
console.error('[Intercept] bridge.start_file_drag not available!');
}
});
- currentDragUrl = null;
+ currentDragUrls = [];
return false;
}
}
@@ -151,8 +178,23 @@
}
// Wait for Angular to register its listeners, then install our handler
- // Start checking after 2 seconds (give Angular time to load on first page load)
- setTimeout(installDragHandler, 2000);
+ // Start checking after 3 seconds (give Angular time to load), then retry for up to 30 seconds
+ var installRetries = 0;
+ var maxRetries = 27; // 3 initial + 27 retries * 1s = 30s total
+
+ function scheduleInstall() {
+ if (dragHandlerInstalled) return; // Already done
+ installRetries++;
+ console.log('[Intercept] Install attempt', installRetries, '/', maxRetries + 3);
+ installDragHandler();
+ if (!dragHandlerInstalled && installRetries < maxRetries) {
+ setTimeout(scheduleInstall, 1000);
+ } else if (!dragHandlerInstalled) {
+ console.warn('[Intercept] Gave up waiting for Angular handlers after 30s');
+ }
+ }
+
+ setTimeout(scheduleInstall, 3000);
// ============================================================================
// PART 3: QWebChannel connection
@@ -188,7 +230,7 @@
});
}
- console.log('%c[WebDrop Intercept] Ready! ALT-drag will use Qt file drag.',
+ console.log('%c[WebDrop Intercept] Ready! URL-mapped drags will use Qt file drag.',
'background: #4CAF50; color: white; font-weight: bold; padding: 4px 8px;');
} catch(e) {
console.error('[WebDrop Intercept] FATAL ERROR in bridge script:', e);
diff --git a/src/webdrop_bridge/ui/developer_tools.py b/src/webdrop_bridge/ui/developer_tools.py
new file mode 100644
index 0000000..30cfe61
--- /dev/null
+++ b/src/webdrop_bridge/ui/developer_tools.py
@@ -0,0 +1,54 @@
+"""Developer Tools for WebDrop Bridge - using Chromium Remote Debugging Protocol."""
+
+import logging
+from typing import Any
+
+from PySide6.QtCore import QTimer, QUrl
+from PySide6.QtWebEngineWidgets import QWebEngineView
+from PySide6.QtWidgets import QVBoxLayout, QWidget
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["DeveloperToolsWidget"]
+
+
+class DeveloperToolsWidget(QWidget):
+ """Embedded Chromium Developer Tools Inspector.
+
+ Loads the Chromium DevTools UI using the Remote Debugging Protocol
+ running on localhost:9222.
+
+ Features:
+ - Real HTML/CSS Inspector with live editing
+ - Full JavaScript Console with all DevTools features
+ - Network monitoring
+ - Performance profiling
+ - Storage inspection
+ - All standard Chromium DevTools features
+ """
+
+ def __init__(self, web_view: Any) -> None:
+ """Initialize Developer Tools.
+
+ Args:
+ web_view: The QWebEngineView to debug
+ """
+ super().__init__()
+ self.web_view = web_view
+
+ # Create layout
+ layout = QVBoxLayout(self)
+ layout.setContentsMargins(0, 0, 0, 0)
+ layout.setSpacing(0)
+
+ # Create WebEngineView for DevTools UI
+ self.dev_tools_view = QWebEngineView()
+ layout.addWidget(self.dev_tools_view)
+
+ # Load DevTools after delay to let debugger start
+ QTimer.singleShot(500, self._load_devtools)
+
+ def _load_devtools(self) -> None:
+ """Load the DevTools targets page from localhost:9222."""
+ logger.info("Loading DevTools from http://localhost:9222")
+ self.dev_tools_view.load(QUrl("http://localhost:9222"))
diff --git a/src/webdrop_bridge/ui/main_window.py b/src/webdrop_bridge/ui/main_window.py
index 0a12eca..7b7bb5a 100644
--- a/src/webdrop_bridge/ui/main_window.py
+++ b/src/webdrop_bridge/ui/main_window.py
@@ -3,11 +3,13 @@
import asyncio
import json
import logging
+import os
import re
+import subprocess
import sys
from datetime import datetime
from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
from PySide6.QtCore import (
QEvent,
@@ -22,12 +24,13 @@ from PySide6.QtCore import (
Signal,
Slot,
)
-from PySide6.QtGui import QIcon, QMouseEvent
+from PySide6.QtGui import QDesktopServices, QIcon, QKeySequence, QMouseEvent, QShortcut
from PySide6.QtWebChannel import QWebChannel
from PySide6.QtWebEngineCore import QWebEngineDownloadRequest, QWebEngineScript
from PySide6.QtWidgets import (
QLabel,
QMainWindow,
+ QMessageBox,
QSizePolicy,
QSpacerItem,
QStatusBar,
@@ -41,6 +44,7 @@ from webdrop_bridge.config import Config
from webdrop_bridge.core.drag_interceptor import DragInterceptor
from webdrop_bridge.core.validator import PathValidator
from webdrop_bridge.ui.restricted_web_view import RestrictedWebEngineView
+from webdrop_bridge.utils.i18n import tr
logger = logging.getLogger(__name__)
@@ -199,43 +203,197 @@ DEFAULT_WELCOME_PAGE = """
"""
+class OpenDropZone(QWidget):
+ """Drop target widget that opens dragged files with their system default application.
+
+ Displays an 'open folder' icon in the navigation toolbar. When a file is
+ dragged from the web view and dropped here, the file's URL is passed to
+ ``QDesktopServices.openUrl()`` so the OS opens it with the associated
+ programme — exactly the same way double-clicking a file in Explorer/Finder
+ would behave.
+
+ Visual feedback is provided on drag-enter (green border highlight) so the
+ user can see the drop target is active.
+
+ Signals:
+ file_opened (str): Emitted with the local file path when successfully opened.
+ file_open_failed (str, str): Emitted with (path, error_message) on failure.
+ """
+
+ file_opened = Signal(str)
+ file_open_failed = Signal(str, str)
+
+ _NORMAL_STYLE = "QLabel { padding: 4px; border: 2px solid transparent; border-radius: 4px; }"
+ _HOVER_STYLE = (
+ "QLabel { padding: 4px; border: 2px solid #4CAF50; border-radius: 4px;"
+ " background: #E8F5E9; }"
+ )
+
+ def __init__(self, parent: Optional[QWidget] = None) -> None:
+ """Initialize the OpenDropZone widget.
+
+ Args:
+ parent: Parent widget.
+ """
+ super().__init__(parent)
+ self.setAcceptDrops(True)
+
+ layout = QVBoxLayout(self)
+ layout.setContentsMargins(0, 0, 0, 0)
+
+ self._icon_label = QLabel(self)
+ icon = self.style().standardIcon(self.style().StandardPixmap.SP_DirOpenIcon)
+ pixmap = icon.pixmap(QSize(32, 32))
+ self._icon_label.setPixmap(pixmap)
+ self._icon_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+ self._icon_label.setStyleSheet(self._NORMAL_STYLE)
+ self._icon_label.setToolTip(tr("toolbar.tooltip.open_drop"))
+ layout.addWidget(self._icon_label)
+
+ self.setMinimumSize(QSize(44, 44))
+ self.setMaximumSize(QSize(48, 48))
+
+ def set_icon(self, icon: QIcon) -> None:
+ """Set the displayed icon for the drop zone widget."""
+ if icon.isNull():
+ return
+ self._icon_label.setPixmap(icon.pixmap(QSize(32, 32)))
+
+ # ------------------------------------------------------------------
+ # Drop handling
+ # ------------------------------------------------------------------
+
+ def dragEnterEvent(self, event) -> None: # type: ignore[override]
+ """Accept drag events that carry file URLs."""
+ if event.mimeData().hasUrls():
+ event.acceptProposedAction()
+ self._icon_label.setStyleSheet(self._HOVER_STYLE)
+ else:
+ event.ignore()
+
+ def dragLeaveEvent(self, event) -> None: # type: ignore[override]
+ """Reset appearance when drag leaves the widget."""
+ self._icon_label.setStyleSheet(self._NORMAL_STYLE)
+ super().dragLeaveEvent(event)
+
+ def dropEvent(self, event) -> None: # type: ignore[override]
+ """Open each dropped file with the system default application.
+
+ Accepts the drop action so that the originating ``QDrag`` reports
+ success (preserving normal drag-started accounting), then immediately
+ opens the file via ``QDesktopServices.openUrl()``.
+ """
+ self._icon_label.setStyleSheet(self._NORMAL_STYLE)
+ mime = event.mimeData()
+ if not mime.hasUrls():
+ event.ignore()
+ return
+
+ event.acceptProposedAction()
+ for url in mime.urls():
+ if url.isLocalFile():
+ file_path = url.toLocalFile()
+ logger.info(f"OpenDropZone: opening '{file_path}' with system default app")
+ if QDesktopServices.openUrl(url):
+ self.file_opened.emit(file_path)
+ else:
+ msg = "OS could not open the file"
+ logger.warning(f"OpenDropZone: {msg}: {file_path}")
+ self.file_open_failed.emit(file_path, msg)
+ else:
+ logger.debug(f"OpenDropZone: skipping non-local URL {url.toString()}")
+
+
+class OpenWithDropZone(OpenDropZone):
+ """Drop target widget that opens files via an app chooser dialog.
+
+ When a file is dropped, this widget emits ``file_open_with_requested`` for
+ each local file so the main window can invoke platform-specific
+ "Open With" behavior.
+
+ Signals:
+ file_open_with_requested (str): Emitted with the local file path.
+ """
+
+ file_open_with_requested = Signal(str)
+
+ def __init__(self, parent: Optional[QWidget] = None) -> None:
+ """Initialize the OpenWithDropZone widget.
+
+ Args:
+ parent: Parent widget.
+ """
+ super().__init__(parent)
+ self._icon_label.setToolTip(tr("toolbar.tooltip.open_with_drop"))
+
+ def dropEvent(self, event) -> None: # type: ignore[override]
+ """Emit dropped local files for app-chooser handling."""
+ self._icon_label.setStyleSheet(self._NORMAL_STYLE)
+ mime = event.mimeData()
+ if not mime.hasUrls():
+ event.ignore()
+ return
+
+ event.acceptProposedAction()
+ for url in mime.urls():
+ if url.isLocalFile():
+ file_path = url.toLocalFile()
+ logger.info(f"OpenWithDropZone: request app chooser for '{file_path}'")
+ self.file_open_with_requested.emit(file_path)
+ else:
+ logger.debug(f"OpenWithDropZone: skipping non-local URL {url.toString()}")
+
+
class _DragBridge(QObject):
"""JavaScript bridge for drag operations via QWebChannel.
-
+
Exposed to JavaScript as 'bridge' object.
"""
-
- def __init__(self, window: 'MainWindow', parent: Optional[QObject] = None):
+
+ def __init__(self, window: "MainWindow", parent: Optional[QObject] = None):
"""Initialize the drag bridge.
-
+
Args:
window: MainWindow instance
parent: Parent QObject
"""
super().__init__(parent)
self.window = window
-
+
@Slot(str)
- def start_file_drag(self, path_text: str) -> None:
- """Start a native file drag for the given path or Azure URL.
-
- Called from JavaScript when user drags an item.
- Accepts either local file paths or Azure Blob Storage URLs.
+ def start_file_drag(self, paths_text: str) -> None:
+ """Start a native file drag for the given path(s) or Azure URL(s).
+
+ Called from JavaScript when user drags item(s).
+ Accepts either:
+ - Single file path string or Azure URL
+ - JSON array string of file paths or Azure URLs (multiple drag support)
+
Defers execution to avoid Qt drag manager state issues.
-
+
Args:
- path_text: File path string or Azure URL to drag
+ paths_text: String (single path/URL) or JSON array string (multiple paths/URLs)
"""
- logger.debug(f"Bridge: start_file_drag called for {path_text}")
-
- # Defer to avoid drag manager state issues
- # handle_drag() handles URL conversion and validation internally
- QTimer.singleShot(0, lambda: self.window.drag_interceptor.handle_drag(path_text))
-
+ logger.debug(f"Bridge: start_file_drag called with {len(paths_text)} chars")
+
+ # Try to parse as JSON array first (for multiple-drag support)
+ paths_list: Union[str, list] = paths_text
+ if paths_text.startswith("["):
+ try:
+ parsed = json.loads(paths_text)
+ if isinstance(parsed, list):
+ paths_list = parsed
+ logger.debug(f"Parsed JSON array with {len(parsed)} item(s)")
+ except (json.JSONDecodeError, TypeError) as e:
+ logger.warning(f"Failed to parse JSON array: {e}, treating as single string")
+
+ # Handle both single string and list
+ QTimer.singleShot(0, lambda: self.window.drag_interceptor.handle_drag(paths_list))
+
@Slot(str)
def debug_log(self, message: str) -> None:
"""Log debug message from JavaScript.
-
+
Args:
message: Debug message from JavaScript
"""
@@ -269,6 +427,7 @@ class MainWindow(QMainWindow):
self._background_threads = [] # Keep references to background threads
self._background_workers = {} # Keep references to background workers
self.checking_dialog = None # Track the checking dialog
+ self.downloading_dialog = None # Track the download dialog
self._is_manual_check = False # Track if this is a manual check (for UI feedback)
# Set window properties
@@ -279,38 +438,47 @@ class MainWindow(QMainWindow):
config.window_width,
config.window_height,
)
-
+
# Set window icon
# Support both development mode and PyInstaller bundle
- if hasattr(sys, '_MEIPASS'):
+ if hasattr(sys, "_MEIPASS"):
# Running as PyInstaller bundle
- icon_path = Path(sys._MEIPASS) / "resources" / "icons" / "app.ico" # type: ignore
+ icon_path = Path(sys._MEIPASS) / "resources" / "icons" / "app.ico" # type: ignore
else:
# Running in development mode
- icon_path = Path(__file__).parent.parent.parent.parent / "resources" / "icons" / "app.ico"
-
+ icon_path = (
+ Path(__file__).parent.parent.parent.parent / "resources" / "icons" / "app.ico"
+ )
+
if icon_path.exists():
self.setWindowIcon(QIcon(str(icon_path)))
logger.debug(f"Window icon set from {icon_path}")
else:
logger.warning(f"Window icon not found at {icon_path}")
- # Create web engine view
- self.web_view = RestrictedWebEngineView(config.allowed_urls)
-
+ # Create web engine view with URL for profile isolation
+ self.web_view = RestrictedWebEngineView(
+ allowed_urls=config.allowed_urls, webapp_url=config.webapp_url
+ )
+
# Enable the main window and web view to receive drag events
self.setAcceptDrops(True)
self.web_view.setAcceptDrops(True)
-
+
# Track ongoing drags from web view
self._current_drag_url = None
-
+
# Redirect JavaScript console messages to Python logger
self.web_view.page().javaScriptConsoleMessage = self._on_js_console_message
# Create navigation toolbar (Kiosk-mode navigation)
self._create_navigation_toolbar()
+ # Set up F12 keyboard shortcut for Developer Tools
+ f12_shortcut = QShortcut(QKeySequence(Qt.Key.Key_F12), self)
+ f12_shortcut.activated.connect(self._open_developer_tools)
+ logger.debug("F12 shortcut registered for Developer Tools")
+
# Create status bar
self._create_status_bar()
@@ -326,20 +494,20 @@ class MainWindow(QMainWindow):
web_channel = QWebChannel(self)
web_channel.registerObject("bridge", self._drag_bridge)
self.web_view.page().setWebChannel(web_channel)
-
+
# Install the drag bridge script
self._install_bridge_script()
-
+
# Connect to loadFinished to verify script injection
self.web_view.loadFinished.connect(self._on_page_loaded)
# Set up download handler
profile = self.web_view.page().profile()
logger.debug(f"Connecting download handler to profile: {profile}")
-
+
# CRITICAL: Connect download handler BEFORE any page loads
profile.downloadRequested.connect(self._on_download_requested)
-
+
# Enable downloads by setting download path
downloads_path = QStandardPaths.writableLocation(
QStandardPaths.StandardLocation.DownloadLocation
@@ -347,7 +515,7 @@ class MainWindow(QMainWindow):
if downloads_path:
profile.setDownloadPath(downloads_path)
logger.debug(f"Download path set to: {downloads_path}")
-
+
logger.debug("Download handler connected successfully")
# Set up central widget with layout
@@ -381,14 +549,14 @@ class MainWindow(QMainWindow):
# Local file path
try:
file_path = Path(webapp_url).resolve()
-
+
# If path doesn't exist, try relative to application root
# This handles both development and bundled (PyInstaller) modes
if not file_path.exists():
# Try relative to application package root
app_root = Path(__file__).parent.parent.parent.parent
relative_path = app_root / webapp_url.lstrip("file:///").lstrip("./")
-
+
if relative_path.exists():
file_path = relative_path
else:
@@ -396,7 +564,7 @@ class MainWindow(QMainWindow):
alt_path = Path(webapp_url.lstrip("file:///").lstrip("./")).resolve()
if alt_path.exists():
file_path = alt_path
-
+
if not file_path.exists():
# Show welcome page with instructions
welcome_html = DEFAULT_WELCOME_PAGE.format(version=self.config.app_version)
@@ -404,11 +572,11 @@ class MainWindow(QMainWindow):
return
# Load local file
- html_content = file_path.read_text(encoding='utf-8')
-
+ html_content = file_path.read_text(encoding="utf-8")
+
# Inject WebChannel bridge JavaScript
injected_html = self._inject_drag_bridge(html_content)
-
+
# Load the modified HTML
self.web_view.setHtml(injected_html, QUrl.fromLocalFile(file_path.parent))
@@ -419,34 +587,36 @@ class MainWindow(QMainWindow):
def _install_bridge_script(self) -> None:
"""Install the drag bridge JavaScript via QWebEngineScript.
-
- Uses DocumentCreation injection point to ensure script runs as early as possible,
- before any page scripts that might interfere with drag events.
-
+
+ Uses Deferred injection point to ensure script runs after the DOM is ready,
+ allowing proper event listener registration without race conditions.
+
Embeds qwebchannel.js inline to avoid CSP issues with qrc:// URLs.
Injects configuration that bridge script uses for dynamic URL pattern matching.
"""
from PySide6.QtCore import QFile, QIODevice
-
+
script = QWebEngineScript()
script.setName("webdrop-bridge")
- script.setInjectionPoint(QWebEngineScript.InjectionPoint.DocumentCreation)
+ # Use Deferred instead of DocumentCreation to allow DOM to be ready first
+ # This prevents race conditions with JavaScript event listeners
+ script.setInjectionPoint(QWebEngineScript.InjectionPoint.Deferred)
script.setWorldId(QWebEngineScript.ScriptWorldId.MainWorld)
script.setRunsOnSubFrames(False)
-
+
# Load qwebchannel.js from Qt resources (avoids CSP blocking qrc:// URLs)
qwebchannel_code = ""
qwebchannel_file = QFile(":/qtwebchannel/qwebchannel.js")
if qwebchannel_file.open(QIODevice.OpenModeFlag.ReadOnly | QIODevice.OpenModeFlag.Text):
- qwebchannel_code = bytes(qwebchannel_file.readAll()).decode('utf-8') # type: ignore
+ qwebchannel_code = bytes(qwebchannel_file.readAll()).decode("utf-8") # type: ignore
qwebchannel_file.close()
logger.debug("Loaded qwebchannel.js inline to avoid CSP issues")
else:
logger.warning("Failed to load qwebchannel.js from resources")
-
+
# Generate configuration injection script
config_code = self._generate_config_injection_script()
-
+
# Load bridge script from file
# Try multiple paths to support dev mode, PyInstaller bundle, and MSI installation
# 1. Development mode: __file__.parent / script.js
@@ -454,28 +624,28 @@ class MainWindow(QMainWindow):
# 3. MSI installation: Same directory as executable
script_path = None
download_interceptor_path = None
-
+
# List of paths to try in order of preference
search_paths = []
-
+
# 1. Development mode
search_paths.append(Path(__file__).parent / "bridge_script_intercept.js")
-
+
# 2. PyInstaller bundle (via sys._MEIPASS)
- if hasattr(sys, '_MEIPASS'):
- search_paths.append(Path(sys._MEIPASS) / "webdrop_bridge" / "ui" / "bridge_script_intercept.js") # type: ignore
-
+ if hasattr(sys, "_MEIPASS"):
+ search_paths.append(Path(sys._MEIPASS) / "webdrop_bridge" / "ui" / "bridge_script_intercept.js") # type: ignore
+
# 3. Installed executable's directory (handles MSI installation where all files are packaged together)
exe_dir = Path(sys.executable).parent
search_paths.append(exe_dir / "webdrop_bridge" / "ui" / "bridge_script_intercept.js")
-
+
# Find the bridge script
for path in search_paths:
if path.exists():
script_path = path
logger.debug(f"Found bridge script at: {script_path}")
break
-
+
if script_path is None:
# Log all attempted paths for debugging
logger.error("Bridge script NOT found at any expected location:")
@@ -484,52 +654,87 @@ class MainWindow(QMainWindow):
logger.error(f"sys._MEIPASS: {getattr(sys, '_MEIPASS', 'NOT SET')}")
logger.error(f"sys.executable: {sys.executable}")
logger.error(f"__file__: {__file__}")
-
+
try:
if script_path is None:
- raise FileNotFoundError("bridge_script_intercept.js not found in any expected location")
-
- with open(script_path, 'r', encoding='utf-8') as f:
+ raise FileNotFoundError(
+ "bridge_script_intercept.js not found in any expected location"
+ )
+
+ with open(script_path, "r", encoding="utf-8") as f:
bridge_code = f.read()
-
+
# Load download interceptor using similar search path logic
download_search_paths = []
download_search_paths.append(Path(__file__).parent / "download_interceptor.js")
- if hasattr(sys, '_MEIPASS'):
- download_search_paths.append(Path(sys._MEIPASS) / "webdrop_bridge" / "ui" / "download_interceptor.js") # type: ignore
- download_search_paths.append(exe_dir / "webdrop_bridge" / "ui" / "download_interceptor.js")
-
+ if hasattr(sys, "_MEIPASS"):
+ download_search_paths.append(Path(sys._MEIPASS) / "webdrop_bridge" / "ui" / "download_interceptor.js") # type: ignore
+ download_search_paths.append(
+ exe_dir / "webdrop_bridge" / "ui" / "download_interceptor.js"
+ )
+
download_interceptor_code = ""
for path in download_search_paths:
if path.exists():
download_interceptor_path = path
break
-
+
if download_interceptor_path:
try:
- with open(download_interceptor_path, 'r', encoding='utf-8') as f:
+ with open(download_interceptor_path, "r", encoding="utf-8") as f:
download_interceptor_code = f.read()
logger.debug(f"Loaded download interceptor from {download_interceptor_path}")
except (OSError, IOError) as e:
logger.warning(f"Download interceptor exists but failed to load: {e}")
else:
logger.debug("Download interceptor not found (optional)")
-
- # Combine: qwebchannel.js + config + bridge script + download interceptor
+
+ # Load mouse event emulator for hover effect support
+ mouse_emulator_search_paths = []
+ mouse_emulator_search_paths.append(Path(__file__).parent / "mouse_event_emulator.js")
+ if hasattr(sys, "_MEIPASS"):
+ mouse_emulator_search_paths.append(
+ Path(sys._MEIPASS) / "webdrop_bridge" / "ui" / "mouse_event_emulator.js" # type: ignore
+ )
+ mouse_emulator_search_paths.append(
+ exe_dir / "webdrop_bridge" / "ui" / "mouse_event_emulator.js"
+ )
+
+ mouse_emulator_code = ""
+ for path in mouse_emulator_search_paths:
+ if path.exists():
+ try:
+ with open(path, "r", encoding="utf-8") as f:
+ mouse_emulator_code = f.read()
+ logger.debug(f"Loaded mouse event emulator from {path}")
+ break
+ except (OSError, IOError) as e:
+ logger.warning(f"Mouse event emulator exists but failed to load: {e}")
+ if not mouse_emulator_code:
+ logger.debug("Mouse event emulator not found (optional)")
+
+ # Combine: qwebchannel.js + config + bridge script + download interceptor + mouse emulator
combined_code = qwebchannel_code + "\n\n" + config_code + "\n\n" + bridge_code
-
+
if download_interceptor_code:
combined_code += "\n\n" + download_interceptor_code
-
- logger.debug(f"Combined script size: {len(combined_code)} chars "
- f"(qwebchannel: {len(qwebchannel_code)}, "
- f"config: {len(config_code)}, "
- f"bridge: {len(bridge_code)}, "
- f"interceptor: {len(download_interceptor_code)})")
+
+ # Add mouse event emulator last to ensure it runs after all other scripts
+ if mouse_emulator_code:
+ combined_code += "\n\n" + mouse_emulator_code
+
+ logger.debug(
+ f"Combined script size: {len(combined_code)} chars "
+ f"(qwebchannel: {len(qwebchannel_code)}, "
+ f"config: {len(config_code)}, "
+ f"bridge: {len(bridge_code)}, "
+ f"interceptor: {len(download_interceptor_code)}, "
+ f"mouse_emulator: {len(mouse_emulator_code)})"
+ )
logger.debug(f"URL mappings in config: {len(self.config.url_mappings)}")
for i, mapping in enumerate(self.config.url_mappings):
logger.debug(f" Mapping {i+1}: {mapping.url_prefix} → {mapping.local_path}")
-
+
script.setSourceCode(combined_code)
self.web_view.page().scripts().insert(script)
logger.debug(f"✅ Successfully installed bridge script")
@@ -539,35 +744,33 @@ class MainWindow(QMainWindow):
logger.error(f"❌ Failed to load bridge script: {e}")
logger.error(f" This will break drag-and-drop functionality!")
# Don't re-raise - allow app to start (will show error in logs)
-
+
def _generate_config_injection_script(self) -> str:
"""Generate JavaScript code that injects configuration.
-
+
Creates a script that sets window.webdropConfig with the current
URL mappings, allowing the bridge script to dynamically check
against configured patterns instead of hardcoded values.
-
+
Returns:
JavaScript code as string
"""
# Convert URL mappings to format expected by bridge script
mappings = []
for mapping in self.config.url_mappings:
- mappings.append({
- "url_prefix": mapping.url_prefix,
- "local_path": mapping.local_path
- })
-
+ mappings.append({"url_prefix": mapping.url_prefix, "local_path": mapping.local_path})
+
logger.debug(f"Generating config injection with {len(mappings)} URL mappings")
for i, m in enumerate(mappings):
logger.debug(f" [{i+1}] {m['url_prefix']} -> {m['local_path']}")
-
+
# Generate config object as JSON
- config_obj = {"urlMappings": mappings}
+ config_obj = {"urlMappings": mappings, "enableCheckout": self.config.enable_checkout}
config_json = json.dumps(config_obj)
-
+
logger.debug(f"Config JSON size: {len(config_json)} bytes")
-
+ logger.debug(f"Checkout enabled: {self.config.enable_checkout}")
+
# Generate JavaScript code - Safe injection with error handling
config_js = f"""
(function() {{
@@ -576,6 +779,7 @@ class MainWindow(QMainWindow):
console.log('[WebDrop Config] Starting configuration injection...');
window.webdropConfig = {config_json};
console.log('[WebDrop Config] Configuration object created');
+ console.log('[WebDrop Config] Checkout enabled: ' + window.webdropConfig.enableCheckout);
if (window.webdropConfig && window.webdropConfig.urlMappings) {{
console.log('[WebDrop Config] SUCCESS: ' + window.webdropConfig.urlMappings.length + ' URL mappings loaded');
@@ -593,16 +797,16 @@ class MainWindow(QMainWindow):
}})();
"""
return config_js
-
+
def _inject_drag_bridge(self, html_content: str) -> str:
"""Return HTML content unmodified.
-
+
The drag bridge script is now injected via QWebEngineScript in _install_bridge_script().
This method is kept for compatibility but does nothing.
-
+
Args:
html_content: Original HTML content
-
+
Returns:
HTML unchanged
"""
@@ -610,8 +814,9 @@ class MainWindow(QMainWindow):
def _apply_stylesheet(self) -> None:
"""Apply application stylesheet if available."""
- stylesheet_path = Path(__file__).parent.parent.parent.parent / \
- "resources" / "stylesheets" / "default.qss"
+ stylesheet_path = (
+ Path(__file__).parent.parent.parent.parent / "resources" / "stylesheets" / "default.qss"
+ )
if stylesheet_path.exists():
try:
@@ -630,16 +835,16 @@ class MainWindow(QMainWindow):
local_path: Local file path that is being dragged
"""
logger.info(f"Drag started: {source} -> {local_path}")
-
- # Ask user if they want to check out the asset
- if source.startswith('http'):
+
+ # Ask user if they want to check out the asset (only when enabled in config)
+ if source.startswith("http") and self.config.enable_checkout:
self._prompt_checkout(source, local_path)
-
+
def _prompt_checkout(self, azure_url: str, local_path: str) -> None:
"""Check checkout status and prompt user if needed.
-
+
First checks if the asset is already checked out. Only shows dialog if not checked out.
-
+
Args:
azure_url: Azure Blob Storage URL
local_path: Local file path
@@ -648,18 +853,18 @@ class MainWindow(QMainWindow):
# Extract filename for display
filename = Path(local_path).name
-
+
# Extract asset ID
- match = re.search(r'/([^/]+)/[^/]+$', azure_url)
+ match = re.search(r"/([^/]+)/[^/]+$", azure_url)
if not match:
logger.warning(f"Could not extract asset ID from URL: {azure_url}")
return
-
+
asset_id = match.group(1)
-
+
# Store callback ID for this check
callback_id = f"checkout_check_{id(self)}"
-
+
# Check checkout status - use callback approach since Qt doesn't handle Promise returns well
js_code = f"""
(async () => {{
@@ -702,22 +907,30 @@ class MainWindow(QMainWindow):
}}
}})();
"""
-
+
# Execute the async fetch
self.web_view.page().runJavaScript(js_code)
-
+
# After a short delay, read the result from window variable
def check_result():
read_code = f"window['{callback_id}']"
- self.web_view.page().runJavaScript(read_code, lambda result: self._handle_checkout_status(result, azure_url, filename, callback_id))
-
+ self.web_view.page().runJavaScript(
+ read_code,
+ lambda result: self._handle_checkout_status(
+ result, azure_url, filename, callback_id
+ ),
+ )
+
# Wait 500ms for async fetch to complete
from PySide6.QtCore import QTimer
+
QTimer.singleShot(500, check_result)
-
- def _handle_checkout_status(self, result, azure_url: str, filename: str, callback_id: str) -> None:
+
+ def _handle_checkout_status(
+ self, result, azure_url: str, filename: str, callback_id: str
+ ) -> None:
"""Handle the result of checkout status check.
-
+
Args:
result: Result from JavaScript (JSON string)
azure_url: Azure URL
@@ -727,56 +940,59 @@ class MainWindow(QMainWindow):
# Clean up window variable
cleanup_code = f"delete window['{callback_id}']"
self.web_view.page().runJavaScript(cleanup_code)
-
+
logger.debug(f"Checkout status result type: {type(result)}, value: {result}")
-
+
if not result or not isinstance(result, str):
logger.warning(f"Checkout status check returned invalid result: {result}")
self._show_checkout_dialog(azure_url, filename)
return
-
+
# Parse JSON string
try:
import json
+
parsed_result = json.loads(result)
except (json.JSONDecodeError, ValueError) as e:
logger.warning(f"Failed to parse checkout status result: {e}")
self._show_checkout_dialog(azure_url, filename)
return
-
- if parsed_result.get('error'):
+
+ if parsed_result.get("error"):
logger.warning(f"Could not check checkout status: {parsed_result}")
self._show_checkout_dialog(azure_url, filename)
return
-
+
# Check if already checked out
- has_checkout = parsed_result.get('hasCheckout', False)
+ has_checkout = parsed_result.get("hasCheckout", False)
if has_checkout:
- checkout_info = parsed_result.get('checkout', {})
- logger.info(f"Asset {filename} is already checked out: {checkout_info}, skipping dialog")
+ checkout_info = parsed_result.get("checkout", {})
+ logger.info(
+ f"Asset {filename} is already checked out: {checkout_info}, skipping dialog"
+ )
return
-
+
# Not checked out, show confirmation dialog
logger.debug(f"Asset {filename} is not checked out, showing dialog")
self._show_checkout_dialog(azure_url, filename)
-
+
def _show_checkout_dialog(self, azure_url: str, filename: str) -> None:
"""Show the checkout confirmation dialog.
-
+
Args:
azure_url: Azure Blob Storage URL
filename: Asset filename
"""
from PySide6.QtWidgets import QMessageBox
-
+
reply = QMessageBox.question(
self,
- "Checkout Asset",
- f"Do you want to check out this asset?\n\n{filename}",
+ tr("dialog.checkout.title"),
+ tr("dialog.checkout.msg", filename=filename),
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
- QMessageBox.StandardButton.Yes
+ QMessageBox.StandardButton.Yes,
)
-
+
if reply == QMessageBox.StandardButton.Yes:
logger.info(f"User confirmed checkout for {filename}")
self._trigger_checkout_api(azure_url)
@@ -796,14 +1012,14 @@ class MainWindow(QMainWindow):
try:
# Extract asset ID from URL (middle segment between domain and filename)
# Format: https://domain/container/ASSET_ID/filename
- match = re.search(r'/([^/]+)/[^/]+$', azure_url)
+ match = re.search(r"/([^/]+)/[^/]+$", azure_url)
if not match:
logger.warning(f"Could not extract asset ID from URL: {azure_url}")
return
-
+
asset_id = match.group(1)
logger.info(f"Extracted asset ID: {asset_id}")
-
+
# Call API from JavaScript with Authorization header
js_code = f"""
(async function() {{
@@ -846,22 +1062,22 @@ class MainWindow(QMainWindow):
}}
}})();
"""
-
+
def on_result(result):
"""Callback when JavaScript completes."""
if result and isinstance(result, dict):
- if result.get('success'):
+ if result.get("success"):
logger.info(f"✅ Checkout successful for asset {asset_id}")
else:
- status = result.get('status', 'unknown')
- error = result.get('error', 'unknown error')
+ status = result.get("status", "unknown")
+ error = result.get("error", "unknown error")
logger.warning(f"Checkout API returned status {status}: {error}")
else:
logger.debug(f"Checkout API call completed (result: {result})")
-
+
# Execute JavaScript (async, non-blocking)
self.web_view.page().runJavaScript(js_code, on_result)
-
+
except Exception as e:
logger.exception(f"Error triggering checkout API: {e}")
@@ -873,7 +1089,107 @@ class MainWindow(QMainWindow):
error: Error message
"""
logger.warning(f"Drag failed for {source}: {error}")
- # Can be extended with user notification or status bar message
+ # Show error dialog to user
+ QMessageBox.warning(
+ self,
+ tr("dialog.drag_error.title"),
+ tr("dialog.drag_error.msg", error=error),
+ )
+
+ def _on_file_opened_via_drop(self, file_path: str) -> None:
+ """Handle a file successfully opened via the OpenDropZone.
+
+ Args:
+ file_path: Local file path that was opened.
+ """
+ logger.info(f"Opened via drop zone: {file_path}")
+ self.statusBar().showMessage(tr("status.opened", name=Path(file_path).name), 4000)
+
+ def _on_file_open_failed_via_drop(self, file_path: str, error: str) -> None:
+ """Handle a failure to open a file dropped on the OpenDropZone.
+
+ Args:
+ file_path: Local file path that could not be opened.
+ error: Error description.
+ """
+ logger.warning(f"Failed to open via drop zone '{file_path}': {error}")
+ QMessageBox.warning(
+ self,
+ tr("dialog.open_file_error.title"),
+ tr("dialog.open_file_error.msg", file_path=file_path, error=error),
+ )
+
+ def _on_file_open_with_requested(self, file_path: str) -> None:
+ """Handle a file dropped on the OpenWithDropZone.
+
+ Args:
+ file_path: Local file path to open using an app chooser.
+ """
+ if self._open_with_app_chooser(file_path):
+ self.statusBar().showMessage(tr("status.choose_app", name=Path(file_path).name), 4000)
+ logger.info(f"Opened app chooser for '{file_path}'")
+ return
+
+ logger.warning(f"Could not open app chooser for '{file_path}'")
+ QMessageBox.warning(
+ self,
+ tr("dialog.open_with_error.title"),
+ tr("dialog.open_with_error.msg"),
+ )
+
+ def _open_with_app_chooser(self, file_path: str) -> bool:
+ """Open OS-specific app chooser for a local file.
+
+ Args:
+ file_path: Local file path.
+
+ Returns:
+ True if the chooser command was started successfully, False otherwise.
+ """
+ try:
+ normalized_path = str(Path(file_path))
+ if not Path(normalized_path).exists():
+ logger.warning(f"Open-with target does not exist: {normalized_path}")
+ return False
+
+ if sys.platform.startswith("win"):
+ # First try the native shell "openas" verb.
+ import ctypes
+
+ result = ctypes.windll.shell32.ShellExecuteW(
+ None, "openas", normalized_path, None, None, 1
+ )
+ if result > 32:
+ return True
+
+ logger.warning(f"ShellExecuteW(openas) failed with code {result}; trying fallback")
+
+ # Fallback for systems where openas verb is not available/reliable.
+ subprocess.Popen(["rundll32.exe", "shell32.dll,OpenAs_RunDLL", normalized_path])
+ return True
+
+ if sys.platform == "darwin":
+ # Prompt for an app and open the file with the selected app.
+ script = (
+ "on run argv\n"
+ "set targetFile to POSIX file (item 1 of argv)\n"
+ "set chosenApp to choose application\n"
+ 'tell application "Finder" to open targetFile using chosenApp\n'
+ "end run"
+ )
+ result = subprocess.run(
+ ["osascript", "-e", script, file_path],
+ check=False,
+ capture_output=True,
+ text=True,
+ )
+ return result.returncode == 0
+
+ logger.warning(f"Open-with chooser not implemented for platform: {sys.platform}")
+ return False
+ except Exception as e:
+ logger.warning(f"Failed to open app chooser for '{file_path}': {e}")
+ return False
def _on_download_requested(self, download: QWebEngineDownloadRequest) -> None:
"""Handle download requests from the embedded web view.
@@ -890,52 +1206,50 @@ class MainWindow(QMainWindow):
logger.debug(f"Download mime type: {download.mimeType()}")
logger.debug(f"Download suggested filename: {download.suggestedFileName()}")
logger.debug(f"Download state: {download.state()}")
-
+
# Get the system's Downloads folder
downloads_path = QStandardPaths.writableLocation(
QStandardPaths.StandardLocation.DownloadLocation
)
-
+
if not downloads_path:
# Fallback to user's home directory if Downloads folder not available
downloads_path = str(Path.home())
logger.warning("Downloads folder not found, using home directory")
-
+
# Use suggested filename if available, fallback to downloadFileName
filename = download.suggestedFileName() or download.downloadFileName()
if not filename:
filename = "download"
logger.warning("No filename suggested, using 'download'")
-
+
# Construct full download path
download_file = Path(downloads_path) / filename
logger.debug(f"Download will be saved to: {download_file}")
-
+
# Set download path and accept
download.setDownloadDirectory(str(download_file.parent))
download.setDownloadFileName(download_file.name)
download.accept()
-
+
logger.info(f"Download started: {filename}")
-
+
# Update status bar (temporarily)
- self.status_bar.showMessage(
- f"📥 Download: {filename}", 3000
- )
-
+ self.status_bar.showMessage(tr("status.download_started", filename=filename), 3000)
+
# Connect to state changed for progress tracking
download.stateChanged.connect(
lambda state: logger.debug(f"Download state changed to: {state}")
)
-
+
# Connect to finished signal for completion feedback
download.isFinishedChanged.connect(
lambda: self._on_download_finished(download, download_file)
)
-
+
except Exception as e:
logger.error(f"Error handling download: {e}", exc_info=True)
- self.status_bar.showMessage(f"Download error: {e}", 5000)
+ self.status_bar.showMessage(tr("status.download_error", error=str(e)), 5000)
def _on_download_finished(self, download: QWebEngineDownloadRequest, file_path: Path) -> None:
"""Handle download completion.
@@ -947,67 +1261,65 @@ class MainWindow(QMainWindow):
try:
if not download.isFinished():
return
-
+
state = download.state()
logger.debug(f"Download finished with state: {state}")
-
+
if state == QWebEngineDownloadRequest.DownloadState.DownloadCompleted:
logger.info(f"Download completed: {file_path.name}")
self.status_bar.showMessage(
- f"Download completed: {file_path.name}", 5000
+ tr("status.download_completed", name=file_path.name), 5000
)
elif state == QWebEngineDownloadRequest.DownloadState.DownloadCancelled:
logger.info(f"Download cancelled: {file_path.name}")
self.status_bar.showMessage(
- f"⚠️ Download abgebrochen: {file_path.name}", 3000
+ tr("status.download_cancelled", name=file_path.name), 3000
)
elif state == QWebEngineDownloadRequest.DownloadState.DownloadInterrupted:
logger.warning(f"Download interrupted: {file_path.name}")
- self.status_bar.showMessage(
- f"❌ Download fehlgeschlagen: {file_path.name}", 5000
- )
+ self.status_bar.showMessage(tr("status.download_failed", name=file_path.name), 5000)
except Exception as e:
logger.error(f"Error in download finished handler: {e}", exc_info=True)
-
+
def dragEnterEvent(self, event):
"""Handle drag entering the main window (from WebView or external).
-
+
Note: With intercept script, ALT-drags are prevented in JavaScript
and handled via bridge.start_file_drag(). This just handles any
remaining drag events.
-
+
Args:
event: QDragEnterEvent
"""
event.ignore()
-
+
def dragMoveEvent(self, event):
"""Handle drag moving over the main window.
-
+
Args:
event: QDragMoveEvent
"""
event.ignore()
-
+
def dragLeaveEvent(self, event):
"""Handle drag leaving the main window.
-
+
Args:
- event: QDragLeaveEvent
+ event: QDragLeaveEvent
"""
event.ignore()
-
+
def dropEvent(self, event):
"""Handle drop on the main window.
-
+
Args:
event: QDropEvent
"""
event.ignore()
-
+
def _on_js_console_message(self, level, message, line_number, source_id):
"""Redirect JavaScript console messages to Python logger.
-
+
Args:
level: Console message level (JavaScriptConsoleMessageLevel enum)
message: The console message
@@ -1025,19 +1337,19 @@ class MainWindow(QMainWindow):
else: # ErrorMessageLevel
logger.error(f"JS Console: {message}")
logger.debug(f" at {source_id}:{line_number}")
-
+
def _on_page_loaded(self, success: bool) -> None:
"""Called when a page finishes loading.
-
+
Checks if the bridge script was successfully injected.
-
+
Args:
success: True if page loaded successfully
"""
if not success:
logger.warning("Page failed to load")
return
-
+
# Check if bridge script is loaded
def check_script(result):
if result:
@@ -1046,11 +1358,11 @@ class MainWindow(QMainWindow):
else:
logger.error("WebDrop Bridge script NOT loaded!")
logger.error("Drag-and-drop conversion will not work")
-
+
# Execute JS to check if our script is loaded
self.web_view.page().runJavaScript(
- "typeof window.__webdrop_bridge_injected !== 'undefined' && window.__webdrop_bridge_injected === true",
- check_script
+ "typeof window.__webdrop_intercept_injected !== 'undefined' && window.__webdrop_intercept_injected === true",
+ check_script,
)
def _create_navigation_toolbar(self) -> None:
@@ -1065,31 +1377,65 @@ class MainWindow(QMainWindow):
self.addToolBar(Qt.ToolBarArea.TopToolBarArea, toolbar)
# Back button
- back_action = self.web_view.pageAction(
- self.web_view.page().WebAction.Back
- )
+ back_action = self.web_view.pageAction(self.web_view.page().WebAction.Back)
toolbar.addAction(back_action)
# Forward button
- forward_action = self.web_view.pageAction(
- self.web_view.page().WebAction.Forward
- )
+ forward_action = self.web_view.pageAction(self.web_view.page().WebAction.Forward)
toolbar.addAction(forward_action)
# Separator
toolbar.addSeparator()
# Home button
- home_action = toolbar.addAction(self.style().standardIcon(self.style().StandardPixmap.SP_DirHomeIcon), "")
- home_action.setToolTip("Home")
+ home_icon_path = self._resolve_toolbar_icon_path(
+ os.getenv("TOOLBAR_ICON_HOME", "resources/icons/home.ico")
+ )
+ home_icon = (
+ QIcon(str(home_icon_path))
+ if home_icon_path is not None
+ else self.style().standardIcon(self.style().StandardPixmap.SP_DirHomeIcon)
+ )
+ home_action = toolbar.addAction(home_icon, "")
+ home_action.setToolTip(tr("toolbar.tooltip.home"))
home_action.triggered.connect(self._navigate_home)
# Refresh button
- refresh_action = self.web_view.pageAction(
- self.web_view.page().WebAction.Reload
+ refresh_action = self.web_view.pageAction(self.web_view.page().WebAction.Reload)
+ reload_icon_path = self._resolve_toolbar_icon_path(
+ os.getenv("TOOLBAR_ICON_RELOAD", "resources/icons/reload.ico")
)
+ if reload_icon_path is not None:
+ refresh_action.setIcon(QIcon(str(reload_icon_path)))
toolbar.addAction(refresh_action)
+ # Open-with-default-app drop zone (right of Reload)
+ self._open_drop_zone = OpenDropZone()
+ open_icon_path = self._resolve_toolbar_icon_path(
+ os.getenv("TOOLBAR_ICON_OPEN", "resources/icons/open.ico")
+ )
+ if open_icon_path is not None:
+ self._open_drop_zone.set_icon(QIcon(str(open_icon_path)))
+ self._open_drop_zone.file_opened.connect(self._on_file_opened_via_drop)
+ self._open_drop_zone.file_open_failed.connect(self._on_file_open_failed_via_drop)
+ open_drop_action = QWidgetAction(toolbar)
+ open_drop_action.setDefaultWidget(self._open_drop_zone)
+ toolbar.addAction(open_drop_action)
+
+ # Open-with chooser drop zone (right of Open-with-default-app)
+ self._open_with_drop_zone = OpenWithDropZone()
+ open_with_icon_path = self._resolve_toolbar_icon_path(
+ os.getenv("TOOLBAR_ICON_OPENWITH", "resources/icons/openwith.ico")
+ )
+ if open_with_icon_path is not None:
+ self._open_with_drop_zone.set_icon(QIcon(str(open_with_icon_path)))
+ self._open_with_drop_zone.file_open_with_requested.connect(
+ self._on_file_open_with_requested
+ )
+ open_with_drop_action = QWidgetAction(toolbar)
+ open_with_drop_action.setDefaultWidget(self._open_with_drop_zone)
+ toolbar.addAction(open_with_drop_action)
+
# Add stretch spacer to push help buttons to the right
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
@@ -1097,72 +1443,230 @@ class MainWindow(QMainWindow):
# About button (info icon) on the right
about_action = toolbar.addAction("ℹ️")
- about_action.setToolTip("About WebDrop Bridge")
+ about_action.setToolTip(tr("toolbar.tooltip.about"))
about_action.triggered.connect(self._show_about_dialog)
# Settings button on the right
settings_action = toolbar.addAction("⚙️")
- settings_action.setToolTip("Settings")
+ settings_action.setToolTip(tr("toolbar.tooltip.settings"))
settings_action.triggered.connect(self._show_settings_dialog)
# Check for Updates button on the right
check_updates_action = toolbar.addAction("🔄")
- check_updates_action.setToolTip("Check for Updates")
+ check_updates_action.setToolTip(tr("toolbar.tooltip.check_updates"))
check_updates_action.triggered.connect(self._on_manual_check_for_updates)
+ # Clear cache button on the right
+ clear_cache_action = toolbar.addAction("🗑️")
+ clear_cache_action.setToolTip(tr("toolbar.tooltip.clear_cache"))
+ clear_cache_action.triggered.connect(self._clear_cache_and_cookies)
+
+ # Log file button on the right
+ log_action = toolbar.addAction("📋")
+ log_action.setToolTip(tr("toolbar.tooltip.open_log"))
+ log_action.triggered.connect(self._open_log_file)
+
+ # Developer Tools button on the right
+ dev_tools_action = toolbar.addAction("🔧")
+ dev_tools_action.setToolTip(tr("toolbar.tooltip.dev_tools"))
+ dev_tools_action.triggered.connect(self._open_developer_tools)
+
+ def _resolve_toolbar_icon_path(self, configured_path: str) -> Path | None:
+ """Resolve configured toolbar icon path in both dev and packaged layouts."""
+ icon_path = Path(configured_path)
+
+ candidates: list[Path] = []
+ if icon_path.is_absolute():
+ candidates.append(icon_path)
+ else:
+ if hasattr(sys, "_MEIPASS"):
+ meipass = Path(sys._MEIPASS) # type: ignore[attr-defined]
+ candidates.append(meipass / icon_path)
+
+ exe_dir = Path(sys.executable).resolve().parent
+ candidates.append(exe_dir / icon_path)
+ candidates.append(exe_dir / "_internal" / icon_path)
+
+ project_root = Path(__file__).parent.parent.parent.parent
+ candidates.append(project_root / icon_path)
+
+ for candidate in candidates:
+ if candidate.exists():
+ return candidate
+
+ logger.warning(f"Toolbar icon not found for configured path: {configured_path}")
+ return None
+
+ def _open_log_file(self) -> None:
+ """Open the application log file in the system default text editor.
+
+ Resolves the log file path from config, falls back to the default
+ AppData location, and opens it with QDesktopServices. Shows an
+ informational message if the file does not exist yet.
+ """
+ log_file: Optional[Path] = None
+
+ if self.config.log_file:
+ log_file = Path(self.config.log_file)
+ else:
+ # Default location: /webdrop_bridge/logs/webdrop_bridge.log
+ app_data = Path(
+ QStandardPaths.writableLocation(QStandardPaths.StandardLocation.AppDataLocation)
+ )
+ log_file = app_data / "logs" / "webdrop_bridge.log"
+
+ if log_file.exists():
+ QDesktopServices.openUrl(QUrl.fromLocalFile(str(log_file)))
+ else:
+ QMessageBox.information(
+ self,
+ tr("dialog.log_not_found.title"),
+ tr("dialog.log_not_found.msg", log_file=str(log_file)),
+ )
+
+ def _open_developer_tools(self) -> None:
+ """Open Developer Tools in a separate window.
+
+ Creates a dedicated window with JavaScript Console and DOM Inspector.
+ Provides code execution, DOM inspection, and console log capture all
+ in your application window - no external browser needed.
+ """
+ try:
+ # Check if dev tools window already exists and is visible
+ if not hasattr(self, "_dev_tools_window") or self._dev_tools_window is None:
+ from webdrop_bridge.ui.developer_tools import DeveloperToolsWidget
+
+ # Create new window
+ self._dev_tools_window = QMainWindow()
+ self._dev_tools_window.setWindowTitle(tr("dialog.dev_tools.window_title"))
+ self._dev_tools_window.setGeometry(100, 100, 1200, 700)
+ self._dev_tools_window.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+
+ # Create developer tools widget
+ dev_tools_widget = DeveloperToolsWidget(self.web_view)
+
+ # Set the widget as central widget
+ self._dev_tools_window.setCentralWidget(dev_tools_widget)
+
+ # Connect close event to clear reference
+ def on_close_dev_tools():
+ self._dev_tools_window = None
+
+ self._dev_tools_window.destroyed.connect(on_close_dev_tools)
+
+ # Show or bring to front
+ self._dev_tools_window.show()
+ self._dev_tools_window.raise_()
+ self._dev_tools_window.activateWindow()
+ logger.info("Developer Tools window opened")
+
+ except Exception as e:
+ logger.error(f"Failed to open Developer Tools window: {e}", exc_info=True)
+ QMessageBox.warning(
+ self,
+ tr("dialog.dev_tools.error_title"),
+ tr("dialog.dev_tools.error_msg", error=str(e)),
+ )
+
def _create_status_bar(self) -> None:
"""Create status bar with update status indicator."""
self.status_bar = self.statusBar()
-
+
# Update status label
- self.update_status_label = QLabel("Ready")
+ self.update_status_label = QLabel(tr("status.ready"))
self.update_status_label.setStyleSheet("margin-right: 10px;")
self.status_bar.addPermanentWidget(self.update_status_label)
def set_update_status(self, status: str, emoji: str = "") -> None:
"""Update the status bar with update information.
-
+
Args:
status: Status text to display
emoji: Optional emoji prefix (rotating, checkmark, download, warning symbols)
"""
+ # Map known internal status strings to translated display text
+ _STATIC_STATUS_MAP = {
+ "Checking for updates": "update.status.checking",
+ "Ready": "update.status.ready",
+ "Update deferred": "update.status.deferred",
+ "Ready to install": "update.status.ready_to_install",
+ "Installation started": "update.status.installation_started",
+ "Installation failed": "update.status.installation_failed",
+ "Download failed": "update.status.download_failed",
+ "Verification failed": "update.status.verification_failed",
+ "Operation timed out": "update.status.timed_out",
+ "Check timed out - no server response": "update.status.check_timed_out",
+ "Download timed out - no server response": "update.status.download_timed_out",
+ }
+ tr_key = _STATIC_STATUS_MAP.get(status)
+ display = tr(tr_key) if tr_key else status
if emoji:
- self.update_status_label.setText(f"{emoji} {status}")
+ self.update_status_label.setText(f"{emoji} {display}")
else:
- self.update_status_label.setText(status)
+ self.update_status_label.setText(display)
def _on_manual_check_for_updates(self) -> None:
"""Handle manual check for updates from menu.
-
+
Triggers an immediate update check (bypass cache) with user feedback dialog.
"""
logger.info("Manual update check requested from menu")
-
+
# Show "Checking for Updates..." dialog
from webdrop_bridge.ui.update_manager_ui import CheckingDialog
-
+
self.checking_dialog = CheckingDialog(self)
self._is_manual_check = True
-
+
# Start the update check
self.check_for_updates_startup()
-
+
# Show the dialog
self.checking_dialog.show()
+ def _clear_cache_and_cookies(self) -> None:
+ """Clear web view cache and cookies.
+
+ Useful for clearing authentication tokens or cached data from previous
+ sessions. Also disconnects and reconnects the page to ensure clean state.
+ """
+ logger.info("Clearing cache and cookies")
+
+ try:
+ # Clear cache and cookies in the web view profile
+ self.web_view.clear_cache_and_cookies()
+
+ # Show confirmation message
+ QMessageBox.information(
+ self,
+ tr("dialog.cache_cleared.title"),
+ tr("dialog.cache_cleared.msg"),
+ )
+ logger.info("Cache and cookies cleared successfully")
+ except Exception as e:
+ logger.error(f"Failed to clear cache and cookies: {e}")
+ QMessageBox.warning(
+ self,
+ tr("dialog.cache_clear_failed.title"),
+ tr("dialog.cache_clear_failed.msg", error=str(e)),
+ )
+
def _show_about_dialog(self) -> None:
"""Show About dialog with version and information."""
from PySide6.QtWidgets import QMessageBox
-
+
about_text = (
f"{self.config.app_name}
" - f"Version: {self.config.app_version}
" + f"{tr('about.version', version=self.config.app_version)}
" f"
" - f"Bridges web-based drag-and-drop workflows with native file operations " - f"for professional desktop applications.
" + f"{tr('about.description')}
" f"
" - f"Product of:
" - f"Hörl Information Management GmbH
" + f"{tr('about.drop_zones_title')}
" + f"{tr('about.open_icon_desc')}
" + f"{tr('about.open_with_icon_desc')}
" + f"
" + f"{tr('about.product_of')}
" + f"hörl Information Management GmbH
" f"Silberburgstraße 126
" f"70176 Stuttgart, Germany
" f"
" @@ -1172,18 +1676,177 @@ class MainWindow(QMainWindow): f"Web: https://www.hoerl-im.de/
" f"" f"
" - f"© 2026 Hörl Information Management GmbH. All rights reserved." + f"{tr('about.rights')}" ) - - QMessageBox.about(self, f"About {self.config.app_name}", about_text) + + QMessageBox.about(self, tr("about.title", app_name=self.config.app_name), about_text) def _show_settings_dialog(self) -> None: - """Show Settings dialog for configuration management.""" + """Show Settings dialog for configuration management. + + After closing, checks if webapp URL changed and reloads if needed. + For domain changes, shows restart dialog. + For path-only changes, reloads silently without dialog. + """ from webdrop_bridge.ui.settings_dialog import SettingsDialog - + + # Store current URL before opening dialog + old_webapp_url = self.config.webapp_url + old_language = self.config.language + + # Show dialog dialog = SettingsDialog(self.config, self) dialog.exec() + # Check if webapp URL changed + new_webapp_url = self.config.webapp_url + language_changed = old_language != self.config.language + if old_webapp_url != new_webapp_url: + logger.info(f"Web application URL changed: {old_webapp_url} → {new_webapp_url}") + + # Check if domain changed (not just path) + domain_changed = self._check_domain_changed(old_webapp_url, new_webapp_url) + + if domain_changed: + logger.warning("Domain has changed - recommending restart") + self._handle_domain_change_restart() + else: + logger.info("Path changed but domain is same - reloading...") + # Clear cache and navigate to home asynchronously + # Use timer to ensure dialog is fully closed before reloading + self.web_view.clear_cache_and_cookies() + QTimer.singleShot(100, self._navigate_home) + + if language_changed: + logger.info(f"Language changed: {old_language} → {self.config.language}") + self._handle_language_change_restart() + + def _check_domain_changed(self, old_url: str, new_url: str) -> bool: + """Check if the domain/host has changed between two URLs. + + Args: + old_url: Previous URL + new_url: New URL + + Returns: + True if domain changed, False if only path changed + """ + from urllib.parse import urlparse + + try: + old_parts = urlparse(old_url) + new_parts = urlparse(new_url) + + old_host = old_parts.netloc or old_parts.path + new_host = new_parts.netloc or new_parts.path + + return old_host != new_host + except Exception as e: + logger.warning(f"Could not parse URLs for domain comparison: {e}") + return True # Assume domain changed if we can't parse + + def _handle_domain_change_restart(self) -> None: + """Handle domain change with restart dialog. + + Shows dialog asking user to restart application with options: + - Restart now (automatic) + - Restart later (manual) + - Cancel restart (undo URL change) + """ + from PySide6.QtCore import QProcess + from PySide6.QtGui import QIcon + from PySide6.QtWidgets import QMessageBox + + msg = QMessageBox(self) + msg.setWindowTitle(tr("dialog.domain_changed.title")) + msg.setIcon(QMessageBox.Icon.Warning) + msg.setText(tr("dialog.domain_changed.msg")) + + # Add custom buttons + restart_now_btn = msg.addButton( + tr("dialog.domain_changed.restart_now"), QMessageBox.ButtonRole.AcceptRole + ) + restart_later_btn = msg.addButton( + tr("dialog.domain_changed.restart_later"), QMessageBox.ButtonRole.RejectRole + ) + + msg.exec() + + if msg.clickedButton() == restart_now_btn: + logger.info("User chose to restart application now") + self._restart_application() + else: + logger.info("User chose to restart later - clearing cache and loading new URL") + # Clear cache and load new URL directly + self.web_view.clear_cache_and_cookies() + self._navigate_home() + + def _handle_language_change_restart(self) -> None: + """Handle language change by prompting for an optional restart.""" + from PySide6.QtWidgets import QMessageBox + + msg = QMessageBox(self) + msg.setWindowTitle(tr("dialog.language_changed.title")) + msg.setIcon(QMessageBox.Icon.Information) + msg.setText(tr("dialog.language_changed.msg")) + + restart_now_btn = msg.addButton( + tr("dialog.language_changed.restart_now"), QMessageBox.ButtonRole.AcceptRole + ) + msg.addButton( + tr("dialog.language_changed.restart_later"), QMessageBox.ButtonRole.RejectRole + ) + + msg.exec() + + if msg.clickedButton() == restart_now_btn: + self._restart_application() + + def _restart_application(self) -> None: + """Restart the application automatically. + + Starts a new process with the same arguments and closes the current application. + """ + import os + import sys + + from PySide6.QtCore import QProcess + + logger.info("Restarting application...") + + try: + # Get the path to the Python executable + if hasattr(sys, "_MEIPASS"): + # Running as PyInstaller bundle + executable = sys.executable + else: + # Running in development mode + executable = sys.executable + + # Get the module to run + module_args = ["-m", "webdrop_bridge.main"] + + # Start new process + QProcess.startDetached(executable, module_args) + + logger.info("New application process started successfully") + + # Close current application after a small delay to allow process to start + from PySide6.QtCore import QTimer + + QTimer.singleShot(500, lambda: sys.exit(0)) + + except Exception as e: + logger.error(f"Failed to restart application: {e}") + + from PySide6.QtWidgets import QMessageBox + + QMessageBox.warning( + self, + tr("dialog.restart_failed.title"), + tr("dialog.restart_failed.msg", error=str(e)), + ) + def _navigate_home(self) -> None: """Navigate to the home (start) URL.""" home_url = self.config.webapp_url @@ -1208,10 +1871,10 @@ class MainWindow(QMainWindow): event: Close event """ logger.debug("Closing application - cleaning up web engine resources") - + # Properly delete WebEnginePage before the profile is released # This ensures cookies and session data are saved correctly - if hasattr(self, 'web_view') and self.web_view: + if hasattr(self, "web_view") and self.web_view: page = self.web_view.page() if page: # Disconnect signals to prevent callbacks during shutdown @@ -1219,95 +1882,99 @@ class MainWindow(QMainWindow): page.loadFinished.disconnect() except RuntimeError: pass # Already disconnected or never connected - + # Delete the page explicitly page.deleteLater() logger.debug("WebEnginePage scheduled for deletion") - + # Clear the page from the view - self.web_view.setPage(None) # type: ignore - + self.web_view.setPage(None) # type: ignore + event.accept() def check_for_updates_startup(self) -> None: """Check for updates on application startup. - + Runs asynchronously in background without blocking UI. Uses 24-hour cache so will not hammer the API. """ from webdrop_bridge.core.updater import UpdateManager - + try: # Create update manager - cache_dir = Path.home() / ".webdrop-bridge" + cache_dir = self.config.get_cache_dir() manager = UpdateManager( current_version=self.config.app_version, - config_dir=cache_dir + config_dir=cache_dir, + brand_id=self.config.brand_id, + forgejo_url=self.config.update_base_url, + repo=self.config.update_repo, + update_channel=self.config.update_channel, + manifest_name=self.config.update_manifest_name, ) - + # Run async check in background self._run_async_check(manager) - + except Exception as e: logger.error(f"Failed to initialize update check: {e}") def _run_async_check(self, manager) -> None: """Run update check in background thread with safety timeout. - + Args: manager: UpdateManager instance """ try: logger.debug("_run_async_check() starting") - + # Create and start background thread thread = QThread() worker = UpdateCheckWorker(manager, self.config.app_version) - + # IMPORTANT: Keep references to prevent garbage collection # Store in a list to keep worker alive during thread execution self._background_threads.append(thread) - self._background_workers = getattr(self, '_background_workers', {}) + self._background_workers = getattr(self, "_background_workers", {}) self._background_workers[id(thread)] = worker - + logger.debug(f"Created worker and thread, thread id: {id(thread)}") - + # Create a safety timeout timer (but don't start it yet) # Use a flag-based approach to avoid thread issues with stopping timers check_started_time = [datetime.now()] # Track when check started check_completed = [False] # Flag to mark when check completes - + def force_close_timeout(): # Check if already completed - if so, don't show error if check_completed[0]: logger.debug("Timeout fired but check already completed, suppressing error") return - + logger.warning("Update check taking too long (30s timeout)") - if hasattr(self, 'checking_dialog') and self.checking_dialog: + if hasattr(self, "checking_dialog") and self.checking_dialog: self.checking_dialog.close() self.set_update_status("Check timed out - no server response", emoji="⏱️") - + # Show error dialog from PySide6.QtWidgets import QMessageBox + QMessageBox.warning( self, - "Update Check Timeout", - "The server did not respond within 30 seconds.\n\n" - "This may be due to a network issue or server unavailability.\n\n" - "Please check your connection and try again." + tr("dialog.update_timeout.title"), + tr("dialog.update_timeout.msg"), ) - + safety_timer = QTimer() safety_timer.setSingleShot(True) safety_timer.setInterval(30000) # 30 seconds safety_timer.timeout.connect(force_close_timeout) - + # Mark check as completed when any result arrives def on_check_done(): logger.debug("Check finished, marking as completed to prevent timeout error") check_completed[0] = True - + # Connect signals worker.update_available.connect(self._on_update_available) worker.update_available.connect(on_check_done) @@ -1318,7 +1985,7 @@ class MainWindow(QMainWindow): worker.finished.connect(thread.quit) worker.finished.connect(worker.deleteLater) thread.finished.connect(thread.deleteLater) - + # Clean up finished threads and workers from list def cleanup_thread(): logger.debug(f"Cleaning up thread {id(thread)}") @@ -1326,199 +1993,199 @@ class MainWindow(QMainWindow): self._background_threads.remove(thread) if id(thread) in self._background_workers: del self._background_workers[id(thread)] - + thread.finished.connect(cleanup_thread) - + # Move worker to thread and start logger.debug("Moving worker to thread and connecting started signal") worker.moveToThread(thread) thread.started.connect(worker.run) - + logger.debug("Starting thread...") thread.start() logger.debug("Thread started, starting safety timer") - + # Start the safety timeout safety_timer.start() - + except Exception as e: logger.error(f"Failed to start update check thread: {e}", exc_info=True) def _on_update_status(self, status: str, emoji: str) -> None: """Handle update status changes. - + Args: status: Status text emoji: Status emoji """ self.set_update_status(status, emoji) - + # If this is a manual check and we get the "Ready" status, it means no updates if self._is_manual_check and status == "Ready": # Close checking dialog first, then show result - if hasattr(self, 'checking_dialog') and self.checking_dialog: + if hasattr(self, "checking_dialog") and self.checking_dialog: self.checking_dialog.close() - + from webdrop_bridge.ui.update_manager_ui import NoUpdateDialog + dialog = NoUpdateDialog(parent=self) self._is_manual_check = False dialog.exec() def _on_check_failed(self, error_message: str) -> None: """Handle update check failure. - + Args: error_message: Error description """ logger.error(f"Update check failed: {error_message}") - self.set_update_status(f"Check failed: {error_message}", emoji="❌") + self.set_update_status(tr("update.status.check_failed", error=error_message), emoji="❌") self._is_manual_check = False - + # Close checking dialog first, then show error - if hasattr(self, 'checking_dialog') and self.checking_dialog: + if hasattr(self, "checking_dialog") and self.checking_dialog: self.checking_dialog.close() - + from PySide6.QtWidgets import QMessageBox + QMessageBox.warning( self, - "Update Check Failed", - f"Could not check for updates:\n\n{error_message}\n\nPlease try again later." + tr("dialog.update_failed.title"), + tr("dialog.update_failed.msg", error=error_message), ) def _on_update_available(self, release) -> None: """Handle update available notification. - + Args: release: Release object with update info """ + # Close checking dialog if open (manual check case) + if hasattr(self, "checking_dialog") and self.checking_dialog: + self.checking_dialog.close() + self.checking_dialog = None + self._is_manual_check = False + # Update status to show update available - self.set_update_status(f"Update available: v{release.version}", emoji="✅") - + self.set_update_status(tr("update.status.available", version=release.version), emoji="✅") + # Show update available dialog from webdrop_bridge.ui.update_manager_ui import UpdateAvailableDialog - - dialog = UpdateAvailableDialog( - version=release.version, - changelog=release.body, - parent=self - ) - + + dialog = UpdateAvailableDialog(version=release.version, changelog=release.body, parent=self) + # Connect dialog signals dialog.update_now.connect(lambda: self._on_user_update_now(release)) dialog.update_later.connect(lambda: self._on_user_update_later()) - dialog.skip_version.connect(lambda: self._on_user_skip_version(release.version)) - + # Show dialog (modal) dialog.exec() def _on_user_update_now(self, release) -> None: """Handle user clicking 'Update Now' button. - + Args: release: Release object to download and install """ logger.info(f"User clicked 'Update Now' for v{release.version}") - + # Start download self._start_update_download(release) def _on_user_update_later(self) -> None: """Handle user clicking 'Later' button.""" logger.info("User deferred update") - self.set_update_status("Update deferred", emoji="") - - def _on_user_skip_version(self, version: str) -> None: - """Handle user clicking 'Skip Version' button. - - Args: - version: Version to skip - """ - logger.info(f"User skipped version {version}") - - # Store skipped version in preferences - skipped_file = Path.home() / ".webdrop-bridge" / "skipped_version.txt" - skipped_file.parent.mkdir(parents=True, exist_ok=True) - skipped_file.write_text(version) - - self.set_update_status(f"Skipped v{version}", emoji="") + self.set_update_status(tr("update.status.deferred"), emoji="") def _start_update_download(self, release) -> None: """Start downloading the update in background thread. - + Args: release: Release object to download """ logger.info(f"Starting download for v{release.version}") - self.set_update_status(f"Downloading v{release.version}", emoji="⬇️") - + self.set_update_status(tr("update.status.downloading", version=release.version), emoji="⬇️") + + # Show download progress dialog + from webdrop_bridge.ui.update_manager_ui import DownloadingDialog + + self.downloading_dialog = DownloadingDialog(self) + self.downloading_dialog.show() + # Run download in background thread to avoid blocking UI self._perform_update_async(release) def _perform_update_async(self, release) -> None: """Download and install update asynchronously in background thread. - + Args: release: Release object to download and install """ from webdrop_bridge.core.updater import UpdateManager - + try: logger.debug("_perform_update_async() starting") - + # Create update manager manager = UpdateManager( current_version=self.config.app_version, - config_dir=Path.home() / ".webdrop-bridge" + config_dir=self.config.get_cache_dir(), + brand_id=self.config.brand_id, + forgejo_url=self.config.update_base_url, + repo=self.config.update_repo, + update_channel=self.config.update_channel, + manifest_name=self.config.update_manifest_name, ) - + # Create and start background thread thread = QThread() worker = UpdateDownloadWorker(manager, release, self.config.app_version) - + # IMPORTANT: Keep references to prevent garbage collection self._background_threads.append(thread) self._background_workers[id(thread)] = worker - + logger.debug(f"Created download worker and thread, thread id: {id(thread)}") - + # Connect signals worker.download_complete.connect(self._on_download_complete) worker.download_failed.connect(self._on_download_failed) + worker.download_progress.connect(self._on_download_progress) worker.update_status.connect(self._on_update_status) worker.finished.connect(thread.quit) worker.finished.connect(worker.deleteLater) thread.finished.connect(thread.deleteLater) - + # Create a safety timeout timer for download (10 minutes) # Use a flag-based approach to avoid thread issues with stopping timers download_started_time = [datetime.now()] # Track when download started download_completed = [False] # Flag to mark when download completes - + def force_timeout(): # Check if already completed - if so, don't show error if download_completed[0]: logger.debug("Timeout fired but download already completed, suppressing error") return - + logger.error("Download taking too long (10 minute timeout)") self.set_update_status("Download timed out - no server response", emoji="⏱️") worker.download_failed.emit("Download took too long with no response") thread.quit() thread.wait() - + safety_timer = QTimer() safety_timer.setSingleShot(True) safety_timer.setInterval(600000) # 10 minutes safety_timer.timeout.connect(force_timeout) - + # Mark download as completed when it finishes def on_download_done(): logger.debug("Download finished, marking as completed to prevent timeout error") download_completed[0] = True - + worker.download_complete.connect(on_download_done) worker.download_failed.connect(on_download_done) - + # Clean up finished threads from list def cleanup_thread(): logger.debug(f"Cleaning up download thread {id(thread)}") @@ -1526,9 +2193,9 @@ class MainWindow(QMainWindow): self._background_threads.remove(thread) if id(thread) in self._background_workers: del self._background_workers[id(thread)] - + thread.finished.connect(cleanup_thread) - + # Start thread logger.debug("Moving download worker to thread and connecting started signal") worker.moveToThread(thread) @@ -1536,68 +2203,90 @@ class MainWindow(QMainWindow): logger.debug("Starting download thread...") thread.start() logger.debug("Download thread started, starting safety timer") - + # Start the safety timeout safety_timer.start() - + except Exception as e: logger.error(f"Failed to start update download: {e}") self.set_update_status(f"Update failed: {str(e)[:30]}", emoji="❌") def _on_download_complete(self, installer_path: Path) -> None: """Handle successful download and verification. - + Args: installer_path: Path to downloaded and verified installer """ from webdrop_bridge.ui.update_manager_ui import InstallDialog - + + if hasattr(self, "downloading_dialog") and self.downloading_dialog: + self.downloading_dialog.close() + self.downloading_dialog = None + logger.info(f"Download complete: {installer_path}") - self.set_update_status("Ready to install", emoji="✅") - + self.set_update_status(tr("update.status.ready_to_install"), emoji="✅") + # Show install confirmation dialog install_dialog = InstallDialog(parent=self) - install_dialog.install_now.connect( - lambda: self._do_install(installer_path) - ) + install_dialog.install_now.connect(lambda: self._do_install(installer_path)) install_dialog.exec() def _on_download_failed(self, error: str) -> None: """Handle download failure. - + Args: error: Error message """ + if hasattr(self, "downloading_dialog") and self.downloading_dialog: + self.downloading_dialog.close() + self.downloading_dialog = None + logger.error(f"Download failed: {error}") self.set_update_status(error, emoji="❌") - + from PySide6.QtWidgets import QMessageBox + QMessageBox.critical( self, - "Download Failed", - f"Could not download the update:\n\n{error}\n\nPlease try again later." + tr("dialog.download_failed.title"), + tr("dialog.download_failed.msg", error=error), ) + def _on_download_progress(self, downloaded: int, total: int) -> None: + """Forward download progress to the downloading dialog. + + Args: + downloaded: Bytes downloaded so far + total: Total bytes (0 if unknown) + """ + if hasattr(self, "downloading_dialog") and self.downloading_dialog: + self.downloading_dialog.set_progress(downloaded, total) + def _do_install(self, installer_path: Path) -> None: """Execute the installer. - + Args: installer_path: Path to installer executable """ logger.info(f"Installing from {installer_path}") - + from webdrop_bridge.core.updater import UpdateManager - + manager = UpdateManager( current_version=self.config.app_version, - config_dir=Path.home() / ".webdrop-bridge" + config_dir=self.config.get_cache_dir(), + brand_id=self.config.brand_id, + forgejo_url=self.config.update_base_url, + repo=self.config.update_repo, + update_channel=self.config.update_channel, + manifest_name=self.config.update_manifest_name, ) - + if manager.install_update(installer_path): - self.set_update_status("Installation started", emoji="✅") + self.set_update_status(tr("update.status.installation_started"), emoji="✅") logger.info("Update installer launched successfully") else: - self.set_update_status("Installation failed", emoji="❌") + self.set_update_status(tr("update.status.installation_failed"), emoji="❌") logger.error("Failed to launch update installer") @@ -1606,13 +2295,13 @@ class UpdateCheckWorker(QObject): # Define signals at class level update_available = Signal(object) # Emits Release object - update_status = Signal(str, str) # Emits (status_text, emoji) - check_failed = Signal(str) # Emits error message + update_status = Signal(str, str) # Emits (status_text, emoji) + check_failed = Signal(str) # Emits error message finished = Signal() def __init__(self, manager, current_version: str): """Initialize worker. - + Args: manager: UpdateManager instance current_version: Current app version @@ -1626,26 +2315,23 @@ class UpdateCheckWorker(QObject): loop = None try: logger.debug("UpdateCheckWorker.run() starting") - + # Notify checking status - self.update_status.emit("Checking for updates", "🔄") - + self.update_status.emit("Checking for updates", "🔄") # Translated by set_update_status + # Create a fresh event loop for this thread logger.debug("Creating new event loop for worker thread") loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) - + try: # Check for updates with short timeout (network call has its own timeout) logger.debug("Starting update check with 10-second timeout") release = loop.run_until_complete( - asyncio.wait_for( - self.manager.check_for_updates(), - timeout=10 - ) + asyncio.wait_for(self.manager.check_for_updates(), timeout=10) ) logger.debug(f"Update check completed, release={release}") - + # Emit result if release: logger.info(f"Update available: {release.version}") @@ -1653,15 +2339,17 @@ class UpdateCheckWorker(QObject): else: # No update available - show ready status logger.info("No update available") - self.update_status.emit("Ready", "") - + self.update_status.emit( + "Ready", "" + ) # English sentinel; _on_update_status compares this + except asyncio.TimeoutError: logger.warning("Update check timed out - server not responding") - self.check_failed.emit("Server not responding - check again later") - + self.check_failed.emit(tr("worker.server_not_responding")) + except Exception as e: logger.error(f"Update check failed: {e}", exc_info=True) - self.check_failed.emit(f"Check failed: {str(e)[:50]}") + self.check_failed.emit(tr("worker.check_failed", error=str(e)[:50])) finally: # Properly close the event loop if loop is not None: @@ -1679,13 +2367,14 @@ class UpdateDownloadWorker(QObject): # Define signals at class level download_complete = Signal(Path) # Emits installer_path - download_failed = Signal(str) # Emits error message + download_failed = Signal(str) # Emits error message + download_progress = Signal(int, int) # Emits (bytes_downloaded, total_bytes) update_status = Signal(str, str) # Emits (status_text, emoji) finished = Signal() def __init__(self, manager, release, current_version: str): """Initialize worker. - + Args: manager: UpdateManager instance release: Release object to download @@ -1701,60 +2390,70 @@ class UpdateDownloadWorker(QObject): loop = None try: # Download the update - self.update_status.emit(f"Downloading v{self.release.version}", "⬇️") - + self.update_status.emit( + tr("update.status.downloading", version=self.release.version), "⬇️" + ) + # Create a fresh event loop for this thread loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) - + try: # Download with 5 minute timeout (300 seconds) logger.info("Starting download with 5-minute timeout") installer_path = loop.run_until_complete( asyncio.wait_for( - self.manager.download_update(self.release), - timeout=300 + self.manager.download_update( + self.release, + progress_callback=lambda cur, tot: self.download_progress.emit( + cur, tot + ), + ), + timeout=300, ) ) - + if not installer_path: - self.update_status.emit("Download failed", "❌") - self.download_failed.emit("No installer found in release") + self.update_status.emit( + "Download failed", "❌" + ) # Translated by set_update_status + self.download_failed.emit(tr("worker.no_installer")) logger.error("Download failed - no installer found") return - + logger.info(f"Downloaded to {installer_path}") self.update_status.emit("Verifying download", "🔍") - + # Verify checksum with 30 second timeout logger.info("Starting checksum verification") checksum_ok = loop.run_until_complete( asyncio.wait_for( - self.manager.verify_checksum(installer_path, self.release), - timeout=30 + self.manager.verify_checksum(installer_path, self.release), timeout=30 ) ) - + if not checksum_ok: self.update_status.emit("Verification failed", "❌") - self.download_failed.emit("Checksum verification failed") + self.download_failed.emit(tr("worker.checksum_failed")) logger.error("Checksum verification failed") return - + logger.info("Checksum verification passed") self.download_complete.emit(installer_path) - + except asyncio.TimeoutError as e: logger.error(f"Download/verification timed out: {e}") - self.update_status.emit("Operation timed out", "⏱️") - self.download_failed.emit("Download or verification timed out (no response from server)") + self.update_status.emit( + "Operation timed out", "⏱️" + ) # Translated by set_update_status + self.download_failed.emit(tr("worker.download_timed_out")) except Exception as e: logger.error(f"Error during download: {e}") - self.download_failed.emit(f"Download error: {str(e)[:50]}") - + self.download_failed.emit(tr("worker.download_error", error=str(e)[:50])) + except Exception as e: logger.error(f"Download worker failed: {e}") - self.download_failed.emit(f"Download error: {str(e)[:50]}") + self.download_failed.emit(tr("worker.download_error", error=str(e)[:50])) finally: # Properly close the event loop if loop is not None: @@ -1765,3 +2464,4 @@ class UpdateDownloadWorker(QObject): except Exception as e: logger.warning(f"Error closing event loop: {e}") self.finished.emit() + self.finished.emit() diff --git a/src/webdrop_bridge/ui/mouse_event_emulator.js b/src/webdrop_bridge/ui/mouse_event_emulator.js new file mode 100644 index 0000000..c38c6fa --- /dev/null +++ b/src/webdrop_bridge/ui/mouse_event_emulator.js @@ -0,0 +1,186 @@ +// Mouse Event Emulator for Qt WebEngineView +// Qt WebEngineView may not forward all mouse events to JavaScript properly +// This script uses polling with document.elementFromPoint() to detect hover changes +// and manually dispatches mouseover/mouseenter/mouseleave events. +// ALSO: Injects a CSS stylesheet that simulates :hover effects using classes + +(function() { + try { + if (window.__mouse_emulator_injected) return; + window.__mouse_emulator_injected = true; + +console.log("[MouseEventEmulator] Initialized - polling for hover state changes"); + + // ======================================================== + // PART 1: Inject CSS stylesheet for hover simulation + // ======================================================== + + var style = document.createElement("style"); + style.type = "text/css"; + style.id = "__mouse_emulator_hover_styles"; + style.innerHTML = ` + /* Checkbox hover simulation */ + input[type="checkbox"].__mouse_hover { + cursor: pointer; + } + + /* Link hover simulation */ + a.__mouse_hover { + text-decoration: underline; + } + `; + + if (document.head) { + document.head.insertBefore(style, document.head.firstChild); + } else { + document.body.insertBefore(style, document.body.firstChild); + } + + // ======================================================== + // PART 2: Track hover state and apply hover class + // ======================================================== + + var lastElement = null; + var lastX = -1; + var lastY = -1; + + // High-frequency polling to detect element changes at mouse position + var pollIntervalId = setInterval(function() { + if (!window.__lastMousePos) { + window.__lastMousePos = { x: 0, y: 0 }; + } + + var x = window.__lastMousePos.x; + var y = window.__lastMousePos.y; + + lastX = x; + lastY = y; + + var element = document.elementFromPoint(x, y); + + if (!element || element === document || element.tagName === "HTML") { + if (lastElement && lastElement !== document) { + try { + lastElement.classList.remove("__mouse_hover"); + var leaveEvent = new MouseEvent("mouseleave", { + bubbles: true, + cancelable: true, + view: window, + }); + lastElement.dispatchEvent(leaveEvent); + } catch (err) { + console.warn("[MouseEventEmulator] Error in leave handler:", err); + } + lastElement = null; + } + return; + } + + // Element changed + if (element !== lastElement) { + // Remove hover class from previous element + if (lastElement && lastElement !== document && lastElement !== element) { + try { + lastElement.classList.remove("__mouse_hover"); + var leaveEvent = new MouseEvent("mouseleave", { + bubbles: true, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + lastElement.dispatchEvent(leaveEvent); + } catch (err) { + console.warn("[MouseEventEmulator] Error dispatching mouseleave:", err); + } + } + + // Add hover class and dispatch events for new element + if (element) { + try { + element.classList.add("__mouse_hover"); + + var overEvent = new MouseEvent("mouseover", { + bubbles: true, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + element.dispatchEvent(overEvent); + + var enterEvent = new MouseEvent("mouseenter", { + bubbles: false, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + element.dispatchEvent(enterEvent); + + var moveEvent = new MouseEvent("mousemove", { + bubbles: true, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + element.dispatchEvent(moveEvent); + } catch (err) { + console.warn("[MouseEventEmulator] Error dispatching mouse events:", err); + } + } + + lastElement = element; + } + }, 50); + + // Track mouse position from all available events + document.addEventListener( + "mousemove", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mousedown", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mouseup", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mouseover", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mouseenter", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + console.log("[MouseEventEmulator] Ready - polling enabled for hover state detection"); + } catch (e) { + console.error("[MouseEventEmulator] FATAL ERROR:", e); + if (e.stack) { + console.error("[MouseEventEmulator] Stack:", e.stack); + } + } +})(); diff --git a/src/webdrop_bridge/ui/restricted_web_view.py b/src/webdrop_bridge/ui/restricted_web_view.py index bd77741..12dbeee 100644 --- a/src/webdrop_bridge/ui/restricted_web_view.py +++ b/src/webdrop_bridge/ui/restricted_web_view.py @@ -1,21 +1,24 @@ """Restricted web view with URL whitelist enforcement for Kiosk-mode.""" import fnmatch +import hashlib import logging from pathlib import Path from typing import List, Optional, Union from PySide6.QtCore import QStandardPaths, QUrl from PySide6.QtGui import QDesktopServices -from PySide6.QtWebEngineCore import QWebEngineNavigationRequest, QWebEnginePage, QWebEngineProfile +from PySide6.QtWebEngineCore import ( + QWebEngineNavigationRequest, + QWebEnginePage, + QWebEngineProfile, + QWebEngineSettings, +) from PySide6.QtWebEngineWidgets import QWebEngineView logger = logging.getLogger(__name__) -logger = logging.getLogger(__name__) - - class CustomWebEnginePage(QWebEnginePage): """Custom page that handles new window requests for downloads.""" @@ -108,21 +111,53 @@ class RestrictedWebEngineView(QWebEngineView): If allowed_urls is empty, no restrictions are applied. If allowed_urls is not empty, only matching URLs are loaded in the view. Non-matching URLs open in the system default browser. + + Each webapp_url gets an isolated profile to prevent cache corruption + from old domains affecting new domains. """ - def __init__(self, allowed_urls: Optional[List[str]] = None): + def __init__(self, allowed_urls: Optional[List[str]] = None, webapp_url: Optional[str] = None): """Initialize the restricted web view. Args: allowed_urls: List of allowed URL patterns (empty = no restriction) Patterns support wildcards: *.example.com, localhost, etc. + webapp_url: The web application URL for profile isolation. If provided, + creates a unique profile per domain to avoid cache corruption. """ super().__init__() self.allowed_urls = allowed_urls or [] + self.webapp_url = webapp_url # Create persistent profile for cookie and session storage + # Profile is unique per domain to prevent cache corruption self.profile = self._create_persistent_profile() + # Configure WebEngine settings on the profile for proper JavaScript and mouse event support + settings = self.profile.settings() + + # Enable JavaScript (required for mouseover events and interactive features) + settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptEnabled, True) + + # Enable JavaScript access to clipboard (some web apps need this) + settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptCanAccessClipboard, True) + + # Enable JavaScript to open windows (for dialogs, popups) + settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptCanOpenWindows, True) + + # Enable local content access (needed for drag operations) + settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, True) + + # Allow local content to access remote resources (some web apps may need this) + settings.setAttribute( + QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, False + ) + + logger.debug( + "RestrictedWebEngineView WebEngine settings configured: " + "JavaScript=enabled, Clipboard=enabled, WindowOpen=enabled, LocalFileAccess=enabled" + ) + # Use custom page for better download handling with persistent profile custom_page = CustomWebEnginePage(self.profile, self) self.setPage(custom_page) @@ -131,6 +166,23 @@ class RestrictedWebEngineView(QWebEngineView): "RestrictedWebEngineView initialized with CustomWebEnginePage and persistent profile" ) + # CRITICAL: Also configure settings on the page itself after setPage() + # This ensures Page-level settings override Profile defaults for event handling + page_settings = self.page().settings() + page_settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptEnabled, True) + page_settings.setAttribute( + QWebEngineSettings.WebAttribute.JavascriptCanAccessClipboard, True + ) + page_settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptCanOpenWindows, True) + page_settings.setAttribute( + QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, True + ) + page_settings.setAttribute( + QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, False + ) + + logger.debug("Page-level WebEngine settings configured for mouse event handling") + # Connect to navigation request handler self.page().navigationRequested.connect(self._on_navigation_requested) @@ -141,6 +193,9 @@ class RestrictedWebEngineView(QWebEngineView): authentication sessions (e.g., Microsoft login) to persist across application restarts. + Each unique webapp domain gets its own profile to prevent + cache corruption from old domains affecting new domains. + Returns: Configured QWebEngineProfile with persistent storage """ @@ -149,14 +204,32 @@ class RestrictedWebEngineView(QWebEngineView): QStandardPaths.StandardLocation.AppDataLocation ) + # Create unique profile name based on webapp_url domain + # This ensures different domains get isolated profiles + if self.webapp_url: + # Extract domain/path for profile naming + if self.webapp_url.startswith("http://") or self.webapp_url.startswith("https://"): + # Remote URL - use domain + url_obj = QUrl(self.webapp_url) + domain = url_obj.host() or "remote" + else: + # Local file - use hash of path + domain = "local" + else: + domain = "default" + + # Create a stable hash of the domain + # This creates a unique but consistent profile name per domain + domain_hash = hashlib.md5(domain.encode()).hexdigest()[:8] + profile_name = f"webdrop_bridge_{domain_hash}" + # Create profile directory path - profile_path = Path(app_data_dir) / "WebEngineProfile" + profile_path = Path(app_data_dir) / "webdrop_bridge" / profile_name profile_path.mkdir(parents=True, exist_ok=True) # Create persistent profile with custom storage location - # Using "WebDropBridge" as the profile name - # Note: No parent specified so we control the lifecycle - profile = QWebEngineProfile("WebDropBridge") + # Using unique profile name so different domains have isolated caches + profile = QWebEngineProfile(profile_name) profile.setPersistentStoragePath(str(profile_path)) # Configure persistent cookies (critical for authentication) @@ -170,7 +243,8 @@ class RestrictedWebEngineView(QWebEngineView): # Set cache size to 100 MB profile.setHttpCacheMaximumSize(100 * 1024 * 1024) - logger.debug(f"Created persistent profile at: {profile_path}") + logger.debug(f"Created persistent profile '{profile_name}' at: {profile_path}") + logger.debug(f"Profile domain identifier: {domain}") logger.debug("Cookies policy: ForcePersistentCookies") logger.debug("HTTP cache: DiskHttpCache (100 MB)") @@ -204,7 +278,7 @@ class RestrictedWebEngineView(QWebEngineView): - Exact domain matches: example.com - Wildcard patterns: *.example.com - Localhost variations: localhost, 127.0.0.1 - - File URLs: file://... + - Internal/local URLs: file://, data:, about:, blob:, qrc: Args: url: QUrl to check @@ -216,8 +290,8 @@ class RestrictedWebEngineView(QWebEngineView): host = url.host() scheme = url.scheme() - # Allow file:// URLs (local webapp) - if scheme == "file": + # Allow internal browser/Qt schemes (never send these to the OS) + if scheme in ("file", "data", "about", "blob", "qrc"): return True # If no whitelist, allow all URLs @@ -242,3 +316,19 @@ class RestrictedWebEngineView(QWebEngineView): return True return False + + def clear_cache_and_cookies(self) -> None: + """Clear the profile cache and cookies. + + Use this method when the webapp URL changes to prevent cache corruption + from old domains affecting the new domain's authentication. + """ + logger.debug(f"Clearing cache and cookies for profile: {self.profile.storageName()}") + + # Clear all cookies + self.profile.cookieStore().deleteAllCookies() + + # Clear cache + self.profile.clearHttpCache() + + logger.debug("Cache and cookies cleared successfully") diff --git a/src/webdrop_bridge/ui/settings_dialog.py b/src/webdrop_bridge/ui/settings_dialog.py index dcbd016..99f5241 100644 --- a/src/webdrop_bridge/ui/settings_dialog.py +++ b/src/webdrop_bridge/ui/settings_dialog.py @@ -2,10 +2,10 @@ import logging from pathlib import Path -from typing import List, Optional +from typing import Any, Dict, Optional -from PySide6.QtCore import Qt from PySide6.QtWidgets import ( + QComboBox, QDialog, QDialogButtonBox, QFileDialog, @@ -13,7 +13,6 @@ from PySide6.QtWidgets import ( QLabel, QLineEdit, QListWidget, - QListWidgetItem, QPushButton, QSpinBox, QTableWidget, @@ -25,118 +24,95 @@ from PySide6.QtWidgets import ( from webdrop_bridge.config import Config, ConfigurationError from webdrop_bridge.core.config_manager import ConfigExporter, ConfigProfile, ConfigValidator +from webdrop_bridge.utils.i18n import get_available_languages, tr from webdrop_bridge.utils.logging import reconfigure_logging logger = logging.getLogger(__name__) class SettingsDialog(QDialog): - """Dialog for managing application settings and configuration. - - Provides tabs for: - - Paths: Manage allowed root directories - - URLs: Manage allowed web URLs - - Logging: Configure logging settings - - Window: Manage window size and behavior - - Profiles: Save/load/delete configuration profiles - """ + """Dialog for managing application settings and configuration.""" - def __init__(self, config: Config, parent=None): + def __init__(self, config: Config, parent: Optional[QWidget] = None): """Initialize the settings dialog. - + Args: config: Current application configuration parent: Parent widget """ super().__init__(parent) self.config = config - self.profile_manager = ConfigProfile() - self.setWindowTitle("Settings") + self.profile_manager = ConfigProfile(config.config_dir_name) + self.setWindowTitle(tr("settings.title")) self.setGeometry(100, 100, 600, 500) - + self.setup_ui() def setup_ui(self) -> None: """Set up the dialog UI with tabs.""" layout = QVBoxLayout() - - # Create tab widget + self.tabs = QTabWidget() - - # Add tabs - self.tabs.addTab(self._create_web_source_tab(), "Web Source") - self.tabs.addTab(self._create_paths_tab(), "Paths") - self.tabs.addTab(self._create_urls_tab(), "URLs") - self.tabs.addTab(self._create_logging_tab(), "Logging") - self.tabs.addTab(self._create_window_tab(), "Window") - self.tabs.addTab(self._create_profiles_tab(), "Profiles") - + self.tabs.addTab(self._create_general_tab(), tr("settings.tab.general")) + self.tabs.addTab(self._create_web_source_tab(), tr("settings.tab.web_source")) + self.tabs.addTab(self._create_paths_tab(), tr("settings.tab.paths")) + self.tabs.addTab(self._create_urls_tab(), tr("settings.tab.urls")) + self.tabs.addTab(self._create_logging_tab(), tr("settings.tab.logging")) + self.tabs.addTab(self._create_window_tab(), tr("settings.tab.window")) + self.tabs.addTab(self._create_profiles_tab(), tr("settings.tab.profiles")) layout.addWidget(self.tabs) - - # Add buttons + button_box = QDialogButtonBox( QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel ) button_box.accepted.connect(self.accept) button_box.rejected.connect(self.reject) layout.addWidget(button_box) - + self.setLayout(layout) def accept(self) -> None: - """Handle OK button - save configuration changes to file. - - Validates configuration and saves to the default config path. - Applies log level changes immediately in the running application. - If validation or save fails, shows error and stays in dialog. - """ + """Handle OK button - save configuration changes to file.""" try: - # Get updated configuration data from UI config_data = self.get_config_data() - - # Convert URL mappings from dict to URLMapping objects + from webdrop_bridge.config import URLMapping - + url_mappings = [ - URLMapping( - url_prefix=m["url_prefix"], - local_path=m["local_path"] - ) + URLMapping(url_prefix=m["url_prefix"], local_path=m["local_path"]) for m in config_data["url_mappings"] ] - - # Update the config object with new values + old_log_level = self.config.log_level + self.config.language = config_data["language"] self.config.log_level = config_data["log_level"] - self.config.log_file = Path(config_data["log_file"]) if config_data["log_file"] else None + self.config.log_file = ( + Path(config_data["log_file"]) if config_data["log_file"] else None + ) self.config.allowed_roots = [Path(r).resolve() for r in config_data["allowed_roots"]] self.config.allowed_urls = config_data["allowed_urls"] self.config.webapp_url = config_data["webapp_url"] self.config.url_mappings = url_mappings self.config.window_width = config_data["window_width"] self.config.window_height = config_data["window_height"] - - # Save to file (creates parent dirs if needed) - config_path = Config.get_default_config_path() + + config_path = self.config.get_config_path() self.config.to_file(config_path) - + logger.info(f"Configuration saved to {config_path}") logger.info(f" Log level: {self.config.log_level} (was: {old_log_level})") logger.info(f" Window size: {self.config.window_width}x{self.config.window_height}") - - # Apply log level change immediately to running application + if old_log_level != self.config.log_level: - logger.info(f"🔄 Updating log level: {old_log_level} → {self.config.log_level}") reconfigure_logging( logger_name="webdrop_bridge", level=self.config.log_level, - log_file=self.config.log_file + log_file=self.config.log_file, ) - logger.info(f"✅ Log level updated to {self.config.log_level}") - - # Call parent accept to close dialog + logger.info(f"Log level updated to {self.config.log_level}") + super().accept() - + except ConfigurationError as e: logger.error(f"Configuration error: {e}") self._show_error(f"Configuration Error:\n\n{e}") @@ -144,133 +120,165 @@ class SettingsDialog(QDialog): logger.error(f"Failed to save configuration: {e}", exc_info=True) self._show_error(f"Failed to save configuration:\n\n{e}") - def _create_web_source_tab(self) -> QWidget: - """Create web source configuration tab.""" - from PySide6.QtWidgets import QTableWidget, QTableWidgetItem - + def _create_general_tab(self) -> QWidget: + """Create general settings tab with language selector.""" widget = QWidget() layout = QVBoxLayout() - - # Webapp URL configuration - layout.addWidget(QLabel("Web Application URL:")) + + lang_layout = QHBoxLayout() + lang_layout.addWidget(QLabel(tr("settings.general.language_label"))) + + self.language_combo = QComboBox() + self.language_combo.addItem(tr("settings.general.language_auto"), "auto") + available = get_available_languages() + current_lang = self.config.language + for code, name in available.items(): + self.language_combo.addItem(name, code) + + idx = self.language_combo.findData(current_lang) + if idx >= 0: + self.language_combo.setCurrentIndex(idx) + + lang_layout.addWidget(self.language_combo) + lang_layout.addStretch() + layout.addLayout(lang_layout) + + note = QLabel(tr("settings.general.language_restart_note")) + note.setStyleSheet("color: gray; font-size: 11px;") + layout.addWidget(note) + + layout.addStretch() + widget.setLayout(layout) + return widget + + def _create_web_source_tab(self) -> QWidget: + """Create web source configuration tab.""" + widget = QWidget() + layout = QVBoxLayout() + + layout.addWidget(QLabel(tr("settings.web_source.url_label"))) url_layout = QHBoxLayout() - + self.webapp_url_input = QLineEdit() self.webapp_url_input.setText(self.config.webapp_url) - self.webapp_url_input.setPlaceholderText("e.g., http://localhost:8080 or file:///./webapp/index.html") + self.webapp_url_input.setPlaceholderText( + "e.g., http://localhost:8080 or file:///./webapp/index.html" + ) url_layout.addWidget(self.webapp_url_input) - - open_btn = QPushButton("Open") + + open_btn = QPushButton(tr("settings.web_source.open_btn")) open_btn.clicked.connect(self._open_webapp_url) url_layout.addWidget(open_btn) - + layout.addLayout(url_layout) - - # URL Mappings (Azure Blob URL → Local Path) - layout.addWidget(QLabel("URL Mappings (Azure Blob Storage → Local Paths):")) - - # Create table for URL mappings + + layout.addWidget(QLabel(tr("settings.web_source.url_mappings_label"))) + self.url_mappings_table = QTableWidget() self.url_mappings_table.setColumnCount(2) - self.url_mappings_table.setHorizontalHeaderLabels(["URL Prefix", "Local Path"]) + self.url_mappings_table.setHorizontalHeaderLabels( + [ + tr("settings.web_source.col_url_prefix"), + tr("settings.web_source.col_local_path"), + ] + ) self.url_mappings_table.horizontalHeader().setStretchLastSection(True) - - # Populate from config + for mapping in self.config.url_mappings: row = self.url_mappings_table.rowCount() self.url_mappings_table.insertRow(row) self.url_mappings_table.setItem(row, 0, QTableWidgetItem(mapping.url_prefix)) self.url_mappings_table.setItem(row, 1, QTableWidgetItem(mapping.local_path)) - + layout.addWidget(self.url_mappings_table) - - # Buttons for URL mapping management + button_layout = QHBoxLayout() - - add_mapping_btn = QPushButton("Add Mapping") + + add_mapping_btn = QPushButton(tr("settings.web_source.add_mapping_btn")) add_mapping_btn.clicked.connect(self._add_url_mapping) button_layout.addWidget(add_mapping_btn) - - edit_mapping_btn = QPushButton("Edit Selected") + + edit_mapping_btn = QPushButton(tr("settings.web_source.edit_mapping_btn")) edit_mapping_btn.clicked.connect(self._edit_url_mapping) button_layout.addWidget(edit_mapping_btn) - - remove_mapping_btn = QPushButton("Remove Selected") + + remove_mapping_btn = QPushButton(tr("settings.web_source.remove_mapping_btn")) remove_mapping_btn.clicked.connect(self._remove_url_mapping) button_layout.addWidget(remove_mapping_btn) - + layout.addLayout(button_layout) layout.addStretch() - + widget.setLayout(layout) return widget - + def _open_webapp_url(self) -> None: """Open the webapp URL in the default browser.""" import webbrowser + url = self.webapp_url_input.text().strip() - if url: - # Handle file:// URLs - try: - webbrowser.open(url) - except Exception as e: - logger.error(f"Failed to open URL: {e}") - self._show_error(f"Failed to open URL:\n\n{e}") - + if not url: + return + try: + webbrowser.open(url) + except Exception as e: + logger.error(f"Failed to open URL: {e}") + self._show_error(f"Failed to open URL:\n\n{e}") + def _add_url_mapping(self) -> None: """Add new URL mapping.""" from PySide6.QtWidgets import QInputDialog - + url_prefix, ok1 = QInputDialog.getText( self, - "Add URL Mapping", - "Enter Azure Blob Storage URL prefix:\n(e.g., https://myblob.blob.core.windows.net/container/)" + tr("settings.web_source.add_mapping_title"), + tr("settings.web_source.add_mapping_url_prompt"), ) - + if ok1 and url_prefix: local_path, ok2 = QInputDialog.getText( self, - "Add URL Mapping", - "Enter local file system path:\n(e.g., C:\\Share or /mnt/share)" + tr("settings.web_source.add_mapping_title"), + tr("settings.web_source.add_mapping_path_prompt"), ) - + if ok2 and local_path: row = self.url_mappings_table.rowCount() self.url_mappings_table.insertRow(row) self.url_mappings_table.setItem(row, 0, QTableWidgetItem(url_prefix)) self.url_mappings_table.setItem(row, 1, QTableWidgetItem(local_path)) - + def _edit_url_mapping(self) -> None: """Edit selected URL mapping.""" from PySide6.QtWidgets import QInputDialog - + current_row = self.url_mappings_table.currentRow() if current_row < 0: - self._show_error("Please select a mapping to edit") + self._show_error(tr("settings.web_source.select_mapping_to_edit")) return - - url_prefix = self.url_mappings_table.item(current_row, 0).text() - local_path = self.url_mappings_table.item(current_row, 1).text() - + + url_prefix = self.url_mappings_table.item(current_row, 0).text() # type: ignore + local_path = self.url_mappings_table.item(current_row, 1).text() # type: ignore + new_url_prefix, ok1 = QInputDialog.getText( self, - "Edit URL Mapping", - "Enter Azure Blob Storage URL prefix:", - text=url_prefix + tr("settings.web_source.edit_mapping_title"), + tr("settings.web_source.edit_mapping_url_prompt"), + text=url_prefix, ) - + if ok1 and new_url_prefix: new_local_path, ok2 = QInputDialog.getText( self, - "Edit URL Mapping", - "Enter local file system path:", - text=local_path + tr("settings.web_source.edit_mapping_title"), + tr("settings.web_source.edit_mapping_path_prompt"), + text=local_path, ) - + if ok2 and new_local_path: self.url_mappings_table.setItem(current_row, 0, QTableWidgetItem(new_url_prefix)) self.url_mappings_table.setItem(current_row, 1, QTableWidgetItem(new_local_path)) - + def _remove_url_mapping(self) -> None: """Remove selected URL mapping.""" current_row = self.url_mappings_table.currentRow() @@ -281,29 +289,27 @@ class SettingsDialog(QDialog): """Create paths configuration tab.""" widget = QWidget() layout = QVBoxLayout() - - layout.addWidget(QLabel("Allowed root directories for file access:")) - - # List widget for paths + + layout.addWidget(QLabel(tr("settings.paths.label"))) + self.paths_list = QListWidget() for path in self.config.allowed_roots: self.paths_list.addItem(str(path)) layout.addWidget(self.paths_list) - - # Buttons for path management + button_layout = QHBoxLayout() - - add_path_btn = QPushButton("Add Path") + + add_path_btn = QPushButton(tr("settings.paths.add_btn")) add_path_btn.clicked.connect(self._add_path) button_layout.addWidget(add_path_btn) - - remove_path_btn = QPushButton("Remove Selected") + + remove_path_btn = QPushButton(tr("settings.paths.remove_btn")) remove_path_btn.clicked.connect(self._remove_path) button_layout.addWidget(remove_path_btn) - + layout.addLayout(button_layout) layout.addStretch() - + widget.setLayout(layout) return widget @@ -311,29 +317,27 @@ class SettingsDialog(QDialog): """Create URLs configuration tab.""" widget = QWidget() layout = QVBoxLayout() - - layout.addWidget(QLabel("Allowed web URLs (supports wildcards like http://*.example.com):")) - - # List widget for URLs + + layout.addWidget(QLabel(tr("settings.urls.label"))) + self.urls_list = QListWidget() for url in self.config.allowed_urls: self.urls_list.addItem(url) layout.addWidget(self.urls_list) - - # Buttons for URL management + button_layout = QHBoxLayout() - - add_url_btn = QPushButton("Add URL") + + add_url_btn = QPushButton(tr("settings.urls.add_btn")) add_url_btn.clicked.connect(self._add_url) button_layout.addWidget(add_url_btn) - - remove_url_btn = QPushButton("Remove Selected") + + remove_url_btn = QPushButton(tr("settings.urls.remove_btn")) remove_url_btn.clicked.connect(self._remove_url) button_layout.addWidget(remove_url_btn) - + layout.addLayout(button_layout) layout.addStretch() - + widget.setLayout(layout) return widget @@ -341,27 +345,23 @@ class SettingsDialog(QDialog): """Create logging configuration tab.""" widget = QWidget() layout = QVBoxLayout() - - # Log level selection - layout.addWidget(QLabel("Log Level:")) - from PySide6.QtWidgets import QComboBox + + layout.addWidget(QLabel(tr("settings.logging.level_label"))) self.log_level_combo: QComboBox = self._create_log_level_widget() layout.addWidget(self.log_level_combo) - - # Log file path - layout.addWidget(QLabel("Log File (optional):")) + + layout.addWidget(QLabel(tr("settings.logging.file_label"))) log_file_layout = QHBoxLayout() - + self.log_file_input = QLineEdit() self.log_file_input.setText(str(self.config.log_file) if self.config.log_file else "") log_file_layout.addWidget(self.log_file_input) - - browse_btn = QPushButton("Browse...") + + browse_btn = QPushButton(tr("settings.logging.browse_btn")) browse_btn.clicked.connect(self._browse_log_file) log_file_layout.addWidget(browse_btn) - + layout.addLayout(log_file_layout) - layout.addStretch() widget.setLayout(layout) return widget @@ -370,10 +370,9 @@ class SettingsDialog(QDialog): """Create window settings tab.""" widget = QWidget() layout = QVBoxLayout() - - # Window width + width_layout = QHBoxLayout() - width_layout.addWidget(QLabel("Window Width:")) + width_layout.addWidget(QLabel(tr("settings.window.width_label"))) self.width_spin = QSpinBox() self.width_spin.setMinimum(400) self.width_spin.setMaximum(5000) @@ -381,10 +380,9 @@ class SettingsDialog(QDialog): width_layout.addWidget(self.width_spin) width_layout.addStretch() layout.addLayout(width_layout) - - # Window height + height_layout = QHBoxLayout() - height_layout.addWidget(QLabel("Window Height:")) + height_layout.addWidget(QLabel(tr("settings.window.height_label"))) self.height_spin = QSpinBox() self.height_spin.setMinimum(300) self.height_spin.setMaximum(5000) @@ -392,7 +390,7 @@ class SettingsDialog(QDialog): height_layout.addWidget(self.height_spin) height_layout.addStretch() layout.addLayout(height_layout) - + layout.addStretch() widget.setLayout(layout) return widget @@ -401,52 +399,47 @@ class SettingsDialog(QDialog): """Create profiles management tab.""" widget = QWidget() layout = QVBoxLayout() - - layout.addWidget(QLabel("Saved Configuration Profiles:")) - - # List of profiles + + layout.addWidget(QLabel(tr("settings.profiles.label"))) + self.profiles_list = QListWidget() self._refresh_profiles_list() layout.addWidget(self.profiles_list) - - # Profile management buttons + button_layout = QHBoxLayout() - - save_profile_btn = QPushButton("Save as Profile") + + save_profile_btn = QPushButton(tr("settings.profiles.save_btn")) save_profile_btn.clicked.connect(self._save_profile) button_layout.addWidget(save_profile_btn) - - load_profile_btn = QPushButton("Load Profile") + + load_profile_btn = QPushButton(tr("settings.profiles.load_btn")) load_profile_btn.clicked.connect(self._load_profile) button_layout.addWidget(load_profile_btn) - - delete_profile_btn = QPushButton("Delete Profile") + + delete_profile_btn = QPushButton(tr("settings.profiles.delete_btn")) delete_profile_btn.clicked.connect(self._delete_profile) button_layout.addWidget(delete_profile_btn) - + layout.addLayout(button_layout) - - # Export/Import buttons + export_layout = QHBoxLayout() - - export_btn = QPushButton("Export Configuration") + + export_btn = QPushButton(tr("settings.profiles.export_btn")) export_btn.clicked.connect(self._export_config) export_layout.addWidget(export_btn) - - import_btn = QPushButton("Import Configuration") + + import_btn = QPushButton(tr("settings.profiles.import_btn")) import_btn.clicked.connect(self._import_config) export_layout.addWidget(import_btn) - + layout.addLayout(export_layout) layout.addStretch() - + widget.setLayout(layout) return widget - def _create_log_level_widget(self): + def _create_log_level_widget(self) -> QComboBox: """Create log level selection widget.""" - from PySide6.QtWidgets import QComboBox - combo = QComboBox() levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] combo.addItems(levels) @@ -455,7 +448,7 @@ class SettingsDialog(QDialog): def _add_path(self) -> None: """Add a new allowed path.""" - path = QFileDialog.getExistingDirectory(self, "Select Directory to Allow") + path = QFileDialog.getExistingDirectory(self, tr("settings.paths.select_dir_title")) if path: self.paths_list.addItem(path) @@ -467,11 +460,9 @@ class SettingsDialog(QDialog): def _add_url(self) -> None: """Add a new allowed URL.""" from PySide6.QtWidgets import QInputDialog - + url, ok = QInputDialog.getText( - self, - "Add URL", - "Enter URL pattern (e.g., http://example.com or http://*.example.com):" + self, tr("settings.urls.add_title"), tr("settings.urls.add_prompt") ) if ok and url: self.urls_list.addItem(url) @@ -485,9 +476,9 @@ class SettingsDialog(QDialog): """Browse for log file location.""" file_path, _ = QFileDialog.getSaveFileName( self, - "Select Log File", + tr("settings.logging.select_file_title"), str(Path.home()), - "Log Files (*.log);;All Files (*)" + "Log Files (*.log);;All Files (*)", ) if file_path: self.log_file_input.setText(file_path) @@ -501,13 +492,11 @@ class SettingsDialog(QDialog): def _save_profile(self) -> None: """Save current configuration as a profile.""" from PySide6.QtWidgets import QInputDialog - + profile_name, ok = QInputDialog.getText( - self, - "Save Profile", - "Enter profile name (e.g., work, personal):" + self, tr("settings.profiles.save_title"), tr("settings.profiles.save_prompt") ) - + if ok and profile_name: try: self.profile_manager.save_profile(profile_name, self.config) @@ -519,9 +508,9 @@ class SettingsDialog(QDialog): """Load a saved profile.""" current_item = self.profiles_list.currentItem() if not current_item: - self._show_error("Please select a profile to load") + self._show_error(tr("settings.profiles.select_to_load")) return - + profile_name = current_item.text() try: config_data = self.profile_manager.load_profile(profile_name) @@ -533,9 +522,9 @@ class SettingsDialog(QDialog): """Delete a saved profile.""" current_item = self.profiles_list.currentItem() if not current_item: - self._show_error("Please select a profile to delete") + self._show_error(tr("settings.profiles.select_to_delete")) return - + profile_name = current_item.text() try: self.profile_manager.delete_profile(profile_name) @@ -547,11 +536,11 @@ class SettingsDialog(QDialog): """Export configuration to file.""" file_path, _ = QFileDialog.getSaveFileName( self, - "Export Configuration", + tr("settings.profiles.export_title"), str(Path.home()), - "JSON Files (*.json);;All Files (*)" + "JSON Files (*.json);;All Files (*)", ) - + if file_path: try: ConfigExporter.export_to_json(self.config, Path(file_path)) @@ -562,11 +551,11 @@ class SettingsDialog(QDialog): """Import configuration from file.""" file_path, _ = QFileDialog.getOpenFileName( self, - "Import Configuration", + tr("settings.profiles.import_title"), str(Path.home()), - "JSON Files (*.json);;All Files (*)" + "JSON Files (*.json);;All Files (*)", ) - + if file_path: try: config_data = ConfigExporter.import_from_json(Path(file_path)) @@ -574,70 +563,85 @@ class SettingsDialog(QDialog): except ConfigurationError as e: self._show_error(f"Failed to import configuration: {e}") - def _apply_config_data(self, config_data: dict) -> None: + def _apply_config_data(self, config_data: Dict[str, Any]) -> None: """Apply imported configuration data to UI. - + Args: config_data: Configuration dictionary """ - # Apply paths self.paths_list.clear() for path in config_data.get("allowed_roots", []): self.paths_list.addItem(str(path)) - - # Apply URLs + self.urls_list.clear() for url in config_data.get("allowed_urls", []): self.urls_list.addItem(url) - - # Apply logging settings + self.log_level_combo.setCurrentText(config_data.get("log_level", "INFO")) log_file = config_data.get("log_file") self.log_file_input.setText(str(log_file) if log_file else "") - - # Apply window settings + self.width_spin.setValue(config_data.get("window_width", 800)) self.height_spin.setValue(config_data.get("window_height", 600)) - def get_config_data(self) -> dict: + language = config_data.get("language", "auto") + idx = self.language_combo.findData(language) + if idx >= 0: + self.language_combo.setCurrentIndex(idx) + + def get_config_data(self) -> Dict[str, Any]: """Get updated configuration data from dialog. - + Returns: Configuration dictionary - + Raises: ConfigurationError: If configuration is invalid """ + url_mappings_table_count = ( + self.url_mappings_table.rowCount() if self.url_mappings_table else 0 + ) + config_data = { "app_name": self.config.app_name, "app_version": self.config.app_version, + "language": self.language_combo.currentData(), "log_level": self.log_level_combo.currentText(), "log_file": self.log_file_input.text() or None, - "allowed_roots": [self.paths_list.item(i).text() for i in range(self.paths_list.count())], + "allowed_roots": [ + self.paths_list.item(i).text() for i in range(self.paths_list.count()) + ], "allowed_urls": [self.urls_list.item(i).text() for i in range(self.urls_list.count())], "webapp_url": self.webapp_url_input.text().strip(), "url_mappings": [ { - "url_prefix": self.url_mappings_table.item(i, 0).text(), - "local_path": self.url_mappings_table.item(i, 1).text() + "url_prefix": ( + self.url_mappings_table.item(i, 0).text() # type: ignore + if self.url_mappings_table.item(i, 0) + else "" + ), + "local_path": ( + self.url_mappings_table.item(i, 1).text() # type: ignore + if self.url_mappings_table.item(i, 1) + else "" + ), } - for i in range(self.url_mappings_table.rowCount()) + for i in range(url_mappings_table_count) ], "window_width": self.width_spin.value(), "window_height": self.height_spin.value(), "enable_logging": self.config.enable_logging, } - - # Validate + ConfigValidator.validate_or_raise(config_data) - return config_data def _show_error(self, message: str) -> None: """Show error message to user. - + Args: message: Error message """ from PySide6.QtWidgets import QMessageBox - QMessageBox.critical(self, "Error", message) + + QMessageBox.critical(self, tr("dialog.error.title"), message) diff --git a/src/webdrop_bridge/ui/update_manager_ui.py b/src/webdrop_bridge/ui/update_manager_ui.py index 1ddd4f0..474f18b 100644 --- a/src/webdrop_bridge/ui/update_manager_ui.py +++ b/src/webdrop_bridge/ui/update_manager_ui.py @@ -25,182 +25,174 @@ from PySide6.QtWidgets import ( QVBoxLayout, ) +from webdrop_bridge.utils.i18n import tr + logger = logging.getLogger(__name__) class CheckingDialog(QDialog): """Dialog shown while checking for updates. - + Shows an animated progress indicator and times out after 10 seconds. """ def __init__(self, parent=None): """Initialize checking dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Checking for Updates") + self.setWindowTitle(tr("update.checking.title")) self.setModal(True) self.setMinimumWidth(300) self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowCloseButtonHint) - + layout = QVBoxLayout() - + # Status label - self.label = QLabel("Checking for updates...") + self.label = QLabel(tr("update.checking.label")) layout.addWidget(self.label) - + # Animated progress bar self.progress = QProgressBar() self.progress.setMaximum(0) # Makes it animated layout.addWidget(self.progress) - + # Timeout info - info_label = QLabel("This may take up to 10 seconds") + info_label = QLabel(tr("update.checking.timeout_info")) info_label.setStyleSheet("color: gray; font-size: 11px;") layout.addWidget(info_label) - + self.setLayout(layout) class UpdateAvailableDialog(QDialog): """Dialog shown when an update is available. - + Displays: - Current version - Available version - Changelog/release notes - Buttons: Update Now, Update Later, Skip This Version """ - + # Signals update_now = Signal() update_later = Signal() - skip_version = Signal() def __init__(self, version: str, changelog: str, parent=None): """Initialize update available dialog. - + Args: version: New version string (e.g., "0.0.2") changelog: Release notes text parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Update Available") + self.setWindowTitle(tr("update.available.title")) self.setModal(True) self.setMinimumWidth(400) self.setMinimumHeight(300) - + layout = QVBoxLayout() - + # Header - header = QLabel(f"WebDrop Bridge v{version} is available") + header = QLabel(tr("update.available.header", version=version)) header.setStyleSheet("font-weight: bold; font-size: 14px;") layout.addWidget(header) - + # Changelog - changelog_label = QLabel("Release Notes:") + changelog_label = QLabel(tr("update.available.changelog_label")) changelog_label.setStyleSheet("font-weight: bold; margin-top: 10px;") layout.addWidget(changelog_label) - + self.changelog = QTextEdit() self.changelog.setText(changelog) self.changelog.setReadOnly(True) layout.addWidget(self.changelog) - + # Buttons button_layout = QHBoxLayout() - - self.update_now_btn = QPushButton("Update Now") + + self.update_now_btn = QPushButton(tr("update.available.update_now_btn")) self.update_now_btn.clicked.connect(self._on_update_now) button_layout.addWidget(self.update_now_btn) - - self.update_later_btn = QPushButton("Later") + + self.update_later_btn = QPushButton(tr("update.available.later_btn")) self.update_later_btn.clicked.connect(self._on_update_later) button_layout.addWidget(self.update_later_btn) - - self.skip_btn = QPushButton("Skip Version") - self.skip_btn.clicked.connect(self._on_skip) - button_layout.addWidget(self.skip_btn) - + layout.addLayout(button_layout) self.setLayout(layout) - + def _on_update_now(self): """Handle update now button click.""" self.update_now.emit() self.accept() - + def _on_update_later(self): """Handle update later button click.""" self.update_later.emit() self.reject() - - def _on_skip(self): - """Handle skip version button click.""" - self.skip_version.emit() - self.reject() class DownloadingDialog(QDialog): """Dialog shown while downloading the update. - + Displays: - Download progress bar - Current file being downloaded - Cancel button """ - + cancel_download = Signal() def __init__(self, parent=None): """Initialize downloading dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Downloading Update") + self.setWindowTitle(tr("update.downloading.title")) self.setModal(True) self.setMinimumWidth(350) self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowCloseButtonHint) - + layout = QVBoxLayout() - + # Header - header = QLabel("Downloading update...") + header = QLabel(tr("update.downloading.header")) header.setStyleSheet("font-weight: bold;") layout.addWidget(header) - + # File label - self.file_label = QLabel("Preparing download") + self.file_label = QLabel(tr("update.downloading.preparing")) layout.addWidget(self.file_label) - + # Progress bar self.progress = QProgressBar() self.progress.setMinimum(0) self.progress.setMaximum(100) self.progress.setValue(0) layout.addWidget(self.progress) - + # Size info self.size_label = QLabel("0 MB / 0 MB") self.size_label.setStyleSheet("color: gray; font-size: 11px;") layout.addWidget(self.size_label) - + # Cancel button - self.cancel_btn = QPushButton("Cancel") + self.cancel_btn = QPushButton(tr("update.downloading.cancel_btn")) self.cancel_btn.clicked.connect(self._on_cancel) layout.addWidget(self.cancel_btn) - + self.setLayout(layout) - + def set_progress(self, current: int, total: int): """Update progress bar. - + Args: current: Current bytes downloaded total: Total bytes to download @@ -208,20 +200,20 @@ class DownloadingDialog(QDialog): if total > 0: percentage = int((current / total) * 100) self.progress.setValue(percentage) - + # Format size display current_mb = current / (1024 * 1024) total_mb = total / (1024 * 1024) self.size_label.setText(f"{current_mb:.1f} MB / {total_mb:.1f} MB") - + def set_filename(self, filename: str): """Set the filename being downloaded. - + Args: filename: Name of file being downloaded """ - self.file_label.setText(f"Downloading: {filename}") - + self.file_label.setText(tr("update.downloading.filename", filename=filename)) + def _on_cancel(self): """Handle cancel button click.""" self.cancel_download.emit() @@ -230,61 +222,58 @@ class DownloadingDialog(QDialog): class InstallDialog(QDialog): """Dialog shown before installing update and restarting. - + Displays: - Installation confirmation message - Warning about unsaved changes - Buttons: Install Now, Cancel """ - + install_now = Signal() def __init__(self, parent=None): """Initialize install dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Install Update") + self.setWindowTitle(tr("update.install.title")) self.setModal(True) self.setMinimumWidth(350) - + layout = QVBoxLayout() - + # Header - header = QLabel("Ready to Install") + header = QLabel(tr("update.install.header")) header.setStyleSheet("font-weight: bold; font-size: 14px;") layout.addWidget(header) - + # Message - message = QLabel("The update is ready to install. The application will restart.") + message = QLabel(tr("update.install.message")) layout.addWidget(message) - + # Warning - warning = QLabel( - "⚠️ Please save any unsaved work before continuing.\n" - "The application will close and restart." - ) + warning = QLabel(tr("update.install.warning")) warning.setStyleSheet("background-color: #fff3cd; padding: 10px; border-radius: 4px;") warning.setWordWrap(True) layout.addWidget(warning) - + # Buttons button_layout = QHBoxLayout() - - self.install_btn = QPushButton("Install Now") + + self.install_btn = QPushButton(tr("update.install.now_btn")) self.install_btn.setStyleSheet("background-color: #28a745; color: white;") self.install_btn.clicked.connect(self._on_install) button_layout.addWidget(self.install_btn) - - self.cancel_btn = QPushButton("Cancel") + + self.cancel_btn = QPushButton(tr("update.install.cancel_btn")) self.cancel_btn.clicked.connect(self.reject) button_layout.addWidget(self.cancel_btn) - + layout.addLayout(button_layout) self.setLayout(layout) - + def _on_install(self): """Handle install now button click.""" self.install_now.emit() @@ -293,107 +282,105 @@ class InstallDialog(QDialog): class NoUpdateDialog(QDialog): """Dialog shown when no updates are available. - + Simple confirmation that the application is up to date. """ def __init__(self, parent=None): """Initialize no update dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("No Updates Available") + self.setWindowTitle(tr("update.no_update.title")) self.setModal(True) self.setMinimumWidth(300) - + layout = QVBoxLayout() - + # Message - message = QLabel("✓ You're using the latest version") + message = QLabel(tr("update.no_update.message")) message.setStyleSheet("font-weight: bold; font-size: 12px; color: #28a745;") layout.addWidget(message) - - info = QLabel("WebDrop Bridge is up to date.") + + info = QLabel(tr("update.no_update.info")) layout.addWidget(info) - + # Close button - close_btn = QPushButton("OK") + close_btn = QPushButton(tr("update.no_update.ok_btn")) close_btn.clicked.connect(self.accept) layout.addWidget(close_btn) - + self.setLayout(layout) class ErrorDialog(QDialog): """Dialog shown when update check or installation fails. - + Displays: - Error message - Buttons: Retry, Manual Download, Cancel """ - + retry = Signal() manual_download = Signal() def __init__(self, error_message: str, parent=None): """Initialize error dialog. - + Args: error_message: Description of the error parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Update Failed") + self.setWindowTitle(tr("update.error.title")) self.setModal(True) self.setMinimumWidth(350) - + layout = QVBoxLayout() - + # Header - header = QLabel("⚠️ Update Failed") + header = QLabel(tr("update.error.header")) header.setStyleSheet("font-weight: bold; font-size: 14px; color: #dc3545;") layout.addWidget(header) - + # Error message self.error_text = QTextEdit() self.error_text.setText(error_message) self.error_text.setReadOnly(True) self.error_text.setMaximumHeight(100) layout.addWidget(self.error_text) - + # Info message - info = QLabel( - "Please try again or visit the website to download the update manually." - ) + info = QLabel(tr("update.error.info")) info.setWordWrap(True) info.setStyleSheet("color: gray; font-size: 11px;") layout.addWidget(info) - + # Buttons button_layout = QHBoxLayout() - - self.retry_btn = QPushButton("Retry") + + self.retry_btn = QPushButton(tr("update.error.retry_btn")) self.retry_btn.clicked.connect(self._on_retry) button_layout.addWidget(self.retry_btn) - - self.manual_btn = QPushButton("Download Manually") + + self.manual_btn = QPushButton(tr("update.error.manual_btn")) self.manual_btn.clicked.connect(self._on_manual) button_layout.addWidget(self.manual_btn) - - self.cancel_btn = QPushButton("Cancel") + + self.cancel_btn = QPushButton(tr("update.error.cancel_btn")) self.cancel_btn.clicked.connect(self.reject) button_layout.addWidget(self.cancel_btn) - + layout.addLayout(button_layout) self.setLayout(layout) - + def _on_retry(self): """Handle retry button click.""" self.retry.emit() self.accept() - + def _on_manual(self): """Handle manual download button click.""" self.manual_download.emit() diff --git a/src/webdrop_bridge/utils/i18n.py b/src/webdrop_bridge/utils/i18n.py new file mode 100644 index 0000000..b01f693 --- /dev/null +++ b/src/webdrop_bridge/utils/i18n.py @@ -0,0 +1,292 @@ +"""Internationalization (i18n) support for WebDrop Bridge. + +Provides a simple JSON-based translation system. Translation files are stored +in ``resources/translations/`` (e.g. ``en.json``, ``de.json``, ``fr.json``). + +Usage:: + + from webdrop_bridge.utils.i18n import tr + + # Simple lookup + self.setWindowTitle(tr("settings.title")) + + # With named format arguments + label.setText(tr("status.opened", name="file.pdf")) + +To add a new language, place a JSON file named ``
" - f"Version: {self.config.app_version}
" + f"{tr('about.version', version=self.config.app_version)}
" f"
" - f"Bridges web-based drag-and-drop workflows with native file operations " - f"for professional desktop applications.
" + f"{tr('about.description')}
" f"
" - f"Product of:
" - f"Hörl Information Management GmbH
" + f"{tr('about.drop_zones_title')}
" + f"{tr('about.open_icon_desc')}
" + f"{tr('about.open_with_icon_desc')}
" + f"
" + f"{tr('about.product_of')}
" + f"hörl Information Management GmbH
" f"Silberburgstraße 126
" f"70176 Stuttgart, Germany
" f"
" @@ -1172,18 +1676,177 @@ class MainWindow(QMainWindow): f"Web: https://www.hoerl-im.de/
" f"" f"
" - f"© 2026 Hörl Information Management GmbH. All rights reserved." + f"{tr('about.rights')}" ) - - QMessageBox.about(self, f"About {self.config.app_name}", about_text) + + QMessageBox.about(self, tr("about.title", app_name=self.config.app_name), about_text) def _show_settings_dialog(self) -> None: - """Show Settings dialog for configuration management.""" + """Show Settings dialog for configuration management. + + After closing, checks if webapp URL changed and reloads if needed. + For domain changes, shows restart dialog. + For path-only changes, reloads silently without dialog. + """ from webdrop_bridge.ui.settings_dialog import SettingsDialog - + + # Store current URL before opening dialog + old_webapp_url = self.config.webapp_url + old_language = self.config.language + + # Show dialog dialog = SettingsDialog(self.config, self) dialog.exec() + # Check if webapp URL changed + new_webapp_url = self.config.webapp_url + language_changed = old_language != self.config.language + if old_webapp_url != new_webapp_url: + logger.info(f"Web application URL changed: {old_webapp_url} → {new_webapp_url}") + + # Check if domain changed (not just path) + domain_changed = self._check_domain_changed(old_webapp_url, new_webapp_url) + + if domain_changed: + logger.warning("Domain has changed - recommending restart") + self._handle_domain_change_restart() + else: + logger.info("Path changed but domain is same - reloading...") + # Clear cache and navigate to home asynchronously + # Use timer to ensure dialog is fully closed before reloading + self.web_view.clear_cache_and_cookies() + QTimer.singleShot(100, self._navigate_home) + + if language_changed: + logger.info(f"Language changed: {old_language} → {self.config.language}") + self._handle_language_change_restart() + + def _check_domain_changed(self, old_url: str, new_url: str) -> bool: + """Check if the domain/host has changed between two URLs. + + Args: + old_url: Previous URL + new_url: New URL + + Returns: + True if domain changed, False if only path changed + """ + from urllib.parse import urlparse + + try: + old_parts = urlparse(old_url) + new_parts = urlparse(new_url) + + old_host = old_parts.netloc or old_parts.path + new_host = new_parts.netloc or new_parts.path + + return old_host != new_host + except Exception as e: + logger.warning(f"Could not parse URLs for domain comparison: {e}") + return True # Assume domain changed if we can't parse + + def _handle_domain_change_restart(self) -> None: + """Handle domain change with restart dialog. + + Shows dialog asking user to restart application with options: + - Restart now (automatic) + - Restart later (manual) + - Cancel restart (undo URL change) + """ + from PySide6.QtCore import QProcess + from PySide6.QtGui import QIcon + from PySide6.QtWidgets import QMessageBox + + msg = QMessageBox(self) + msg.setWindowTitle(tr("dialog.domain_changed.title")) + msg.setIcon(QMessageBox.Icon.Warning) + msg.setText(tr("dialog.domain_changed.msg")) + + # Add custom buttons + restart_now_btn = msg.addButton( + tr("dialog.domain_changed.restart_now"), QMessageBox.ButtonRole.AcceptRole + ) + restart_later_btn = msg.addButton( + tr("dialog.domain_changed.restart_later"), QMessageBox.ButtonRole.RejectRole + ) + + msg.exec() + + if msg.clickedButton() == restart_now_btn: + logger.info("User chose to restart application now") + self._restart_application() + else: + logger.info("User chose to restart later - clearing cache and loading new URL") + # Clear cache and load new URL directly + self.web_view.clear_cache_and_cookies() + self._navigate_home() + + def _handle_language_change_restart(self) -> None: + """Handle language change by prompting for an optional restart.""" + from PySide6.QtWidgets import QMessageBox + + msg = QMessageBox(self) + msg.setWindowTitle(tr("dialog.language_changed.title")) + msg.setIcon(QMessageBox.Icon.Information) + msg.setText(tr("dialog.language_changed.msg")) + + restart_now_btn = msg.addButton( + tr("dialog.language_changed.restart_now"), QMessageBox.ButtonRole.AcceptRole + ) + msg.addButton( + tr("dialog.language_changed.restart_later"), QMessageBox.ButtonRole.RejectRole + ) + + msg.exec() + + if msg.clickedButton() == restart_now_btn: + self._restart_application() + + def _restart_application(self) -> None: + """Restart the application automatically. + + Starts a new process with the same arguments and closes the current application. + """ + import os + import sys + + from PySide6.QtCore import QProcess + + logger.info("Restarting application...") + + try: + # Get the path to the Python executable + if hasattr(sys, "_MEIPASS"): + # Running as PyInstaller bundle + executable = sys.executable + else: + # Running in development mode + executable = sys.executable + + # Get the module to run + module_args = ["-m", "webdrop_bridge.main"] + + # Start new process + QProcess.startDetached(executable, module_args) + + logger.info("New application process started successfully") + + # Close current application after a small delay to allow process to start + from PySide6.QtCore import QTimer + + QTimer.singleShot(500, lambda: sys.exit(0)) + + except Exception as e: + logger.error(f"Failed to restart application: {e}") + + from PySide6.QtWidgets import QMessageBox + + QMessageBox.warning( + self, + tr("dialog.restart_failed.title"), + tr("dialog.restart_failed.msg", error=str(e)), + ) + def _navigate_home(self) -> None: """Navigate to the home (start) URL.""" home_url = self.config.webapp_url @@ -1208,10 +1871,10 @@ class MainWindow(QMainWindow): event: Close event """ logger.debug("Closing application - cleaning up web engine resources") - + # Properly delete WebEnginePage before the profile is released # This ensures cookies and session data are saved correctly - if hasattr(self, 'web_view') and self.web_view: + if hasattr(self, "web_view") and self.web_view: page = self.web_view.page() if page: # Disconnect signals to prevent callbacks during shutdown @@ -1219,95 +1882,99 @@ class MainWindow(QMainWindow): page.loadFinished.disconnect() except RuntimeError: pass # Already disconnected or never connected - + # Delete the page explicitly page.deleteLater() logger.debug("WebEnginePage scheduled for deletion") - + # Clear the page from the view - self.web_view.setPage(None) # type: ignore - + self.web_view.setPage(None) # type: ignore + event.accept() def check_for_updates_startup(self) -> None: """Check for updates on application startup. - + Runs asynchronously in background without blocking UI. Uses 24-hour cache so will not hammer the API. """ from webdrop_bridge.core.updater import UpdateManager - + try: # Create update manager - cache_dir = Path.home() / ".webdrop-bridge" + cache_dir = self.config.get_cache_dir() manager = UpdateManager( current_version=self.config.app_version, - config_dir=cache_dir + config_dir=cache_dir, + brand_id=self.config.brand_id, + forgejo_url=self.config.update_base_url, + repo=self.config.update_repo, + update_channel=self.config.update_channel, + manifest_name=self.config.update_manifest_name, ) - + # Run async check in background self._run_async_check(manager) - + except Exception as e: logger.error(f"Failed to initialize update check: {e}") def _run_async_check(self, manager) -> None: """Run update check in background thread with safety timeout. - + Args: manager: UpdateManager instance """ try: logger.debug("_run_async_check() starting") - + # Create and start background thread thread = QThread() worker = UpdateCheckWorker(manager, self.config.app_version) - + # IMPORTANT: Keep references to prevent garbage collection # Store in a list to keep worker alive during thread execution self._background_threads.append(thread) - self._background_workers = getattr(self, '_background_workers', {}) + self._background_workers = getattr(self, "_background_workers", {}) self._background_workers[id(thread)] = worker - + logger.debug(f"Created worker and thread, thread id: {id(thread)}") - + # Create a safety timeout timer (but don't start it yet) # Use a flag-based approach to avoid thread issues with stopping timers check_started_time = [datetime.now()] # Track when check started check_completed = [False] # Flag to mark when check completes - + def force_close_timeout(): # Check if already completed - if so, don't show error if check_completed[0]: logger.debug("Timeout fired but check already completed, suppressing error") return - + logger.warning("Update check taking too long (30s timeout)") - if hasattr(self, 'checking_dialog') and self.checking_dialog: + if hasattr(self, "checking_dialog") and self.checking_dialog: self.checking_dialog.close() self.set_update_status("Check timed out - no server response", emoji="⏱️") - + # Show error dialog from PySide6.QtWidgets import QMessageBox + QMessageBox.warning( self, - "Update Check Timeout", - "The server did not respond within 30 seconds.\n\n" - "This may be due to a network issue or server unavailability.\n\n" - "Please check your connection and try again." + tr("dialog.update_timeout.title"), + tr("dialog.update_timeout.msg"), ) - + safety_timer = QTimer() safety_timer.setSingleShot(True) safety_timer.setInterval(30000) # 30 seconds safety_timer.timeout.connect(force_close_timeout) - + # Mark check as completed when any result arrives def on_check_done(): logger.debug("Check finished, marking as completed to prevent timeout error") check_completed[0] = True - + # Connect signals worker.update_available.connect(self._on_update_available) worker.update_available.connect(on_check_done) @@ -1318,7 +1985,7 @@ class MainWindow(QMainWindow): worker.finished.connect(thread.quit) worker.finished.connect(worker.deleteLater) thread.finished.connect(thread.deleteLater) - + # Clean up finished threads and workers from list def cleanup_thread(): logger.debug(f"Cleaning up thread {id(thread)}") @@ -1326,199 +1993,199 @@ class MainWindow(QMainWindow): self._background_threads.remove(thread) if id(thread) in self._background_workers: del self._background_workers[id(thread)] - + thread.finished.connect(cleanup_thread) - + # Move worker to thread and start logger.debug("Moving worker to thread and connecting started signal") worker.moveToThread(thread) thread.started.connect(worker.run) - + logger.debug("Starting thread...") thread.start() logger.debug("Thread started, starting safety timer") - + # Start the safety timeout safety_timer.start() - + except Exception as e: logger.error(f"Failed to start update check thread: {e}", exc_info=True) def _on_update_status(self, status: str, emoji: str) -> None: """Handle update status changes. - + Args: status: Status text emoji: Status emoji """ self.set_update_status(status, emoji) - + # If this is a manual check and we get the "Ready" status, it means no updates if self._is_manual_check and status == "Ready": # Close checking dialog first, then show result - if hasattr(self, 'checking_dialog') and self.checking_dialog: + if hasattr(self, "checking_dialog") and self.checking_dialog: self.checking_dialog.close() - + from webdrop_bridge.ui.update_manager_ui import NoUpdateDialog + dialog = NoUpdateDialog(parent=self) self._is_manual_check = False dialog.exec() def _on_check_failed(self, error_message: str) -> None: """Handle update check failure. - + Args: error_message: Error description """ logger.error(f"Update check failed: {error_message}") - self.set_update_status(f"Check failed: {error_message}", emoji="❌") + self.set_update_status(tr("update.status.check_failed", error=error_message), emoji="❌") self._is_manual_check = False - + # Close checking dialog first, then show error - if hasattr(self, 'checking_dialog') and self.checking_dialog: + if hasattr(self, "checking_dialog") and self.checking_dialog: self.checking_dialog.close() - + from PySide6.QtWidgets import QMessageBox + QMessageBox.warning( self, - "Update Check Failed", - f"Could not check for updates:\n\n{error_message}\n\nPlease try again later." + tr("dialog.update_failed.title"), + tr("dialog.update_failed.msg", error=error_message), ) def _on_update_available(self, release) -> None: """Handle update available notification. - + Args: release: Release object with update info """ + # Close checking dialog if open (manual check case) + if hasattr(self, "checking_dialog") and self.checking_dialog: + self.checking_dialog.close() + self.checking_dialog = None + self._is_manual_check = False + # Update status to show update available - self.set_update_status(f"Update available: v{release.version}", emoji="✅") - + self.set_update_status(tr("update.status.available", version=release.version), emoji="✅") + # Show update available dialog from webdrop_bridge.ui.update_manager_ui import UpdateAvailableDialog - - dialog = UpdateAvailableDialog( - version=release.version, - changelog=release.body, - parent=self - ) - + + dialog = UpdateAvailableDialog(version=release.version, changelog=release.body, parent=self) + # Connect dialog signals dialog.update_now.connect(lambda: self._on_user_update_now(release)) dialog.update_later.connect(lambda: self._on_user_update_later()) - dialog.skip_version.connect(lambda: self._on_user_skip_version(release.version)) - + # Show dialog (modal) dialog.exec() def _on_user_update_now(self, release) -> None: """Handle user clicking 'Update Now' button. - + Args: release: Release object to download and install """ logger.info(f"User clicked 'Update Now' for v{release.version}") - + # Start download self._start_update_download(release) def _on_user_update_later(self) -> None: """Handle user clicking 'Later' button.""" logger.info("User deferred update") - self.set_update_status("Update deferred", emoji="") - - def _on_user_skip_version(self, version: str) -> None: - """Handle user clicking 'Skip Version' button. - - Args: - version: Version to skip - """ - logger.info(f"User skipped version {version}") - - # Store skipped version in preferences - skipped_file = Path.home() / ".webdrop-bridge" / "skipped_version.txt" - skipped_file.parent.mkdir(parents=True, exist_ok=True) - skipped_file.write_text(version) - - self.set_update_status(f"Skipped v{version}", emoji="") + self.set_update_status(tr("update.status.deferred"), emoji="") def _start_update_download(self, release) -> None: """Start downloading the update in background thread. - + Args: release: Release object to download """ logger.info(f"Starting download for v{release.version}") - self.set_update_status(f"Downloading v{release.version}", emoji="⬇️") - + self.set_update_status(tr("update.status.downloading", version=release.version), emoji="⬇️") + + # Show download progress dialog + from webdrop_bridge.ui.update_manager_ui import DownloadingDialog + + self.downloading_dialog = DownloadingDialog(self) + self.downloading_dialog.show() + # Run download in background thread to avoid blocking UI self._perform_update_async(release) def _perform_update_async(self, release) -> None: """Download and install update asynchronously in background thread. - + Args: release: Release object to download and install """ from webdrop_bridge.core.updater import UpdateManager - + try: logger.debug("_perform_update_async() starting") - + # Create update manager manager = UpdateManager( current_version=self.config.app_version, - config_dir=Path.home() / ".webdrop-bridge" + config_dir=self.config.get_cache_dir(), + brand_id=self.config.brand_id, + forgejo_url=self.config.update_base_url, + repo=self.config.update_repo, + update_channel=self.config.update_channel, + manifest_name=self.config.update_manifest_name, ) - + # Create and start background thread thread = QThread() worker = UpdateDownloadWorker(manager, release, self.config.app_version) - + # IMPORTANT: Keep references to prevent garbage collection self._background_threads.append(thread) self._background_workers[id(thread)] = worker - + logger.debug(f"Created download worker and thread, thread id: {id(thread)}") - + # Connect signals worker.download_complete.connect(self._on_download_complete) worker.download_failed.connect(self._on_download_failed) + worker.download_progress.connect(self._on_download_progress) worker.update_status.connect(self._on_update_status) worker.finished.connect(thread.quit) worker.finished.connect(worker.deleteLater) thread.finished.connect(thread.deleteLater) - + # Create a safety timeout timer for download (10 minutes) # Use a flag-based approach to avoid thread issues with stopping timers download_started_time = [datetime.now()] # Track when download started download_completed = [False] # Flag to mark when download completes - + def force_timeout(): # Check if already completed - if so, don't show error if download_completed[0]: logger.debug("Timeout fired but download already completed, suppressing error") return - + logger.error("Download taking too long (10 minute timeout)") self.set_update_status("Download timed out - no server response", emoji="⏱️") worker.download_failed.emit("Download took too long with no response") thread.quit() thread.wait() - + safety_timer = QTimer() safety_timer.setSingleShot(True) safety_timer.setInterval(600000) # 10 minutes safety_timer.timeout.connect(force_timeout) - + # Mark download as completed when it finishes def on_download_done(): logger.debug("Download finished, marking as completed to prevent timeout error") download_completed[0] = True - + worker.download_complete.connect(on_download_done) worker.download_failed.connect(on_download_done) - + # Clean up finished threads from list def cleanup_thread(): logger.debug(f"Cleaning up download thread {id(thread)}") @@ -1526,9 +2193,9 @@ class MainWindow(QMainWindow): self._background_threads.remove(thread) if id(thread) in self._background_workers: del self._background_workers[id(thread)] - + thread.finished.connect(cleanup_thread) - + # Start thread logger.debug("Moving download worker to thread and connecting started signal") worker.moveToThread(thread) @@ -1536,68 +2203,90 @@ class MainWindow(QMainWindow): logger.debug("Starting download thread...") thread.start() logger.debug("Download thread started, starting safety timer") - + # Start the safety timeout safety_timer.start() - + except Exception as e: logger.error(f"Failed to start update download: {e}") self.set_update_status(f"Update failed: {str(e)[:30]}", emoji="❌") def _on_download_complete(self, installer_path: Path) -> None: """Handle successful download and verification. - + Args: installer_path: Path to downloaded and verified installer """ from webdrop_bridge.ui.update_manager_ui import InstallDialog - + + if hasattr(self, "downloading_dialog") and self.downloading_dialog: + self.downloading_dialog.close() + self.downloading_dialog = None + logger.info(f"Download complete: {installer_path}") - self.set_update_status("Ready to install", emoji="✅") - + self.set_update_status(tr("update.status.ready_to_install"), emoji="✅") + # Show install confirmation dialog install_dialog = InstallDialog(parent=self) - install_dialog.install_now.connect( - lambda: self._do_install(installer_path) - ) + install_dialog.install_now.connect(lambda: self._do_install(installer_path)) install_dialog.exec() def _on_download_failed(self, error: str) -> None: """Handle download failure. - + Args: error: Error message """ + if hasattr(self, "downloading_dialog") and self.downloading_dialog: + self.downloading_dialog.close() + self.downloading_dialog = None + logger.error(f"Download failed: {error}") self.set_update_status(error, emoji="❌") - + from PySide6.QtWidgets import QMessageBox + QMessageBox.critical( self, - "Download Failed", - f"Could not download the update:\n\n{error}\n\nPlease try again later." + tr("dialog.download_failed.title"), + tr("dialog.download_failed.msg", error=error), ) + def _on_download_progress(self, downloaded: int, total: int) -> None: + """Forward download progress to the downloading dialog. + + Args: + downloaded: Bytes downloaded so far + total: Total bytes (0 if unknown) + """ + if hasattr(self, "downloading_dialog") and self.downloading_dialog: + self.downloading_dialog.set_progress(downloaded, total) + def _do_install(self, installer_path: Path) -> None: """Execute the installer. - + Args: installer_path: Path to installer executable """ logger.info(f"Installing from {installer_path}") - + from webdrop_bridge.core.updater import UpdateManager - + manager = UpdateManager( current_version=self.config.app_version, - config_dir=Path.home() / ".webdrop-bridge" + config_dir=self.config.get_cache_dir(), + brand_id=self.config.brand_id, + forgejo_url=self.config.update_base_url, + repo=self.config.update_repo, + update_channel=self.config.update_channel, + manifest_name=self.config.update_manifest_name, ) - + if manager.install_update(installer_path): - self.set_update_status("Installation started", emoji="✅") + self.set_update_status(tr("update.status.installation_started"), emoji="✅") logger.info("Update installer launched successfully") else: - self.set_update_status("Installation failed", emoji="❌") + self.set_update_status(tr("update.status.installation_failed"), emoji="❌") logger.error("Failed to launch update installer") @@ -1606,13 +2295,13 @@ class UpdateCheckWorker(QObject): # Define signals at class level update_available = Signal(object) # Emits Release object - update_status = Signal(str, str) # Emits (status_text, emoji) - check_failed = Signal(str) # Emits error message + update_status = Signal(str, str) # Emits (status_text, emoji) + check_failed = Signal(str) # Emits error message finished = Signal() def __init__(self, manager, current_version: str): """Initialize worker. - + Args: manager: UpdateManager instance current_version: Current app version @@ -1626,26 +2315,23 @@ class UpdateCheckWorker(QObject): loop = None try: logger.debug("UpdateCheckWorker.run() starting") - + # Notify checking status - self.update_status.emit("Checking for updates", "🔄") - + self.update_status.emit("Checking for updates", "🔄") # Translated by set_update_status + # Create a fresh event loop for this thread logger.debug("Creating new event loop for worker thread") loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) - + try: # Check for updates with short timeout (network call has its own timeout) logger.debug("Starting update check with 10-second timeout") release = loop.run_until_complete( - asyncio.wait_for( - self.manager.check_for_updates(), - timeout=10 - ) + asyncio.wait_for(self.manager.check_for_updates(), timeout=10) ) logger.debug(f"Update check completed, release={release}") - + # Emit result if release: logger.info(f"Update available: {release.version}") @@ -1653,15 +2339,17 @@ class UpdateCheckWorker(QObject): else: # No update available - show ready status logger.info("No update available") - self.update_status.emit("Ready", "") - + self.update_status.emit( + "Ready", "" + ) # English sentinel; _on_update_status compares this + except asyncio.TimeoutError: logger.warning("Update check timed out - server not responding") - self.check_failed.emit("Server not responding - check again later") - + self.check_failed.emit(tr("worker.server_not_responding")) + except Exception as e: logger.error(f"Update check failed: {e}", exc_info=True) - self.check_failed.emit(f"Check failed: {str(e)[:50]}") + self.check_failed.emit(tr("worker.check_failed", error=str(e)[:50])) finally: # Properly close the event loop if loop is not None: @@ -1679,13 +2367,14 @@ class UpdateDownloadWorker(QObject): # Define signals at class level download_complete = Signal(Path) # Emits installer_path - download_failed = Signal(str) # Emits error message + download_failed = Signal(str) # Emits error message + download_progress = Signal(int, int) # Emits (bytes_downloaded, total_bytes) update_status = Signal(str, str) # Emits (status_text, emoji) finished = Signal() def __init__(self, manager, release, current_version: str): """Initialize worker. - + Args: manager: UpdateManager instance release: Release object to download @@ -1701,60 +2390,70 @@ class UpdateDownloadWorker(QObject): loop = None try: # Download the update - self.update_status.emit(f"Downloading v{self.release.version}", "⬇️") - + self.update_status.emit( + tr("update.status.downloading", version=self.release.version), "⬇️" + ) + # Create a fresh event loop for this thread loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) - + try: # Download with 5 minute timeout (300 seconds) logger.info("Starting download with 5-minute timeout") installer_path = loop.run_until_complete( asyncio.wait_for( - self.manager.download_update(self.release), - timeout=300 + self.manager.download_update( + self.release, + progress_callback=lambda cur, tot: self.download_progress.emit( + cur, tot + ), + ), + timeout=300, ) ) - + if not installer_path: - self.update_status.emit("Download failed", "❌") - self.download_failed.emit("No installer found in release") + self.update_status.emit( + "Download failed", "❌" + ) # Translated by set_update_status + self.download_failed.emit(tr("worker.no_installer")) logger.error("Download failed - no installer found") return - + logger.info(f"Downloaded to {installer_path}") self.update_status.emit("Verifying download", "🔍") - + # Verify checksum with 30 second timeout logger.info("Starting checksum verification") checksum_ok = loop.run_until_complete( asyncio.wait_for( - self.manager.verify_checksum(installer_path, self.release), - timeout=30 + self.manager.verify_checksum(installer_path, self.release), timeout=30 ) ) - + if not checksum_ok: self.update_status.emit("Verification failed", "❌") - self.download_failed.emit("Checksum verification failed") + self.download_failed.emit(tr("worker.checksum_failed")) logger.error("Checksum verification failed") return - + logger.info("Checksum verification passed") self.download_complete.emit(installer_path) - + except asyncio.TimeoutError as e: logger.error(f"Download/verification timed out: {e}") - self.update_status.emit("Operation timed out", "⏱️") - self.download_failed.emit("Download or verification timed out (no response from server)") + self.update_status.emit( + "Operation timed out", "⏱️" + ) # Translated by set_update_status + self.download_failed.emit(tr("worker.download_timed_out")) except Exception as e: logger.error(f"Error during download: {e}") - self.download_failed.emit(f"Download error: {str(e)[:50]}") - + self.download_failed.emit(tr("worker.download_error", error=str(e)[:50])) + except Exception as e: logger.error(f"Download worker failed: {e}") - self.download_failed.emit(f"Download error: {str(e)[:50]}") + self.download_failed.emit(tr("worker.download_error", error=str(e)[:50])) finally: # Properly close the event loop if loop is not None: @@ -1765,3 +2464,4 @@ class UpdateDownloadWorker(QObject): except Exception as e: logger.warning(f"Error closing event loop: {e}") self.finished.emit() + self.finished.emit() diff --git a/src/webdrop_bridge/ui/mouse_event_emulator.js b/src/webdrop_bridge/ui/mouse_event_emulator.js new file mode 100644 index 0000000..c38c6fa --- /dev/null +++ b/src/webdrop_bridge/ui/mouse_event_emulator.js @@ -0,0 +1,186 @@ +// Mouse Event Emulator for Qt WebEngineView +// Qt WebEngineView may not forward all mouse events to JavaScript properly +// This script uses polling with document.elementFromPoint() to detect hover changes +// and manually dispatches mouseover/mouseenter/mouseleave events. +// ALSO: Injects a CSS stylesheet that simulates :hover effects using classes + +(function() { + try { + if (window.__mouse_emulator_injected) return; + window.__mouse_emulator_injected = true; + +console.log("[MouseEventEmulator] Initialized - polling for hover state changes"); + + // ======================================================== + // PART 1: Inject CSS stylesheet for hover simulation + // ======================================================== + + var style = document.createElement("style"); + style.type = "text/css"; + style.id = "__mouse_emulator_hover_styles"; + style.innerHTML = ` + /* Checkbox hover simulation */ + input[type="checkbox"].__mouse_hover { + cursor: pointer; + } + + /* Link hover simulation */ + a.__mouse_hover { + text-decoration: underline; + } + `; + + if (document.head) { + document.head.insertBefore(style, document.head.firstChild); + } else { + document.body.insertBefore(style, document.body.firstChild); + } + + // ======================================================== + // PART 2: Track hover state and apply hover class + // ======================================================== + + var lastElement = null; + var lastX = -1; + var lastY = -1; + + // High-frequency polling to detect element changes at mouse position + var pollIntervalId = setInterval(function() { + if (!window.__lastMousePos) { + window.__lastMousePos = { x: 0, y: 0 }; + } + + var x = window.__lastMousePos.x; + var y = window.__lastMousePos.y; + + lastX = x; + lastY = y; + + var element = document.elementFromPoint(x, y); + + if (!element || element === document || element.tagName === "HTML") { + if (lastElement && lastElement !== document) { + try { + lastElement.classList.remove("__mouse_hover"); + var leaveEvent = new MouseEvent("mouseleave", { + bubbles: true, + cancelable: true, + view: window, + }); + lastElement.dispatchEvent(leaveEvent); + } catch (err) { + console.warn("[MouseEventEmulator] Error in leave handler:", err); + } + lastElement = null; + } + return; + } + + // Element changed + if (element !== lastElement) { + // Remove hover class from previous element + if (lastElement && lastElement !== document && lastElement !== element) { + try { + lastElement.classList.remove("__mouse_hover"); + var leaveEvent = new MouseEvent("mouseleave", { + bubbles: true, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + lastElement.dispatchEvent(leaveEvent); + } catch (err) { + console.warn("[MouseEventEmulator] Error dispatching mouseleave:", err); + } + } + + // Add hover class and dispatch events for new element + if (element) { + try { + element.classList.add("__mouse_hover"); + + var overEvent = new MouseEvent("mouseover", { + bubbles: true, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + element.dispatchEvent(overEvent); + + var enterEvent = new MouseEvent("mouseenter", { + bubbles: false, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + element.dispatchEvent(enterEvent); + + var moveEvent = new MouseEvent("mousemove", { + bubbles: true, + cancelable: true, + view: window, + clientX: x, + clientY: y, + }); + element.dispatchEvent(moveEvent); + } catch (err) { + console.warn("[MouseEventEmulator] Error dispatching mouse events:", err); + } + } + + lastElement = element; + } + }, 50); + + // Track mouse position from all available events + document.addEventListener( + "mousemove", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mousedown", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mouseup", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mouseover", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + document.addEventListener( + "mouseenter", + function(e) { + window.__lastMousePos = { x: e.clientX, y: e.clientY }; + }, + true + ); + + console.log("[MouseEventEmulator] Ready - polling enabled for hover state detection"); + } catch (e) { + console.error("[MouseEventEmulator] FATAL ERROR:", e); + if (e.stack) { + console.error("[MouseEventEmulator] Stack:", e.stack); + } + } +})(); diff --git a/src/webdrop_bridge/ui/restricted_web_view.py b/src/webdrop_bridge/ui/restricted_web_view.py index bd77741..12dbeee 100644 --- a/src/webdrop_bridge/ui/restricted_web_view.py +++ b/src/webdrop_bridge/ui/restricted_web_view.py @@ -1,21 +1,24 @@ """Restricted web view with URL whitelist enforcement for Kiosk-mode.""" import fnmatch +import hashlib import logging from pathlib import Path from typing import List, Optional, Union from PySide6.QtCore import QStandardPaths, QUrl from PySide6.QtGui import QDesktopServices -from PySide6.QtWebEngineCore import QWebEngineNavigationRequest, QWebEnginePage, QWebEngineProfile +from PySide6.QtWebEngineCore import ( + QWebEngineNavigationRequest, + QWebEnginePage, + QWebEngineProfile, + QWebEngineSettings, +) from PySide6.QtWebEngineWidgets import QWebEngineView logger = logging.getLogger(__name__) -logger = logging.getLogger(__name__) - - class CustomWebEnginePage(QWebEnginePage): """Custom page that handles new window requests for downloads.""" @@ -108,21 +111,53 @@ class RestrictedWebEngineView(QWebEngineView): If allowed_urls is empty, no restrictions are applied. If allowed_urls is not empty, only matching URLs are loaded in the view. Non-matching URLs open in the system default browser. + + Each webapp_url gets an isolated profile to prevent cache corruption + from old domains affecting new domains. """ - def __init__(self, allowed_urls: Optional[List[str]] = None): + def __init__(self, allowed_urls: Optional[List[str]] = None, webapp_url: Optional[str] = None): """Initialize the restricted web view. Args: allowed_urls: List of allowed URL patterns (empty = no restriction) Patterns support wildcards: *.example.com, localhost, etc. + webapp_url: The web application URL for profile isolation. If provided, + creates a unique profile per domain to avoid cache corruption. """ super().__init__() self.allowed_urls = allowed_urls or [] + self.webapp_url = webapp_url # Create persistent profile for cookie and session storage + # Profile is unique per domain to prevent cache corruption self.profile = self._create_persistent_profile() + # Configure WebEngine settings on the profile for proper JavaScript and mouse event support + settings = self.profile.settings() + + # Enable JavaScript (required for mouseover events and interactive features) + settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptEnabled, True) + + # Enable JavaScript access to clipboard (some web apps need this) + settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptCanAccessClipboard, True) + + # Enable JavaScript to open windows (for dialogs, popups) + settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptCanOpenWindows, True) + + # Enable local content access (needed for drag operations) + settings.setAttribute(QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, True) + + # Allow local content to access remote resources (some web apps may need this) + settings.setAttribute( + QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, False + ) + + logger.debug( + "RestrictedWebEngineView WebEngine settings configured: " + "JavaScript=enabled, Clipboard=enabled, WindowOpen=enabled, LocalFileAccess=enabled" + ) + # Use custom page for better download handling with persistent profile custom_page = CustomWebEnginePage(self.profile, self) self.setPage(custom_page) @@ -131,6 +166,23 @@ class RestrictedWebEngineView(QWebEngineView): "RestrictedWebEngineView initialized with CustomWebEnginePage and persistent profile" ) + # CRITICAL: Also configure settings on the page itself after setPage() + # This ensures Page-level settings override Profile defaults for event handling + page_settings = self.page().settings() + page_settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptEnabled, True) + page_settings.setAttribute( + QWebEngineSettings.WebAttribute.JavascriptCanAccessClipboard, True + ) + page_settings.setAttribute(QWebEngineSettings.WebAttribute.JavascriptCanOpenWindows, True) + page_settings.setAttribute( + QWebEngineSettings.WebAttribute.LocalContentCanAccessFileUrls, True + ) + page_settings.setAttribute( + QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, False + ) + + logger.debug("Page-level WebEngine settings configured for mouse event handling") + # Connect to navigation request handler self.page().navigationRequested.connect(self._on_navigation_requested) @@ -141,6 +193,9 @@ class RestrictedWebEngineView(QWebEngineView): authentication sessions (e.g., Microsoft login) to persist across application restarts. + Each unique webapp domain gets its own profile to prevent + cache corruption from old domains affecting new domains. + Returns: Configured QWebEngineProfile with persistent storage """ @@ -149,14 +204,32 @@ class RestrictedWebEngineView(QWebEngineView): QStandardPaths.StandardLocation.AppDataLocation ) + # Create unique profile name based on webapp_url domain + # This ensures different domains get isolated profiles + if self.webapp_url: + # Extract domain/path for profile naming + if self.webapp_url.startswith("http://") or self.webapp_url.startswith("https://"): + # Remote URL - use domain + url_obj = QUrl(self.webapp_url) + domain = url_obj.host() or "remote" + else: + # Local file - use hash of path + domain = "local" + else: + domain = "default" + + # Create a stable hash of the domain + # This creates a unique but consistent profile name per domain + domain_hash = hashlib.md5(domain.encode()).hexdigest()[:8] + profile_name = f"webdrop_bridge_{domain_hash}" + # Create profile directory path - profile_path = Path(app_data_dir) / "WebEngineProfile" + profile_path = Path(app_data_dir) / "webdrop_bridge" / profile_name profile_path.mkdir(parents=True, exist_ok=True) # Create persistent profile with custom storage location - # Using "WebDropBridge" as the profile name - # Note: No parent specified so we control the lifecycle - profile = QWebEngineProfile("WebDropBridge") + # Using unique profile name so different domains have isolated caches + profile = QWebEngineProfile(profile_name) profile.setPersistentStoragePath(str(profile_path)) # Configure persistent cookies (critical for authentication) @@ -170,7 +243,8 @@ class RestrictedWebEngineView(QWebEngineView): # Set cache size to 100 MB profile.setHttpCacheMaximumSize(100 * 1024 * 1024) - logger.debug(f"Created persistent profile at: {profile_path}") + logger.debug(f"Created persistent profile '{profile_name}' at: {profile_path}") + logger.debug(f"Profile domain identifier: {domain}") logger.debug("Cookies policy: ForcePersistentCookies") logger.debug("HTTP cache: DiskHttpCache (100 MB)") @@ -204,7 +278,7 @@ class RestrictedWebEngineView(QWebEngineView): - Exact domain matches: example.com - Wildcard patterns: *.example.com - Localhost variations: localhost, 127.0.0.1 - - File URLs: file://... + - Internal/local URLs: file://, data:, about:, blob:, qrc: Args: url: QUrl to check @@ -216,8 +290,8 @@ class RestrictedWebEngineView(QWebEngineView): host = url.host() scheme = url.scheme() - # Allow file:// URLs (local webapp) - if scheme == "file": + # Allow internal browser/Qt schemes (never send these to the OS) + if scheme in ("file", "data", "about", "blob", "qrc"): return True # If no whitelist, allow all URLs @@ -242,3 +316,19 @@ class RestrictedWebEngineView(QWebEngineView): return True return False + + def clear_cache_and_cookies(self) -> None: + """Clear the profile cache and cookies. + + Use this method when the webapp URL changes to prevent cache corruption + from old domains affecting the new domain's authentication. + """ + logger.debug(f"Clearing cache and cookies for profile: {self.profile.storageName()}") + + # Clear all cookies + self.profile.cookieStore().deleteAllCookies() + + # Clear cache + self.profile.clearHttpCache() + + logger.debug("Cache and cookies cleared successfully") diff --git a/src/webdrop_bridge/ui/settings_dialog.py b/src/webdrop_bridge/ui/settings_dialog.py index dcbd016..99f5241 100644 --- a/src/webdrop_bridge/ui/settings_dialog.py +++ b/src/webdrop_bridge/ui/settings_dialog.py @@ -2,10 +2,10 @@ import logging from pathlib import Path -from typing import List, Optional +from typing import Any, Dict, Optional -from PySide6.QtCore import Qt from PySide6.QtWidgets import ( + QComboBox, QDialog, QDialogButtonBox, QFileDialog, @@ -13,7 +13,6 @@ from PySide6.QtWidgets import ( QLabel, QLineEdit, QListWidget, - QListWidgetItem, QPushButton, QSpinBox, QTableWidget, @@ -25,118 +24,95 @@ from PySide6.QtWidgets import ( from webdrop_bridge.config import Config, ConfigurationError from webdrop_bridge.core.config_manager import ConfigExporter, ConfigProfile, ConfigValidator +from webdrop_bridge.utils.i18n import get_available_languages, tr from webdrop_bridge.utils.logging import reconfigure_logging logger = logging.getLogger(__name__) class SettingsDialog(QDialog): - """Dialog for managing application settings and configuration. - - Provides tabs for: - - Paths: Manage allowed root directories - - URLs: Manage allowed web URLs - - Logging: Configure logging settings - - Window: Manage window size and behavior - - Profiles: Save/load/delete configuration profiles - """ + """Dialog for managing application settings and configuration.""" - def __init__(self, config: Config, parent=None): + def __init__(self, config: Config, parent: Optional[QWidget] = None): """Initialize the settings dialog. - + Args: config: Current application configuration parent: Parent widget """ super().__init__(parent) self.config = config - self.profile_manager = ConfigProfile() - self.setWindowTitle("Settings") + self.profile_manager = ConfigProfile(config.config_dir_name) + self.setWindowTitle(tr("settings.title")) self.setGeometry(100, 100, 600, 500) - + self.setup_ui() def setup_ui(self) -> None: """Set up the dialog UI with tabs.""" layout = QVBoxLayout() - - # Create tab widget + self.tabs = QTabWidget() - - # Add tabs - self.tabs.addTab(self._create_web_source_tab(), "Web Source") - self.tabs.addTab(self._create_paths_tab(), "Paths") - self.tabs.addTab(self._create_urls_tab(), "URLs") - self.tabs.addTab(self._create_logging_tab(), "Logging") - self.tabs.addTab(self._create_window_tab(), "Window") - self.tabs.addTab(self._create_profiles_tab(), "Profiles") - + self.tabs.addTab(self._create_general_tab(), tr("settings.tab.general")) + self.tabs.addTab(self._create_web_source_tab(), tr("settings.tab.web_source")) + self.tabs.addTab(self._create_paths_tab(), tr("settings.tab.paths")) + self.tabs.addTab(self._create_urls_tab(), tr("settings.tab.urls")) + self.tabs.addTab(self._create_logging_tab(), tr("settings.tab.logging")) + self.tabs.addTab(self._create_window_tab(), tr("settings.tab.window")) + self.tabs.addTab(self._create_profiles_tab(), tr("settings.tab.profiles")) layout.addWidget(self.tabs) - - # Add buttons + button_box = QDialogButtonBox( QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel ) button_box.accepted.connect(self.accept) button_box.rejected.connect(self.reject) layout.addWidget(button_box) - + self.setLayout(layout) def accept(self) -> None: - """Handle OK button - save configuration changes to file. - - Validates configuration and saves to the default config path. - Applies log level changes immediately in the running application. - If validation or save fails, shows error and stays in dialog. - """ + """Handle OK button - save configuration changes to file.""" try: - # Get updated configuration data from UI config_data = self.get_config_data() - - # Convert URL mappings from dict to URLMapping objects + from webdrop_bridge.config import URLMapping - + url_mappings = [ - URLMapping( - url_prefix=m["url_prefix"], - local_path=m["local_path"] - ) + URLMapping(url_prefix=m["url_prefix"], local_path=m["local_path"]) for m in config_data["url_mappings"] ] - - # Update the config object with new values + old_log_level = self.config.log_level + self.config.language = config_data["language"] self.config.log_level = config_data["log_level"] - self.config.log_file = Path(config_data["log_file"]) if config_data["log_file"] else None + self.config.log_file = ( + Path(config_data["log_file"]) if config_data["log_file"] else None + ) self.config.allowed_roots = [Path(r).resolve() for r in config_data["allowed_roots"]] self.config.allowed_urls = config_data["allowed_urls"] self.config.webapp_url = config_data["webapp_url"] self.config.url_mappings = url_mappings self.config.window_width = config_data["window_width"] self.config.window_height = config_data["window_height"] - - # Save to file (creates parent dirs if needed) - config_path = Config.get_default_config_path() + + config_path = self.config.get_config_path() self.config.to_file(config_path) - + logger.info(f"Configuration saved to {config_path}") logger.info(f" Log level: {self.config.log_level} (was: {old_log_level})") logger.info(f" Window size: {self.config.window_width}x{self.config.window_height}") - - # Apply log level change immediately to running application + if old_log_level != self.config.log_level: - logger.info(f"🔄 Updating log level: {old_log_level} → {self.config.log_level}") reconfigure_logging( logger_name="webdrop_bridge", level=self.config.log_level, - log_file=self.config.log_file + log_file=self.config.log_file, ) - logger.info(f"✅ Log level updated to {self.config.log_level}") - - # Call parent accept to close dialog + logger.info(f"Log level updated to {self.config.log_level}") + super().accept() - + except ConfigurationError as e: logger.error(f"Configuration error: {e}") self._show_error(f"Configuration Error:\n\n{e}") @@ -144,133 +120,165 @@ class SettingsDialog(QDialog): logger.error(f"Failed to save configuration: {e}", exc_info=True) self._show_error(f"Failed to save configuration:\n\n{e}") - def _create_web_source_tab(self) -> QWidget: - """Create web source configuration tab.""" - from PySide6.QtWidgets import QTableWidget, QTableWidgetItem - + def _create_general_tab(self) -> QWidget: + """Create general settings tab with language selector.""" widget = QWidget() layout = QVBoxLayout() - - # Webapp URL configuration - layout.addWidget(QLabel("Web Application URL:")) + + lang_layout = QHBoxLayout() + lang_layout.addWidget(QLabel(tr("settings.general.language_label"))) + + self.language_combo = QComboBox() + self.language_combo.addItem(tr("settings.general.language_auto"), "auto") + available = get_available_languages() + current_lang = self.config.language + for code, name in available.items(): + self.language_combo.addItem(name, code) + + idx = self.language_combo.findData(current_lang) + if idx >= 0: + self.language_combo.setCurrentIndex(idx) + + lang_layout.addWidget(self.language_combo) + lang_layout.addStretch() + layout.addLayout(lang_layout) + + note = QLabel(tr("settings.general.language_restart_note")) + note.setStyleSheet("color: gray; font-size: 11px;") + layout.addWidget(note) + + layout.addStretch() + widget.setLayout(layout) + return widget + + def _create_web_source_tab(self) -> QWidget: + """Create web source configuration tab.""" + widget = QWidget() + layout = QVBoxLayout() + + layout.addWidget(QLabel(tr("settings.web_source.url_label"))) url_layout = QHBoxLayout() - + self.webapp_url_input = QLineEdit() self.webapp_url_input.setText(self.config.webapp_url) - self.webapp_url_input.setPlaceholderText("e.g., http://localhost:8080 or file:///./webapp/index.html") + self.webapp_url_input.setPlaceholderText( + "e.g., http://localhost:8080 or file:///./webapp/index.html" + ) url_layout.addWidget(self.webapp_url_input) - - open_btn = QPushButton("Open") + + open_btn = QPushButton(tr("settings.web_source.open_btn")) open_btn.clicked.connect(self._open_webapp_url) url_layout.addWidget(open_btn) - + layout.addLayout(url_layout) - - # URL Mappings (Azure Blob URL → Local Path) - layout.addWidget(QLabel("URL Mappings (Azure Blob Storage → Local Paths):")) - - # Create table for URL mappings + + layout.addWidget(QLabel(tr("settings.web_source.url_mappings_label"))) + self.url_mappings_table = QTableWidget() self.url_mappings_table.setColumnCount(2) - self.url_mappings_table.setHorizontalHeaderLabels(["URL Prefix", "Local Path"]) + self.url_mappings_table.setHorizontalHeaderLabels( + [ + tr("settings.web_source.col_url_prefix"), + tr("settings.web_source.col_local_path"), + ] + ) self.url_mappings_table.horizontalHeader().setStretchLastSection(True) - - # Populate from config + for mapping in self.config.url_mappings: row = self.url_mappings_table.rowCount() self.url_mappings_table.insertRow(row) self.url_mappings_table.setItem(row, 0, QTableWidgetItem(mapping.url_prefix)) self.url_mappings_table.setItem(row, 1, QTableWidgetItem(mapping.local_path)) - + layout.addWidget(self.url_mappings_table) - - # Buttons for URL mapping management + button_layout = QHBoxLayout() - - add_mapping_btn = QPushButton("Add Mapping") + + add_mapping_btn = QPushButton(tr("settings.web_source.add_mapping_btn")) add_mapping_btn.clicked.connect(self._add_url_mapping) button_layout.addWidget(add_mapping_btn) - - edit_mapping_btn = QPushButton("Edit Selected") + + edit_mapping_btn = QPushButton(tr("settings.web_source.edit_mapping_btn")) edit_mapping_btn.clicked.connect(self._edit_url_mapping) button_layout.addWidget(edit_mapping_btn) - - remove_mapping_btn = QPushButton("Remove Selected") + + remove_mapping_btn = QPushButton(tr("settings.web_source.remove_mapping_btn")) remove_mapping_btn.clicked.connect(self._remove_url_mapping) button_layout.addWidget(remove_mapping_btn) - + layout.addLayout(button_layout) layout.addStretch() - + widget.setLayout(layout) return widget - + def _open_webapp_url(self) -> None: """Open the webapp URL in the default browser.""" import webbrowser + url = self.webapp_url_input.text().strip() - if url: - # Handle file:// URLs - try: - webbrowser.open(url) - except Exception as e: - logger.error(f"Failed to open URL: {e}") - self._show_error(f"Failed to open URL:\n\n{e}") - + if not url: + return + try: + webbrowser.open(url) + except Exception as e: + logger.error(f"Failed to open URL: {e}") + self._show_error(f"Failed to open URL:\n\n{e}") + def _add_url_mapping(self) -> None: """Add new URL mapping.""" from PySide6.QtWidgets import QInputDialog - + url_prefix, ok1 = QInputDialog.getText( self, - "Add URL Mapping", - "Enter Azure Blob Storage URL prefix:\n(e.g., https://myblob.blob.core.windows.net/container/)" + tr("settings.web_source.add_mapping_title"), + tr("settings.web_source.add_mapping_url_prompt"), ) - + if ok1 and url_prefix: local_path, ok2 = QInputDialog.getText( self, - "Add URL Mapping", - "Enter local file system path:\n(e.g., C:\\Share or /mnt/share)" + tr("settings.web_source.add_mapping_title"), + tr("settings.web_source.add_mapping_path_prompt"), ) - + if ok2 and local_path: row = self.url_mappings_table.rowCount() self.url_mappings_table.insertRow(row) self.url_mappings_table.setItem(row, 0, QTableWidgetItem(url_prefix)) self.url_mappings_table.setItem(row, 1, QTableWidgetItem(local_path)) - + def _edit_url_mapping(self) -> None: """Edit selected URL mapping.""" from PySide6.QtWidgets import QInputDialog - + current_row = self.url_mappings_table.currentRow() if current_row < 0: - self._show_error("Please select a mapping to edit") + self._show_error(tr("settings.web_source.select_mapping_to_edit")) return - - url_prefix = self.url_mappings_table.item(current_row, 0).text() - local_path = self.url_mappings_table.item(current_row, 1).text() - + + url_prefix = self.url_mappings_table.item(current_row, 0).text() # type: ignore + local_path = self.url_mappings_table.item(current_row, 1).text() # type: ignore + new_url_prefix, ok1 = QInputDialog.getText( self, - "Edit URL Mapping", - "Enter Azure Blob Storage URL prefix:", - text=url_prefix + tr("settings.web_source.edit_mapping_title"), + tr("settings.web_source.edit_mapping_url_prompt"), + text=url_prefix, ) - + if ok1 and new_url_prefix: new_local_path, ok2 = QInputDialog.getText( self, - "Edit URL Mapping", - "Enter local file system path:", - text=local_path + tr("settings.web_source.edit_mapping_title"), + tr("settings.web_source.edit_mapping_path_prompt"), + text=local_path, ) - + if ok2 and new_local_path: self.url_mappings_table.setItem(current_row, 0, QTableWidgetItem(new_url_prefix)) self.url_mappings_table.setItem(current_row, 1, QTableWidgetItem(new_local_path)) - + def _remove_url_mapping(self) -> None: """Remove selected URL mapping.""" current_row = self.url_mappings_table.currentRow() @@ -281,29 +289,27 @@ class SettingsDialog(QDialog): """Create paths configuration tab.""" widget = QWidget() layout = QVBoxLayout() - - layout.addWidget(QLabel("Allowed root directories for file access:")) - - # List widget for paths + + layout.addWidget(QLabel(tr("settings.paths.label"))) + self.paths_list = QListWidget() for path in self.config.allowed_roots: self.paths_list.addItem(str(path)) layout.addWidget(self.paths_list) - - # Buttons for path management + button_layout = QHBoxLayout() - - add_path_btn = QPushButton("Add Path") + + add_path_btn = QPushButton(tr("settings.paths.add_btn")) add_path_btn.clicked.connect(self._add_path) button_layout.addWidget(add_path_btn) - - remove_path_btn = QPushButton("Remove Selected") + + remove_path_btn = QPushButton(tr("settings.paths.remove_btn")) remove_path_btn.clicked.connect(self._remove_path) button_layout.addWidget(remove_path_btn) - + layout.addLayout(button_layout) layout.addStretch() - + widget.setLayout(layout) return widget @@ -311,29 +317,27 @@ class SettingsDialog(QDialog): """Create URLs configuration tab.""" widget = QWidget() layout = QVBoxLayout() - - layout.addWidget(QLabel("Allowed web URLs (supports wildcards like http://*.example.com):")) - - # List widget for URLs + + layout.addWidget(QLabel(tr("settings.urls.label"))) + self.urls_list = QListWidget() for url in self.config.allowed_urls: self.urls_list.addItem(url) layout.addWidget(self.urls_list) - - # Buttons for URL management + button_layout = QHBoxLayout() - - add_url_btn = QPushButton("Add URL") + + add_url_btn = QPushButton(tr("settings.urls.add_btn")) add_url_btn.clicked.connect(self._add_url) button_layout.addWidget(add_url_btn) - - remove_url_btn = QPushButton("Remove Selected") + + remove_url_btn = QPushButton(tr("settings.urls.remove_btn")) remove_url_btn.clicked.connect(self._remove_url) button_layout.addWidget(remove_url_btn) - + layout.addLayout(button_layout) layout.addStretch() - + widget.setLayout(layout) return widget @@ -341,27 +345,23 @@ class SettingsDialog(QDialog): """Create logging configuration tab.""" widget = QWidget() layout = QVBoxLayout() - - # Log level selection - layout.addWidget(QLabel("Log Level:")) - from PySide6.QtWidgets import QComboBox + + layout.addWidget(QLabel(tr("settings.logging.level_label"))) self.log_level_combo: QComboBox = self._create_log_level_widget() layout.addWidget(self.log_level_combo) - - # Log file path - layout.addWidget(QLabel("Log File (optional):")) + + layout.addWidget(QLabel(tr("settings.logging.file_label"))) log_file_layout = QHBoxLayout() - + self.log_file_input = QLineEdit() self.log_file_input.setText(str(self.config.log_file) if self.config.log_file else "") log_file_layout.addWidget(self.log_file_input) - - browse_btn = QPushButton("Browse...") + + browse_btn = QPushButton(tr("settings.logging.browse_btn")) browse_btn.clicked.connect(self._browse_log_file) log_file_layout.addWidget(browse_btn) - + layout.addLayout(log_file_layout) - layout.addStretch() widget.setLayout(layout) return widget @@ -370,10 +370,9 @@ class SettingsDialog(QDialog): """Create window settings tab.""" widget = QWidget() layout = QVBoxLayout() - - # Window width + width_layout = QHBoxLayout() - width_layout.addWidget(QLabel("Window Width:")) + width_layout.addWidget(QLabel(tr("settings.window.width_label"))) self.width_spin = QSpinBox() self.width_spin.setMinimum(400) self.width_spin.setMaximum(5000) @@ -381,10 +380,9 @@ class SettingsDialog(QDialog): width_layout.addWidget(self.width_spin) width_layout.addStretch() layout.addLayout(width_layout) - - # Window height + height_layout = QHBoxLayout() - height_layout.addWidget(QLabel("Window Height:")) + height_layout.addWidget(QLabel(tr("settings.window.height_label"))) self.height_spin = QSpinBox() self.height_spin.setMinimum(300) self.height_spin.setMaximum(5000) @@ -392,7 +390,7 @@ class SettingsDialog(QDialog): height_layout.addWidget(self.height_spin) height_layout.addStretch() layout.addLayout(height_layout) - + layout.addStretch() widget.setLayout(layout) return widget @@ -401,52 +399,47 @@ class SettingsDialog(QDialog): """Create profiles management tab.""" widget = QWidget() layout = QVBoxLayout() - - layout.addWidget(QLabel("Saved Configuration Profiles:")) - - # List of profiles + + layout.addWidget(QLabel(tr("settings.profiles.label"))) + self.profiles_list = QListWidget() self._refresh_profiles_list() layout.addWidget(self.profiles_list) - - # Profile management buttons + button_layout = QHBoxLayout() - - save_profile_btn = QPushButton("Save as Profile") + + save_profile_btn = QPushButton(tr("settings.profiles.save_btn")) save_profile_btn.clicked.connect(self._save_profile) button_layout.addWidget(save_profile_btn) - - load_profile_btn = QPushButton("Load Profile") + + load_profile_btn = QPushButton(tr("settings.profiles.load_btn")) load_profile_btn.clicked.connect(self._load_profile) button_layout.addWidget(load_profile_btn) - - delete_profile_btn = QPushButton("Delete Profile") + + delete_profile_btn = QPushButton(tr("settings.profiles.delete_btn")) delete_profile_btn.clicked.connect(self._delete_profile) button_layout.addWidget(delete_profile_btn) - + layout.addLayout(button_layout) - - # Export/Import buttons + export_layout = QHBoxLayout() - - export_btn = QPushButton("Export Configuration") + + export_btn = QPushButton(tr("settings.profiles.export_btn")) export_btn.clicked.connect(self._export_config) export_layout.addWidget(export_btn) - - import_btn = QPushButton("Import Configuration") + + import_btn = QPushButton(tr("settings.profiles.import_btn")) import_btn.clicked.connect(self._import_config) export_layout.addWidget(import_btn) - + layout.addLayout(export_layout) layout.addStretch() - + widget.setLayout(layout) return widget - def _create_log_level_widget(self): + def _create_log_level_widget(self) -> QComboBox: """Create log level selection widget.""" - from PySide6.QtWidgets import QComboBox - combo = QComboBox() levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] combo.addItems(levels) @@ -455,7 +448,7 @@ class SettingsDialog(QDialog): def _add_path(self) -> None: """Add a new allowed path.""" - path = QFileDialog.getExistingDirectory(self, "Select Directory to Allow") + path = QFileDialog.getExistingDirectory(self, tr("settings.paths.select_dir_title")) if path: self.paths_list.addItem(path) @@ -467,11 +460,9 @@ class SettingsDialog(QDialog): def _add_url(self) -> None: """Add a new allowed URL.""" from PySide6.QtWidgets import QInputDialog - + url, ok = QInputDialog.getText( - self, - "Add URL", - "Enter URL pattern (e.g., http://example.com or http://*.example.com):" + self, tr("settings.urls.add_title"), tr("settings.urls.add_prompt") ) if ok and url: self.urls_list.addItem(url) @@ -485,9 +476,9 @@ class SettingsDialog(QDialog): """Browse for log file location.""" file_path, _ = QFileDialog.getSaveFileName( self, - "Select Log File", + tr("settings.logging.select_file_title"), str(Path.home()), - "Log Files (*.log);;All Files (*)" + "Log Files (*.log);;All Files (*)", ) if file_path: self.log_file_input.setText(file_path) @@ -501,13 +492,11 @@ class SettingsDialog(QDialog): def _save_profile(self) -> None: """Save current configuration as a profile.""" from PySide6.QtWidgets import QInputDialog - + profile_name, ok = QInputDialog.getText( - self, - "Save Profile", - "Enter profile name (e.g., work, personal):" + self, tr("settings.profiles.save_title"), tr("settings.profiles.save_prompt") ) - + if ok and profile_name: try: self.profile_manager.save_profile(profile_name, self.config) @@ -519,9 +508,9 @@ class SettingsDialog(QDialog): """Load a saved profile.""" current_item = self.profiles_list.currentItem() if not current_item: - self._show_error("Please select a profile to load") + self._show_error(tr("settings.profiles.select_to_load")) return - + profile_name = current_item.text() try: config_data = self.profile_manager.load_profile(profile_name) @@ -533,9 +522,9 @@ class SettingsDialog(QDialog): """Delete a saved profile.""" current_item = self.profiles_list.currentItem() if not current_item: - self._show_error("Please select a profile to delete") + self._show_error(tr("settings.profiles.select_to_delete")) return - + profile_name = current_item.text() try: self.profile_manager.delete_profile(profile_name) @@ -547,11 +536,11 @@ class SettingsDialog(QDialog): """Export configuration to file.""" file_path, _ = QFileDialog.getSaveFileName( self, - "Export Configuration", + tr("settings.profiles.export_title"), str(Path.home()), - "JSON Files (*.json);;All Files (*)" + "JSON Files (*.json);;All Files (*)", ) - + if file_path: try: ConfigExporter.export_to_json(self.config, Path(file_path)) @@ -562,11 +551,11 @@ class SettingsDialog(QDialog): """Import configuration from file.""" file_path, _ = QFileDialog.getOpenFileName( self, - "Import Configuration", + tr("settings.profiles.import_title"), str(Path.home()), - "JSON Files (*.json);;All Files (*)" + "JSON Files (*.json);;All Files (*)", ) - + if file_path: try: config_data = ConfigExporter.import_from_json(Path(file_path)) @@ -574,70 +563,85 @@ class SettingsDialog(QDialog): except ConfigurationError as e: self._show_error(f"Failed to import configuration: {e}") - def _apply_config_data(self, config_data: dict) -> None: + def _apply_config_data(self, config_data: Dict[str, Any]) -> None: """Apply imported configuration data to UI. - + Args: config_data: Configuration dictionary """ - # Apply paths self.paths_list.clear() for path in config_data.get("allowed_roots", []): self.paths_list.addItem(str(path)) - - # Apply URLs + self.urls_list.clear() for url in config_data.get("allowed_urls", []): self.urls_list.addItem(url) - - # Apply logging settings + self.log_level_combo.setCurrentText(config_data.get("log_level", "INFO")) log_file = config_data.get("log_file") self.log_file_input.setText(str(log_file) if log_file else "") - - # Apply window settings + self.width_spin.setValue(config_data.get("window_width", 800)) self.height_spin.setValue(config_data.get("window_height", 600)) - def get_config_data(self) -> dict: + language = config_data.get("language", "auto") + idx = self.language_combo.findData(language) + if idx >= 0: + self.language_combo.setCurrentIndex(idx) + + def get_config_data(self) -> Dict[str, Any]: """Get updated configuration data from dialog. - + Returns: Configuration dictionary - + Raises: ConfigurationError: If configuration is invalid """ + url_mappings_table_count = ( + self.url_mappings_table.rowCount() if self.url_mappings_table else 0 + ) + config_data = { "app_name": self.config.app_name, "app_version": self.config.app_version, + "language": self.language_combo.currentData(), "log_level": self.log_level_combo.currentText(), "log_file": self.log_file_input.text() or None, - "allowed_roots": [self.paths_list.item(i).text() for i in range(self.paths_list.count())], + "allowed_roots": [ + self.paths_list.item(i).text() for i in range(self.paths_list.count()) + ], "allowed_urls": [self.urls_list.item(i).text() for i in range(self.urls_list.count())], "webapp_url": self.webapp_url_input.text().strip(), "url_mappings": [ { - "url_prefix": self.url_mappings_table.item(i, 0).text(), - "local_path": self.url_mappings_table.item(i, 1).text() + "url_prefix": ( + self.url_mappings_table.item(i, 0).text() # type: ignore + if self.url_mappings_table.item(i, 0) + else "" + ), + "local_path": ( + self.url_mappings_table.item(i, 1).text() # type: ignore + if self.url_mappings_table.item(i, 1) + else "" + ), } - for i in range(self.url_mappings_table.rowCount()) + for i in range(url_mappings_table_count) ], "window_width": self.width_spin.value(), "window_height": self.height_spin.value(), "enable_logging": self.config.enable_logging, } - - # Validate + ConfigValidator.validate_or_raise(config_data) - return config_data def _show_error(self, message: str) -> None: """Show error message to user. - + Args: message: Error message """ from PySide6.QtWidgets import QMessageBox - QMessageBox.critical(self, "Error", message) + + QMessageBox.critical(self, tr("dialog.error.title"), message) diff --git a/src/webdrop_bridge/ui/update_manager_ui.py b/src/webdrop_bridge/ui/update_manager_ui.py index 1ddd4f0..474f18b 100644 --- a/src/webdrop_bridge/ui/update_manager_ui.py +++ b/src/webdrop_bridge/ui/update_manager_ui.py @@ -25,182 +25,174 @@ from PySide6.QtWidgets import ( QVBoxLayout, ) +from webdrop_bridge.utils.i18n import tr + logger = logging.getLogger(__name__) class CheckingDialog(QDialog): """Dialog shown while checking for updates. - + Shows an animated progress indicator and times out after 10 seconds. """ def __init__(self, parent=None): """Initialize checking dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Checking for Updates") + self.setWindowTitle(tr("update.checking.title")) self.setModal(True) self.setMinimumWidth(300) self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowCloseButtonHint) - + layout = QVBoxLayout() - + # Status label - self.label = QLabel("Checking for updates...") + self.label = QLabel(tr("update.checking.label")) layout.addWidget(self.label) - + # Animated progress bar self.progress = QProgressBar() self.progress.setMaximum(0) # Makes it animated layout.addWidget(self.progress) - + # Timeout info - info_label = QLabel("This may take up to 10 seconds") + info_label = QLabel(tr("update.checking.timeout_info")) info_label.setStyleSheet("color: gray; font-size: 11px;") layout.addWidget(info_label) - + self.setLayout(layout) class UpdateAvailableDialog(QDialog): """Dialog shown when an update is available. - + Displays: - Current version - Available version - Changelog/release notes - Buttons: Update Now, Update Later, Skip This Version """ - + # Signals update_now = Signal() update_later = Signal() - skip_version = Signal() def __init__(self, version: str, changelog: str, parent=None): """Initialize update available dialog. - + Args: version: New version string (e.g., "0.0.2") changelog: Release notes text parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Update Available") + self.setWindowTitle(tr("update.available.title")) self.setModal(True) self.setMinimumWidth(400) self.setMinimumHeight(300) - + layout = QVBoxLayout() - + # Header - header = QLabel(f"WebDrop Bridge v{version} is available") + header = QLabel(tr("update.available.header", version=version)) header.setStyleSheet("font-weight: bold; font-size: 14px;") layout.addWidget(header) - + # Changelog - changelog_label = QLabel("Release Notes:") + changelog_label = QLabel(tr("update.available.changelog_label")) changelog_label.setStyleSheet("font-weight: bold; margin-top: 10px;") layout.addWidget(changelog_label) - + self.changelog = QTextEdit() self.changelog.setText(changelog) self.changelog.setReadOnly(True) layout.addWidget(self.changelog) - + # Buttons button_layout = QHBoxLayout() - - self.update_now_btn = QPushButton("Update Now") + + self.update_now_btn = QPushButton(tr("update.available.update_now_btn")) self.update_now_btn.clicked.connect(self._on_update_now) button_layout.addWidget(self.update_now_btn) - - self.update_later_btn = QPushButton("Later") + + self.update_later_btn = QPushButton(tr("update.available.later_btn")) self.update_later_btn.clicked.connect(self._on_update_later) button_layout.addWidget(self.update_later_btn) - - self.skip_btn = QPushButton("Skip Version") - self.skip_btn.clicked.connect(self._on_skip) - button_layout.addWidget(self.skip_btn) - + layout.addLayout(button_layout) self.setLayout(layout) - + def _on_update_now(self): """Handle update now button click.""" self.update_now.emit() self.accept() - + def _on_update_later(self): """Handle update later button click.""" self.update_later.emit() self.reject() - - def _on_skip(self): - """Handle skip version button click.""" - self.skip_version.emit() - self.reject() class DownloadingDialog(QDialog): """Dialog shown while downloading the update. - + Displays: - Download progress bar - Current file being downloaded - Cancel button """ - + cancel_download = Signal() def __init__(self, parent=None): """Initialize downloading dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Downloading Update") + self.setWindowTitle(tr("update.downloading.title")) self.setModal(True) self.setMinimumWidth(350) self.setWindowFlags(self.windowFlags() & ~Qt.WindowType.WindowCloseButtonHint) - + layout = QVBoxLayout() - + # Header - header = QLabel("Downloading update...") + header = QLabel(tr("update.downloading.header")) header.setStyleSheet("font-weight: bold;") layout.addWidget(header) - + # File label - self.file_label = QLabel("Preparing download") + self.file_label = QLabel(tr("update.downloading.preparing")) layout.addWidget(self.file_label) - + # Progress bar self.progress = QProgressBar() self.progress.setMinimum(0) self.progress.setMaximum(100) self.progress.setValue(0) layout.addWidget(self.progress) - + # Size info self.size_label = QLabel("0 MB / 0 MB") self.size_label.setStyleSheet("color: gray; font-size: 11px;") layout.addWidget(self.size_label) - + # Cancel button - self.cancel_btn = QPushButton("Cancel") + self.cancel_btn = QPushButton(tr("update.downloading.cancel_btn")) self.cancel_btn.clicked.connect(self._on_cancel) layout.addWidget(self.cancel_btn) - + self.setLayout(layout) - + def set_progress(self, current: int, total: int): """Update progress bar. - + Args: current: Current bytes downloaded total: Total bytes to download @@ -208,20 +200,20 @@ class DownloadingDialog(QDialog): if total > 0: percentage = int((current / total) * 100) self.progress.setValue(percentage) - + # Format size display current_mb = current / (1024 * 1024) total_mb = total / (1024 * 1024) self.size_label.setText(f"{current_mb:.1f} MB / {total_mb:.1f} MB") - + def set_filename(self, filename: str): """Set the filename being downloaded. - + Args: filename: Name of file being downloaded """ - self.file_label.setText(f"Downloading: {filename}") - + self.file_label.setText(tr("update.downloading.filename", filename=filename)) + def _on_cancel(self): """Handle cancel button click.""" self.cancel_download.emit() @@ -230,61 +222,58 @@ class DownloadingDialog(QDialog): class InstallDialog(QDialog): """Dialog shown before installing update and restarting. - + Displays: - Installation confirmation message - Warning about unsaved changes - Buttons: Install Now, Cancel """ - + install_now = Signal() def __init__(self, parent=None): """Initialize install dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Install Update") + self.setWindowTitle(tr("update.install.title")) self.setModal(True) self.setMinimumWidth(350) - + layout = QVBoxLayout() - + # Header - header = QLabel("Ready to Install") + header = QLabel(tr("update.install.header")) header.setStyleSheet("font-weight: bold; font-size: 14px;") layout.addWidget(header) - + # Message - message = QLabel("The update is ready to install. The application will restart.") + message = QLabel(tr("update.install.message")) layout.addWidget(message) - + # Warning - warning = QLabel( - "⚠️ Please save any unsaved work before continuing.\n" - "The application will close and restart." - ) + warning = QLabel(tr("update.install.warning")) warning.setStyleSheet("background-color: #fff3cd; padding: 10px; border-radius: 4px;") warning.setWordWrap(True) layout.addWidget(warning) - + # Buttons button_layout = QHBoxLayout() - - self.install_btn = QPushButton("Install Now") + + self.install_btn = QPushButton(tr("update.install.now_btn")) self.install_btn.setStyleSheet("background-color: #28a745; color: white;") self.install_btn.clicked.connect(self._on_install) button_layout.addWidget(self.install_btn) - - self.cancel_btn = QPushButton("Cancel") + + self.cancel_btn = QPushButton(tr("update.install.cancel_btn")) self.cancel_btn.clicked.connect(self.reject) button_layout.addWidget(self.cancel_btn) - + layout.addLayout(button_layout) self.setLayout(layout) - + def _on_install(self): """Handle install now button click.""" self.install_now.emit() @@ -293,107 +282,105 @@ class InstallDialog(QDialog): class NoUpdateDialog(QDialog): """Dialog shown when no updates are available. - + Simple confirmation that the application is up to date. """ def __init__(self, parent=None): """Initialize no update dialog. - + Args: parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("No Updates Available") + self.setWindowTitle(tr("update.no_update.title")) self.setModal(True) self.setMinimumWidth(300) - + layout = QVBoxLayout() - + # Message - message = QLabel("✓ You're using the latest version") + message = QLabel(tr("update.no_update.message")) message.setStyleSheet("font-weight: bold; font-size: 12px; color: #28a745;") layout.addWidget(message) - - info = QLabel("WebDrop Bridge is up to date.") + + info = QLabel(tr("update.no_update.info")) layout.addWidget(info) - + # Close button - close_btn = QPushButton("OK") + close_btn = QPushButton(tr("update.no_update.ok_btn")) close_btn.clicked.connect(self.accept) layout.addWidget(close_btn) - + self.setLayout(layout) class ErrorDialog(QDialog): """Dialog shown when update check or installation fails. - + Displays: - Error message - Buttons: Retry, Manual Download, Cancel """ - + retry = Signal() manual_download = Signal() def __init__(self, error_message: str, parent=None): """Initialize error dialog. - + Args: error_message: Description of the error parent: Parent widget """ super().__init__(parent) - self.setWindowTitle("Update Failed") + self.setWindowTitle(tr("update.error.title")) self.setModal(True) self.setMinimumWidth(350) - + layout = QVBoxLayout() - + # Header - header = QLabel("⚠️ Update Failed") + header = QLabel(tr("update.error.header")) header.setStyleSheet("font-weight: bold; font-size: 14px; color: #dc3545;") layout.addWidget(header) - + # Error message self.error_text = QTextEdit() self.error_text.setText(error_message) self.error_text.setReadOnly(True) self.error_text.setMaximumHeight(100) layout.addWidget(self.error_text) - + # Info message - info = QLabel( - "Please try again or visit the website to download the update manually." - ) + info = QLabel(tr("update.error.info")) info.setWordWrap(True) info.setStyleSheet("color: gray; font-size: 11px;") layout.addWidget(info) - + # Buttons button_layout = QHBoxLayout() - - self.retry_btn = QPushButton("Retry") + + self.retry_btn = QPushButton(tr("update.error.retry_btn")) self.retry_btn.clicked.connect(self._on_retry) button_layout.addWidget(self.retry_btn) - - self.manual_btn = QPushButton("Download Manually") + + self.manual_btn = QPushButton(tr("update.error.manual_btn")) self.manual_btn.clicked.connect(self._on_manual) button_layout.addWidget(self.manual_btn) - - self.cancel_btn = QPushButton("Cancel") + + self.cancel_btn = QPushButton(tr("update.error.cancel_btn")) self.cancel_btn.clicked.connect(self.reject) button_layout.addWidget(self.cancel_btn) - + layout.addLayout(button_layout) self.setLayout(layout) - + def _on_retry(self): """Handle retry button click.""" self.retry.emit() self.accept() - + def _on_manual(self): """Handle manual download button click.""" self.manual_download.emit() diff --git a/src/webdrop_bridge/utils/i18n.py b/src/webdrop_bridge/utils/i18n.py new file mode 100644 index 0000000..b01f693 --- /dev/null +++ b/src/webdrop_bridge/utils/i18n.py @@ -0,0 +1,292 @@ +"""Internationalization (i18n) support for WebDrop Bridge. + +Provides a simple JSON-based translation system. Translation files are stored +in ``resources/translations/`` (e.g. ``en.json``, ``de.json``, ``fr.json``). + +Usage:: + + from webdrop_bridge.utils.i18n import tr + + # Simple lookup + self.setWindowTitle(tr("settings.title")) + + # With named format arguments + label.setText(tr("status.opened", name="file.pdf")) + +To add a new language, place a JSON file named ``
.json`` in
+``resources/translations/`` and optionally add an entry to
+:attr:`Translator.BUILTIN_LANGUAGES` for a nicer display name.
+"""
+
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class Translator:
+ """Manages translations for the application.
+
+ Loads translations from UTF-8 JSON files that use dot-notation string keys.
+ Falls back to the English translation (and ultimately to the bare key) when
+ a translation is missing.
+
+ Attributes:
+ BUILTIN_LANGUAGES: Mapping of language code → display name for languages
+ that ship with the application. Add entries here when including new
+ translation files.
+ """
+
+ #: Human-readable display names for supported language codes.
+ #: Unknown codes fall back to their uppercase code string.
+ BUILTIN_LANGUAGES: Dict[str, str] = {
+ "en": "English",
+ "de": "Deutsch",
+ "fr": "Français",
+ "it": "Italiano",
+ "ru": "Русский",
+ "zh": "中文",
+ }
+
+ def __init__(self) -> None:
+ self._language: str = "en"
+ self._translations: Dict[str, str] = {}
+ self._fallback: Dict[str, str] = {}
+ self._translations_dir: Optional[Path] = None
+
+ def initialize(self, language: str, translations_dir: Path) -> None:
+ """Initialize the translator with a language and translations directory.
+
+ Args:
+ language: Language code (e.g. ``"en"``, ``"de"``, ``"fr"``) or
+ ``"auto"`` to detect from the system locale.
+ translations_dir: Directory containing the ``.json`` translation files.
+ """
+ self._translations_dir = translations_dir
+
+ # Resolve "auto" to system locale
+ if language == "auto":
+ language = self._detect_system_language()
+ logger.debug(f"Auto-detected language: {language}")
+
+ # Load English as fallback first
+ en_path = translations_dir / "en.json"
+ if en_path.exists():
+ self._fallback = self._load_file(en_path)
+ logger.debug(f"Loaded English fallback translations ({len(self._fallback)} keys)")
+ else:
+ logger.warning(f"English translation file not found at {en_path}")
+
+ # Load requested language
+ self._language = language
+ if language != "en":
+ lang_path = translations_dir / f"{language}.json"
+ if lang_path.exists():
+ self._translations = self._load_file(lang_path)
+ logger.debug(f"Loaded '{language}' translations ({len(self._translations)} keys)")
+ else:
+ logger.warning(
+ f"Translation file not found for language '{language}', "
+ "falling back to English"
+ )
+ self._translations = {}
+ else:
+ self._translations = self._fallback
+
+ def tr(self, key: str, **kwargs: str) -> str:
+ """Get translated string for the given key.
+
+ Args:
+ key: Translation key using dot-notation (e.g. ``"toolbar.home"``).
+ **kwargs: Named format arguments applied to the translated string.
+
+ Returns:
+ Translated and formatted string. Returns the *key* itself when no
+ translation is found, so missing keys are always visible.
+ """
+ text = self._translations.get(key) or self._fallback.get(key) or key
+ if kwargs:
+ try:
+ text = text.format(**kwargs)
+ except (KeyError, ValueError) as e:
+ logger.debug(f"Translation format error for key '{key}': {e}")
+ return text
+
+ def get_current_language(self) -> str:
+ """Get the currently active language code (e.g. ``"de"``)."""
+ return self._language
+
+ def get_available_languages(self) -> Dict[str, str]:
+ """Return available languages as ``{code: display_name}``.
+
+ Discovers language files at runtime so newly added JSON files are
+ automatically included without code changes.
+
+ Returns:
+ Ordered dict mapping language code → human-readable display name.
+ """
+ if self._translations_dir is None:
+ return {"en": "English"}
+
+ languages: Dict[str, str] = {}
+ for lang_file in sorted(self._translations_dir.glob("*.json")):
+ code = lang_file.stem
+ name = self.BUILTIN_LANGUAGES.get(code, code.upper())
+ languages[code] = name
+ return languages
+
+ # ------------------------------------------------------------------
+ # Private helpers
+ # ------------------------------------------------------------------
+
+ def _load_file(self, path: Path) -> Dict[str, str]:
+ """Load a JSON translation file.
+
+ Args:
+ path: Path to the UTF-8 encoded JSON translation file.
+
+ Returns:
+ Dictionary of translation keys to translated strings, or an empty
+ dict when the file cannot be read or parsed.
+ """
+ try:
+ with open(path, "r", encoding="utf-8") as f:
+ return json.load(f)
+ except (json.JSONDecodeError, IOError) as e:
+ logger.error(f"Failed to load translation file {path}: {e}")
+ return {}
+
+ def _detect_system_language(self) -> str:
+ """Detect system language from locale or platform settings.
+
+ On Windows, attempts to read the UI language via the WinAPI before
+ falling back to the ``locale`` module.
+
+ Returns:
+ Best-matching supported language code, or ``"en"`` as fallback.
+ """
+ import locale
+
+ try:
+ lang_code: Optional[str] = None
+
+ if sys.platform.startswith("win"):
+ # Windows: use GetUserDefaultUILanguage for accuracy
+ try:
+ import ctypes
+
+ lcid = ctypes.windll.kernel32.GetUserDefaultUILanguage() # type: ignore[attr-defined]
+ # Subset of LCID → ISO 639-1 mappings
+ lcid_map: Dict[int, str] = {
+ 0x0407: "de", # German (Germany)
+ 0x0C07: "de", # German (Austria)
+ 0x0807: "de", # German (Switzerland)
+ 0x040C: "fr", # French (France)
+ 0x080C: "fr", # French (Belgium)
+ 0x0C0C: "fr", # French (Canada)
+ 0x100C: "fr", # French (Switzerland)
+ 0x0410: "it", # Italian (Italy)
+ 0x0810: "it", # Italian (Switzerland)
+ 0x0419: "ru", # Russian
+ 0x0804: "zh", # Chinese Simplified
+ 0x0404: "zh", # Chinese Traditional
+ 0x0409: "en", # English (US)
+ 0x0809: "en", # English (UK)
+ }
+ lang_code = lcid_map.get(lcid)
+ except Exception:
+ pass
+
+ if not lang_code:
+ raw = locale.getdefaultlocale()[0] or ""
+ lang_code = raw.split("_")[0].lower() if raw else None
+
+ if lang_code and lang_code in self.BUILTIN_LANGUAGES:
+ return lang_code
+
+ except Exception as e:
+ logger.debug(f"Language auto-detection failed: {e}")
+
+ return "en"
+
+
+# ---------------------------------------------------------------------------
+# Module-level singleton and public API
+# ---------------------------------------------------------------------------
+
+_translator = Translator()
+
+
+def _ensure_initialized() -> None:
+ """Initialize translator lazily with default settings if needed."""
+ if _translator._translations_dir is not None: # type: ignore[attr-defined]
+ return
+ _translator.initialize("en", get_translations_dir())
+
+
+def initialize(language: str, translations_dir: Path) -> None:
+ """Initialize the global translator.
+
+ Should be called **once at application startup**, before any UI is shown.
+
+ Args:
+ language: Language code (e.g. ``"de"``) or ``"auto"`` for system
+ locale detection.
+ translations_dir: Directory containing the ``.json`` translation files.
+ """
+ _translator.initialize(language, translations_dir)
+
+
+def tr(key: str, **kwargs: str) -> str:
+ """Translate a string by key.
+
+ Args:
+ key: Translation key (e.g. ``"toolbar.home"``).
+ **kwargs: Named format arguments (e.g. ``name="file.pdf"``).
+
+ Returns:
+ Translated string with any format substitutions applied.
+ """
+ _ensure_initialized()
+ text = _translator.tr(key, **kwargs)
+
+ # If lookup failed and translator points to a non-default directory (e.g. tests
+ # overriding translator state), retry from default bundled translations.
+ if text == key:
+ default_dir = get_translations_dir()
+ current_dir = _translator._translations_dir # type: ignore[attr-defined]
+ if current_dir != default_dir:
+ _translator.initialize("en", default_dir)
+ text = _translator.tr(key, **kwargs)
+
+ return text
+
+
+def get_current_language() -> str:
+ """Return the currently active language code (e.g. ``"de"``)."""
+ return _translator.get_current_language()
+
+
+def get_available_languages() -> Dict[str, str]:
+ """Return all available languages as ``{code: display_name}``."""
+ _ensure_initialized()
+ return _translator.get_available_languages()
+
+
+def get_translations_dir() -> Path:
+ """Resolve the translations directory for the current runtime context.
+
+ Handles development mode, PyInstaller bundles, and MSI installations
+ by searching the known candidate paths in order.
+
+ Returns:
+ Path to the ``resources/translations`` directory.
+ """
+ if hasattr(sys, "_MEIPASS"):
+ # PyInstaller bundle
+ return Path(sys._MEIPASS) / "resources" / "translations" # type: ignore[attr-defined]
+ # Development mode or installed Python package
+ return Path(__file__).parent.parent.parent.parent / "resources" / "translations"
diff --git a/tests/unit/test_brand_config.py b/tests/unit/test_brand_config.py
new file mode 100644
index 0000000..9016fef
--- /dev/null
+++ b/tests/unit/test_brand_config.py
@@ -0,0 +1,147 @@
+"""Tests for brand-aware build configuration helpers."""
+
+import json
+import sys
+from pathlib import Path
+
+BUILD_SCRIPTS_DIR = Path(__file__).resolve().parents[2] / "build" / "scripts"
+if str(BUILD_SCRIPTS_DIR) not in sys.path:
+ sys.path.insert(0, str(BUILD_SCRIPTS_DIR))
+
+from brand_config import (
+ DEFAULT_BRAND_ID,
+ collect_local_release_data,
+ generate_release_manifest,
+ load_brand_config,
+ merge_release_manifests,
+)
+
+
+def test_load_agravity_brand_config():
+ """Test loading the Agravity brand manifest."""
+ brand = load_brand_config("agravity")
+
+ assert brand.brand_id == "agravity"
+ assert brand.display_name == "Agravity Bridge"
+ assert brand.asset_prefix == "AgravityBridge"
+ assert brand.exe_name == "AgravityBridge"
+ assert brand.toolbar_icon_home == "resources/icons/home.ico"
+ assert brand.toolbar_icon_reload == "resources/icons/reload.ico"
+ assert brand.toolbar_icon_open == "resources/icons/open.ico"
+ assert brand.toolbar_icon_openwith == "resources/icons/openwith.ico"
+ assert brand.windows_installer_name("0.8.4") == "AgravityBridge-0.8.4-win-x64.msi"
+
+
+def test_generate_release_manifest_for_agravity(tmp_path):
+ """Test generating a shared release manifest from local artifacts."""
+ project_root = tmp_path
+ (project_root / "build" / "brands").mkdir(parents=True)
+ (project_root / "build" / "dist" / "windows" / "agravity").mkdir(parents=True)
+ (project_root / "build" / "dist" / "macos" / "agravity").mkdir(parents=True)
+
+ source_manifest = Path(__file__).resolve().parents[2] / "build" / "brands" / "agravity.json"
+ (project_root / "build" / "brands" / "agravity.json").write_text(
+ source_manifest.read_text(encoding="utf-8"),
+ encoding="utf-8",
+ )
+
+ win_installer = (
+ project_root
+ / "build"
+ / "dist"
+ / "windows"
+ / "agravity"
+ / "AgravityBridge-0.8.4-win-x64.msi"
+ )
+ win_installer.write_bytes(b"msi")
+ (win_installer.parent / f"{win_installer.name}.sha256").write_text("abc", encoding="utf-8")
+
+ mac_installer = (
+ project_root
+ / "build"
+ / "dist"
+ / "macos"
+ / "agravity"
+ / "AgravityBridge-0.8.4-macos-universal.dmg"
+ )
+ mac_installer.write_bytes(b"dmg")
+ (mac_installer.parent / f"{mac_installer.name}.sha256").write_text("def", encoding="utf-8")
+
+ output_path = project_root / "build" / "dist" / "release-manifest.json"
+ generate_release_manifest(
+ "0.8.4",
+ ["agravity"],
+ output_path=output_path,
+ root=project_root,
+ )
+
+ manifest = json.loads(output_path.read_text(encoding="utf-8"))
+ assert manifest["version"] == "0.8.4"
+ assert (
+ manifest["brands"]["agravity"]["windows-x64"]["installer"]
+ == "AgravityBridge-0.8.4-win-x64.msi"
+ )
+ assert (
+ manifest["brands"]["agravity"]["macos-universal"]["installer"]
+ == "AgravityBridge-0.8.4-macos-universal.dmg"
+ )
+
+
+def test_collect_local_release_data_includes_default_brand(tmp_path):
+ """Test discovering local artifacts for the default Windows build."""
+ project_root = tmp_path
+ installer_dir = project_root / "build" / "dist" / "windows" / DEFAULT_BRAND_ID
+ installer_dir.mkdir(parents=True)
+
+ installer = installer_dir / "WebDropBridge-0.8.4-win-x64.msi"
+ installer.write_bytes(b"msi")
+ checksum = installer_dir / f"{installer.name}.sha256"
+ checksum.write_text("abc", encoding="utf-8")
+
+ data = collect_local_release_data("0.8.4", platform="windows", root=project_root)
+
+ assert data["brands"] == [DEFAULT_BRAND_ID]
+ assert str(installer) in data["artifacts"]
+ assert str(checksum) in data["artifacts"]
+ assert (
+ data["manifest"]["brands"][DEFAULT_BRAND_ID]["windows-x64"]["installer"] == installer.name
+ )
+
+
+def test_merge_release_manifests_preserves_existing_platforms():
+ """Test merging platform-specific manifest entries from separate upload runs."""
+ base_manifest = {
+ "version": "0.8.4",
+ "channel": "stable",
+ "brands": {
+ "agravity": {
+ "windows-x64": {
+ "installer": "AgravityBridge-0.8.4-win-x64.msi",
+ "checksum": "AgravityBridge-0.8.4-win-x64.msi.sha256",
+ }
+ }
+ },
+ }
+ overlay_manifest = {
+ "version": "0.8.4",
+ "channel": "stable",
+ "brands": {
+ "agravity": {
+ "macos-universal": {
+ "installer": "AgravityBridge-0.8.4-macos-universal.dmg",
+ "checksum": "AgravityBridge-0.8.4-macos-universal.dmg.sha256",
+ }
+ }
+ },
+ }
+
+ merged = merge_release_manifests(base_manifest, overlay_manifest)
+
+ assert (
+ merged["brands"]["agravity"]["windows-x64"]["installer"]
+ == "AgravityBridge-0.8.4-win-x64.msi"
+ )
+ assert (
+ merged["brands"]["agravity"]["macos-universal"]["installer"]
+ == "AgravityBridge-0.8.4-macos-universal.dmg"
+ )
diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py
index fdeda3d..09e4d6d 100644
--- a/tests/unit/test_config.py
+++ b/tests/unit/test_config.py
@@ -1,6 +1,7 @@
"""Unit tests for configuration system."""
import os
+import sys
import pytest
@@ -12,14 +13,26 @@ def clear_env():
"""Clear environment variables before each test to avoid persistence."""
# Save current env
saved_env = os.environ.copy()
-
+
# Clear relevant variables
for key in list(os.environ.keys()):
- if key.startswith(('APP_', 'LOG_', 'ALLOWED_', 'WEBAPP_', 'WINDOW_', 'ENABLE_')):
+ if key.startswith(
+ (
+ "APP_",
+ "LOG_",
+ "ALLOWED_",
+ "WEBAPP_",
+ "WINDOW_",
+ "ENABLE_",
+ "BRAND_",
+ "UPDATE_",
+ "LANGUAGE",
+ )
+ ):
del os.environ[key]
-
+
yield
-
+
# Restore env (cleanup)
os.environ.clear()
os.environ.update(saved_env)
@@ -64,6 +77,28 @@ class TestConfigFromEnv:
assert config.window_width == 1200
assert config.window_height == 800
+ def test_from_env_with_branding_values(self, tmp_path):
+ """Test loading branding and update metadata from environment."""
+ env_file = tmp_path / ".env"
+ root1 = tmp_path / "root1"
+ root1.mkdir()
+ env_file.write_text(
+ f"BRAND_ID=agravity\n"
+ f"APP_CONFIG_DIR_NAME=agravity_bridge\n"
+ f"UPDATE_REPO=HIM-public/webdrop-bridge\n"
+ f"UPDATE_CHANNEL=stable\n"
+ f"UPDATE_MANIFEST_NAME=release-manifest.json\n"
+ f"ALLOWED_ROOTS={root1}\n"
+ )
+
+ config = Config.from_env(str(env_file))
+
+ assert config.brand_id == "agravity"
+ assert config.config_dir_name == "agravity_bridge"
+ assert config.update_repo == "HIM-public/webdrop-bridge"
+ assert config.update_channel == "stable"
+ assert config.update_manifest_name == "release-manifest.json"
+
def test_from_env_with_defaults(self, tmp_path):
"""Test loading config uses defaults when env vars not set."""
# Create empty .env file
@@ -73,8 +108,11 @@ class TestConfigFromEnv:
config = Config.from_env(str(env_file))
assert config.app_name == "WebDrop Bridge"
+ assert config.brand_id == "webdrop_bridge"
+ assert config.config_dir_name == "webdrop_bridge"
# Version should come from __init__.py (dynamic, not hardcoded)
from webdrop_bridge import __version__
+
assert config.app_version == __version__
assert config.log_level == "INFO"
assert config.window_width == 1024
@@ -187,3 +225,30 @@ class TestConfigValidation:
config = Config.from_env(str(env_file))
assert config.allowed_urls == ["example.com", "test.org"]
+
+ def test_brand_specific_default_paths(self):
+ """Test brand-specific config and log directories."""
+ config_path = Config.get_default_config_path("agravity_bridge")
+ log_path = Config.get_default_log_path("agravity_bridge")
+
+ assert config_path.parts[-2:] == ("agravity_bridge", "config.json")
+ assert log_path.parts[-2:] == ("logs", "agravity_bridge.log")
+
+
+class TestBootstrapEnvLoading:
+ """Test bootstrap .env loading behavior for packaged builds."""
+
+ def test_load_bootstrap_env_reads_meipass_dotenv(self, tmp_path, monkeypatch):
+ """Packaged app should load .env from PyInstaller runtime directory."""
+ meipass_dir = tmp_path / "runtime"
+ meipass_dir.mkdir(parents=True)
+ env_path = meipass_dir / ".env"
+ env_path.write_text("APP_NAME=Agravity Bridge\n", encoding="utf-8")
+
+ monkeypatch.setattr(sys, "frozen", True, raising=False)
+ monkeypatch.setattr(sys, "_MEIPASS", str(meipass_dir), raising=False)
+
+ loaded_path = Config.load_bootstrap_env()
+
+ assert loaded_path == env_path
+ assert os.getenv("APP_NAME") == "Agravity Bridge"
diff --git a/tests/unit/test_drag_interceptor.py b/tests/unit/test_drag_interceptor.py
index 74b262e..c19333f 100644
--- a/tests/unit/test_drag_interceptor.py
+++ b/tests/unit/test_drag_interceptor.py
@@ -82,6 +82,7 @@ class TestDragInterceptorValidation:
mock_drag_instance = MagicMock()
# Simulate successful copy action
from PySide6.QtCore import Qt
+
mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
mock_drag.return_value = mock_drag_instance
@@ -136,7 +137,7 @@ class TestDragInterceptorAzureURL:
url_mappings=[
URLMapping(
url_prefix="https://devagravitystg.file.core.windows.net/devagravitysync/",
- local_path=str(tmp_path)
+ local_path=str(tmp_path),
)
],
check_file_exists=True,
@@ -150,6 +151,7 @@ class TestDragInterceptorAzureURL:
with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
mock_drag_instance = MagicMock()
from PySide6.QtCore import Qt
+
mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
mock_drag.return_value = mock_drag_instance
@@ -196,6 +198,7 @@ class TestDragInterceptorSignals:
interceptor.drag_started.connect(lambda src, path: signal_spy.append((src, path)))
from PySide6.QtCore import Qt
+
with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
mock_drag_instance = MagicMock()
mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
@@ -235,3 +238,234 @@ class TestDragInterceptorSignals:
# Verify result and signal emission
assert result is False
assert len(signal_spy) == 1
+
+
+class TestDragInterceptorMultipleDrags:
+ """Test multiple file drag support."""
+
+ def test_handle_drag_with_list_single_item(self, qtbot, tmp_path):
+ """Test handle_drag with list containing single file path."""
+ test_file = tmp_path / "test.txt"
+ test_file.write_text("content")
+
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
+
+ from PySide6.QtCore import Qt
+
+ with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
+ mock_drag_instance = MagicMock()
+ mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
+ mock_drag.return_value = mock_drag_instance
+
+ result = interceptor.handle_drag([str(test_file)])
+
+ assert result is True
+
+ def test_handle_drag_with_multiple_files(self, qtbot, tmp_path):
+ """Test handle_drag with list of multiple file paths."""
+ # Create multiple test files
+ test_file1 = tmp_path / "test1.txt"
+ test_file1.write_text("content1")
+ test_file2 = tmp_path / "test2.txt"
+ test_file2.write_text("content2")
+ test_file3 = tmp_path / "test3.txt"
+ test_file3.write_text("content3")
+
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
+
+ from PySide6.QtCore import Qt
+
+ with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
+ mock_drag_instance = MagicMock()
+ mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
+ mock_drag.return_value = mock_drag_instance
+
+ result = interceptor.handle_drag(
+ [
+ str(test_file1),
+ str(test_file2),
+ str(test_file3),
+ ]
+ )
+
+ assert result is True
+
+ def test_handle_drag_with_multiple_azure_urls(self, qtbot, tmp_path):
+ """Test handle_drag with list of multiple Azure URLs."""
+ from webdrop_bridge.config import URLMapping
+
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[
+ URLMapping(
+ url_prefix="https://produktagravitystg.file.core.windows.net/produktagravitysync/",
+ local_path=str(tmp_path),
+ )
+ ],
+ check_file_exists=False, # Don't check file existence for this test
+ )
+ interceptor = DragInterceptor(config)
+
+ # Multiple Azure URLs (as would be in a multi-drag)
+ azure_urls = [
+ "https://produktagravitystg.file.core.windows.net/produktagravitysync/axtZdPVjs5iUaKU2muKMFN1WZ/igkjieyjcko.jpg",
+ "https://produktagravitystg.file.core.windows.net/produktagravitysync/aWd7mDjnsm2w0PHU9AryQBYz2/457101023fd46d673e2ce6642f78fb0d62736f0f06c7.jpg",
+ ]
+
+ from PySide6.QtCore import Qt
+
+ with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
+ mock_drag_instance = MagicMock()
+ mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
+ mock_drag.return_value = mock_drag_instance
+
+ result = interceptor.handle_drag(azure_urls)
+
+ assert result is True
+ # Verify QDrag.exec was called (meaning drag was set up correctly)
+ mock_drag_instance.exec.assert_called_once()
+
+ def test_handle_drag_mixed_urls_and_paths(self, qtbot, tmp_path):
+ """Test handle_drag with mixed Azure URLs and local paths."""
+ from webdrop_bridge.config import URLMapping
+
+ # Create test file
+ test_file = tmp_path / "local_file.txt"
+ test_file.write_text("local content")
+
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[
+ URLMapping(
+ url_prefix="https://devagravitystg.file.core.windows.net/devagravitysync/",
+ local_path=str(tmp_path),
+ )
+ ],
+ check_file_exists=False, # Don't check existence for remote files
+ )
+ interceptor = DragInterceptor(config)
+
+ mixed_items = [
+ str(test_file), # local path
+ "https://devagravitystg.file.core.windows.net/devagravitysync/remote.jpg", # Azure URL
+ ]
+
+ from PySide6.QtCore import Qt
+
+ with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
+ mock_drag_instance = MagicMock()
+ mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
+ mock_drag.return_value = mock_drag_instance
+
+ result = interceptor.handle_drag(mixed_items)
+
+ assert result is True
+
+ def test_handle_drag_multiple_empty_list(self, qtbot, test_config):
+ """Test handle_drag with empty list fails."""
+ interceptor = DragInterceptor(test_config)
+
+ with qtbot.waitSignal(interceptor.drag_failed):
+ result = interceptor.handle_drag([])
+
+ assert result is False
+
+ def test_handle_drag_multiple_one_invalid_fails(self, qtbot, tmp_path):
+ """Test handle_drag with multiple files fails if one is invalid."""
+ test_file1 = tmp_path / "test1.txt"
+ test_file1.write_text("content1")
+
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
+
+ # One valid, one invalid
+ files = [
+ str(test_file1),
+ "/etc/passwd", # Invalid - outside allowed roots
+ ]
+
+ with qtbot.waitSignal(interceptor.drag_failed):
+ result = interceptor.handle_drag(files)
+
+ assert result is False
+
+ def test_handle_drag_multiple_signal_with_pipes(self, qtbot, tmp_path):
+ """Test drag_started signal contains pipe-separated paths for multiple files."""
+ test_file1 = tmp_path / "test1.txt"
+ test_file1.write_text("content1")
+ test_file2 = tmp_path / "test2.txt"
+ test_file2.write_text("content2")
+
+ config = Config(
+ app_name="Test",
+ app_version="1.0.0",
+ log_level="INFO",
+ log_file=None,
+ allowed_roots=[tmp_path],
+ allowed_urls=[],
+ webapp_url="https://test.com/",
+ url_mappings=[],
+ check_file_exists=True,
+ )
+ interceptor = DragInterceptor(config)
+
+ signal_spy = []
+ interceptor.drag_started.connect(lambda src, path: signal_spy.append((src, path)))
+
+ from PySide6.QtCore import Qt
+
+ with patch("webdrop_bridge.core.drag_interceptor.QDrag") as mock_drag:
+ mock_drag_instance = MagicMock()
+ mock_drag_instance.exec.return_value = Qt.DropAction.CopyAction
+ mock_drag.return_value = mock_drag_instance
+
+ result = interceptor.handle_drag([str(test_file1), str(test_file2)])
+
+ assert result is True
+ assert len(signal_spy) == 1
+ # Multiple paths should be separated by " | "
+ assert " | " in signal_spy[0][1]
diff --git a/tests/unit/test_i18n.py b/tests/unit/test_i18n.py
new file mode 100644
index 0000000..b52da9d
--- /dev/null
+++ b/tests/unit/test_i18n.py
@@ -0,0 +1,60 @@
+"""Unit tests for i18n translation helper."""
+
+import json
+from pathlib import Path
+
+from webdrop_bridge.utils import i18n
+
+
+class TestI18n:
+ """Tests for translation lookup and fallback behavior."""
+
+ def test_tr_lazy_initialization_uses_english_defaults(self):
+ """Translator should lazily initialize and resolve known keys."""
+ # Force a fresh singleton state for this test.
+ i18n._translator = i18n.Translator() # type: ignore[attr-defined]
+
+ assert i18n.tr("settings.title") == "Settings"
+
+ def test_initialize_with_language_falls_back_to_english(self, tmp_path: Path):
+ """Missing keys in selected language should fall back to English."""
+ translations = tmp_path / "translations"
+ translations.mkdir(parents=True, exist_ok=True)
+
+ (translations / "en.json").write_text(
+ json.dumps(
+ {
+ "greeting": "Hello {name}",
+ "settings.title": "Settings",
+ }
+ ),
+ encoding="utf-8",
+ )
+ (translations / "de.json").write_text(
+ json.dumps(
+ {
+ "settings.title": "Einstellungen",
+ }
+ ),
+ encoding="utf-8",
+ )
+
+ i18n._translator = i18n.Translator() # type: ignore[attr-defined]
+ i18n.initialize("de", translations)
+
+ assert i18n.tr("settings.title") == "Einstellungen"
+ assert i18n.tr("greeting", name="Alex") == "Hello Alex"
+
+ def test_get_available_languages_reads_translation_files(self, tmp_path: Path):
+ """Available languages should be discovered from JSON files."""
+ translations = tmp_path / "translations"
+ translations.mkdir(parents=True, exist_ok=True)
+ (translations / "en.json").write_text("{}", encoding="utf-8")
+ (translations / "fr.json").write_text("{}", encoding="utf-8")
+
+ i18n._translator = i18n.Translator() # type: ignore[attr-defined]
+ i18n.initialize("en", translations)
+
+ available = i18n.get_available_languages()
+ assert "en" in available
+ assert "fr" in available
diff --git a/tests/unit/test_main_window.py b/tests/unit/test_main_window.py
index 72a53d3..161be8a 100644
--- a/tests/unit/test_main_window.py
+++ b/tests/unit/test_main_window.py
@@ -82,136 +82,6 @@ class TestMainWindowInitialization:
assert window.drag_interceptor is not None
-class TestMainWindowNavigation:
- """Test navigation toolbar and functionality."""
-
- def test_navigation_toolbar_created(self, qtbot, sample_config):
- """Test navigation toolbar is created."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- toolbars = window.findChildren(QToolBar)
- assert len(toolbars) > 0
-
- def test_navigation_toolbar_not_movable(self, qtbot, sample_config):
- """Test navigation toolbar is not movable (locked for Kiosk-mode)."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- toolbar = window.findChild(QToolBar)
- assert toolbar is not None
- assert not toolbar.isMovable()
-
- def test_navigate_home(self, qtbot, sample_config):
- """Test home button navigation."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- with patch.object(window.web_view, "load") as mock_load:
- window._navigate_home()
- mock_load.assert_called_once()
-
- def test_navigate_home_with_http_url(self, qtbot, tmp_path):
- """Test home navigation with HTTP URL."""
- config = Config(
- app_name="Test",
- app_version="1.0.0",
- log_level="INFO",
- log_file=None,
- allowed_roots=[tmp_path],
- allowed_urls=[],
- webapp_url="http://localhost:8000",
- window_width=800,
- window_height=600,
- enable_logging=False,
- )
-
- window = MainWindow(config)
- qtbot.addWidget(window)
-
- with patch.object(window.web_view, "load") as mock_load:
- window._navigate_home()
-
- # Verify load was called with HTTP URL
- call_args = mock_load.call_args
- url = call_args[0][0]
- assert url.scheme() == "http"
-
- def test_navigate_home_with_file_url(self, qtbot, sample_config):
- """Test home navigation with file:// URL."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- with patch.object(window.web_view, "load") as mock_load:
- window._navigate_home()
-
- call_args = mock_load.call_args
- url = call_args[0][0]
- assert url.scheme() == "file"
-
-
-class TestMainWindowWebAppLoading:
- """Test web application loading."""
-
- def test_load_local_webapp_file(self, qtbot, sample_config):
- """Test loading local webapp file."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- # Window should load without errors
- assert window.web_view is not None
-
- def test_load_remote_webapp_url(self, qtbot, tmp_path):
- """Test loading remote webapp URL."""
- config = Config(
- app_name="Test",
- app_version="1.0.0",
- log_level="INFO",
- log_file=None,
- allowed_roots=[tmp_path],
- allowed_urls=["localhost"],
- webapp_url="http://localhost:3000",
- window_width=800,
- window_height=600,
- enable_logging=False,
- )
-
- window = MainWindow(config)
- qtbot.addWidget(window)
-
- assert window.web_view is not None
-
- def test_load_nonexistent_file_shows_welcome_page(self, qtbot, tmp_path):
- """Test loading nonexistent file shows welcome page HTML."""
- config = Config(
- app_name="Test",
- app_version="1.0.0",
- log_level="INFO",
- log_file=None,
- allowed_roots=[tmp_path],
- allowed_urls=[],
- webapp_url="/nonexistent/file.html",
- window_width=800,
- window_height=600,
- enable_logging=False,
- )
-
- with patch.object(config, "webapp_url", "/nonexistent/file.html"):
- window = MainWindow(config)
- qtbot.addWidget(window)
-
- with patch.object(
- window.web_view, "setHtml"
- ) as mock_set_html:
- window._load_webapp()
- mock_set_html.assert_called_once()
-
- # Verify welcome page is shown instead of error
- call_args = mock_set_html.call_args[0][0]
- assert "WebDrop Bridge" in call_args
- assert "Application Ready" in call_args
-
-
class TestMainWindowDragIntegration:
"""Test drag-and-drop integration."""
@@ -231,12 +101,10 @@ class TestMainWindowDragIntegration:
assert window.drag_interceptor.drag_started is not None
assert window.drag_interceptor.drag_failed is not None
- def test_handle_drag_delegates_to_interceptor(
- self, qtbot, sample_config, tmp_path
- ):
+ def test_handle_drag_delegates_to_interceptor(self, qtbot, sample_config, tmp_path):
"""Test drag handling delegates to interceptor."""
from PySide6.QtCore import QCoreApplication
-
+
window = MainWindow(sample_config)
qtbot.addWidget(window)
@@ -244,13 +112,11 @@ class TestMainWindowDragIntegration:
test_file = sample_config.allowed_roots[0] / "test.txt"
test_file.write_text("test")
- with patch.object(
- window.drag_interceptor, "handle_drag"
- ) as mock_drag:
+ with patch.object(window.drag_interceptor, "handle_drag") as mock_drag:
mock_drag.return_value = True
# Call through bridge
window._drag_bridge.start_file_drag(str(test_file))
-
+
# Process deferred QTimer.singleShot(0, ...) call
QCoreApplication.processEvents()
@@ -276,9 +142,7 @@ class TestMainWindowDragIntegration:
class TestMainWindowURLWhitelist:
"""Test URL whitelisting integration."""
- def test_restricted_web_view_receives_allowed_urls(
- self, qtbot, sample_config
- ):
+ def test_restricted_web_view_receives_allowed_urls(self, qtbot, sample_config):
"""Test RestrictedWebEngineView receives allowed URLs from config."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
@@ -286,268 +150,73 @@ class TestMainWindowURLWhitelist:
# web_view should have allowed_urls configured
assert window.web_view.allowed_urls == sample_config.allowed_urls
- def test_empty_allowed_urls_list(self, qtbot, tmp_path):
- """Test with empty allowed URLs (no restriction)."""
- config = Config(
- app_name="Test",
- app_version="1.0.0",
- log_level="INFO",
- log_file=None,
- allowed_roots=[tmp_path],
- allowed_urls=[], # Empty = no restriction
- webapp_url="http://localhost",
- window_width=800,
- window_height=600,
- enable_logging=False,
- )
- window = MainWindow(config)
- qtbot.addWidget(window)
+class TestMainWindowOpenWith:
+ """Test Open With chooser behavior."""
- assert window.web_view.allowed_urls == []
-
-
-class TestMainWindowSignals:
- """Test signal connections."""
-
- def test_drag_started_signal_connection(self, qtbot, sample_config):
- """Test drag_started signal is connected to handler."""
+ def test_open_with_app_chooser_windows(self, qtbot, sample_config):
+ """Windows should use ShellExecuteW with the openas verb."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- with patch.object(window, "_on_drag_started") as mock_handler:
- window.drag_interceptor.drag_started.emit(["/path/to/file"])
- mock_handler.assert_called_once()
+ test_file = sample_config.allowed_roots[0] / "open_with_test.txt"
+ test_file.write_text("test")
- def test_drag_failed_signal_connection(self, qtbot, sample_config):
- """Test drag_failed signal is connected to handler."""
+ with patch("webdrop_bridge.ui.main_window.sys.platform", "win32"):
+ with patch("ctypes.windll.shell32.ShellExecuteW", return_value=33) as mock_shell:
+ assert window._open_with_app_chooser(str(test_file)) is True
+ mock_shell.assert_called_once_with(
+ None,
+ "openas",
+ str(test_file),
+ None,
+ None,
+ 1,
+ )
+
+ def test_open_with_app_chooser_windows_shellexecute_failure(self, qtbot, sample_config):
+ """Windows should fall back to OpenAs_RunDLL when ShellExecuteW fails."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- with patch.object(window, "_on_drag_failed") as mock_handler:
- window.drag_interceptor.drag_failed.emit("Error message")
- mock_handler.assert_called_once()
+ test_file = sample_config.allowed_roots[0] / "open_with_fallback.txt"
+ test_file.write_text("test")
+ with patch("webdrop_bridge.ui.main_window.sys.platform", "win32"):
+ with patch("ctypes.windll.shell32.ShellExecuteW", return_value=31):
+ with patch("webdrop_bridge.ui.main_window.subprocess.Popen") as mock_popen:
+ assert window._open_with_app_chooser(str(test_file)) is True
+ mock_popen.assert_called_once_with(
+ ["rundll32.exe", "shell32.dll,OpenAs_RunDLL", str(test_file)]
+ )
-class TestMainWindowMenuBar:
- """Test toolbar help actions integration."""
-
- def test_navigation_toolbar_created(self, qtbot, sample_config):
- """Test navigation toolbar is created with help buttons."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- # Check that toolbar exists
- assert len(window.findChildren(QToolBar)) > 0
- toolbar = window.findChildren(QToolBar)[0]
- assert toolbar is not None
-
- def test_window_has_check_for_updates_signal(self, qtbot, sample_config):
- """Test window has check_for_updates signal."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- # Test that signal exists
- assert hasattr(window, "check_for_updates")
-
- # Test that signal is callable (can be emitted)
- assert callable(window.check_for_updates.emit)
-
- def test_on_check_for_updates_method_exists(self, qtbot, sample_config):
- """Test _on_manual_check_for_updates method exists."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- # Test that the method exists
- assert hasattr(window, "_on_manual_check_for_updates")
- assert callable(window._on_manual_check_for_updates)
-
- def test_show_about_dialog_method_exists(self, qtbot, sample_config):
- """Test _show_about_dialog method exists."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- # Test that the method exists
- assert hasattr(window, "_show_about_dialog")
- assert callable(window._show_about_dialog)
-
-
-class TestMainWindowStatusBar:
- """Test status bar and update status."""
-
- def test_status_bar_created(self, qtbot, sample_config):
- """Test status bar is created."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- assert window.statusBar() is not None
- assert hasattr(window, "status_bar")
-
- def test_update_status_label_created(self, qtbot, sample_config):
- """Test update status label exists."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- assert hasattr(window, "update_status_label")
- assert window.update_status_label is not None
-
- def test_set_update_status_text_only(self, qtbot, sample_config):
- """Test setting update status with text only."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- window.set_update_status("Checking for updates")
- assert "Checking for updates" in window.update_status_label.text()
-
- def test_set_update_status_with_emoji(self, qtbot, sample_config):
- """Test setting update status with emoji."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- window.set_update_status("Checking", emoji="🔄")
- assert "🔄" in window.update_status_label.text()
- assert "Checking" in window.update_status_label.text()
-
- def test_set_update_status_checking(self, qtbot, sample_config):
- """Test checking for updates status."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- window.set_update_status("Checking for updates", emoji="🔄")
- assert "🔄" in window.update_status_label.text()
-
- def test_set_update_status_available(self, qtbot, sample_config):
- """Test update available status."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- window.set_update_status("Update available v0.0.2", emoji="✅")
- assert "✅" in window.update_status_label.text()
-
- def test_set_update_status_downloading(self, qtbot, sample_config):
- """Test downloading status."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- window.set_update_status("Downloading update", emoji="⬇️")
- assert "⬇️" in window.update_status_label.text()
-
- def test_set_update_status_error(self, qtbot, sample_config):
- """Test error status."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- window.set_update_status("Update check failed", emoji="⚠️")
- assert "⚠️" in window.update_status_label.text()
-
-
-class TestMainWindowStylesheet:
- """Test stylesheet application."""
-
- def test_stylesheet_loading_gracefully_handles_missing_file(
- self, qtbot, sample_config
- ):
- """Test missing stylesheet doesn't crash application."""
+ def test_open_with_app_chooser_missing_file(self, qtbot, sample_config):
+ """Missing files should fail before platform-specific invocation."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- # Should not raise even if stylesheet missing
- window._apply_stylesheet()
+ with patch("webdrop_bridge.ui.main_window.sys.platform", "win32"):
+ assert window._open_with_app_chooser("C:/tmp/does_not_exist.txt") is False
- def test_stylesheet_loading_with_nonexistent_file(
- self, qtbot, sample_config
- ):
- """Test stylesheet loading with nonexistent file path."""
+ def test_open_with_app_chooser_macos_success(self, qtbot, sample_config):
+ """macOS should return True when osascript exits successfully."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- with patch("builtins.open", side_effect=OSError("File not found")):
- # Should handle gracefully
- window._apply_stylesheet()
+ test_file = sample_config.allowed_roots[0] / "open_with_macos.txt"
+ test_file.write_text("test")
+ class _Result:
+ returncode = 0
-class TestMainWindowCloseEvent:
- """Test window close handling."""
+ with patch("webdrop_bridge.ui.main_window.sys.platform", "darwin"):
+ with patch("webdrop_bridge.ui.main_window.subprocess.run", return_value=_Result()):
+ assert window._open_with_app_chooser(str(test_file)) is True
- def test_close_event_accepted(self, qtbot, sample_config):
- """Test close event is accepted."""
+ def test_open_with_app_chooser_unsupported_platform(self, qtbot, sample_config):
+ """Unsupported platforms should return False."""
window = MainWindow(sample_config)
qtbot.addWidget(window)
- from PySide6.QtGui import QCloseEvent
-
- event = QCloseEvent()
- window.closeEvent(event)
-
- assert event.isAccepted()
-
-
-class TestMainWindowIntegration:
- """Integration tests for MainWindow with all components."""
-
- def test_full_initialization_flow(self, qtbot, sample_config):
- """Test complete initialization flow."""
- window = MainWindow(sample_config)
- qtbot.addWidget(window)
-
- # Verify all components initialized
- assert window.web_view is not None
- assert window.drag_interceptor is not None
- assert window.config == sample_config
-
- # Verify toolbar exists
- toolbars = window.findChildren(QToolBar)
- assert len(toolbars) > 0
-
- def test_window_with_multiple_allowed_roots(self, qtbot, tmp_path):
- """Test MainWindow with multiple allowed root directories."""
- root1 = tmp_path / "root1"
- root2 = tmp_path / "root2"
- root1.mkdir()
- root2.mkdir()
-
- webapp_file = tmp_path / "index.html"
- webapp_file.write_text("")
-
- config = Config(
- app_name="Test",
- app_version="1.0.0",
- log_level="INFO",
- log_file=None,
- allowed_roots=[root1, root2],
- allowed_urls=[],
- webapp_url=str(webapp_file),
- window_width=800,
- window_height=600,
- enable_logging=False,
- )
-
- window = MainWindow(config)
- qtbot.addWidget(window)
-
- # Verify validator has both roots
- assert window.drag_interceptor._validator is not None
- assert len(
- window.drag_interceptor._validator.allowed_roots
- ) == 2
-
- def test_window_with_url_whitelist(self, qtbot, tmp_path):
- """Test MainWindow respects URL whitelist."""
- config = Config(
- app_name="Test",
- app_version="1.0.0",
- log_level="INFO",
- log_file=None,
- allowed_roots=[tmp_path],
- allowed_urls=["*.example.com", "localhost"],
- webapp_url="http://localhost",
- window_width=800,
- window_height=600,
- enable_logging=False,
- )
-
- window = MainWindow(config)
- qtbot.addWidget(window)
-
- # Verify whitelist is set
- assert window.web_view.allowed_urls == ["*.example.com", "localhost"]
+ with patch("webdrop_bridge.ui.main_window.sys.platform", "linux"):
+ assert window._open_with_app_chooser("/tmp/test.txt") is False
diff --git a/tests/unit/test_restricted_web_view.py b/tests/unit/test_restricted_web_view.py
index cd6ca95..fc2ee8f 100644
--- a/tests/unit/test_restricted_web_view.py
+++ b/tests/unit/test_restricted_web_view.py
@@ -8,6 +8,20 @@ from PySide6.QtWebEngineCore import QWebEngineNavigationRequest
from webdrop_bridge.ui.restricted_web_view import RestrictedWebEngineView
+def _create_mock_request(url: str) -> MagicMock:
+ """Create properly mocked navigation request.
+
+ Args:
+ url: URL string to mock
+
+ Returns:
+ Properly mocked QWebEngineNavigationRequest
+ """
+ request = MagicMock(spec=QWebEngineNavigationRequest)
+ request.url = MagicMock(return_value=QUrl(url))
+ return request
+
+
class TestRestrictedWebEngineView:
"""Test URL whitelist enforcement."""
@@ -16,8 +30,7 @@ class TestRestrictedWebEngineView:
view = RestrictedWebEngineView([])
# Mock navigation request
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://example.com/page")
+ request = _create_mock_request("https://example.com/page")
# Should not reject any URL
view._on_navigation_requested(request)
@@ -27,8 +40,7 @@ class TestRestrictedWebEngineView:
"""Test that None allowed_urls means no restrictions."""
view = RestrictedWebEngineView(None)
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://blocked.com/page")
+ request = _create_mock_request("https://blocked.com/page")
view._on_navigation_requested(request)
request.reject.assert_not_called()
@@ -37,8 +49,7 @@ class TestRestrictedWebEngineView:
"""Test exact domain matching."""
view = RestrictedWebEngineView(["example.com"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://example.com/page")
+ request = _create_mock_request("https://example.com/page")
view._on_navigation_requested(request)
request.reject.assert_not_called()
@@ -47,8 +58,7 @@ class TestRestrictedWebEngineView:
"""Test that mismatched domains are rejected."""
view = RestrictedWebEngineView(["example.com"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://other.com/page")
+ request = _create_mock_request("https://other.com/page")
with patch("webdrop_bridge.ui.restricted_web_view.QDesktopServices"):
view._on_navigation_requested(request)
@@ -58,8 +68,7 @@ class TestRestrictedWebEngineView:
"""Test wildcard pattern matching."""
view = RestrictedWebEngineView(["*.example.com"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://sub.example.com/page")
+ request = _create_mock_request("https://sub.example.com/page")
view._on_navigation_requested(request)
request.reject.assert_not_called()
@@ -68,8 +77,7 @@ class TestRestrictedWebEngineView:
"""Test that non-matching wildcard patterns are rejected."""
view = RestrictedWebEngineView(["*.example.com"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://example.org/page")
+ request = _create_mock_request("https://example.org/page")
with patch("webdrop_bridge.ui.restricted_web_view.QDesktopServices"):
view._on_navigation_requested(request)
@@ -79,8 +87,7 @@ class TestRestrictedWebEngineView:
"""Test that localhost is allowed."""
view = RestrictedWebEngineView(["localhost"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("http://localhost:8000/page")
+ request = _create_mock_request("http://localhost:8000/page")
view._on_navigation_requested(request)
request.reject.assert_not_called()
@@ -89,8 +96,7 @@ class TestRestrictedWebEngineView:
"""Test that file:// URLs are always allowed."""
view = RestrictedWebEngineView(["example.com"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("file:///var/www/index.html")
+ request = _create_mock_request("file:///var/www/index.html")
view._on_navigation_requested(request)
request.reject.assert_not_called()
@@ -100,20 +106,17 @@ class TestRestrictedWebEngineView:
view = RestrictedWebEngineView(["example.com", "test.org"])
# First allowed URL
- request1 = MagicMock(spec=QWebEngineNavigationRequest)
- request1.url = QUrl("https://example.com/page")
+ request1 = _create_mock_request("https://example.com/page")
view._on_navigation_requested(request1)
request1.reject.assert_not_called()
# Second allowed URL
- request2 = MagicMock(spec=QWebEngineNavigationRequest)
- request2.url = QUrl("https://test.org/page")
+ request2 = _create_mock_request("https://test.org/page")
view._on_navigation_requested(request2)
request2.reject.assert_not_called()
# Non-allowed URL
- request3 = MagicMock(spec=QWebEngineNavigationRequest)
- request3.url = QUrl("https://blocked.com/page")
+ request3 = _create_mock_request("https://blocked.com/page")
with patch("webdrop_bridge.ui.restricted_web_view.QDesktopServices"):
view._on_navigation_requested(request3)
request3.reject.assert_called_once()
@@ -122,15 +125,13 @@ class TestRestrictedWebEngineView:
"""Test that rejected URLs open in system browser."""
view = RestrictedWebEngineView(["allowed.com"])
- request = MagicMock(spec=QWebEngineNavigationRequest)
- request.url = QUrl("https://blocked.com/page")
+ request = _create_mock_request("https://blocked.com/page")
- with patch(
- "webdrop_bridge.ui.restricted_web_view.QDesktopServices.openUrl"
- ) as mock_open:
+ with patch("webdrop_bridge.ui.restricted_web_view.QDesktopServices.openUrl") as mock_open:
view._on_navigation_requested(request)
request.reject.assert_called_once()
- mock_open.assert_called_once_with(request.url)
+ # Check that openUrl was called with a QUrl
+ mock_open.assert_called_once()
class TestURLAllowedLogic:
@@ -167,12 +168,12 @@ class TestURLAllowedLogic:
# Wildcard *.example.com will match sub.example.com
assert view._is_url_allowed(QUrl("https://sub.example.com/page")) is True
-
+
# *.example.com will also match example.com (fnmatch behavior)
assert view._is_url_allowed(QUrl("https://example.com/page")) is True
-
+
# But not other domains
assert view._is_url_allowed(QUrl("https://other.org/page")) is False
-
+
# localhost should work
assert view._is_url_allowed(QUrl("http://localhost:3000")) is True
diff --git a/tests/unit/test_settings_dialog.py b/tests/unit/test_settings_dialog.py
index 332d63d..06d78d0 100644
--- a/tests/unit/test_settings_dialog.py
+++ b/tests/unit/test_settings_dialog.py
@@ -34,7 +34,7 @@ class TestSettingsDialogInitialization:
"""Test dialog can be created."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog is not None
assert dialog.windowTitle() == "Settings"
@@ -42,44 +42,58 @@ class TestSettingsDialogInitialization:
"""Test dialog has all required tabs."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.tabs is not None
- assert dialog.tabs.count() == 5 # Paths, URLs, Logging, Window, Profiles
+ assert dialog.tabs.count() == 7 # General + previous 6 tabs
+
+ def test_dialog_has_general_tab(self, qtbot, sample_config):
+ """Test General tab exists."""
+ dialog = SettingsDialog(sample_config)
+ qtbot.addWidget(dialog)
+
+ assert dialog.tabs.tabText(0) == "General"
+
+ def test_dialog_has_web_source_tab(self, qtbot, sample_config):
+ """Test Web Source tab exists."""
+ dialog = SettingsDialog(sample_config)
+ qtbot.addWidget(dialog)
+
+ assert dialog.tabs.tabText(1) == "Web Source"
def test_dialog_has_paths_tab(self, qtbot, sample_config):
"""Test Paths tab exists."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
- assert dialog.tabs.tabText(0) == "Paths"
+
+ assert dialog.tabs.tabText(2) == "Paths"
def test_dialog_has_urls_tab(self, qtbot, sample_config):
"""Test URLs tab exists."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
- assert dialog.tabs.tabText(1) == "URLs"
+
+ assert dialog.tabs.tabText(3) == "URLs"
def test_dialog_has_logging_tab(self, qtbot, sample_config):
"""Test Logging tab exists."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
- assert dialog.tabs.tabText(2) == "Logging"
+
+ assert dialog.tabs.tabText(4) == "Logging"
def test_dialog_has_window_tab(self, qtbot, sample_config):
"""Test Window tab exists."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
- assert dialog.tabs.tabText(3) == "Window"
+
+ assert dialog.tabs.tabText(5) == "Window"
def test_dialog_has_profiles_tab(self, qtbot, sample_config):
"""Test Profiles tab exists."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
- assert dialog.tabs.tabText(4) == "Profiles"
+
+ assert dialog.tabs.tabText(6) == "Profiles"
class TestPathsTab:
@@ -89,7 +103,7 @@ class TestPathsTab:
"""Test paths are loaded from configuration."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
items = [dialog.paths_list.item(i).text() for i in range(dialog.paths_list.count())]
assert len(items) == 2
# Paths are normalized (backslashes on Windows)
@@ -100,7 +114,7 @@ class TestPathsTab:
"""Test Add Path button exists."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.tabs.currentWidget() is not None
@@ -111,7 +125,7 @@ class TestURLsTab:
"""Test URLs are loaded from configuration."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
items = [dialog.urls_list.item(i).text() for i in range(dialog.urls_list.count())]
assert len(items) == 2
assert "http://example.com" in items
@@ -125,14 +139,14 @@ class TestLoggingTab:
"""Test log level is set from configuration."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.log_level_combo.currentText() == "INFO"
def test_log_levels_available(self, qtbot, sample_config):
"""Test all log levels are available."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
levels = [dialog.log_level_combo.itemText(i) for i in range(dialog.log_level_combo.count())]
assert "DEBUG" in levels
assert "INFO" in levels
@@ -148,21 +162,21 @@ class TestWindowTab:
"""Test window width is set from configuration."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.width_spin.value() == 800
def test_window_height_set_from_config(self, qtbot, sample_config):
"""Test window height is set from configuration."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.height_spin.value() == 600
def test_window_width_has_min_max(self, qtbot, sample_config):
"""Test window width spinbox has min/max."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.width_spin.minimum() == 400
assert dialog.width_spin.maximum() == 5000
@@ -170,7 +184,7 @@ class TestWindowTab:
"""Test window height spinbox has min/max."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.height_spin.minimum() == 300
assert dialog.height_spin.maximum() == 5000
@@ -182,7 +196,7 @@ class TestProfilesTab:
"""Test profiles list is initialized."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
assert dialog.profiles_list is not None
@@ -193,9 +207,9 @@ class TestConfigDataRetrieval:
"""Test retrieving configuration data from dialog."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
config_data = dialog.get_config_data()
-
+
assert config_data["app_name"] == "WebDrop Bridge"
assert config_data["log_level"] == "INFO"
assert config_data["window_width"] == 800
@@ -205,7 +219,7 @@ class TestConfigDataRetrieval:
"""Test get_config_data returns valid configuration data."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
# All default values are valid
config_data = dialog.get_config_data()
assert config_data is not None
@@ -215,14 +229,14 @@ class TestConfigDataRetrieval:
"""Test get_config_data returns modified values."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
# Modify values
dialog.width_spin.setValue(1024)
dialog.height_spin.setValue(768)
dialog.log_level_combo.setCurrentText("DEBUG")
-
+
config_data = dialog.get_config_data()
-
+
assert config_data["window_width"] == 1024
assert config_data["window_height"] == 768
assert config_data["log_level"] == "DEBUG"
@@ -235,7 +249,7 @@ class TestApplyConfigData:
"""Test applying config data updates paths."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
new_config = {
"app_name": "Test",
"app_version": "1.0.0",
@@ -248,9 +262,9 @@ class TestApplyConfigData:
"window_height": 600,
"enable_logging": True,
}
-
+
dialog._apply_config_data(new_config)
-
+
items = [dialog.paths_list.item(i).text() for i in range(dialog.paths_list.count())]
assert "/new/path" in items
assert "/another/path" in items
@@ -259,7 +273,7 @@ class TestApplyConfigData:
"""Test applying config data updates URLs."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
new_config = {
"app_name": "Test",
"app_version": "1.0.0",
@@ -272,9 +286,9 @@ class TestApplyConfigData:
"window_height": 600,
"enable_logging": True,
}
-
+
dialog._apply_config_data(new_config)
-
+
items = [dialog.urls_list.item(i).text() for i in range(dialog.urls_list.count())]
assert "http://new.com" in items
assert "http://test.org" in items
@@ -283,7 +297,7 @@ class TestApplyConfigData:
"""Test applying config data updates window size."""
dialog = SettingsDialog(sample_config)
qtbot.addWidget(dialog)
-
+
new_config = {
"app_name": "Test",
"app_version": "1.0.0",
@@ -296,8 +310,8 @@ class TestApplyConfigData:
"window_height": 1024,
"enable_logging": True,
}
-
+
dialog._apply_config_data(new_config)
-
+
assert dialog.width_spin.value() == 1280
assert dialog.height_spin.value() == 1024
diff --git a/tests/unit/test_update_manager_ui.py b/tests/unit/test_update_manager_ui.py
index 23f5d3e..99083fd 100644
--- a/tests/unit/test_update_manager_ui.py
+++ b/tests/unit/test_update_manager_ui.py
@@ -76,24 +76,17 @@ class TestUpdateAvailableDialog:
def test_signals_emitted_update_now(self, qapp, qtbot):
"""Test update now signal is emitted."""
dialog = UpdateAvailableDialog("0.0.2", "Changes")
-
+
with qtbot.waitSignal(dialog.update_now):
dialog.update_now_btn.click()
def test_signals_emitted_update_later(self, qapp, qtbot):
"""Test update later signal is emitted."""
dialog = UpdateAvailableDialog("0.0.2", "Changes")
-
+
with qtbot.waitSignal(dialog.update_later):
dialog.update_later_btn.click()
- def test_signals_emitted_skip(self, qapp, qtbot):
- """Test skip version signal is emitted."""
- dialog = UpdateAvailableDialog("0.0.2", "Changes")
-
- with qtbot.waitSignal(dialog.skip_version):
- dialog.skip_btn.click()
-
class TestDownloadingDialog:
"""Tests for DownloadingDialog."""
@@ -134,7 +127,7 @@ class TestDownloadingDialog:
def test_cancel_signal(self, qapp, qtbot):
"""Test cancel signal is emitted."""
dialog = DownloadingDialog()
-
+
with qtbot.waitSignal(dialog.cancel_download):
dialog.cancel_btn.click()
@@ -156,7 +149,7 @@ class TestInstallDialog:
def test_install_signal(self, qapp, qtbot):
"""Test install signal is emitted."""
dialog = InstallDialog()
-
+
with qtbot.waitSignal(dialog.install_now):
dialog.install_btn.click()
@@ -211,13 +204,13 @@ class TestErrorDialog:
def test_retry_signal(self, qapp, qtbot):
"""Test retry signal is emitted."""
dialog = ErrorDialog("Error")
-
+
with qtbot.waitSignal(dialog.retry):
dialog.retry_btn.click()
def test_manual_download_signal(self, qapp, qtbot):
"""Test manual download signal is emitted."""
dialog = ErrorDialog("Error")
-
+
with qtbot.waitSignal(dialog.manual_download):
dialog.manual_btn.click()
diff --git a/tests/unit/test_updater.py b/tests/unit/test_updater.py
index 40d4a59..db57ebc 100644
--- a/tests/unit/test_updater.py
+++ b/tests/unit/test_updater.py
@@ -16,6 +16,17 @@ def update_manager(tmp_path):
return UpdateManager(current_version="0.0.1", config_dir=tmp_path)
+@pytest.fixture
+def agravity_update_manager(tmp_path):
+ """Create a brand-aware UpdateManager instance for Agravity Bridge."""
+ return UpdateManager(
+ current_version="0.0.1",
+ config_dir=tmp_path,
+ brand_id="agravity",
+ update_channel="stable",
+ )
+
+
@pytest.fixture
def sample_release():
"""Sample release data from API."""
@@ -166,9 +177,7 @@ class TestCheckForUpdates:
@pytest.mark.asyncio
@patch.object(UpdateManager, "_fetch_release")
- async def test_check_for_updates_no_update(
- self, mock_fetch, update_manager
- ):
+ async def test_check_for_updates_no_update(self, mock_fetch, update_manager):
"""Test no update available."""
mock_fetch.return_value = {
"tag_name": "v0.0.1",
@@ -184,9 +193,7 @@ class TestCheckForUpdates:
@pytest.mark.asyncio
@patch.object(UpdateManager, "_fetch_release")
- async def test_check_for_updates_uses_cache(
- self, mock_fetch, update_manager, sample_release
- ):
+ async def test_check_for_updates_uses_cache(self, mock_fetch, update_manager, sample_release):
"""Test cache is used on subsequent calls."""
mock_fetch.return_value = sample_release
@@ -207,9 +214,7 @@ class TestDownloading:
"""Test update downloading."""
@pytest.mark.asyncio
- async def test_download_update_success(
- self, update_manager, tmp_path
- ):
+ async def test_download_update_success(self, update_manager, tmp_path):
"""Test successful update download."""
# Create release with .msi asset
release_data = {
@@ -237,9 +242,7 @@ class TestDownloading:
@pytest.mark.asyncio
@patch.object(UpdateManager, "_download_file")
- async def test_download_update_no_installer(
- self, mock_download, update_manager
- ):
+ async def test_download_update_no_installer(self, mock_download, update_manager):
"""Test download fails when no installer in release."""
release_data = {
"tag_name": "v0.0.2",
@@ -260,6 +263,143 @@ class TestDownloading:
assert result is None
+ @pytest.mark.asyncio
+ async def test_download_update_uses_release_manifest(self, agravity_update_manager, tmp_path):
+ """Test branded download selection from a shared release manifest."""
+ release = Release(
+ tag_name="v0.0.2",
+ name="WebDropBridge v0.0.2",
+ version="0.0.2",
+ body="Release notes",
+ assets=[
+ {
+ "name": "AgravityBridge-0.0.2-win-x64.msi",
+ "browser_download_url": "https://example.com/AgravityBridge-0.0.2-win-x64.msi",
+ },
+ {
+ "name": "AgravityBridge-0.0.2-win-x64.msi.sha256",
+ "browser_download_url": "https://example.com/AgravityBridge-0.0.2-win-x64.msi.sha256",
+ },
+ {
+ "name": "OtherBridge-0.0.2-win-x64.msi",
+ "browser_download_url": "https://example.com/OtherBridge-0.0.2-win-x64.msi",
+ },
+ {
+ "name": "release-manifest.json",
+ "browser_download_url": "https://example.com/release-manifest.json",
+ },
+ ],
+ published_at="2026-01-29T10:00:00Z",
+ )
+
+ manifest = {
+ "version": "0.0.2",
+ "channel": "stable",
+ "brands": {
+ "agravity": {
+ "windows-x64": {
+ "installer": "AgravityBridge-0.0.2-win-x64.msi",
+ "checksum": "AgravityBridge-0.0.2-win-x64.msi.sha256",
+ }
+ }
+ },
+ }
+
+ with (
+ patch.object(UpdateManager, "_download_json_asset", return_value=manifest),
+ patch.object(UpdateManager, "_download_file", return_value=True) as mock_download,
+ ):
+ result = await agravity_update_manager.download_update(release, tmp_path)
+
+ assert result is not None
+ assert result.name == "AgravityBridge-0.0.2-win-x64.msi"
+ mock_download.assert_called_once()
+
+ @pytest.mark.asyncio
+ async def test_download_update_falls_back_to_brand_prefix_without_manifest(
+ self, agravity_update_manager, tmp_path
+ ):
+ """Test branded download selection still works when the manifest is unavailable."""
+ release = Release(
+ tag_name="v0.0.2",
+ name="WebDropBridge v0.0.2",
+ version="0.0.2",
+ body="Release notes",
+ assets=[
+ {
+ "name": "WebDropBridge-0.0.2-win-x64.msi",
+ "browser_download_url": "https://example.com/WebDropBridge-0.0.2-win-x64.msi",
+ },
+ {
+ "name": "AgravityBridge-0.0.2-win-x64.msi",
+ "browser_download_url": "https://example.com/AgravityBridge-0.0.2-win-x64.msi",
+ },
+ {
+ "name": "AgravityBridge-0.0.2-win-x64.msi.sha256",
+ "browser_download_url": "https://example.com/AgravityBridge-0.0.2-win-x64.msi.sha256",
+ },
+ ],
+ published_at="2026-01-29T10:00:00Z",
+ )
+
+ with patch.object(UpdateManager, "_download_file", return_value=True) as mock_download:
+ result = await agravity_update_manager.download_update(release, tmp_path)
+
+ assert result is not None
+ assert result.name == "AgravityBridge-0.0.2-win-x64.msi"
+ mock_download.assert_called_once()
+
+ @pytest.mark.asyncio
+ async def test_verify_checksum_uses_release_manifest(self, agravity_update_manager, tmp_path):
+ """Test branded checksum selection from a shared release manifest."""
+ test_file = tmp_path / "AgravityBridge-0.0.2-win-x64.msi"
+ test_file.write_bytes(b"test content")
+
+ import hashlib
+
+ checksum = hashlib.sha256(b"test content").hexdigest()
+ release = Release(
+ tag_name="v0.0.2",
+ name="WebDropBridge v0.0.2",
+ version="0.0.2",
+ body="Release notes",
+ assets=[
+ {
+ "name": "AgravityBridge-0.0.2-win-x64.msi",
+ "browser_download_url": "https://example.com/AgravityBridge-0.0.2-win-x64.msi",
+ },
+ {
+ "name": "AgravityBridge-0.0.2-win-x64.msi.sha256",
+ "browser_download_url": "https://example.com/AgravityBridge-0.0.2-win-x64.msi.sha256",
+ },
+ {
+ "name": "release-manifest.json",
+ "browser_download_url": "https://example.com/release-manifest.json",
+ },
+ ],
+ published_at="2026-01-29T10:00:00Z",
+ )
+ manifest = {
+ "version": "0.0.2",
+ "channel": "stable",
+ "brands": {
+ "agravity": {
+ "windows-x64": {
+ "installer": "AgravityBridge-0.0.2-win-x64.msi",
+ "checksum": "AgravityBridge-0.0.2-win-x64.msi.sha256",
+ }
+ }
+ },
+ }
+
+ with (
+ patch.object(UpdateManager, "_download_json_asset", return_value=manifest),
+ patch.object(UpdateManager, "_download_checksum", return_value=checksum),
+ ):
+ result = await agravity_update_manager.verify_checksum(test_file, release)
+
+ assert result is True
+
class TestChecksumVerification:
"""Test checksum verification."""
@@ -270,8 +410,8 @@ class TestChecksumVerification:
self, mock_download_checksum, update_manager, sample_release, tmp_path
):
"""Test successful checksum verification."""
- # Create test file
- test_file = tmp_path / "test.exe"
+ # File must match the asset name so the .sha256 lookup succeeds
+ test_file = tmp_path / "WebDropBridge.exe"
test_file.write_bytes(b"test content")
# Calculate actual checksum
@@ -291,7 +431,8 @@ class TestChecksumVerification:
self, mock_download_checksum, update_manager, sample_release, tmp_path
):
"""Test checksum verification fails on mismatch."""
- test_file = tmp_path / "test.exe"
+ # File must match the asset name so the .sha256 lookup succeeds
+ test_file = tmp_path / "WebDropBridge.exe"
test_file.write_bytes(b"test content")
# Return wrong checksum
@@ -303,9 +444,7 @@ class TestChecksumVerification:
assert result is False
@pytest.mark.asyncio
- async def test_verify_checksum_no_checksum_file(
- self, update_manager, tmp_path
- ):
+ async def test_verify_checksum_no_checksum_file(self, update_manager, tmp_path):
"""Test verification skipped when no checksum file in release."""
test_file = tmp_path / "test.exe"
test_file.write_bytes(b"test content")
@@ -336,9 +475,7 @@ class TestInstallation:
@patch("subprocess.Popen")
@patch("platform.system")
- def test_install_update_windows(
- self, mock_platform, mock_popen, update_manager, tmp_path
- ):
+ def test_install_update_windows(self, mock_platform, mock_popen, update_manager, tmp_path):
"""Test installation on Windows."""
mock_platform.return_value = "Windows"
installer = tmp_path / "WebDropBridge.msi"
@@ -351,9 +488,7 @@ class TestInstallation:
@patch("subprocess.Popen")
@patch("platform.system")
- def test_install_update_macos(
- self, mock_platform, mock_popen, update_manager, tmp_path
- ):
+ def test_install_update_macos(self, mock_platform, mock_popen, update_manager, tmp_path):
"""Test installation on macOS."""
mock_platform.return_value = "Darwin"
installer = tmp_path / "WebDropBridge.dmg"