v1.1.0

2026-07-18 13:40:27 +02:00 · 2025-07-11 11:09:24 +03:00
parent 3a87fb032f efe0c48877
commit c9450d2ca5
18 changed files with 1272 additions and 232 deletions
@@ -1,6 +1,10 @@
-# v1.1.0 (pre-release)
+# v1.1.0
+- Added queue system for processing multiple items, allowing users to add multiple files and process them in a queue, mentioned by @jborza in #30 (Special thanks to @jborza for implementing this feature in PR #35)
 - Added a feature that allows selecting multiple items in book handler (in right click menu) by @jborza in #31, that fixes #28
 - Added dark theme support, allowing users to switch between light and dark themes in the settings.
+- Added auto-accept system to the chapter options dialog in conversion process, allowing the dialog to auto-accept after a certain time if no action is taken.
+- Added new option: `Configure max lines in log window` that allows configuring the maximum number of lines to display in the log window.
+- Improvements in documentation and code.

 # v1.0.9
 - Added chunking/segmenting system that fixes memory outage issues when processing large audio files.
@@ -119,34 +119,58 @@ abogen

 Here’s Abogen in action: in this demo, it processes ∼3,000 characters of text in just 11 seconds and turns it into 3 minutes and 28 seconds of audio, and I have a low-end **RTX 2060 Mobile laptop GPU**. Your results may vary depending on your hardware.

-## `Key Features`
- **Supported formats**: `ePub`, `PDF`, or `.TXT` files (or use built-in text editor)
- **Speed**: Adjust speech rate from `0.1x` to `2.0x`
- **Voices**: First letter of the language code (e.g., `a` for American English, `b` for British English, etc.), second letter is for `m` for male and `f` for female.
- **Voice mixer**: Create custom voices by mixing different voice models with a profile system.
- **Generate subtitles**: `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry)
- **Output formats**: `.WAV`, `.FLAC`, `.MP3`, `.OPUS` and `M4B (with chapters)` (Special thanks to [@jborza](https://github.com/jborza) for chapter support in PR [#10](https://github.com/denizsafak/abogen/pull/10))
- **Save location**: `Save next to input file`, `Save to desktop`, or `Choose output folder`
- **Chapter Control**: Select specific `chapters` from ePUBs or `chapters + pages` from PDFs.
- **Save each chapter separately**: Save each chapter in e-books as a separate audio file.
- **Project folder**: Save the converted items in a project folder with available metadata files.
- **Options**:
-    - **Replace single newlines with spaces**: Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks.
-    - **Configure max words per subtitle**: Configures the maximum number of words per subtitle entry.
-    - **Subtitle format**: Configures the subtitle format as `srt`, `ass (wide)`, `ass (narrow)`, `ass (centered wide)`, or `ass (centered narrow)`.
-    - **Separate chapters audio format**: Configures the audio format for separate chapters as `wav`, `flac`, `mp3`, or `opus`.
-    - **Create desktop shortcut**: Creates a shortcut on your desktop for easy access.
-    - **Open config.json directory**: Opens the directory where the configuration file is stored.
-    - **Open temp directory**: Opens the temporary directory where converted text files are stored.
-    - **Clear temporary files**: Deletes temporary files created during the conversion or preview.
-    - **Check for updates at startup**: Automatically checks for updates when the program starts.
- **After conversion**: `Open file`, `Go to folder`, `New conversion`, or `Go back`.
+## `Configuration`
+
+| Options | Description |
+|---------|-------------|
+| **Input Box** | Drag and drop `ePub`, `PDF`, or `.TXT` files (or use built-in text editor) |
+| **Queue options** | Add multiple files to a queue and process them in batch, with individual settings for each file. See [Queue mode](#queue-mode) for more details. |
+| **Speed** | Adjust speech rate from `0.1x` to `2.0x` |
+| **Select Voice** | First letter of the language code (e.g., `a` for American English, `b` for British English, etc.), second letter is for `m` for male and `f` for female. |
+| **Voice mixer** | Create custom voices by mixing different voice models with a profile system. See [Voice Mixer](#voice-mixer) for more details. |
+| **Voice preview** | Listen to the selected voice before processing. |
+| **Generate subtitles** | `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry) |
+| **Output voice format** | `.WAV`, `.FLAC`, `.MP3`, `.OPUS (best compression)` and `M4B (with chapters)` (Special thanks to [@jborza](https://github.com/jborza) for chapter support in PR [#10](https://github.com/denizsafak/abogen/pull/10)) |
+| **Output subtitle format** | Configures the subtitle format as `SRT (standard)`, `ASS (wide)`, `ASS (narrow)`, `ASS (centered wide)`, or `ASS (centered narrow)`. |
+| **Replace single newlines with spaces** | Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks. |
+| **Save location** | `Save next to input file`, `Save to desktop`, or `Choose output folder` |
+
+| Book handler options | Description |
+|---------|-------------|
+| **Chapter Control** | Select specific `chapters` from ePUBs or `chapters + pages` from PDFs. |
+| **Save each chapter separately** | Save each chapter in e-books as a separate audio file. |
+| **Create a merged version** | Create a single audio file that combines all chapters. (If `Save each chapter separately` is disabled, this option will be the default behavior.) |
+| **Save in a project folder with metadata** | Save the converted items in a project folder with available metadata files. |
+
+| Menu options | Description |
+|---------|-------------|
+| **Theme** | Change the application's theme using `System`, `Light`, or `Dark` options. |
+| **Configure max words per subtitle** | Configures the maximum number of words per subtitle entry. |
+| **Configure max lines in log window** | Configures the maximum number of lines to display in the log window. |
+| **Separate chapters audio format** | Configures the audio format for separate chapters as `wav`, `flac`, `mp3`, or `opus`. |
+| **Create desktop shortcut** | Creates a shortcut on your desktop for easy access. |
+| **Open config.json directory** | Opens the directory where the configuration file is stored. |
+| **Open temp directory** | Opens the temporary directory where converted text files are stored. |
+| **Clear temporary files** | Deletes temporary files created during the conversion or preview. |
+| **Check for updates at startup** | Automatically checks for updates when the program starts. |

 ## `Voice Mixer`
 <img title="Abogen Voice Mixer" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/voice_mixer.png'>

 With voice mixer, you can create custom voices by mixing different voice models. You can adjust the weight of each voice and save your custom voice as a profile for future use. The voice mixer allows you to create unique and personalized voices. (Huge thanks to [@jborza](https://github.com/jborza) for making this possible through his contributions in [#5](https://github.com/denizsafak/abogen/pull/5))

+## `Queue Mode`
+<img title="Abogen queue mode" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/queue.png'>
+
+Abogen supports **queue mode**, allowing you to add multiple files to a processing queue. This is useful if you want to convert several files in one batch.
+
+- You can add text files (`.txt`) directly using the **Add files** button in the Queue Manager. To add PDF or EPUB files, use the input box in the main window and click the **Add to Queue** button.
+- Each file in the queue keeps the configuration settings that were active when it was added. Changing the main window configuration afterward does **not** affect files already in the queue.
+- You can view each file's configuration by hovering over them.
+
+Abogen will process each item in the queue automatically, saving outputs as configured.
+> Special thanks to [@jborza](https://github.com/jborza) for adding queue mode in PR [#35](https://github.com/denizsafak/abogen/pull/35)
+
 ## `About Chapter Markers`
 When you process ePUB or PDF files, Abogen converts them into text files stored in your temporary directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:

@@ -257,12 +281,12 @@ Abogen is a standalone project, but it is inspired by and shares some similariti
 - [ebook2audiobook](https://github.com/DrewThomasson/ebook2audiobook): Convert ebooks to audiobooks with chapters and metadata using dynamic AI models and voice cloning

 ## `Roadmap`
- [ ] Add OCR scan feature for PDF files using docling.
+- [ ] Add OCR scan feature for PDF files using docling/teserract.
 - [x] Add chapter metadata for .m4a files. (Issue [#9](https://github.com/denizsafak/abogen/issues/9), PR [#10](https://github.com/denizsafak/abogen/pull/10))
 - [ ] Add support for different languages in GUI.
 - [x] Add voice formula feature that enables mixing different voice models. (Issue [#1](https://github.com/denizsafak/abogen/issues/1), PR [#5](https://github.com/denizsafak/abogen/pull/5))
 - [ ] Add support for kokoro-onnx (If it's necessary).
- [ ] Add dark mode.
+- [x] Add dark mode.

 ## `Troubleshooting`
 If you encounter any issues while running Abogen, try launching it from the command line with:
@@ -1 +1 @@
-1.0.9
+1.1.0
@@ -1,4 +1,4 @@
-from utils import get_version
+from abogen.utils import get_version

 # Program Information
 PROGRAM_NAME = "abogen"
@@ -8,6 +8,9 @@ PROGRAM_DESCRIPTION = (
 GITHUB_URL = "https://github.com/denizsafak/abogen"
 VERSION = get_version()

+# Settings
+CHAPTER_OPTIONS_COUNTDOWN = 30  # Countdown seconds for chapter options
+
 # Language description mapping
 LANGUAGE_DESCRIPTIONS = {
    "a": "American English",
@@ -106,9 +109,18 @@ SAMPLE_VOICE_TEXTS = {
 COLORS = {
    "BLUE": "#007dff",
    "RED": "#c0392b",
+    "GREEN": "#42ad4a",
+    "GREEN_BG": "rgba(66, 173, 73, 0.1)",
+    "GREEN_BG_HOVER": "rgba(66, 173, 73, 0.15)",
+    "GREEN_BORDER": "#42ad4a",
+    "BLUE_BG": "rgba(0, 102, 255, 0.05)",
+    "BLUE_BG_HOVER": "rgba(0, 102, 255, 0.1)",
+    "BLUE_BORDER_HOVER": "#6ab0de",
    "YELLOW_BACKGROUND": "rgba(255, 221, 51, 0.40)",
    "GREY_BACKGROUND": "rgba(128, 128, 128, 0.15)",
    "RED_BACKGROUND": "rgba(232, 78, 60, 0.15)",
+    "RED_BG": "rgba(232, 78, 60, 0.10)",
+    "RED_BG_HOVER": "rgba(232, 78, 60, 0.15)",
    # Theme palette colors
    "DARK_BG": "#202326",
    "DARK_BASE": "#141618",
@@ -6,18 +6,17 @@ import chardet
 import charset_normalizer
 import hashlib  # For generating unique cache filenames
 from platformdirs import user_desktop_dir
-from PyQt5.QtCore import QThread, pyqtSignal, Qt
+from PyQt5.QtCore import QThread, pyqtSignal, Qt, QTimer
 from PyQt5.QtWidgets import QCheckBox, QVBoxLayout, QDialog, QLabel, QDialogButtonBox
 import soundfile as sf
-from utils import clean_text, create_process
-from constants import PROGRAM_NAME, LANGUAGE_DESCRIPTIONS, SAMPLE_VOICE_TEXTS
-from voice_formulas import get_new_voice
-import hf_tracker
+from abogen.utils import clean_text, create_process
+from abogen.constants import PROGRAM_NAME, LANGUAGE_DESCRIPTIONS, SAMPLE_VOICE_TEXTS, COLORS, CHAPTER_OPTIONS_COUNTDOWN
+from abogen.voice_formulas import get_new_voice
+import abogen.hf_tracker as hf_tracker
 import static_ffmpeg
 import threading  # for efficient waiting
 import subprocess

-
 def get_sample_voice_text(lang_code):
    return SAMPLE_VOICE_TEXTS.get(lang_code, SAMPLE_VOICE_TEXTS["a"])

@@ -61,7 +60,7 @@ class ChapterOptionsDialog(QDialog):
        self.merge_at_end_checkbox = QCheckBox("Create a merged version at the end")

        # Set default states
-        self.save_separately_checkbox.setChecked(True)
+        self.save_separately_checkbox.setChecked(False)
        self.merge_at_end_checkbox.setChecked(True)

        # Connect checkbox state change signal
@@ -72,14 +71,36 @@ class ChapterOptionsDialog(QDialog):
        layout.addWidget(self.save_separately_checkbox)
        layout.addWidget(self.merge_at_end_checkbox)

+        # Countdown label
+        self.countdown_seconds = CHAPTER_OPTIONS_COUNTDOWN
+        self.countdown_label = QLabel(f"Auto-accepting in {self.countdown_seconds} seconds...")
+        self.countdown_label.setStyleSheet(f"color: {COLORS['GREEN']};")
+        layout.addWidget(self.countdown_label)
+
        # Add OK button
        button_box = QDialogButtonBox(QDialogButtonBox.Ok)
        button_box.accepted.connect(self.accept)
        layout.addWidget(button_box)

+        # Timer for countdown
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._on_timer_tick)
+        self._timer.start(1000)  # 1 second interval
+
+        # Store button_box for later use
+        self._button_box = button_box
+
        # Initialize merge checkbox state
        self.update_merge_checkbox_state()

+    def _on_timer_tick(self):
+        self.countdown_seconds -= 1
+        if self.countdown_seconds > 0:
+            self.countdown_label.setText(f"Auto-accepting in {self.countdown_seconds} seconds...")
+        else:
+            self._timer.stop()
+            self._button_box.accepted.emit()  # Simulate OK click
+
    def update_merge_checkbox_state(self):
        # Enable merge checkbox only if save separately is checked
        self.merge_at_end_checkbox.setEnabled(self.save_separately_checkbox.isChecked())
@@ -131,6 +152,7 @@ class ConversionThread(QThread):
        start_time,
        total_char_count,
        use_gpu=True,
+        from_queue=False
    ):  # Add use_gpu parameter
        super().__init__()
        self._chapter_options_event = threading.Event()
@@ -144,7 +166,10 @@ class ConversionThread(QThread):
        self.output_folder = output_folder
        self.subtitle_mode = subtitle_mode
        self.cancel_requested = False
+        self.should_cancel = False
+        self.process = None
        self.output_format = output_format
+        self.from_queue = from_queue
        self.start_time = start_time  # Store start_time
        self.total_char_count = total_char_count  # Use passed total character count
        self.processed_char_count = 0  # Initialize processed character count
@@ -316,15 +341,20 @@ class ConversionThread(QThread):
            hf_tracker.set_log_callback(lambda msg: self.log_updated.emit(msg))
            # Show configuration
            self.log_updated.emit("Configuration:")
-            # Use display_path for logs if available, otherwise use the actual file name
-            display_file = self.display_path if self.display_path else self.file_name
+            
+            # Use file_name for logs if from_queue, otherwise use display_path if available
+            if getattr(self, "from_queue", False):
+                display_file = self.file_name
+            else:
+                display_file = self.display_path if self.display_path else self.file_name
+
            self.log_updated.emit(f"- Input File: {display_file}")

            # Use file size string passed from GUI
            if hasattr(self, "file_size_str"):
                self.log_updated.emit(f"- File size: {self.file_size_str}")

-            self.log_updated.emit(f"- Total characters: {self.total_char_count:,}")
+            self.log_updated.emit(f"- Total characters: {int(self.total_char_count):,}")

            self.log_updated.emit(
                f"- Language: {self.lang_code} ({LANGUAGE_DESCRIPTIONS.get(self.lang_code, 'Unknown')})"
@@ -447,7 +477,14 @@ class ConversionThread(QThread):
            save_chapters_separately = getattr(self, "save_chapters_separately", False)
            chapters_out_dir = None
            suffix = ""
-            base_path = self.display_path if self.display_path else self.file_name
+
+
+            # Use file_name for logs if from_queue, otherwise use display_path if available
+            if getattr(self, "from_queue", False):
+                base_path = self.file_name
+            else:
+                base_path = self.display_path if self.display_path else self.file_name
+
            base_name = os.path.splitext(os.path.basename(base_path))[0]
            if self.save_option == "Save to Desktop":
                parent_dir = user_desktop_dir()
@@ -946,8 +983,13 @@ class ConversionThread(QThread):
        genre_match = re.search(r"<<METADATA_GENRE:([^>]*)>>", text)
        
        # Use display path or filename as fallback for title
-        filename = os.path.splitext(os.path.basename(self.display_path if self.display_path else self.file_name))[0]
        
+        # Use file_name for logs if from_queue, otherwise use display_path if available
+        if getattr(self, "from_queue", False):
+            filename = os.path.splitext(os.path.basename(self.file_name))[0]
+        else:
+            filename = os.path.splitext(os.path.basename(self.display_path if self.display_path else self.file_name))[0]
+
        if title_match:
            metadata_options.extend(["-metadata", f"title={title_match.group(1)}"])
        else:
@@ -1123,9 +1165,14 @@ class ConversionThread(QThread):

    def cancel(self):
        self.cancel_requested = True
-        self.waiting_for_user_input = (
-            False  # Also release the wait if we're waiting for input
-        )
+        self.should_cancel = True
+        self.waiting_for_user_input = False
+        # Terminate subprocess if running
+        if self.process:
+            try:
+                self.process.terminate()
+            except Exception:
+                pass


 class VoicePreviewThread(QThread):
@@ -7,9 +7,9 @@ from PyQt5.QtCore import qInstallMessageHandler, QtMsgType

 # Add the directory to Python path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__)))
-from gui import abogen
-from utils import get_resource_path
-from constants import PROGRAM_NAME, VERSION
+from abogen.gui import abogen
+from abogen.utils import get_resource_path
+from abogen.constants import PROGRAM_NAME, VERSION

 # Set environment variables for AMD ROCm
 os.environ["MIOPEN_FIND_MODE"] = "FAST"
@@ -0,0 +1,491 @@
+# a simple window with a list of items in the queue, no checkboxes
+# button to remove an item from the queue
+# button to clear the queue
+
+from PyQt5.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QDialogButtonBox,
+    QPushButton,
+    QListWidget,
+    QListWidgetItem,
+    QFileIconProvider,
+    QLabel,
+    QWidget,
+    QSizePolicy,
+)
+from PyQt5.QtCore import QFileInfo, Qt
+from abogen.constants import COLORS
+from copy import deepcopy
+from PyQt5.QtGui import QFontMetrics
+
+class ElidedLabel(QLabel):
+    def __init__(self, text, parent=None):
+        super().__init__(text, parent)
+        self._full_text = text
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+
+    def setText(self, text):
+        self._full_text = text
+        super().setText(text)
+        self.update()
+
+    def resizeEvent(self, event):
+        metrics = QFontMetrics(self.font())
+        elided = metrics.elidedText(self._full_text, Qt.ElideRight, self.width())
+        super().setText(elided)
+        super().resizeEvent(event)
+
+    def fullText(self):
+        return self._full_text
+
+class QueueListItemWidget(QWidget):
+    def __init__(self, file_name, char_count):
+        super().__init__()
+        layout = QHBoxLayout()
+        layout.setContentsMargins(12, 0, 6, 0)
+        layout.setSpacing(0)
+        import os
+        name_label = ElidedLabel(os.path.basename(file_name))
+        char_label = QLabel(f"Chars: {char_count}")
+        char_label.setStyleSheet(f"color: {COLORS['LIGHT_DISABLED']};")
+        char_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        char_label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
+        layout.addWidget(name_label, 1)
+        layout.addWidget(char_label, 0)
+        self.setLayout(layout)
+
+class DroppableQueueListWidget(QListWidget):
+    def __init__(self, parent_dialog):
+        super().__init__()
+        self.parent_dialog = parent_dialog
+        self.setAcceptDrops(True)
+        # Overlay for drag hover
+        self.drag_overlay = QLabel("", self)
+        self.drag_overlay.setAlignment(Qt.AlignCenter)
+        self.drag_overlay.setStyleSheet(
+            f"border:2px dashed {COLORS['BLUE_BORDER_HOVER']}; border-radius:5px; padding:20px; background:{COLORS['BLUE_BG_HOVER']};"
+        )
+        self.drag_overlay.setVisible(False)
+        self.drag_overlay.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+
+    def dragEnterEvent(self, event):
+        if event.mimeData().hasUrls():
+            for url in event.mimeData().urls():
+                if url.isLocalFile() and url.toLocalFile().lower().endswith('.txt'):
+                    self.drag_overlay.resize(self.size())
+                    self.drag_overlay.setVisible(True)
+                    event.acceptProposedAction()
+                    return
+        self.drag_overlay.setVisible(False)
+        event.ignore()
+
+    def dragMoveEvent(self, event):
+        if event.mimeData().hasUrls():
+            for url in event.mimeData().urls():
+                if url.isLocalFile() and url.toLocalFile().lower().endswith('.txt'):
+                    event.acceptProposedAction()
+                    return
+        event.ignore()
+
+    def dragLeaveEvent(self, event):
+        self.drag_overlay.setVisible(False)
+        event.accept()
+
+    def dropEvent(self, event):
+        self.drag_overlay.setVisible(False)
+        if event.mimeData().hasUrls():
+            file_paths = [url.toLocalFile() for url in event.mimeData().urls() if url.isLocalFile() and url.toLocalFile().lower().endswith('.txt')]
+            if file_paths:
+                self.parent_dialog.add_files_from_paths(file_paths)
+                event.acceptProposedAction()
+            else:
+                event.ignore()
+        else:
+            event.ignore()
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        if hasattr(self, 'drag_overlay'):
+            self.drag_overlay.resize(self.size())
+
+class QueueManager(QDialog):
+    def __init__(self, parent, queue: list, title="Queue Manager", size=(600, 700)):
+        super().__init__()
+        self.queue = queue
+        self._original_queue = deepcopy(queue)  # Store a deep copy of the original queue
+        self.parent = parent
+        layout = QVBoxLayout()
+        layout.setContentsMargins(15, 15, 15, 15)  # set main layout margins
+        layout.setSpacing(12)  # set spacing between widgets in main layout
+        # list of queued items
+        self.listwidget = DroppableQueueListWidget(self)
+        self.listwidget.setSelectionMode(QListWidget.ExtendedSelection)
+        self.listwidget.setAlternatingRowColors(True)
+        self.listwidget.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.listwidget.customContextMenuRequested.connect(self.show_context_menu)
+        # Add informative instructions at the top
+        instructions = QLabel(
+            "<h2>How Queue Works?</h2>"
+            "You can add text files (.txt) directly using the '<b>Add files</b>' button below. "
+            "To add PDF or EPUB files, use the input box in the main window and click the <b>'Add to Queue'</b> button. "
+            "Each file in the queue keeps the configuration settings active when it was added. "
+            "Changing the main window configuration afterward <b>does not</b> affect files already in the queue. "
+            "You can view each file's configuration by hovering over them."
+        )
+        instructions.setAlignment(Qt.AlignLeft)
+        instructions.setWordWrap(True)
+        instructions.setStyleSheet("margin-bottom: 8px;")
+        layout.addWidget(instructions)
+        # Overlay label for empty queue
+        self.empty_overlay = QLabel(
+            "Drag and drop your text files here or use the 'Add files' button.",
+            self.listwidget
+        )
+        self.empty_overlay.setAlignment(Qt.AlignCenter)
+        self.empty_overlay.setStyleSheet(f"color: {COLORS['LIGHT_DISABLED']}; background: transparent; padding: 20px;")
+        self.empty_overlay.setWordWrap(True)
+        self.empty_overlay.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+        self.empty_overlay.hide()
+        # add queue items to the list
+        self.process_queue()
+
+        button_row = QHBoxLayout()
+        button_row.setContentsMargins(0, 0, 0, 0)  # optional: no margins for button row
+        button_row.setSpacing(7)  # set spacing between buttons
+        # Add files button
+        add_files_button = QPushButton("Add files")
+        add_files_button.setFixedHeight(40)
+        add_files_button.clicked.connect(self.add_more_files)
+        button_row.addWidget(add_files_button)
+
+        # Remove button
+        self.remove_button = QPushButton("Remove selected")
+        self.remove_button.setFixedHeight(40)
+        self.remove_button.clicked.connect(self.remove_item)
+        button_row.addWidget(self.remove_button)
+
+        # Clear button
+        self.clear_button = QPushButton("Clear Queue")
+        self.clear_button.setFixedHeight(40)
+        self.clear_button.clicked.connect(self.clear_queue)
+        button_row.addWidget(self.clear_button)
+
+        layout.addLayout(button_row)
+        layout.addWidget(self.listwidget)
+
+        # Connect selection change to update button state
+        self.listwidget.currentItemChanged.connect(self.update_button_states)
+        self.listwidget.itemSelectionChanged.connect(self.update_button_states)
+
+        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self)
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+
+        layout.addWidget(buttons)
+
+        self.setLayout(layout)
+
+        self.setWindowTitle(title)
+        self.resize(*size)
+
+        self.update_button_states()
+
+    def process_queue(self):
+        """Process the queue items."""
+        self.listwidget.clear()
+        if not self.queue:
+            self.empty_overlay.resize(self.listwidget.size())
+            self.empty_overlay.show()
+            self.update_button_states()
+            return
+        else:
+            self.empty_overlay.hide()
+        icon_provider = QFileIconProvider()
+        for item in self.queue:
+            # Only show the file name, not the full path
+            file_name = item.file_name
+            display_name = file_name
+            import os
+            if os.path.sep in file_name:
+                display_name = os.path.basename(file_name)
+            # Get icon for the file
+            icon = icon_provider.icon(QFileInfo(file_name))
+            list_item = QListWidgetItem()
+            # Set tooltip with detailed info
+            output_folder = getattr(item, 'output_folder', '')
+            tooltip = (
+                f"<b>Path:</b> {file_name}<br>"
+                f"<b>Language:</b> {getattr(item, 'lang_code', '')}<br>"
+                f"<b>Speed:</b> {getattr(item, 'speed', '')}<br>"
+                f"<b>Voice:</b> {getattr(item, 'voice', '')}<br>"
+                f"<b>Save Option:</b> {getattr(item, 'save_option', '')}<br>"
+            )
+            if output_folder not in (None, '', 'None'):
+                tooltip += f"<b>Output Folder:</b> {output_folder}<br>"
+            tooltip += (
+                f"<b>Subtitle Mode:</b> {getattr(item, 'subtitle_mode', '')}<br>"
+                f"<b>Output Format:</b> {getattr(item, 'output_format', '')}<br>"
+                f"<b>Characters:</b> {getattr(item, 'total_char_count', '')}<br>"
+                f"<b>Replace Single Newlines:</b> {getattr(item, 'replace_single_newlines', False)}"
+            )
+            list_item.setToolTip(tooltip)
+            list_item.setIcon(icon)
+            # Use custom widget for display
+            char_count = getattr(item, 'total_char_count', 0)
+            widget = QueueListItemWidget(file_name, char_count)
+            self.listwidget.addItem(list_item)
+            self.listwidget.setItemWidget(list_item, widget)
+        self.update_button_states()
+
+    def remove_item(self):
+        items = self.listwidget.selectedItems()
+        if not items:
+            return
+        from PyQt5.QtWidgets import QMessageBox
+        # Remove by index to ensure correct mapping
+        rows = sorted([self.listwidget.row(item) for item in items], reverse=True)
+        # Warn user if removing multiple files
+        if len(rows) > 1:
+            reply = QMessageBox.question(
+                self,
+                "Confirm Remove",
+                f"Are you sure you want to remove {len(rows)} selected items from the queue?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No
+            )
+            if reply != QMessageBox.Yes:
+                return
+        for row in rows:
+            if 0 <= row < len(self.queue):
+                del self.queue[row]
+        self.process_queue()
+        self.update_button_states()
+
+    def clear_queue(self):
+        from PyQt5.QtWidgets import QMessageBox
+        if len(self.queue) > 1:
+            reply = QMessageBox.question(
+                self,
+                "Confirm Clear Queue",
+                f"Are you sure you want to clear {len(self.queue)} items from the queue?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No
+            )
+            if reply != QMessageBox.Yes:
+                return
+        self.queue.clear()
+        self.listwidget.clear()
+        self.empty_overlay.resize(self.listwidget.size())  # Ensure overlay is sized correctly
+        self.empty_overlay.show()  # Show the overlay when queue is empty
+        self.update_button_states()
+
+    def get_queue(self):
+        return self.queue
+
+    def get_current_attributes(self):
+        # Fetch current attribute values from the parent abogen GUI
+        attrs = {}
+        parent = self.parent
+        if parent is not None:
+            # lang_code: use parent's get_voice_formula and get_selected_lang
+            if hasattr(parent, 'get_voice_formula') and hasattr(parent, 'get_selected_lang'):
+                voice_formula = parent.get_voice_formula()
+                attrs['lang_code'] = parent.get_selected_lang(voice_formula)
+                attrs['voice'] = voice_formula
+            else:
+                attrs['lang_code'] = getattr(parent, 'selected_lang', '')
+                attrs['voice'] = getattr(parent, 'selected_voice', '')
+            # speed
+            if hasattr(parent, 'speed_slider'):
+                attrs['speed'] = parent.speed_slider.value() / 100.0
+            else:
+                attrs['speed'] = getattr(parent, 'speed', 1.0)
+            # save_option
+            attrs['save_option'] = getattr(parent, 'save_option', '')
+            # output_folder
+            attrs['output_folder'] = getattr(parent, 'selected_output_folder', '')
+            # subtitle_mode
+            if hasattr(parent, 'get_actual_subtitle_mode'):
+                attrs['subtitle_mode'] = parent.get_actual_subtitle_mode()
+            else:
+                attrs['subtitle_mode'] = getattr(parent, 'subtitle_mode', '')
+            # output_format
+            attrs['output_format'] = getattr(parent, 'selected_format', '')
+            # total_char_count
+            attrs['total_char_count'] = getattr(parent, 'char_count', '')
+            # replace_single_newlines
+            attrs['replace_single_newlines'] = getattr(parent, 'replace_single_newlines', False)
+        else:
+            # fallback: empty values
+            attrs = {k: '' for k in [
+                'lang_code', 'speed', 'voice', 'save_option',
+                'output_folder', 'subtitle_mode', 'output_format', 'total_char_count', 'replace_single_newlines']}
+        return attrs
+
+    def add_files_from_paths(self, file_paths):
+        from abogen.utils import calculate_text_length
+        from PyQt5.QtWidgets import QMessageBox
+        import os
+        current_attrs = self.get_current_attributes()
+        duplicates = []
+        for file_path in file_paths:
+            class QueueItem:
+                pass
+            item = QueueItem()
+            item.file_name = file_path
+            for attr, value in current_attrs.items():
+                setattr(item, attr, value)
+            # Read file content and calculate total_char_count using calculate_text_length
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    file_content = f.read()
+                item.total_char_count = calculate_text_length(file_content)
+            except Exception:
+                item.total_char_count = 0
+            # Prevent adding duplicate items to the queue (check all attributes)
+            is_duplicate = False
+            for queued_item in self.queue:
+                if (
+                    getattr(queued_item, 'file_name', None) == getattr(item, 'file_name', None) and
+                    getattr(queued_item, 'lang_code', None) == getattr(item, 'lang_code', None) and
+                    getattr(queued_item, 'speed', None) == getattr(item, 'speed', None) and
+                    getattr(queued_item, 'voice', None) == getattr(item, 'voice', None) and
+                    getattr(queued_item, 'save_option', None) == getattr(item, 'save_option', None) and
+                    getattr(queued_item, 'output_folder', None) == getattr(item, 'output_folder', None) and
+                    getattr(queued_item, 'subtitle_mode', None) == getattr(item, 'subtitle_mode', None) and
+                    getattr(queued_item, 'output_format', None) == getattr(item, 'output_format', None) and
+                    getattr(queued_item, 'total_char_count', None) == getattr(item, 'total_char_count', None) and
+                    getattr(queued_item, 'replace_single_newlines', False) == getattr(item, 'replace_single_newlines', False)
+                ):
+                    is_duplicate = True
+                    break
+            if is_duplicate:
+                duplicates.append(os.path.basename(file_path))
+                continue
+            self.queue.append(item)
+        if duplicates:
+            QMessageBox.warning(
+                self,
+                "Duplicate Item(s)",
+                f"Skipping {len(duplicates)} file(s) with the same attributes, already in the queue."
+            )
+        self.process_queue()
+        self.update_button_states()
+
+    def add_more_files(self):
+        from PyQt5.QtWidgets import QFileDialog
+        from abogen.utils import calculate_text_length  # import the function
+        # Only allow .txt files
+        files, _ = QFileDialog.getOpenFileNames(self, "Select .txt files", "", "Text Files (*.txt)")
+        if not files:
+            return
+        self.add_files_from_paths(files)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        if hasattr(self, 'empty_overlay'):
+            self.empty_overlay.resize(self.listwidget.size())
+
+    def update_button_states(self):
+        # Enable Remove if at least one item is selected, else disable
+        if hasattr(self, 'remove_button'):
+            selected_count = len(self.listwidget.selectedItems())
+            self.remove_button.setEnabled(selected_count > 0)
+            if selected_count > 1:
+                self.remove_button.setText(f"Remove selected ({selected_count})")
+            else:
+                self.remove_button.setText("Remove selected")
+        # Disable Clear if queue is empty
+        if hasattr(self, 'clear_button'):
+            self.clear_button.setEnabled(bool(self.queue))
+
+    def show_context_menu(self, pos):
+        from PyQt5.QtWidgets import QMenu, QAction
+        from PyQt5.QtGui import QDesktopServices
+        from PyQt5.QtCore import QUrl
+        import os
+        global_pos = self.listwidget.viewport().mapToGlobal(pos)
+        selected_items = self.listwidget.selectedItems()
+        menu = QMenu(self)
+        if len(selected_items) == 1:
+            # Add Remove action
+            remove_action = QAction("Remove this item", self)
+            remove_action.triggered.connect(self.remove_item)
+            menu.addAction(remove_action)
+
+            # Add Open file action
+            open_file_action = QAction("Open file", self)
+            def open_file():
+                from PyQt5.QtWidgets import QMessageBox
+                item = selected_items[0]
+                display_name = item.text()
+                for q in self.queue:
+                    if os.path.basename(q.file_name) == display_name:
+                        if not os.path.exists(q.file_name):
+                            QMessageBox.warning(self, "File Not Found", f"The file does not exist.")
+                            return
+                        QDesktopServices.openUrl(QUrl.fromLocalFile(q.file_name))
+                        break
+            open_file_action.triggered.connect(open_file)
+            menu.addAction(open_file_action)
+
+            # Add Go to folder action
+            go_to_folder_action = QAction("Go to folder", self)
+            def go_to_folder():
+                from PyQt5.QtWidgets import QMessageBox
+                item = selected_items[0]
+                display_name = item.text()
+                for q in self.queue:
+                    if os.path.basename(q.file_name) == display_name:
+                        if not os.path.exists(q.file_name):
+                            QMessageBox.warning(self, "File Not Found", f"The file does not exist.")
+                            return
+                        folder = os.path.dirname(q.file_name)
+                        if os.path.exists(folder):
+                            QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
+                        break
+            go_to_folder_action.triggered.connect(go_to_folder)
+            menu.addAction(go_to_folder_action)
+
+        elif len(selected_items) > 1:
+            remove_action = QAction(f"Remove selected ({len(selected_items)})", self)
+            remove_action.triggered.connect(self.remove_item)
+            menu.addAction(remove_action)
+        # Always add Clear Queue
+        clear_action = QAction("Clear Queue", self)
+        clear_action.triggered.connect(self.clear_queue)
+        menu.addAction(clear_action)
+        menu.exec_(global_pos)
+
+    def accept(self):
+        # Accept: keep changes
+        super().accept()
+
+    def reject(self):
+        # Cancel: restore original queue
+        from PyQt5.QtWidgets import QMessageBox
+        # Warn if user changed a lot (e.g., more than 1 items difference)
+        original_count = len(self._original_queue)
+        current_count = len(self.queue)
+        if abs(original_count - current_count) > 1:
+            reply = QMessageBox.question(
+                self,
+                "Confirm Cancel",
+                f"Are you sure you want to cancel and discard all changes?",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No
+            )
+            if reply != QMessageBox.Yes:
+                return
+        self.queue.clear()
+        self.queue.extend(deepcopy(self._original_queue))
+        super().reject()
+
+    def keyPressEvent(self, event):
+        from PyQt5.QtCore import Qt
+        if event.key() == Qt.Key_Delete:
+            self.remove_item()
+        else:
+            super().keyPressEvent(event)
@@ -0,0 +1,15 @@
+# represents a queued item - book, chapters, voice, etc.
+from dataclasses import dataclass
+
+@dataclass
+class QueuedItem:
+    file_name: str
+    lang_code: str
+    speed: float
+    voice: str
+    save_option: str
+    output_folder: str
+    subtitle_mode: str
+    output_format: str
+    total_char_count: int
+    replace_single_newlines: bool = False
@@ -217,14 +217,22 @@ def calculate_text_length(text):


 def get_gpu_acceleration(enabled):
-    from torch.cuda import is_available
-
-    if not enabled:
-        return "CUDA GPU available but using CPU.", False
-
-    if is_available():
-        return "CUDA GPU available and enabled.", True
-    return "CUDA GPU is not available. Using CPU.", False
+    try:
+        import torch
+        from torch.cuda import is_available
+        if not enabled:
+            return "CUDA GPU available but using CPU.", False
+        if is_available():
+            return "CUDA GPU available and enabled.", True
+        # Gather more diagnostic info if CUDA is not available
+        try:
+            cuda_devices = torch.cuda.device_count()
+            cuda_error = torch.cuda.get_device_name(0) if cuda_devices > 0 else "No devices found"
+        except Exception as e:
+            cuda_error = str(e)
+        return f"CUDA GPU is not available. Using CPU. ({cuda_error})", False
+    except Exception as e:
+        return f"Error checking CUDA GPU: {e}", False


 def prevent_sleep_start():
@@ -28,7 +28,7 @@ from PyQt5.QtWidgets import (
 )
 from PyQt5.QtCore import Qt, QTimer, QPoint, QRect, QSize
 from PyQt5.QtGui import QPixmap, QIcon
-from constants import (
+from abogen.constants import (
    VOICES_INTERNAL,
    SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
    LANGUAGE_DESCRIPTIONS,
@@ -36,8 +36,8 @@ from constants import (
 )
 import re
 import platform
-from utils import get_resource_path
-from voice_profiles import (
+from abogen.utils import get_resource_path
+from abogen.voice_profiles import (
    load_profiles,
    save_profiles,
    delete_profile,
@@ -1084,7 +1084,7 @@ class VoiceFormulaDialog(QDialog):
            self, "Import Profiles", "", "JSON Files (*.json)"
        )
        if path:
-            from voice_profiles import load_profiles, save_profiles
+            from abogen.voice_profiles import load_profiles, save_profiles

            # Try to read the file and count profiles
            try:
@@ -1,6 +1,5 @@
 import re
-from constants import VOICES_INTERNAL
-
+from abogen.constants import VOICES_INTERNAL

 # Calls parsing and loads the voice to gpu or cpu
 def get_new_voice(pipeline, formula, use_gpu):
@@ -1,6 +1,6 @@
 import os
 import json
-from utils import get_user_config_path
+from abogen.utils import get_user_config_path


 def _get_profiles_path():
@@ -1 +1 @@
 .0.9
 .1.0