Update __version__.py

* wip: use PyQT5 for window display

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* wip: first slide is shown

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* wip: pushing non-working code

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* wip: some logging

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* feat: new configuration wizard working

* fix: prevent key error

* wip: making action work

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* wip: soon done! info + video

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix: bugs in sleep and exiting

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* try: offscreen

* fix: pop default value if not present

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* feat: add aspect ratio option

* chore: typing wip

* fix: now() function returns seconds, not milliseconds anymore

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

.flake8

@@ -0,0 +1,4 @@
+[flake8]
+extend-ignore =
+    # E501: line too long
+    E501,

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,40 @@
+name: Bug
+description: Report an issue to help improve the project.
+labels: "bug"
+title: '[BUG] <description>'
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: A brief description of the question or issue, also include what you tried and what didn't work
+    validations:
+      required: true
+  - type: textarea
+    id: version
+    attributes:
+      label: Version
+      description: Which version of Manim Slides are you using? You can use `manim-slides --version` to get that information.
+    validations:
+      required: true
+  - type: textarea
+    id: platform
+    attributes:
+      label: Platform
+      description: What is your platform. Linux, macOS, or Windows?
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add screenshots if applicable
+    validations:
+      required: false
+  - type: textarea
+    id: extrainfo
+    attributes:
+      label: Additional information
+      description: Is there anything else we should know about this bug?
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,26 @@
+name: Feature Request
+description: Have a new idea/feature? Please suggest!
+labels: "enhancement"
+title: '[FEATURE] <description>'
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: A brief description of the enhancement you propose, also include what you tried and what worked.
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add screenshots if applicable
+    validations:
+      required: false
+  - type: textarea
+    id: extrainfo
+    attributes:
+      label: Additional information
+      description: Is there anything else we should know about this idea?
+    validations:
+      required: false

.github/pull_request_template.md

@@ -0,0 +1,26 @@
+<!-- If your PR fixes an open issue, use `Closes #999` to link your PR with the issue. #999 stands for the issue number you are fixing -->
+
+## Fixes Issue
+
+<!-- Remove this section if not applicable -->
+
+<!-- Example: Closes #31 -->
+
+## Description
+
+<!-- Describe all the proposed changes in your PR -->
+
+## Check List (Check all the applicable boxes)
+
+- [ ] I understand that my contributions needs to pass the checks.
+- [ ] If I created new functions / methods, I documented them and add type hints.
+- [ ] If I modified already existing code, I updated the documentation accordingly.
+- [ ] The title of my pull request is a short description of the requested changes.
+
+## Screenshots
+
+<!-- Add all the screenshots which support your changes -->
+
+## Note to reviewers
+
+<!-- Add notes to reviewers if applicable -->

.github/workflows/pages.yml

@@ -0,0 +1,50 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy static content to Pages
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["main"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Pages
+        uses: actions/configure-pages@v2
+      - name: Install Linux Dependencies
+        run: sudo apt install libcairo2-dev libpango1.0-dev ffmpeg
+      - name: Install Python dependencies
+        run: pip install manim sphinx sphinx_click furo
+      - name: Install local Python package
+        run: pip install -e .
+      - name: Build docs
+        run: cd docs && make html
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v1
+        with:
+          # Upload docs/build/html dir
+          path: 'docs/build/html/'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v1

.github/workflows/test_examples.yml

@@ -6,6 +6,9 @@ on:
 
 name: Test Examples
 
+env:
+  QT_QPA_PLATFORM: offscreen
+
 jobs:
   build-examples:
     strategy:

.gitignore

@@ -17,3 +17,5 @@ slides/
 videos/
 
 images/
+
+docs/build/

.pre-commit-config.yaml

@@ -6,7 +6,7 @@ repos:
     -   id: end-of-file-fixer
     -   id: trailing-whitespace
 -   repo: https://github.com/psf/black
-    rev: 22.8.0
+    rev: 22.10.0
     hooks:
     -   id: black
 -   repo: https://github.com/pycqa/isort
@@ -16,10 +16,47 @@ repos:
         name: isort (python)
         args: ["--profile", "black"]
 -   repo: https://github.com/psf/black
-    rev: 22.8.0
+    rev: 22.10.0
     hooks:
       - id: black
--   repo: https://github.com/jendrikseipp/vulture
-    rev: v2.3
+-   repo: https://github.com/PyCQA/flake8
+    rev: 5.0.4
     hooks:
-      - id: vulture
+      - id: flake8
+        additional_dependencies:
+        - flake8-bugbear
+        - flake8-comprehensions
+        - flake8-tidy-imports
+        - flake8-typing-imports
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: 'v0.982'
+    hooks:
+    -   id: mypy
+        args:
+        - --install-types
+        - --non-interactive
+        - --ignore-missing-imports
+        # Disallow dynamic typing
+        - --disallow-any-unimported
+        - --disallow-any-generics
+        - --disallow-subclassing-any
+
+        # Disallow untyped definitions and calls
+        - --disallow-untyped-defs
+        - --disallow-incomplete-defs
+        - --check-untyped-defs
+
+        # None and optional handling
+        - --no-implicit-optional
+
+        # Configuring warnings
+        - --warn-unused-ignores
+        - --warn-no-return
+        - --warn-return-any
+        - --warn-redundant-casts
+
+        # Strict equality
+        - --strict-equality
+
+        # Config file
+        - --warn-unused-configs

README.md

@@ -30,7 +30,7 @@ While installing Manim Slides and its dependencies on your global Python is fine
 
 Manim Slides requires either Manim or ManimGL to be installed. Having both packages installed is fine too.
 
-If none of those packages are installed, please refer to their specifc installation guidelines:
+If none of those packages are installed, please refer to their specific installation guidelines:
 - [Manim](https://docs.manim.community/en/stable/installation.html)
 - [ManimGL](https://3b1b.github.io/manim/getting_started/installation.html)
 
@@ -59,6 +59,8 @@ Using Manim Slides is a two-step process:
 1. Render animations using `Slide` (resp. `ThreeDSlide`) as a base class instead of `Scene` (resp. `ThreeDScene`), and add calls to `self.pause()` everytime you want to create a new slide.
 2. Run `manim-slides` on rendered animations and display them like a *Power Point* presentation.
 
+The command-line documentation is available [online](https://eertmans.be/manim-slides/).
+
 ### Basic Example
 
 

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/source/conf.py

@@ -0,0 +1,27 @@
+# type: ignore
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = "Manim Slides"
+copyright = "2022, Jérome Eertmans"
+author = "Jérome Eertmans"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = ["sphinx.ext.autodoc", "sphinx_click"]
+
+templates_path = ["_templates"]
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "furo"
+html_static_path = ["_static"]

docs/source/index.rst

@@ -0,0 +1,20 @@
+.. manim-slides documentation master file, created by
+   sphinx-quickstart on Wed Sep 21 15:07:28 2022.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+.. image:: _static/logo.png
+    :width: 600
+    :align: center
+    :alt: Manim Slide logo
+
+Welcome to Manim Slide's CLI documentation!
+===========================================
+
+This page contains an exhaustive list of all the commands available with `manim-slides`.
+
+If you need help installing or using Manim Slide, please refer to the `GitHub README <https://github.com/jeertmans/manim-slides>`_.
+
+.. click:: manim_slides.main:cli
+    :prog: manim-slides
+    :nested: full

example.py

@@ -1,3 +1,5 @@
+# flake8: noqa: F403, F405
+# type: ignore
 import sys
 
 if "manim" in sys.modules:

manim_slides/__init__.py

@@ -1,2 +1,3 @@
+# flake8: noqa: F401
 from .__version__ import __version__
 from .slide import Slide, ThreeDSlide

manim_slides/__version__.py

@@ -1 +1 @@
-__version__ = "4.0.1"
+__version__ = "4.2.0"

manim_slides/commons.py

@@ -1,11 +1,13 @@
 from typing import Callable
 
 import click
+from click import Context, Parameter
 
 from .defaults import CONFIG_PATH
+from .manim import logger
 
 
-def config_path_option(function) -> Callable:
+def config_path_option(function: Callable) -> Callable:
     """Wraps a function to add configuration path option."""
     return click.option(
         "-c",
@@ -14,10 +16,11 @@ def config_path_option(function) -> Callable:
         default=CONFIG_PATH,
         type=click.Path(dir_okay=False),
         help="Set path to configuration file.",
+        show_default=True,
     )(function)
 
 
-def config_options(function) -> Callable:
+def config_options(function: Callable) -> Callable:
     """Wraps a function to add configuration options."""
     function = config_path_option(function)
     function = click.option(
@@ -30,3 +33,27 @@ def config_options(function) -> Callable:
         help="Merge any existing configuration file with the new configuration.",
     )(function)
     return function
+
+
+def verbosity_option(function: Callable) -> Callable:
+    """Wraps a function to add verbosity option."""
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+
+        if not value or ctx.resilient_parsing:
+            return
+
+        logger.setLevel(value)
+
+    return click.option(
+        "-v",
+        "--verbosity",
+        type=click.Choice(
+            ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            case_sensitive=False,
+        ),
+        help="Verbosity of CLI output",
+        default=None,
+        expose_value=False,
+        callback=callback,
+    )(function)

manim_slides/config.py

@@ -3,8 +3,9 @@ from enum import Enum
 from typing import List, Optional, Set
 
 from pydantic import BaseModel, root_validator, validator
+from PyQt5.QtCore import Qt
 
-from .defaults import LEFT_ARROW_KEY_CODE, RIGHT_ARROW_KEY_CODE
+from .manim import logger
 
 
 class Key(BaseModel):
@@ -13,25 +14,33 @@ class Key(BaseModel):
     ids: Set[int]
     name: Optional[str] = None
 
+    def set_ids(self, *ids: int) -> None:
+        self.ids = set(ids)
+
     @validator("ids", each_item=True)
-    def id_is_posint(cls, v: int):
+    def id_is_posint(cls, v: int) -> int:
         if v < 0:
             raise ValueError("Key ids cannot be negative integers")
         return v
 
-    def match(self, key_id: int):
-        return key_id in self.ids
+    def match(self, key_id: int) -> bool:
+        m = key_id in self.ids
+
+        if m:
+            logger.debug(f"Pressed key: {self.name}")
+
+        return m
 
 
 class Config(BaseModel):
     """General Manim Slides config"""
 
-    QUIT: Key = Key(ids=[ord("q")], name="QUIT")
-    CONTINUE: Key = Key(ids=[RIGHT_ARROW_KEY_CODE], name="CONTINUE / NEXT")
-    BACK: Key = Key(ids=[LEFT_ARROW_KEY_CODE], name="BACK")
-    REVERSE: Key = Key(ids=[ord("v")], name="REVERSE")
-    REWIND: Key = Key(ids=[ord("r")], name="REWIND")
-    PLAY_PAUSE: Key = Key(ids=[32], name="PLAY / PAUSE")
+    QUIT: Key = Key(ids=[Qt.Key_Q], name="QUIT")
+    CONTINUE: Key = Key(ids=[Qt.Key_Right], name="CONTINUE / NEXT")
+    BACK: Key = Key(ids=[Qt.Key_Left], name="BACK")
+    REVERSE: Key = Key(ids=[Qt.Key_V], name="REVERSE")
+    REWIND: Key = Key(ids=[Qt.Key_R], name="REWIND")
+    PLAY_PAUSE: Key = Key(ids=[Qt.Key_Space], name="PLAY / PAUSE")
 
     @root_validator
     def ids_are_unique_across_keys(cls, values):
@@ -40,7 +49,7 @@ class Config(BaseModel):
         for key in values.values():
             if len(ids.intersection(key.ids)) != 0:
                 raise ValueError(
-                    "Two or more keys share a common key code: please make sure each key has distinc key codes"
+                    "Two or more keys share a common key code: please make sure each key has distinct key codes"
                 )
             ids.update(key.ids)
 
@@ -84,6 +93,11 @@ class SlideConfig(BaseModel):
     def start_animation_is_before_end(cls, values):
         if values["start_animation"] >= values["end_animation"]:
 
+            if values["start_animation"] == values["end_animation"] == 0:
+                raise ValueError(
+                    "You have to play at least one animation (e.g., `self.wait()`) before pausing. If you want to start paused, use the approriate command-line option when presenting."
+                )
+
             raise ValueError(
                 "Start animation index must be strictly lower than end animation index"
             )

manim_slides/defaults.py

@@ -1,14 +1,2 @@
-import platform
-
-import cv2
-
-FONT_ARGS = (cv2.FONT_HERSHEY_SIMPLEX, 1, 255, 1, cv2.LINE_AA)
 FOLDER_PATH: str = "./slides"
 CONFIG_PATH: str = ".manim-slides.json"
-
-if platform.system() == "Windows":
-    RIGHT_ARROW_KEY_CODE = 2555904
-    LEFT_ARROW_KEY_CODE = 2424832
-else:
-    RIGHT_ARROW_KEY_CODE = 65363
-    LEFT_ARROW_KEY_CODE = 65361

manim_slides/main.py

@@ -9,7 +9,12 @@ from .wizard import init, wizard
 @click.group(cls=DefaultGroup, default="present", default_if_no_args=True)
 @click.version_option(__version__, "-v", "--version")
 @click.help_option("-h", "--help")
-def cli():
+def cli() -> None:
+    """
+    Manim Slides command-line utilities.
+
+    If not command is specified, defaults to `present`.
+    """
     pass
 
 

manim_slides/manim.py

@@ -2,10 +2,27 @@ import os
 import sys
 from contextlib import contextmanager
 from importlib.util import find_spec
+from typing import Iterator
+
+__all__ = [
+    "MANIM",
+    "MANIM_PACKAGE_NAME",
+    "MANIM_AVAILABLE",
+    "MANIM_IMPORTED",
+    "MANIMGL",
+    "MANIMGL_PACKAGE_NAME",
+    "MANIMGL_AVAILABLE",
+    "MANIMGL_IMPORTED",
+    "logger",
+    "Scene",
+    "ThreeDScene",
+    "config",
+    "FFMPEG_BIN",
+]
 
 
 @contextmanager
-def suppress_stdout():
+def suppress_stdout() -> Iterator[None]:
     with open(os.devnull, "w") as devnull:
         old_stdout = sys.stdout
         sys.stdout = devnull
@@ -49,8 +66,6 @@ else:
     )
 
 
-FFMPEG_BIN = None
-
 if MANIMGL:
     from manimlib import Scene, ThreeDScene, config
     from manimlib.constants import FFMPEG_BIN
@@ -61,6 +76,6 @@ else:
         from manim import Scene, ThreeDScene, config, logger
 
         try:  # For manim<v0.16.0.post0
-            from manim.constants import FFMPEG_BIN as FFMPEG_BIN
+            from manim.constants import FFMPEG_BIN
         except ImportError:
             FFMPEG_BIN = config.ffmpeg_executable

manim_slides/present.py

@@ -1,35 +1,38 @@
-import json
-import math
 import os
 import platform
 import sys
 import time
 from enum import IntEnum, auto, unique
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 import click
 import cv2
 import numpy as np
 from pydantic import ValidationError
+from PyQt5 import QtGui
+from PyQt5.QtCore import Qt, QThread, pyqtSignal, pyqtSlot
+from PyQt5.QtGui import QPixmap
+from PyQt5.QtWidgets import QApplication, QGridLayout, QLabel, QWidget
+from tqdm import tqdm
 
-from .commons import config_path_option
+from .commons import config_path_option, verbosity_option
 from .config import Config, PresentationConfig, SlideConfig, SlideType
-from .defaults import CONFIG_PATH, FOLDER_PATH, FONT_ARGS
+from .defaults import FOLDER_PATH
+from .manim import logger
 
-INTERPOLATION_FLAGS = {
-    "nearest": cv2.INTER_NEAREST,
-    "linear": cv2.INTER_LINEAR,
-    "cubic": cv2.INTER_CUBIC,
-    "area": cv2.INTER_AREA,
-    "lanczos4": cv2.INTER_LANCZOS4,
-    "linear-exact": cv2.INTER_LINEAR_EXACT,
-    "nearest-exact": cv2.INTER_NEAREST_EXACT,
-}
+os.environ.pop(
+    "QT_QPA_PLATFORM_PLUGIN_PATH", None
+)  # See why here: https://stackoverflow.com/a/67863156
 
 WINDOW_NAME = "Manim Slides"
 WINDOW_INFO_NAME = f"{WINDOW_NAME}: Info"
 WINDOWS = platform.system() == "Windows"
 
+ASPECT_RATIO_MODES = {
+    "ignore": Qt.IgnoreAspectRatio,
+    "keep": Qt.KeepAspectRatio,
+}
+
 
 @unique
 class State(IntEnum):
@@ -44,33 +47,29 @@ class State(IntEnum):
         return self.name.capitalize()
 
 
-def now() -> int:
-    """Returns time.time() in milliseconds."""
-    return round(time.time() * 1000)
-
-
-def fix_time(t: float) -> float:
-    """Clips time t such that it is always positive."""
-    return t if t > 0 else 1
+def now() -> float:
+    """Returns time.time() in seconds."""
+    return time.time()
 
 
 class Presentation:
     """Creates presentation from a configuration object."""
 
-    def __init__(self, config: PresentationConfig):
+    def __init__(self, config: PresentationConfig) -> None:
         self.slides: List[SlideConfig] = config.slides
         self.files: List[str] = config.files
 
-        self.current_slide_index = 0
-        self.current_animation = self.current_slide.start_animation
+        self.current_slide_index: int = 0
+        self.current_animation: int = self.current_slide.start_animation
+        self.current_file: Optional[str] = None
 
-        self.loaded_animation_cap = -1
+        self.loaded_animation_cap: int = -1
         self.cap = None  # cap = cv2.VideoCapture
 
-        self.reverse = False
-        self.reversed_animation = -1
+        self.reverse: bool = False
+        self.reversed_animation: int = -1
 
-        self.lastframe = None
+        self.lastframe: Optional[np.ndarray] = None
 
         self.reset()
         self.add_last_slide()
@@ -90,28 +89,32 @@ class Presentation:
         """Returns last slide."""
         return self.slides[-1]
 
-    def release_cap(self):
+    def release_cap(self) -> None:
         """Releases current Video Capture, if existing."""
-        if not self.cap is None:
+        if self.cap is not None:
             self.cap.release()
 
         self.loaded_animation_cap = -1
 
-    def load_animation_cap(self, animation: int):
+    def load_animation_cap(self, animation: int) -> None:
         """Loads video file of given animation."""
         # We must load a new VideoCapture file if:
         if (self.loaded_animation_cap != animation) or (
             self.reverse and self.reversed_animation != animation
         ):  # cap already loaded
 
+            logger.debug(f"Loading new cap for animation #{animation}")
+
             self.release_cap()
 
-            file = self.files[animation]
+            file: str = self.files[animation]
 
             if self.reverse:
                 file = "{}_reversed{}".format(*os.path.splitext(file))
                 self.reversed_animation = animation
 
+            self.current_file = file
+
             self.cap = cv2.VideoCapture(file)
             self.loaded_animation_cap = animation
 
@@ -121,26 +124,35 @@ class Presentation:
         self.load_animation_cap(self.current_animation)
         return self.cap
 
-    def rewind_current_slide(self):
+    def rewind_current_slide(self) -> None:
         """Rewinds current slide to first frame."""
+        logger.debug("Rewinding curring slide")
         if self.reverse:
             self.current_animation = self.current_slide.end_animation - 1
         else:
             self.current_animation = self.current_slide.start_animation
 
-        self.current_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        cap = self.current_cap
+        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
 
-    def reverse_current_slide(self):
+    def cancel_reverse(self) -> None:
+        """Cancels any effet produced by a reversed slide."""
+        if self.reverse:
+            logger.debug("Cancelling effects from previous 'reverse' action'")
+            self.reverse = False
+            self.reversed_animation = -1
+            self.release_cap()
+
+    def reverse_current_slide(self) -> None:
         """Reverses current slide."""
         self.reverse = True
         self.rewind_current_slide()
 
-    def load_next_slide(self):
+    def load_next_slide(self) -> None:
         """Loads next slide."""
+        logger.debug("Loading next slide")
         if self.reverse:
-            self.reverse = False
-            self.reversed_animation = -1
-            self.release_cap()
+            self.cancel_reverse()
             self.rewind_current_slide()
         elif self.current_slide.is_last():
             self.current_slide.terminated = True
@@ -150,17 +162,24 @@ class Presentation:
             )
             self.rewind_current_slide()
 
-    def load_previous_slide(self):
+    def load_previous_slide(self) -> None:
         """Loads previous slide."""
+        logger.debug("Loading previous slide")
+        self.cancel_reverse()
         self.current_slide_index = max(0, self.current_slide_index - 1)
         self.rewind_current_slide()
 
     @property
     def fps(self) -> int:
         """Returns the number of frames per second of the current video."""
-        return self.current_cap.get(cv2.CAP_PROP_FPS)
+        fps = self.current_cap.get(cv2.CAP_PROP_FPS)
+        if fps == 0:
+            logger.warn(
+                f"Something is wrong with video file {self.current_file}, as the fps returned by frame {self.current_frame_number} is 0"
+            )
+        return max(fps, 1)  # TODO: understand why we sometimes get 0 fps
 
-    def add_last_slide(self):
+    def add_last_slide(self) -> None:
         """Add a 'last' slide to the end of slides."""
         self.slides.append(
             SlideConfig(
@@ -171,14 +190,14 @@ class Presentation:
             )
         )
 
-    def reset(self):
+    def reset(self) -> None:
         """Rests current presentation."""
         self.current_animation = 0
         self.load_animation_cap(0)
         self.current_slide_index = 0
         self.slides[-1].terminated = False
 
-    def load_last_slide(self):
+    def load_last_slide(self) -> None:
         """Loads last slide."""
         self.current_slide_index = len(self.slides) - 2
         assert (
@@ -204,6 +223,11 @@ class Presentation:
         else:
             return self.next_animation == self.current_slide.end_animation
 
+    @property
+    def current_frame_number(self) -> int:
+        """Returns current frame number."""
+        return int(self.current_cap.get(cv2.CAP_PROP_POS_FRAMES))
+
     def update_state(self, state) -> Tuple[np.ndarray, State]:
         """
         Updates the current state given the previous one.
@@ -250,62 +274,47 @@ class Presentation:
         return self.lastframe, state
 
 
-class Display:
+class Display(QThread):
     """Displays one or more presentations one after each other."""
 
+    change_video_signal = pyqtSignal(np.ndarray)
+    change_info_signal = pyqtSignal(dict)
+    finished = pyqtSignal()
+
     def __init__(
         self,
         presentations,
         config,
         start_paused=False,
-        fullscreen=False,
         skip_all=False,
-        resolution=(1980, 1080),
-        interpolation_flag=cv2.INTER_LINEAR,
-    ):
+        record_to=None,
+        exit_after_last_slide=False,
+    ) -> None:
+        super().__init__()
         self.presentations = presentations
         self.start_paused = start_paused
         self.config = config
         self.skip_all = skip_all
-        self.fullscreen = fullscreen
-        self.resolution = resolution
-        self.interpolation_flag = interpolation_flag
-        self.window_flags = (
-            cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_FREERATIO | cv2.WINDOW_NORMAL
-        )
+        self.record_to = record_to
+        self.recordings: List[Tuple[str, int, int]] = []
 
         self.state = State.PLAYING
-        self.lastframe = None
+        self.lastframe: Optional[np.ndarray] = None
         self.current_presentation_index = 0
-        self.exit = False
+        self.run_flag = True
 
-        self.lag = 0
-        self.last_time = now()
-
-        cv2.namedWindow(
-            WINDOW_INFO_NAME,
-            cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_FREERATIO | cv2.WINDOW_AUTOSIZE,
-        )
-
-        if self.fullscreen:
-            cv2.namedWindow(
-                WINDOW_NAME, cv2.WINDOW_GUI_NORMAL | cv2.WND_PROP_FULLSCREEN
-            )
-            cv2.setWindowProperty(
-                WINDOW_NAME, cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN
-            )
-        else:
-            cv2.namedWindow(WINDOW_NAME, self.window_flags)
-            cv2.resizeWindow(WINDOW_NAME, *self.resolution)
+        self.key = -1
+        self.exit_after_last_slide = exit_after_last_slide
 
     @property
     def current_presentation(self) -> Presentation:
-        """Returns the current presentation"""
+        """Returns the current presentation."""
         return self.presentations[self.current_presentation_index]
 
-    def run(self):
+    def run(self) -> None:
         """Runs a series of presentations until end or exit."""
-        while not self.exit:
+        while self.run_flag:
+            last_time = now()
             self.lastframe, self.state = self.current_presentation.update_state(
                 self.state
             )
@@ -315,82 +324,98 @@ class Display:
                     self.start_paused = False
             if self.state == State.END:
                 if self.current_presentation_index == len(self.presentations) - 1:
-                    self.quit()
-                    continue
+                    if self.exit_after_last_slide:
+                        self.run_flag = False
+                        continue
                 else:
                     self.current_presentation_index += 1
                     self.state = State.PLAYING
+
             self.handle_key()
-            if self.exit:
-                continue
             self.show_video()
             self.show_info()
 
-    def show_video(self):
+            lag = now() - last_time
+            sleep_time = 1 / self.current_presentation.fps
+            sleep_time = max(sleep_time - lag, 0)
+            time.sleep(sleep_time)
+            last_time = now()
+        self.current_presentation.release_cap()
+
+        if self.record_to is not None:
+            self.record_movie()
+
+        logger.debug("Closing video thread gracully and exiting")
+        self.finished.emit()
+
+    def record_movie(self) -> None:
+        logger.debug(
+            f"A total of {len(self.recordings)} frames will be saved to {self.record_to}"
+        )
+        file, frame_number, fps = self.recordings[0]
+
+        cap = cv2.VideoCapture(file)
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number - 1)
+        _, frame = cap.read()
+
+        w, h = frame.shape[:2]
+        fourcc = cv2.VideoWriter_fourcc(*"XVID")
+        out = cv2.VideoWriter(self.record_to, fourcc, fps, (h, w))
+
+        out.write(frame)
+
+        for _file, frame_number, _ in tqdm(
+            self.recordings[1:], desc="Creating recording file", leave=False
+        ):
+            if file != _file:
+                cap.release()
+                file = _file
+                cap = cv2.VideoCapture(_file)
+
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number - 1)
+            _, frame = cap.read()
+            out.write(frame)
+
+        cap.release()
+        out.release()
+
+    def show_video(self) -> None:
         """Shows updated video."""
-        self.lag = now() - self.last_time
-        self.last_time = now()
+        if self.record_to is not None:
+            pres = self.current_presentation
+            self.recordings.append(
+                (pres.current_file, pres.current_frame_number, pres.fps)
+            )
 
-        frame = self.lastframe
+        frame: np.ndarray = self.lastframe
+        self.change_video_signal.emit(frame)
 
-        # If Window was manually closed (impossible in fullscreen),
-        # we reopen it
-        if cv2.getWindowProperty(WINDOW_NAME, cv2.WND_PROP_VISIBLE) < 1:
-            cv2.namedWindow(WINDOW_NAME, self.window_flags)
-            cv2.resizeWindow(WINDOW_NAME, *self.resolution)
-
-        if WINDOWS:  # Only resize on Windows
-            _, _, w, h = cv2.getWindowImageRect(WINDOW_NAME)
-
-            if (h, w) != frame.shape[:2]:  # Only if shape is different
-                frame = cv2.resize(frame, (w, h), self.interpolation_flag)
-
-        cv2.imshow(WINDOW_NAME, frame)
-
-    def show_info(self):
+    def show_info(self) -> None:
         """Shows updated information about presentations."""
-        info = np.zeros((130, 420), np.uint8)
-        font_args = (FONT_ARGS[0], 0.7, *FONT_ARGS[2:])
-        grid_x = [30, 230]
-        grid_y = [30, 70, 110]
-
-        cv2.putText(
-            info,
-            f"Animation: {self.current_presentation.current_animation}",
-            (grid_x[0], grid_y[0]),
-            *font_args,
-        )
-        cv2.putText(info, f"State: {self.state}", (grid_x[1], grid_y[0]), *font_args)
-
-        cv2.putText(
-            info,
-            f"Slide {self.current_presentation.current_slide.number}/{len(self.current_presentation.slides)}",
-            (grid_x[0], grid_y[1]),
-            *font_args,
-        )
-        cv2.putText(
-            info,
-            f"Slide Type: {self.current_presentation.current_slide.type}",
-            (grid_x[1], grid_y[1]),
-            *font_args,
+        self.change_info_signal.emit(
+            {
+                "animation": self.current_presentation.current_animation,
+                "state": self.state,
+                "slide_index": self.current_presentation.current_slide.number,
+                "n_slides": len(self.current_presentation.slides),
+                "type": self.current_presentation.current_slide.type,
+                "scene_index": self.current_presentation_index + 1,
+                "n_scenes": len(self.presentations),
+            }
         )
 
-        cv2.putText(
-            info,
-            f"Scene  {self.current_presentation_index + 1}/{len(self.presentations)}",
-            ((grid_x[0] + grid_x[1]) // 2, grid_y[2]),
-            *font_args,
-        )
+    @pyqtSlot(int)
+    def set_key(self, key: int) -> None:
+        """Sets the next key to be handled."""
+        self.key = key
 
-        cv2.imshow(WINDOW_INFO_NAME, info)
-
-    def handle_key(self):
+    def handle_key(self) -> None:
         """Handles key strokes."""
-        sleep_time = math.ceil(1000 / self.current_presentation.fps)
-        key = cv2.waitKeyEx(fix_time(sleep_time - self.lag))
+
+        key = self.key
 
         if self.config.QUIT.match(key):
-            self.quit()
+            self.run_flag = False
         elif self.state == State.PLAYING and self.config.PLAY_PAUSE.match(key):
             self.state = State.PAUSED
         elif self.state == State.PAUSED and self.config.PLAY_PAUSE.match(key):
@@ -407,7 +432,7 @@ class Display:
         elif self.config.BACK.match(key):
             if self.current_presentation.current_slide_index == 0:
                 if self.current_presentation_index == 0:
-                    self.current_presentation.rewind_current_slide()
+                    self.current_presentation.load_previous_slide()
                 else:
                     self.current_presentation_index -= 1
                     self.current_presentation.load_last_slide()
@@ -419,13 +444,169 @@ class Display:
             self.current_presentation.reverse_current_slide()
             self.state = State.PLAYING
         elif self.config.REWIND.match(key):
+            self.current_presentation.cancel_reverse()
             self.current_presentation.rewind_current_slide()
             self.state = State.PLAYING
 
-    def quit(self):
-        """Destroys all windows created by presentations and exits gracefully."""
-        cv2.destroyAllWindows()
-        self.exit = True
+        self.key = -1  # No more key to be handled
+
+    def stop(self):
+        """Stops current thread, without doing anything after."""
+        self.run_flag = False
+        self.wait()
+
+
+class Info(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle(WINDOW_INFO_NAME)
+
+        self.layout = QGridLayout()
+
+        self.setLayout(self.layout)
+
+        self.animationLabel = QLabel()
+        self.stateLabel = QLabel()
+        self.slideLabel = QLabel()
+        self.typeLabel = QLabel()
+        self.sceneLabel = QLabel()
+
+        self.layout.addWidget(self.animationLabel, 0, 0, 1, 2)
+        self.layout.addWidget(self.stateLabel, 1, 0)
+        self.layout.addWidget(self.slideLabel, 1, 1)
+        self.layout.addWidget(self.typeLabel, 2, 0)
+        self.layout.addWidget(self.sceneLabel, 2, 1)
+
+        self.update_info({})
+
+    @pyqtSlot(dict)
+    def update_info(self, info: dict):
+        self.animationLabel.setText("Animation: {}".format(info.get("animation", "na")))
+        self.stateLabel.setText("State: {}".format(info.get("state", "unknown")))
+        self.slideLabel.setText(
+            "Slide: {}/{}".format(
+                info.get("slide_index", "na"), info.get("n_slides", "na")
+            )
+        )
+        self.typeLabel.setText("Slide Type: {}".format(info.get("type", "unknown")))
+        self.sceneLabel.setText(
+            "Scene: {}/{}".format(
+                info.get("scene_index", "na"), info.get("n_scenes", "na")
+            )
+        )
+
+
+class InfoThread(QThread):
+    def __init__(self):
+        super().__init__()
+        self.dialog = Info()
+        self.run_flag = True
+
+    def start(self):
+        super().start()
+
+        self.dialog.show()
+
+    def stop(self):
+        self.dialog.deleteLater()
+
+
+class App(QWidget):
+    send_key_signal = pyqtSignal(int)
+
+    def __init__(
+        self,
+        *args,
+        fullscreen: bool = False,
+        resolution: Tuple[int, int] = (1980, 1080),
+        hide_mouse: bool = False,
+        aspect_ratio: Qt.AspectRatioMode = Qt.IgnoreAspectRatio,
+        **kwargs,
+    ):
+        super().__init__()
+
+        self.setWindowTitle(WINDOW_NAME)
+        self.display_width, self.display_height = resolution
+        self.aspect_ratio = aspect_ratio
+
+        if hide_mouse:
+            self.setCursor(Qt.BlankCursor)
+
+        self.label = QLabel(self)
+        self.label.setAlignment(Qt.AlignCenter)
+        self.label.resize(self.display_width, self.display_height)
+
+        self.pixmap = QPixmap(self.width(), self.height())
+        self.label.setPixmap(self.pixmap)
+        self.label.setMinimumSize(1, 1)
+
+        # create the video capture thread
+        self.thread = Display(*args, **kwargs)
+        # create the info dialog
+        self.info = Info()
+        self.info.show()
+
+        # info widget will also listen to key presses
+        self.info.keyPressEvent = self.keyPressEvent
+
+        if fullscreen:
+            self.showFullScreen()
+
+        # connect signals
+        self.thread.change_video_signal.connect(self.update_image)
+        self.thread.change_info_signal.connect(self.info.update_info)
+        self.thread.finished.connect(self.closeAll)
+        self.send_key_signal.connect(self.thread.set_key)
+
+        # start the thread
+        self.thread.start()
+
+    def keyPressEvent(self, event):
+        key = event.key()
+        # We send key to be handled by video display
+        self.send_key_signal.emit(key)
+        event.accept()
+
+    def closeAll(self):
+        logger.debug("Closing all QT windows")
+        self.thread.stop()
+        self.info.deleteLater()
+        self.deleteLater()
+
+    def resizeEvent(self, event):
+        self.pixmap = self.pixmap.scaled(self.width(), self.height(), self.aspect_ratio)
+        self.label.setPixmap(self.pixmap)
+        self.label.resize(self.width(), self.height())
+
+    def closeEvent(self, event):
+        self.closeAll()
+        event.accept()
+
+    @pyqtSlot(np.ndarray)
+    def update_image(self, cv_img: dict):
+        """Updates the image_label with a new opencv image"""
+        self.pixmap = self.convert_cv_qt(cv_img)
+        self.label.setPixmap(self.pixmap)
+
+    @pyqtSlot(dict)
+    def update_info(self, info: dict):
+        """Updates the image_label with a new opencv image"""
+        pass
+
+    def convert_cv_qt(self, cv_img):
+        """Convert from an opencv image to QPixmap"""
+        rgb_image = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
+        h, w, ch = rgb_image.shape
+        bytes_per_line = ch * w
+        convert_to_Qt_format = QtGui.QImage(
+            rgb_image.data, w, h, bytes_per_line, QtGui.QImage.Format_RGB888
+        )
+        p = convert_to_Qt_format.scaled(
+            self.width(),
+            self.height(),
+            self.aspect_ratio,
+        )
+        return QPixmap.fromImage(p)
 
 
 @click.command()
@@ -434,9 +615,11 @@ class Display:
     default=FOLDER_PATH,
     type=click.Path(exists=True, file_okay=False),
     help="Set slides folder.",
+    show_default=True,
 )
 @click.help_option("-h", "--help")
-def list_scenes(folder):
+@verbosity_option
+def list_scenes(folder) -> None:
     """List available scenes."""
 
     for i, scene in enumerate(_list_scenes(folder), start=1):
@@ -449,13 +632,18 @@ def _list_scenes(folder) -> List[str]:
 
     for file in os.listdir(folder):
         if file.endswith(".json"):
+            filepath = os.path.join(folder, file)
             try:
-                filepath = os.path.join(folder, file)
                 _ = PresentationConfig.parse_file(filepath)
                 scenes.append(os.path.basename(file)[:-5])
             except Exception as e:  # Could not parse this file as a proper presentation config
+                logger.warn(
+                    f"Something went wrong with parsing presentation config `{filepath}`: {e}"
+                )
                 pass
 
+    logger.debug(f"Found {len(scenes)} valid scene configuration files in `{folder}`.")
+
     return scenes
 
 
@@ -467,31 +655,51 @@ def _list_scenes(folder) -> List[str]:
     default=FOLDER_PATH,
     type=click.Path(exists=True, file_okay=False),
     help="Set slides folder.",
+    show_default=True,
 )
 @click.option("--start-paused", is_flag=True, help="Start paused.")
 @click.option("--fullscreen", is_flag=True, help="Fullscreen mode.")
 @click.option(
+    "-s",
     "--skip-all",
     is_flag=True,
-    help="Skip all slides, useful the test if slides are working.",
+    help="Skip all slides, useful the test if slides are working. Automatically sets `--skip-after-last-slide` to True.",
 )
 @click.option(
     "-r",
     "--resolution",
     type=(int, int),
     default=(1920, 1080),
-    help="Window resolution used if fullscreen is not set. You may manually resize the window afterward.",
+    help="Window resolution WIDTH HEIGHT used if fullscreen is not set. You may manually resize the window afterward.",
     show_default=True,
 )
 @click.option(
-    "-i",
-    "--interpolation-flag",
-    type=click.Choice(INTERPOLATION_FLAGS.keys(), case_sensitive=False),
-    default="linear",
-    help="Set the interpolation flag to be used when resizing image. See OpenCV cv::InterpolationFlags.",
+    "--to",
+    "--record-to",
+    "record_to",
+    type=click.Path(dir_okay=False),
+    default=None,
+    help="If set, the presentation will be recorded into a AVI video file with given name.",
+)
+@click.option(
+    "--exit-after-last-slide",
+    is_flag=True,
+    help="At the end of last slide, the application will be exited.",
+)
+@click.option(
+    "--hide-mouse",
+    is_flag=True,
+    help="Hide mouse cursor.",
+)
+@click.option(
+    "--aspect-ratio",
+    type=click.Choice(ASPECT_RATIO_MODES.keys(), case_sensitive=False),
+    default="ignore",
+    help="Set the aspect ratio mode to be used when rescaling video.",
     show_default=True,
 )
 @click.help_option("-h", "--help")
+@verbosity_option
 def present(
     scenes,
     config_path,
@@ -500,9 +708,23 @@ def present(
     fullscreen,
     skip_all,
     resolution,
-    interpolation_flag,
-):
-    """Present the different scenes."""
+    record_to,
+    exit_after_last_slide,
+    hide_mouse,
+    aspect_ratio,
+) -> None:
+    """
+    Present SCENE(s), one at a time, in order.
+
+    Each SCENE parameter must be the name of a Manim scene, with existing SCENE.json config file.
+
+    You can present the same SCENE multiple times by repeating the parameter.
+
+    Use `manim-slide list-scenes` to list all available scenes in a given folder.
+    """
+
+    if skip_all:
+        exit_after_last_slide = True
 
     if len(scenes) == 0:
         scene_choices = _list_scenes(folder)
@@ -517,10 +739,10 @@ def present(
         click.echo("Choose number corresponding to desired scene/arguments.")
         click.echo("(Use comma separated list for multiple entries)")
 
-        def value_proc(value: str):
+        def value_proc(value: str) -> List[str]:
             indices = list(map(int, value.strip().replace(" ", "").split(",")))
 
-            if not all(map(lambda i: 0 < i <= len(scene_choices), indices)):
+            if not all(0 < i <= len(scene_choices) for i in indices):
                 raise click.UsageError(
                     "Please only enter numbers displayed on the screen."
                 )
@@ -539,7 +761,7 @@ def present(
             except ValueError as e:
                 raise click.UsageError(e)
 
-    presentations = list()
+    presentations = []
     for scene in scenes:
         config_file = os.path.join(folder, f"{scene}.json")
         if not os.path.exists(config_file):
@@ -547,8 +769,8 @@ def present(
                 f"File {config_file} does not exist, check the scene name and make sure to use Slide as your scene base class"
             )
         try:
-            config = PresentationConfig.parse_file(config_file)
-            presentations.append(Presentation(config))
+            pres_config = PresentationConfig.parse_file(config_file)
+            presentations.append(Presentation(pres_config))
         except ValidationError as e:
             raise click.UsageError(str(e))
 
@@ -558,15 +780,29 @@ def present(
         except ValidationError as e:
             raise click.UsageError(str(e))
     else:
+        logger.debug("No configuration file found, using default configuration.")
         config = Config()
 
-    display = Display(
+    if record_to is not None:
+        _, ext = os.path.splitext(record_to)
+        if ext.lower() != ".avi":
+            raise click.UsageError(
+                "Recording only support '.avi' extension. For other video formats, please convert the resulting '.avi' file afterwards."
+            )
+
+    app = QApplication(sys.argv)
+    a = App(
         presentations,
         config=config,
         start_paused=start_paused,
         fullscreen=fullscreen,
         skip_all=skip_all,
         resolution=resolution,
-        interpolation_flag=INTERPOLATION_FLAGS[interpolation_flag],
+        record_to=record_to,
+        exit_after_last_slide=exit_after_last_slide,
+        hide_mouse=hide_mouse,
+        aspect_ratio=ASPECT_RATIO_MODES[aspect_ratio],
     )
-    display.run()
+    a.show()
+    sys.exit(app.exec_())
+    logger.debug("After")

manim_slides/slide.py

@@ -1,9 +1,8 @@
-import json
 import os
 import platform
 import shutil
 import subprocess
-from typing import List
+from typing import Any, List, Optional
 
 from tqdm import tqdm
 
@@ -12,7 +11,7 @@ from .defaults import FOLDER_PATH
 from .manim import FFMPEG_BIN, MANIMGL, Scene, ThreeDScene, config, logger
 
 
-def reverse_video_file(src: str, dst: str):
+def reverse_video_file(src: str, dst: str) -> None:
     """Reverses a video file, writting the result to `dst`."""
     command = [FFMPEG_BIN, "-i", src, "-vf", "reverse", dst]
     process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -24,7 +23,9 @@ class Slide(Scene):
     Inherits from `manim.Scene` or `manimlib.Scene` and provide necessary tools for slides rendering.
     """
 
-    def __init__(self, *args, output_folder=FOLDER_PATH, **kwargs):
+    def __init__(
+        self, *args: Any, output_folder: str = FOLDER_PATH, **kwargs: Any
+    ) -> None:
         if MANIMGL:
             if not os.path.isdir("videos"):
                 os.mkdir("videos")
@@ -39,10 +40,10 @@ class Slide(Scene):
         super().__init__(*args, **kwargs)
 
         self.output_folder = output_folder
-        self.slides = list()
+        self.slides: List[SlideConfig] = []
         self.current_slide = 1
         self.current_animation = 0
-        self.loop_start_animation = None
+        self.loop_start_animation: Optional[int] = None
         self.pause_start_animation = 0
 
     @property
@@ -70,19 +71,19 @@ class Slide(Scene):
             return config["progress_bar"] != "none"
 
     @property
-    def leave_progress_bar(self):
+    def leave_progress_bar(self) -> bool:
         """Returns True if progress bar should be left after completed."""
         if MANIMGL:
             return getattr(super(Scene, self), "leave_progress_bars", False)
         else:
             return config["progress_bar"] == "leave"
 
-    def play(self, *args, **kwargs):
+    def play(self, *args: Any, **kwargs: Any) -> None:
         """Overloads `self.play` and increment animation count."""
         super().play(*args, **kwargs)
         self.current_animation += 1
 
-    def pause(self):
+    def pause(self) -> None:
         """Creates a new slide with previous animations."""
         self.slides.append(
             SlideConfig(
@@ -95,12 +96,12 @@ class Slide(Scene):
         self.current_slide += 1
         self.pause_start_animation = self.current_animation
 
-    def start_loop(self):
+    def start_loop(self) -> None:
         """Starts a loop."""
         assert self.loop_start_animation is None, "You cannot nest loops"
         self.loop_start_animation = self.current_animation
 
-    def end_loop(self):
+    def end_loop(self) -> None:
         """Ends an existing loop."""
         assert (
             self.loop_start_animation is not None
@@ -117,7 +118,7 @@ class Slide(Scene):
         self.loop_start_animation = None
         self.pause_start_animation = self.current_animation
 
-    def save_slides(self, use_cache=True):
+    def save_slides(self, use_cache: bool = True) -> None:
         """
         Saves slides, optionally using cached files.
 
@@ -143,7 +144,7 @@ class Slide(Scene):
         else:
             old_animation_files.update(os.listdir(scene_files_folder))
 
-        files = list()
+        files = []
         for src_file in tqdm(
             self.partial_movie_files,
             desc=f"Copying animation files to '{scene_files_folder}' and generating reversed animations",
@@ -183,12 +184,12 @@ class Slide(Scene):
             f"Slide '{scene_name}' configuration written in '{os.path.abspath(slide_path)}'"
         )
 
-    def run(self, *args, **kwargs):
+    def run(self, *args: Any, **kwargs: Any) -> None:
         """MANIMGL renderer"""
         super().run(*args, **kwargs)
         self.save_slides(use_cache=False)
 
-    def render(self, *args, **kwargs):
+    def render(self, *args: Any, **kwargs: Any) -> None:
         """MANIM render"""
         # We need to disable the caching limit since we rely on intermidiate files
         max_files_cached = config["max_files_cached"]

manim_slides/wizard.py

@@ -1,43 +1,133 @@
 import os
 import sys
+from functools import partial
+from typing import Any
 
 import click
-import cv2
-import numpy as np
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import (
+    QApplication,
+    QDialog,
+    QDialogButtonBox,
+    QGridLayout,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
 
-from .commons import config_options
-from .config import Config
-from .defaults import CONFIG_PATH, FONT_ARGS
+from .commons import config_options, verbosity_option
+from .config import Config, Key
+from .defaults import CONFIG_PATH
+from .manim import logger
 
-WINDOW_NAME = "Manim Slides Configuration Wizard"
-WINDOW_SIZE = (120, 620)
+WINDOW_NAME: str = "Configuration Wizard"
+
+keymap = {}
+for key, value in vars(Qt).items():
+    if isinstance(value, Qt.Key):
+        keymap[value] = key.partition("_")[2]
 
 
-def center_text_horizontally(text, window_size, font_args) -> int:
-    """Returns centered position for text to be displayed in current window."""
-    _, width = window_size
-    font, scale, _, thickness, _ = font_args
-    (size_in_pixels, _), _ = cv2.getTextSize(text, font, scale, thickness)
-    return (width - size_in_pixels) // 2
+class KeyInput(QDialog):
+    def __init__(self) -> None:
+        super().__init__()
+        self.key = None
+
+        self.layout = QVBoxLayout()
+
+        self.setWindowTitle("Keyboard Input")
+        self.label = QLabel("Press any key to register it")
+        self.layout.addWidget(self.label)
+        self.setLayout(self.layout)
+
+    def keyPressEvent(self, event: Any) -> None:
+        self.key = event.key()
+        self.deleteLater()
+        event.accept()
 
 
-def prompt(question: str) -> int:
-    """Diplays some question in current window and waits for key press."""
-    display = np.zeros(WINDOW_SIZE, np.uint8)
+class Wizard(QWidget):
+    def __init__(self, config: Config):
 
-    text = "* Manim Slides Wizard *"
-    text_org = center_text_horizontally(text, WINDOW_SIZE, FONT_ARGS), 33
-    question_org = center_text_horizontally(question, WINDOW_SIZE, FONT_ARGS), 85
+        super().__init__()
 
-    cv2.putText(display, "* Manim Slides Wizard *", text_org, *FONT_ARGS)
-    cv2.putText(display, question, question_org, *FONT_ARGS)
+        self.setWindowTitle(WINDOW_NAME)
+        self.config = config
 
-    cv2.imshow(WINDOW_NAME, display)
-    return cv2.waitKeyEx(-1)
+        QBtn = QDialogButtonBox.Save | QDialogButtonBox.Cancel
+
+        self.buttonBox = QDialogButtonBox(QBtn)
+        self.buttonBox.accepted.connect(self.saveConfig)
+        self.buttonBox.rejected.connect(self.closeWithoutSaving)
+
+        self.buttons = []
+
+        self.layout = QGridLayout()
+
+        for i, (key, value) in enumerate(self.config.dict().items()):
+            # Create label for key name information
+            label = QLabel()
+            key_info = value["name"] or key
+            label.setText(key_info)
+            self.layout.addWidget(label, i, 0)
+
+            # Create button that will pop-up a dialog and ask to input a new key
+            value = value["ids"].pop()
+            button = QPushButton(keymap[value])
+            button.setToolTip(
+                f"Click to modify the key associated to action {key_info}"
+            )
+            self.buttons.append(button)
+            button.clicked.connect(
+                partial(self.openDialog, i, getattr(self.config, key))
+            )
+            self.layout.addWidget(button, i, 1)
+
+        self.layout.addWidget(self.buttonBox, len(self.buttons), 1)
+
+        self.setLayout(self.layout)
+
+    def closeWithoutSaving(self) -> None:
+        logger.debug("Closing configuration wizard without saving")
+        self.deleteLater()
+        sys.exit(0)
+
+    def closeEvent(self, event: Any) -> None:
+        self.closeWithoutSaving()
+        event.accept()
+
+    def saveConfig(self) -> None:
+        try:
+            Config.parse_obj(self.config.dict())
+        except ValueError:
+            msg = QMessageBox()
+            msg.setIcon(QMessageBox.Critical)
+            msg.setText("Error")
+            msg.setInformativeText(
+                "Two or more actions share a common key: make sure actions have distinct key codes."
+            )
+            msg.setWindowTitle("Error: duplicated keys")
+            msg.exec_()
+            return
+
+        self.deleteLater()
+
+    def openDialog(self, button_number: int, key: Key) -> None:
+        button = self.buttons[button_number]
+        dialog = KeyInput()
+        dialog.exec_()
+        if dialog.key is not None:
+            key_name = keymap[dialog.key]
+            key.set_ids(dialog.key)
+            button.setText(key_name)
 
 
 @click.command()
 @config_options
+@click.help_option("-h", "--help")
+@verbosity_option
 def wizard(config_path, force, merge):
     """Launch configuration wizard."""
     return _init(config_path, force, merge, skip_interactive=False)
@@ -45,6 +135,8 @@ def wizard(config_path, force, merge):
 
 @click.command()
 @config_options
+@click.help_option("-h", "--help")
+@verbosity_option
 def init(config_path, force, merge, skip_interactive=False):
     """Initialize a new default configuration file."""
     return _init(config_path, force, merge, skip_interactive=True)
@@ -65,27 +157,27 @@ def _init(config_path, force, merge, skip_interactive=False):
             force = choice == "o"
             merge = choice == "m"
 
-        if force:
-            click.secho("Overwriting.")
-        elif merge:
-            click.secho("Merging.")
-        else:
-            click.secho("Exiting.")
+        if not force and not merge:
+            logger.debug("Exiting without doing anything")
             sys.exit(0)
 
     config = Config()
 
+    if force:
+        logger.debug(f"Overwriting `{config_path}` if exists")
+    elif merge:
+        logger.debug("Merging new config into `{config_path}`")
+
     if not skip_interactive:
+        if os.path.exists(config_path):
+            config = Config.parse_file(config_path)
 
-        cv2.namedWindow(
-            WINDOW_NAME,
-            cv2.WINDOW_GUI_NORMAL | cv2.WINDOW_FREERATIO | cv2.WINDOW_AUTOSIZE,
-        )
+        app = QApplication(sys.argv)
+        window = Wizard(config)
+        window.show()
+        app.exec()
 
-        prompt("Press any key to continue")
-
-        for _, key in config:
-            key.ids = [prompt(f"Press the {key.name} key")]
+        config = window.config
 
     if merge:
         config = Config.parse_file(config_path).merge_with(config)
@@ -93,4 +185,4 @@ def _init(config_path, force, merge, skip_interactive=False):
     with open(config_path, "w") as config_file:
         config_file.write(config.json(indent=2))
 
-    click.echo(f"Configuration file successfully save to `{config_path}`")
+    click.secho(f"Configuration file successfully saved to `{config_path}`")

setup.py

@@ -1,3 +1,4 @@
+# type: ignore
 import importlib.util
 import os
 import sys
@@ -38,6 +39,7 @@ setuptools.setup(
         "click-default-group>=1.2",
         "numpy>=1.19.3",
         "pydantic>=1.9.1",
+        "pyqt5>=5.15",
         "opencv-python>=4.6",
         "tqdm>=4.62.3",
     ],

static/logo.py

@@ -1,3 +1,5 @@
+# flake8: noqa: F403, F405
+# type: ignore
 from manim import *