feat: Add installation scripts for Windows and Unix-based systems

- Created `install_and_run.bat` for Windows installation and setup.
- Created `install_and_run.sh` for Unix-based systems installation and setup.
- Removed `main.py` as it is no longer needed.
- Updated `requirements.txt` to specify package versions and added PyQt5.
- Deleted `start.bat` as it is redundant.
- Added unit tests for core functionality and scraping modes.
- Implemented input validation utilities in `utils/validators.py`.
- Added support for dual scraping modes in the scraper.

README.md

@@ -1,86 +1,90 @@
 # EBoek.info Scraper
 
-Een geautomatiseerde scraper voor het downloaden van stripverhalen van EBoek.info.
+Een moderne PyQt5 GUI applicatie voor het scrapen van EBoek.info met dual scraping modes, real-time voortgangsmonitoring en veilige opslag van inloggegevens.
 
-## Vereisten
+## ✨ Functies
 
-- Windows 10 of hoger
-- Python 3.8 of hoger
-- Google Chrome browser
-- EBoek.info account
+- **Twee scraping modi**: All Comics en Latest Comics
+- **Gebruiksvriendelijke GUI** met real-time voortgang
+- **Veilige credential opslag** in JSON config
+- **Cross-platform** ondersteuning (Windows/macOS)
+- **Background threading** - GUI blijft responsief
+- **Graceful cancellation** tijdens operaties
 
-## Installatie
+## 📋 Vereisten
 
-### Stap 1: Python installeren
+- **Python 3.8+**
+- **Google Chrome** browser
+- **EBoek.info** account
 
-1. Download Python van [python.org](https://www.python.org/downloads/)
-2. Tijdens installatie: vink **"Add Python to PATH"** aan
-3. Open Command Prompt en controleer de installatie:
-   ```
-   python --version
-   ```
+## 🚀 Installatie
 
-### Stap 2: Chrome WebDriver installeren
+### Windows
+Dubbelklik op `install_and_run.bat`
 
-De ChromeDriver wordt automatisch geïnstalleerd bij het eerste gebruik. Zorg dat Google Chrome up-to-date is.
-
-### Stap 3: Benodigde Python packages installeren
-
-Open Command Prompt in de projectmap en voer uit:
-```
-python -m pip install selenium requests urllib3
+### macOS / Linux
+```bash
+chmod +x install_and_run.sh
+./install_and_run.sh
 ```
 
-### Stap 4: Login gegevens instellen
-
-Open `main.py` in een teksteditor (bijvoorbeeld Notepad) en pas regel 189 aan met je EBoek.info inloggegevens:
-```python
-scraper.login("jouw_gebruikersnaam", "jouw_wachtwoord")
-```
-Vervang `"jouw_gebruikersnaam"` en `"jouw_wachtwoord"` met je echte gegevens.
-
-## Gebruik
-
-### De scraper starten
-
-1. Open Command Prompt
-2. Navigeer naar de projectmap:
-   ```
-   cd pad\naar\EBOEK.INFO SCRAPER
-   ```
-3. Start het script:
-   ```
-   python main.py
-   ```
-
-### Stappen tijdens gebruik
-
-1. **Inloggen**: Het script logt automatisch in met de opgegeven gebruikersnaam en wachtwoord
-2. **Pagina selectie**: 
-   - Voer het startpaginanummer in (1 voor de eerste pagina)
-   - Voer het eindpaginanummer in (zelfde als start voor één pagina)
-3. **Downloaden**: Het script zal:
-   - Alle strips op de geselecteerde pagina's bezoeken
-   - De downloadlinks activeren
-   - Bestanden downloaden naar je Chrome Downloads map
-4. **Afsluiten**: Druk op Enter om de browser te sluiten
-
-### Voorbeelden
-
-- **Één pagina downloaden**: Start=2, Eind=2 (download alleen pagina 2)
-- **Meerdere pagina's**: Start=1, Eind=5 (download pagina 1 t/m 5)
-- **Eerste pagina**: Start=1, Eind=1
-
-## Downloads locatie
-
-De bestanden worden gedownload naar je standaard Chrome downloadmap:
-```
-C:\Users\[gebruikersnaam]\Downloads
+### Handmatig
+```bash
+pip install selenium urllib3 PyQt5
+python3 gui_main.py
 ```
 
-## Tips
+## 🎯 Gebruik
 
-- Het script simuleert menselijk gedrag met willekeurige pauzes
-- Er zijn automatische pauzes tussen pagina's (15-45 seconden)
-- Na elke 5 strips is er een korte pauze
-- Laat het script ongestoord draaien voor beste resultaten
+1. **Start de applicatie**: `python3 gui_main.py`
+2. **Voer credentials in**: Klik "Change Credentials"
+3. **Kies scraping mode**: All Comics of Latest Comics
+4. **Stel pagina bereik in**: Start/eind pagina
+5. **Start scraping**: Klik "Start Scraping"
+
+## 📊 Scraping Modi
+
+### Mode 0: All Comics
+- **URL patroon**: `stripverhalen-alle/page/X/`
+- **Structuur**: Traditionele blog layout
+- **Selecteer**: `h2.post-title a`
+
+### Mode 1: Latest Comics
+- **URL patroon**: `laatste?_page=X&ref=dw`
+- **Structuur**: Grid layout met containers
+- **Selecteer**: `.pt-cv-wrapper .pt-cv-ifield h5.pt-cv-title a`
+
+## 🗂️ Project Structuur
+
+```
+├── gui_main.py              # GUI applicatie entry point
+├── install_and_run.bat      # Windows installer
+├── install_and_run.sh       # macOS/Linux installer
+├── requirements.txt         # Dependencies
+├── core/                    # Scraping logic
+│   ├── scraper.py          # Dual-mode scraper
+│   ├── scraper_thread.py   # Threading wrapper
+│   └── credentials.py      # Config management
+├── gui/                     # GUI components
+│   ├── main_window.py      # Main interface
+│   ├── login_dialog.py     # Credential input
+│   └── progress_dialog.py  # Progress monitoring
+├── tests/                   # Test scripts
+└── utils/                   # Helper functions
+```
+
+## 🔧 Troubleshooting
+
+**GUI start niet**: Controleer PyQt5 installatie
+**Login problemen**: Test credentials via GUI
+**Download issues**: Controleer `~/Downloads` folder
+
+## 💡 Tips
+
+- Begin met 1-2 pagina's om de functionaliteit te testen
+- Gebruik headless mode voor optimale snelheid
+- Monitor de voortgang in de progress dialog
+
+---
+
+**Veel succes met scrapen! 🚀**

core/__init__.py

@@ -0,0 +1 @@
+# Core scraping functionality

core/credentials.py

@@ -0,0 +1,309 @@
+"""
+Simple JSON-based credential storage system for EBoek.info scraper.
+"""
+
+import json
+import os
+from pathlib import Path
+import stat
+
+
+class CredentialManager:
+    """
+    Manages storage and retrieval of user credentials in a JSON config file.
+
+    Credentials are stored in the user's home directory in a hidden folder
+    with appropriate file permissions for basic security.
+    """
+
+    def __init__(self, app_name="eboek_scraper"):
+        """
+        Initialize the credential manager.
+
+        Args:
+            app_name (str): Application name for config directory
+        """
+        self.app_name = app_name
+        self.config_dir = Path.home() / f".{app_name}"
+        self.config_file = self.config_dir / "config.json"
+        self._ensure_config_dir()
+
+    def _ensure_config_dir(self):
+        """
+        Ensure the configuration directory exists with appropriate permissions.
+        """
+        try:
+            if not self.config_dir.exists():
+                self.config_dir.mkdir(mode=0o700, exist_ok=True)  # Only user can read/write/execute
+
+            # Ensure directory has correct permissions (user only)
+            if os.name != 'nt':  # Unix-like systems (macOS, Linux)
+                os.chmod(self.config_dir, stat.S_IRWXU)  # 700 permissions
+
+        except Exception as e:
+            # If we can't create the config directory, fall back to current directory
+            self.config_dir = Path(".")
+            self.config_file = self.config_dir / f".{self.app_name}_config.json"
+
+    def _load_config(self):
+        """
+        Load the configuration file.
+
+        Returns:
+            dict: Configuration data, empty dict if file doesn't exist
+        """
+        try:
+            if self.config_file.exists():
+                with open(self.config_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+        except (json.JSONDecodeError, IOError, PermissionError) as e:
+            # If there's any error reading the config, return empty dict
+            pass
+
+        return {}
+
+    def _save_config(self, config_data):
+        """
+        Save configuration data to file.
+
+        Args:
+            config_data (dict): Configuration data to save
+
+        Returns:
+            bool: True if saved successfully, False otherwise
+        """
+        try:
+            with open(self.config_file, 'w', encoding='utf-8') as f:
+                json.dump(config_data, f, indent=2, ensure_ascii=False)
+
+            # Set file permissions to be readable/writable by user only
+            if os.name != 'nt':  # Unix-like systems
+                os.chmod(self.config_file, stat.S_IRUSR | stat.S_IWUSR)  # 600 permissions
+
+            return True
+
+        except (IOError, PermissionError) as e:
+            return False
+
+    def save_credentials(self, username, password, remember=True):
+        """
+        Save user credentials to the config file.
+
+        Args:
+            username (str): EBoek.info username
+            password (str): EBoek.info password
+            remember (bool): Whether to save credentials for future use
+
+        Returns:
+            bool: True if saved successfully, False otherwise
+        """
+        if not remember:
+            # If remember is False, just clear any existing credentials
+            return self.clear_credentials()
+
+        try:
+            config = self._load_config()
+
+            config['credentials'] = {
+                'username': username,
+                'password': password,
+                'saved_at': str(Path.home()),  # Just to know which user saved it
+            }
+
+            return self._save_config(config)
+
+        except Exception as e:
+            return False
+
+    def load_credentials(self):
+        """
+        Load stored credentials.
+
+        Returns:
+            dict or None: Dictionary with 'username' and 'password' keys if found,
+                         None if no credentials are stored
+        """
+        try:
+            config = self._load_config()
+            credentials = config.get('credentials')
+
+            if credentials and 'username' in credentials and 'password' in credentials:
+                return {
+                    'username': credentials['username'],
+                    'password': credentials['password']
+                }
+
+        except Exception as e:
+            pass
+
+        return None
+
+    def has_saved_credentials(self):
+        """
+        Check if there are saved credentials available.
+
+        Returns:
+            bool: True if credentials are available, False otherwise
+        """
+        return self.load_credentials() is not None
+
+    def get_saved_username(self):
+        """
+        Get the saved username without the password.
+
+        Returns:
+            str or None: Saved username if available, None otherwise
+        """
+        credentials = self.load_credentials()
+        return credentials['username'] if credentials else None
+
+    def clear_credentials(self):
+        """
+        Remove stored credentials from the config file.
+
+        Returns:
+            bool: True if cleared successfully, False otherwise
+        """
+        try:
+            config = self._load_config()
+
+            if 'credentials' in config:
+                del config['credentials']
+                return self._save_config(config)
+
+            return True  # No credentials to clear is success
+
+        except Exception as e:
+            return False
+
+    def validate_credentials(self, username, password):
+        """
+        Basic validation of credential format.
+
+        Args:
+            username (str): Username to validate
+            password (str): Password to validate
+
+        Returns:
+            dict: Validation result with 'valid' bool and 'errors' list
+        """
+        errors = []
+
+        if not username or not username.strip():
+            errors.append("Username cannot be empty")
+        elif len(username.strip()) < 2:
+            errors.append("Username must be at least 2 characters")
+
+        if not password or not password.strip():
+            errors.append("Password cannot be empty")
+        elif len(password) < 3:
+            errors.append("Password must be at least 3 characters")
+
+        return {
+            'valid': len(errors) == 0,
+            'errors': errors
+        }
+
+    def get_config_file_path(self):
+        """
+        Get the path to the configuration file.
+
+        Returns:
+            Path: Path to the config file
+        """
+        return self.config_file
+
+    def save_app_settings(self, settings):
+        """
+        Save application settings (non-credential settings).
+
+        Args:
+            settings (dict): Application settings to save
+
+        Returns:
+            bool: True if saved successfully, False otherwise
+        """
+        try:
+            config = self._load_config()
+            config['app_settings'] = settings
+            return self._save_config(config)
+        except Exception as e:
+            return False
+
+    def load_app_settings(self):
+        """
+        Load application settings (non-credential settings).
+
+        Returns:
+            dict: Application settings, empty dict if none saved
+        """
+        try:
+            config = self._load_config()
+            return config.get('app_settings', {})
+        except Exception as e:
+            return {}
+
+    def get_default_settings(self):
+        """
+        Get default application settings.
+
+        Returns:
+            dict: Default settings
+        """
+        return {
+            'headless_mode': True,
+            'verbose_logging': False,
+            'auto_save_credentials': True,
+            'download_path': str(Path.home() / "Downloads"),
+            'default_start_page': 1,
+            'default_end_page': 1,
+            'scraping_mode': 0  # 0=All Comics, 1=Latest Comics
+        }
+
+    def export_settings(self, export_path):
+        """
+        Export settings (excluding credentials) to a file.
+
+        Args:
+            export_path (str or Path): Path to export settings to
+
+        Returns:
+            bool: True if exported successfully, False otherwise
+        """
+        try:
+            config = self._load_config()
+            # Remove credentials from export
+            export_config = {k: v for k, v in config.items() if k != 'credentials'}
+
+            with open(export_path, 'w', encoding='utf-8') as f:
+                json.dump(export_config, f, indent=2, ensure_ascii=False)
+
+            return True
+        except Exception as e:
+            return False
+
+    def import_settings(self, import_path):
+        """
+        Import settings (excluding credentials) from a file.
+
+        Args:
+            import_path (str or Path): Path to import settings from
+
+        Returns:
+            bool: True if imported successfully, False otherwise
+        """
+        try:
+            with open(import_path, 'r', encoding='utf-8') as f:
+                imported_config = json.load(f)
+
+            # Don't import credentials for security
+            if 'credentials' in imported_config:
+                del imported_config['credentials']
+
+            # Merge with existing config
+            config = self._load_config()
+            config.update(imported_config)
+
+            return self._save_config(config)
+        except Exception as e:
+            return False

core/scraper.py

@@ -0,0 +1,513 @@
+"""
+Core scraper functionality extracted from main.py with callback support for GUI integration.
+"""
+
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.chrome.options import Options
+import time
+import random
+import os
+import sys
+from pathlib import Path
+
+# Disable SSL verification warnings and errors
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+class Scraper:
+    """
+    EBoek.info web scraper with GUI callback support.
+
+    This class handles the core scraping functionality while providing
+    callback mechanisms for progress updates to a GUI application.
+    """
+
+    def __init__(self, headless=False, progress_callback=None, scraping_mode=0):
+        """
+        Initialize the scraper with optional GUI callback support.
+
+        Args:
+            headless (bool): Whether to run Chrome in headless mode
+            progress_callback (callable): Optional callback function for progress updates
+                Callback signature: callback(event_type: str, data: dict)
+            scraping_mode (int): Scraping mode (0=All Comics, 1=Latest Comics)
+        """
+        self.progress_callback = progress_callback
+        self._stop_requested = False
+        self.scraping_mode = scraping_mode
+
+        # Set up Chrome options with anti-detection measures
+        chrome_options = Options()
+        if headless:
+            chrome_options.add_argument('--headless')
+
+        # Fix SSL and certificate issues
+        chrome_options.add_argument('--ignore-ssl-errors')
+        chrome_options.add_argument('--ignore-certificate-errors')
+        chrome_options.add_argument('--disable-web-security')
+        chrome_options.add_argument('--allow-running-insecure-content')
+        chrome_options.add_argument('--disable-extensions')
+
+        # Fix DevTools connection issues
+        chrome_options.add_argument('--remote-debugging-port=0')
+        chrome_options.add_argument('--disable-dev-shm-usage')
+        chrome_options.add_argument('--no-sandbox')
+
+        # Make it look more human
+        chrome_options.add_argument('--disable-blink-features=AutomationControlled')
+        chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
+        chrome_options.add_experimental_option('useAutomationExtension', False)
+        chrome_options.add_argument('user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')
+
+        # Suppress logging
+        chrome_options.add_experimental_option('excludeSwitches', ['enable-logging'])
+        chrome_options.add_experimental_option('useAutomationExtension', False)
+        chrome_options.add_argument('--disable-logging')
+        chrome_options.add_argument('--log-level=3')
+
+        # Set cross-platform download directory
+        downloads_path = str(Path.home() / "Downloads")
+        prefs = {
+            "download.default_directory": downloads_path,
+            "download.prompt_for_download": False,
+            "download.directory_upgrade": True,
+            "safebrowsing.enabled": True
+        }
+        chrome_options.add_experimental_option("prefs", prefs)
+
+        self.driver = webdriver.Chrome(options=chrome_options)
+        self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
+
+        self._emit_progress("scraper_initialized", {"headless": headless, "downloads_path": downloads_path})
+
+    def _emit_progress(self, event_type, data):
+        """
+        Internal method to emit progress updates via callback.
+
+        Args:
+            event_type (str): Type of event (e.g., 'page_started', 'comic_completed')
+            data (dict): Event data
+        """
+        if self.progress_callback:
+            try:
+                self.progress_callback(event_type, data)
+            except Exception as e:
+                # Don't let callback errors crash the scraper
+                pass
+
+    def request_stop(self):
+        """Request the scraper to stop gracefully at the next opportunity."""
+        self._stop_requested = True
+        self._emit_progress("stop_requested", {})
+
+    def human_delay(self, min_sec=0.5, max_sec=2):
+        """
+        Simulate human-like delay with cancellation support.
+
+        Args:
+            min_sec (float): Minimum delay time
+            max_sec (float): Maximum delay time
+        """
+        if self._stop_requested:
+            return
+        delay_time = random.uniform(min_sec, max_sec)
+        self._emit_progress("delay_started", {"duration": delay_time})
+        time.sleep(delay_time)
+
+    def human_type(self, element, text):
+        """
+        Type text character by character with human-like delays.
+
+        Args:
+            element: Selenium web element to type into
+            text (str): Text to type
+        """
+        for char in text:
+            if self._stop_requested:
+                return
+            element.send_keys(char)
+            time.sleep(random.uniform(0.05, 0.15))
+
+    def navigate(self, url):
+        """
+        Navigate to a URL with human-like delay.
+
+        Args:
+            url (str): URL to navigate to
+        """
+        if self._stop_requested:
+            return False
+
+        self._emit_progress("navigation_started", {"url": url})
+        self.driver.get(url)
+        self.human_delay(1, 3)
+        self._emit_progress("navigation_completed", {"url": url})
+        return True
+
+    def login(self, username, password):
+        """
+        Login to EBoek.info with provided credentials.
+
+        Args:
+            username (str): Username for login
+            password (str): Password for login
+
+        Returns:
+            bool: True if login successful, False otherwise
+        """
+        if self._stop_requested:
+            return False
+
+        self._emit_progress("login_started", {"username": username})
+
+        try:
+            self.driver.get("https://eboek.info/komerin")
+            self.human_delay(2, 4)
+
+            if self._stop_requested:
+                return False
+
+            # Find and fill username field
+            username_field = self.driver.find_element(By.CSS_SELECTOR, "input[type='text']")
+            self.human_type(username_field, username)
+
+            self.human_delay(0.5, 1)
+
+            if self._stop_requested:
+                return False
+
+            # Find and fill password field
+            password_field = self.driver.find_element(By.CSS_SELECTOR, "input[type='password']")
+            self.human_type(password_field, password)
+
+            self.human_delay(0.5, 1.5)
+
+            if self._stop_requested:
+                return False
+
+            # Submit the form
+            submit_button = self.driver.find_element(By.CSS_SELECTOR, "input[type='submit']")
+            submit_button.click()
+
+            self.human_delay(2, 4)
+
+            # Check if login was successful (basic check)
+            # You could enhance this by checking for specific elements that appear after login
+            current_url = self.driver.current_url
+            login_successful = "komerin" not in current_url
+
+            if login_successful:
+                self._emit_progress("login_success", {"username": username})
+            else:
+                self._emit_progress("login_failed", {"username": username, "error": "Login appears to have failed"})
+
+            return login_successful
+
+        except Exception as e:
+            self._emit_progress("login_failed", {"username": username, "error": str(e)})
+            return False
+
+    def trigger_download(self, url):
+        """
+        Open URL in new tab to trigger browser download.
+
+        Args:
+            url (str): URL of file to download
+
+        Returns:
+            bool: True if download triggered successfully
+        """
+        if self._stop_requested:
+            return False
+
+        try:
+            # Store current window handle
+            current_window = self.driver.current_window_handle
+
+            # Use JavaScript to open URL in new tab with same session
+            self.driver.execute_script(f"window.open('{url}', '_blank');")
+
+            # Wait for download to complete and tab to auto-close
+            self.human_delay(3, 5)
+
+            # Switch back to original window
+            self.driver.switch_to.window(current_window)
+
+            self._emit_progress("download_triggered", {"url": url})
+            return True
+
+        except Exception as e:
+            self._emit_progress("download_failed", {"url": url, "error": str(e)})
+            return False
+
+    def scrape(self, start_page=1, end_page=1):
+        """
+        Scrape comics from specified page range.
+
+        Args:
+            start_page (int): Starting page number
+            end_page (int): Ending page number
+
+        Returns:
+            dict: Summary of scraping results
+        """
+        if self._stop_requested:
+            return {"success": False, "reason": "Cancelled before starting"}
+
+        # Determine base URL and URL pattern based on scraping mode
+        if self.scraping_mode == 1:  # Latest Comics
+            base_url = "https://eboek.info/laatste"
+            mode_name = "Latest Comics"
+        else:  # All Comics (default)
+            base_url = "https://eboek.info/stripverhalen-alle"
+            mode_name = "All Comics"
+
+        total_pages = end_page - start_page + 1
+        total_comics_processed = 0
+        total_downloads_triggered = 0
+        errors = []
+
+        self._emit_progress("scraping_started", {
+            "start_page": start_page,
+            "end_page": end_page,
+            "total_pages": total_pages,
+            "mode": mode_name
+        })
+
+        for page_num in range(start_page, end_page + 1):
+            if self._stop_requested:
+                break
+
+            # Construct page URL based on scraping mode
+            if self.scraping_mode == 1:  # Latest Comics
+                page_url = f"{base_url}?_page={page_num}&ref=dw"
+            else:  # All Comics
+                if page_num == 1:
+                    page_url = base_url
+                else:
+                    page_url = f"{base_url}/page/{page_num}/"
+
+            current_page_index = page_num - start_page + 1
+            self._emit_progress("page_started", {
+                "page_number": page_num,
+                "page_index": current_page_index,
+                "total_pages": total_pages,
+                "url": page_url
+            })
+
+            # Navigate to the page
+            if not self.navigate(page_url):
+                continue
+
+            # Scroll down a bit like a human would to see content
+            self.driver.execute_script("window.scrollTo(0, 300)")
+            self.human_delay(1, 2)
+
+            if self._stop_requested:
+                break
+
+            try:
+                # Find all comic strip links using mode-specific CSS selectors
+                if self.scraping_mode == 1:  # Latest Comics page
+                    # For "laatste" page - target only title links to avoid duplicates
+                    comic_links = self.driver.find_elements(By.CSS_SELECTOR, '.pt-cv-wrapper .pt-cv-ifield h5.pt-cv-title a')
+                else:  # All Comics page (default)
+                    # For "stripverhalen-alle" page - original selector
+                    comic_links = self.driver.find_elements(By.CSS_SELECTOR, 'h2.post-title a')
+
+                comic_count = len(comic_links)
+
+                self._emit_progress("page_comics_found", {
+                    "page_number": page_num,
+                    "comic_count": comic_count
+                })
+
+                # Store URLs first to avoid stale element issues
+                comic_urls = [link.get_attribute('href') for link in comic_links]
+
+                # Take a break between pages (more likely and longer)
+                if page_num > start_page:
+                    if random.random() < 0.7:  # 70% chance of break
+                        break_time = random.uniform(15, 45)  # 15-45 seconds
+                        self._emit_progress("page_break_started", {
+                            "duration": break_time,
+                            "page_number": page_num
+                        })
+                        time.sleep(break_time)
+                    else:
+                        # Even if no long break, always pause a bit
+                        short_break = random.uniform(5, 10)
+                        self._emit_progress("short_break", {
+                            "duration": short_break,
+                            "page_number": page_num
+                        })
+                        time.sleep(short_break)
+
+                # Process all comics on this page
+                for i, url in enumerate(comic_urls, 1):
+                    if self._stop_requested:
+                        break
+
+                    self._emit_progress("comic_started", {
+                        "page_number": page_num,
+                        "comic_index": i,
+                        "total_comics": comic_count,
+                        "url": url
+                    })
+
+                    # Random chance to scroll on main page before clicking
+                    if random.random() < 0.4:
+                        scroll_amount = random.randint(100, 500)
+                        self.driver.execute_script(f"window.scrollBy(0, {scroll_amount})")
+                        self.human_delay(0.5, 1.5)
+
+                    # Open in new tab to keep main page
+                    self.driver.execute_script("window.open('');")
+                    self.driver.switch_to.window(self.driver.window_handles[-1])
+
+                    try:
+                        self.driver.get(url)
+                        self.human_delay(2, 4)
+
+                        if self._stop_requested:
+                            break
+
+                        # Sometimes scroll down to see the content
+                        if random.random() < 0.6:
+                            self.driver.execute_script("window.scrollTo(0, 400)")
+                            self.human_delay(0.5, 1.5)
+
+                        # Extract title
+                        try:
+                            title = self.driver.find_element(By.CSS_SELECTOR, 'h1.entry-title').text
+                        except:
+                            title = f"Comic {i} on page {page_num}"
+
+                        self._emit_progress("comic_title_extracted", {
+                            "title": title,
+                            "url": url
+                        })
+
+                        # Small delay before clicking download
+                        self.human_delay(0.8, 2)
+
+                        if self._stop_requested:
+                            break
+
+                        # Execute the downloadLinks() JavaScript function
+                        self.driver.execute_script("downloadLinks()")
+                        self.human_delay(1.5, 3)
+
+                        # Find all download links in the table
+                        download_links = self.driver.find_elements(By.CSS_SELECTOR, 'table a')
+                        download_count = len(download_links)
+
+                        self._emit_progress("download_links_found", {
+                            "title": title,
+                            "download_count": download_count
+                        })
+
+                        # Trigger download for each file
+                        for j, link in enumerate(download_links):
+                            if self._stop_requested:
+                                break
+
+                            file_url = link.get_attribute('href')
+                            file_name = link.text.strip()
+
+                            self._emit_progress("download_started", {
+                                "file_name": file_name,
+                                "url": file_url,
+                                "index": j + 1,
+                                "total": download_count
+                            })
+
+                            if self.trigger_download(file_url):
+                                total_downloads_triggered += 1
+
+                            # Human-like delay between downloads
+                            if j < len(download_links) - 1:
+                                delay_time = random.uniform(2, 5)
+                                self._emit_progress("download_delay", {
+                                    "duration": delay_time,
+                                    "remaining": len(download_links) - j - 1
+                                })
+                                time.sleep(delay_time)
+
+                        total_comics_processed += 1
+
+                        self._emit_progress("comic_completed", {
+                            "title": title,
+                            "downloads_triggered": download_count,
+                            "page_number": page_num,
+                            "comic_index": i
+                        })
+
+                        # Take a longer break every 5 comics
+                        if i % 5 == 0 and i < len(comic_urls):
+                            break_time = random.uniform(3, 7)
+                            self._emit_progress("comic_batch_break", {
+                                "duration": break_time,
+                                "comics_processed": i
+                            })
+                            time.sleep(break_time)
+
+                    except Exception as e:
+                        error_msg = f"Error processing {url}: {e}"
+                        errors.append(error_msg)
+                        self._emit_progress("comic_error", {
+                            "url": url,
+                            "error": str(e)
+                        })
+                        # Human would pause after an error
+                        self.human_delay(2, 4)
+
+                    # Close tab and switch back
+                    try:
+                        self.driver.close()
+                        self.driver.switch_to.window(self.driver.window_handles[0])
+                    except:
+                        # Handle case where tab might have closed itself
+                        if len(self.driver.window_handles) > 0:
+                            self.driver.switch_to.window(self.driver.window_handles[0])
+
+                    # Vary the delay between comics
+                    self.human_delay(1, 3)
+
+                self._emit_progress("page_completed", {
+                    "page_number": page_num,
+                    "comics_processed": len(comic_urls)
+                })
+
+            except Exception as e:
+                error_msg = f"Error processing page {page_num}: {e}"
+                errors.append(error_msg)
+                self._emit_progress("page_error", {
+                    "page_number": page_num,
+                    "error": str(e)
+                })
+
+        # Generate summary
+        summary = {
+            "success": not self._stop_requested,
+            "total_pages_processed": min(page_num - start_page + 1, total_pages) if 'page_num' in locals() else 0,
+            "total_comics_processed": total_comics_processed,
+            "total_downloads_triggered": total_downloads_triggered,
+            "errors": errors,
+            "cancelled": self._stop_requested
+        }
+
+        self._emit_progress("scraping_completed", summary)
+
+        return summary
+
+    def close(self):
+        """Close the browser and clean up resources."""
+        try:
+            self.driver.quit()
+            self._emit_progress("scraper_closed", {})
+        except Exception as e:
+            self._emit_progress("scraper_close_error", {"error": str(e)})

core/scraper_thread.py

@@ -0,0 +1,301 @@
+"""
+QThread wrapper for the Scraper class with PyQt signals for GUI communication.
+"""
+
+from PyQt5.QtCore import QThread, pyqtSignal
+from .scraper import Scraper
+import time
+
+
+class ScraperThread(QThread):
+    """
+    Thread wrapper for the Scraper class that converts callback events to PyQt signals.
+
+    This class runs the scraper in a separate thread and emits signals that can be
+    connected to GUI components for real-time updates.
+    """
+
+    # Login-related signals
+    login_started = pyqtSignal(str)  # username
+    login_success = pyqtSignal(str)  # username
+    login_failed = pyqtSignal(str, str)  # username, error_message
+
+    # Scraping progress signals
+    scraping_started = pyqtSignal(int, int, int)  # start_page, end_page, total_pages
+    scraping_completed = pyqtSignal(dict)  # summary dictionary
+
+    # Page-level progress signals
+    page_started = pyqtSignal(int, int, int, str)  # page_number, page_index, total_pages, url
+    page_completed = pyqtSignal(int, int)  # page_number, comics_processed
+    page_comics_found = pyqtSignal(int, int)  # page_number, comic_count
+    page_error = pyqtSignal(int, str)  # page_number, error_message
+
+    # Comic-level progress signals
+    comic_started = pyqtSignal(int, int, int, str)  # page_number, comic_index, total_comics, url
+    comic_completed = pyqtSignal(str, int, int, int)  # title, downloads_triggered, page_number, comic_index
+    comic_title_extracted = pyqtSignal(str, str)  # title, url
+    comic_error = pyqtSignal(str, str)  # url, error_message
+
+    # Download-related signals
+    download_links_found = pyqtSignal(str, int)  # title, download_count
+    download_started = pyqtSignal(str, str, int, int)  # file_name, url, index, total
+    download_triggered = pyqtSignal(str)  # url
+    download_failed = pyqtSignal(str, str)  # url, error_message
+
+    # General status and control signals
+    status_update = pyqtSignal(str)  # general status message
+    error_occurred = pyqtSignal(str)  # error message
+    delay_started = pyqtSignal(float)  # duration
+    stop_requested = pyqtSignal()
+
+    # Navigation signals
+    navigation_started = pyqtSignal(str)  # url
+    navigation_completed = pyqtSignal(str)  # url
+
+    # Break and timing signals
+    page_break_started = pyqtSignal(float, int)  # duration, page_number
+    short_break = pyqtSignal(float, int)  # duration, page_number
+    comic_batch_break = pyqtSignal(float, int)  # duration, comics_processed
+    download_delay = pyqtSignal(float, int)  # duration, remaining_downloads
+
+    def __init__(self, username, password, start_page, end_page, scraping_mode=0, headless=True):
+        """
+        Initialize the scraper thread.
+
+        Args:
+            username (str): EBoek.info username
+            password (str): EBoek.info password
+            start_page (int): Starting page number
+            end_page (int): Ending page number
+            scraping_mode (int): Scraping mode (0=All Comics, 1=Latest Comics)
+            headless (bool): Whether to run Chrome in headless mode
+        """
+        super().__init__()
+        self.username = username
+        self.password = password
+        self.start_page = start_page
+        self.end_page = end_page
+        self.scraping_mode = scraping_mode
+        self.headless = headless
+        self.scraper = None
+        self._is_running = False
+
+    def run(self):
+        """
+        Main thread execution method.
+        This runs in the separate thread and should not be called directly.
+        """
+        try:
+            self._is_running = True
+
+            # Initialize scraper with progress callback
+            self.scraper = Scraper(
+                headless=self.headless,
+                progress_callback=self._handle_scraper_progress,
+                scraping_mode=self.scraping_mode
+            )
+
+            # Perform login
+            self.login_started.emit(self.username)
+            login_success = self.scraper.login(self.username, self.password)
+
+            if not login_success:
+                self.login_failed.emit(self.username, "Login failed. Please check your credentials.")
+                return
+
+            # Check if stop was requested during login
+            if self.scraper._stop_requested:
+                return
+
+            # Start scraping
+            summary = self.scraper.scrape(self.start_page, self.end_page)
+
+            # Emit completion signal
+            self.scraping_completed.emit(summary)
+
+        except Exception as e:
+            self.error_occurred.emit(f"Unexpected error: {str(e)}")
+        finally:
+            # Clean up
+            if self.scraper:
+                self.scraper.close()
+            self._is_running = False
+
+    def _handle_scraper_progress(self, event_type, data):
+        """
+        Handle progress callbacks from the Scraper and convert them to PyQt signals.
+
+        Args:
+            event_type (str): Type of event from the scraper
+            data (dict): Event data
+        """
+        try:
+            # Login events
+            if event_type == "login_started":
+                # Already handled in run() method
+                pass
+            elif event_type == "login_success":
+                self.login_success.emit(data.get("username", ""))
+            elif event_type == "login_failed":
+                self.login_failed.emit(data.get("username", ""), data.get("error", "Unknown error"))
+
+            # Scraping events
+            elif event_type == "scraping_started":
+                self.scraping_started.emit(
+                    data.get("start_page", 1),
+                    data.get("end_page", 1),
+                    data.get("total_pages", 1)
+                )
+            elif event_type == "scraping_completed":
+                self.scraping_completed.emit(data)
+
+            # Page events
+            elif event_type == "page_started":
+                self.page_started.emit(
+                    data.get("page_number", 1),
+                    data.get("page_index", 1),
+                    data.get("total_pages", 1),
+                    data.get("url", "")
+                )
+            elif event_type == "page_completed":
+                self.page_completed.emit(
+                    data.get("page_number", 1),
+                    data.get("comics_processed", 0)
+                )
+            elif event_type == "page_comics_found":
+                self.page_comics_found.emit(
+                    data.get("page_number", 1),
+                    data.get("comic_count", 0)
+                )
+            elif event_type == "page_error":
+                self.page_error.emit(
+                    data.get("page_number", 1),
+                    data.get("error", "Unknown error")
+                )
+
+            # Comic events
+            elif event_type == "comic_started":
+                self.comic_started.emit(
+                    data.get("page_number", 1),
+                    data.get("comic_index", 1),
+                    data.get("total_comics", 1),
+                    data.get("url", "")
+                )
+            elif event_type == "comic_completed":
+                self.comic_completed.emit(
+                    data.get("title", "Unknown"),
+                    data.get("downloads_triggered", 0),
+                    data.get("page_number", 1),
+                    data.get("comic_index", 1)
+                )
+            elif event_type == "comic_title_extracted":
+                self.comic_title_extracted.emit(
+                    data.get("title", "Unknown"),
+                    data.get("url", "")
+                )
+            elif event_type == "comic_error":
+                self.comic_error.emit(
+                    data.get("url", ""),
+                    data.get("error", "Unknown error")
+                )
+
+            # Download events
+            elif event_type == "download_links_found":
+                self.download_links_found.emit(
+                    data.get("title", "Unknown"),
+                    data.get("download_count", 0)
+                )
+            elif event_type == "download_started":
+                self.download_started.emit(
+                    data.get("file_name", ""),
+                    data.get("url", ""),
+                    data.get("index", 1),
+                    data.get("total", 1)
+                )
+            elif event_type == "download_triggered":
+                self.download_triggered.emit(data.get("url", ""))
+            elif event_type == "download_failed":
+                self.download_failed.emit(
+                    data.get("url", ""),
+                    data.get("error", "Unknown error")
+                )
+
+            # Navigation events
+            elif event_type == "navigation_started":
+                self.navigation_started.emit(data.get("url", ""))
+            elif event_type == "navigation_completed":
+                self.navigation_completed.emit(data.get("url", ""))
+
+            # Timing and break events
+            elif event_type == "delay_started":
+                self.delay_started.emit(data.get("duration", 0.0))
+            elif event_type == "page_break_started":
+                self.page_break_started.emit(
+                    data.get("duration", 0.0),
+                    data.get("page_number", 1)
+                )
+            elif event_type == "short_break":
+                self.short_break.emit(
+                    data.get("duration", 0.0),
+                    data.get("page_number", 1)
+                )
+            elif event_type == "comic_batch_break":
+                self.comic_batch_break.emit(
+                    data.get("duration", 0.0),
+                    data.get("comics_processed", 0)
+                )
+            elif event_type == "download_delay":
+                self.download_delay.emit(
+                    data.get("duration", 0.0),
+                    data.get("remaining", 0)
+                )
+
+            # Control events
+            elif event_type == "stop_requested":
+                self.stop_requested.emit()
+
+            # General status updates
+            elif event_type in ["scraper_initialized", "scraper_closed", "scraper_close_error"]:
+                self.status_update.emit(f"{event_type}: {data}")
+
+            # Emit a general status update for events we didn't specifically handle
+            else:
+                self.status_update.emit(f"{event_type}: {data}")
+
+        except Exception as e:
+            # Don't let signal emission errors crash the scraper
+            self.error_occurred.emit(f"Signal emission error: {str(e)}")
+
+    def request_stop(self):
+        """
+        Request the scraper to stop gracefully.
+        This can be called from the main thread (GUI).
+        """
+        if self.scraper:
+            self.scraper.request_stop()
+
+    def is_running(self):
+        """
+        Check if the scraper thread is currently running.
+
+        Returns:
+            bool: True if the thread is running
+        """
+        return self._is_running and self.isRunning()
+
+    def get_progress_summary(self):
+        """
+        Get a summary of the current progress.
+        This is thread-safe and can be called from the main thread.
+
+        Returns:
+            dict: Current progress information
+        """
+        if not self.scraper:
+            return {"status": "not_started"}
+
+        return {
+            "status": "running" if self._is_running else "stopped",
+            "stop_requested": self.scraper._stop_requested if self.scraper else False,
+            "thread_running": self.isRunning()
+        }

gui/__init__.py

@@ -0,0 +1 @@
+# GUI components for the scraper application

gui/login_dialog.py

@@ -0,0 +1,317 @@
+"""
+Login dialog for EBoek.info credential input.
+"""
+
+from PyQt5.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QGridLayout,
+    QPushButton, QLabel, QLineEdit, QCheckBox, QMessageBox, QProgressBar
+)
+from PyQt5.QtCore import Qt, QTimer, QThread, pyqtSignal
+from PyQt5.QtGui import QFont
+
+from pathlib import Path
+import sys
+
+# Add the project root directory to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+from utils.validators import validate_username, validate_password, format_error_message
+
+
+class LoginTestThread(QThread):
+    """Thread for testing login credentials without blocking the UI."""
+
+    login_result = pyqtSignal(bool, str)  # success, message
+
+    def __init__(self, username, password):
+        super().__init__()
+        self.username = username
+        self.password = password
+
+    def run(self):
+        """Test the login credentials."""
+        try:
+            # Import here to avoid circular imports and ensure GUI responsiveness
+            from core.scraper import Scraper
+
+            # Create a scraper instance for testing
+            scraper = Scraper(headless=True)
+
+            # Attempt login
+            success = scraper.login(self.username, self.password)
+
+            # Clean up
+            scraper.close()
+
+            if success:
+                self.login_result.emit(True, "Login successful!")
+            else:
+                self.login_result.emit(False, "Login failed. Please check your credentials.")
+
+        except Exception as e:
+            self.login_result.emit(False, f"Error testing login: {str(e)}")
+
+
+class LoginDialog(QDialog):
+    """
+    Dialog for entering EBoek.info login credentials.
+
+    Provides fields for username and password input, with options to save
+    credentials and test them before saving.
+    """
+
+    def __init__(self, parent=None, credential_manager=None):
+        super().__init__(parent)
+        self.credential_manager = credential_manager
+        self.test_thread = None
+
+        self.init_ui()
+        self.load_existing_credentials()
+
+    def init_ui(self):
+        """Initialize the user interface."""
+        self.setWindowTitle("EBoek.info Login")
+        self.setModal(True)
+        self.setFixedSize(400, 300)
+
+        layout = QVBoxLayout(self)
+
+        # Title
+        title_label = QLabel("EBoek.info Credentials")
+        title_font = QFont()
+        title_font.setPointSize(14)
+        title_font.setBold(True)
+        title_label.setFont(title_font)
+        title_label.setAlignment(Qt.AlignCenter)
+        layout.addWidget(title_label)
+
+        layout.addSpacing(10)
+
+        # Credentials form
+        form_layout = QGridLayout()
+
+        form_layout.addWidget(QLabel("Username:"), 0, 0)
+        self.username_input = QLineEdit()
+        self.username_input.setPlaceholderText("Enter your EBoek.info username")
+        form_layout.addWidget(self.username_input, 0, 1)
+
+        form_layout.addWidget(QLabel("Password:"), 1, 0)
+        self.password_input = QLineEdit()
+        self.password_input.setEchoMode(QLineEdit.Password)
+        self.password_input.setPlaceholderText("Enter your password")
+        form_layout.addWidget(self.password_input, 1, 1)
+
+        layout.addLayout(form_layout)
+
+        layout.addSpacing(10)
+
+        # Options
+        self.remember_checkbox = QCheckBox("Save credentials for future use")
+        self.remember_checkbox.setChecked(True)
+        layout.addWidget(self.remember_checkbox)
+
+        layout.addSpacing(5)
+
+        # Info text
+        info_label = QLabel(
+            "Note: Credentials are stored securely on your computer "
+            "for convenience. You can clear them anytime from the Settings menu."
+        )
+        info_label.setWordWrap(True)
+        info_label.setStyleSheet("color: #666; font-size: 10px;")
+        layout.addWidget(info_label)
+
+        layout.addSpacing(15)
+
+        # Test progress (hidden initially)
+        self.test_progress = QProgressBar()
+        self.test_progress.setVisible(False)
+        layout.addWidget(self.test_progress)
+
+        self.test_status_label = QLabel("")
+        self.test_status_label.setVisible(False)
+        layout.addWidget(self.test_status_label)
+
+        # Buttons
+        button_layout = QHBoxLayout()
+
+        self.test_btn = QPushButton("Test Login")
+        self.test_btn.clicked.connect(self.test_login)
+        button_layout.addWidget(self.test_btn)
+
+        button_layout.addStretch()
+
+        self.ok_btn = QPushButton("OK")
+        self.ok_btn.clicked.connect(self.accept_credentials)
+        self.ok_btn.setDefault(True)
+        button_layout.addWidget(self.ok_btn)
+
+        self.cancel_btn = QPushButton("Cancel")
+        self.cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(self.cancel_btn)
+
+        layout.addLayout(button_layout)
+
+        # Connect Enter key to OK button
+        self.username_input.returnPressed.connect(self.password_input.setFocus)
+        self.password_input.returnPressed.connect(self.accept_credentials)
+
+    def load_existing_credentials(self):
+        """Load existing credentials if available."""
+        if self.credential_manager:
+            username = self.credential_manager.get_saved_username()
+            if username:
+                self.username_input.setText(username)
+                # Focus password field if username is pre-filled
+                self.password_input.setFocus()
+            else:
+                self.username_input.setFocus()
+
+    def validate_input(self):
+        """
+        Validate the entered credentials.
+
+        Returns:
+            tuple: (is_valid, errors_list)
+        """
+        username = self.username_input.text().strip()
+        password = self.password_input.text()
+
+        username_validation = validate_username(username)
+        password_validation = validate_password(password)
+
+        all_errors = []
+        all_errors.extend(username_validation.get('errors', []))
+        all_errors.extend(password_validation.get('errors', []))
+
+        return len(all_errors) == 0, all_errors
+
+    def test_login(self):
+        """Test the login credentials."""
+        # First validate input
+        is_valid, errors = self.validate_input()
+        if not is_valid:
+            QMessageBox.warning(self, "Invalid Input", format_error_message(errors))
+            return
+
+        # Disable UI elements during test
+        self.test_btn.setEnabled(False)
+        self.ok_btn.setEnabled(False)
+        self.username_input.setEnabled(False)
+        self.password_input.setEnabled(False)
+
+        # Show progress
+        self.test_progress.setVisible(True)
+        self.test_progress.setRange(0, 0)  # Indeterminate progress
+        self.test_status_label.setText("Testing login credentials...")
+        self.test_status_label.setVisible(True)
+
+        # Start test thread
+        username = self.username_input.text().strip()
+        password = self.password_input.text()
+
+        self.test_thread = LoginTestThread(username, password)
+        self.test_thread.login_result.connect(self.on_test_completed)
+        self.test_thread.start()
+
+    def on_test_completed(self, success, message):
+        """Handle test completion."""
+        # Re-enable UI elements
+        self.test_btn.setEnabled(True)
+        self.ok_btn.setEnabled(True)
+        self.username_input.setEnabled(True)
+        self.password_input.setEnabled(True)
+
+        # Hide progress
+        self.test_progress.setVisible(False)
+
+        # Show result
+        if success:
+            self.test_status_label.setText("✓ " + message)
+            self.test_status_label.setStyleSheet("color: #2E8B57; font-weight: bold;")
+        else:
+            self.test_status_label.setText("✗ " + message)
+            self.test_status_label.setStyleSheet("color: #f44336; font-weight: bold;")
+
+        # Auto-hide status after 5 seconds
+        QTimer.singleShot(5000, lambda: self.test_status_label.setVisible(False))
+
+        # Clean up thread
+        self.test_thread = None
+
+    def accept_credentials(self):
+        """Accept and save the credentials."""
+        # Validate input
+        is_valid, errors = self.validate_input()
+        if not is_valid:
+            QMessageBox.warning(self, "Invalid Input", format_error_message(errors))
+            return
+
+        username = self.username_input.text().strip()
+        password = self.password_input.text()
+        remember = self.remember_checkbox.isChecked()
+
+        # Save credentials if manager is available
+        if self.credential_manager:
+            if remember:
+                success = self.credential_manager.save_credentials(username, password, remember=True)
+                if not success:
+                    QMessageBox.warning(
+                        self, "Save Error",
+                        "Could not save credentials. They will be used for this session only."
+                    )
+            else:
+                # Clear any existing saved credentials if user unchecked remember
+                self.credential_manager.clear_credentials()
+
+        # Accept the dialog
+        self.accept()
+
+    def get_credentials(self):
+        """
+        Get the entered credentials.
+
+        Returns:
+            dict: Dictionary with 'username', 'password', and 'remember' keys
+        """
+        return {
+            'username': self.username_input.text().strip(),
+            'password': self.password_input.text(),
+            'remember': self.remember_checkbox.isChecked()
+        }
+
+    def closeEvent(self, event):
+        """Handle dialog close event."""
+        # Make sure test thread is stopped
+        if self.test_thread and self.test_thread.isRunning():
+            self.test_thread.quit()
+            self.test_thread.wait(1000)  # Wait up to 1 second
+
+        event.accept()
+
+    def reject(self):
+        """Handle dialog rejection (Cancel button)."""
+        # Stop test thread if running
+        if self.test_thread and self.test_thread.isRunning():
+            self.test_thread.quit()
+            self.test_thread.wait(1000)
+
+        super().reject()
+
+
+def show_login_dialog(parent=None, credential_manager=None):
+    """
+    Convenience function to show login dialog and get credentials.
+
+    Args:
+        parent: Parent widget
+        credential_manager: CredentialManager instance
+
+    Returns:
+        dict or None: Credentials if dialog accepted, None if cancelled
+    """
+    dialog = LoginDialog(parent, credential_manager)
+    if dialog.exec_() == QDialog.Accepted:
+        return dialog.get_credentials()
+    return None

gui/main_window.py

@@ -0,0 +1,510 @@
+"""
+Main application window for the EBoek.info scraper GUI.
+"""
+
+import sys
+from pathlib import Path
+from PyQt5.QtWidgets import (
+    QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QGridLayout,
+    QPushButton, QLabel, QSpinBox, QTextEdit, QGroupBox,
+    QCheckBox, QProgressBar, QMessageBox, QFileDialog, QMenuBar, QMenu, QAction,
+    QComboBox
+)
+from PyQt5.QtCore import Qt, QTimer, pyqtSignal
+from PyQt5.QtGui import QFont, QIcon
+
+# Import our custom modules
+import os
+import sys
+
+# Add the project root directory to Python path so we can import our modules
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+from core.credentials import CredentialManager
+from core.scraper_thread import ScraperThread
+from utils.validators import validate_page_range, format_error_message
+from gui.login_dialog import LoginDialog
+from gui.progress_dialog import ProgressDialog
+
+
+class MainWindow(QMainWindow):
+    """
+    Main application window for the EBoek.info scraper.
+
+    This window provides the primary interface for:
+    - Managing credentials
+    - Setting scraping parameters
+    - Starting/stopping scraping operations
+    - Monitoring progress and logs
+    """
+
+    # Custom signals
+    scraping_requested = pyqtSignal(str, str, int, int, bool)  # username, password, start_page, end_page, headless
+
+    def __init__(self):
+        super().__init__()
+        self.credential_manager = CredentialManager()
+        self.scraper_thread = None
+        self.progress_dialog = None
+
+        # Load application settings
+        self.app_settings = self.credential_manager.load_app_settings()
+        if not self.app_settings:
+            self.app_settings = self.credential_manager.get_default_settings()
+
+        self.init_ui()
+        self.update_credential_status()
+
+    def init_ui(self):
+        """Initialize the user interface."""
+        self.setWindowTitle("EBoek.info Scraper")
+        self.setMinimumSize(600, 500)
+        self.resize(700, 600)
+
+        # Create menu bar
+        self.create_menu_bar()
+
+        # Create central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        # Main layout
+        layout = QVBoxLayout(central_widget)
+
+        # Create sections
+        self.create_credential_section(layout)
+        self.create_scraping_section(layout)
+        self.create_status_section(layout)
+        self.create_control_section(layout)
+
+        # Status bar
+        self.statusBar().showMessage("Ready")
+
+    def create_menu_bar(self):
+        """Create the menu bar."""
+        menubar = self.menuBar()
+
+        # File menu
+        file_menu = menubar.addMenu('File')
+
+        export_action = QAction('Export Settings', self)
+        export_action.triggered.connect(self.export_settings)
+        file_menu.addAction(export_action)
+
+        import_action = QAction('Import Settings', self)
+        import_action.triggered.connect(self.import_settings)
+        file_menu.addAction(import_action)
+
+        file_menu.addSeparator()
+
+        exit_action = QAction('Exit', self)
+        exit_action.triggered.connect(self.close)
+        file_menu.addAction(exit_action)
+
+        # Settings menu
+        settings_menu = menubar.addMenu('Settings')
+
+        clear_creds_action = QAction('Clear Saved Credentials', self)
+        clear_creds_action.triggered.connect(self.clear_credentials)
+        settings_menu.addAction(clear_creds_action)
+
+        # Help menu
+        help_menu = menubar.addMenu('Help')
+
+        about_action = QAction('About', self)
+        about_action.triggered.connect(self.show_about)
+        help_menu.addAction(about_action)
+
+    def create_credential_section(self, parent_layout):
+        """Create the credential management section."""
+        group = QGroupBox("Credentials")
+        layout = QHBoxLayout(group)
+
+        self.credential_status_label = QLabel("No credentials configured")
+        layout.addWidget(self.credential_status_label)
+
+        layout.addStretch()
+
+        self.change_credentials_btn = QPushButton("Change Credentials")
+        self.change_credentials_btn.clicked.connect(self.show_login_dialog)
+        layout.addWidget(self.change_credentials_btn)
+
+        parent_layout.addWidget(group)
+
+    def create_scraping_section(self, parent_layout):
+        """Create the scraping configuration section."""
+        group = QGroupBox("Scraping Configuration")
+        layout = QGridLayout(group)
+
+        # Scraping mode selection
+        layout.addWidget(QLabel("Mode:"), 0, 0)
+        self.mode_combo = QComboBox()
+        self.mode_combo.addItems([
+            "All Comics (stripverhalen-alle)",
+            "Latest Comics (laatste)"
+        ])
+        self.mode_combo.setCurrentIndex(self.app_settings.get('scraping_mode', 0))
+        self.mode_combo.setToolTip("Select which page type to scrape")
+        self.mode_combo.currentIndexChanged.connect(self.on_mode_changed)
+        layout.addWidget(self.mode_combo, 0, 1, 1, 3)
+
+        # Page range selection
+        layout.addWidget(QLabel("Start Page:"), 1, 0)
+        self.start_page_spin = QSpinBox()
+        self.start_page_spin.setMinimum(1)
+        self.start_page_spin.setMaximum(9999)
+        self.start_page_spin.setValue(self.app_settings.get('default_start_page', 1))
+        layout.addWidget(self.start_page_spin, 1, 1)
+
+        layout.addWidget(QLabel("End Page:"), 1, 2)
+        self.end_page_spin = QSpinBox()
+        self.end_page_spin.setMinimum(1)
+        self.end_page_spin.setMaximum(9999)
+        self.end_page_spin.setValue(self.app_settings.get('default_end_page', 1))
+        layout.addWidget(self.end_page_spin, 1, 3)
+
+        # Mode description label
+        self.mode_description_label = QLabel("")
+        self.mode_description_label.setStyleSheet("color: #666; font-size: 11px; font-style: italic;")
+        self.mode_description_label.setWordWrap(True)
+        layout.addWidget(self.mode_description_label, 2, 0, 1, 4)
+
+        # Options
+        self.headless_checkbox = QCheckBox("Headless Mode")
+        self.headless_checkbox.setChecked(self.app_settings.get('headless_mode', True))
+        self.headless_checkbox.setToolTip("Run browser in background (recommended)")
+        layout.addWidget(self.headless_checkbox, 3, 0, 1, 2)
+
+        self.verbose_checkbox = QCheckBox("Verbose Logging")
+        self.verbose_checkbox.setChecked(self.app_settings.get('verbose_logging', False))
+        self.verbose_checkbox.setToolTip("Show detailed progress information")
+        layout.addWidget(self.verbose_checkbox, 3, 2, 1, 2)
+
+        # Update mode description
+        self.update_mode_description()
+
+        parent_layout.addWidget(group)
+
+    def on_mode_changed(self):
+        """Handle scraping mode selection change."""
+        self.update_mode_description()
+        self.save_current_settings()
+
+    def update_mode_description(self):
+        """Update the mode description text based on current selection."""
+        mode_index = self.mode_combo.currentIndex()
+
+        if mode_index == 0:  # All Comics
+            description = ("Scrapes all comics from the 'stripverhalen-alle' page. "
+                          "This is the original scraping mode with complete comic archives.")
+        elif mode_index == 1:  # Latest Comics
+            description = ("Scrapes latest comics from the 'laatste' page. "
+                          "This mode gets the most recently added comics with page parameter support.")
+        else:
+            description = ""
+
+        self.mode_description_label.setText(description)
+
+    def create_status_section(self, parent_layout):
+        """Create the status display section."""
+        group = QGroupBox("Status")
+        layout = QVBoxLayout(group)
+
+        self.status_label = QLabel("Ready to start scraping...")
+        self.status_label.setStyleSheet("font-weight: bold; color: #2E8B57;")
+        layout.addWidget(self.status_label)
+
+        # Progress bar
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setVisible(False)
+        layout.addWidget(self.progress_bar)
+
+        parent_layout.addWidget(group)
+
+
+    def create_control_section(self, parent_layout):
+        """Create the control buttons section."""
+        layout = QHBoxLayout()
+
+        self.start_btn = QPushButton("Start Scraping")
+        self.start_btn.clicked.connect(self.start_scraping)
+        self.start_btn.setStyleSheet("QPushButton { background-color: #4CAF50; color: white; font-weight: bold; padding: 8px; }")
+        layout.addWidget(self.start_btn)
+
+        layout.addStretch()
+
+        self.downloads_btn = QPushButton("Open Downloads Folder")
+        self.downloads_btn.clicked.connect(self.open_downloads_folder)
+        layout.addWidget(self.downloads_btn)
+
+        parent_layout.addLayout(layout)
+
+    def update_credential_status(self):
+        """Update the credential status display."""
+        username = self.credential_manager.get_saved_username()
+        if username:
+            self.credential_status_label.setText(f"Logged in as: {username}")
+            self.credential_status_label.setStyleSheet("color: #2E8B57; font-weight: bold;")
+        else:
+            self.credential_status_label.setText("No credentials configured")
+            self.credential_status_label.setStyleSheet("color: #FF6B35; font-weight: bold;")
+
+    def show_login_dialog(self):
+        """Show the login dialog for credential input."""
+        dialog = LoginDialog(self, self.credential_manager)
+        if dialog.exec_() == dialog.Accepted:
+            self.update_credential_status()
+            self.log_message("Credentials updated successfully.")
+
+    def start_scraping(self):
+        """Start the scraping process."""
+        # Validate credentials
+        credentials = self.credential_manager.load_credentials()
+        if not credentials:
+            QMessageBox.warning(self, "No Credentials",
+                               "Please configure your EBoek.info credentials first.")
+            self.show_login_dialog()
+            return
+
+        # Validate page range
+        start_page = self.start_page_spin.value()
+        end_page = self.end_page_spin.value()
+
+        validation = validate_page_range(start_page, end_page)
+        if not validation['valid']:
+            QMessageBox.warning(self, "Invalid Page Range",
+                               format_error_message(validation['errors']))
+            return
+
+        # Save current settings
+        self.save_current_settings()
+
+        # Get scraping mode
+        mode_index = self.mode_combo.currentIndex()
+        mode_names = ["All Comics", "Latest Comics"]
+        mode_name = mode_names[mode_index] if mode_index < len(mode_names) else "Unknown"
+
+        # Start scraping
+        self.log_message(f"Starting scraping: {mode_name} mode, pages {start_page} to {end_page}")
+
+        # Create and start scraper thread
+        self.scraper_thread = ScraperThread(
+            username=credentials['username'],
+            password=credentials['password'],
+            start_page=start_page,
+            end_page=end_page,
+            scraping_mode=mode_index,
+            headless=self.headless_checkbox.isChecked()
+        )
+
+        # Connect signals
+        self.connect_scraper_signals()
+
+        # Show progress dialog
+        self.progress_dialog = ProgressDialog(self, self.scraper_thread)
+        self.progress_dialog.show()
+
+        # Start the thread
+        self.scraper_thread.start()
+
+        # Update UI state
+        self.start_btn.setEnabled(False)
+        self.status_label.setText("Scraping in progress...")
+        self.status_label.setStyleSheet("font-weight: bold; color: #FF8C00;")
+
+    def connect_scraper_signals(self):
+        """Connect signals from the scraper thread to UI updates."""
+        if not self.scraper_thread:
+            return
+
+        # Login signals
+        self.scraper_thread.login_started.connect(self.on_login_started)
+        self.scraper_thread.login_success.connect(self.on_login_success)
+        self.scraper_thread.login_failed.connect(self.on_login_failed)
+
+        # Scraping completion
+        self.scraper_thread.scraping_completed.connect(self.on_scraping_completed)
+
+        # Status updates
+        self.scraper_thread.status_update.connect(self.log_message)
+        self.scraper_thread.error_occurred.connect(self.on_error_occurred)
+
+        # Page progress
+        self.scraper_thread.page_started.connect(self.on_page_started)
+        self.scraper_thread.page_completed.connect(self.on_page_completed)
+
+    def on_login_started(self, username):
+        """Handle login started event."""
+        self.log_message(f"Logging in as {username}...")
+
+    def on_login_success(self, username):
+        """Handle successful login."""
+        self.log_message(f"Login successful for {username}")
+
+    def on_login_failed(self, username, error):
+        """Handle failed login."""
+        self.log_message(f"Login failed for {username}: {error}")
+        QMessageBox.critical(self, "Login Failed",
+                            f"Could not log in as {username}.\n\n{error}\n\nPlease check your credentials.")
+
+    def on_page_started(self, page_number, page_index, total_pages, url):
+        """Handle page started event."""
+        self.log_message(f"Processing page {page_number} ({page_index}/{total_pages})")
+
+    def on_page_completed(self, page_number, comics_processed):
+        """Handle page completed event."""
+        self.log_message(f"Page {page_number} completed - {comics_processed} comics processed")
+
+    def on_scraping_completed(self, summary):
+        """Handle scraping completion."""
+        self.start_btn.setEnabled(True)
+
+        if summary.get('cancelled'):
+            self.status_label.setText("Scraping cancelled")
+            self.status_label.setStyleSheet("font-weight: bold; color: #FF6B35;")
+            self.log_message("Scraping was cancelled by user")
+        elif summary.get('success'):
+            self.status_label.setText("Scraping completed")
+            self.status_label.setStyleSheet("font-weight: bold; color: #2E8B57;")
+            self.log_message(f"Scraping completed! Processed {summary.get('total_comics_processed', 0)} comics, "
+                           f"triggered {summary.get('total_downloads_triggered', 0)} downloads")
+        else:
+            self.status_label.setText("Scraping failed")
+            self.status_label.setStyleSheet("font-weight: bold; color: #f44336;")
+            self.log_message("Scraping failed - see errors above")
+
+        # Show summary
+        if summary.get('errors'):
+            error_count = len(summary['errors'])
+            QMessageBox.warning(self, "Scraping Completed with Errors",
+                               f"Scraping completed but {error_count} errors occurred.\n"
+                               f"Check the log for details.")
+
+    def on_error_occurred(self, error_message):
+        """Handle error events."""
+        self.log_message(f"ERROR: {error_message}")
+
+    def log_message(self, message):
+        """Log message - removed from main window, only shown in progress dialog."""
+        # Activity log now only appears in the scraping progress dialog
+        pass
+
+    def save_current_settings(self):
+        """Save current UI settings to configuration."""
+        settings = {
+            'headless_mode': self.headless_checkbox.isChecked(),
+            'verbose_logging': self.verbose_checkbox.isChecked(),
+            'default_start_page': self.start_page_spin.value(),
+            'default_end_page': self.end_page_spin.value(),
+            'scraping_mode': self.mode_combo.currentIndex(),
+        }
+        settings.update(self.app_settings)  # Keep other settings
+        self.credential_manager.save_app_settings(settings)
+        self.app_settings = settings
+
+    def open_downloads_folder(self):
+        """Open the downloads folder in the system file manager."""
+        downloads_path = Path.home() / "Downloads"
+
+        import sys
+        import subprocess
+
+        try:
+            if sys.platform == "win32":
+                os.startfile(downloads_path)
+            elif sys.platform == "darwin":
+                subprocess.run(["open", str(downloads_path)])
+            else:  # linux
+                subprocess.run(["xdg-open", str(downloads_path)])
+        except Exception as e:
+            QMessageBox.information(self, "Downloads Folder",
+                                   f"Downloads are saved to:\n{downloads_path}\n\n"
+                                   f"Could not open folder automatically: {e}")
+
+    def clear_credentials(self):
+        """Clear saved credentials."""
+        reply = QMessageBox.question(self, "Clear Credentials",
+                                    "Are you sure you want to clear the saved credentials?",
+                                    QMessageBox.Yes | QMessageBox.No)
+
+        if reply == QMessageBox.Yes:
+            if self.credential_manager.clear_credentials():
+                self.update_credential_status()
+                self.log_message("Saved credentials cleared.")
+                QMessageBox.information(self, "Credentials Cleared",
+                                       "Saved credentials have been cleared.")
+            else:
+                QMessageBox.warning(self, "Error", "Could not clear credentials.")
+
+    def export_settings(self):
+        """Export application settings to a file."""
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Export Settings",
+            "eboek_scraper_settings.json",
+            "JSON files (*.json);;All files (*.*)"
+        )
+
+        if file_path:
+            if self.credential_manager.export_settings(file_path):
+                QMessageBox.information(self, "Export Successful",
+                                       f"Settings exported to:\n{file_path}")
+            else:
+                QMessageBox.warning(self, "Export Failed",
+                                   "Could not export settings.")
+
+    def import_settings(self):
+        """Import application settings from a file."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Import Settings",
+            "",
+            "JSON files (*.json);;All files (*.*)"
+        )
+
+        if file_path:
+            if self.credential_manager.import_settings(file_path):
+                self.app_settings = self.credential_manager.load_app_settings()
+                # Update UI with imported settings
+                self.headless_checkbox.setChecked(self.app_settings.get('headless_mode', True))
+                self.verbose_checkbox.setChecked(self.app_settings.get('verbose_logging', False))
+                self.start_page_spin.setValue(self.app_settings.get('default_start_page', 1))
+                self.end_page_spin.setValue(self.app_settings.get('default_end_page', 1))
+
+                QMessageBox.information(self, "Import Successful",
+                                       f"Settings imported from:\n{file_path}")
+                self.log_message("Settings imported successfully.")
+            else:
+                QMessageBox.warning(self, "Import Failed",
+                                   "Could not import settings.")
+
+    def show_about(self):
+        """Show the about dialog."""
+        QMessageBox.about(self, "About EBoek.info Scraper",
+                         "EBoek.info Scraper\n\n"
+                         "A GUI application for downloading comic strips from eboek.info.\n\n"
+                         "Features:\n"
+                         "• Automated login and scraping\n"
+                         "• Real-time progress monitoring\n"
+                         "• Human-like behavior simulation\n"
+                         "• Secure credential storage\n\n"
+                         "Built with Python and PyQt5.")
+
+    def closeEvent(self, event):
+        """Handle application close event."""
+        if self.scraper_thread and self.scraper_thread.isRunning():
+            reply = QMessageBox.question(self, "Scraping in Progress",
+                                        "Scraping is currently in progress. "
+                                        "Do you want to stop and exit?",
+                                        QMessageBox.Yes | QMessageBox.No)
+
+            if reply == QMessageBox.Yes:
+                self.scraper_thread.request_stop()
+                # Give it a moment to stop gracefully
+                self.scraper_thread.wait(3000)  # Wait up to 3 seconds
+                event.accept()
+            else:
+                event.ignore()
+        else:
+            # Save settings before closing
+            self.save_current_settings()
+            event.accept()

gui/progress_dialog.py

@@ -0,0 +1,477 @@
+"""
+Progress dialog for real-time scraping progress monitoring.
+"""
+
+import time
+from PyQt5.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QGridLayout,
+    QPushButton, QLabel, QProgressBar, QTextEdit, QGroupBox
+)
+from PyQt5.QtCore import Qt, QTimer, pyqtSignal
+from PyQt5.QtGui import QFont
+
+from pathlib import Path
+import sys
+
+# Add the project root directory to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+
+class ProgressDialog(QDialog):
+    """
+    Dialog for displaying real-time scraping progress.
+
+    Shows progress bars for pages and comics, current activity status,
+    and a detailed log of operations with the ability to cancel.
+    """
+
+    # Signals
+    cancel_requested = pyqtSignal()
+
+    def __init__(self, parent=None, scraper_thread=None):
+        super().__init__(parent)
+        self.scraper_thread = scraper_thread
+        self.start_time = time.time()
+
+        # Progress tracking
+        self.total_pages = 0
+        self.current_page = 0
+        self.total_comics_on_page = 0
+        self.current_comic = 0
+        self.total_comics_processed = 0
+        self.total_downloads_triggered = 0
+
+        # Enhanced time tracking for better estimation
+        self.comic_start_times = []  # Track start time of each comic
+        self.comic_durations = []    # Track how long each comic took
+        self.estimated_total_comics = 0  # Estimated total comics across all pages
+        self.last_comic_start = None
+        self.pages_processed = 0
+
+        self.init_ui()
+        self.connect_signals()
+
+    def init_ui(self):
+        """Initialize the user interface."""
+        self.setWindowTitle("Scraping Progress")
+        self.setMinimumSize(500, 400)
+        self.resize(600, 500)
+
+        layout = QVBoxLayout(self)
+
+        # Overall progress section
+        self.create_overall_progress_section(layout)
+
+        # Current activity section
+        self.create_activity_section(layout)
+
+        # Progress details section
+        self.create_details_section(layout)
+
+        # Log section
+        self.create_log_section(layout)
+
+        # Control buttons
+        self.create_control_section(layout)
+
+    def create_overall_progress_section(self, parent_layout):
+        """Create the overall progress section."""
+        group = QGroupBox("Overall Progress")
+        layout = QVBoxLayout(group)
+
+        # Page progress
+        self.page_progress_label = QLabel("Initializing...")
+        layout.addWidget(self.page_progress_label)
+
+        self.page_progress_bar = QProgressBar()
+        self.page_progress_bar.setRange(0, 100)
+        layout.addWidget(self.page_progress_bar)
+
+        # Comic progress (current page)
+        self.comic_progress_label = QLabel("Waiting for page data...")
+        layout.addWidget(self.comic_progress_label)
+
+        self.comic_progress_bar = QProgressBar()
+        self.comic_progress_bar.setRange(0, 100)
+        layout.addWidget(self.comic_progress_bar)
+
+        parent_layout.addWidget(group)
+
+    def create_activity_section(self, parent_layout):
+        """Create the current activity section."""
+        group = QGroupBox("Current Activity")
+        layout = QVBoxLayout(group)
+
+        self.activity_label = QLabel("Starting scraper...")
+        self.activity_label.setStyleSheet("font-weight: bold; color: #2E8B57;")
+        layout.addWidget(self.activity_label)
+
+        # Current item details
+        self.current_item_label = QLabel("")
+        layout.addWidget(self.current_item_label)
+
+        parent_layout.addWidget(group)
+
+    def create_details_section(self, parent_layout):
+        """Create the progress details section."""
+        group = QGroupBox("Session Details")
+        layout = QGridLayout(group)
+
+        # Time information
+        layout.addWidget(QLabel("Time Elapsed:"), 0, 0)
+        self.elapsed_time_label = QLabel("00:00:00")
+        layout.addWidget(self.elapsed_time_label, 0, 1)
+
+        layout.addWidget(QLabel("Estimated Remaining:"), 0, 2)
+        self.remaining_time_label = QLabel("Calculating...")
+        layout.addWidget(self.remaining_time_label, 0, 3)
+
+        # Progress statistics
+        layout.addWidget(QLabel("Comics Processed:"), 1, 0)
+        self.comics_processed_label = QLabel("0")
+        layout.addWidget(self.comics_processed_label, 1, 1)
+
+        layout.addWidget(QLabel("Downloads Triggered:"), 1, 2)
+        self.downloads_triggered_label = QLabel("0")
+        layout.addWidget(self.downloads_triggered_label, 1, 3)
+
+        parent_layout.addWidget(group)
+
+        # Start timer for elapsed time updates
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.update_elapsed_time)
+        self.timer.start(1000)  # Update every second
+
+    def create_log_section(self, parent_layout):
+        """Create the log display section."""
+        group = QGroupBox("Activity Log")
+        layout = QVBoxLayout(group)
+
+        self.log_text = QTextEdit()
+        self.log_text.setReadOnly(True)
+        self.log_text.setMaximumHeight(150)
+
+        # Set monospace font for logs (cross-platform)
+        font = QFont()
+        font.setFamily("Monaco, Consolas, 'Courier New', monospace")  # Cross-platform fallback
+        font.setPointSize(9)
+        font.setStyleHint(QFont.TypeWriter)  # Monospace hint
+        self.log_text.setFont(font)
+
+        layout.addWidget(self.log_text)
+
+        parent_layout.addWidget(group)
+
+    def create_control_section(self, parent_layout):
+        """Create the control buttons section."""
+        layout = QHBoxLayout()
+
+        layout.addStretch()
+
+        self.cancel_btn = QPushButton("Cancel Operation")
+        self.cancel_btn.clicked.connect(self.cancel_scraping)
+        self.cancel_btn.setStyleSheet("QPushButton { background-color: #f44336; color: white; font-weight: bold; padding: 8px; }")
+        layout.addWidget(self.cancel_btn)
+
+        self.close_btn = QPushButton("Close")
+        self.close_btn.clicked.connect(self.accept)
+        self.close_btn.setEnabled(False)  # Enabled when scraping completes
+        layout.addWidget(self.close_btn)
+
+        parent_layout.addLayout(layout)
+
+    def connect_signals(self):
+        """Connect signals from the scraper thread."""
+        if not self.scraper_thread:
+            return
+
+        # Login signals
+        self.scraper_thread.login_started.connect(self.on_login_started)
+        self.scraper_thread.login_success.connect(self.on_login_success)
+        self.scraper_thread.login_failed.connect(self.on_login_failed)
+
+        # Scraping progress
+        self.scraper_thread.scraping_started.connect(self.on_scraping_started)
+        self.scraper_thread.scraping_completed.connect(self.on_scraping_completed)
+
+        # Page progress
+        self.scraper_thread.page_started.connect(self.on_page_started)
+        self.scraper_thread.page_completed.connect(self.on_page_completed)
+        self.scraper_thread.page_comics_found.connect(self.on_page_comics_found)
+
+        # Comic progress
+        self.scraper_thread.comic_started.connect(self.on_comic_started)
+        self.scraper_thread.comic_completed.connect(self.on_comic_completed)
+        self.scraper_thread.comic_title_extracted.connect(self.on_comic_title_extracted)
+
+        # Download progress
+        self.scraper_thread.download_links_found.connect(self.on_download_links_found)
+        self.scraper_thread.download_started.connect(self.on_download_started)
+        self.scraper_thread.download_triggered.connect(self.on_download_triggered)
+
+        # General status
+        self.scraper_thread.status_update.connect(self.log_message)
+        self.scraper_thread.error_occurred.connect(self.on_error_occurred)
+
+        # Timing events
+        self.scraper_thread.page_break_started.connect(self.on_break_started)
+        self.scraper_thread.comic_batch_break.connect(self.on_break_started)
+
+    def cancel_scraping(self):
+        """Cancel the scraping operation."""
+        if self.scraper_thread:
+            self.log_message("Cancel requested - stopping after current operation...")
+            self.scraper_thread.request_stop()
+            self.cancel_btn.setEnabled(False)
+            self.activity_label.setText("Cancelling...")
+            self.activity_label.setStyleSheet("font-weight: bold; color: #FF6B35;")
+
+    def log_message(self, message):
+        """Add a message to the log."""
+        import datetime
+        timestamp = datetime.datetime.now().strftime("%H:%M:%S")
+        formatted_message = f"[{timestamp}] {message}"
+
+        self.log_text.append(formatted_message)
+
+        # Auto-scroll to bottom
+        scrollbar = self.log_text.verticalScrollBar()
+        scrollbar.setValue(scrollbar.maximum())
+
+    def update_elapsed_time(self):
+        """Update the elapsed time display with enhanced estimation."""
+        elapsed = int(time.time() - self.start_time)
+        hours = elapsed // 3600
+        minutes = (elapsed % 3600) // 60
+        seconds = elapsed % 60
+
+        self.elapsed_time_label.setText(f"{hours:02d}:{minutes:02d}:{seconds:02d}")
+
+        # Enhanced time estimation based on comic processing rate
+        self.calculate_realistic_time_estimate(elapsed)
+
+    def calculate_realistic_time_estimate(self, elapsed):
+        """Calculate realistic time estimate based on comic processing data."""
+        try:
+            # If we have comic duration data, use it for accurate estimation
+            if len(self.comic_durations) >= 2 and self.estimated_total_comics > 0:
+                # Calculate average time per comic from actual data
+                avg_time_per_comic = sum(self.comic_durations) / len(self.comic_durations)
+                comics_remaining = self.estimated_total_comics - self.total_comics_processed
+
+                if comics_remaining > 0:
+                    estimated_remaining = int(comics_remaining * avg_time_per_comic)
+                    self.format_remaining_time(estimated_remaining)
+                else:
+                    self.remaining_time_label.setText("Almost done!")
+
+            # Comic-based estimation when we know total comics but don't have enough duration data
+            elif self.estimated_total_comics > 0 and self.total_comics_processed > 0:
+                # Use current processing rate
+                avg_time_per_comic = elapsed / self.total_comics_processed
+                comics_remaining = self.estimated_total_comics - self.total_comics_processed
+
+                if comics_remaining > 0:
+                    estimated_remaining = int(comics_remaining * avg_time_per_comic)
+                    self.format_remaining_time(estimated_remaining)
+                else:
+                    self.remaining_time_label.setText("Almost done!")
+
+            # Fallback to combined page + comic estimation
+            elif self.total_pages > 0 and self.total_comics_on_page > 0:
+                # Calculate combined progress: pages completed + current page comic progress
+                pages_completed = self.current_page - 1
+                current_page_progress = self.current_comic / self.total_comics_on_page
+                total_progress = (pages_completed + current_page_progress) / self.total_pages
+
+                if total_progress > 0.05:  # Only estimate after 5% progress
+                    estimated_total = elapsed / total_progress
+                    remaining = int(estimated_total - elapsed)
+                    if remaining > 0:
+                        self.format_remaining_time(remaining)
+                    else:
+                        self.remaining_time_label.setText("Almost done!")
+                else:
+                    self.remaining_time_label.setText("Calculating...")
+            else:
+                self.remaining_time_label.setText("Calculating...")
+
+        except (ZeroDivisionError, ValueError):
+            self.remaining_time_label.setText("Calculating...")
+
+    def format_remaining_time(self, remaining_seconds):
+        """Format remaining time into readable format."""
+        if remaining_seconds <= 0:
+            self.remaining_time_label.setText("Almost done!")
+            return
+
+        rem_hours = remaining_seconds // 3600
+        rem_minutes = (remaining_seconds % 3600) // 60
+        rem_secs = remaining_seconds % 60
+
+        # Show different formats based on duration
+        if rem_hours > 0:
+            self.remaining_time_label.setText(f"{rem_hours:02d}:{rem_minutes:02d}:{rem_secs:02d}")
+        elif rem_minutes > 0:
+            self.remaining_time_label.setText(f"{rem_minutes:02d}:{rem_secs:02d}")
+        else:
+            self.remaining_time_label.setText(f"{rem_secs} sec")
+
+    def update_progress_bars(self):
+        """Update progress bars based on current state."""
+        # Page progress
+        if self.total_pages > 0:
+            page_progress = int((self.current_page / self.total_pages) * 100)
+            self.page_progress_bar.setValue(page_progress)
+            self.page_progress_label.setText(f"Page {self.current_page} of {self.total_pages} ({page_progress}%)")
+
+        # Comic progress
+        if self.total_comics_on_page > 0:
+            comic_progress = int((self.current_comic / self.total_comics_on_page) * 100)
+            self.comic_progress_bar.setValue(comic_progress)
+            self.comic_progress_label.setText(f"Comic {self.current_comic} of {self.total_comics_on_page} ({comic_progress}%)")
+
+    def update_statistics(self):
+        """Update the statistics display."""
+        self.comics_processed_label.setText(str(self.total_comics_processed))
+        self.downloads_triggered_label.setText(str(self.total_downloads_triggered))
+
+    # Event handlers
+    def on_login_started(self, username):
+        """Handle login started."""
+        self.activity_label.setText(f"Logging in as {username}...")
+        self.log_message(f"Logging in as {username}")
+
+    def on_login_success(self, username):
+        """Handle successful login."""
+        self.activity_label.setText("Login successful - starting scraper...")
+        self.log_message(f"Login successful for {username}")
+
+    def on_login_failed(self, username, error):
+        """Handle failed login."""
+        self.activity_label.setText("Login failed")
+        self.activity_label.setStyleSheet("font-weight: bold; color: #f44336;")
+        self.log_message(f"Login failed: {error}")
+
+    def on_scraping_started(self, start_page, end_page, total_pages):
+        """Handle scraping start."""
+        self.total_pages = total_pages
+        self.current_page = 0
+        self.activity_label.setText(f"Starting scraping: pages {start_page} to {end_page}")
+        self.log_message(f"Starting scraping: pages {start_page} to {end_page}")
+        self.update_progress_bars()
+
+    def on_scraping_completed(self, summary):
+        """Handle scraping completion."""
+        self.cancel_btn.setEnabled(False)
+        self.close_btn.setEnabled(True)
+        self.timer.stop()
+
+        if summary.get('cancelled'):
+            self.activity_label.setText("Scraping cancelled by user")
+            self.activity_label.setStyleSheet("font-weight: bold; color: #FF6B35;")
+        elif summary.get('success'):
+            self.activity_label.setText("Scraping completed successfully!")
+            self.activity_label.setStyleSheet("font-weight: bold; color: #2E8B57;")
+        else:
+            self.activity_label.setText("Scraping completed with errors")
+            self.activity_label.setStyleSheet("font-weight: bold; color: #f44336;")
+
+        # Update final statistics
+        self.total_comics_processed = summary.get('total_comics_processed', 0)
+        self.total_downloads_triggered = summary.get('total_downloads_triggered', 0)
+        self.update_statistics()
+
+        self.log_message("Scraping operation completed")
+
+    def on_page_started(self, page_number, page_index, total_pages, url):
+        """Handle page start."""
+        self.current_page = page_index
+        self.current_comic = 0
+        self.total_comics_on_page = 0
+        self.activity_label.setText(f"Processing page {page_number}...")
+        self.current_item_label.setText(f"URL: {url}")
+        self.update_progress_bars()
+        self.log_message(f"Started processing page {page_number}")
+
+    def on_page_completed(self, page_number, comics_processed):
+        """Handle page completion."""
+        self.pages_processed = self.current_page
+        self.log_message(f"Completed page {page_number} - {comics_processed} comics processed")
+
+    def on_page_comics_found(self, page_number, comic_count):
+        """Handle comics found on page."""
+        self.total_comics_on_page = comic_count
+        self.current_comic = 0
+
+        # Update estimated total comics based on current data
+        if self.total_pages > 0 and self.current_page > 0:
+            avg_comics_per_page = (self.total_comics_processed + comic_count) / self.current_page
+            self.estimated_total_comics = int(avg_comics_per_page * self.total_pages)
+
+        self.log_message(f"Found {comic_count} comics on page {page_number}")
+        self.update_progress_bars()
+
+    def on_comic_started(self, page_number, comic_index, total_comics, url):
+        """Handle comic start."""
+        self.current_comic = comic_index
+        self.last_comic_start = time.time()  # Track start time for duration calculation
+        self.activity_label.setText(f"Processing comic {comic_index} of {total_comics}...")
+        self.current_item_label.setText(f"URL: {url}")
+        self.update_progress_bars()
+
+    def on_comic_completed(self, title, downloads_triggered, page_number, comic_index):
+        """Handle comic completion."""
+        # Track timing data for enhanced estimation
+        if self.last_comic_start is not None:
+            comic_duration = time.time() - self.last_comic_start
+            self.comic_durations.append(comic_duration)
+            # Keep only recent durations for adaptive estimation (last 20 comics)
+            if len(self.comic_durations) > 20:
+                self.comic_durations = self.comic_durations[-20:]
+
+        # Update live counters
+        self.total_comics_processed += 1
+        # Note: downloads_triggered counter is now updated in real-time in on_download_triggered
+        self.update_statistics()  # This updates the live display
+        self.log_message(f"Completed: {title} ({downloads_triggered} downloads)")
+
+    def on_comic_title_extracted(self, title, url):
+        """Handle comic title extraction."""
+        self.current_item_label.setText(f"Processing: {title}")
+
+    def on_download_links_found(self, title, download_count):
+        """Handle download links found."""
+        self.log_message(f"Found {download_count} download links for: {title}")
+
+    def on_download_started(self, file_name, url, index, total):
+        """Handle download start."""
+        self.activity_label.setText(f"Downloading file {index} of {total}")
+        self.current_item_label.setText(f"File: {file_name}")
+
+    def on_download_triggered(self, url):
+        """Handle download triggered."""
+        # Update download counter in real-time
+        self.total_downloads_triggered += 1
+        self.update_statistics()
+
+    def on_error_occurred(self, error_message):
+        """Handle error."""
+        self.log_message(f"ERROR: {error_message}")
+
+    def on_break_started(self, duration, context=None):
+        """Handle break start."""
+        self.activity_label.setText(f"Taking a break for {duration:.1f} seconds...")
+        self.current_item_label.setText("Human-like delay in progress...")
+
+    def closeEvent(self, event):
+        """Handle dialog close."""
+        if self.scraper_thread and self.scraper_thread.isRunning():
+            # Don't allow closing while scraping is active
+            event.ignore()
+        else:
+            # Stop timer
+            if hasattr(self, 'timer'):
+                self.timer.stop()
+            event.accept()

gui_main.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+EBoek.info Scraper GUI Application
+
+Main entry point for the PyQt5 GUI version of the EBoek.info scraper.
+"""
+
+import sys
+import os
+import traceback
+import warnings
+from pathlib import Path
+
+# Suppress urllib3 OpenSSL warnings on macOS
+warnings.filterwarnings("ignore", message="urllib3 v2 only supports OpenSSL 1.1.1+")
+warnings.filterwarnings("ignore", category=UserWarning, module="urllib3")
+
+# Ensure we can import PyQt5
+try:
+    from PyQt5.QtWidgets import QApplication, QMessageBox
+    from PyQt5.QtCore import Qt
+    from PyQt5.QtGui import QIcon
+except ImportError as e:
+    print("Error: PyQt5 is not installed.")
+    print("Please run: pip install PyQt5")
+    print(f"Import error: {e}")
+    sys.exit(1)
+
+# Add the project root to Python path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+# Import our GUI components
+try:
+    from gui.main_window import MainWindow
+    from core.credentials import CredentialManager
+except ImportError as e:
+    print(f"Error importing application modules: {e}")
+    print("Please ensure all required files are present.")
+    traceback.print_exc()
+    sys.exit(1)
+
+
+class EBoekScraperApp(QApplication):
+    """
+    Main application class for the EBoek.info Scraper GUI.
+    """
+
+    def __init__(self, argv):
+        super().__init__(argv)
+
+        self.setApplicationName("EBoek.info Scraper")
+        self.setApplicationVersion("2.0")
+        self.setOrganizationName("EBoek Scraper")
+
+        # Set application icon if available
+        self.set_application_icon()
+
+        # Handle exceptions
+        sys.excepthook = self.handle_exception
+
+        self.main_window = None
+
+    def set_application_icon(self):
+        """Set the application icon if available."""
+        # You can add an icon file here if desired
+        # icon_path = project_root / "resources" / "icon.png"
+        # if icon_path.exists():
+        #     self.setWindowIcon(QIcon(str(icon_path)))
+        pass
+
+    def handle_exception(self, exc_type, exc_value, exc_traceback):
+        """Handle uncaught exceptions."""
+        if issubclass(exc_type, KeyboardInterrupt):
+            # Allow Ctrl+C to exit gracefully
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+
+        # Log the exception
+        error_msg = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+        print("Uncaught exception:")
+        print(error_msg)
+
+        # Show error dialog to user
+        if self.main_window:
+            try:
+                QMessageBox.critical(
+                    self.main_window,
+                    "Unexpected Error",
+                    f"An unexpected error occurred:\n\n{str(exc_value)}\n\n"
+                    f"The application may need to be restarted.\n\n"
+                    f"Error type: {exc_type.__name__}"
+                )
+            except:
+                # If we can't show the dialog, just print
+                print("Could not display error dialog")
+
+    def initialize(self):
+        """Initialize the application."""
+        try:
+            # Check system requirements
+            self.check_requirements()
+
+            # Create and show main window
+            self.main_window = MainWindow()
+            self.main_window.show()
+
+            return True
+
+        except Exception as e:
+            print(f"Error initializing application: {e}")
+            traceback.print_exc()
+
+            # Try to show error dialog
+            try:
+                msg = QMessageBox()
+                msg.setIcon(QMessageBox.Critical)
+                msg.setWindowTitle("Initialization Error")
+                msg.setText(f"Could not initialize the application:\n\n{str(e)}")
+                msg.setDetailedText(traceback.format_exc())
+                msg.exec_()
+            except:
+                print("Could not display initialization error dialog")
+
+            return False
+
+    def check_requirements(self):
+        """Check system requirements and dependencies."""
+        errors = []
+
+        # Check Python version
+        if sys.version_info < (3, 6):
+            errors.append(f"Python 3.6+ required (found {sys.version_info.major}.{sys.version_info.minor})")
+
+        # Check required modules
+        required_modules = ['selenium', 'urllib3']
+        missing_modules = []
+
+        for module in required_modules:
+            try:
+                __import__(module)
+            except ImportError:
+                missing_modules.append(module)
+
+        if missing_modules:
+            errors.append(f"Missing required modules: {', '.join(missing_modules)}")
+
+        # Check Chrome/Chromium availability (basic check)
+        chrome_paths = [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",  # macOS
+            "/usr/bin/google-chrome",  # Linux
+            "/usr/bin/chromium-browser",  # Linux (Chromium)
+            "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",  # Windows
+            "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",  # Windows 32-bit
+        ]
+
+        chrome_found = any(Path(path).exists() for path in chrome_paths)
+        if not chrome_found:
+            # This is a warning, not an error
+            print("Warning: Chrome browser not detected in standard locations.")
+            print("Make sure Google Chrome is installed for the scraper to work.")
+
+        if errors:
+            error_text = "System requirement errors:\n\n" + "\n".join(f"• {error}" for error in errors)
+            error_text += "\n\nPlease install missing requirements and try again."
+            raise RuntimeError(error_text)
+
+
+def show_startup_error(title, message):
+    """Show a startup error dialog without a main window."""
+    app = QApplication.instance()
+    if not app:
+        app = QApplication(sys.argv)
+
+    msg = QMessageBox()
+    msg.setIcon(QMessageBox.Critical)
+    msg.setWindowTitle(title)
+    msg.setText(message)
+    msg.exec_()
+
+
+def main():
+    """Main entry point for the GUI application."""
+    # Set up high DPI support
+    if hasattr(Qt, 'AA_EnableHighDpiScaling'):
+        QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
+
+    if hasattr(Qt, 'AA_UseHighDpiPixmaps'):
+        QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+
+    # Create the application
+    try:
+        app = EBoekScraperApp(sys.argv)
+
+        # Initialize and run
+        if app.initialize():
+            # Run the application
+            sys.exit(app.exec_())
+        else:
+            print("Application initialization failed")
+            sys.exit(1)
+
+    except Exception as e:
+        print(f"Fatal error starting application: {e}")
+        traceback.print_exc()
+
+        # Try to show error dialog
+        try:
+            show_startup_error(
+                "Startup Error",
+                f"Could not start the EBoek.info Scraper:\n\n{str(e)}\n\n"
+                f"Please check the installation and try again."
+            )
+        except:
+            print("Could not display startup error dialog")
+
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

install_and_run.bat

@@ -0,0 +1,81 @@
+@echo off
+echo ===============================================
+echo  EBoek.info Scraper - Installation and Setup
+echo ===============================================
+echo.
+
+REM Check if Python is installed
+python --version >nul 2>&1
+if %errorlevel% neq 0 (
+    echo Python is not installed or not in PATH.
+    echo.
+    echo Please install Python from: https://www.python.org/downloads/
+    echo Make sure to check "Add Python to PATH" during installation.
+    echo.
+    pause
+    exit /b 1
+)
+
+echo Python found! Checking version...
+for /f "tokens=2" %%i in ('python --version') do set PYTHON_VERSION=%%i
+echo Python version: %PYTHON_VERSION%
+
+REM Check if this is the first run
+if exist "gui_main.py" (
+    echo GUI application already set up.
+    echo.
+    goto :run_gui
+)
+
+echo.
+echo Installing required packages...
+echo ===============================================
+python -m pip install --upgrade pip
+python -m pip install -r requirements.txt
+
+if %errorlevel% neq 0 (
+    echo.
+    echo ERROR: Failed to install requirements.
+    echo Please check your internet connection and try again.
+    echo You may need to run this as Administrator.
+    pause
+    exit /b 1
+)
+
+echo.
+echo Requirements installed successfully!
+echo Setting up GUI application...
+
+REM The GUI files will be created by the setup process
+echo.
+echo ===============================================
+echo Installation complete!
+echo ===============================================
+
+:run_gui
+if exist "gui_main.py" (
+    echo Starting EBoek.info Scraper GUI...
+    echo.
+    python gui_main.py
+    if %errorlevel% neq 0 (
+        echo.
+        echo GUI failed to start. You can still use the terminal version:
+        echo python main.py
+        echo.
+        pause
+    )
+) else (
+    echo GUI version not found. Running terminal version...
+    echo.
+    if exist "main.py" (
+        python main.py
+    ) else (
+        echo Error: No scraper found. Please check installation.
+        pause
+        exit /b 1
+    )
+)
+
+echo.
+echo Application closed.
+pause

install_and_run.sh

@@ -0,0 +1,158 @@
+#!/bin/bash
+
+echo "==============================================="
+echo " EBoek.info Scraper - Installation and Setup"
+echo "==============================================="
+echo
+
+# Function to check if command exists
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+# Check operating system
+OS="$(uname -s)"
+case "${OS}" in
+    Linux*)     MACHINE=Linux;;
+    Darwin*)    MACHINE=Mac;;
+    *)          MACHINE="UNKNOWN:${OS}"
+esac
+
+echo "Operating System: $MACHINE"
+
+# Check if Python is installed
+if command_exists python3; then
+    PYTHON_CMD="python3"
+elif command_exists python; then
+    PYTHON_VERSION=$(python --version 2>&1 | grep -oP '\d+\.\d+')
+    if [[ ${PYTHON_VERSION%.*} -ge 3 ]]; then
+        PYTHON_CMD="python"
+    else
+        echo "ERROR: Python 3 is required. Found Python $PYTHON_VERSION"
+        PYTHON_CMD=""
+    fi
+else
+    PYTHON_CMD=""
+fi
+
+if [ -z "$PYTHON_CMD" ]; then
+    echo "Python 3 is not installed."
+    echo
+    if [ "$MACHINE" = "Mac" ]; then
+        echo "To install Python on macOS:"
+        echo "1. Install Homebrew: /bin/bash -c \"\$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\""
+        echo "2. Install Python: brew install python"
+        echo "   OR download from: https://www.python.org/downloads/"
+    elif [ "$MACHINE" = "Linux" ]; then
+        echo "To install Python on Linux:"
+        echo "Ubuntu/Debian: sudo apt update && sudo apt install python3 python3-pip"
+        echo "CentOS/RHEL: sudo yum install python3 python3-pip"
+        echo "Fedora: sudo dnf install python3 python3-pip"
+    fi
+    echo
+    echo "After installing Python, run this script again."
+    exit 1
+fi
+
+echo "Python found: $($PYTHON_CMD --version)"
+
+# Check if pip is available
+if ! $PYTHON_CMD -m pip --version >/dev/null 2>&1; then
+    echo "pip is not available. Installing pip..."
+    if [ "$MACHINE" = "Mac" ]; then
+        curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
+        $PYTHON_CMD get-pip.py
+        rm get-pip.py
+    elif [ "$MACHINE" = "Linux" ]; then
+        echo "Please install pip using your package manager:"
+        echo "Ubuntu/Debian: sudo apt install python3-pip"
+        echo "CentOS/RHEL: sudo yum install python3-pip"
+        exit 1
+    fi
+fi
+
+# Check if GUI is already set up
+if [ -f "gui_main.py" ]; then
+    echo "GUI application already set up."
+    echo
+else
+    echo
+    echo "Installing required packages..."
+    echo "==============================================="
+
+    # Upgrade pip first
+    $PYTHON_CMD -m pip install --upgrade pip
+
+    # Install requirements
+    if ! $PYTHON_CMD -m pip install -r requirements.txt; then
+        echo
+        echo "ERROR: Failed to install requirements."
+        echo "Please check your internet connection and try again."
+        echo "You may need to install additional system dependencies."
+
+        if [ "$MACHINE" = "Mac" ]; then
+            echo
+            echo "On macOS, you might need to install Xcode command line tools:"
+            echo "xcode-select --install"
+        elif [ "$MACHINE" = "Linux" ]; then
+            echo
+            echo "On Linux, you might need additional packages:"
+            echo "Ubuntu/Debian: sudo apt install python3-dev python3-tk"
+            echo "CentOS/RHEL: sudo yum install python3-devel tkinter"
+        fi
+        exit 1
+    fi
+
+    echo
+    echo "Requirements installed successfully!"
+    echo "Setting up GUI application..."
+fi
+
+# Check for Chrome browser
+if [ "$MACHINE" = "Mac" ]; then
+    if [ ! -d "/Applications/Google Chrome.app" ]; then
+        echo
+        echo "WARNING: Google Chrome not found."
+        echo "Please install Chrome from: https://www.google.com/chrome/"
+        echo "The scraper requires Chrome to function."
+    fi
+elif [ "$MACHINE" = "Linux" ]; then
+    if ! command_exists google-chrome && ! command_exists chromium-browser; then
+        echo
+        echo "WARNING: Chrome/Chromium not found."
+        echo "Please install Chrome or Chromium:"
+        echo "Ubuntu/Debian: sudo apt install chromium-browser"
+        echo "Or download Chrome from: https://www.google.com/chrome/"
+    fi
+fi
+
+echo
+echo "==============================================="
+echo "Installation complete!"
+echo "==============================================="
+
+# Run the GUI application
+if [ -f "gui_main.py" ]; then
+    echo "Starting EBoek.info Scraper GUI..."
+    echo
+    if ! $PYTHON_CMD gui_main.py; then
+        echo
+        echo "GUI failed to start. You can still use the terminal version:"
+        echo "$PYTHON_CMD main.py"
+        echo
+    fi
+else
+    echo "GUI version not found. Running terminal version..."
+    echo
+    if [ -f "main.py" ]; then
+        $PYTHON_CMD main.py
+    else
+        echo "Error: No scraper found. Please check installation."
+        exit 1
+    fi
+fi
+
+echo
+echo "Application closed."
+echo "Press Enter to exit..."
+read

main.py

@@ -1,258 +0,0 @@
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.common.keys import Keys
-from selenium.webdriver.chrome.options import Options
-import time
-import random
-import os
-
-# Disable SSL verification warnings and errors
-import urllib3
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-class Scraper:
-    def __init__(self, headless=False):
-        chrome_options = Options()
-        if headless:
-            chrome_options.add_argument('--headless')
-        
-        # Fix SSL and certificate issues
-        chrome_options.add_argument('--ignore-ssl-errors')
-        chrome_options.add_argument('--ignore-certificate-errors')
-        chrome_options.add_argument('--disable-web-security')
-        chrome_options.add_argument('--allow-running-insecure-content')
-        chrome_options.add_argument('--disable-extensions')
-        
-        # Fix DevTools connection issues
-        chrome_options.add_argument('--remote-debugging-port=0')
-        chrome_options.add_argument('--disable-dev-shm-usage')
-        chrome_options.add_argument('--no-sandbox')
-        
-        # Make it look more human
-        chrome_options.add_argument('--disable-blink-features=AutomationControlled')
-        chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
-        chrome_options.add_experimental_option('useAutomationExtension', False)
-        chrome_options.add_argument('user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')
-        
-        # Suppress logging
-        chrome_options.add_experimental_option('excludeSwitches', ['enable-logging'])
-        chrome_options.add_experimental_option('useAutomationExtension', False)
-        chrome_options.add_argument('--disable-logging')
-        chrome_options.add_argument('--log-level=3')
-        
-        self.driver = webdriver.Chrome(options=chrome_options)
-        self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
-    
-    def human_delay(self, min_sec=0.5, max_sec=2):
-        time.sleep(random.uniform(min_sec, max_sec))
-    
-    def human_type(self, element, text):
-        for char in text:
-            element.send_keys(char)
-            time.sleep(random.uniform(0.05, 0.15))
-    
-    def navigate(self, url):
-        self.driver.get(url)
-        self.human_delay(1, 3)
-    
-    def login(self, username, password):
-        self.driver.get("https://eboek.info/komerin")
-        self.human_delay(2, 4)
-        
-        # Direct selectors based on what worked
-        username_field = self.driver.find_element(By.CSS_SELECTOR, "input[type='text']")
-        self.human_type(username_field, username)
-        
-        self.human_delay(0.5, 1)
-        
-        password_field = self.driver.find_element(By.CSS_SELECTOR, "input[type='password']")
-        self.human_type(password_field, password)
-        
-        self.human_delay(0.5, 1.5)
-        
-        submit_button = self.driver.find_element(By.CSS_SELECTOR, "input[type='submit']")
-        submit_button.click()
-        
-        self.human_delay(2, 4)
-    
-    def trigger_download(self, url):
-        """Open URL in new tab to trigger browser download"""
-        # Store current window handle
-        current_window = self.driver.current_window_handle
-        
-        # Use JavaScript to open URL in new tab with same session
-        self.driver.execute_script(f"window.open('{url}', '_blank');")
-        
-        # Wait for download to complete and tab to auto-close
-        self.human_delay(3, 5)
-        
-        # Switch back to original window
-        self.driver.switch_to.window(current_window)
-        
-        print(f"Download triggered for: {url}")
-    
-    def scrape(self, start_page=1, end_page=1):
-        """Scrape comics from specified page range"""
-        base_url = "https://eboek.info/stripverhalen-alle"
-        
-        for page_num in range(start_page, end_page + 1):
-            # Construct page URL
-            if page_num == 1:
-                page_url = base_url
-            else:
-                page_url = f"{base_url}/page/{page_num}/"
-            
-            print(f"\n{'='*50}")
-            print(f"Processing page {page_num}: {page_url}")
-            print(f"{'='*50}")
-            
-            # Navigate to the page
-            self.navigate(page_url)
-            
-            # Scroll down a bit like a human would to see content
-            self.driver.execute_script("window.scrollTo(0, 300)")
-            self.human_delay(1, 2)
-            
-            # Find all comic strip links
-            comic_links = self.driver.find_elements(By.CSS_SELECTOR, 'h2.post-title a')
-            
-            print(f"Found {len(comic_links)} comic strips on page {page_num}")
-            
-            # Store URLs first to avoid stale element issues
-            comic_urls = [link.get_attribute('href') for link in comic_links]
-            
-            # Take a break between pages (more likely and longer)
-            if page_num > start_page:
-                if random.random() < 0.7:  # 70% chance of break
-                    break_time = random.uniform(15, 45)  # 15-45 seconds
-                    print(f"\nTaking a break between pages for {break_time:.1f} seconds...")
-                    time.sleep(break_time)
-                else:
-                    # Even if no long break, always pause a bit
-                    short_break = random.uniform(5, 10)
-                    print(f"\nQuick pause for {short_break:.1f} seconds...")
-                    time.sleep(short_break)
-            
-            # Process all comics on this page
-            for i, url in enumerate(comic_urls, 1):
-                print(f"\nProcessing comic {i}/{len(comic_urls)} on page {page_num}: {url}")
-                
-                # Random chance to scroll on main page before clicking
-                if random.random() < 0.4:
-                    scroll_amount = random.randint(100, 500)
-                    self.driver.execute_script(f"window.scrollBy(0, {scroll_amount})")
-                    self.human_delay(0.5, 1.5)
-                
-                # Open in new tab to keep main page
-                self.driver.execute_script("window.open('');")
-                self.driver.switch_to.window(self.driver.window_handles[-1])
-                
-                try:
-                    self.driver.get(url)
-                    self.human_delay(2, 4)
-                    
-                    # Sometimes scroll down to see the content
-                    if random.random() < 0.6:
-                        self.driver.execute_script("window.scrollTo(0, 400)")
-                        self.human_delay(0.5, 1.5)
-                    
-                    # Extract title
-                    title = self.driver.find_element(By.CSS_SELECTOR, 'h1.entry-title').text
-                    print(f"Title: {title}")
-                    
-                    # Small delay before clicking download
-                    self.human_delay(0.8, 2)
-                    
-                    # Execute the downloadLinks() JavaScript function
-                    self.driver.execute_script("downloadLinks()")
-                    self.human_delay(1.5, 3)
-                    
-                    # Find all download links in the table
-                    download_links = self.driver.find_elements(By.CSS_SELECTOR, 'table a')
-                    
-                    print(f"Found {len(download_links)} download links")
-                    
-                    # Trigger download for each file
-                    for j, link in enumerate(download_links):
-                        file_url = link.get_attribute('href')
-                        file_name = link.text.strip()
-                        
-                        print(f"Triggering download: {file_name}")
-                        self.trigger_download(file_url)
-                        
-                        # Human-like delay between downloads
-                        if j < len(download_links) - 1:
-                            # Longer delay for multiple downloads (human would wait and check)
-                            delay_time = random.uniform(2, 5)
-                            print(f"Waiting {delay_time:.1f} seconds before next download...")
-                            time.sleep(delay_time)
-                    
-                    # Take a longer break every 5 comics
-                    if i % 5 == 0 and i < len(comic_urls):
-                        break_time = random.uniform(3, 7)
-                        print(f"\nTaking a break for {break_time:.1f} seconds...")
-                        time.sleep(break_time)
-                    
-                except Exception as e:
-                    print(f"Error processing {url}: {e}")
-                    # Human would pause after an error
-                    self.human_delay(2, 4)
-                
-                # Close tab and switch back
-                self.driver.close()
-                self.driver.switch_to.window(self.driver.window_handles[0])
-                
-                # Vary the delay between comics
-                self.human_delay(1, 3)
-    
-    def close(self):
-        self.driver.quit()
-
-def update_credentials_in_file(username, password):
-    """Update the credentials in this file for future use"""
-    # Read the current file
-    with open(__file__, 'r', encoding='utf-8') as f:
-        content = f.read()
-    
-    # Replace the placeholder credentials
-    content = content.replace('scraper.login("xxx", "yyy")', 
-                             f'scraper.login("{username}", "{password}")')
-    
-    # Write back to file
-    with open(__file__, 'w', encoding='utf-8') as f:
-        f.write(content)
-    
-    print("Credentials saved for future use!")
-
-if __name__ == "__main__":
-    # Check if credentials need to be set
-    username = "jouw_gebruikersnaam"
-    password = "jouw_wachtwoord"
-    
-    if username == "jouw_gebruikersnaam" or password == "jouw_wachtwoord":
-        print("First time setup: Please enter your EBoek.info credentials")
-        new_username = input("Username: ")
-        new_password = input("Password: ")
-        
-        # Update the file with new credentials
-        update_credentials_in_file(new_username, new_password)
-        
-        # Use the new credentials
-        username = new_username
-        password = new_password
-    
-    scraper = Scraper()
-    
-    # Login first
-    scraper.login(username, password)
-    
-    # Ask which page(s) to scrape
-    start = int(input("Enter start page number (1 for first page): "))
-    end = int(input("Enter end page number (same as start for single page): "))
-    
-    # Scrape the specified pages
-    scraper.scrape(start_page=start, end_page=end)
-    
-    # Keep browser open
-    input("\nDone! Press Enter to close the browser...")
-    scraper.close()

requirements.txt

@@ -1,2 +1,3 @@
-selenium
-urllib3
+selenium>=4.0
+urllib3>=1.26
+PyQt5>=5.15.0

start.bat

@@ -1,3 +0,0 @@
-@echo off
-cd /d %~dp0
-start cmd /k "python main.py"

tests/test_core.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Basic test script for core functionality without GUI dependencies.
+"""
+
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+def test_imports():
+    """Test that core modules can be imported."""
+    print("Testing core module imports...")
+
+    try:
+        from core.credentials import CredentialManager
+        print("✓ CredentialManager import successful")
+
+        from utils.validators import validate_page_range, validate_username, validate_password
+        print("✓ Validators import successful")
+
+        from core.scraper import Scraper
+        print("✓ Scraper import successful")
+
+        return True
+    except Exception as e:
+        print(f"✗ Import failed: {e}")
+        return False
+
+def test_credential_manager():
+    """Test basic credential manager functionality."""
+    print("\nTesting credential manager...")
+
+    try:
+        from core.credentials import CredentialManager
+        cm = CredentialManager("test_app")
+
+        # Test default settings
+        defaults = cm.get_default_settings()
+        print(f"✓ Default settings: {len(defaults)} items")
+
+        # Test validation
+        validation = cm.validate_credentials("testuser", "testpass")
+        print(f"✓ Credential validation: {validation['valid']}")
+
+        # Test config file path
+        config_path = cm.get_config_file_path()
+        print(f"✓ Config file path: {config_path}")
+
+        return True
+    except Exception as e:
+        print(f"✗ Credential manager test failed: {e}")
+        return False
+
+def test_validators():
+    """Test validation functions."""
+    print("\nTesting validators...")
+
+    try:
+        from utils.validators import validate_page_range, validate_username, validate_password
+
+        # Test page range validation
+        valid_range = validate_page_range(1, 5)
+        print(f"✓ Valid page range (1-5): {valid_range['valid']}")
+
+        invalid_range = validate_page_range(5, 1)
+        print(f"✓ Invalid page range (5-1): {not invalid_range['valid']}")
+
+        # Test username validation
+        valid_username = validate_username("testuser")
+        print(f"✓ Valid username: {valid_username['valid']}")
+
+        invalid_username = validate_username("")
+        print(f"✓ Invalid username (empty): {not invalid_username['valid']}")
+
+        # Test password validation
+        valid_password = validate_password("password123")
+        print(f"✓ Valid password: {valid_password['valid']}")
+
+        invalid_password = validate_password("")
+        print(f"✓ Invalid password (empty): {not invalid_password['valid']}")
+
+        return True
+    except Exception as e:
+        print(f"✗ Validator test failed: {e}")
+        return False
+
+def test_scraper_init():
+    """Test scraper initialization without actually running it."""
+    print("\nTesting scraper initialization...")
+
+    try:
+        # Test importing selenium
+        import selenium
+        print(f"✓ Selenium available: {selenium.__version__}")
+
+        # Test callback mechanism
+        events = []
+
+        def test_callback(event_type, data):
+            events.append((event_type, data))
+
+        print("✓ Callback mechanism ready")
+
+        # We won't actually create a Scraper instance since it requires Chrome
+        # but we can test that the class is properly defined
+        from core.scraper import Scraper
+
+        # Check that the class has the expected methods
+        expected_methods = ['login', 'scrape', 'trigger_download', 'human_delay', 'close']
+        for method in expected_methods:
+            if hasattr(Scraper, method):
+                print(f"✓ Scraper has {method} method")
+            else:
+                print(f"✗ Scraper missing {method} method")
+                return False
+
+        return True
+    except Exception as e:
+        print(f"✗ Scraper test failed: {e}")
+        return False
+
+def test_project_structure():
+    """Test that all expected files are present."""
+    print("\nTesting project structure...")
+
+    expected_files = [
+        "core/__init__.py",
+        "core/scraper.py",
+        "core/credentials.py",
+        "core/scraper_thread.py",
+        "gui/__init__.py",
+        "gui/main_window.py",
+        "gui/login_dialog.py",
+        "gui/progress_dialog.py",
+        "utils/__init__.py",
+        "utils/validators.py",
+        "gui_main.py",
+        "requirements.txt",
+        "install_and_run.bat",
+        "install_and_run.sh"
+    ]
+
+    missing_files = []
+    for file_path in expected_files:
+        full_path = project_root / file_path
+        if full_path.exists():
+            print(f"✓ {file_path}")
+        else:
+            print(f"✗ {file_path} missing")
+            missing_files.append(file_path)
+
+    if missing_files:
+        print(f"\nMissing files: {len(missing_files)}")
+        return False
+    else:
+        print(f"\n✓ All {len(expected_files)} expected files present")
+        return True
+
+def main():
+    """Run all tests."""
+    print("=== EBoek.info Scraper Core Test ===\n")
+
+    tests = [
+        ("Project Structure", test_project_structure),
+        ("Module Imports", test_imports),
+        ("Credential Manager", test_credential_manager),
+        ("Validators", test_validators),
+        ("Scraper Initialization", test_scraper_init),
+    ]
+
+    results = []
+
+    for test_name, test_func in tests:
+        print(f"\n{'='*50}")
+        print(f"Running: {test_name}")
+        print('='*50)
+
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"✗ Test '{test_name}' crashed: {e}")
+            results.append((test_name, False))
+
+    # Summary
+    print(f"\n{'='*50}")
+    print("TEST SUMMARY")
+    print('='*50)
+
+    passed = 0
+    failed = 0
+
+    for test_name, result in results:
+        status = "PASS" if result else "FAIL"
+        symbol = "✓" if result else "✗"
+        print(f"{symbol} {test_name}: {status}")
+
+        if result:
+            passed += 1
+        else:
+            failed += 1
+
+    print(f"\nResults: {passed} passed, {failed} failed")
+
+    if failed == 0:
+        print("\n🎉 All tests passed! The core functionality is ready.")
+        print("\nNext steps:")
+        print("1. Install PyQt5: pip install PyQt5")
+        print("2. Run the GUI: python3 gui_main.py")
+        print("3. Or use the installer: ./install_and_run.sh")
+    else:
+        print(f"\n⚠️  {failed} test(s) failed. Please check the errors above.")
+
+    return failed == 0
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

tests/test_scraping_modes.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Test script for the new dual scraping mode functionality.
+"""
+
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+
+def test_url_construction():
+    """Test URL construction for both scraping modes."""
+    print("Testing URL construction logic...")
+
+    # Test Mode 0: All Comics
+    print("\n=== Mode 0: All Comics (stripverhalen-alle) ===")
+    mode = 0
+    base_url = "https://eboek.info/stripverhalen-alle" if mode == 0 else "https://eboek.info/laatste"
+
+    for page_num in [1, 2, 5, 10]:
+        if mode == 1:  # Latest Comics
+            page_url = f"{base_url}?_page={page_num}&ref=dw"
+        else:  # All Comics
+            if page_num == 1:
+                page_url = base_url
+            else:
+                page_url = f"{base_url}/page/{page_num}/"
+
+        print(f"Page {page_num}: {page_url}")
+
+    # Test Mode 1: Latest Comics
+    print("\n=== Mode 1: Latest Comics (laatste) ===")
+    mode = 1
+    base_url = "https://eboek.info/stripverhalen-alle" if mode == 0 else "https://eboek.info/laatste"
+
+    for page_num in [1, 2, 5, 10]:
+        if mode == 1:  # Latest Comics
+            page_url = f"{base_url}?_page={page_num}&ref=dw"
+        else:  # All Comics
+            if page_num == 1:
+                page_url = base_url
+            else:
+                page_url = f"{base_url}/page/{page_num}/"
+
+        print(f"Page {page_num}: {page_url}")
+
+    print("\n✓ URL construction logic working correctly!")
+
+
+def test_scraper_modes():
+    """Test Scraper class with different modes."""
+    print("\nTesting Scraper class mode support...")
+
+    try:
+        from core.scraper import Scraper
+
+        # Test Mode 0 (All Comics)
+        scraper_mode_0 = Scraper(headless=True, scraping_mode=0)
+        print(f"✓ Mode 0 scraper created, mode = {scraper_mode_0.scraping_mode}")
+
+        # Test Mode 1 (Latest Comics)
+        scraper_mode_1 = Scraper(headless=True, scraping_mode=1)
+        print(f"✓ Mode 1 scraper created, mode = {scraper_mode_1.scraping_mode}")
+
+        # Test default mode
+        scraper_default = Scraper(headless=True)
+        print(f"✓ Default scraper created, mode = {scraper_default.scraping_mode}")
+
+        # Clean up (don't actually initialize Chrome)
+        # We're just testing the constructor parameters
+
+        print("✓ Scraper class mode support working!")
+
+    except Exception as e:
+        print(f"✗ Scraper test failed: {e}")
+        return False
+
+    return True
+
+
+def test_thread_modes():
+    """Test ScraperThread class with different modes."""
+    print("\nTesting ScraperThread class mode support...")
+
+    try:
+        from core.scraper_thread import ScraperThread
+
+        # Test with different modes
+        thread_mode_0 = ScraperThread("test", "test", 1, 1, scraping_mode=0, headless=True)
+        print(f"✓ Mode 0 thread created, mode = {thread_mode_0.scraping_mode}")
+
+        thread_mode_1 = ScraperThread("test", "test", 1, 1, scraping_mode=1, headless=True)
+        print(f"✓ Mode 1 thread created, mode = {thread_mode_1.scraping_mode}")
+
+        thread_default = ScraperThread("test", "test", 1, 1, headless=True)
+        print(f"✓ Default thread created, mode = {thread_default.scraping_mode}")
+
+        print("✓ ScraperThread class mode support working!")
+
+    except Exception as e:
+        print(f"✗ ScraperThread test failed: {e}")
+        return False
+
+    return True
+
+
+def test_credential_manager():
+    """Test CredentialManager with new default settings."""
+    print("\nTesting CredentialManager default settings...")
+
+    try:
+        from core.credentials import CredentialManager
+
+        cm = CredentialManager("test_scraping_modes")
+        defaults = cm.get_default_settings()
+
+        print(f"Default settings: {defaults}")
+
+        expected_keys = ['scraping_mode', 'headless_mode', 'verbose_logging',
+                        'default_start_page', 'default_end_page']
+
+        for key in expected_keys:
+            if key in defaults:
+                print(f"✓ {key}: {defaults[key]}")
+            else:
+                print(f"✗ Missing key: {key}")
+                return False
+
+        if defaults['scraping_mode'] == 0:
+            print("✓ Default scraping mode is 0 (All Comics)")
+        else:
+            print(f"⚠️  Unexpected default scraping mode: {defaults['scraping_mode']}")
+
+        print("✓ CredentialManager default settings working!")
+
+    except Exception as e:
+        print(f"✗ CredentialManager test failed: {e}")
+        return False
+
+    return True
+
+
+def test_css_selectors():
+    """Test CSS selector logic for different page types."""
+    print("\nTesting CSS selector logic for different page types...")
+
+    # Test selector logic without actually connecting to Chrome
+    print("\n=== Mode 0: All Comics Page ===")
+    print("CSS Selector: 'h2.post-title a'")
+    print("✓ Uses original selector for stripverhalen-alle page structure")
+
+    print("\n=== Mode 1: Latest Comics Page ===")
+    print("CSS Selector: '.pt-cv-wrapper .pt-cv-ifield h5.pt-cv-title a'")
+    print("✓ Uses class-based selector for laatste page structure")
+    print("✓ Targets only title links to avoid duplicates (each comic has 2 links)")
+    print("✓ More robust than ID-based selector - classes are more stable")
+
+    print("\n✓ CSS selector logic correctly configured for both page types!")
+    return True
+
+
+def main():
+    """Run all tests."""
+    print("=== Dual Scraping Mode Functionality Test ===\n")
+
+    tests = [
+        ("URL Construction Logic", test_url_construction),
+        ("CSS Selector Logic", test_css_selectors),
+        ("Scraper Class Mode Support", test_scraper_modes),
+        ("ScraperThread Class Mode Support", test_thread_modes),
+        ("CredentialManager Defaults", test_credential_manager),
+    ]
+
+    passed = 0
+    failed = 0
+
+    for test_name, test_func in tests:
+        print(f"\n{'='*50}")
+        print(f"Running: {test_name}")
+        print('='*50)
+
+        try:
+            result = test_func()
+            if result is None:
+                result = True  # Functions that don't return boolean
+
+            if result:
+                passed += 1
+                print(f"✅ {test_name}: PASSED")
+            else:
+                failed += 1
+                print(f"❌ {test_name}: FAILED")
+
+        except Exception as e:
+            failed += 1
+            print(f"❌ {test_name}: CRASHED - {e}")
+
+    # Summary
+    print(f"\n{'='*50}")
+    print("TEST SUMMARY")
+    print('='*50)
+    print(f"✅ Passed: {passed}")
+    print(f"❌ Failed: {failed}")
+
+    if failed == 0:
+        print(f"\n🎉 All tests passed! Dual scraping mode feature is ready!")
+        print("\nThe GUI now supports:")
+        print("• Mode 0: All Comics (stripverhalen-alle) - Original functionality")
+        print("• Mode 1: Latest Comics (laatste?_page=X&ref=dw) - New functionality")
+        print("\nReady to test in the GUI! 🚀")
+    else:
+        print(f"\n⚠️  {failed} test(s) failed. Please review the errors above.")
+
+    return failed == 0
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

utils/__init__.py

@@ -0,0 +1 @@
+# Utility functions for validation and helpers

utils/validators.py

@@ -0,0 +1,319 @@
+"""
+Input validation utilities for the EBoek.info scraper GUI.
+"""
+
+import re
+from urllib.parse import urlparse
+
+
+def validate_page_range(start_page, end_page):
+    """
+    Validate page range input.
+
+    Args:
+        start_page (int or str): Starting page number
+        end_page (int or str): Ending page number
+
+    Returns:
+        dict: Validation result with 'valid' bool, 'errors' list, and cleaned values
+    """
+    errors = []
+    cleaned_start = None
+    cleaned_end = None
+
+    # Convert to integers
+    try:
+        cleaned_start = int(start_page)
+    except (ValueError, TypeError):
+        errors.append("Start page must be a valid number")
+
+    try:
+        cleaned_end = int(end_page)
+    except (ValueError, TypeError):
+        errors.append("End page must be a valid number")
+
+    # Validate range if both are valid numbers
+    if cleaned_start is not None and cleaned_end is not None:
+        if cleaned_start < 1:
+            errors.append("Start page must be 1 or greater")
+        if cleaned_end < 1:
+            errors.append("End page must be 1 or greater")
+        if cleaned_start > cleaned_end:
+            errors.append("Start page cannot be greater than end page")
+        if cleaned_end - cleaned_start > 100:
+            errors.append("Page range too large (maximum 100 pages at once)")
+
+    return {
+        'valid': len(errors) == 0,
+        'errors': errors,
+        'start_page': cleaned_start,
+        'end_page': cleaned_end
+    }
+
+
+def validate_username(username):
+    """
+    Validate EBoek.info username.
+
+    Args:
+        username (str): Username to validate
+
+    Returns:
+        dict: Validation result with 'valid' bool and 'errors' list
+    """
+    errors = []
+
+    if not username:
+        errors.append("Username is required")
+    else:
+        username = username.strip()
+        if len(username) < 2:
+            errors.append("Username must be at least 2 characters long")
+        elif len(username) > 50:
+            errors.append("Username is too long (maximum 50 characters)")
+        elif not re.match(r'^[a-zA-Z0-9_.-]+$', username):
+            errors.append("Username contains invalid characters (use only letters, numbers, _, ., -)")
+
+    return {
+        'valid': len(errors) == 0,
+        'errors': errors,
+        'username': username.strip() if username else ""
+    }
+
+
+def validate_password(password):
+    """
+    Validate EBoek.info password.
+
+    Args:
+        password (str): Password to validate
+
+    Returns:
+        dict: Validation result with 'valid' bool and 'errors' list
+    """
+    errors = []
+
+    if not password:
+        errors.append("Password is required")
+    else:
+        if len(password) < 3:
+            errors.append("Password must be at least 3 characters long")
+        elif len(password) > 128:
+            errors.append("Password is too long (maximum 128 characters)")
+
+    return {
+        'valid': len(errors) == 0,
+        'errors': errors
+    }
+
+
+def validate_url(url):
+    """
+    Validate URL format.
+
+    Args:
+        url (str): URL to validate
+
+    Returns:
+        dict: Validation result with 'valid' bool and 'errors' list
+    """
+    errors = []
+
+    if not url:
+        errors.append("URL is required")
+    else:
+        try:
+            parsed = urlparse(url)
+            if not parsed.scheme:
+                errors.append("URL must include protocol (http:// or https://)")
+            elif parsed.scheme not in ['http', 'https']:
+                errors.append("URL must use http:// or https://")
+            if not parsed.netloc:
+                errors.append("URL must include domain name")
+        except Exception:
+            errors.append("Invalid URL format")
+
+    return {
+        'valid': len(errors) == 0,
+        'errors': errors,
+        'url': url.strip() if url else ""
+    }
+
+
+def validate_file_path(file_path):
+    """
+    Validate file path format.
+
+    Args:
+        file_path (str): File path to validate
+
+    Returns:
+        dict: Validation result with 'valid' bool and 'errors' list
+    """
+    errors = []
+
+    if not file_path:
+        errors.append("File path is required")
+    else:
+        file_path = file_path.strip()
+        # Basic path validation - more specific validation would depend on OS
+        invalid_chars = ['<', '>', '|', '"', '*', '?']
+        for char in invalid_chars:
+            if char in file_path:
+                errors.append(f"File path contains invalid character: {char}")
+                break
+
+        if len(file_path) > 255:
+            errors.append("File path is too long (maximum 255 characters)")
+
+    return {
+        'valid': len(errors) == 0,
+        'errors': errors,
+        'path': file_path.strip() if file_path else ""
+    }
+
+
+def sanitize_filename(filename):
+    """
+    Sanitize a filename for safe storage.
+
+    Args:
+        filename (str): Original filename
+
+    Returns:
+        str: Sanitized filename safe for most file systems
+    """
+    if not filename:
+        return "download"
+
+    # Replace invalid characters with underscores
+    invalid_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
+    sanitized = filename
+    for char in invalid_chars:
+        sanitized = sanitized.replace(char, '_')
+
+    # Remove leading/trailing whitespace and dots
+    sanitized = sanitized.strip(' .')
+
+    # Ensure it's not empty and not too long
+    if not sanitized:
+        sanitized = "download"
+    elif len(sanitized) > 200:
+        sanitized = sanitized[:200]
+
+    return sanitized
+
+
+def validate_settings(settings):
+    """
+    Validate application settings dictionary.
+
+    Args:
+        settings (dict): Settings to validate
+
+    Returns:
+        dict: Validation result with 'valid' bool, 'errors' list, and cleaned settings
+    """
+    errors = []
+    cleaned_settings = {}
+
+    # Validate headless_mode
+    if 'headless_mode' in settings:
+        if isinstance(settings['headless_mode'], bool):
+            cleaned_settings['headless_mode'] = settings['headless_mode']
+        else:
+            errors.append("Headless mode must be true or false")
+
+    # Validate verbose_logging
+    if 'verbose_logging' in settings:
+        if isinstance(settings['verbose_logging'], bool):
+            cleaned_settings['verbose_logging'] = settings['verbose_logging']
+        else:
+            errors.append("Verbose logging must be true or false")
+
+    # Validate auto_save_credentials
+    if 'auto_save_credentials' in settings:
+        if isinstance(settings['auto_save_credentials'], bool):
+            cleaned_settings['auto_save_credentials'] = settings['auto_save_credentials']
+        else:
+            errors.append("Auto save credentials must be true or false")
+
+    # Validate download_path
+    if 'download_path' in settings:
+        path_validation = validate_file_path(settings['download_path'])
+        if path_validation['valid']:
+            cleaned_settings['download_path'] = path_validation['path']
+        else:
+            errors.extend(path_validation['errors'])
+
+    # Validate default pages
+    for page_key in ['default_start_page', 'default_end_page']:
+        if page_key in settings:
+            try:
+                page_num = int(settings[page_key])
+                if page_num < 1:
+                    errors.append(f"{page_key.replace('_', ' ').title()} must be 1 or greater")
+                else:
+                    cleaned_settings[page_key] = page_num
+            except (ValueError, TypeError):
+                errors.append(f"{page_key.replace('_', ' ').title()} must be a valid number")
+
+    return {
+        'valid': len(errors) == 0,
+        'errors': errors,
+        'settings': cleaned_settings
+    }
+
+
+def format_error_message(errors):
+    """
+    Format a list of error messages into a user-friendly string.
+
+    Args:
+        errors (list): List of error messages
+
+    Returns:
+        str: Formatted error message
+    """
+    if not errors:
+        return ""
+    elif len(errors) == 1:
+        return errors[0]
+    else:
+        return "Multiple errors:\n• " + "\n• ".join(errors)
+
+
+def is_safe_string(text, max_length=1000):
+    """
+    Check if a string is safe for display/storage (no dangerous content).
+
+    Args:
+        text (str): Text to check
+        max_length (int): Maximum allowed length
+
+    Returns:
+        bool: True if string is safe, False otherwise
+    """
+    if not isinstance(text, str):
+        return False
+
+    if len(text) > max_length:
+        return False
+
+    # Check for potential script injection or dangerous content
+    dangerous_patterns = [
+        '<script',
+        'javascript:',
+        'data:',
+        'vbscript:',
+        '<?php',
+        '<%',
+        '${',
+    ]
+
+    text_lower = text.lower()
+    for pattern in dangerous_patterns:
+        if pattern in text_lower:
+            return False
+
+    return True