📌 Présentation

Ce projet est une application graphique développée en Python avec PySide6.
Elle permet de charger une vidéo, d’y ajouter des effets visuels temporisés, de les positionner sur une frise chronologique (timeline) multi-pistes, puis de sauvegarder/charger des projets au format JSON.

Une fonctionnalité de chargement de modèles (templates) est également intégrée pour réutiliser rapidement des descriptions d’effets stockées dans des fichiers texte.

⚙️ Dépendances

Installer les bibliothèques nécessaires avant d’exécuter le script :

pip install PySide6

Le script utilise les modules standards de Python :

sys, json, os

Et les modules PySide6 :

QtCore : gestion des signaux/slots, géométrie, constantes
QtGui : gestion des événements souris, dessin (QPainter)
QtWidgets : interface graphique (QMainWindow, QWidget, QPushButton, etc.)
QtMultimedia : lecture audio/vidéo (QMediaPlayer)
QtMultimediaWidgets : rendu vidéo (QVideoWidget)

📂 Organisation du Code

1. Constantes

MODEL_DIR = "modeles" : répertoire contenant les modèles d’effets (fichiers .txt).

2. Classe `Effect`

Représente un effet placé sur la timeline.
Attributs principaux :

uid : identifiant unique
name : nom de l’effet
description : texte descriptif (peut être chargé depuis un modèle)
start_time, end_time : début et fin en millisecondes
track : piste (ligne de la timeline)
rect : rectangle affiché sur la timeline
États d’interaction : is_resizing_left, is_resizing_right, is_moving

3. Classe `EffectDialog`

Fenêtre modale pour ajouter ou modifier un effet.
Composants :

QLineEdit pour le nom
QTextEdit pour la description
Bouton Charger Modèle : ouvre un QFileDialog dans MODEL_DIR
Boutons OK/Annuler

Méthodes :

load_template_file() : insère le contenu d’un modèle texte dans la description
get_data() : retourne (name, description)

4. Classe `TimelineWidget`

Widget personnalisé représentant la frise chronologique.

Fonctionnalités :

Affichage des pistes (par défaut 3)
Placement et dessin des effets colorés
Affichage de la tête de lecture (playhead)
Ajout/suppression de pistes
Conversion temps ↔︎ position en pixels
Gestion des événements souris :
- Sélection d’un effet
- Déplacement horizontal (temps) et vertical (piste)
- Redimensionnement gauche/droite
- Double-clic → ouverture de l’éditeur d’effet

Signaux émis :

position_seek_requested(int) : repositionner la lecture
effect_double_clicked(object) : édition d’un effet
effect_selected(object) : sélection dans l’UI

5. Classe `MainWindow`

Fenêtre principale de l’application.

Composants :

QMediaPlayer + QVideoWidget pour afficher la vidéo
TimelineWidget dans un QScrollArea (scroll horizontal/vertical)
Boutons pour ajouter/supprimer des pistes
Contrôles multimédia : lecture/pause, restart, label de temps
Menu :
- Fichier : Charger vidéo, Enregistrer projet, Ouvrir projet, Quitter
- Édition : Ajouter un effet, Supprimer l’effet sélectionné

Méthodes principales :

_ensure_model_dir_exists() : crée modeles/ si absent
load_video() : ouvre une vidéo (MP4, MOV, AVI)
save_project() : sauvegarde en JSON (.videff)
load_project() : recharge un projet JSON avec effets
add_effect() : ajoute un effet à l’instant courant
edit_effect(effect) : modifie un effet existant
delete_effect() : supprime l’effet sélectionné
play_pause(), restart_video() : contrôle de lecture
update_play_button_icon(state), update_time_label(position) : mise à jour UI

📝 Format du projet JSON

Un fichier projet contient :

{
    "video_path": "chemin/vers/video.mp4",
    "effects": [
        {
            "name": "Titre",
            "description": "Description de l'effet",
            "start_time": 1000,
            "end_time": 2000,
            "track": 0
        }
    ]
}

▶️ Exécution

Lancer l’application :

python main.py

🚀 Fonctionnalités Clés

Lecture et visualisation de vidéo
Ajout de plusieurs effets visuels synchronisés avec la vidéo
Organisation des effets sur plusieurs pistes
Redimensionnement et déplacement interactif à la souris
Sauvegarde/chargement de projets
Insertion de modèles d’effets depuis des fichiers texte externes

📌 Limitations & Améliorations possibles

Pas d’export vidéo final (seulement un éditeur visuel)
Pas de gestion avancée des effets (uniquement texte et temps)
Améliorations envisageables :
- Ajout de raccourcis clavier
- Exportation des effets en overlay vidéo
- Personnalisation des couleurs d’effets
- Undo/Redo

Tutoriel pas à pas

Ce guide explique comment utiliser l’application pour créer, gérer et sauvegarder des effets vidéo.

1. 📂 Lancer l’application

Dans un terminal, exécuter :

python main.py

Une fenêtre s’ouvre avec deux zones principales :

En haut : la vidéo (QVideoWidget)
En bas : la frise chronologique (timeline) et les contrôles

2. 🎥 Charger une vidéo

Menu Fichier → Charger une Vidéo…
Sélectionner un fichier vidéo (formats supportés : .mp4, .mov, .avi)
La vidéo s’affiche dans la partie supérieure.

À ce stade, les options Ajouter un Effet deviennent actives.

3. ➕ Ajouter un effet

Lire la vidéo et mettre en pause au moment voulu (ou se déplacer sur la timeline).
Menu Édition → Ajouter un Effet.
Une fenêtre s’ouvre :
- Nom de l’effet : saisir un titre (ex. Texte d’intro)
- Description : écrire un texte ou cliquer sur Charger Modèle… pour importer un fichier depuis le dossier modeles/.
Valider avec OK.

L’effet apparaît sur la timeline, sous forme de bloc coloré.
Il occupe par défaut 1 seconde ou jusqu’à la fin de la vidéo.

4. ✏️ Modifier un effet

Double-clic sur un bloc d’effet → fenêtre d’édition.
Modifier le nom et la description.
Valider avec OK.

5. 🎚️ Manipuler les effets

Sélectionner un effet : cliquer dessus.
Déplacer : cliquer-glisser le bloc pour le changer de moment ou de piste.
Redimensionner : déplacer le curseur proche du bord gauche/droit puis cliquer-glisser.
Supprimer : Menu Édition → Supprimer l’Effet Sélectionné.

6. 🎼 Gérer les pistes

Ajouter une piste : bouton + à gauche de la timeline.
Supprimer une piste : bouton - (possible uniquement si la piste est vide).

7. 💾 Sauvegarder et recharger un projet

Sauvegarde

Menu Fichier → Enregistrer le Projet
Donner un nom au fichier (ex. projet.json).

Le fichier JSON contient :

Chemin de la vidéo
Liste des effets avec leur nom, description, temps et piste

Chargement

Menu Fichier → Ouvrir un Projet…
Sélectionner un fichier .json.
La vidéo et les effets sont rechargés.

8. ▶️ Contrôles de lecture

Lecture/Pause : bouton à gauche (ou raccourci depuis la timeline).
Revenir au début : bouton skip backward.
Avancer/Reculer manuellement : cliquer dans l’entête de la timeline.

Un label indique la position courante et la durée totale au format mm:ss.mmm.

9. 📑 Exemple concret

Étapes :

Charger une vidéo demo.mp4.
Ajouter un effet Titre à 00:05s.
Charger un modèle intro.txt depuis le dossier modeles/.
Déplacer l’effet sur la piste 2.
Ajouter un second effet Fin à 01:10s.
Sauvegarder le projet sous demo.json.

Résultat dans `demo.json` :

{
    "video_path": "demo.mp4",
    "effects": [
        {
            "name": "Titre",
            "description": "Texte du modèle intro...",
            "start_time": 5000,
            "end_time": 6000,
            "track": 1
        },
        {
            "name": "Fin",
            "description": "",
            "start_time": 70000,
            "end_time": 71000,
            "track": 0
        }
    ]
}

✅ Résumé

Avec cet outil, vous pouvez :

Charger une vidéo
Ajouter et organiser des effets sur plusieurs pistes
Modifier et supprimer les effets
Sauvegarder/recharger vos projets
Réutiliser des descriptions via des modèles

Cela en fait un éditeur léger pour synchroniser des annotations ou des effets avec une vidéo.

Exemples de modèles pour le dossier `modeles`

Ces fichiers peuvent être placés dans le dossier modeles de ton projet.
Ils sont ensuite réutilisables lors de l’ajout d’un effet via le bouton Charger Modèle….

1. `intro.txt`

=== INTRODUCTION ===
Titre : Présentation
Texte  : Bienvenue dans cette vidéo.
Durée  : 5 secondes
Effet  : Fondu en ouverture
----------------------

2. `transition.txt`

=== TRANSITION ===
Texte  : Passage à la section suivante.
Effet  : Glissement gauche → droite
Durée  : 3 secondes
----------------------

3. `highlight.txt`

=== HIGHLIGHT ===
Texte  : ATTENTION - point important !
Effet  : Clignotement rapide
Couleur: Jaune
Durée  : 4 secondes
----------------------

4. `fin.txt`

=== FIN ===
Texte  : Merci d’avoir regardé !
Effet  : Fondu en fermeture
Durée  : 6 secondes
----------------------

5. `credits.txt`

=== CRÉDITS ===
Titre : Remerciements
Texte  : Montage réalisé avec l'Éditeur d'Effets Vidéo Simplifié
Effet  : Défilement vers le haut
Durée  : 10 secondes
----------------------

📂 Organisation recommandée

/projet-video/
   ├── main.py
   ├── projet.json
   └── modeles/
        ├── intro.txt
        ├── transition.txt
        ├── highlight.txt
        ├── fin.txt
        └── credits.txt

✅ Utilisation

Lors de l’ajout d’un effet :

Cliquer sur Charger Modèle…
Sélectionner un fichier dans modeles
Le contenu est inséré automatiquement dans la description de l’effet.

Source

Python

# main.py (corrigé et amélioré avec chargement de modèle)
# Éditeur d'Effets Vidéo Simplifié
# Dépendance : pip install PySide6

import sys
import json
import os
from PySide6.QtCore import (Qt, QUrl, QPoint, QRect, QSize, Signal, Slot)
from PySide6.QtGui import (QPainter, QColor, QPen, QFont, QAction, QMouseEvent, QBrush)
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QPushButton, QFileDialog, QStyle, QLabel, QDialog, QLineEdit,
    QTextEdit, QDialogButtonBox, QScrollArea, QFrame, QSplitter
)
from PySide6.QtMultimedia import QMediaPlayer, QMediaFormat
from PySide6.QtMultimediaWidgets import QVideoWidget

# Définition du répertoire de modèles
MODEL_DIR = "modeles"

# — Classe pour stocker les données d'un effet —
class Effect:
    """Représente un effet avec ses propriétés et sa position sur l'UI."""
    def __init__(self, name, description, start_time, end_time, track=0, uid=None):
        self.uid = uid if uid is not None else id(self)
        self.name = name
        self.description = description
        self.start_time = start_time
        self.end_time = end_time
        self.track = track
        self.rect = QRect()  # Rectangle pour le dessin et la détection de clics
        # États pour l'interaction
        self.is_resizing_left = False
        self.is_resizing_right = False
        self.is_moving = False

# — Fenêtre modale pour éditer les informations d'un effet —
class EffectDialog(QDialog):
    """Dialogue pour créer ou modifier un effet."""
    def __init__(self, effect=None, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Éditer l'Effet")
        
        self.layout = QVBoxLayout(self)
        
        # Champ Nom
        self.name_label = QLabel("Nom de l'effet:")
        self.name_input = QLineEdit()
        self.layout.addWidget(self.name_label)
        self.layout.addWidget(self.name_input)
        
        # Champ Description
        self.desc_label = QLabel("Description:")
        self.desc_input = QTextEdit()
        self.layout.addWidget(self.desc_label)
        self.layout.addWidget(self.desc_input)

        # Bouton pour charger le modèle
        self.load_template_button = QPushButton("Charger Modèle…")
        self.load_template_button.clicked.connect(self.load_template_file)
        self.layout.addWidget(self.load_template_button)
        
        # Boutons OK/Annuler
        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        self.button_box.accepted.connect(self.accept)
        self.button_box.rejected.connect(self.reject)
        self.layout.addWidget(self.button_box)
        
        if effect:
            self.name_input.setText(effect.name)
            self.desc_input.setPlainText(effect.description)

    def load_template_file(self):
        """Ouvre un dialogue de fichier pour sélectionner un modèle et insère son contenu."""
        # Utiliser le répertoire MODEL_DIR comme point de départ
        initial_dir = os.path.abspath(MODEL_DIR)
        
        # S'assurer que le répertoire existe avant d'ouvrir la boîte de dialogue
        if not os.path.isdir(initial_dir):
             print(f"Avertissement: Le répertoire de modèles '{MODEL_DIR}' n'existe pas ou n'est pas accessible.")
             # Si le répertoire n'existe pas, on ouvre sur le répertoire courant.
             initial_dir = "" 
        
        path, _ = QFileDialog.getOpenFileName(
            self, 
            "Sélectionner un Fichier Modèle", 
            initial_dir, 
            "Fichiers Texte (*.txt);;Tous les Fichiers (*.*)"
        )
        
        if path:
            try:
                with open(path, 'r', encoding='utf-8') as f:
                    content = f.read()
                
                # Insérer le contenu dans le champ description, en l'ajoutant s'il n'est pas vide
                current_text = self.desc_input.toPlainText()
                if current_text:
                    self.desc_input.setPlainText(current_text + "\n\n#— MODÈLE CHARGÉ —\n" + content)
                else:
                    self.desc_input.setPlainText(content)
                    
            except Exception as e:
                print(f"Erreur lors de la lecture du fichier modèle : {e}")


    def get_data(self):
        return self.name_input.text(), self.desc_input.toPlainText()

# — Widget de la Frise Chronologique (Timeline) —
class TimelineWidget(QWidget):
    """Widget customisé pour afficher et interagir avec la timeline."""
    position_seek_requested = Signal(int)
    effect_double_clicked = Signal(object)
    effect_selected = Signal(object)

    HEADER_HEIGHT = 25
    TRACK_HEIGHT = 35
    DEFAULT_TRACKS = 3

    def __init__(self, parent=None):
        super().__init__(parent)
        self.setMouseTracking(True)
        
        self._duration = 0
        self._position = 0
        self.effects = []
        self.num_tracks = self.DEFAULT_TRACKS
        self.selected_effect = None
        self._dragging_effect = None
        self._drag_offset = QPoint()

        # self.update_height() # Déplacé dans MainWindow.__init__ après l'assignation du parent

    def update_height(self):
        """Met à jour la hauteur minimale du widget basé sur le nombre de pistes."""
        total_height = self.HEADER_HEIGHT + self.num_tracks * self.TRACK_HEIGHT
        self.setMinimumHeight(total_height)
        # S'assurer que le parent (QScrollArea) est notifié du changement de taille
        if self.parentWidget():
            self.parentWidget().updateGeometry()


    def set_duration(self, duration):
        self._duration = duration
        self.update()

    def set_position(self, position):
        self._position = position
        self.update()

    def load_effects(self, effects):
        self.effects = effects
        if self.effects:
            max_track = max(e.track for e in self.effects) if self.effects else -1
            self.num_tracks = max(self.DEFAULT_TRACKS, max_track + 1)
        else:
            self.num_tracks = self.DEFAULT_TRACKS
        self.update_height()
        self.update()

    def add_track(self):
        self.num_tracks += 1
        self.update_height()
        self.update()

    def remove_track(self):
        if self.num_tracks <= 1:
            return
        
        last_track_index = self.num_tracks – 1
        if any(e.track == last_track_index for e in self.effects):
            print("Impossible de supprimer une piste non vide.")
            return

        self.num_tracks -= 1
        self.update_height()
        self.update()
        
    def time_to_x(self, time):
        if self._duration == 0:
            return 0
        return int((time / self._duration) * self.width())

    def x_to_time(self, x):
        if self.width() == 0:
            return 0
        time = int((x / self.width()) * self._duration)
        return max(0, time)

    def y_to_track(self, y):
        track = (y – self.HEADER_HEIGHT) // self.TRACK_HEIGHT
        return max(0, min(track, self.num_tracks – 1))

    def find_first_available_track(self, start_time, end_time):
        for track_idx in range(self.num_tracks):
            is_occupied = False
            for effect in self.effects:
                if effect.track == track_idx:
                    # Vérifie si les intervalles se chevauchent
                    if not (end_time <= effect.start_time or start_time >= effect.end_time):
                        is_occupied = True
                        break
            if not is_occupied:
                return track_idx
        # Si aucune piste disponible, ajoute une nouvelle piste
        self.add_track()
        return self.num_tracks – 1

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        
        painter.fillRect(self.rect(), QColor("#333"))

        # Dessin des pistes
        for i in range(self.num_tracks):
            y = self.HEADER_HEIGHT + i * self.TRACK_HEIGHT
            rect = QRect(0, y, self.width(), self.TRACK_HEIGHT)
            color = QColor("#444") if i % 2 == 0 else QColor("#404040")
            painter.fillRect(rect, color)
        
        if self._duration > 0:
            # Dessin de la grille et des marqueurs de temps
            pen = QPen(QColor("#888"), 1)
            painter.setPen(pen)
            font = QFont()
            font.setPointSize(8)
            painter.setFont(font)
            
            # Affichage des marqueurs toutes les 1 seconde (1000ms)
            interval_ms = 1000
            num_ticks = self._duration // interval_ms
            for i in range(num_ticks + 1):
                time_ms = i * interval_ms
                x = self.time_to_x(time_ms)
                painter.drawLine(x, self.HEADER_HEIGHT – 5, x, self.height())
                painter.drawText(x + 2, 15, f"{i}s")

            # Dessin des effets
            for effect in self.effects:
                x_start = self.time_to_x(effect.start_time)
                x_end = self.time_to_x(effect.end_time)
                y = self.HEADER_HEIGHT + effect.track * self.TRACK_HEIGHT + 2
                effect.rect = QRect(x_start, y, x_end – x_start, self.TRACK_HEIGHT – 4)
                
                # Couleur selon la sélection
                color = QColor("#3498db") if effect != self.selected_effect else QColor("#f1c40f")
                painter.fillRect(effect.rect, color)
                
                painter.setPen(Qt.white)
                painter.drawText(effect.rect, Qt.AlignCenter, effect.name)

        # Dessin de la tête de lecture (Playhead)
        playhead_x = self.time_to_x(self._position)
        painter.setPen(QPen(QColor("#e74c3c"), 2))
        painter.drawLine(playhead_x, 0, playhead_x, self.height())

    def get_effect_at(self, pos):
        """Retourne l'effet à la position donnée, en commençant par le dernier dessiné."""
        for effect in reversed(self.effects):
            if effect.rect.contains(pos):
                return effect
        return None

    def mousePressEvent(self, event: QMouseEvent):
        if event.button() != Qt.LeftButton:
            return

        effect = self.get_effect_at(event.pos())
        self.selected_effect = effect
        self.effect_selected.emit(effect)

        if effect:
            cursor_pos = event.pos().x()
            # Détection du redimensionnement gauche
            if abs(cursor_pos – effect.rect.left()) < 8:
                effect.is_resizing_left = True
                self._dragging_effect = effect
            # Détection du redimensionnement droit
            elif abs(cursor_pos – effect.rect.right()) < 8:
                effect.is_resizing_right = True
                self._dragging_effect = effect
            # Détection du déplacement
            else:
                effect.is_moving = True
                self._dragging_effect = effect
                self._drag_offset = event.pos() – effect.rect.topLeft()
        else:
            # Cliquer dans l'en-tête de la timeline pour se positionner
            if event.pos().y() < self.HEADER_HEIGHT:
                self.position_seek_requested.emit(self.x_to_time(event.pos().x()))
        self.update()

    def mouseMoveEvent(self, event: QMouseEvent):
        if not self._dragging_effect:
            # Gestion du curseur pour le redimensionnement
            effect = self.get_effect_at(event.pos())
            if effect:
                cursor_pos = event.pos().x()
                if abs(cursor_pos – effect.rect.left()) < 8 or abs(cursor_pos – effect.rect.right()) < 8:
                    self.setCursor(Qt.SizeHorCursor)
                else:
                    self.setCursor(Qt.ArrowCursor)
            else:
                self.setCursor(Qt.ArrowCursor)
            return

        e = self._dragging_effect
        if e.is_resizing_left:
            new_start_time = self.x_to_time(event.pos().x())
            if new_start_time < e.end_time:
                e.start_time = new_start_time
        elif e.is_resizing_right:
            new_end_time = self.x_to_time(event.pos().x())
            if new_end_time > e.start_time:
                e.end_time = new_end_time
        elif e.is_moving:
            new_pos = event.pos() – self._drag_offset
            duration = e.end_time – e.start_time
            # Déplacement temporel
            e.start_time = self.x_to_time(new_pos.x())
            e.end_time = e.start_time + duration
            # Déplacement vertical de la piste
            e.track = self.y_to_track(new_pos.y())
        
        self.update()

    def mouseReleaseEvent(self, event: QMouseEvent):
        if self._dragging_effect:
            self._dragging_effect.is_resizing_left = False
            self._dragging_effect.is_resizing_right = False
            self._dragging_effect.is_moving = False
            self._dragging_effect = None
        self.update()

    def mouseDoubleClickEvent(self, event: QMouseEvent):
        effect = self.get_effect_at(event.pos())
        if effect:
            self.effect_double_clicked.emit(effect)

# — Fenêtre Principale de l'Application —
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Éditeur d'Effets Vidéo Simplifié")
        self.setGeometry(100, 100, 1000, 700)
        
        self.current_project_path = ""
        self.video_path = ""
        self.effects = []
        
        # S'assurer que le répertoire de modèles existe
        self._ensure_model_dir_exists()

        self.media_player = QMediaPlayer()
        self.video_widget = QVideoWidget()
        self.media_player.setVideoOutput(self.video_widget)
        
        # — Zone inférieure (timeline + contrôles) —
        bottom_widget = QWidget()
        bottom_layout = QVBoxLayout(bottom_widget)
        bottom_layout.setContentsMargins(0, 5, 0, 0)

        # — Timeline dans une zone avec ascenseur —
        self.timeline = TimelineWidget()
        self.scroll_area = QScrollArea()
        self.scroll_area.setWidget(self.timeline)
        self.scroll_area.setWidgetResizable(True)
        self.scroll_area.setFrameShape(QFrame.NoFrame)
        
        # CORRECTION de l'AttributeError: Initialiser la hauteur après l'assignation du parent
        self.timeline.update_height() 

        self.add_track_button = QPushButton("+")
        self.add_track_button.setFixedSize(25, 25)
        self.add_track_button.setToolTip("Ajouter une piste")
        self.add_track_button.clicked.connect(self.timeline.add_track)
        
        self.remove_track_button = QPushButton("-")
        self.remove_track_button.setFixedSize(25, 25)
        self.remove_track_button.setToolTip("Supprimer la dernière piste (si vide)")
        self.remove_track_button.clicked.connect(self.timeline.remove_track)

        track_controls_layout = QVBoxLayout()
        track_controls_layout.addWidget(self.add_track_button)
        track_controls_layout.addWidget(self.remove_track_button)
        track_controls_layout.addStretch()

        timeline_area_layout = QHBoxLayout()
        timeline_area_layout.addLayout(track_controls_layout)
        timeline_area_layout.addWidget(self.scroll_area)
        
        # — Contrôles de lecture —
        self.play_pause_button = QPushButton()
        self.play_pause_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
        self.play_pause_button.clicked.connect(self.play_pause)
        
        self.restart_button = QPushButton()
        self.restart_button.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipBackward))
        self.restart_button.clicked.connect(self.restart_video)
        
        self.time_label = QLabel("00:00.000 / 00:00.000")
        
        controls_layout = QHBoxLayout()
        controls_layout.addWidget(self.play_pause_button)
        controls_layout.addWidget(self.restart_button)
        controls_layout.addWidget(self.time_label)
        controls_layout.addStretch()

        bottom_layout.addLayout(timeline_area_layout)
        bottom_layout.addLayout(controls_layout)
        
        # — Utilisation du QSplitter pour le layout principal —
        splitter = QSplitter(Qt.Vertical)
        splitter.addWidget(self.video_widget)
        splitter.addWidget(bottom_widget)

        # Définir les tailles initiales (70% pour la vidéo, 30% pour la timeline)
        splitter.setSizes([700, 300]) 
        
        self.setCentralWidget(splitter)
        
        self.create_menu()

        # — Connexions (Signaux et Slots) —
        self.media_player.durationChanged.connect(self.timeline.set_duration)
        self.media_player.positionChanged.connect(self.timeline.set_position)
        self.media_player.positionChanged.connect(self.update_time_label)
        self.media_player.playbackStateChanged.connect(self.update_play_button_icon)

        self.timeline.position_seek_requested.connect(self.media_player.setPosition)
        self.timeline.effect_double_clicked.connect(self.edit_effect)
        self.timeline.effect_selected.connect(self.update_selection)
        
    def _ensure_model_dir_exists(self):
        """Crée le répertoire de modèles s'il n'existe pas."""
        try:
            os.makedirs(MODEL_DIR, exist_ok=True)
        except OSError as e:
            print(f"Erreur lors de la création du répertoire de modèles '{MODEL_DIR}': {e}")
            
    def create_menu(self):
        menu_bar = self.menuBar()
        file_menu = menu_bar.addMenu("&Fichier")
        
        load_video_action = QAction("&Charger une Vidéo…", self)
        load_video_action.triggered.connect(self.load_video)
        file_menu.addAction(load_video_action)
        file_menu.addSeparator()
        
        save_project_action = QAction("&Enregistrer le Projet", self)
        save_project_action.triggered.connect(self.save_project)
        file_menu.addAction(save_project_action)
        
        load_project_action = QAction("&Ouvrir un Projet…", self)
        load_project_action.triggered.connect(self.load_project)
        file_menu.addAction(load_project_action)
        file_menu.addSeparator()
        
        exit_action = QAction("&Quitter", self)
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        edit_menu = menu_bar.addMenu("&Édition")
        self.add_effect_action = QAction("&Ajouter un Effet", self)
        self.add_effect_action.triggered.connect(self.add_effect)
        self.add_effect_action.setEnabled(False)
        edit_menu.addAction(self.add_effect_action)
        
        self.delete_effect_action = QAction("&Supprimer l'Effet Sélectionné", self)
        self.delete_effect_action.triggered.connect(self.delete_effect)
        self.delete_effect_action.setEnabled(False)
        edit_menu.addAction(self.delete_effect_action)

    @Slot()
    def load_video(self):
        path, _ = QFileDialog.getOpenFileName(self, "Ouvrir une vidéo", "", "Fichiers Vidéo (*.mp4 *.mov *.avi)")
        if path:
            self.video_path = path
            self.media_player.setSource(QUrl.fromLocalFile(path))
            self.add_effect_action.setEnabled(True)
            self.effects = []
            self.timeline.load_effects(self.effects)

    @Slot()
    def save_project(self):
        if not self.video_path: return
        path, _ = QFileDialog.getSaveFileName(self, "Enregistrer le projet", "", "Projet VidEff (*.json)")
        if path:
            project_data = {
                "video_path": self.video_path,
                "effects": [
                    {
                        "name": e.name, "description": e.description,
                        "start_time": e.start_time, "end_time": e.end_time,
                        "track": e.track
                    } for e in self.effects
                ]
            }
            with open(path, "w") as f:
                json.dump(project_data, f, indent=4)
            self.current_project_path = path

    @Slot()
    def load_project(self):
        path, _ = QFileDialog.getOpenFileName(self, "Ouvrir un projet", "", "Projet VidEff (*.json)")
        if path:
            try:
                with open(path, "r") as f:
                    project_data = json.load(f)
            except Exception as e:
                print(f"Erreur de lecture du fichier projet: {e}")
                return
            
            self.video_path = project_data.get("video_path", "")
            if not self.video_path or not os.path.exists(self.video_path):
                print(f"Erreur : Fichier vidéo non trouvé à {self.video_path}")
                # Permet de charger le projet même sans vidéo, mais avec un avertissement
                
            self.media_player.setSource(QUrl.fromLocalFile(self.video_path) if self.video_path else QUrl())
            
            self.effects = []
            for effect_data in project_data.get("effects", []):
                effect = Effect(
                    name=effect_data["name"], description=effect_data["description"],
                    start_time=effect_data["start_time"], end_time=effect_data["end_time"],
                    track=effect_data.get("track", 0)
                )
                self.effects.append(effect)
            
            self.timeline.load_effects(self.effects)
            self.add_effect_action.setEnabled(bool(self.video_path))
            self.current_project_path = path

    def play_pause(self):
        if self.media_player.playbackState() == QMediaPlayer.PlayingState:
            self.media_player.pause()
        else:
            self.media_player.play()

    def restart_video(self):
        self.media_player.setPosition(0)

    @Slot(QMediaPlayer.PlaybackState)
    def update_play_button_icon(self, state):
        icon = QStyle.SP_MediaPause if state == QMediaPlayer.PlayingState else QStyle.SP_MediaPlay
        self.play_pause_button.setIcon(self.style().standardIcon(icon))

    @Slot(int)
    def update_time_label(self, position):
        duration = self.media_player.duration()
        def format_time(ms):
            ms = max(0, ms)
            s = (ms // 1000) % 60
            m = (ms // 60000) % 60
            return f"{m:02d}:{s:02d}.{ms % 1000:03d}"
        self.time_label.setText(f"{format_time(position)} / {format_time(duration)}")

    @Slot()
    def add_effect(self):
        # Vérifie si la durée est valide avant d'ajouter un effet
        if self.media_player.duration() <= 0:
            print("Erreur : Veuillez d'abord charger une vidéo valide.")
            return

        start_time = self.media_player.position()
        # Assure que l'effet dure au moins 1s ou jusqu'à la fin de la vidéo
        end_time = min(start_time + 1000, self.media_player.duration()) 
        
        dialog = EffectDialog(parent=self)
        if dialog.exec():
            name, desc = dialog.get_data()
            if name:
                track = self.timeline.find_first_available_track(start_time, end_time)
                new_effect = Effect(name, desc, start_time, end_time, track)
                self.effects.append(new_effect)
                self.timeline.load_effects(self.effects)

    @Slot(object)
    def edit_effect(self, effect_to_edit):
        dialog = EffectDialog(effect=effect_to_edit, parent=self)
        if dialog.exec():
            name, desc = dialog.get_data()
            if name:
                effect_to_edit.name = name
                effect_to_edit.description = desc
                self.timeline.update()

    @Slot()
    def delete_effect(self):
        if self.timeline.selected_effect:
            self.effects.remove(self.timeline.selected_effect)
            self.timeline.selected_effect = None
            self.update_selection(None)
            self.timeline.load_effects(self.effects)

    @Slot(object)
    def update_selection(self, selected_effect):
        self.delete_effect_action.setEnabled(selected_effect is not None)

if __name__ == "__main__":
    # Assurez-vous que le répertoire de modèles existe avant de démarrer l'application
    try:
        os.makedirs(MODEL_DIR, exist_ok=True)
    except OSError as e:
        print(f"Erreur fatale : Impossible de créer le répertoire {MODEL_DIR}. {e}")
        sys.exit(1)
        
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

Documentation – Éditeur d’Effets Vidéo Simplifié

Published by geo on 30 septembre 202530 septembre 2025

📌 Présentation

⚙️ Dépendances

📂 Organisation du Code

1. Constantes

2. Classe Effect

3. Classe EffectDialog

4. Classe TimelineWidget

5. Classe MainWindow