v1.1.1

v1.1.0

.github/workflows/test_publish.yml

@@ -0,0 +1,61 @@
+name: Build multi-arch Docker Image
+
+on:
+  # Build and push
+  #release:
+  #  types: [published]
+  # Build only
+  #push:
+  #  branches: [main]
+  # TODO - enable build on pull requests if build times can be reduced
+  # pull_request:
+  workflow_dispatch:
+
+env:
+  IMAGE_REPOSITORY: ghcr.io/denizsafak/abogen
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Login to Github Container Registry
+      # Only if we need to push an image
+      if: ${{ github.event_name == 'release' && github.event.action == 'published' }}
+      uses: docker/login-action@v3
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+    # Setup for buildx
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v3
+
+    - name: Set up Docker Buildx
+      id: buildx
+      uses: docker/setup-buildx-action@v3
+
+    # Debugging information
+    - name: Docker info
+      run: docker info
+
+    - name: Buildx inspect
+      run: docker buildx inspect
+
+    # Build and (optionally) push the image
+    - name: Build image
+      uses: docker/build-push-action@v6
+      with:
+        context: ./abogen
+        file: ./abogen/Dockerfile
+        # platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
+        platforms: linux/amd64,linux/arm64
+        # Only push if we are publishing a release
+        push: ${{ github.event_name == 'release' && github.event.action == 'published' }}
+        # Use a 'temp' tag, that won't be pushed, for non-release builds
+        tags: ${{ env.IMAGE_REPOSITORY }}:${{ github.event.release.tag_name || 'temp' }}
+        # Use a cache to reduce build times
+        cache-to: type=gha,mode=max
+        cache-from: type=gha

CHANGELOG.md

@@ -1,3 +1,15 @@
+# v1.1.1
+- Fixed adding wrong file in queue for EPUB and PDF files, ensuring the correct file is added to the queue.
+- Reformatted the code using Black.
+
+# 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.
 - Added new option: `Subtitle format`, allowing users to choose between `srt` , `ass (wide)`, `ass (narrow)`, and `ass (centered wide)` and `ass (centered narrow)`

README.md

@@ -34,6 +34,7 @@ This method handles everything automatically - installing all dependencies inclu
 #### OPTION 2: Install using pip
 ```bash
 # Create a virtual environment (optional)
+mkdir abogen && cd abogen
 python -m venv venv
 venv\Scripts\activate
 
@@ -53,6 +54,7 @@ pip install abogen
 brew install espeak-ng
 
 # Create a virtual environment (recommended)
+mkdir abogen && cd abogen
 python3 -m venv venv
 source venv/bin/activate
 
@@ -67,6 +69,7 @@ sudo pacman -S espeak-ng # Arch Linux
 sudo dnf install espeak-ng # Fedora
 
 # Create a virtual environment (recommended)
+mkdir abogen && cd abogen
 python3 -m venv venv
 source venv/bin/activate
 
@@ -116,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`
+## `Configuration`
-- **Supported formats**: `ePub`, `PDF`, or `.TXT` files (or use built-in text editor)
+
-- **Speed**: Adjust speech rate from `0.1x` to `2.0x`
+| Options | Description |
-- **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.
+| **Input Box** | Drag and drop `ePub`, `PDF`, or `.TXT` files (or use built-in text editor) |
-- **Generate subtitles**: `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry)
+| **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. |
-- **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))
+| **Speed** | Adjust speech rate from `0.1x` to `2.0x` |
-- **Save location**: `Save next to input file`, `Save to desktop`, or `Choose output folder`
+| **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. |
-- **Chapter Control**: Select specific `chapters` from ePUBs or `chapters + pages` from PDFs.
+| **Voice mixer** | Create custom voices by mixing different voice models with a profile system. See [Voice Mixer](#voice-mixer) for more details. |
-- **Save each chapter separately**: Save each chapter in e-books as a separate audio file.
+| **Voice preview** | Listen to the selected voice before processing. |
-- **Project folder**: Save the converted items in a project folder with available metadata files.
+| **Generate subtitles** | `Disabled`, `Sentence`, `Sentence + Comma`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry) |
-- **Options**:
+| **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)) |
-    - **Replace single newlines with spaces**: Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks.
+| **Output subtitle format** | Configures the subtitle format as `SRT (standard)`, `ASS (wide)`, `ASS (narrow)`, `ASS (centered wide)`, or `ASS (centered narrow)`. |
-    - **Configure max words per subtitle**: Configures the maximum number of words per subtitle entry.
+| **Replace single newlines with spaces** | Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks. |
-    - **Subtitle format**: Configures the subtitle format as `srt`, `ass (wide)`, `ass (narrow)`, `ass (centered wide)`, or `ass (centered narrow)`.
+| **Save location** | `Save next to input file`, `Save to desktop`, or `Choose output folder` |
-    - **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.
+| Book handler options | Description |
-    - **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.
+| **Chapter Control** | Select specific `chapters` from ePUBs or `chapters + pages` from PDFs. |
-    - **Clear temporary files**: Deletes temporary files created during the conversion or preview.
+| **Save each chapter separately** | Save each chapter in e-books as a separate audio file. |
-    - **Check for updates at startup**: Automatically checks for updates when the program starts.
+| **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.) |
-- **After conversion**: `Open file`, `Go to folder`, `New conversion`, or `Go back`.
+| **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:
 
@@ -168,7 +195,7 @@ When you process the text file, Abogen will detect these markers automatically a
 ![Abogen Chapter Marker](https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/chapter_marker.png)
 
 ## `About Metadata Tags`
-Similar to chapter markers, it is possible to add metadata tags to `M4B` files. This is useful for audiobook players that support metadata, allowing you to add information like title, author, year, etc. Abogen automatically adds these tags when you process ePUB or PDF files, but you can also add them manually to your text files. Add metadata tags **at the beginning of your text file** like this:
+Similar to chapter markers, it is possible to add metadata tags for `M4B` files. This is useful for audiobook players that support metadata, allowing you to add information like title, author, year, etc. Abogen automatically adds these tags when you process ePUB or PDF files, but you can also add them manually to your text files. Add metadata tags **at the beginning of your text file** like this:
 ```
 <<METADATA_TITLE:Title>>
 <<METADATA_ARTIST:Author>>
@@ -254,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:

abogen/VERSION

@@ -1 +1 @@
-1.0.9
+1.1.1

abogen/assets/settings.svg

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg height="800px" width="800px" version="1.1" id="_x32_" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
+	 viewBox="0 0 512 512"  xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#808080;}
+</style>
+<g>
+	<path class="st0" d="M502.325,307.303l-39.006-30.805c-6.215-4.908-9.665-12.429-9.668-20.348c0-0.084,0-0.168,0-0.252
+		c-0.014-7.936,3.44-15.478,9.667-20.396l39.007-30.806c8.933-7.055,12.093-19.185,7.737-29.701l-17.134-41.366
+		c-4.356-10.516-15.167-16.86-26.472-15.532l-49.366,5.8c-7.881,0.926-15.656-1.966-21.258-7.586
+		c-0.059-0.06-0.118-0.119-0.177-0.178c-5.597-5.602-8.476-13.36-7.552-21.225l5.799-49.363
+		c1.328-11.305-5.015-22.116-15.531-26.472L337.004,1.939c-10.516-4.356-22.646-1.196-29.701,7.736l-30.805,39.005
+		c-4.908,6.215-12.43,9.665-20.349,9.668c-0.084,0-0.168,0-0.252,0c-7.935,0.014-15.477-3.44-20.395-9.667L204.697,9.675
+		c-7.055-8.933-19.185-12.092-29.702-7.736L133.63,19.072c-10.516,4.356-16.86,15.167-15.532,26.473l5.799,49.366
+		c0.926,7.881-1.964,15.656-7.585,21.257c-0.059,0.059-0.118,0.118-0.178,0.178c-5.602,5.598-13.36,8.477-21.226,7.552
+		l-49.363-5.799c-11.305-1.328-22.116,5.015-26.472,15.531L1.939,174.996c-4.356,10.516-1.196,22.646,7.736,29.701l39.006,30.805
+		c6.215,4.908,9.665,12.429,9.668,20.348c0,0.084,0,0.167,0,0.251c0.014,7.935-3.44,15.477-9.667,20.395L9.675,307.303
+		c-8.933,7.055-12.092,19.185-7.736,29.701l17.134,41.365c4.356,10.516,15.168,16.86,26.472,15.532l49.366-5.799
+		c7.882-0.926,15.656,1.965,21.258,7.586c0.059,0.059,0.118,0.119,0.178,0.178c5.597,5.603,8.476,13.36,7.552,21.226l-5.799,49.364
+		c-1.328,11.305,5.015,22.116,15.532,26.472l41.366,17.134c10.516,4.356,22.646,1.196,29.701-7.736l30.804-39.005
+		c4.908-6.215,12.43-9.665,20.348-9.669c0.084,0,0.168,0,0.251,0c7.936-0.014,15.478,3.44,20.396,9.667l30.806,39.007
+		c7.055,8.933,19.185,12.093,29.701,7.736l41.366-17.134c10.516-4.356,16.86-15.168,15.532-26.472l-5.8-49.366
+		c-0.926-7.881,1.965-15.656,7.586-21.257c0.059-0.059,0.119-0.119,0.178-0.178c5.602-5.597,13.36-8.476,21.225-7.552l49.364,5.799
+		c11.305,1.328,22.117-5.015,26.472-15.531l17.134-41.365C514.418,326.488,511.258,314.358,502.325,307.303z M281.292,329.698
+		c-39.68,16.436-85.172-2.407-101.607-42.087c-16.436-39.68,2.407-85.171,42.087-101.608c39.68-16.436,85.172,2.407,101.608,42.088
+		C339.815,267.771,320.972,313.262,281.292,329.698z"/>
+</g>
+</svg>

abogen/book_handler.py

@@ -111,7 +111,7 @@ class HandlerDialog(QDialog):
         # Build treeview
         self.treeWidget = QTreeWidget(self)
         self.treeWidget.setHeaderHidden(True)
-        self.treeWidget.setSelectionMode(QTreeWidget.SingleSelection)
+        self.treeWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
         self.treeWidget.setContextMenuPolicy(Qt.CustomContextMenu)
         self.treeWidget.customContextMenuRequested.connect(self.on_tree_context_menu)
 
@@ -161,6 +161,7 @@ class HandlerDialog(QDialog):
         self.treeWidget.expandAll()
         if self.treeWidget.topLevelItemCount() > 0:
             self.treeWidget.setCurrentItem(self.treeWidget.topLevelItem(0))
+            self.treeWidget.setFocus()
 
         # Update checkbox states
         self._update_checkbox_states()
@@ -849,6 +850,12 @@ class HandlerDialog(QDialog):
             has_parents = True
         self.treeWidget.setRootIsDecorated(has_parents)
 
+    def _update_checkbox_states(self):
+        """Update the checkbox states based on the current checked chapters."""
+        for i in range(self.treeWidget.topLevelItemCount()):
+            item = self.treeWidget.topLevelItem(i)
+            self._update_item_checkbox_state(item)
+
     def _build_epub_tree_from_nav(
         self, nav_nodes, parent_item, seen_content_hashes=None
     ):
@@ -990,10 +997,21 @@ class HandlerDialog(QDialog):
                     bookmark_item.setData(0, Qt.UserRole, page_id)
                     # only allow checking if this chapter has content
                     if self.content_lengths.get(page_id, 0) > 0:
-                        bookmark_item.setFlags(bookmark_item.flags() | Qt.ItemIsUserCheckable)
+                        bookmark_item.setFlags(
-                        bookmark_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+                            bookmark_item.flags() | Qt.ItemIsUserCheckable
+                        )
+                        bookmark_item.setCheckState(
+                            0,
+                            (
+                                Qt.Checked
+                                if page_id in self.checked_chapters
+                                else Qt.Unchecked
+                            ),
+                        )
                     else:
-                        bookmark_item.setFlags(bookmark_item.flags() & ~Qt.ItemIsUserCheckable)
+                        bookmark_item.setFlags(
+                            bookmark_item.flags() & ~Qt.ItemIsUserCheckable
+                        )
                     # map for uncategorized pages
                     self.bookmark_items_map[page_num] = bookmark_item
 
@@ -1020,10 +1038,21 @@ class HandlerDialog(QDialog):
                         page_item.setData(0, Qt.UserRole, page_id)
                         # only allow checking if this sub-page has content
                         if self.content_lengths.get(page_id, 0) > 0:
-                            page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
+                            page_item.setFlags(
-                            page_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+                                page_item.flags() | Qt.ItemIsUserCheckable
+                            )
+                            page_item.setCheckState(
+                                0,
+                                (
+                                    Qt.Checked
+                                    if page_id in self.checked_chapters
+                                    else Qt.Unchecked
+                                ),
+                            )
                         else:
-                            page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)
+                            page_item.setFlags(
+                                page_item.flags() & ~Qt.ItemIsUserCheckable
+                            )
 
                         added_pages.add(sub_page_num)
 
@@ -1031,11 +1060,15 @@ class HandlerDialog(QDialog):
 
         covered_pages = set(added_pages)
         # attach any pages without direct bookmarks under nearest preceding chapter
-        uncategorized_pages = [i for i in range(len(self.pdf_doc)) if i not in covered_pages]
+        uncategorized_pages = [
+            i for i in range(len(self.pdf_doc)) if i not in covered_pages
+        ]
         for page_num in uncategorized_pages:
             # find nearest previous bookmark
             prev_nums = [n for n in sorted(self.bookmark_items_map) if n < page_num]
-            parent_item = self.bookmark_items_map[prev_nums[-1]] if prev_nums else self.treeWidget
+            parent_item = (
+                self.bookmark_items_map[prev_nums[-1]] if prev_nums else self.treeWidget
+            )
             page_id = f"page_{page_num+1}"
             title = f"Page {page_num+1}"
             text = self.content_texts.get(page_id, "").strip()
@@ -1048,7 +1081,9 @@ class HandlerDialog(QDialog):
             # only allow checking if uncategorized page has content
             if self.content_lengths.get(page_id, 0) > 0:
                 page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
-                page_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+                page_item.setCheckState(
+                    0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked
+                )
             else:
                 page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)
 
@@ -1074,7 +1109,9 @@ class HandlerDialog(QDialog):
             # only allow checking if standalone page has content
             if self.content_lengths.get(page_id, 0) > 0:
                 page_item.setFlags(page_item.flags() | Qt.ItemIsUserCheckable)
-                page_item.setCheckState(0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked)
+                page_item.setCheckState(
+                    0, Qt.Checked if page_id in self.checked_chapters else Qt.Unchecked
+                )
             else:
                 page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)
 
@@ -1175,7 +1212,7 @@ class HandlerDialog(QDialog):
         self.save_chapters_checkbox = QCheckBox(checkbox_text, self)
         self.save_chapters_checkbox.setChecked(self.save_chapters_separately)
         self.save_chapters_checkbox.stateChanged.connect(self.on_save_chapters_changed)
-        leftLayout.addWidget(self.save_chapters_checkbox)        
+        leftLayout.addWidget(self.save_chapters_checkbox)
         self.merge_chapters_checkbox = QCheckBox(
             "Create a merged version at the end", self
         )
@@ -1184,7 +1221,7 @@ class HandlerDialog(QDialog):
             self.on_merge_chapters_changed
         )
         leftLayout.addWidget(self.merge_chapters_checkbox)
-        
+
         self.save_as_project_checkbox = QCheckBox(
             "Save in a project folder with metadata", self
         )
@@ -1494,7 +1531,9 @@ class HandlerDialog(QDialog):
             authors_text = ", ".join(self.book_metadata["authors"])
             html_content += f"<p style='text-align: center; font-style: italic;'>By {authors_text}</p>"
 
-        if self.book_metadata["publisher"] or self.book_metadata.get("publication_year"):
+        if self.book_metadata["publisher"] or self.book_metadata.get(
+            "publication_year"
+        ):
             pub_info = []
             if self.book_metadata["publisher"]:
                 pub_info.append(f"Published by {self.book_metadata['publisher']}")
@@ -1536,7 +1575,9 @@ class HandlerDialog(QDialog):
             try:
                 author_items = self.book.get_metadata("DC", "creator")
                 if author_items:
-                    metadata["authors"] = [author[0] for author in author_items if len(author) > 0]
+                    metadata["authors"] = [
+                        author[0] for author in author_items if len(author) > 0
+                    ]
             except Exception as e:
                 logging.warning(f"Error extracting author metadata: {e}")
 
@@ -1553,14 +1594,14 @@ class HandlerDialog(QDialog):
                     metadata["publisher"] = publisher_items[0][0]
             except Exception as e:
                 logging.warning(f"Error extracting publisher metadata: {e}")
-                
+
             # Try to extract publication year
             try:
                 date_items = self.book.get_metadata("DC", "date")
                 if date_items and len(date_items) > 0:
                     date_str = date_items[0][0]
                     # Try to extract just the year from the date string
-                    year_match = re.search(r'\b(19|20)\d{2}\b', date_str)
+                    year_match = re.search(r"\b(19|20)\d{2}\b", date_str)
                     if year_match:
                         metadata["publication_year"] = year_match.group(0)
                     else:
@@ -1596,16 +1637,16 @@ class HandlerDialog(QDialog):
                         metadata["description"] = f"Keywords: {keywords}"
 
                 metadata["publisher"] = pdf_info.get("creator", None)
-                
+
                 # Try to extract publication date from PDF metadata
                 if "creationDate" in pdf_info:
                     date_str = pdf_info["creationDate"]
-                    year_match = re.search(r'D:(\d{4})', date_str)
+                    year_match = re.search(r"D:(\d{4})", date_str)
                     if year_match:
                         metadata["publication_year"] = year_match.group(1)
                 elif "modDate" in pdf_info:
                     date_str = pdf_info["modDate"]
-                    year_match = re.search(r'D:(\d{4})', date_str)
+                    year_match = re.search(r"D:(\d{4})", date_str)
                     if year_match:
                         metadata["publication_year"] = year_match.group(1)
 
@@ -1627,22 +1668,26 @@ class HandlerDialog(QDialog):
     def _format_metadata_tags(self):
         """Format metadata tags for insertion at the beginning of the text"""
         import datetime
-        
+
         metadata = self.book_metadata
         filename = os.path.splitext(os.path.basename(self.book_path))[0]
         current_year = str(datetime.datetime.now().year)
-        
+
         # Get values with fallbacks
         title = metadata.get("title") or filename
         authors = metadata.get("authors") or ["Unknown"]
         authors_text = ", ".join(authors)
         album_artist = authors_text or "Unknown"
-        year = metadata.get("publication_year") or current_year  # Use publication year if available
+        year = (
-        
+            metadata.get("publication_year") or current_year
+        )  # Use publication year if available
+
         # Count chapters/pages
         total_chapters = len(self.checked_chapters)
-        chapter_text = f"{total_chapters} {'Chapters' if self.file_type == 'epub' else 'Pages'}"
+        chapter_text = (
-        
+            f"{total_chapters} {'Chapters' if self.file_type == 'epub' else 'Pages'}"
+        )
+
         # Format metadata tags
         metadata_tags = [
             f"<<METADATA_TITLE:{title}>>",
@@ -1651,9 +1696,9 @@ class HandlerDialog(QDialog):
             f"<<METADATA_YEAR:{year}>>",
             f"<<METADATA_ALBUM_ARTIST:{album_artist}>>",
             f"<<METADATA_COMPOSER:Narrator>>",
-            f"<<METADATA_GENRE:Audiobook>>"
+            f"<<METADATA_GENRE:Audiobook>>",
         ]
-        
+
         return "\n".join(metadata_tags)
 
     def _get_epub_selected_text(self):
@@ -1662,7 +1707,7 @@ class HandlerDialog(QDialog):
 
         # Add metadata tags at the beginning
         metadata_tags = self._format_metadata_tags()
-        
+
         item_order_counter = 0
         ordered_checked_items = []
 
@@ -1723,7 +1768,10 @@ class HandlerDialog(QDialog):
                     if text:
                         all_content.append(text)
                         included_text_ids.add(page_id)
-            return metadata_tags + "\n\n" + "\n\n".join(all_content), all_checked_identifiers
+            return (
+                metadata_tags + "\n\n" + "\n\n".join(all_content),
+                all_checked_identifiers,
+            )
 
         iterator = QTreeWidgetItemIterator(self.treeWidget)
         while iterator.value():
@@ -1781,7 +1829,10 @@ class HandlerDialog(QDialog):
                         included_text_ids.add(identifier)
             iterator += 1
 
-        return metadata_tags + "\n\n" + "\n\n".join([t[1] for t in section_titles]), all_checked_identifiers
+        return (
+            metadata_tags + "\n\n" + "\n\n".join([t[1] for t in section_titles]),
+            all_checked_identifiers,
+        )
 
     def on_save_chapters_changed(self, state):
         self.save_chapters_separately = bool(state)
@@ -1809,8 +1860,33 @@ class HandlerDialog(QDialog):
     def get_save_as_project(self):
         return self.save_as_project
 
+    def check_selected_items(self):
+        self.set_selected_items_checked(True)
+
+    def uncheck_selected_items(self):
+        self.set_selected_items_checked(False)
+
+    def set_selected_items_checked(self, state: bool):
+        print(f"Checking selected items: {state}")
+        self.treeWidget.blockSignals(True)
+        for item in self.treeWidget.selectedItems():
+            if item.flags() & Qt.ItemIsUserCheckable:
+                item.setCheckState(0, Qt.Checked if state else Qt.Unchecked)
+        self.treeWidget.blockSignals(False)
+        self._update_checked_set_from_tree()
+
     def on_tree_context_menu(self, pos):
         item = self.treeWidget.itemAt(pos)
+        # multi-select context menu
+        if self.treeWidget.selectedItems() and len(self.treeWidget.selectedItems()) > 1:
+            menu = QMenu(self)
+            action = menu.addAction("Select")
+            action.triggered.connect(self.check_selected_items)
+            action = menu.addAction("Clear")
+            action.triggered.connect(self.uncheck_selected_items)
+            menu.exec_(self.treeWidget.mapToGlobal(pos))
+            return
+
         if (
             not item
             or item.childCount() == 0

abogen/constants.py

@@ -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",
@@ -102,3 +105,28 @@ SAMPLE_VOICE_TEXTS = {
     "p": "Este é um exemplo da voz selecionada.",
     "z": "这是所选语音的示例。",
 }
+
+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",
+    "DARK_ALT": "#2c2f31",
+    "DARK_BUTTON": "#292c30",
+    "DARK_DISABLED": "#535353",
+    "LIGHT_BG": "#eff0f1",
+    "LIGHT_DISABLED": "#9a9999",
+}

abogen/conversion.py

@@ -6,13 +6,19 @@ 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 abogen.utils import clean_text, create_process
-from constants import PROGRAM_NAME, LANGUAGE_DESCRIPTIONS, SAMPLE_VOICE_TEXTS
+from abogen.constants import (
-from voice_formulas import get_new_voice
+    PROGRAM_NAME,
-import hf_tracker
+    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
@@ -61,7 +67,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 +78,40 @@ 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 +163,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 +177,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
@@ -157,15 +193,17 @@ class ConversionThread(QThread):
         self.use_gpu = use_gpu  # Store the GPU setting
         self.max_subtitle_words = 50  # Default value, will be overridden from GUI
 
-    def _stream_audio_in_chunks(self, segments, process_func, progress_prefix="Processing"):
+    def _stream_audio_in_chunks(
+        self, segments, process_func, progress_prefix="Processing"
+    ):
         """
         Process audio segments in memory-efficient chunks
-        
+
         Args:
             segments: List of audio segments to process
             process_func: Function that takes (segment_bytes, is_last) and processes a chunk
             progress_prefix: Prefix for progress messages
-            
+
         Returns:
             Total samples processed
         """
@@ -174,83 +212,98 @@ class ConversionThread(QThread):
         samples_processed = 0
 
         self.log_updated.emit(f"\n{progress_prefix} segments...")
-        
+
         # Stream each segment individually
         for i, segment in enumerate(segments):
             try:
                 # Handle both NumPy arrays and PyTorch tensors
-                if hasattr(segment, 'astype'):
+                if hasattr(segment, "astype"):
                     segment_bytes = segment.astype("float32").tobytes()
                 else:
                     segment_bytes = segment.cpu().numpy().astype("float32").tobytes()
-                is_last = (i == len(segments) - 1)
+                is_last = i == len(segments) - 1
-                
+
                 # Update progress periodically - skip if there's only one segment
                 if (i % 20 == 0 or is_last) and len(segments) > 1:
                     progress_percent = int((samples_processed / total_samples) * 100)
-                    self.log_updated.emit(f"{progress_prefix} segment {i+1}/{len(segments)} ({progress_percent}% complete)")
+                    self.log_updated.emit(
-                
+                        f"{progress_prefix} segment {i+1}/{len(segments)} ({progress_percent}% complete)"
+                    )
+
                 # Process this segment
                 process_func(segment_bytes, is_last)
-                
+
                 # Update samples processed
                 samples_processed += len(segment)
-                
+
                 # Clear segment bytes from memory
                 del segment_bytes
             except Exception as e:
                 self.log_updated.emit(f"Error processing segment {i}: {str(e)}")
                 raise
-                
+
         return samples_processed
 
-    def _process_audio_segments(self, audio_segments, output_path, output_format, use_ffmpeg=False, ffmpeg_args=None):
+    def _process_audio_segments(
+        self,
+        audio_segments,
+        output_path,
+        output_format,
+        use_ffmpeg=False,
+        ffmpeg_args=None,
+    ):
         """
         Process audio segments to a target format with memory-efficient handling
-        
+
         Args:
             audio_segments: List of audio segments to process
             output_path: Path for output file
             output_format: Format of output (wav, mp3, flac, opus, m4b)
             use_ffmpeg: Whether to use FFmpeg instead of soundfile
             ffmpeg_args: Optional additional FFmpeg arguments when use_ffmpeg=True
-            
+
         Returns:
             Tuple of (success, output_path)
         """
         self.log_updated.emit(f"\nProcessing audio data to {output_format.upper()}...")
         segments_count = len(audio_segments)
-        
+
         # Handle direct streaming for WAV (the only format supporting append mode)
         if output_format == "wav" and not use_ffmpeg:
             try:
                 # Write first segment
                 sf.write(output_path, audio_segments[0], 24000, format="wav")
-                
+
                 # Append remaining segments
                 for i, segment in enumerate(audio_segments[1:], 1):
-                    with sf.SoundFile(output_path, mode='r+') as f:
+                    with sf.SoundFile(output_path, mode="r+") as f:
                         f.seek(0, sf.SEEK_END)
                         f.write(segment)
                 return True, output_path
             except Exception as e:
                 self.log_updated.emit((f"Error writing WAV file: {str(e)}", "red"))
                 return False, None
-        
+
         # For formats requiring FFmpeg (opus, m4b) or when explicitly requested
         if use_ffmpeg or output_format in ["opus", "m4b"]:
             static_ffmpeg.add_paths()
-            
+
             # Basic FFmpeg command
             cmd = [
-                "ffmpeg", "-y",
+                "ffmpeg",
-                "-thread_queue_size", "32768",
+                "-y",
-                "-f", "f32le",
+                "-thread_queue_size",
-                "-ar", "24000",
+                "32768",
-                "-ac", "1",
+                "-f",
-                "-i", "pipe:0"
+                "f32le",
+                "-ar",
+                "24000",
+                "-ac",
+                "1",
+                "-i",
+                "pipe:0",
             ]
-            
+
             # Add custom FFmpeg arguments if provided
             if ffmpeg_args:
                 cmd.extend(ffmpeg_args)
@@ -264,48 +317,62 @@ class ConversionThread(QThread):
                     cmd.extend(["-c:a", "flac", "-compression_level", "8"])
                 else:
                     cmd.extend(["-c:a", "aac", "-q:a", "2"])
-            
+
             # Add output path
             cmd.append(output_path)
-            
+
             # Create process
             proc = create_process(cmd, stdin=subprocess.PIPE, text=False)
-            
+
             # Process segments
             try:
                 # Use the unified streaming function
                 def process_chunk(chunk_bytes, is_last):
                     proc.stdin.write(chunk_bytes)
-                
+
-                self._stream_audio_in_chunks(audio_segments, process_chunk, 
+                self._stream_audio_in_chunks(
-                                          progress_prefix=f"Processing {output_format.upper()}")
+                    audio_segments,
-                
+                    process_chunk,
+                    progress_prefix=f"Processing {output_format.upper()}",
+                )
+
                 # Close stdin and wait for process to complete
                 proc.stdin.close()
                 if proc.wait() != 0:
-                    self.log_updated.emit((f"{output_format.upper()} conversion failed.", "red"))
+                    self.log_updated.emit(
+                        (f"{output_format.upper()} conversion failed.", "red")
+                    )
                     return False, None
-                
+
                 return True, output_path
-                
+
             except Exception as e:
-                self.log_updated.emit((f"Error during {output_format.upper()} conversion: {str(e)}", "red"))
+                self.log_updated.emit(
+                    (
+                        f"Error during {output_format.upper()} conversion: {str(e)}",
+                        "red",
+                    )
+                )
                 proc.stdin.close()
                 try:
                     proc.terminate()
                 except:
                     pass
                 return False, None
-        
+
         # For formats supported by soundfile (mp3, flac)
         else:
             try:
-                with sf.SoundFile(output_path, 'w', samplerate=24000, channels=1, format=output_format) as f:
+                with sf.SoundFile(
+                    output_path, "w", samplerate=24000, channels=1, format=output_format
+                ) as f:
                     for i, segment in enumerate(audio_segments):
                         f.write(segment)
                 return True, output_path
             except Exception as e:
-                self.log_updated.emit((f"Error processing {output_format.upper()} file: {str(e)}", "red"))
+                self.log_updated.emit(
+                    (f"Error processing {output_format.upper()} file: {str(e)}", "red")
+                )
                 return False, None
 
     def run(self):
@@ -316,15 +383,22 @@ 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')})"
@@ -333,7 +407,9 @@ class ConversionThread(QThread):
             self.log_updated.emit(f"- Speed: {self.speed}")
             self.log_updated.emit(f"- Subtitle mode: {self.subtitle_mode}")
             self.log_updated.emit(f"- Output format: {self.output_format}")
-            self.log_updated.emit(f"- Subtitle format: {getattr(self, 'subtitle_format', 'srt')}")
+            self.log_updated.emit(
+                f"- Subtitle format: {getattr(self, 'subtitle_format', 'srt')}"
+            )
             self.log_updated.emit(f"- Save option: {self.save_option}")
             if self.replace_single_newlines:
                 self.log_updated.emit(f"- Replace single newlines: Yes")
@@ -352,8 +428,10 @@ class ConversionThread(QThread):
                         f"- Merge chapters at the end: {'Yes' if merge_at_end else 'No'}"
                     )
                     # Display the separate chapters format if it's set
-                    separate_format = getattr(self, 'separate_chapters_format', 'wav')
+                    separate_format = getattr(self, "separate_chapters_format", "wav")
-                    self.log_updated.emit(f"- Separate chapters format: {separate_format}")
+                    self.log_updated.emit(
+                        f"- Separate chapters format: {separate_format}"
+                    )
 
             if self.save_option == "Choose output folder":
                 self.log_updated.emit(
@@ -378,7 +456,7 @@ class ConversionThread(QThread):
 
             # Clean up text using utility function
             text = clean_text(text)
-            
+
             # Remove metadata markers from the text to be processed
             metadata_pattern = r"<<METADATA_[^:]+:[^>]*>>"
             text = re.sub(metadata_pattern, "", text)
@@ -447,7 +525,13 @@ 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()
@@ -664,42 +748,61 @@ class ConversionThread(QThread):
                         # Find last word boundary before limit
                         pos = sanitized[:MAX_LEN].rfind("_")
                         # Use word boundary if found, otherwise use hard limit
-                        sanitized = sanitized[:pos if pos > 0 else MAX_LEN].rstrip("_")
+                        sanitized = sanitized[: pos if pos > 0 else MAX_LEN].rstrip("_")
                     chapter_filename = f"{chapter_idx:02d}_{sanitized}"
 
                     # Use separate_chapters_format
-                    separate_format = getattr(self, 'separate_chapters_format', 'wav')
+                    separate_format = getattr(self, "separate_chapters_format", "wav")
-                    
+
                     chapter_out_path = os.path.join(
                         chapters_out_dir, f"{chapter_filename}.{separate_format}"
                     )
 
                     # Process audio segments using the unified function
                     success, chapter_out_path = self._process_audio_segments(
-                        chapter_audio_segments, chapter_out_path, separate_format, use_ffmpeg=(separate_format in ["opus", "m4b"])
+                        chapter_audio_segments,
+                        chapter_out_path,
+                        separate_format,
+                        use_ffmpeg=(separate_format in ["opus", "m4b"]),
                     )
-                    
+
                     if not success:
-                        self.log_updated.emit((f"Failed to write {separate_format.upper()} file.", "red"))
+                        self.log_updated.emit(
+                            (f"Failed to write {separate_format.upper()} file.", "red")
+                        )
                         continue
 
                     # Generate subtitle file for chapter if not Disabled
                     if self.subtitle_mode != "Disabled" and chapter_subtitle_entries:
-                        subtitle_format = getattr(self, 'subtitle_format', 'srt')
+                        subtitle_format = getattr(self, "subtitle_format", "srt")
-                        file_extension = 'ass' if 'ass' in subtitle_format else 'srt'
+                        file_extension = "ass" if "ass" in subtitle_format else "srt"
                         chapter_subtitle_path = os.path.join(
                             chapters_out_dir, f"{chapter_filename}.{file_extension}"
                         )
-                        
+
-                        if 'ass' in subtitle_format:
+                        if "ass" in subtitle_format:
                             # Generate ASS subtitle
-                            is_centered = 'centered' in subtitle_format
+                            is_centered = subtitle_format in (
-                            is_narrow = 'narrow' in subtitle_format
+                                "ass_centered_wide",
-                            self._write_ass_subtitle(chapter_subtitle_path, chapter_subtitle_entries, is_centered, is_narrow)
+                                "ass_centered_narrow",
+                            )
+                            is_narrow = subtitle_format in (
+                                "ass_narrow",
+                                "ass_centered_narrow",
+                            )
+                            self._write_ass_subtitle(
+                                chapter_subtitle_path,
+                                chapter_subtitle_entries,
+                                is_centered,
+                                is_narrow,
+                            )
                         else:
                             # Generate SRT subtitle (default)
                             with open(
-                                chapter_subtitle_path, "w", encoding="utf-8", errors="replace"
+                                chapter_subtitle_path,
+                                "w",
+                                encoding="utf-8",
+                                errors="replace",
                             ) as srt_file:
                                 for i, (start, end, text) in enumerate(
                                     chapter_subtitle_entries, 1
@@ -731,8 +834,8 @@ class ConversionThread(QThread):
                 or not self.save_chapters_separately
                 or getattr(self, "merge_chapters_at_end", True)
             )
-            
+
-            intended_output_format = self.output_format # Store the original choice
+            intended_output_format = self.output_format  # Store the original choice
 
             if audio_segments and merge_chapters:
                 self.log_updated.emit("\nFinalizing audio file...")
@@ -741,7 +844,7 @@ class ConversionThread(QThread):
                 base_filepath_no_ext = os.path.join(out_dir, f"{base_name}{suffix}")
 
                 final_out_path = None
-                
+
                 # Use dedicated chapter processing for M4B when we have chapters
                 if intended_output_format == "m4b":
                     self.log_updated.emit("\nGenerating audio with chapters...")
@@ -751,35 +854,52 @@ class ConversionThread(QThread):
                 else:
                     # Process audio segments using the unified function
                     success, final_out_path = self._process_audio_segments(
-                        audio_segments, f"{base_filepath_no_ext}.{intended_output_format}", 
+                        audio_segments,
-                        intended_output_format, 
+                        f"{base_filepath_no_ext}.{intended_output_format}",
-                        use_ffmpeg=(intended_output_format in ["opus", "m4b"])
+                        intended_output_format,
+                        use_ffmpeg=(intended_output_format in ["opus", "m4b"]),
                     )
-                    
+
                     if not success:
                         final_out_path = None
-                
+
                 if not final_out_path:
                     self.log_updated.emit(("Audio generation failed.", "red"))
-                    self.conversion_finished.emit(("Audio generation failed.", "red"), None)
+                    self.conversion_finished.emit(
+                        ("Audio generation failed.", "red"), None
+                    )
                     return
 
                 # Subtitle and final message logic
                 if final_out_path:
                     if self.subtitle_mode != "Disabled":
-                        subtitle_format = getattr(self, 'subtitle_format', 'srt')
+                        subtitle_format = getattr(self, "subtitle_format", "srt")
-                        file_extension = 'ass' if 'ass' in subtitle_format else 'srt'
+                        file_extension = "ass" if "ass" in subtitle_format else "srt"
-                        subtitle_path = os.path.splitext(final_out_path)[0] + f".{file_extension}"
+                        subtitle_path = (
-                        
+                            os.path.splitext(final_out_path)[0] + f".{file_extension}"
-                        if 'ass' in subtitle_format:
+                        )
-                            # Generate ASS subtitle with optional centering and margin
+
-                            is_centered = 'centered' in subtitle_format
+                        if "ass" in subtitle_format:
-                            is_narrow = 'narrow' in subtitle_format
+                            # Generate ASS subtitle
-                            self._write_ass_subtitle(subtitle_path, subtitle_entries, is_centered, is_narrow)
+                            is_centered = subtitle_format in (
+                                "ass_centered_wide",
+                                "ass_centered_narrow",
+                            )
+                            is_narrow = subtitle_format in (
+                                "ass_narrow",
+                                "ass_centered_narrow",
+                            )
+                            self._write_ass_subtitle(
+                                subtitle_path, subtitle_entries, is_centered, is_narrow
+                            )
                         else:
                             # Generate SRT subtitle (default)
-                            with open(subtitle_path, "w", encoding="utf-8", errors="replace") as srt_file:
+                            with open(
-                                for i, (start, end, text) in enumerate(subtitle_entries, 1):
+                                subtitle_path, "w", encoding="utf-8", errors="replace"
+                            ) as srt_file:
+                                for i, (start, end, text) in enumerate(
+                                    subtitle_entries, 1
+                                ):
                                     srt_file.write(
                                         f"{i}\n{self._srt_time(start)} --> {self._srt_time(end)}\n{text}\n\n"
                                     )
@@ -792,11 +912,16 @@ class ConversionThread(QThread):
                         )
                     else:
                         self.conversion_finished.emit(
-                            (f"\nAudiobook saved to: {final_out_path}", "green"), final_out_path
+                            (f"\nAudiobook saved to: {final_out_path}", "green"),
+                            final_out_path,
                         )
                 else:
-                    self.log_updated.emit(("Audio generation failed (final_out_path was not set).", "red"))
+                    self.log_updated.emit(
-                    self.conversion_finished.emit(("Audio generation failed.", "red"), None)
+                        ("Audio generation failed (final_out_path was not set).", "red")
+                    )
+                    self.conversion_finished.emit(
+                        ("Audio generation failed.", "red"), None
+                    )
             elif audio_segments and not merge_chapters:
                 self.conversion_finished.emit(
                     (
@@ -819,12 +944,14 @@ class ConversionThread(QThread):
         self.waiting_for_user_input = False
         self._chapter_options_event.set()
 
-    def _generate_m4b_with_chapters(self, audio_segments, chapters_time, base_filepath_no_ext):
+    def _generate_m4b_with_chapters(
+        self, audio_segments, chapters_time, base_filepath_no_ext
+    ):
         """Generate M4B file with chapters from audio segments"""
         final_wav_path = f"{base_filepath_no_ext}.wav"
         output_m4b_path = f"{base_filepath_no_ext}.m4b"
         chapters_info_path = f"{base_filepath_no_ext}_chapters.txt"
-        
+
         # Early check for single/no chapter case
         if not chapters_time or len(chapters_time) <= 1:
             self.log_updated.emit(
@@ -840,7 +967,9 @@ class ConversionThread(QThread):
             if success:
                 return wav_path
             else:
-                self.log_updated.emit((f"\nFailed to save single/no chapter audio as WAV", "red"))
+                self.log_updated.emit(
+                    (f"\nFailed to save single/no chapter audio as WAV", "red")
+                )
                 return None
 
         try:
@@ -848,46 +977,61 @@ class ConversionThread(QThread):
             with open(chapters_info_path, "w", encoding="utf-8") as f:
                 f.write(";FFMETADATA1\n")
                 for chapter in chapters_time:
-                    chapter_title = chapter['chapter'].replace('=', '\\=')
+                    chapter_title = chapter["chapter"].replace("=", "\\=")
                     f.write(f"[CHAPTER]\n")
                     f.write(f"TIMEBASE=1/1000\n")
                     f.write(f"START={int(chapter['start']*1000)}\n")
                     f.write(f"END={int(chapter['end']*1000)}\n")
                     f.write(f"title={chapter_title}\n\n")
-            
+
             # For M4B with chapters, we need to use input file for chapter information
             static_ffmpeg.add_paths()
             metadata_options = self._extract_and_add_metadata_tags_to_ffmpeg_cmd()
-            
+
             # Use pipe-based approach for audio input with special args for M4B chapters
             ffmpeg_args = [
-                "-i", chapters_info_path,
+                "-i",
-                "-map", "0:a",
+                chapters_info_path,
-                "-map_metadata", "1", 
+                "-map",
-                "-map_chapters", "1",
+                "0:a",
+                "-map_metadata",
+                "1",
+                "-map_chapters",
+                "1",
                 *metadata_options,
-                "-c:a", "aac",
+                "-c:a",
-                "-q:a", "2", # Quality-based VBR for better quality control
+                "aac",
-                "-movflags", "+faststart+use_metadata_tags",  # Added for better compatibility
+                "-q:a",
+                "2",  # Quality-based VBR for better quality control
+                "-movflags",
+                "+faststart+use_metadata_tags",  # Added for better compatibility
             ]
 
             # Use the established unified method with M4B-specific args
             success, out_path = self._process_audio_segments(
-                audio_segments, output_m4b_path, "m4b", use_ffmpeg=True, ffmpeg_args=ffmpeg_args
+                audio_segments,
+                output_m4b_path,
+                "m4b",
+                use_ffmpeg=True,
+                ffmpeg_args=ffmpeg_args,
             )
-            
+
             # Clean up the temporary chapter metadata file
             if os.path.exists(chapters_info_path):
                 try:
                     os.remove(chapters_info_path)
                 except Exception as e:
-                    self.log_updated.emit((f"Warning: Could not delete chapters file: {e}", "orange"))
+                    self.log_updated.emit(
+                        (f"Warning: Could not delete chapters file: {e}", "orange")
+                    )
 
             if success:
                 return out_path
-            
+
             # If M4B generation failed, fallback to WAV
-            self.log_updated.emit((f"M4B conversion failed. Falling back to WAV.\n", "red"))
+            self.log_updated.emit(
+                (f"M4B conversion failed. Falling back to WAV.\n", "red")
+            )
             success, wav_path = self._process_audio_segments(
                 audio_segments, final_wav_path, "wav", use_ffmpeg=False
             )
@@ -899,30 +1043,37 @@ class ConversionThread(QThread):
 
         except Exception as e:
             # General error during M4B generation - create WAV file directly as final output
-            self.log_updated.emit((f"Error during M4B generation: {str(e)}.\n\nFalling back to WAV.\n", "red"))
+            self.log_updated.emit(
-            
+                (
+                    f"Error during M4B generation: {str(e)}.\n\nFalling back to WAV.\n",
+                    "red",
+                )
+            )
+
             # Use the established unified method to create a WAV file as fallback
             success, wav_path = self._process_audio_segments(
                 audio_segments, final_wav_path, "wav", use_ffmpeg=False
             )
-            
+
             # Clean up temp files
             if os.path.exists(chapters_info_path):
                 try:
                     os.remove(chapters_info_path)
                 except Exception:
                     pass
-                
+
             if success:
                 return wav_path
             else:
-                self.log_updated.emit((f"Critical error: Failed to save WAV fallback", "red"))
+                self.log_updated.emit(
+                    (f"Critical error: Failed to save WAV fallback", "red")
+                )
                 return None
 
     def _extract_and_add_metadata_tags_to_ffmpeg_cmd(self):
         """Extract metadata tags from text content and add them to ffmpeg command"""
         metadata_options = []
-        
+
         # Get the input text (either direct or from file)
         text = ""
         if self.is_direct_text:
@@ -930,59 +1081,77 @@ class ConversionThread(QThread):
         else:
             try:
                 encoding = detect_encoding(self.file_name)
-                with open(self.file_name, "r", encoding=encoding, errors="replace") as file:
+                with open(
+                    self.file_name, "r", encoding=encoding, errors="replace"
+                ) as file:
                     text = file.read()
             except Exception as e:
-                self.log_updated.emit(f"Warning: Could not read file for metadata extraction: {e}")
+                self.log_updated.emit(
+                    f"Warning: Could not read file for metadata extraction: {e}"
+                )
                 return []
-                
+
         # Extract metadata tags using regex
         title_match = re.search(r"<<METADATA_TITLE:([^>]*)>>", text)
-        artist_match = re.search(r"<<METADATA_ARTIST:([^>]*)>>", text) 
+        artist_match = re.search(r"<<METADATA_ARTIST:([^>]*)>>", text)
         album_match = re.search(r"<<METADATA_ALBUM:([^>]*)>>", text)
         year_match = re.search(r"<<METADATA_YEAR:([^>]*)>>", text)
         album_artist_match = re.search(r"<<METADATA_ALBUM_ARTIST:([^>]*)>>", text)
         composer_match = re.search(r"<<METADATA_COMPOSER:([^>]*)>>", text)
         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:
             metadata_options.extend(["-metadata", f"title={filename}"])
-            
+
         # Add artist metadata
         if artist_match:
             metadata_options.extend(["-metadata", f"artist={artist_match.group(1)}"])
         else:
             metadata_options.extend(["-metadata", f"artist=Unknown"])
-            
+
         # Add album metadata
         if album_match:
             metadata_options.extend(["-metadata", f"album={album_match.group(1)}"])
         else:
             metadata_options.extend(["-metadata", f"album={filename}"])
-            
+
         # Add year metadata
         if year_match:
             metadata_options.extend(["-metadata", f"date={year_match.group(1)}"])
         else:
             # Use current year if year is not specified
             import datetime
+
             current_year = datetime.datetime.now().year
             metadata_options.extend(["-metadata", f"date={current_year}"])
 
         # Add album artist metadata
         if album_artist_match:
-            metadata_options.extend(["-metadata", f"album_artist={album_artist_match.group(1)}"])
+            metadata_options.extend(
+                ["-metadata", f"album_artist={album_artist_match.group(1)}"]
+            )
         else:
             metadata_options.extend(["-metadata", f"album_artist=Unknown"])
 
         # Add composer metadata
         if composer_match:
-            metadata_options.extend(["-metadata", f"composer={composer_match.group(1)}"])
+            metadata_options.extend(
+                ["-metadata", f"composer={composer_match.group(1)}"]
+            )
         else:
             metadata_options.extend(["-metadata", f"composer=Narrator"])
 
@@ -991,7 +1160,7 @@ class ConversionThread(QThread):
             metadata_options.extend(["-metadata", f"genre={genre_match.group(1)}"])
         else:
             metadata_options.extend(["-metadata", f"genre=Audiobook"])
-            
+
         # Add these to ffmpeg command
         return metadata_options
 
@@ -1002,7 +1171,7 @@ class ConversionThread(QThread):
         s = int(t % 60)
         ms = int((t - int(t)) * 1000)
         return f"{h:02}:{m:02}:{s:02},{ms:03}"
-        
+
     def _ass_time(self, t):
         """Helper function to format time for ASS files"""
         h = int(t // 3600)
@@ -1097,17 +1266,21 @@ class ConversionThread(QThread):
                         (group[0]["start"], group[-1]["end"], text.strip())
                     )
 
-    def _write_ass_subtitle(self, file_path, subtitle_entries, is_centered=False, is_narrow=False):
+    def _write_ass_subtitle(
+        self, file_path, subtitle_entries, is_centered=False, is_narrow=False
+    ):
         with open(file_path, "w", encoding="utf-8", errors="replace") as f:
             # Minimal ASS header
             f.write("[Script Info]\n")
             f.write("Title: Generated by Abogen\n")
             f.write("ScriptType: v4.00+\n\n")
-            
+
             # Only events section, use override tags for positioning
             f.write("[Events]\n")
-            f.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
+            f.write(
-            
+                "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
+            )
+
             # Set margin based on is_narrow parameter
             margin = "90" if is_narrow else ""
             alignment_tag = ""
@@ -1119,13 +1292,20 @@ class ConversionThread(QThread):
             for i, (start, end, text) in enumerate(subtitle_entries, 1):
                 start_time = self._ass_time(start)
                 end_time = self._ass_time(end)
-                f.write(f"Dialogue: 0,{start_time},{end_time},Default,,{margin},{margin},0,,{alignment_tag}{text}\n")
+                f.write(
+                    f"Dialogue: 0,{start_time},{end_time},Default,,{margin},{margin},0,,{alignment_tag}{text}\n"
+                )
 
     def cancel(self):
         self.cancel_requested = True
-        self.waiting_for_user_input = (
+        self.should_cancel = True
-            False  # Also release the wait if we're waiting for input
+        self.waiting_for_user_input = False
-        )
+        # Terminate subprocess if running
+        if self.process:
+            try:
+                self.process.terminate()
+            except Exception:
+                pass
 
 
 class VoicePreviewThread(QThread):
@@ -1149,11 +1329,13 @@ class VoicePreviewThread(QThread):
         self.voice = voice
         self.speed = speed
         self.use_gpu = use_gpu
-        
+
         # Cache location for preview audio
-        self.cache_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME, "preview_cache")
+        self.cache_dir = os.path.join(
+            tempfile.gettempdir(), PROGRAM_NAME, "preview_cache"
+        )
         os.makedirs(self.cache_dir, exist_ok=True)
-        
+
         # Calculate cache path
         self.cache_path = self._get_cache_path()
 
@@ -1161,10 +1343,12 @@ class VoicePreviewThread(QThread):
         """Generate a unique filename for the voice with its parameters"""
         # For a voice formula, use a hash of the formula
         if "*" in self.voice:
-            voice_id = f"voice_formula_{hashlib.md5(self.voice.encode()).hexdigest()[:8]}"
+            voice_id = (
+                f"voice_formula_{hashlib.md5(self.voice.encode()).hexdigest()[:8]}"
+            )
         else:
             voice_id = self.voice
-            
+
         # Create a unique filename based on voice_id, language, and speed
         filename = f"{voice_id}_{self.lang_code}_{self.speed:.2f}.wav"
         return os.path.join(self.cache_dir, filename)
@@ -1173,7 +1357,7 @@ class VoicePreviewThread(QThread):
         print(
             f"\nVoice: {self.voice}\nLanguage: {self.lang_code}\nSpeed: {self.speed}\nGPU: {self.use_gpu}\n"
         )
-        
+
         # Generate the preview and save to cache
         try:
             device = "cuda" if self.use_gpu else "cpu"
@@ -1221,7 +1405,7 @@ class PlayAudioThread(QThread):
             # Wait until playback is finished or canceled
             while pygame.mixer.music.get_busy() and not self.is_canceled:
                 _time.sleep(0.2)
-                
+
             # Make sure to clean up regardless of how we exited the loop
             try:
                 pygame.mixer.music.stop()
@@ -1230,21 +1414,24 @@ class PlayAudioThread(QThread):
             except Exception:
                 # Ignore any errors during cleanup
                 pass
-                
+
             self.finished.emit()
         except Exception as e:
             # Handle initialization errors separately to give better error messages
             if "mixer not initialized" in str(e):
-                self.error.emit("Audio playback error: The audio system was not properly initialized")
+                self.error.emit(
+                    "Audio playback error: The audio system was not properly initialized"
+                )
             else:
                 self.error.emit(f"Audio playback error: {str(e)}")
-            
+
     def stop(self):
         """Safely stop playback"""
         self.is_canceled = True
         # Try to stop pygame if it's running, but catch all exceptions
         try:
             import pygame
+
             if pygame.mixer.get_init():
                 if pygame.mixer.music.get_busy():
                     pygame.mixer.music.stop()

abogen/hf_tracker.py

@@ -1,16 +1,20 @@
 log_callback = None
 show_warning_signal_emitter = None  # Renamed for clarity
 
+
 def set_log_callback(cb):
     global log_callback
     log_callback = cb
 
+
 def set_show_warning_signal_emitter(emitter):  # Renamed for clarity
     global show_warning_signal_emitter
     show_warning_signal_emitter = emitter
 
+
 from huggingface_hub import hf_hub_download
 
+
 def tracked_hf_hub_download(*args, **kwargs):
     try:
         local_kwargs = dict(kwargs)
@@ -22,7 +26,10 @@ def tracked_hf_hub_download(*args, **kwargs):
         if filename.endswith(".pth"):
             msg = f"\nDownloading model '{filename}' from Hugging Face ({repo_id}). This may take a while. Please wait..."
             if show_warning_signal_emitter:  # Check if the emitter is set
-                show_warning_signal_emitter.emit("Downloading Model", f"Downloading model '{filename}' from Hugging Face repository '{repo_id}'. This may take a while, please wait.")
+                show_warning_signal_emitter.emit(
+                    "Downloading Model",
+                    f"Downloading model '{filename}' from Hugging Face repository '{repo_id}'. This may take a while, please wait.",
+                )
         else:
             msg = f"\nDownloading '{filename}' from Hugging Face ({repo_id}). Please wait..."
         if log_callback:
@@ -32,5 +39,7 @@ def tracked_hf_hub_download(*args, **kwargs):
             print(msg, flush=True)
     return hf_hub_download(*args, **kwargs)
 
+
 import huggingface_hub
-huggingface_hub.hf_hub_download = tracked_hf_hub_download
+
+huggingface_hub.hf_hub_download = tracked_hf_hub_download

abogen/is_nvidia.py

@@ -1,16 +1,22 @@
 import gpustat
 
+
 def check():
     try:
         stats = gpustat.new_query()
     except Exception:
         return False
 
+    nvidia_keywords = ["nvidia", "rtx", "gtx", "quadro", "tesla", "titan", "mx"]
     for gpu in stats.gpus:
-        print(gpu.name)
+        name = gpu.name.lower()
-        if 'nvidia' in gpu.name.lower():
+        if any(keyword in name for keyword in nvidia_keywords):
             return True
     return False
 
+
 if __name__ == "__main__":
-    print(check())
+    stats = gpustat.new_query()
+    for gpu in stats.gpus:
+        print(gpu.name)
+    print(check())

abogen/main.py

@@ -3,12 +3,13 @@ import sys
 import platform
 from PyQt5.QtWidgets import QApplication
 from PyQt5.QtGui import QIcon
+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 abogen.gui import abogen
-from utils import get_resource_path
+from abogen.utils import get_resource_path
-from constants import PROGRAM_NAME, VERSION
+from abogen.constants import PROGRAM_NAME, VERSION
 
 # Set environment variables for AMD ROCm
 os.environ["MIOPEN_FIND_MODE"] = "FAST"
@@ -24,6 +25,26 @@ if sys.stderr is None:
 if platform.system() == "Darwin" and platform.processor() == "arm":
     os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 
+
+# Custom message handler to filter out specific Qt warnings
+def qt_message_handler(mode, context, message):
+    if "Wayland does not support QWindow::requestActivate()" in message:
+        return  # Suppress this specific message
+    if "setGrabPopup called with a parent, QtWaylandClient" in message:
+        return
+    if mode == QtMsgType.QtWarningMsg:
+        print(f"Qt Warning: {message}")
+    elif mode == QtMsgType.QtCriticalMsg:
+        print(f"Qt Critical: {message}")
+    elif mode == QtMsgType.QtFatalMsg:
+        print(f"Qt Fatal: {message}")
+    elif mode == QtMsgType.QtInfoMsg:
+        print(f"Qt Info: {message}")
+
+
+# Install the custom message handler
+qInstallMessageHandler(qt_message_handler)
+
 # Set application ID for Windows taskbar icon
 if platform.system() == "Windows":
     import ctypes

abogen/queue_manager_gui.py

@@ -0,0 +1,553 @@
+# 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)

abogen/queued_item.py

@@ -0,0 +1,16 @@
+# 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

abogen/utils.py

@@ -105,19 +105,21 @@ def clean_text(text, *args, **kwargs):
 
 default_encoding = sys.getfilesystemencoding()
 
+
 def create_process(cmd, stdin=None, text=True, capture_output=False):
     import logging
+
     logger = logging.getLogger(__name__)
-    
+
     # Configure root logger to output to console if not already configured
     root = logging.getLogger()
     if not root.handlers:
         handler = logging.StreamHandler(sys.stdout)
-        formatter = logging.Formatter('%(message)s')
+        formatter = logging.Formatter("%(message)s")
         handler.setFormatter(formatter)
         root.addHandler(handler)
         root.setLevel(logging.INFO)
-    
+
     # Determine shell usage: use shell only for string commands
     use_shell = isinstance(cmd, str)
     kwargs = {
@@ -151,11 +153,12 @@ def create_process(cmd, stdin=None, text=True, capture_output=False):
 
     # Print the command being executed
     print(f"Executing: {cmd if isinstance(cmd, str) else ' '.join(cmd)}")
-    
+
     proc = subprocess.Popen(cmd, **kwargs)
-    
+
     # Stream output to console in real-time if not capturing
     if proc.stdout and not capture_output:
+
         def _stream_output(stream):
             if text:
                 # For text mode, read character by character for real-time output
@@ -174,12 +177,14 @@ def create_process(cmd, stdin=None, text=True, capture_output=False):
                         break
                     try:
                         # Try to decode binary data for display
-                        sys.stdout.write(chunk.decode(default_encoding, errors='replace'))
+                        sys.stdout.write(
+                            chunk.decode(default_encoding, errors="replace")
+                        )
                         sys.stdout.flush()
                     except Exception:
                         pass
             stream.close()
-        
+
         # Start a daemon thread to handle output streaming
         Thread(target=_stream_output, args=(proc.stdout,), daemon=True).start()
 
@@ -217,20 +222,34 @@ def calculate_text_length(text):
 
 
 def get_gpu_acceleration(enabled):
-    from torch.cuda import is_available
+    try:
+        import torch
+        from torch.cuda import is_available
 
-    if not enabled:
+        if not enabled:
-        return "CUDA GPU available but using CPU.", False
+            return "CUDA GPU available but using CPU.", False
-
+        if is_available():
-    if is_available():
+            return "CUDA GPU available and enabled.", True
-        return "CUDA GPU available and enabled.", True
+        # Gather more diagnostic info if CUDA is not available
-    return "CUDA GPU is not available. Using CPU.", False
+        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():
     system = platform.system()
     if system == "Windows":
         import ctypes
+
         ctypes.windll.kernel32.SetThreadExecutionState(
             0x80000000 | 0x00000001 | 0x00000040
         )
@@ -238,19 +257,22 @@ def prevent_sleep_start():
         _sleep_procs["Darwin"] = create_process(["caffeinate"])
     elif system == "Linux":
         # use a sleep that never exits so inhibition stays active
-        _sleep_procs["Linux"] = create_process([
+        _sleep_procs["Linux"] = create_process(
-            "systemd-inhibit",
+            [
-            "--what=handle-lid-switch:sleep",
+                "systemd-inhibit",
-            "--mode=block",
+                "--what=handle-lid-switch:sleep",
-            "sleep",
+                "--mode=block",
-            "infinity",
+                "sleep",
-        ])
+                "infinity",
+            ]
+        )
 
 
 def prevent_sleep_end():
     system = platform.system()
     if system == "Windows":
         import ctypes
+
         ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)  # ES_CONTINUOUS
     elif system in ("Darwin", "Linux") and _sleep_procs[system]:
         try:

abogen/voice_formula_gui.py

@@ -24,16 +24,20 @@ from PyQt5.QtWidgets import (
     QMenu,
     QAction,
     QComboBox,
+    QApplication,
 )
 from PyQt5.QtCore import Qt, QTimer, QPoint, QRect, QSize
-from PyQt5.QtGui import QPixmap, QIcon, QColor
+from PyQt5.QtGui import QPixmap, QIcon
-from constants import (
+from abogen.constants import (
     VOICES_INTERNAL,
     SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
     LANGUAGE_DESCRIPTIONS,
+    COLORS,
 )
-from utils import get_resource_path
+import re
-from voice_profiles import (
+import platform
+from abogen.utils import get_resource_path
+from abogen.voice_profiles import (
     load_profiles,
     save_profiles,
     delete_profile,
@@ -221,6 +225,21 @@ class VoiceMixer(QWidget):
         self.slider.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
         self.slider.setFixedWidth(SLIDER_WIDTH)
 
+        # Fix slider in Windows
+        if platform.system() == "Windows":
+            appstyle = QApplication.instance().style().objectName().lower()
+            if appstyle != "windowsvista":
+                # Set custom groove color for disabled state using COLORS["GREY_BACKGROUND"]
+                self.slider.setStyleSheet(
+                    f"""
+                    QSlider::groove:vertical:disabled {{
+                        background: {COLORS.get("GREY_BACKGROUND")};
+                        width: 4px;
+                        border-radius: 4px;
+                    }}
+                """
+                )
+
         # Connect controls
         self.slider.valueChanged.connect(lambda val: self.spin_box.setValue(val / 100))
         self.spin_box.valueChanged.connect(
@@ -271,9 +290,9 @@ class HoverLabel(QLabel):
         self.delete_button = QPushButton("×", self)
         self.delete_button.setFixedSize(16, 16)
         self.delete_button.setStyleSheet(
-            """
+            f"""
-            QPushButton {
+            QPushButton {{
-                background-color: #ff5555;
+                background-color: {COLORS.get("RED")};
                 color: white;
                 border-radius: 7px;
                 font-weight: bold;
@@ -281,11 +300,11 @@ class HoverLabel(QLabel):
                 border: none;
                 padding: 0px;
                 margin: 0px;
-            }
+            }}
-            QPushButton:hover {
+            QPushButton:hover {{
                 background-color: red;
-            }
+            }}
-        """
+            """
         )
         # Make sure the entire button is clickable, not just the text
         self.delete_button.setFocusPolicy(Qt.NoFocus)
@@ -313,7 +332,9 @@ class VoiceFormulaDialog(QDialog):
         self._original_mixed_voice_state = None
         if parent is not None:
             self._original_profile_name = getattr(parent, "selected_profile_name", None)
-            self._original_mixed_voice_state = getattr(parent, "mixed_voice_state", None)
+            self._original_mixed_voice_state = getattr(
+                parent, "mixed_voice_state", None
+            )
         profiles = load_profiles()
         self._virtual_new_profile = False
         if not profiles:
@@ -350,6 +371,11 @@ class VoiceFormulaDialog(QDialog):
         profile_layout.addLayout(header_layout)
         # Profile list
         self.profile_list = QListWidget()
+        self.profile_list.setSelectionMode(QListWidget.SingleSelection)
+        self.profile_list.setSelectionBehavior(QListWidget.SelectRows)
+        self.profile_list.setStyleSheet(
+            "QListWidget::item:selected { background: palette(highlight); color: palette(highlighted-text); }"
+        )
         icon = QIcon(get_resource_path("abogen.assets", "profile.png"))
         if self._virtual_new_profile:
             item = QListWidgetItem(icon, "New profile")
@@ -738,7 +764,7 @@ class VoiceFormulaDialog(QDialog):
                 percentage = weight / total * 100
                 # Make the voice name bold and include percentage
                 voice_label = HoverLabel(
-                    f'<b><span style="color:#007dff">{name}: {percentage:.1f}%</span></b>',
+                    f'<b><span style="color:{COLORS.get("BLUE")}">{name}: {percentage:.1f}%</span></b>',
                     name,
                 )
                 voice_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
@@ -953,6 +979,19 @@ class VoiceFormulaDialog(QDialog):
             return
         super().closeEvent(event)
 
+    def _parse_rgba_to_qcolor(self, rgba_str):
+        from PyQt5.QtCore import Qt
+        from PyQt5.QtGui import QColor
+
+        """Helper to convert 'rgba(R,G,B,A_float)' string to QColor."""
+        match = re.match(r"rgba\((\d+),\s*(\d+),\s*(\d+),\s*([\d.]+)\)", rgba_str)
+        if match:
+            r, g, b = int(match.group(1)), int(match.group(2)), int(match.group(3))
+            a_float = float(match.group(4))
+            a_int = int(a_float * 255)
+            return QColor(r, g, b, a_int)
+        return Qt.GlobalColor.transparent
+
     def mark_profile_modified(self):
         item = self.profile_list.currentItem()
         if item and not item.text().startswith("*"):
@@ -1052,7 +1091,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:
@@ -1339,23 +1378,23 @@ class VoiceFormulaDialog(QDialog):
                 self.profile_list.setItemWidget(item, widget)
 
     def update_profile_list_colors(self):
+        from PyQt5.QtCore import Qt
+
         profiles = load_profiles()
         for i in range(self.profile_list.count()):
             item = self.profile_list.item(i)
             name = item.text().lstrip("*")
             if self._virtual_new_profile and name == "New profile":
-                color = QColor("#ffff00")  # yellow
+                color = self._parse_rgba_to_qcolor(COLORS.get("YELLOW_BACKGROUND"))
-                color.setAlpha(64)  # Set transparency
+                item.setData(Qt.BackgroundRole, color)
-                item.setBackground(color)
             elif item.text().startswith("*"):
-                color = QColor("#ffff00")  # yellow
+                color = self._parse_rgba_to_qcolor(COLORS.get("YELLOW_BACKGROUND"))
-                color.setAlpha(64)  # Set transparency
+                item.setData(Qt.BackgroundRole, color)
-                item.setBackground(color)
             else:
-                item.setBackground(self.profile_list.palette().base().color()) # Use default list item background
+                item.setData(
-
+                    Qt.BackgroundRole, self.profile_list.palette().base().color()
+                )
                 weights = profiles.get(name, {}).get("voices", [])
-                # Defensive: only sum if weights is a list of (voice, weight) pairs
                 total = 0
                 if isinstance(weights, list):
                     for entry in weights:
@@ -1366,9 +1405,8 @@ class VoiceFormulaDialog(QDialog):
                         ):
                             total += entry[1]
                 if total == 0:
-                    color = QColor("#ff0000")  # red
+                    color = self._parse_rgba_to_qcolor(COLORS.get("RED_BACKGROUND"))
-                    color.setAlpha(64)  # Set transparency
+                    item.setData(Qt.BackgroundRole, color)
-                    item.setBackground(color)
         self.update_profile_save_buttons()
 
     def preview_current_mix(self):

abogen/voice_formulas.py

@@ -1,5 +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

abogen/voice_profiles.py

@@ -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():

demo/README.md

@@ -23,7 +23,7 @@ brew install ffmpeg
 sudo apt install ffmpeg
 ```
 
-### Create the Video (.webm)
+## Create the Video (.webm)
 
 Run this FFmpeg command to create the tiny video: