2169 lines
102 KiB
Python
2169 lines
102 KiB
Python
"""
|
||
Professional Video Editor for Generated Shorts
|
||
Author: Dario Pascoal
|
||
|
||
Description: This is a comprehensive video editing application designed specifically for editing
|
||
short-form video content. The application provides a professional timeline-based interface
|
||
similar to industry-standard video editing software, with features including:
|
||
|
||
- Multi-track timeline with visual track roads for professional editing workflow
|
||
- Real-time video preview with frame-accurate scrubbing
|
||
- Professional editing tools: trim, speed adjustment, volume control, fade effects
|
||
- Text overlay capabilities with customizable styling
|
||
- Export functionality with multiple format support
|
||
- Tabbed interface organizing tools into logical categories
|
||
- Dark theme optimized for video editing work
|
||
- Support for multiple video formats (MP4, AVI, MOV, MKV, etc.)
|
||
|
||
The application is built using Python's Tkinter for the GUI, OpenCV for basic video processing,
|
||
and optionally MoviePy for advanced video editing features. It's designed to be educational,
|
||
showing how professional video editing interfaces work while remaining accessible to beginners.
|
||
|
||
Technical Architecture:
|
||
- Uses threading for non-blocking video playback and processing
|
||
- Implements canvas-based timeline with precise time-to-pixel calculations
|
||
- Supports both MoviePy (full features) and OpenCV (basic features) backends
|
||
- Maintains professional video editing workflow patterns
|
||
- Provides real-time preview updates during editing operations
|
||
|
||
This file serves as the main entry point for the video editing functionality and can be
|
||
integrated into larger applications or run as a standalone tool.
|
||
"""
|
||
|
||
import tkinter as tk
|
||
from tkinter import ttk, filedialog, messagebox
|
||
import cv2
|
||
import numpy as np
|
||
import os
|
||
import threading
|
||
import time
|
||
from datetime import datetime
|
||
from PIL import Image, ImageTk
|
||
|
||
# Try to import MoviePy, handle if not available
|
||
try:
|
||
from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip
|
||
from moviepy.video.fx import FadeIn, FadeOut, Resize
|
||
from moviepy.audio.fx import MultiplyVolume
|
||
MOVIEPY_AVAILABLE = True
|
||
except ImportError:
|
||
print("⚠️ MoviePy not available - using OpenCV backend for video processing")
|
||
MOVIEPY_AVAILABLE = False
|
||
|
||
# Create dummy classes for compatibility
|
||
class VideoFileClip:
|
||
def __init__(self, *args, **kwargs):
|
||
raise ImportError("MoviePy not available")
|
||
class TextClip:
|
||
def __init__(self, *args, **kwargs):
|
||
raise ImportError("MoviePy not available")
|
||
class CompositeVideoClip:
|
||
def __init__(self, *args, **kwargs):
|
||
raise ImportError("MoviePy not available")
|
||
|
||
class ShortsEditorGUI:
|
||
"""
|
||
Professional Video Editing Interface
|
||
|
||
This class provides a complete video editing interface with timeline controls,
|
||
real-time preview, and professional editing tools. It's designed to mimic the
|
||
workflow of professional video editing software while remaining accessible
|
||
to beginners.
|
||
|
||
Key Features:
|
||
- Multi-track timeline with visual separation (road lines)
|
||
- Frame-accurate video scrubbing and playback
|
||
- Professional editing tools (trim, speed, volume, effects)
|
||
- Real-time preview with synchronized timeline
|
||
- Tabbed tool interface for organized workflow
|
||
- Support for multiple video formats
|
||
- Export functionality with timestamp-based naming
|
||
|
||
The interface uses a dark theme optimized for video editing work and provides
|
||
both mouse and keyboard controls for efficient editing workflow.
|
||
|
||
Attributes:
|
||
parent: Parent window or None for standalone operation
|
||
shorts_folder: Directory path for video files
|
||
current_video: Path to currently loaded video file
|
||
current_clip: Video clip object (MoviePy or OpenCV)
|
||
timeline_*: Various timeline state and control variables
|
||
colors: Dictionary defining the dark theme color scheme
|
||
fonts: Dictionary defining typography for different UI elements
|
||
"""
|
||
|
||
def __init__(self, parent=None, shorts_folder="shorts"):
|
||
"""
|
||
Initialize the Professional Video Editor Interface
|
||
|
||
Sets up all the necessary state variables, UI theme, and data structures
|
||
needed for professional video editing. This includes timeline management,
|
||
video playback state, track configuration, and UI styling.
|
||
|
||
The initialization process:
|
||
1. Stores parent window reference and shorts folder path
|
||
2. Initializes video playback state variables
|
||
3. Sets up timeline state and interaction controls
|
||
4. Configures professional editing features (snap, magnetic timeline)
|
||
5. Defines track structure for multi-track editing
|
||
6. Establishes dark theme color scheme optimized for video work
|
||
7. Sets up typography for different UI elements
|
||
|
||
Args:
|
||
parent: Parent tkinter window (None for standalone operation)
|
||
shorts_folder: String path to directory containing video files
|
||
"""
|
||
# Store parent window reference and video directory path
|
||
self.parent = parent
|
||
self.shorts_folder = shorts_folder
|
||
|
||
# Video playback state management
|
||
# These variables track the current state of video loading and playback
|
||
self.current_video = None # File path to currently loaded video
|
||
self.current_clip = None # Video clip object (MoviePy VideoFileClip or OpenCV VideoCapture)
|
||
self.current_time = 0.0 # Current playback position in seconds
|
||
self.video_duration = 0.0 # Total video duration in seconds
|
||
self.is_playing = False # Whether video is currently playing
|
||
self.timeline_is_playing = False # Whether timeline playback is active
|
||
self.play_thread = None # Background thread for video playback
|
||
|
||
# Timeline display and interaction state
|
||
# Controls how the timeline is rendered and how users interact with it
|
||
self.timeline_position = 0.0 # Current scroll position of timeline view
|
||
self.timeline_scale = 1.0 # Zoom level: pixels per second of video
|
||
self.timeline_width = 800 # Width of timeline canvas in pixels
|
||
|
||
# Professional timeline editing features
|
||
# These lists store timeline content and user-created elements
|
||
self.timeline_clips = [] # List of video/audio clips on timeline
|
||
self.selected_clip = None # Currently selected clip for editing
|
||
self.markers = [] # User-placed timeline markers for navigation
|
||
|
||
# Multi-track system for professional video editing workflow
|
||
# Each track has its own properties and can hold different types of media
|
||
# This structure allows for layered editing with video and audio tracks
|
||
self.tracks = {
|
||
# Video tracks - higher tracks appear on top in the final composition
|
||
'video_1': {'y_offset': 40, 'height': 60, 'color': '#3498db', 'name': 'Video 1',
|
||
'muted': False, 'locked': False, 'solo': False, 'visible': True, 'type': 'video'},
|
||
'video_2': {'y_offset': 105, 'height': 60, 'color': '#2ecc71', 'name': 'Video 2',
|
||
'muted': False, 'locked': False, 'solo': False, 'visible': True, 'type': 'video'},
|
||
'video_3': {'y_offset': 170, 'height': 60, 'color': '#9b59b6', 'name': 'Video 3',
|
||
'muted': False, 'locked': False, 'solo': False, 'visible': True, 'type': 'video'},
|
||
# Audio tracks - for background music, sound effects, voiceovers
|
||
'audio_1': {'y_offset': 235, 'height': 40, 'color': '#e74c3c', 'name': 'Audio 1',
|
||
'muted': False, 'locked': False, 'solo': False, 'visible': True, 'type': 'audio'},
|
||
'audio_2': {'y_offset': 280, 'height': 40, 'color': '#f39c12', 'name': 'Audio 2',
|
||
'muted': False, 'locked': False, 'solo': False, 'visible': True, 'type': 'audio'}
|
||
}
|
||
|
||
# Timeline interaction state for drag-and-drop editing
|
||
# These variables track the current state of user interactions with timeline elements
|
||
self.dragging_clip = None # Clip currently being dragged by user
|
||
self.drag_start_x = None # Mouse X position when drag started
|
||
self.drag_start_time = None # Original time position of dragged clip
|
||
self.drag_offset = 0 # Offset from clip start to mouse position
|
||
self.snap_enabled = True # Whether clips snap to grid/other clips
|
||
self.magnetic_timeline = True # Whether clips magnetically attract to each other
|
||
self.grid_size = 1.0 # Snap grid size in seconds (for precise alignment)
|
||
|
||
# Timeline editing modes for different types of operations
|
||
# This affects how mouse interactions behave on the timeline
|
||
self.edit_mode = 'select' # Current editing mode: 'select', 'cut', 'trim', 'ripple'
|
||
|
||
# Visual enhancement options for better user experience
|
||
# These can be toggled on/off based on performance and user preference
|
||
self.show_thumbnails = True # Show video thumbnail previews on timeline clips
|
||
self.show_waveforms = True # Show audio waveform visualization
|
||
|
||
# Cached visual data for performance optimization
|
||
# Storing thumbnails and waveforms prevents repeated generation
|
||
self.clip_thumbnails = {} # Dictionary storing thumbnail images by clip ID
|
||
self.audio_waveforms = {} # Dictionary storing waveform data by clip ID
|
||
|
||
# Track control widget references for dynamic updates
|
||
# This allows us to update track control buttons when states change
|
||
self.track_widgets = {} # Dictionary storing widget references by track ID
|
||
|
||
# Professional dark color scheme optimized for video editing
|
||
# Dark themes reduce eye strain during long editing sessions and help
|
||
# focus attention on the video content rather than the interface
|
||
self.colors = {
|
||
'bg_primary': '#1a1a1a', # Main background - darkest for maximum contrast
|
||
'bg_secondary': '#2d2d2d', # Secondary panels - slightly lighter
|
||
'bg_tertiary': '#3d3d3d', # Buttons and controls - interactive elements
|
||
'text_primary': '#ffffff', # Main text - high contrast for readability
|
||
'text_secondary': '#b8b8b8', # Secondary text - lower contrast for hierarchy
|
||
'accent_blue': '#007acc', # Primary actions - professional blue
|
||
'accent_green': '#28a745', # Success/positive actions - natural green
|
||
'accent_orange': '#fd7e14', # Warning/attention - energetic orange
|
||
'accent_red': '#dc3545', # Destructive/negative actions - clear red
|
||
'border': '#404040' # Subtle borders - defines sections without distraction
|
||
}
|
||
|
||
# Typography system for consistent text hierarchy
|
||
# Font choices prioritize readability and professional appearance
|
||
# Segoe UI provides excellent readability across different screen sizes
|
||
self.fonts = {
|
||
'title': ('Segoe UI', 16, 'bold'), # Main window titles and headers
|
||
'heading': ('Segoe UI', 11, 'bold'), # Section headings and tool categories
|
||
'body': ('Segoe UI', 10), # Regular text and input fields
|
||
'caption': ('Segoe UI', 9), # Small labels and descriptions
|
||
'button': ('Segoe UI', 10, 'bold') # Button text for clear action indicators
|
||
}
|
||
|
||
def open_editor(self):
|
||
"""
|
||
Open the Professional Video Editor Window
|
||
|
||
Creates and displays the main video editing interface window. This method
|
||
sets up the window properties, makes it responsive, and initializes the
|
||
complete editor interface.
|
||
|
||
The window creation process:
|
||
1. Creates either a new Tkinter window (standalone) or Toplevel window (child)
|
||
2. Sets window title, size, and minimum dimensions for usability
|
||
3. Applies the dark theme background color
|
||
4. Configures responsive layout with proper weight distribution
|
||
5. Calls create_editor_interface() to build the complete UI
|
||
6. Starts the main event loop if running standalone
|
||
|
||
Window Properties:
|
||
- Title: "Professional Shorts Editor"
|
||
- Size: 1200x800 pixels (optimal for video editing workflow)
|
||
- Minimum: 900x600 pixels (ensures UI remains functional when resized)
|
||
- Theme: Dark background optimized for video editing
|
||
- Layout: Responsive with proper weight distribution for resizing
|
||
"""
|
||
# Create the main editor window - either standalone or child window
|
||
# If parent exists, create as child window; otherwise create root window
|
||
self.editor_window = tk.Toplevel(self.parent) if self.parent else tk.Tk()
|
||
self.editor_window.title("Professional Shorts Editor")
|
||
self.editor_window.geometry("1200x900") # Increased height for Audio 2 visibility
|
||
self.editor_window.minsize(900, 700) # Increased minimum size
|
||
self.editor_window.configure(bg=self.colors['bg_primary']) # Apply dark theme
|
||
|
||
# Configure responsive layout for window resizing
|
||
# Row 1 gets all extra vertical space (main content area)
|
||
# Column 0 gets all extra horizontal space (full width utilization)
|
||
self.editor_window.rowconfigure(1, weight=1)
|
||
self.editor_window.columnconfigure(0, weight=1)
|
||
|
||
# Build the complete editor interface
|
||
self.create_editor_interface()
|
||
|
||
# Start the application main loop if running as standalone application
|
||
if not self.parent:
|
||
self.editor_window.mainloop()
|
||
|
||
def create_editor_interface(self):
|
||
"""
|
||
Create the Complete Professional Video Editor Interface
|
||
|
||
Builds the entire user interface for the video editor, organizing it into
|
||
logical sections that mirror professional video editing software. The
|
||
interface uses a three-panel layout with header, main content, and tools.
|
||
|
||
Interface Structure:
|
||
1. Header: Title, current file display, and file selection controls
|
||
2. Main Content: Split into left panel (video/timeline) and right panel (tools)
|
||
3. Left Panel: Video preview, playback controls, and professional timeline
|
||
4. Right Panel: Tabbed tool interface with editing functions
|
||
5. Timeline: Multi-track workspace with road lines and interactive controls
|
||
|
||
The layout is designed to be intuitive for users familiar with professional
|
||
video editing software while remaining accessible to beginners. Dark theme
|
||
reduces eye strain during long editing sessions.
|
||
"""
|
||
# Header section - contains title and file management controls
|
||
# Fixed height prevents layout shifts when content changes
|
||
header_frame = tk.Frame(self.editor_window, bg=self.colors['bg_secondary'], height=60)
|
||
header_frame.pack(fill="x", padx=10, pady=(10, 0))
|
||
header_frame.pack_propagate(False) # Maintain fixed height
|
||
|
||
# Application title with professional icon and branding
|
||
title_label = tk.Label(header_frame, text="✏️ Professional Shorts Editor",
|
||
font=self.fonts['title'], bg=self.colors['bg_secondary'],
|
||
fg=self.colors['text_primary'])
|
||
title_label.pack(side="left", padx=20, pady=15)
|
||
|
||
# File selection area - shows current file and provides selection control
|
||
file_frame = tk.Frame(header_frame, bg=self.colors['bg_secondary'])
|
||
file_frame.pack(side="right", padx=20, pady=15)
|
||
|
||
# Current file display - shows filename or "No video selected" status
|
||
self.current_file_label = tk.Label(file_frame, text="No video selected",
|
||
font=self.fonts['body'], bg=self.colors['bg_tertiary'],
|
||
fg=self.colors['text_secondary'], padx=15, pady=8)
|
||
self.current_file_label.pack(side="left", padx=(0, 10))
|
||
|
||
# File selection button - opens file browser or shows available videos
|
||
select_btn = tk.Button(file_frame, text="📁 Select Video",
|
||
command=self.select_video_file, font=self.fonts['button'],
|
||
bg=self.colors['accent_blue'], fg='white', padx=20, pady=8,
|
||
relief="flat", bd=0, cursor="hand2")
|
||
select_btn.pack(side="left")
|
||
|
||
# Main content area - contains the primary editing workspace
|
||
# Uses a two-column grid layout with weighted columns for responsive design
|
||
# Left column (weight=2) is larger for video preview and timeline
|
||
# Right column (weight=1) is smaller for tools and controls
|
||
main_frame = tk.Frame(self.editor_window, bg=self.colors['bg_primary'])
|
||
main_frame.pack(fill="both", expand=True, padx=10, pady=10)
|
||
main_frame.rowconfigure(0, weight=1) # Single row takes all vertical space
|
||
main_frame.columnconfigure(0, weight=2) # Left column gets 2/3 of width
|
||
main_frame.columnconfigure(1, weight=1) # Right column gets 1/3 of width
|
||
|
||
# Left panel - Video preview and timeline workspace
|
||
# This is the main editing area where users see their video and timeline
|
||
# Organized vertically with video preview on top and timeline below
|
||
player_frame = tk.Frame(main_frame, bg=self.colors['bg_secondary'])
|
||
player_frame.grid(row=0, column=0, sticky="nsew", padx=(0, 5))
|
||
player_frame.rowconfigure(0, weight=1) # Video preview area (expandable)
|
||
player_frame.rowconfigure(1, weight=0) # Timeline area (fixed height)
|
||
player_frame.columnconfigure(0, weight=1) # Full width utilization
|
||
|
||
# Video Display Area - The main preview window for video content
|
||
# This section provides real-time video preview with proper aspect ratio maintenance
|
||
# Dark border provides visual separation and professional appearance
|
||
video_container = tk.Frame(player_frame, bg=self.colors['bg_tertiary'])
|
||
video_container.grid(row=0, column=0, sticky="nsew", padx=15, pady=15)
|
||
video_container.rowconfigure(0, weight=1) # Video canvas expands to fill space
|
||
video_container.columnconfigure(0, weight=1) # Full width utilization
|
||
|
||
# Video canvas - displays the actual video frames
|
||
# Black background provides professional video preview appearance
|
||
# No highlight thickness removes the default canvas border for cleaner look
|
||
self.video_canvas = tk.Canvas(video_container, bg='black', highlightthickness=0)
|
||
self.video_canvas.grid(row=0, column=0, sticky="nsew")
|
||
|
||
# Professional Timeline Workspace - Multi-track editing environment
|
||
# Fixed height prevents timeline from shrinking when window is resized
|
||
# This is where users perform the majority of their editing work
|
||
timeline_workspace = tk.Frame(player_frame, bg=self.colors['bg_secondary'], height=480)
|
||
timeline_workspace.grid(row=1, column=0, sticky="ew", padx=15, pady=(0, 15))
|
||
timeline_workspace.pack_propagate(False) # Maintain fixed height for consistent layout
|
||
|
||
# Timeline header - contains editing mode controls and timeline options
|
||
# These controls affect how the user interacts with timeline elements
|
||
header_frame = tk.Frame(timeline_workspace, bg=self.colors['bg_secondary'])
|
||
header_frame.pack(fill="x", pady=(5, 5))
|
||
|
||
# Left side timeline controls - editing modes and interaction options
|
||
left_controls = tk.Frame(header_frame, bg=self.colors['bg_secondary'])
|
||
left_controls.pack(side="left")
|
||
|
||
# Editing mode selector - determines how mouse interactions behave
|
||
# Different modes enable different types of editing operations
|
||
tk.Label(left_controls, text="Mode:", font=self.fonts['caption'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(side="left")
|
||
|
||
# Mode selection dropdown with professional editing modes
|
||
# select: Default mode for selecting and moving clips
|
||
# cut: Razor tool for splitting clips at specific points
|
||
# trim: For adjusting clip start/end points
|
||
# ripple: Moves clips and automatically adjusts following clips
|
||
self.mode_var = tk.StringVar(value="select")
|
||
mode_combo = ttk.Combobox(left_controls, textvariable=self.mode_var, width=8,
|
||
values=["select", "cut", "trim", "ripple"], state="readonly")
|
||
mode_combo.pack(side="left", padx=(5, 10))
|
||
mode_combo.bind('<<ComboboxSelected>>', self.on_mode_change)
|
||
|
||
# Professional timeline assistance features
|
||
# These options help users align and position clips precisely
|
||
self.snap_var = tk.BooleanVar(value=True)
|
||
snap_check = tk.Checkbutton(left_controls, text="Snap", variable=self.snap_var,
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
selectcolor=self.colors['accent_blue'], command=self.toggle_snap)
|
||
snap_check.pack(side="left", padx=5)
|
||
|
||
# Magnetic timeline - clips automatically attract to align with other clips
|
||
# This feature helps maintain precise timing relationships between clips
|
||
self.magnetic_var = tk.BooleanVar(value=True)
|
||
magnetic_check = tk.Checkbutton(left_controls, text="Magnetic", variable=self.magnetic_var,
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
selectcolor=self.colors['accent_blue'], command=self.toggle_magnetic)
|
||
magnetic_check.pack(side="left", padx=5)
|
||
|
||
# Center - Professional playback controls for timeline
|
||
# These controls manage video playback synchronized with timeline position
|
||
# Color-coded for immediate recognition: Green=Play, Orange=Pause, Red=Stop
|
||
center_controls = tk.Frame(header_frame, bg=self.colors['bg_secondary'])
|
||
center_controls.pack(side="left", padx=20)
|
||
|
||
# Play button - starts video playback from current timeline position
|
||
self.timeline_play_btn = tk.Button(center_controls, text="▶️",
|
||
command=self.timeline_play,
|
||
bg=self.colors['accent_green'], fg='white',
|
||
font=('Arial', 12, 'bold'), width=3, height=1,
|
||
relief="flat", bd=0, cursor="hand2")
|
||
self.timeline_play_btn.pack(side="left", padx=2)
|
||
|
||
# Pause button - temporarily stops playback, maintains current position
|
||
self.timeline_pause_btn = tk.Button(center_controls, text="⏸️",
|
||
command=self.timeline_pause,
|
||
bg=self.colors['accent_orange'], fg='white',
|
||
font=('Arial', 12, 'bold'), width=3, height=1,
|
||
relief="flat", bd=0, cursor="hand2")
|
||
self.timeline_pause_btn.pack(side="left", padx=2)
|
||
|
||
# Stop button - stops playback and returns to beginning of timeline
|
||
self.timeline_stop_btn = tk.Button(center_controls, text="⏹️",
|
||
command=self.timeline_stop,
|
||
bg=self.colors['accent_red'], fg='white',
|
||
font=('Arial', 12, 'bold'), width=3, height=1,
|
||
relief="flat", bd=0, cursor="hand2")
|
||
self.timeline_stop_btn.pack(side="left", padx=2)
|
||
|
||
# Right side - Zoom and time display
|
||
right_controls = tk.Frame(header_frame, bg=self.colors['bg_secondary'])
|
||
right_controls.pack(side="right")
|
||
|
||
# Zoom control
|
||
tk.Label(right_controls, text="Zoom:", font=self.fonts['caption'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(side="left")
|
||
|
||
self.zoom_var = tk.DoubleVar(value=1.0)
|
||
zoom_scale = tk.Scale(right_controls, from_=0.1, to=5.0, resolution=0.1,
|
||
orient="horizontal", variable=self.zoom_var,
|
||
command=self.on_zoom_change, length=150,
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
highlightthickness=0, troughcolor=self.colors['bg_tertiary'])
|
||
zoom_scale.pack(side="left", padx=10)
|
||
|
||
# Time display
|
||
self.time_display = tk.Label(right_controls, text="00:00 / 00:00",
|
||
font=self.fonts['body'], bg=self.colors['bg_secondary'],
|
||
fg=self.colors['text_primary'])
|
||
self.time_display.pack(side="left", padx=20)
|
||
|
||
# Main timeline container
|
||
timeline_container = tk.Frame(timeline_workspace, bg=self.colors['bg_tertiary'])
|
||
timeline_container.pack(fill="both", expand=True, pady=5)
|
||
|
||
# Track labels panel (left side)
|
||
self.track_panel = tk.Frame(timeline_container, bg=self.colors['bg_secondary'], width=120)
|
||
self.track_panel.pack(side="left", fill="y")
|
||
self.track_panel.pack_propagate(False)
|
||
|
||
# Timeline canvas with scrollbars
|
||
canvas_frame = tk.Frame(timeline_container, bg=self.colors['bg_tertiary'])
|
||
canvas_frame.pack(side="right", fill="both", expand=True)
|
||
|
||
# Create canvas without internal scrollbars
|
||
self.timeline_canvas = tk.Canvas(canvas_frame, bg='#1a1a1a',
|
||
highlightthickness=0, scrollregion=(0, 0, 2000, 400))
|
||
|
||
# Pack canvas to fill the frame completely
|
||
self.timeline_canvas.pack(fill="both", expand=True)
|
||
|
||
# Create external horizontal scrollbar for timeline control
|
||
# Place it outside the timeline in the workspace area
|
||
external_scrollbar_frame = tk.Frame(timeline_workspace, bg=self.colors['bg_primary'], height=20)
|
||
external_scrollbar_frame.pack(side="bottom", fill="x", padx=5, pady=2)
|
||
external_scrollbar_frame.pack_propagate(False)
|
||
|
||
# Horizontal scrollbar outside timeline but controlling it
|
||
self.external_h_scrollbar = ttk.Scrollbar(external_scrollbar_frame, orient="horizontal",
|
||
command=self.timeline_canvas.xview)
|
||
self.timeline_canvas.configure(xscrollcommand=self.external_h_scrollbar.set)
|
||
self.external_h_scrollbar.pack(fill="x", expand=True)
|
||
|
||
# Bind professional timeline events
|
||
self.timeline_canvas.bind("<Button-1>", self.timeline_click)
|
||
self.timeline_canvas.bind("<B1-Motion>", self.timeline_drag)
|
||
self.timeline_canvas.bind("<ButtonRelease-1>", self.on_timeline_drag_end)
|
||
self.timeline_canvas.bind("<Button-3>", self.on_timeline_right_click)
|
||
self.timeline_canvas.bind("<Double-Button-1>", self.on_timeline_double_click)
|
||
|
||
# Create track controls
|
||
self.create_track_controls()
|
||
|
||
# Bind canvas resize to redraw road lines
|
||
self.track_panel.bind("<Configure>", self.on_track_panel_resize)
|
||
|
||
# Initialize sample clips for demonstration
|
||
self.create_sample_timeline_content()
|
||
|
||
# Right panel - Tools and effects
|
||
tools_frame = tk.Frame(main_frame, bg=self.colors['bg_secondary'])
|
||
tools_frame.grid(row=0, column=1, sticky="nsew", padx=(5, 0))
|
||
|
||
# Tools header
|
||
tools_header = tk.Label(tools_frame, text="🛠️ Editing Tools",
|
||
font=self.fonts['heading'], bg=self.colors['bg_secondary'],
|
||
fg=self.colors['text_primary'])
|
||
tools_header.pack(pady=(15, 10))
|
||
|
||
# Create tabbed interface for tools
|
||
self.create_tabbed_tools(tools_frame)
|
||
|
||
# Initialize timeline
|
||
self.update_timeline()
|
||
|
||
def create_tabbed_tools(self, parent):
|
||
"""Create tabbed interface for editing tools"""
|
||
import tkinter.ttk as ttk
|
||
|
||
# Create notebook for tabs
|
||
self.tools_notebook = ttk.Notebook(parent)
|
||
self.tools_notebook.pack(fill="both", expand=True, padx=10, pady=5)
|
||
|
||
# Configure notebook style for dark theme
|
||
style = ttk.Style()
|
||
|
||
# Set theme and configure colors
|
||
try:
|
||
style.theme_use('clam') # Use clam theme as base for better customization
|
||
except:
|
||
pass # Fall back to default theme if clam isn't available
|
||
|
||
# Configure the notebook (main container)
|
||
style.configure('TNotebook',
|
||
background=self.colors['bg_secondary'],
|
||
borderwidth=0,
|
||
tabmargins=[2, 5, 2, 0])
|
||
|
||
# Configure the tabs themselves with consistent sizing
|
||
style.configure('TNotebook.Tab',
|
||
background=self.colors['bg_tertiary'],
|
||
foreground=self.colors['text_primary'],
|
||
padding=[15, 8, 15, 8], # Explicit left, top, right, bottom padding
|
||
borderwidth=0, # Remove border to prevent size changes
|
||
focuscolor='none',
|
||
relief='flat')
|
||
|
||
# Configure selected tab with same padding to prevent shrinking
|
||
style.map('TNotebook.Tab',
|
||
background=[('selected', self.colors['accent_blue']),
|
||
('active', self.colors['bg_primary']),
|
||
('!active', self.colors['bg_tertiary'])],
|
||
foreground=[('selected', 'white'),
|
||
('active', self.colors['text_primary']),
|
||
('!active', self.colors['text_primary'])],
|
||
padding=[('selected', [15, 8, 15, 8]), # Same padding for selected
|
||
('active', [15, 8, 15, 8]), # Same padding for active
|
||
('!active', [15, 8, 15, 8])], # Same padding for inactive
|
||
borderwidth=[('selected', 0), # No border changes
|
||
('active', 0),
|
||
('!active', 0)],
|
||
relief=[('selected', 'flat'), # Consistent relief
|
||
('active', 'flat'),
|
||
('!active', 'flat')])
|
||
|
||
# Basic Editing Tab
|
||
basic_frame = tk.Frame(self.tools_notebook, bg=self.colors['bg_secondary'])
|
||
self.tools_notebook.add(basic_frame, text="Basic Editing")
|
||
self.create_basic_tools(basic_frame)
|
||
|
||
# Video Effects Tab
|
||
video_effects_frame = tk.Frame(self.tools_notebook, bg=self.colors['bg_secondary'])
|
||
self.tools_notebook.add(video_effects_frame, text="Video Effects")
|
||
self.create_video_effects_tools(video_effects_frame)
|
||
|
||
# Audio Effects Tab
|
||
audio_effects_frame = tk.Frame(self.tools_notebook, bg=self.colors['bg_secondary'])
|
||
self.tools_notebook.add(audio_effects_frame, text="Audio Effects")
|
||
self.create_audio_effects_tools(audio_effects_frame)
|
||
|
||
# Export Tab
|
||
export_frame = tk.Frame(self.tools_notebook, bg=self.colors['bg_secondary'])
|
||
self.tools_notebook.add(export_frame, text="Export")
|
||
self.create_export_tools(export_frame)
|
||
|
||
def create_track_controls(self):
|
||
"""Create professional track control panel with road lines"""
|
||
# Clear existing track controls
|
||
for widget in self.track_panel.winfo_children():
|
||
widget.destroy()
|
||
|
||
# Create road line background canvas
|
||
self.track_road_canvas = tk.Canvas(self.track_panel,
|
||
bg=self.colors['bg_secondary'],
|
||
highlightthickness=0,
|
||
scrollregion=(0, 0, 120, 400))
|
||
self.track_road_canvas.pack(fill="both", expand=True)
|
||
|
||
# Draw road lines for track separation
|
||
self.draw_track_road_lines()
|
||
|
||
# Create controls for each track
|
||
for track_id, track_info in self.tracks.items():
|
||
self.create_track_control(track_id, track_info)
|
||
|
||
def draw_track_road_lines(self):
|
||
"""Draw road lines for track visual separation"""
|
||
# Clear existing lines
|
||
self.track_road_canvas.delete("road_lines")
|
||
|
||
# Get canvas dimensions
|
||
canvas_width = self.track_panel.winfo_width() or 120
|
||
canvas_height = self.track_panel.winfo_height() or 320
|
||
|
||
# Draw horizontal road lines for each track
|
||
for track_id, track_info in self.tracks.items():
|
||
y_pos = track_info['y_offset']
|
||
track_height = track_info['height']
|
||
|
||
# Top line of track
|
||
self.track_road_canvas.create_line(
|
||
0, y_pos, canvas_width, y_pos,
|
||
fill=self.colors['border'], width=1, tags="road_lines"
|
||
)
|
||
|
||
# Bottom line of track
|
||
self.track_road_canvas.create_line(
|
||
0, y_pos + track_height, canvas_width, y_pos + track_height,
|
||
fill=self.colors['border'], width=3, tags="road_lines"
|
||
)
|
||
|
||
# Track type indicator line (left edge with track color)
|
||
self.track_road_canvas.create_line(
|
||
0, y_pos, 0, y_pos + track_height,
|
||
fill=track_info['color'], width=1, tags="road_lines"
|
||
)
|
||
|
||
# Center dashed line for alignment reference
|
||
center_x = canvas_width // 2
|
||
for y in range(0, int(canvas_height), 10):
|
||
self.track_road_canvas.create_line(
|
||
center_x, y, center_x, y + 5,
|
||
fill=self.colors['text_secondary'], width=1,
|
||
tags="road_lines", dash=(2, 3)
|
||
)
|
||
|
||
def on_track_panel_resize(self, event):
|
||
"""Handle track panel resize to redraw road lines"""
|
||
if hasattr(self, 'track_road_canvas'):
|
||
# Small delay to ensure canvas size is updated
|
||
self.editor_window.after(10, self.draw_track_road_lines)
|
||
|
||
def sync_vertical_scroll(self, *args):
|
||
"""Vertical scrolling disabled - no scrollbars for up/down movement"""
|
||
# Vertical scrolling removed for cleaner interface
|
||
pass
|
||
|
||
def create_track_control(self, track_id, track_info):
|
||
"""Create control panel for a single track positioned on road lines"""
|
||
# Calculate precise positioning based on track offset
|
||
y_position = track_info['y_offset']
|
||
track_height = track_info['height']
|
||
|
||
# Create control buttons frame positioned on canvas
|
||
controls_frame = tk.Frame(self.track_road_canvas, bg=self.colors['bg_secondary'])
|
||
|
||
# Control buttons container
|
||
controls = tk.Frame(controls_frame, bg=self.colors['bg_secondary'])
|
||
controls.pack(padx=5, pady=2)
|
||
|
||
# Track name label (small, top of controls)
|
||
name_label = tk.Label(controls, text=track_info['name'],
|
||
font=('Arial', 7, 'bold'), bg=self.colors['bg_secondary'],
|
||
fg=track_info['color'])
|
||
name_label.pack(anchor="center")
|
||
|
||
# Button container
|
||
button_container = tk.Frame(controls, bg=self.colors['bg_secondary'])
|
||
button_container.pack()
|
||
|
||
# Mute button
|
||
mute_text = "🔇" if track_info['muted'] else "🔊"
|
||
mute_btn = tk.Button(button_container, text=mute_text, width=2, height=1,
|
||
bg=self.colors['accent_red'] if track_info['muted'] else self.colors['bg_tertiary'],
|
||
fg='white', font=('Arial', 7), relief="flat", bd=0,
|
||
command=lambda: self.toggle_track_mute(track_id))
|
||
mute_btn.pack(side="left", padx=1)
|
||
|
||
# Solo button
|
||
solo_text = "S"
|
||
solo_btn = tk.Button(button_container, text=solo_text, width=2, height=1,
|
||
bg=self.colors['accent_orange'] if track_info['solo'] else self.colors['bg_tertiary'],
|
||
fg='white', font=('Arial', 7, 'bold'), relief="flat", bd=0,
|
||
command=lambda: self.toggle_track_solo(track_id))
|
||
solo_btn.pack(side="left", padx=1)
|
||
|
||
# Lock button
|
||
lock_text = "🔒" if track_info['locked'] else "🔓"
|
||
lock_btn = tk.Button(button_container, text=lock_text, width=2, height=1,
|
||
bg=self.colors['accent_blue'] if track_info['locked'] else self.colors['bg_tertiary'],
|
||
fg='white', font=('Arial', 7), relief="flat", bd=0,
|
||
command=lambda: self.toggle_track_lock(track_id))
|
||
lock_btn.pack(side="left", padx=1)
|
||
|
||
# Position the controls frame on the canvas
|
||
canvas_width = 120
|
||
control_y = y_position + (track_height // 2) - 20 # Center vertically in track
|
||
|
||
self.track_road_canvas.create_window(
|
||
canvas_width // 2, control_y,
|
||
window=controls_frame, anchor="center"
|
||
)
|
||
|
||
# Store track widgets for updates
|
||
self.track_widgets[track_id] = {
|
||
'frame': controls_frame,
|
||
'mute_btn': mute_btn,
|
||
'solo_btn': solo_btn,
|
||
'lock_btn': lock_btn
|
||
}
|
||
|
||
def create_sample_timeline_content(self):
|
||
"""Create sample timeline content for demonstration"""
|
||
if self.current_video and self.video_duration > 0:
|
||
# Create a sample clip representing the loaded video
|
||
sample_clip = {
|
||
'id': 1,
|
||
'name': os.path.basename(self.current_video) if self.current_video else 'Sample Video',
|
||
'start_time': 0,
|
||
'end_time': min(self.video_duration, 10), # Cap at 10 seconds for demo
|
||
'track': 'video_1',
|
||
'color': self.tracks['video_1']['color'],
|
||
'file_path': self.current_video,
|
||
'type': 'video'
|
||
}
|
||
self.timeline_clips = [sample_clip]
|
||
|
||
# Add sample markers
|
||
self.markers = [
|
||
{'time': 2.0, 'name': 'Intro End', 'color': '#ffeb3b'},
|
||
{'time': 5.0, 'name': 'Mid Point', 'color': '#4caf50'},
|
||
{'time': 8.0, 'name': 'Outro Start', 'color': '#f44336'}
|
||
]
|
||
|
||
self.update_timeline()
|
||
|
||
# Professional timeline interaction methods
|
||
def on_mode_change(self, event=None):
|
||
"""Handle editing mode change"""
|
||
self.edit_mode = self.mode_var.get()
|
||
print(f"🎬 Editing mode changed to: {self.edit_mode}")
|
||
|
||
# Update cursor based on mode
|
||
cursor_map = {
|
||
'select': 'hand2',
|
||
'cut': 'crosshair',
|
||
'trim': 'sb_h_double_arrow',
|
||
'ripple': 'fleur'
|
||
}
|
||
self.timeline_canvas.configure(cursor=cursor_map.get(self.edit_mode, 'hand2'))
|
||
|
||
def toggle_snap(self):
|
||
"""Toggle snap to grid"""
|
||
self.snap_enabled = self.snap_var.get()
|
||
print(f"🧲 Snap enabled: {self.snap_enabled}")
|
||
|
||
def toggle_magnetic(self):
|
||
"""Toggle magnetic timeline"""
|
||
self.magnetic_timeline = self.magnetic_var.get()
|
||
print(f"🧲 Magnetic timeline: {self.magnetic_timeline}")
|
||
|
||
def toggle_track_mute(self, track_id):
|
||
"""Toggle track mute"""
|
||
self.tracks[track_id]['muted'] = not self.tracks[track_id]['muted']
|
||
self.update_track_controls()
|
||
print(f"🔇 Track {track_id} muted: {self.tracks[track_id]['muted']}")
|
||
|
||
def toggle_track_solo(self, track_id):
|
||
"""Toggle track solo"""
|
||
self.tracks[track_id]['solo'] = not self.tracks[track_id]['solo']
|
||
self.update_track_controls()
|
||
print(f"🎵 Track {track_id} solo: {self.tracks[track_id]['solo']}")
|
||
|
||
def toggle_track_lock(self, track_id):
|
||
"""Toggle track lock"""
|
||
self.tracks[track_id]['locked'] = not self.tracks[track_id]['locked']
|
||
self.update_track_controls()
|
||
print(f"🔒 Track {track_id} locked: {self.tracks[track_id]['locked']}")
|
||
|
||
def update_track_controls(self):
|
||
"""Update track control button states"""
|
||
for track_id, widgets in self.track_widgets.items():
|
||
track_info = self.tracks[track_id]
|
||
|
||
# Update mute button
|
||
mute_text = "🔇" if track_info['muted'] else "🔊"
|
||
mute_color = self.colors['accent_red'] if track_info['muted'] else self.colors['bg_tertiary']
|
||
widgets['mute_btn'].configure(text=mute_text, bg=mute_color)
|
||
|
||
# Update solo button
|
||
solo_color = self.colors['accent_orange'] if track_info['solo'] else self.colors['bg_tertiary']
|
||
widgets['solo_btn'].configure(bg=solo_color)
|
||
|
||
# Update lock button
|
||
lock_text = "🔒" if track_info['locked'] else "🔓"
|
||
lock_color = self.colors['accent_blue'] if track_info['locked'] else self.colors['bg_tertiary']
|
||
widgets['lock_btn'].configure(text=lock_text, bg=lock_color)
|
||
|
||
def on_zoom_change(self, value):
|
||
"""Handle timeline zoom change"""
|
||
zoom_level = float(value)
|
||
self.timeline_scale = 50 * zoom_level # Base scale of 50 pixels per second
|
||
self.update_timeline()
|
||
print(f"🔍 Timeline zoom: {zoom_level:.1f}x")
|
||
|
||
# Initialize timeline
|
||
self.update_timeline()
|
||
|
||
def create_basic_tools(self, parent):
|
||
"""Create basic editing tools"""
|
||
# Create scrollable frame for tools
|
||
tools_canvas = tk.Canvas(parent, bg=self.colors['bg_secondary'], highlightthickness=0)
|
||
scrollbar = tk.Scrollbar(parent, orient="vertical", command=tools_canvas.yview)
|
||
scrollable_frame = tk.Frame(tools_canvas, bg=self.colors['bg_secondary'])
|
||
|
||
scrollable_frame.bind(
|
||
"<Configure>",
|
||
lambda e: tools_canvas.configure(scrollregion=tools_canvas.bbox("all"))
|
||
)
|
||
|
||
tools_canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
|
||
tools_canvas.configure(yscrollcommand=scrollbar.set)
|
||
|
||
tools_canvas.pack(side="left", fill="both", expand=True)
|
||
scrollbar.pack(side="right", fill="y")
|
||
|
||
# Trim controls
|
||
trim_frame = tk.LabelFrame(scrollable_frame, text="✂️ Trim Video", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
trim_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
trim_controls = tk.Frame(trim_frame, bg=self.colors['bg_secondary'])
|
||
trim_controls.pack(fill="x", pady=5)
|
||
|
||
tk.Label(trim_controls, text="Start:", font=self.fonts['caption'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(side="left")
|
||
|
||
self.trim_start_var = tk.DoubleVar(value=0.0)
|
||
trim_start_spin = tk.Spinbox(trim_controls, from_=0, to=999, increment=0.1,
|
||
textvariable=self.trim_start_var, width=8,
|
||
font=self.fonts['caption'])
|
||
trim_start_spin.pack(side="left", padx=5)
|
||
|
||
tk.Label(trim_controls, text="End:", font=self.fonts['caption'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(side="left", padx=(10, 0))
|
||
|
||
self.trim_end_var = tk.DoubleVar(value=10.0)
|
||
trim_end_spin = tk.Spinbox(trim_controls, from_=0, to=999, increment=0.1,
|
||
textvariable=self.trim_end_var, width=8,
|
||
font=self.fonts['caption'])
|
||
trim_end_spin.pack(side="left", padx=5)
|
||
|
||
trim_btn = tk.Button(trim_frame, text="✂️ Apply Trim", command=self.apply_trim,
|
||
bg=self.colors['accent_blue'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
trim_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Speed controls
|
||
speed_frame = tk.LabelFrame(scrollable_frame, text="⚡ Speed Control", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
speed_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
self.speed_var = tk.DoubleVar(value=1.0)
|
||
speed_scale = tk.Scale(speed_frame, from_=0.25, to=3.0, resolution=0.25,
|
||
orient="horizontal", variable=self.speed_var,
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
highlightthickness=0, troughcolor=self.colors['bg_tertiary'])
|
||
speed_scale.pack(fill="x", pady=5, padx=10)
|
||
|
||
speed_btn = tk.Button(speed_frame, text="⚡ Apply Speed", command=self.apply_speed,
|
||
bg=self.colors['accent_green'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
speed_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Volume controls
|
||
volume_frame = tk.LabelFrame(scrollable_frame, text="🔊 Volume Control", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
volume_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
self.volume_var = tk.DoubleVar(value=1.0)
|
||
volume_scale = tk.Scale(volume_frame, from_=0.0, to=2.0, resolution=0.1,
|
||
orient="horizontal", variable=self.volume_var,
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
highlightthickness=0, troughcolor=self.colors['bg_tertiary'])
|
||
volume_scale.pack(fill="x", pady=5, padx=10)
|
||
|
||
volume_btn = tk.Button(volume_frame, text="🔊 Apply Volume", command=self.apply_volume,
|
||
bg=self.colors['accent_orange'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
volume_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Resize controls
|
||
resize_frame = tk.LabelFrame(scrollable_frame, text="📐 Resize Video", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
resize_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Preset sizes
|
||
preset_frame = tk.Frame(resize_frame, bg=self.colors['bg_secondary'])
|
||
preset_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
tk.Label(preset_frame, text="Presets:", font=self.fonts['caption'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w")
|
||
|
||
presets = [("9:16 (1080x1920)", 1080, 1920), ("16:9 (1920x1080)", 1920, 1080), ("1:1 (1080x1080)", 1080, 1080)]
|
||
for name, width, height in presets:
|
||
btn = tk.Button(preset_frame, text=name,
|
||
command=lambda w=width, h=height: self.apply_resize(w, h),
|
||
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
|
||
font=self.fonts['caption'], relief="flat", bd=0, cursor="hand2")
|
||
btn.pack(fill="x", pady=2)
|
||
|
||
def create_video_effects_tools(self, parent):
|
||
"""Create video effects tools"""
|
||
# Create scrollable frame for video effects
|
||
effects_canvas = tk.Canvas(parent, bg=self.colors['bg_secondary'], highlightthickness=0)
|
||
scrollbar_effects = tk.Scrollbar(parent, orient="vertical", command=effects_canvas.yview)
|
||
scrollable_effects_frame = tk.Frame(effects_canvas, bg=self.colors['bg_secondary'])
|
||
|
||
scrollable_effects_frame.bind(
|
||
"<Configure>",
|
||
lambda e: effects_canvas.configure(scrollregion=effects_canvas.bbox("all"))
|
||
)
|
||
|
||
effects_canvas.create_window((0, 0), window=scrollable_effects_frame, anchor="nw")
|
||
effects_canvas.configure(yscrollcommand=scrollbar_effects.set)
|
||
|
||
effects_canvas.pack(side="left", fill="both", expand=True)
|
||
scrollbar_effects.pack(side="right", fill="y")
|
||
|
||
# Fade effects
|
||
fade_frame = tk.LabelFrame(scrollable_effects_frame, text="🌅 Fade Effects", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
fade_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
fade_btn = tk.Button(fade_frame, text="🌅 Add Fade In/Out", command=self.apply_fade,
|
||
bg=self.colors['accent_blue'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
fade_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Text overlay
|
||
text_frame = tk.LabelFrame(scrollable_effects_frame, text="📝 Text Overlay", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
text_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
text_controls = tk.Frame(text_frame, bg=self.colors['bg_secondary'])
|
||
text_controls.pack(fill="x", padx=10, pady=5)
|
||
|
||
tk.Label(text_controls, text="Text:", font=self.fonts['caption'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w")
|
||
|
||
self.text_var = tk.StringVar(value="Sample Text")
|
||
text_entry = tk.Entry(text_controls, textvariable=self.text_var, font=self.fonts['body'],
|
||
width=25)
|
||
text_entry.pack(fill="x", pady=5)
|
||
|
||
text_btn = tk.Button(text_frame, text="📝 Add Text", command=self.apply_text,
|
||
bg=self.colors['accent_green'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
text_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
def create_audio_effects_tools(self, parent):
|
||
"""Create audio effects tools"""
|
||
# Create scrollable frame for audio effects
|
||
audio_canvas = tk.Canvas(parent, bg=self.colors['bg_secondary'], highlightthickness=0)
|
||
scrollbar_audio = tk.Scrollbar(parent, orient="vertical", command=audio_canvas.yview)
|
||
scrollable_audio_frame = tk.Frame(audio_canvas, bg=self.colors['bg_secondary'])
|
||
|
||
scrollable_audio_frame.bind(
|
||
"<Configure>",
|
||
lambda e: audio_canvas.configure(scrollregion=audio_canvas.bbox("all"))
|
||
)
|
||
|
||
audio_canvas.create_window((0, 0), window=scrollable_audio_frame, anchor="nw")
|
||
audio_canvas.configure(yscrollcommand=scrollbar_audio.set)
|
||
|
||
audio_canvas.pack(side="left", fill="both", expand=True)
|
||
scrollbar_audio.pack(side="right", fill="y")
|
||
|
||
# Volume controls (detailed)
|
||
volume_frame = tk.LabelFrame(scrollable_audio_frame, text="🔊 Volume Controls", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
volume_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Volume slider with fine control
|
||
self.audio_volume_var = tk.DoubleVar(value=1.0)
|
||
volume_scale = tk.Scale(volume_frame, from_=0.0, to=3.0, resolution=0.01,
|
||
orient="horizontal", variable=self.audio_volume_var,
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
highlightthickness=0, length=250)
|
||
volume_scale.pack(fill="x", pady=5, padx=10)
|
||
|
||
volume_btn = tk.Button(volume_frame, text="🔊 Apply Volume", command=self.apply_volume,
|
||
bg=self.colors['accent_blue'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
volume_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Audio info
|
||
info_frame = tk.LabelFrame(scrollable_audio_frame, text="ℹ️ Audio Information", font=self.fonts['body'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
info_frame.pack(fill="x", padx=10, pady=5)
|
||
|
||
info_text = tk.Label(info_frame,
|
||
text="Audio effects require external tools\nor MoviePy installation.\n\nFor advanced audio editing:\n• Audacity (free)\n• FFmpeg\n• pip install moviepy",
|
||
font=self.fonts['caption'], bg=self.colors['bg_secondary'],
|
||
fg=self.colors['text_secondary'], justify="left")
|
||
info_text.pack(padx=10, pady=5)
|
||
|
||
def create_export_tools(self, parent):
|
||
"""Create export tools"""
|
||
export_frame = tk.LabelFrame(parent, text="Export", font=self.fonts['heading'],
|
||
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
|
||
relief="flat", bd=1)
|
||
export_frame.pack(fill="x", padx=15, pady=5)
|
||
|
||
# Reset button
|
||
reset_btn = tk.Button(export_frame, text="🔄 Reset", command=self.reset_video,
|
||
bg=self.colors['accent_red'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
reset_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
# Export button
|
||
export_btn = tk.Button(export_frame, text="💾 Export Video", command=self.export_video,
|
||
bg=self.colors['accent_green'], fg='white', font=self.fonts['button'],
|
||
relief="flat", bd=0, cursor="hand2")
|
||
export_btn.pack(fill="x", padx=10, pady=5)
|
||
|
||
def select_video_file(self):
|
||
"""Select a video file to edit"""
|
||
# Check for videos in shorts folder first
|
||
if os.path.exists(self.shorts_folder):
|
||
video_files = [f for f in os.listdir(self.shorts_folder)
|
||
if f.lower().endswith(('.mp4', '.avi', '.mov', '.mkv'))]
|
||
|
||
if video_files:
|
||
# Show selection dialog for shorts
|
||
choice_window = tk.Toplevel(self.editor_window)
|
||
choice_window.title("Select Video to Edit")
|
||
choice_window.geometry("400x300")
|
||
choice_window.configure(bg=self.colors['bg_primary'])
|
||
choice_window.transient(self.editor_window)
|
||
choice_window.grab_set()
|
||
|
||
tk.Label(choice_window, text="Select a video to edit:",
|
||
font=self.fonts['heading'], bg=self.colors['bg_primary'],
|
||
fg=self.colors['text_primary']).pack(pady=10)
|
||
|
||
selected_file = None
|
||
|
||
def select_file(filename):
|
||
nonlocal selected_file
|
||
selected_file = os.path.join(self.shorts_folder, filename)
|
||
choice_window.destroy()
|
||
|
||
# List videos
|
||
for video_file in video_files:
|
||
btn = tk.Button(choice_window, text=f"📹 {video_file}",
|
||
command=lambda f=video_file: select_file(f),
|
||
bg=self.colors['accent_blue'], fg='white',
|
||
font=self.fonts['button'], relief="flat", bd=0,
|
||
cursor="hand2")
|
||
btn.pack(fill="x", padx=20, pady=2)
|
||
|
||
# Browse button
|
||
browse_btn = tk.Button(choice_window, text="📁 Browse Other Files",
|
||
command=lambda: self.browse_video_file(choice_window),
|
||
bg=self.colors['accent_orange'], fg='white',
|
||
font=self.fonts['button'], relief="flat", bd=0,
|
||
cursor="hand2")
|
||
browse_btn.pack(fill="x", padx=20, pady=10)
|
||
|
||
choice_window.wait_window()
|
||
|
||
if selected_file:
|
||
self.load_video(selected_file)
|
||
else:
|
||
self.browse_video_file()
|
||
else:
|
||
self.browse_video_file()
|
||
|
||
def browse_video_file(self, parent_window=None):
|
||
"""Browse for video file"""
|
||
filetypes = [
|
||
("Video files", "*.mp4 *.avi *.mov *.mkv *.wmv *.flv *.webm"),
|
||
("All files", "*.*")
|
||
]
|
||
|
||
file_path = filedialog.askopenfilename(
|
||
title="Select Video File",
|
||
filetypes=filetypes,
|
||
parent=parent_window or self.editor_window
|
||
)
|
||
|
||
if file_path:
|
||
if parent_window:
|
||
parent_window.destroy()
|
||
self.load_video(file_path)
|
||
|
||
def load_video(self, video_path):
|
||
"""Load a video for editing"""
|
||
try:
|
||
# Clean up previous video
|
||
if hasattr(self, 'current_clip') and self.current_clip:
|
||
if MOVIEPY_AVAILABLE:
|
||
self.current_clip.close()
|
||
else:
|
||
if hasattr(self.current_clip, 'release'):
|
||
self.current_clip.release()
|
||
|
||
# Load new video
|
||
self.current_video = video_path
|
||
|
||
if MOVIEPY_AVAILABLE:
|
||
# Use MoviePy for full functionality
|
||
self.current_clip = VideoFileClip(video_path)
|
||
self.video_duration = self.current_clip.duration
|
||
self.current_time = 0.0
|
||
|
||
# Display first frame
|
||
self.display_frame_at_time(0.0)
|
||
else:
|
||
# Use OpenCV for basic functionality
|
||
self.current_clip = cv2.VideoCapture(video_path)
|
||
if not self.current_clip.isOpened():
|
||
raise Exception("Could not open video file")
|
||
|
||
# Get video properties
|
||
fps = self.current_clip.get(cv2.CAP_PROP_FPS)
|
||
frame_count = self.current_clip.get(cv2.CAP_PROP_FRAME_COUNT)
|
||
self.video_duration = frame_count / fps if fps > 0 else 0
|
||
self.current_time = 0.0
|
||
|
||
# Display first frame
|
||
self.display_frame_at_time_opencv(0.0)
|
||
|
||
# Update UI
|
||
filename = os.path.basename(video_path)
|
||
self.current_file_label.config(text=filename)
|
||
|
||
# Update trim controls
|
||
self.trim_start_var.set(0.0)
|
||
self.trim_end_var.set(self.video_duration)
|
||
|
||
# Update timeline
|
||
self.update_timeline()
|
||
self.update_time_display()
|
||
|
||
backend = "MoviePy" if MOVIEPY_AVAILABLE else "OpenCV"
|
||
print(f"✅ Loaded video: {filename} ({self.video_duration:.1f}s) using {backend}")
|
||
|
||
if not MOVIEPY_AVAILABLE:
|
||
messagebox.showinfo("Limited Functionality",
|
||
"Video editor is running with limited functionality.\n" +
|
||
"Only basic playback and timeline controls are available.\n" +
|
||
"For full editing features, install MoviePy:\n" +
|
||
"pip install moviepy")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Load Error", f"Could not load video: {e}")
|
||
|
||
def display_frame_at_time_opencv(self, time_sec):
|
||
"""Display a specific frame using OpenCV"""
|
||
if not self.current_clip or not hasattr(self.current_clip, 'get'):
|
||
return
|
||
|
||
try:
|
||
# Calculate frame number
|
||
fps = self.current_clip.get(cv2.CAP_PROP_FPS)
|
||
frame_number = int(time_sec * fps)
|
||
|
||
# Set video position
|
||
self.current_clip.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
|
||
|
||
# Read frame
|
||
ret, frame = self.current_clip.read()
|
||
if not ret:
|
||
return
|
||
|
||
# Convert BGR to RGB
|
||
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
|
||
|
||
# Convert to PIL Image
|
||
pil_image = Image.fromarray(frame_rgb)
|
||
|
||
# Resize to fit canvas while maintaining aspect ratio
|
||
canvas_width = self.video_canvas.winfo_width()
|
||
canvas_height = self.video_canvas.winfo_height()
|
||
|
||
if canvas_width > 1 and canvas_height > 1:
|
||
# Calculate scaling to fit canvas
|
||
scale_w = canvas_width / pil_image.width
|
||
scale_h = canvas_height / pil_image.height
|
||
scale = min(scale_w, scale_h)
|
||
|
||
new_width = int(pil_image.width * scale)
|
||
new_height = int(pil_image.height * scale)
|
||
|
||
pil_image = pil_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
|
||
|
||
# Convert to PhotoImage
|
||
photo = ImageTk.PhotoImage(pil_image)
|
||
|
||
# Clear canvas and display image
|
||
self.video_canvas.delete("all")
|
||
x = canvas_width // 2
|
||
y = canvas_height // 2
|
||
self.video_canvas.create_image(x, y, image=photo)
|
||
|
||
# Keep reference to prevent garbage collection
|
||
self.video_canvas.image = photo
|
||
|
||
except Exception as e:
|
||
print(f"Frame display error: {e}")
|
||
|
||
def display_frame_at_time(self, time_sec):
|
||
"""Display a specific frame from the video"""
|
||
if not self.current_clip:
|
||
return
|
||
|
||
if MOVIEPY_AVAILABLE:
|
||
self.display_frame_at_time_moviepy(time_sec)
|
||
else:
|
||
self.display_frame_at_time_opencv(time_sec)
|
||
|
||
def display_frame_at_time_moviepy(self, time_sec):
|
||
"""Display a specific frame using MoviePy"""
|
||
try:
|
||
# Get frame at specified time
|
||
time_sec = max(0, min(time_sec, self.video_duration))
|
||
frame = self.current_clip.get_frame(time_sec)
|
||
|
||
# Convert to PIL Image
|
||
if frame.dtype != np.uint8:
|
||
frame = (frame * 255).astype(np.uint8)
|
||
|
||
pil_image = Image.fromarray(frame)
|
||
|
||
# Resize to fit canvas while maintaining aspect ratio
|
||
canvas_width = self.video_canvas.winfo_width()
|
||
canvas_height = self.video_canvas.winfo_height()
|
||
|
||
if canvas_width > 1 and canvas_height > 1:
|
||
# Calculate scaling to fit canvas
|
||
scale_w = canvas_width / pil_image.width
|
||
scale_h = canvas_height / pil_image.height
|
||
scale = min(scale_w, scale_h)
|
||
|
||
new_width = int(pil_image.width * scale)
|
||
new_height = int(pil_image.height * scale)
|
||
|
||
pil_image = pil_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
|
||
|
||
# Convert to PhotoImage
|
||
photo = ImageTk.PhotoImage(pil_image)
|
||
|
||
# Clear canvas and display image
|
||
self.video_canvas.delete("all")
|
||
x = canvas_width // 2
|
||
y = canvas_height // 2
|
||
self.video_canvas.create_image(x, y, image=photo)
|
||
|
||
# Keep reference to prevent garbage collection
|
||
self.video_canvas.image = photo
|
||
|
||
except Exception as e:
|
||
print(f"Frame display error: {e}")
|
||
|
||
def update_timeline(self):
|
||
"""Update the timeline display"""
|
||
if not self.timeline_canvas.winfo_exists():
|
||
return
|
||
|
||
self.timeline_canvas.delete("all")
|
||
|
||
if not self.current_clip:
|
||
return
|
||
|
||
canvas_width = self.timeline_canvas.winfo_width()
|
||
canvas_height = self.timeline_canvas.winfo_height()
|
||
|
||
if canvas_width <= 1:
|
||
return
|
||
|
||
# Calculate timeline scale
|
||
self.timeline_scale = (canvas_width - 40) / max(self.video_duration, 1)
|
||
|
||
# Draw timeline background
|
||
self.timeline_canvas.create_rectangle(20, 20, canvas_width - 20, canvas_height - 20,
|
||
fill=self.colors['bg_primary'], outline=self.colors['border'])
|
||
|
||
# Draw track road lines
|
||
self.draw_timeline_track_roads(canvas_width, canvas_height)
|
||
|
||
# Draw time markers
|
||
for i in range(0, int(self.video_duration) + 1):
|
||
x = 20 + i * self.timeline_scale
|
||
if x < canvas_width - 20:
|
||
self.timeline_canvas.create_line(x, 20, x, canvas_height - 20,
|
||
fill=self.colors['border'], width=1)
|
||
|
||
# Time labels
|
||
if i % 2 == 0: # Every 2 seconds
|
||
self.timeline_canvas.create_text(x, canvas_height - 35,
|
||
text=f"{i}s", fill=self.colors['text_secondary'],
|
||
font=self.fonts['caption'])
|
||
|
||
# Draw playhead
|
||
playhead_x = 20 + self.current_time * self.timeline_scale
|
||
self.timeline_canvas.create_line(playhead_x, 20, playhead_x, canvas_height - 20,
|
||
fill=self.colors['accent_blue'], width=3)
|
||
|
||
# Draw playhead handle
|
||
self.timeline_canvas.create_oval(playhead_x - 5, 15, playhead_x + 5, 25,
|
||
fill=self.colors['accent_blue'], outline='white')
|
||
|
||
def draw_timeline_track_roads(self, canvas_width, canvas_height):
|
||
"""Draw track road lines on timeline canvas"""
|
||
left_margin = 20
|
||
right_margin = 20
|
||
|
||
# Draw horizontal road lines for each track
|
||
for track_id, track_info in self.tracks.items():
|
||
y_pos = track_info['y_offset']
|
||
track_height = track_info['height']
|
||
|
||
# Top line of track
|
||
self.timeline_canvas.create_line(
|
||
left_margin, y_pos, canvas_width - right_margin, y_pos,
|
||
fill=self.colors['border'], width=1, tags="track_roads"
|
||
)
|
||
|
||
# Bottom line of track
|
||
self.timeline_canvas.create_line(
|
||
left_margin, y_pos + track_height, canvas_width - right_margin, y_pos + track_height,
|
||
fill=self.colors['border'], width=1, tags="track_roads"
|
||
)
|
||
|
||
# Track type indicator line (left edge with track color)
|
||
self.timeline_canvas.create_line(
|
||
left_margin, y_pos, left_margin, y_pos + track_height,
|
||
fill=track_info['color'], width=4, tags="track_roads"
|
||
)
|
||
|
||
# Track name label on the left
|
||
self.timeline_canvas.create_text(
|
||
left_margin + 50, y_pos + track_height // 2,
|
||
text=track_info['name'], fill=track_info['color'],
|
||
font=('Arial', 8, 'bold'), anchor="center", tags="track_roads"
|
||
)
|
||
|
||
def timeline_click(self, event):
|
||
"""Handle timeline click"""
|
||
if not self.current_clip:
|
||
return
|
||
|
||
canvas_width = self.timeline_canvas.winfo_width()
|
||
click_x = event.x
|
||
|
||
# Convert click position to time
|
||
relative_x = click_x - 20
|
||
if relative_x >= 0 and relative_x <= canvas_width - 40:
|
||
clicked_time = relative_x / self.timeline_scale
|
||
clicked_time = max(0, min(clicked_time, self.video_duration))
|
||
|
||
# Update current time and display
|
||
self.current_time = clicked_time
|
||
self.display_frame_at_time(self.current_time)
|
||
self.update_timeline()
|
||
self.update_time_display()
|
||
|
||
def timeline_drag(self, event):
|
||
"""Handle timeline dragging"""
|
||
self.timeline_click(event) # Same behavior as click for now
|
||
|
||
def on_timeline_drag_end(self, event):
|
||
"""End timeline drag operation"""
|
||
if hasattr(self, 'dragging_clip') and self.dragging_clip:
|
||
print(f"🎬 Moved clip '{self.dragging_clip['name']}' to {self.dragging_clip['start_time']:.2f}s")
|
||
|
||
# Clear drag state
|
||
if hasattr(self, 'dragging_clip'):
|
||
self.dragging_clip = None
|
||
if hasattr(self, 'drag_start_x'):
|
||
self.drag_start_x = None
|
||
if hasattr(self, 'drag_start_time'):
|
||
self.drag_start_time = None
|
||
if hasattr(self, 'drag_offset'):
|
||
self.drag_offset = 0
|
||
|
||
def on_timeline_right_click(self, event):
|
||
"""Handle right-click context menu"""
|
||
try:
|
||
canvas_x = self.timeline_canvas.canvasx(event.x)
|
||
canvas_y = self.timeline_canvas.canvasy(event.y)
|
||
clicked_clip = self.get_clip_at_position(canvas_x, canvas_y) if hasattr(self, 'get_clip_at_position') else None
|
||
|
||
# Create context menu
|
||
context_menu = tk.Menu(self.root, tearoff=0, bg=self.colors['bg_secondary'],
|
||
fg=self.colors['text_primary'])
|
||
|
||
if clicked_clip:
|
||
# Clip context menu
|
||
self.selected_clip = clicked_clip
|
||
context_menu.add_command(label=f"Cut '{clicked_clip['name']}'",
|
||
command=lambda: self.cut_clip_at_playhead())
|
||
context_menu.add_command(label=f"Delete '{clicked_clip['name']}'",
|
||
command=lambda: self.delete_clip(clicked_clip))
|
||
context_menu.add_separator()
|
||
context_menu.add_command(label="Duplicate Clip",
|
||
command=lambda: self.duplicate_clip(clicked_clip))
|
||
context_menu.add_command(label="Properties",
|
||
command=lambda: self.show_clip_properties(clicked_clip))
|
||
else:
|
||
# Timeline context menu
|
||
click_time = canvas_x / self.timeline_scale if hasattr(self, 'timeline_scale') else 0
|
||
context_menu.add_command(label="Add Marker",
|
||
command=lambda: self.add_marker_at_time(click_time))
|
||
context_menu.add_command(label="Zoom to Fit", command=self.zoom_to_fit)
|
||
|
||
try:
|
||
context_menu.tk_popup(event.x_root, event.y_root)
|
||
finally:
|
||
context_menu.grab_release()
|
||
except Exception as e:
|
||
print(f"Context menu error: {e}")
|
||
|
||
def on_timeline_double_click(self, event):
|
||
"""Handle timeline double-click"""
|
||
try:
|
||
canvas_x = self.timeline_canvas.canvasx(event.x)
|
||
canvas_y = self.timeline_canvas.canvasy(event.y)
|
||
clicked_clip = self.get_clip_at_position(canvas_x, canvas_y) if hasattr(self, 'get_clip_at_position') else None
|
||
|
||
if clicked_clip:
|
||
self.show_clip_properties(clicked_clip)
|
||
else:
|
||
# Add marker on double-click
|
||
click_time = canvas_x / self.timeline_scale if hasattr(self, 'timeline_scale') else 0
|
||
self.add_marker_at_time(click_time)
|
||
except Exception as e:
|
||
print(f"Double-click error: {e}")
|
||
|
||
def update_time_display(self):
|
||
"""Update the time display"""
|
||
current_min = int(self.current_time // 60)
|
||
current_sec = int(self.current_time % 60)
|
||
total_min = int(self.video_duration // 60)
|
||
total_sec = int(self.video_duration % 60)
|
||
|
||
time_text = f"{current_min:02d}:{current_sec:02d} / {total_min:02d}:{total_sec:02d}"
|
||
self.time_display.config(text=time_text)
|
||
|
||
def timeline_play(self):
|
||
"""Start timeline playback"""
|
||
if not self.current_clip:
|
||
return
|
||
|
||
self.timeline_is_playing = True
|
||
self.play_video() # Start actual video playback
|
||
self._start_timeline_playback()
|
||
|
||
def timeline_pause(self):
|
||
"""Pause timeline playback"""
|
||
self.timeline_is_playing = False
|
||
self.pause_video() # Pause actual video
|
||
|
||
def timeline_stop(self):
|
||
"""Stop timeline playback"""
|
||
self.timeline_is_playing = False
|
||
self.stop_video() # Stop actual video
|
||
self.current_time = 0.0
|
||
self.display_frame_at_time(0.0)
|
||
self.update_timeline()
|
||
self.update_time_display()
|
||
|
||
def _start_timeline_playback(self):
|
||
"""Start the timeline playback loop"""
|
||
def playback_loop():
|
||
while self.timeline_is_playing and self.current_time < self.video_duration:
|
||
if not self.is_playing: # Sync with video player state
|
||
break
|
||
|
||
# Update timeline display
|
||
self.editor_window.after(0, self.update_timeline)
|
||
self.editor_window.after(0, self.update_time_display)
|
||
|
||
time.sleep(1/30) # 30 FPS update rate
|
||
|
||
# Playback finished
|
||
self.timeline_is_playing = False
|
||
|
||
if not hasattr(self, 'timeline_thread') or not self.timeline_thread.is_alive():
|
||
self.timeline_thread = threading.Thread(target=playback_loop, daemon=True)
|
||
self.timeline_thread.start()
|
||
|
||
def play_video(self):
|
||
"""Start video playback"""
|
||
if not self.current_clip or self.is_playing:
|
||
return
|
||
|
||
self.is_playing = True
|
||
|
||
def play_thread():
|
||
start_time = time.time()
|
||
start_video_time = self.current_time
|
||
|
||
while self.is_playing and self.current_time < self.video_duration:
|
||
try:
|
||
# Calculate current video time
|
||
elapsed = time.time() - start_time
|
||
self.current_time = start_video_time + elapsed
|
||
|
||
if self.current_time >= self.video_duration:
|
||
self.current_time = self.video_duration
|
||
self.is_playing = False
|
||
break
|
||
|
||
# Update display
|
||
self.display_frame_at_time(self.current_time)
|
||
self.update_time_display()
|
||
|
||
# Frame rate control (approximately 30 FPS)
|
||
time.sleep(1/30)
|
||
|
||
except Exception as e:
|
||
print(f"⚠️ Playback error: {e}")
|
||
break
|
||
|
||
# Playback finished
|
||
self.is_playing = False
|
||
|
||
self.play_thread = threading.Thread(target=play_thread, daemon=True)
|
||
self.play_thread.start()
|
||
|
||
def pause_video(self):
|
||
"""Pause video playback"""
|
||
self.is_playing = False
|
||
|
||
def stop_video(self):
|
||
"""Stop video and return to beginning"""
|
||
self.is_playing = False
|
||
self.current_time = 0.0
|
||
self.display_frame_at_time(0.0)
|
||
|
||
def apply_trim(self):
|
||
"""Apply trim to the video"""
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
start_time = self.trim_start_var.get()
|
||
end_time = self.trim_end_var.get()
|
||
|
||
if start_time >= end_time:
|
||
messagebox.showerror("Invalid Range", "Start time must be less than end time.")
|
||
return
|
||
|
||
if end_time > self.video_duration:
|
||
messagebox.showerror("Invalid Range", f"End time cannot exceed video duration ({self.video_duration:.1f}s).")
|
||
return
|
||
|
||
try:
|
||
if MOVIEPY_AVAILABLE and hasattr(self.current_clip, 'subclipped'):
|
||
# Apply trim using MoviePy
|
||
self.current_clip = self.current_clip.subclipped(start_time, end_time)
|
||
self.video_duration = self.current_clip.duration
|
||
self.current_time = 0.0
|
||
|
||
# Update UI
|
||
self.trim_end_var.set(self.video_duration)
|
||
self.display_frame_at_time(0.0)
|
||
self.update_timeline()
|
||
self.update_time_display()
|
||
messagebox.showinfo("Success", f"Video trimmed to {start_time:.1f}s - {end_time:.1f}s")
|
||
else:
|
||
# OpenCV mode - export trimmed video
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video file loaded.")
|
||
return
|
||
|
||
timestamp = datetime.now().strftime("%H%M%S")
|
||
base_name = os.path.splitext(os.path.basename(self.current_video))[0]
|
||
output_path = os.path.join(os.path.dirname(self.current_video),
|
||
f"{base_name}_trimmed_{timestamp}.mp4")
|
||
|
||
self.apply_trim_opencv(self.current_video, output_path, start_time, end_time)
|
||
self.load_video(output_path)
|
||
messagebox.showinfo("Success", f"Video trimmed ({start_time:.1f}s to {end_time:.1f}s) and saved as:\n{os.path.basename(output_path)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Trim Error", f"Could not trim video: {e}")
|
||
|
||
def apply_trim_opencv(self, input_path, output_path, start_time, end_time):
|
||
"""Apply trim using OpenCV"""
|
||
cap = cv2.VideoCapture(input_path)
|
||
fps = cap.get(cv2.CAP_PROP_FPS)
|
||
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
||
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
||
|
||
start_frame = int(start_time * fps)
|
||
end_frame = int(end_time * fps)
|
||
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
|
||
out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
|
||
|
||
# Set to start frame
|
||
cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
|
||
|
||
frame_count = start_frame
|
||
while frame_count < end_frame:
|
||
ret, frame = cap.read()
|
||
if not ret:
|
||
break
|
||
|
||
out.write(frame)
|
||
frame_count += 1
|
||
|
||
cap.release()
|
||
out.release()
|
||
|
||
def apply_speed(self):
|
||
"""Apply speed change to the video"""
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
speed_factor = self.speed_var.get()
|
||
|
||
try:
|
||
if MOVIEPY_AVAILABLE and hasattr(self.current_clip, 'with_fps'):
|
||
# Apply speed change using MoviePy
|
||
if speed_factor > 1:
|
||
# Speed up
|
||
self.current_clip = self.current_clip.with_fps(self.current_clip.fps * speed_factor)
|
||
self.current_clip = self.current_clip.subclipped(0, self.current_clip.duration / speed_factor)
|
||
else:
|
||
# Slow down
|
||
self.current_clip = self.current_clip.with_fps(self.current_clip.fps * speed_factor)
|
||
|
||
self.video_duration = self.current_clip.duration
|
||
self.current_time = 0.0
|
||
|
||
# Update UI
|
||
self.trim_end_var.set(self.video_duration)
|
||
self.display_frame_at_time(0.0)
|
||
self.update_timeline()
|
||
self.update_time_display()
|
||
messagebox.showinfo("Success", f"Speed changed to {speed_factor:.1f}x")
|
||
else:
|
||
# OpenCV mode - export video with speed change
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video file loaded.")
|
||
return
|
||
|
||
timestamp = datetime.now().strftime("%H%M%S")
|
||
base_name = os.path.splitext(os.path.basename(self.current_video))[0]
|
||
output_path = os.path.join(os.path.dirname(self.current_video),
|
||
f"{base_name}_speed_{speed_factor}x_{timestamp}.mp4")
|
||
|
||
self.apply_speed_opencv(self.current_video, output_path, speed_factor)
|
||
self.load_video(output_path)
|
||
messagebox.showinfo("Success", f"Speed changed to {speed_factor:.1f}x and saved as:\n{os.path.basename(output_path)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Speed Error", f"Could not change speed: {e}")
|
||
|
||
def apply_speed_opencv(self, input_path, output_path, speed_factor):
|
||
"""Apply speed change using OpenCV"""
|
||
cap = cv2.VideoCapture(input_path)
|
||
fps = cap.get(cv2.CAP_PROP_FPS)
|
||
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
||
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
||
|
||
# Calculate new FPS for speed change
|
||
new_fps = fps * speed_factor
|
||
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
|
||
out = cv2.VideoWriter(output_path, fourcc, new_fps, (width, height))
|
||
|
||
while True:
|
||
ret, frame = cap.read()
|
||
if not ret:
|
||
break
|
||
|
||
out.write(frame)
|
||
|
||
cap.release()
|
||
out.release()
|
||
|
||
def apply_volume(self):
|
||
"""Apply volume adjustment"""
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
# Check for volume factor from either basic or audio effects tab
|
||
volume_factor = 1.0
|
||
if hasattr(self, 'audio_volume_var'):
|
||
volume_factor = self.audio_volume_var.get()
|
||
elif hasattr(self, 'volume_var'):
|
||
volume_factor = self.volume_var.get()
|
||
|
||
try:
|
||
if MOVIEPY_AVAILABLE and hasattr(self.current_clip, 'audio'):
|
||
# Use MoviePy for volume adjustment
|
||
if not self.current_clip.audio:
|
||
messagebox.showwarning("No Audio", "This video has no audio track.")
|
||
return
|
||
|
||
self.current_clip = self.current_clip.with_effects([MultiplyVolume(volume_factor)])
|
||
messagebox.showinfo("Success", f"Volume adjusted to {volume_factor:.1f}x")
|
||
else:
|
||
# OpenCV mode - show helpful message about audio processing
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video file loaded.")
|
||
return
|
||
|
||
messagebox.showinfo("Audio Processing",
|
||
f"Volume adjustment to {volume_factor:.1f}x noted.\n\n"
|
||
"Audio processing requires external tools.\n"
|
||
"For audio editing, consider using:\n"
|
||
"• Audacity (free audio editor)\n"
|
||
"• FFmpeg command line\n"
|
||
"• Install MoviePy: pip install moviepy")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Volume Error", f"Could not adjust volume: {e}")
|
||
|
||
def apply_fade(self):
|
||
"""Apply fade in/out effects"""
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
try:
|
||
if MOVIEPY_AVAILABLE and hasattr(self.current_clip, 'fadein'):
|
||
# Use MoviePy for advanced fade effects
|
||
fade_duration = min(1.0, self.video_duration / 4)
|
||
|
||
if hasattr(self.current_clip, 'fadein') and hasattr(self.current_clip, 'fadeout'):
|
||
self.current_clip = self.current_clip.fadein(fade_duration).fadeout(fade_duration)
|
||
messagebox.showinfo("Success", f"Fade effects applied ({fade_duration:.1f}s)")
|
||
else:
|
||
messagebox.showinfo("Not Available", "Fade effects not available in this MoviePy version")
|
||
else:
|
||
# OpenCV mode - export video with fade effect
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video file loaded.")
|
||
return
|
||
|
||
timestamp = datetime.now().strftime("%H%M%S")
|
||
base_name = os.path.splitext(os.path.basename(self.current_video))[0]
|
||
output_path = os.path.join(os.path.dirname(self.current_video),
|
||
f"{base_name}_faded_{timestamp}.mp4")
|
||
|
||
self.apply_fade_opencv(self.current_video, output_path)
|
||
self.load_video(output_path)
|
||
messagebox.showinfo("Success", f"Fade effects applied and saved as:\n{os.path.basename(output_path)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Fade Error", f"Could not apply fade effects: {e}")
|
||
|
||
def apply_fade_opencv(self, input_path, output_path):
|
||
"""Apply fade effects using OpenCV"""
|
||
cap = cv2.VideoCapture(input_path)
|
||
fps = cap.get(cv2.CAP_PROP_FPS)
|
||
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
||
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
||
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
|
||
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
|
||
out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
|
||
|
||
# Calculate fade frames (1 second fade in/out)
|
||
fade_frames = min(int(fps), total_frames // 4)
|
||
|
||
frame_count = 0
|
||
while True:
|
||
ret, frame = cap.read()
|
||
if not ret:
|
||
break
|
||
|
||
# Apply fade in
|
||
if frame_count < fade_frames:
|
||
alpha = frame_count / fade_frames
|
||
frame = cv2.convertScaleAbs(frame, alpha=alpha, beta=0)
|
||
|
||
# Apply fade out
|
||
elif frame_count >= total_frames - fade_frames:
|
||
alpha = (total_frames - frame_count) / fade_frames
|
||
frame = cv2.convertScaleAbs(frame, alpha=alpha, beta=0)
|
||
|
||
out.write(frame)
|
||
frame_count += 1
|
||
|
||
cap.release()
|
||
out.release()
|
||
|
||
def apply_text(self):
|
||
"""Apply text overlay"""
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
# Get text from the text variable
|
||
text_content = self.text_var.get().strip() if hasattr(self, 'text_var') and self.text_var.get().strip() else "Sample Text"
|
||
|
||
if not text_content:
|
||
messagebox.showwarning("No Text", "Please enter text to overlay.")
|
||
return
|
||
|
||
try:
|
||
if MOVIEPY_AVAILABLE and hasattr(self.current_clip, 'duration'):
|
||
# Use MoviePy for text overlay
|
||
text_clip = TextClip(text_content, fontsize=50, color='white', font='Arial-Bold')
|
||
text_clip = text_clip.with_duration(self.current_clip.duration)
|
||
text_clip = text_clip.with_position(('center', 'bottom'))
|
||
|
||
# Composite with video
|
||
self.current_clip = CompositeVideoClip([self.current_clip, text_clip])
|
||
messagebox.showinfo("Success", f"Text overlay added: '{text_content}'")
|
||
else:
|
||
# OpenCV mode - export video with text overlay
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video file loaded.")
|
||
return
|
||
|
||
timestamp = datetime.now().strftime("%H%M%S")
|
||
base_name = os.path.splitext(os.path.basename(self.current_video))[0]
|
||
output_path = os.path.join(os.path.dirname(self.current_video),
|
||
f"{base_name}_with_text_{timestamp}.mp4")
|
||
|
||
self.apply_text_opencv(self.current_video, output_path, text_content)
|
||
self.load_video(output_path)
|
||
messagebox.showinfo("Success", f"Text '{text_content}' added and saved as:\n{os.path.basename(output_path)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Text Error", f"Could not add text overlay: {e}")
|
||
|
||
def apply_text_opencv(self, input_path, output_path, text):
|
||
"""Apply text overlay using OpenCV"""
|
||
cap = cv2.VideoCapture(input_path)
|
||
fps = cap.get(cv2.CAP_PROP_FPS)
|
||
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
||
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
||
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
|
||
out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
|
||
|
||
# Text settings
|
||
font = cv2.FONT_HERSHEY_SIMPLEX
|
||
font_scale = min(width, height) / 800 # Scale font based on video size
|
||
color = (255, 255, 255) # White color
|
||
thickness = max(1, int(font_scale * 2))
|
||
|
||
# Get text size for positioning
|
||
(text_width, text_height), baseline = cv2.getTextSize(text, font, font_scale, thickness)
|
||
x = (width - text_width) // 2
|
||
y = height - 50 # Bottom position
|
||
|
||
while True:
|
||
ret, frame = cap.read()
|
||
if not ret:
|
||
break
|
||
|
||
# Add black outline for better visibility
|
||
cv2.putText(frame, text, (x-2, y-2), font, font_scale, (0, 0, 0), thickness+2, cv2.LINE_AA)
|
||
cv2.putText(frame, text, (x+2, y+2), font, font_scale, (0, 0, 0), thickness+2, cv2.LINE_AA)
|
||
|
||
# Add white text
|
||
cv2.putText(frame, text, (x, y), font, font_scale, color, thickness, cv2.LINE_AA)
|
||
|
||
out.write(frame)
|
||
|
||
cap.release()
|
||
out.release()
|
||
|
||
def apply_resize(self, target_width, target_height):
|
||
"""Apply resize to video"""
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
try:
|
||
if MOVIEPY_AVAILABLE and hasattr(self.current_clip, 'resize'):
|
||
# Use MoviePy for resizing
|
||
self.current_clip = self.current_clip.resize((target_width, target_height))
|
||
messagebox.showinfo("Success", f"Video resized to {target_width}x{target_height}")
|
||
else:
|
||
# OpenCV mode - export resized video
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video file loaded.")
|
||
return
|
||
|
||
timestamp = datetime.now().strftime("%H%M%S")
|
||
base_name = os.path.splitext(os.path.basename(self.current_video))[0]
|
||
output_path = os.path.join(os.path.dirname(self.current_video),
|
||
f"{base_name}_resized_{target_width}x{target_height}_{timestamp}.mp4")
|
||
|
||
self.apply_resize_opencv(self.current_video, output_path, target_width, target_height)
|
||
self.load_video(output_path)
|
||
messagebox.showinfo("Success", f"Video resized to {target_width}x{target_height} and saved as:\n{os.path.basename(output_path)}")
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Resize Error", f"Could not resize video: {e}")
|
||
|
||
def apply_resize_opencv(self, input_path, output_path, target_width, target_height):
|
||
"""Apply resize using OpenCV"""
|
||
cap = cv2.VideoCapture(input_path)
|
||
fps = cap.get(cv2.CAP_PROP_FPS)
|
||
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
|
||
out = cv2.VideoWriter(output_path, fourcc, fps, (target_width, target_height))
|
||
|
||
while True:
|
||
ret, frame = cap.read()
|
||
if not ret:
|
||
break
|
||
|
||
# Resize frame
|
||
resized_frame = cv2.resize(frame, (target_width, target_height))
|
||
out.write(resized_frame)
|
||
|
||
cap.release()
|
||
out.release()
|
||
|
||
def reset_video(self):
|
||
"""Reset video to original state"""
|
||
if not self.current_video:
|
||
messagebox.showwarning("No Video", "No video loaded.")
|
||
return
|
||
|
||
if messagebox.askyesno("Reset Video", "Reset all changes and reload original video?"):
|
||
self.load_video(self.current_video)
|
||
|
||
def export_video(self):
|
||
"""Export the edited video"""
|
||
if not MOVIEPY_AVAILABLE:
|
||
messagebox.showwarning("Feature Unavailable",
|
||
"Video export requires MoviePy.\nInstall with: pip install moviepy")
|
||
return
|
||
|
||
if not self.current_clip:
|
||
messagebox.showwarning("No Video", "Please load a video first.")
|
||
return
|
||
|
||
# Get output filename
|
||
timestamp = datetime.now().strftime("%H%M%S")
|
||
default_name = f"edited_video_{timestamp}.mp4"
|
||
|
||
output_path = filedialog.asksaveasfilename(
|
||
title="Save Edited Video",
|
||
defaultextension=".mp4",
|
||
filetypes=[("MP4 files", "*.mp4"), ("All files", "*.*")],
|
||
initialname=default_name
|
||
)
|
||
|
||
if not output_path:
|
||
return
|
||
|
||
# Create progress window
|
||
progress_window = tk.Toplevel(self.editor_window)
|
||
progress_window.title("Exporting Video")
|
||
progress_window.geometry("400x150")
|
||
progress_window.configure(bg=self.colors['bg_primary'])
|
||
progress_window.transient(self.editor_window)
|
||
progress_window.grab_set()
|
||
|
||
progress_label = tk.Label(progress_window, text="Exporting video...",
|
||
font=self.fonts['body'], bg=self.colors['bg_primary'],
|
||
fg=self.colors['text_primary'])
|
||
progress_label.pack(pady=20)
|
||
|
||
progress_bar = ttk.Progressbar(progress_window, mode='indeterminate')
|
||
progress_bar.pack(pady=10, padx=20, fill="x")
|
||
progress_bar.start()
|
||
|
||
def export_thread():
|
||
try:
|
||
# Export video
|
||
self.current_clip.write_videofile(
|
||
output_path,
|
||
codec="libx264",
|
||
audio_codec="aac",
|
||
verbose=False,
|
||
logger=None
|
||
)
|
||
|
||
def show_success():
|
||
progress_window.destroy()
|
||
messagebox.showinfo("Export Complete", f"Video exported successfully!\n\nSaved to: {output_path}")
|
||
|
||
self.editor_window.after(0, show_success)
|
||
|
||
except Exception as e:
|
||
def show_error():
|
||
progress_window.destroy()
|
||
messagebox.showerror("Export Error", f"Could not export video: {e}")
|
||
|
||
self.editor_window.after(0, show_error)
|
||
|
||
# Start export in background thread
|
||
threading.Thread(target=export_thread, daemon=True).start()
|
||
|
||
# Professional timeline helper methods
|
||
def get_clip_at_position(self, x, y):
|
||
"""Get the clip at the given canvas position"""
|
||
time_pos = x / self.timeline_scale
|
||
|
||
for clip in self.timeline_clips:
|
||
if clip['start_time'] <= time_pos <= clip['end_time']:
|
||
# Check if Y position is within the clip's track
|
||
track_info = self.tracks[clip['track']]
|
||
if track_info['y_offset'] <= y <= track_info['y_offset'] + track_info['height']:
|
||
return clip
|
||
return None
|
||
|
||
def snap_to_grid(self, time_value):
|
||
"""Snap time value to grid"""
|
||
if self.snap_enabled and self.grid_size > 0:
|
||
return round(time_value / self.grid_size) * self.grid_size
|
||
return time_value
|
||
|
||
def magnetic_snap(self, new_time, dragging_clip):
|
||
"""Apply magnetic timeline snapping to other clips"""
|
||
if not self.magnetic_timeline:
|
||
return new_time
|
||
|
||
snap_distance = 0.2 # 200ms snap distance
|
||
clip_duration = dragging_clip['end_time'] - dragging_clip['start_time']
|
||
|
||
for clip in self.timeline_clips:
|
||
if clip == dragging_clip or clip['track'] != dragging_clip['track']:
|
||
continue
|
||
|
||
# Snap to start of other clips
|
||
if abs(new_time - clip['start_time']) < snap_distance:
|
||
return clip['start_time']
|
||
|
||
# Snap to end of other clips
|
||
if abs(new_time - clip['end_time']) < snap_distance:
|
||
return clip['end_time']
|
||
|
||
# Snap end of dragging clip to start of other clips
|
||
if abs((new_time + clip_duration) - clip['start_time']) < snap_distance:
|
||
return clip['start_time'] - clip_duration
|
||
|
||
return new_time
|
||
|
||
def cut_clip_at_position(self, clip, cut_time):
|
||
"""Cut a clip at the specified time"""
|
||
if cut_time <= clip['start_time'] or cut_time >= clip['end_time']:
|
||
return
|
||
|
||
# Create two new clips
|
||
first_clip = clip.copy()
|
||
first_clip['id'] = len(self.timeline_clips) + 1
|
||
first_clip['end_time'] = cut_time
|
||
first_clip['name'] = f"{clip['name']} (1)"
|
||
|
||
second_clip = clip.copy()
|
||
second_clip['id'] = len(self.timeline_clips) + 2
|
||
second_clip['start_time'] = cut_time
|
||
second_clip['name'] = f"{clip['name']} (2)"
|
||
|
||
# Remove original clip and add new ones
|
||
self.timeline_clips.remove(clip)
|
||
self.timeline_clips.extend([first_clip, second_clip])
|
||
|
||
self.selected_clip = first_clip
|
||
self.update_timeline()
|
||
print(f"✂️ Cut clip at {cut_time:.2f}s")
|
||
|
||
def cut_clip_at_playhead(self):
|
||
"""Cut selected clip at current playhead position"""
|
||
if self.selected_clip:
|
||
self.cut_clip_at_position(self.selected_clip, self.current_time)
|
||
|
||
def delete_clip(self, clip):
|
||
"""Delete a clip from timeline"""
|
||
if clip in self.timeline_clips:
|
||
self.timeline_clips.remove(clip)
|
||
if self.selected_clip == clip:
|
||
self.selected_clip = None
|
||
self.update_timeline()
|
||
print(f"🗑️ Deleted clip: {clip['name']}")
|
||
|
||
def duplicate_clip(self, clip):
|
||
"""Duplicate a clip"""
|
||
new_clip = clip.copy()
|
||
new_clip['id'] = len(self.timeline_clips) + 1
|
||
new_clip['name'] = f"{clip['name']} (Copy)"
|
||
|
||
# Place after original clip
|
||
duration = clip['end_time'] - clip['start_time']
|
||
new_clip['start_time'] = clip['end_time']
|
||
new_clip['end_time'] = clip['end_time'] + duration
|
||
|
||
self.timeline_clips.append(new_clip)
|
||
self.selected_clip = new_clip
|
||
self.update_timeline()
|
||
print(f"📄 Duplicated clip: {new_clip['name']}")
|
||
|
||
def add_marker_at_time(self, time):
|
||
"""Add a marker at specified time"""
|
||
marker = {
|
||
'time': time,
|
||
'name': f"Marker {len(self.markers) + 1}",
|
||
'color': '#ffeb3b'
|
||
}
|
||
self.markers.append(marker)
|
||
self.update_timeline()
|
||
print(f"📍 Added marker at {time:.2f}s")
|
||
|
||
def show_clip_properties(self, clip):
|
||
"""Show clip properties dialog"""
|
||
props_window = tk.Toplevel(self.root)
|
||
props_window.title(f"Clip Properties - {clip['name']}")
|
||
props_window.configure(bg=self.colors['bg_primary'])
|
||
props_window.geometry("400x300")
|
||
|
||
# Clip info
|
||
tk.Label(props_window, text=f"Clip: {clip['name']}",
|
||
font=self.fonts['heading'], bg=self.colors['bg_primary'],
|
||
fg=self.colors['text_primary']).pack(pady=10)
|
||
|
||
info_frame = tk.Frame(props_window, bg=self.colors['bg_primary'])
|
||
info_frame.pack(fill='x', padx=20)
|
||
|
||
# Duration, start time, etc.
|
||
duration = clip['end_time'] - clip['start_time']
|
||
tk.Label(info_frame, text=f"Duration: {duration:.2f}s",
|
||
bg=self.colors['bg_primary'], fg=self.colors['text_secondary']).pack(anchor='w')
|
||
tk.Label(info_frame, text=f"Start: {clip['start_time']:.2f}s",
|
||
bg=self.colors['bg_primary'], fg=self.colors['text_secondary']).pack(anchor='w')
|
||
tk.Label(info_frame, text=f"End: {clip['end_time']:.2f}s",
|
||
bg=self.colors['bg_primary'], fg=self.colors['text_secondary']).pack(anchor='w')
|
||
tk.Label(info_frame, text=f"Track: {clip['track']}",
|
||
bg=self.colors['bg_primary'], fg=self.colors['text_secondary']).pack(anchor='w')
|
||
|
||
def zoom_to_fit(self):
|
||
"""Zoom timeline to fit all content"""
|
||
if not self.timeline_clips:
|
||
return
|
||
|
||
# Find the last clip end time
|
||
max_time = max(clip['end_time'] for clip in self.timeline_clips)
|
||
canvas_width = self.timeline_canvas.winfo_width()
|
||
|
||
if max_time > 0 and canvas_width > 100:
|
||
zoom_level = (canvas_width - 100) / (max_time * 50) # 50 is base scale
|
||
self.zoom_var.set(max(0.1, min(5.0, zoom_level)))
|
||
self.on_zoom_change(zoom_level)
|
||
print(f"🔍 Zoomed to fit content ({zoom_level:.1f}x)")
|
||
|
||
def open_shorts_editor(shorts_folder="shorts"):
|
||
"""Open the shorts editor as a standalone application"""
|
||
editor = ShortsEditorGUI(shorts_folder=shorts_folder)
|
||
editor.open_editor()
|
||
|
||
if __name__ == "__main__":
|
||
# Run as standalone application
|
||
open_shorts_editor()
|