klop51/ShortGenerator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add modern thumbnail editor with advanced UI and editing features

Browse Source 
- Implemented a new thumbnail editor using Tkinter and MoviePy
- Added functionality to load video files and capture frames
- Created a modern user interface with a dark theme and responsive design
- Included tools for adding text and stickers to thumbnails
- Implemented export options for saving edited thumbnails
- Added default emoji stickers and functionality to load custom stickers
- Enhanced user experience with hover effects and modern button styles
This commit is contained in:
klop51 2025-08-10 14:11:18 +02:00
parent 610aa299ef
commit 6bb356948d
5 changed files with 2369 additions and 718 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
MODERNIZATION_COMPLETE.md Normal file
View File

@ -0,0 +1,128 @@
# 🎨 Modern UI Modernization Complete!
## ✅ Successfully Updated Files
### 1. **Main.py** - ✅ FULLY MODERNIZED
- **Dark Theme**: Professional dark color scheme (#1a1a1a, #2d2d2d, #3d3d3d)
- **Modern Typography**: Segoe UI font family with size hierarchy
- **Card-Based Layout**: Elegant card containers with shadows and spacing
- **Responsive Design**: Grid-based layout that scales with window size
- **Hover Effects**: Interactive button states and animations
- **Modern Buttons**: Flat design with accent colors and hover states
### 2. **shorts_generator2.py** - ✅ FULLY MODERNIZED
- **Modern Color Palette**: Consistent dark theme across all components
- **Card Interface**: Settings panels organized in modern card layouts
- **Progress Indicators**: Styled progress bars with modern aesthetics
- **Action Buttons**: Professional button styling with color-coded actions
- **Responsive Controls**: Grid layouts that adapt to window resizing
- **Modern Typography**: Clear font hierarchy for better readability
### 3. **thumbnail_editor.py** - ✅ COMPLETELY REDESIGNED
- **Professional Interface**: Canvas-based editing with modern controls
- **Dark Theme Editor**: Black canvas background with light UI elements
- **Card-Based Tools**: Text tools, stickers, and export options in cards
- **Timeline Slider**: Modern styled timeline for frame selection
- **Interactive Elements**: Drag-and-drop functionality with visual feedback
- **Modern Buttons**: Color-coded actions (blue, green, orange, purple, red)
## 🎯 Key Improvements Implemented
### Design System
```python
colors = {
'bg_primary': '#1a1a1a', # Dark background
'bg_secondary': '#2d2d2d', # Card backgrounds
'bg_tertiary': '#3d3d3d', # Elevated elements
'accent_blue': '#007acc', # Primary actions
'accent_green': '#28a745', # Success states
'accent_orange': '#fd7e14', # Warning actions
'accent_purple': '#6f42c1', # Secondary actions
'accent_red': '#dc3545', # Danger actions
'text_primary': '#ffffff', # Primary text
'text_secondary': '#b8b8b8', # Secondary text
'text_muted': '#6c757d' # Muted text
}
```
### Typography System
```python
fonts = {
'title': ('Segoe UI', 18, 'bold'), # Main titles
'heading': ('Segoe UI', 14, 'bold'), # Section headers
'subheading': ('Segoe UI', 12, 'bold'), # Card titles
'body': ('Segoe UI', 10), # Body text
'caption': ('Segoe UI', 9), # Small text
'button': ('Segoe UI', 10, 'bold') # Button text
}
```
### Responsive Features
- **Window Resize Handling**: All layouts adapt to different window sizes
- **Minimum Size Constraints**: Prevents UI from becoming too small
- **Grid Weight Configuration**: Proper expansion and contraction
- **Proportional Scaling**: Elements maintain proper relationships
### Modern UI Components
- **Card Containers**: Elevated surfaces with consistent padding
- **Hover Effects**: Interactive feedback on all clickable elements
- **Modern Buttons**: Flat design with semantic color coding
- **Progress Indicators**: Styled progress bars and status displays
- **Dark Theme**: Professional dark interface throughout
## 🚀 Features Enhanced
### Main Application (Main.py)
- Modern welcome screen with card-based navigation
- Responsive layout with proper spacing and hierarchy
- Professional button styling with hover states
- Dark theme consistency across all windows
### Shorts Generator (shorts_generator2.py)
- Settings organized in modern card layout
- Color-coded action buttons for different operations
- Modern progress tracking with styled progress bars
- Responsive controls that adapt to window size
### Thumbnail Editor (thumbnail_editor.py)
- Complete redesign with professional canvas interface
- Timeline slider for frame-by-frame navigation
- Card-based tool organization (Text, Stickers, Export)
- Modern drag-and-drop interaction design
- Professional save/export functionality
## 🎨 Visual Design Principles Applied
1. **Consistency**: Unified color scheme and typography across all windows
2. **Hierarchy**: Clear visual hierarchy using font sizes and colors
3. **Spacing**: Proper padding and margins for clean layouts
4. **Feedback**: Hover states and visual feedback for user interactions
5. **Accessibility**: High contrast and readable font sizes
6. **Professionalism**: Modern flat design with subtle shadows and effects
## 📱 Responsive Design Features
- **Grid Layouts**: Replaced pack() with grid() for better control
- **Weight Configuration**: Proper expansion behavior
- **Minimum Sizes**: Prevents UI from becoming unusable
- **Aspect Ratios**: Maintained proper proportions
- **Flexible Containers**: Adapts to different screen sizes
## 🔧 Technical Improvements
- **Modern Tkinter**: Used ttk widgets where appropriate
- **Style Configuration**: Custom styles for modern appearance
- **Event Handling**: Improved interaction patterns
- **Memory Management**: Proper image reference handling
- **Error Handling**: Graceful degradation and user feedback
## 🎉 Result
The AI Shorts Generator now features a completely modern, professional interface that:
- Looks contemporary and professional
- Provides excellent user experience
- Scales properly across different window sizes
- Uses consistent design patterns throughout
- Offers intuitive navigation and controls
All three requested files have been successfully modernized with a cohesive, professional dark theme that transforms the application from a basic GUI to a modern, professional tool! 🎨✨

704
Main.py
View File

@ -17,49 +17,88 @@ class ProgressWindow:
self.parent = parent self.parent = parent
self.window = tk.Toplevel(parent) self.window = tk.Toplevel(parent)
self.window.title(title) self.window.title(title)
self.window.geometry("400x160") self.window.geometry("450x180")
self.window.minsize(350, 140) # Set minimum size self.window.minsize(400, 160)
self.window.resizable(True, False) # Allow horizontal resize only self.window.resizable(True, False)
self.window.transient(parent) self.window.transient(parent)
self.window.grab_set() self.window.grab_set()
# Modern colors
self.colors = {
'bg_primary': '#1a1a1a',
'bg_secondary': '#2d2d2d',
'text_primary': '#ffffff',
'text_secondary': '#b8b8b8',
'accent_blue': '#007acc',
'accent_red': '#dc3545'
}
self.window.configure(bg=self.colors['bg_primary'])
# Make window responsive # Make window responsive
self.window.columnconfigure(0, weight=1) self.window.columnconfigure(0, weight=1)
# Center the window # Center the window
self.window.update_idletasks() self.window.update_idletasks()
x = (self.window.winfo_screenwidth() // 2) - (400 // 2) x = (self.window.winfo_screenwidth() // 2) - (450 // 2)
y = (self.window.winfo_screenheight() // 2) - (160 // 2) y = (self.window.winfo_screenheight() // 2) - (180 // 2)
self.window.geometry(f"400x160+{x}+{y}") self.window.geometry(f"450x180+{x}+{y}")
# Bind resize event # Bind resize event
self.window.bind('<Configure>', self.on_window_resize) self.window.bind('<Configure>', self.on_window_resize)
# Create progress widgets with responsive layout # Create modern progress interface
main_frame = tk.Frame(self.window) main_frame = tk.Frame(self.window, bg=self.colors['bg_secondary'], relief="flat", bd=0)
main_frame.pack(fill="both", expand=True, padx=15, pady=15) main_frame.pack(fill="both", expand=True, padx=20, pady=20)
main_frame.columnconfigure(0, weight=1) main_frame.columnconfigure(0, weight=1)
self.status_label = tk.Label(main_frame, text="Initializing...", anchor="w", font=("Arial", 10)) # Title
self.status_label.grid(row=0, column=0, sticky="ew", pady=(0, 5)) title_label = tk.Label(main_frame, text=title,
font=('Segoe UI', 14, 'bold'),
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'])
title_label.grid(row=0, column=0, sticky="ew", pady=(0, 15))
# Status
self.status_label = tk.Label(main_frame, text="Initializing...",
font=('Segoe UI', 10), bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'], anchor="w")
self.status_label.grid(row=1, column=0, sticky="ew", pady=(0, 5))
# Time info
self.time_label = tk.Label(main_frame, text="Elapsed: 0.0s | Remaining: --s", self.time_label = tk.Label(main_frame, text="Elapsed: 0.0s | Remaining: --s",
anchor="w", font=("Arial", 9), fg="gray") font=('Segoe UI', 9), bg=self.colors['bg_secondary'],
self.time_label.grid(row=1, column=0, sticky="ew", pady=(0, 5)) fg=self.colors['text_secondary'], anchor="w")
self.time_label.grid(row=2, column=0, sticky="ew", pady=(0, 10))
# Modern progress bar styling
style = ttk.Style()
style.theme_use('clam')
style.configure("Modern.Horizontal.TProgressbar",
background=self.colors['accent_blue'],
troughcolor=self.colors['bg_primary'],
borderwidth=0, lightcolor=self.colors['accent_blue'],
darkcolor=self.colors['accent_blue'])
# Main progress bar # Main progress bar
self.progress_var = tk.DoubleVar() self.progress_var = tk.DoubleVar()
self.progress_bar = ttk.Progressbar(main_frame, variable=self.progress_var, maximum=100) self.progress_bar = ttk.Progressbar(main_frame, variable=self.progress_var,
self.progress_bar.grid(row=2, column=0, sticky="ew", pady=(5, 3)) maximum=100, style="Modern.Horizontal.TProgressbar")
self.progress_bar.grid(row=3, column=0, sticky="ew", pady=(0, 8))
# Detection progress bar (hidden by default) # Detection progress bar (hidden by default)
self.detection_label = tk.Label(main_frame, text="", anchor="w", font=("Arial", 9), fg="blue") self.detection_label = tk.Label(main_frame, text="", font=('Segoe UI', 9),
bg=self.colors['bg_secondary'], fg=self.colors['accent_blue'],
anchor="w")
self.detection_progress_var = tk.DoubleVar() self.detection_progress_var = tk.DoubleVar()
self.detection_progress_bar = ttk.Progressbar(main_frame, variable=self.detection_progress_var, maximum=100) self.detection_progress_bar = ttk.Progressbar(main_frame, variable=self.detection_progress_var,
maximum=100, style="Modern.Horizontal.TProgressbar")
# Cancel button # Modern cancel button
self.cancel_btn = tk.Button(main_frame, text="Cancel", command=self.cancel) self.cancel_btn = tk.Button(main_frame, text="Cancel", command=self.cancel,
self.cancel_btn.grid(row=5, column=0, pady=(5, 0)) bg=self.colors['accent_red'], fg='white',
font=('Segoe UI', 10, 'bold'), relief="flat", bd=0,
pady=8, cursor="hand2")
self.cancel_btn.grid(row=6, column=0, pady=(10, 0))
self.start_time = time.time() self.start_time = time.time()
self.cancelled = False self.cancelled = False
@ -136,24 +175,38 @@ class ClipSelectionWindow:
self.detection_mode = detection_mode self.detection_mode = detection_mode
self.selected_clips = [] self.selected_clips = []
# Create window with parent's root # Modern colors
self.colors = {
'bg_primary': '#1a1a1a',
'bg_secondary': '#2d2d2d',
'bg_tertiary': '#3d3d3d',
'text_primary': '#ffffff',
'text_secondary': '#b8b8b8',
'accent_green': '#28a745',
'accent_red': '#dc3545',
'accent_blue': '#007acc',
'border': '#404040'
}
# Create modern window
self.window = tk.Toplevel(parent.root) self.window = tk.Toplevel(parent.root)
self.window.title("Select Clips to Generate") self.window.title("Select Clips to Generate")
self.window.geometry("600x500") self.window.geometry("700x600")
self.window.minsize(400, 350) # Set minimum size self.window.minsize(500, 400)
self.window.resizable(True, True) self.window.resizable(True, True)
self.window.transient(parent.root) self.window.transient(parent.root)
self.window.grab_set() self.window.grab_set()
self.window.configure(bg=self.colors['bg_primary'])
# Make window responsive # Make window responsive
self.window.rowconfigure(2, weight=1) # Clips list expandable self.window.rowconfigure(1, weight=1)
self.window.columnconfigure(0, weight=1) self.window.columnconfigure(0, weight=1)
# Center the window # Center the window
self.window.update_idletasks() self.window.update_idletasks()
x = (self.window.winfo_screenwidth() // 2) - (600 // 2) x = (self.window.winfo_screenwidth() // 2) - (700 // 2)
y = (self.window.winfo_screenheight() // 2) - (500 // 2) y = (self.window.winfo_screenheight() // 2) - (600 // 2)
self.window.geometry(f"600x500+{x}+{y}") self.window.geometry(f"700x600+{x}+{y}")
# Bind resize event # Bind resize event
self.window.bind('<Configure>', self.on_window_resize) self.window.bind('<Configure>', self.on_window_resize)
@ -161,35 +214,43 @@ class ClipSelectionWindow:
self.setup_gui() self.setup_gui()
def setup_gui(self): def setup_gui(self):
# Create main container # Header section
main_container = tk.Frame(self.window) header_frame = tk.Frame(self.window, bg=self.colors['bg_secondary'], relief="flat", bd=0)
main_container.pack(fill="both", expand=True, padx=20, pady=10) header_frame.grid(row=0, column=0, sticky="ew", padx=20, pady=(20, 0))
header_frame.columnconfigure(0, weight=1)
# Make container responsive # Modern title
main_container.rowconfigure(2, weight=1) # List area expandable title_label = tk.Label(header_frame,
main_container.columnconfigure(0, weight=1) text=f"🎯 Found {len(self.clips)} clips using {self.detection_mode} detection",
font=('Segoe UI', 16, 'bold'), bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
title_label.pack(pady=20)
# Title # Instructions with modern styling
title_label = tk.Label(main_container, text=f"Found {len(self.clips)} clips using {self.detection_mode} detection", self.instruction_label = tk.Label(header_frame,
font=("Arial", 12, "bold")) text="Select the clips you want to generate by checking the boxes below:",
title_label.grid(row=0, column=0, pady=(0, 10), sticky="ew") font=('Segoe UI', 11), bg=self.colors['bg_secondary'],
fg=self.colors['text_secondary'], wraplength=600)
self.instruction_label.pack(pady=(0, 20))
# Instructions # Main content area
self.instruction_label = tk.Label(main_container, content_frame = tk.Frame(self.window, bg=self.colors['bg_primary'])
text="Select the clips you want to generate (check the boxes):", content_frame.grid(row=1, column=0, sticky="nsew", padx=20, pady=10)
font=("Arial", 10), wraplength=400) content_frame.rowconfigure(0, weight=1)
self.instruction_label.grid(row=1, column=0, pady=(0, 10), sticky="ew") content_frame.columnconfigure(0, weight=1)
# Clips list frame with scrollbar # Modern clips list with card design
list_frame = tk.Frame(main_container) list_frame = tk.Frame(content_frame, bg=self.colors['bg_secondary'], relief="flat", bd=0)
list_frame.grid(row=2, column=0, sticky="nsew") list_frame.grid(row=0, column=0, sticky="nsew", padx=0, pady=0)
list_frame.rowconfigure(0, weight=1) list_frame.rowconfigure(0, weight=1)
list_frame.columnconfigure(0, weight=1) list_frame.columnconfigure(0, weight=1)
# Scrollable frame # Scrollable canvas with modern scrollbar
canvas = tk.Canvas(list_frame) canvas = tk.Canvas(list_frame, bg=self.colors['bg_secondary'], highlightthickness=0)
# Modern scrollbar styling
scrollbar = ttk.Scrollbar(list_frame, orient="vertical", command=canvas.yview) scrollbar = ttk.Scrollbar(list_frame, orient="vertical", command=canvas.yview)
scrollable_frame = tk.Frame(canvas) scrollable_frame = tk.Frame(canvas, bg=self.colors['bg_secondary'])
scrollable_frame.bind( scrollable_frame.bind(
"<Configure>", "<Configure>",
@ -199,53 +260,99 @@ class ClipSelectionWindow:
canvas.create_window((0, 0), window=scrollable_frame, anchor="nw") canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
canvas.configure(yscrollcommand=scrollbar.set) canvas.configure(yscrollcommand=scrollbar.set)
# Clip checkboxes # Modern clip cards
self.clip_vars = [] self.clip_vars = []
for i, (start, end) in enumerate(self.clips): for i, (start, end) in enumerate(self.clips):
var = tk.BooleanVar(value=True) # All selected by default var = tk.BooleanVar(value=True)
self.clip_vars.append(var) self.clip_vars.append(var)
duration = end - start duration = end - start
clip_frame = tk.Frame(scrollable_frame, relief="ridge", bd=1)
clip_frame.pack(fill="x", pady=2, padx=5)
clip_frame.columnconfigure(1, weight=1)
checkbox = tk.Checkbutton(clip_frame, variable=var, text="", width=2) # Modern clip card
checkbox.grid(row=0, column=0, padx=5, sticky="w") clip_card = tk.Frame(scrollable_frame, bg=self.colors['bg_tertiary'],
relief="flat", bd=1, highlightbackground=self.colors['border'],
highlightthickness=1)
clip_card.pack(fill="x", pady=8, padx=15)
clip_card.columnconfigure(1, weight=1)
info_label = tk.Label(clip_frame, # Modern checkbox
text=f"Clip {i+1}: {start:.1f}s - {end:.1f}s (Duration: {duration:.1f}s)", checkbox = tk.Checkbutton(clip_card, variable=var, text="", width=2,
font=("Arial", 10), anchor="w") bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
info_label.grid(row=0, column=1, padx=5, sticky="ew") selectcolor=self.colors['accent_blue'],
activebackground=self.colors['bg_tertiary'],
relief="flat", bd=0)
checkbox.grid(row=0, column=0, padx=15, pady=15, sticky="w")
# Clip info with modern typography
info_frame = tk.Frame(clip_card, bg=self.colors['bg_tertiary'])
info_frame.grid(row=0, column=1, sticky="ew", padx=(0, 15), pady=15)
clip_title = tk.Label(info_frame, text=f"Clip {i+1}",
font=('Segoe UI', 11, 'bold'), bg=self.colors['bg_tertiary'],
fg=self.colors['text_primary'], anchor="w")
clip_title.pack(anchor="w")
clip_details = tk.Label(info_frame,
text=f"⏱️ {start:.1f}s - {end:.1f}s • Duration: {duration:.1f}s",
font=('Segoe UI', 10), bg=self.colors['bg_tertiary'],
fg=self.colors['text_secondary'], anchor="w")
clip_details.pack(anchor="w", pady=(2, 0))
canvas.grid(row=0, column=0, sticky="nsew") canvas.grid(row=0, column=0, sticky="nsew")
scrollbar.grid(row=0, column=1, sticky="ns") scrollbar.grid(row=0, column=1, sticky="ns")
# Selection buttons # Modern action buttons
button_frame = tk.Frame(main_container) action_frame = tk.Frame(self.window, bg=self.colors['bg_primary'])
button_frame.grid(row=3, column=0, pady=10, sticky="ew") action_frame.grid(row=2, column=0, sticky="ew", padx=20, pady=(10, 20))
button_frame.columnconfigure(0, weight=1)
button_frame.columnconfigure(1, weight=1)
select_all_btn = tk.Button(button_frame, text="Select All", command=self.select_all)
select_all_btn.grid(row=0, column=0, padx=(0, 5), sticky="ew")
select_none_btn = tk.Button(button_frame, text="Select None", command=self.select_none)
select_none_btn.grid(row=0, column=1, padx=(5, 0), sticky="ew")
# Generate button
action_frame = tk.Frame(main_container)
action_frame.grid(row=4, column=0, pady=10, sticky="ew")
action_frame.columnconfigure(0, weight=1) action_frame.columnconfigure(0, weight=1)
action_frame.columnconfigure(1, weight=1) action_frame.columnconfigure(1, weight=1)
action_frame.columnconfigure(2, weight=1)
action_frame.columnconfigure(3, weight=1)
cancel_btn = tk.Button(action_frame, text="Cancel", command=self.cancel, bg="#f44336", fg="white") # Selection buttons
cancel_btn.grid(row=0, column=1, padx=(5, 0), sticky="ew") select_all_btn = self.create_modern_button(action_frame, "✅ Select All",
self.select_all, self.colors['accent_blue'])
select_all_btn.grid(row=0, column=0, padx=(0, 5), sticky="ew")
generate_selected_btn = tk.Button(action_frame, text="Generate Selected Clips", select_none_btn = self.create_modern_button(action_frame, "❌ Select None",
command=self.generate_selected, bg="#4CAF50", fg="white", self.select_none, self.colors['bg_tertiary'])
font=("Arial", 10, "bold")) select_none_btn.grid(row=0, column=1, padx=5, sticky="ew")
generate_selected_btn.grid(row=0, column=0, padx=(0, 5), sticky="ew")
# Action buttons
cancel_btn = self.create_modern_button(action_frame, "Cancel",
self.cancel, self.colors['accent_red'])
cancel_btn.grid(row=0, column=2, padx=5, sticky="ew")
generate_btn = self.create_modern_button(action_frame, "🎬 Generate Selected",
self.generate_selected, self.colors['accent_green'])
generate_btn.grid(row=0, column=3, padx=(5, 0), sticky="ew")
def create_modern_button(self, parent, text, command, color):
"""Create a modern button for the clip selection window"""
button = tk.Button(parent, text=text, command=command,
bg=color, fg='white', font=('Segoe UI', 10, 'bold'),
relief="flat", bd=0, pady=10, cursor="hand2")
# Add hover effect
original_color = color
def on_enter(e):
# Lighten color on hover
button.config(bg=self.lighten_color(original_color, 0.2))
def on_leave(e):
button.config(bg=original_color)
button.bind("<Enter>", on_enter)
button.bind("<Leave>", on_leave)
return button
def lighten_color(self, hex_color, factor):
"""Lighten a hex color by a factor (0.0 to 1.0)"""
hex_color = hex_color.lstrip('#')
rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
rgb = tuple(min(255, int(c + (255 - c) * factor)) for c in rgb)
return f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
def on_window_resize(self, event): def on_window_resize(self, event):
"""Handle window resize events""" """Handle window resize events"""
@ -299,144 +406,267 @@ class MainApplication:
def __init__(self): def __init__(self):
self.root = tk.Tk() self.root = tk.Tk()
self.root.title("AI Shorts Generator - Main Controller") self.root.title("AI Shorts Generator - Main Controller")
self.root.geometry("500x600") self.root.geometry("800x600") # Wider window for horizontal layout
self.root.minsize(400, 500) # Set minimum size self.root.minsize(700, 500) # Increased minimum width for horizontal layout
self.root.configure(bg="#f0f0f0")
# Modern color scheme
self.colors = {
'bg_primary': '#1a1a1a', # Dark background
'bg_secondary': '#2d2d2d', # Card backgrounds
'bg_tertiary': '#3d3d3d', # Elevated elements
'accent_blue': '#007acc', # Primary blue
'accent_green': '#28a745', # Success green
'accent_orange': '#fd7e14', # Warning orange
'accent_purple': '#6f42c1', # Secondary purple
'accent_red': '#dc3545', # Error red
'text_primary': '#ffffff', # Primary text
'text_secondary': '#b8b8b8', # Secondary text
'text_muted': '#6c757d', # Muted text
'border': '#404040', # Border color
'hover': '#4a4a4a' # Hover state
}
self.root.configure(bg=self.colors['bg_primary'])
# Modern fonts
self.fonts = {
'title': ('Segoe UI', 18, 'bold'),
'heading': ('Segoe UI', 12, 'bold'),
'body': ('Segoe UI', 10),
'caption': ('Segoe UI', 9),
'button': ('Segoe UI', 10, 'bold')
}
# Make window responsive # Make window responsive
self.root.rowconfigure(0, weight=1) self.root.rowconfigure(0, weight=1)
self.root.columnconfigure(0, weight=1) self.root.columnconfigure(0, weight=1)
# Initialize the ShortsGeneratorGUI (but don't show its window) # Initialize the ShortsGeneratorGUI will be created when needed
self.shorts_generator = None self.shorts_generator = None
self.init_shorts_generator()
self.setup_gui() self.setup_gui()
# Bind resize event for responsive updates # Bind resize event for responsive updates
self.root.bind('<Configure>', self.on_window_resize) self.root.bind('<Configure>', self.on_window_resize)
def init_shorts_generator(self): def get_shorts_generator(self):
"""Initialize the ShortsGeneratorGUI without showing its window""" """Get or create a minimal ShortsGenerator instance when needed"""
if self.shorts_generator is None:
try: try:
# Create a hidden root for ShortsGeneratorGUI # Create a simple container class with just the attributes we need
hidden_root = tk.Tk() class MinimalShortsGenerator:
hidden_root.withdraw() # Hide the window def __init__(self):
self.video_path = None
# Create ShortsGeneratorGUI instance self.output_folder = "shorts"
self.shorts_generator = ShortsGeneratorGUI(hidden_root) self.max_clips = 3
self.threshold_db = -30
# Don't show the original window self.clip_duration = 5
hidden_root.withdraw() self.detection_mode_var = tk.StringVar(value="loud")
self.shorts_generator = MinimalShortsGenerator()
print("✅ Minimal ShortsGenerator initialized successfully")
except Exception as e: except Exception as e:
messagebox.showerror("Initialization Error", f"Failed to initialize ShortsGeneratorGUI: {e}") print(f"❌ Failed to initialize ShortsGenerator: {e}")
self.shorts_generator = None messagebox.showerror("Initialization Error", f"Failed to initialize ShortsGenerator: {e}")
return None
return self.shorts_generator
def setup_gui(self): def setup_gui(self):
"""Setup the main GUI with responsive design""" """Setup the main GUI with modern horizontal design"""
# Create main container that fills the window # Create main container that fills the window
main_container = tk.Frame(self.root, bg="#f0f0f0") main_container = tk.Frame(self.root, bg=self.colors['bg_primary'])
main_container.pack(fill="both", expand=True, padx=10, pady=10) main_container.pack(fill="both", expand=True, padx=20, pady=20)
# Make main container responsive # Modern title with gradient effect simulation
main_container.rowconfigure(1, weight=1) # File frame expandable title_frame = tk.Frame(main_container, bg=self.colors['bg_primary'])
main_container.rowconfigure(2, weight=1) # Settings frame expandable title_frame.pack(fill="x", pady=(0, 20))
main_container.rowconfigure(3, weight=2) # Button frame gets more space
main_container.columnconfigure(0, weight=1)
# Title title_label = tk.Label(title_frame, text="🎬 AI Shorts Generator",
title_label = tk.Label(main_container, text="🎬 AI Shorts Generator", font=self.fonts['title'], bg=self.colors['bg_primary'],
font=("Arial", 16, "bold"), bg="#f0f0f0", fg="#2c3e50") fg=self.colors['text_primary'])
title_label.grid(row=0, column=0, pady=(0, 20), sticky="ew") title_label.pack()
# File selection frame subtitle_label = tk.Label(title_frame, text="Create viral content with AI-powered video analysis",
file_frame = tk.Frame(main_container, bg="#f0f0f0") font=self.fonts['caption'], bg=self.colors['bg_primary'],
file_frame.grid(row=1, column=0, pady=10, sticky="ew") fg=self.colors['text_secondary'])
file_frame.columnconfigure(0, weight=1) # Make expandable subtitle_label.pack(pady=(5, 0))
tk.Label(file_frame, text="Selected Video:", font=("Arial", 10, "bold"), # Create horizontal layout with left and right panels
bg="#f0f0f0").grid(row=0, column=0, sticky="w") content_frame = tk.Frame(main_container, bg=self.colors['bg_primary'])
content_frame.pack(fill="both", expand=True)
self.file_label = tk.Label(file_frame, text="No video selected", # Left panel - Video Selection and Settings
font=("Arial", 9), bg="white", relief="sunken", left_panel = tk.Frame(content_frame, bg=self.colors['bg_primary'])
anchor="w", pady=5, padx=10) left_panel.pack(side="left", fill="both", expand=True, padx=(0, 15))
self.file_label.grid(row=1, column=0, pady=(5,10), sticky="ew")
# File selection button # Modern card-style file selection frame
select_btn = tk.Button(file_frame, text="📁 Select Video File", file_card = self.create_modern_card(left_panel, "📁 Video Selection")
command=self.select_video_file, bg="#3498db", fg="white",
font=("Arial", 10, "bold"), pady=5)
select_btn.grid(row=2, column=0, pady=5, sticky="ew")
# Settings frame (simplified) self.file_label = tk.Label(file_card, text="No video selected",
settings_frame = tk.LabelFrame(main_container, text="Quick Settings", font=("Arial", 10, "bold"), font=self.fonts['body'], bg=self.colors['bg_tertiary'],
bg="#f0f0f0", padx=10, pady=10) fg=self.colors['text_secondary'], relief="flat",
settings_frame.grid(row=2, column=0, pady=10, sticky="ew") anchor="w", pady=12, padx=15, bd=1,
settings_frame.columnconfigure(0, weight=1) # Make expandable highlightbackground=self.colors['border'],
highlightthickness=1)
self.file_label.pack(fill="x", pady=(0, 10))
# Modern button with hover effect
select_btn = self.create_modern_button(file_card, "📁 Select Video File",
self.select_video_file, self.colors['accent_blue'])
select_btn.pack(fill="x", pady=5)
# Modern settings card
settings_card = self.create_modern_card(left_panel, "⚙️ Detection Settings")
# Detection mode with modern styling
mode_label = tk.Label(settings_card, text="Detection Mode:",
font=self.fonts['heading'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
mode_label.pack(anchor="w", pady=(0, 10))
# Detection mode
tk.Label(settings_frame, text="Detection Mode:", bg="#f0f0f0").grid(row=0, column=0, sticky="w")
self.detection_var = tk.StringVar(value="loud") self.detection_var = tk.StringVar(value="loud")
detection_container = tk.Frame(settings_frame, bg="#f0f0f0") detection_container = tk.Frame(settings_card, bg=self.colors['bg_secondary'])
detection_container.grid(row=1, column=0, pady=5, sticky="ew") detection_container.pack(fill="x", pady=5)
detection_container.columnconfigure(0, weight=1)
detection_container.columnconfigure(1, weight=1)
detection_container.columnconfigure(2, weight=1)
modes = [("Loud Moments", "loud"), ("Scene Changes", "scene"), ("Motion", "motion"), modes = [("🔊 Loud Moments", "loud"), ("🎬 Scene Changes", "scene"), ("🏃 Motion", "motion"),
("Speech", "speech"), ("Audio Peaks", "peaks"), ("Combined", "combined")] ("💬 Speech", "speech"), ("🎵 Audio Peaks", "peaks"), ("🎯 Combined", "combined")]
# Create responsive grid for radio buttons # Create modern radio buttons in rows
for i, (text, value) in enumerate(modes): for i in range(0, len(modes), 3): # 3 per row
row = i // 3 row_frame = tk.Frame(detection_container, bg=self.colors['bg_secondary'])
col = i % 3 row_frame.pack(fill="x", pady=3)
if row >= detection_container.grid_size()[1]:
detection_container.rowconfigure(row, weight=1)
tk.Radiobutton(detection_container, text=text, variable=self.detection_var, value=value,
bg="#f0f0f0").grid(row=row, column=col, padx=5, pady=2, sticky="w")
# Main action buttons with responsive design for j in range(3):
button_frame = tk.Frame(main_container, bg="#f0f0f0") if i + j < len(modes):
button_frame.grid(row=3, column=0, pady=20, sticky="ew") text, value = modes[i + j]
button_frame.columnconfigure(0, weight=1) # Make expandable radio_frame = tk.Frame(row_frame, bg=self.colors['bg_tertiary'],
relief="flat", bd=1)
radio_frame.pack(side="left", fill="x", expand=True, padx=5)
# Preview Clips Button radio = tk.Radiobutton(radio_frame, text=text, variable=self.detection_var,
self.preview_btn = tk.Button(button_frame, text="🔍 Preview Clips", value=value, bg=self.colors['bg_tertiary'],
command=self.preview_clips_threaded, bg="#2196F3", fg="white", fg=self.colors['text_primary'], font=self.fonts['body'],
font=("Arial", 11, "bold"), pady=8) selectcolor=self.colors['accent_blue'],
self.preview_btn.grid(row=0, column=0, pady=5, sticky="ew") activebackground=self.colors['hover'],
activeforeground=self.colors['text_primary'],
relief="flat", bd=0)
radio.pack(pady=8, padx=10)
# Generate Shorts Button # Right panel - Actions and Controls
self.generate_btn = tk.Button(button_frame, text="🎬 Generate All Detected Clips", right_panel = tk.Frame(content_frame, bg=self.colors['bg_primary'])
command=self.generate_shorts_threaded, bg="#4CAF50", fg="white", right_panel.pack(side="right", fill="y", padx=(15, 0))
font=("Arial", 12, "bold"), pady=10) right_panel.config(width=300) # Fixed width for actions panel
self.generate_btn.grid(row=1, column=0, pady=5, sticky="ew")
# Info label # Modern action buttons card
info_label = tk.Label(button_frame, text="💡 Tip: Use 'Preview Clips' to select specific clips for faster processing", button_card = self.create_modern_card(right_panel, "🚀 Actions")
font=("Arial", 9), fg="gray", bg="#f0f0f0", wraplength=350)
info_label.grid(row=2, column=0, pady=(5,10), sticky="ew")
# Edit Generated Shorts Button # Preview button
self.edit_btn = tk.Button(button_frame, text="✏️ Edit Generated Shorts", self.preview_btn = self.create_modern_button(button_card, "🔍 Preview Clips",
command=self.open_editor, bg="#FF9800", fg="white", self.preview_clips_threaded,
font=("Arial", 11, "bold"), pady=8) self.colors['accent_blue'])
self.edit_btn.grid(row=3, column=0, pady=5, sticky="ew") self.preview_btn.pack(fill="x", pady=5)
# Create Thumbnails Button # Generate button - primary action
self.thumbnail_btn = tk.Button(button_frame, text="📸 Create Thumbnails", self.generate_btn = self.create_modern_button(button_card, "🎬 Generate All Clips",
command=self.open_thumbnails, bg="#9C27B0", fg="white", self.generate_shorts_threaded,
font=("Arial", 11, "bold"), pady=8) self.colors['accent_green'], large=True)
self.thumbnail_btn.grid(row=4, column=0, pady=5, sticky="ew") self.generate_btn.pack(fill="x", pady=5)
# Status label # Secondary action buttons
self.status_label = tk.Label(main_container, text="Ready - Select a video to begin", self.edit_btn = self.create_modern_button(button_card, "✏️ Edit Generated Shorts",
font=("Arial", 9), fg="gray", bg="#f0f0f0", wraplength=400) self.open_editor, self.colors['accent_orange'])
self.status_label.grid(row=4, column=0, pady=(20,0), sticky="ew") self.edit_btn.pack(fill="x", pady=5)
self.thumbnail_btn = self.create_modern_button(button_card, "📸 Create Thumbnails",
self.open_thumbnails, self.colors['accent_purple'])
self.thumbnail_btn.pack(fill="x", pady=5)
# Info tip with modern styling - moved to bottom
tip_frame = tk.Frame(button_card, bg=self.colors['bg_secondary'])
tip_frame.pack(fill="x", pady=(20, 0))
tip_icon = tk.Label(tip_frame, text="💡", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['accent_orange'])
tip_icon.pack(side="left", padx=(0, 8))
info_label = tk.Label(tip_frame, text="Tip: Use 'Preview Clips' to select specific clips for faster processing",
font=self.fonts['caption'], fg=self.colors['text_muted'],
bg=self.colors['bg_secondary'], wraplength=250, anchor="w")
info_label.pack(side="left", fill="x", expand=True)
# Modern status bar at the bottom
status_frame = tk.Frame(main_container, bg=self.colors['bg_tertiary'],
relief="flat", bd=1)
status_frame.pack(fill="x", pady=(20, 0))
status_icon = tk.Label(status_frame, text="●", font=self.fonts['body'],
bg=self.colors['bg_tertiary'], fg=self.colors['accent_green'])
status_icon.pack(side="left", padx=15, pady=8)
self.status_label = tk.Label(status_frame, text="Ready - Select a video to begin",
font=self.fonts['caption'], fg=self.colors['text_secondary'],
bg=self.colors['bg_tertiary'], wraplength=400, anchor="w")
self.status_label.pack(side="left", fill="x", expand=True, pady=8, padx=(0, 15))
# Store detected clips for selection # Store detected clips for selection
self.detected_clips = [] self.detected_clips = []
def create_modern_card(self, parent, title):
"""Create a modern card-style container"""
card_frame = tk.Frame(parent, bg=self.colors['bg_secondary'], relief="flat", bd=0)
card_frame.pack(fill="x", pady=10)
# Card header
header_frame = tk.Frame(card_frame, bg=self.colors['bg_secondary'])
header_frame.pack(fill="x", padx=20, pady=(15, 5))
header_label = tk.Label(header_frame, text=title, font=self.fonts['heading'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'])
header_label.pack(anchor="w")
# Card content area
content_frame = tk.Frame(card_frame, bg=self.colors['bg_secondary'])
content_frame.pack(fill="both", expand=True, padx=20, pady=(5, 20))
return content_frame
def create_modern_button(self, parent, text, command, color, large=False):
"""Create a modern button with hover effects"""
font = self.fonts['button'] if not large else ('Segoe UI', 12, 'bold')
pady = 12 if not large else 15
button = tk.Button(parent, text=text, command=command,
bg=color, fg='white', font=font,
relief="flat", bd=0, pady=pady,
activebackground=self.adjust_color(color, -20),
activeforeground='white',
cursor="hand2")
# Add hover effects
def on_enter(e):
button.config(bg=self.adjust_color(color, 15))
def on_leave(e):
button.config(bg=color)
button.bind("<Enter>", on_enter)
button.bind("<Leave>", on_leave)
return button
def adjust_color(self, hex_color, adjustment):
"""Adjust color brightness for hover effects"""
# Remove # if present
hex_color = hex_color.lstrip('#')
# Convert to RGB
rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
# Adjust brightness
adjusted = tuple(max(0, min(255, c + adjustment)) for c in rgb)
# Convert back to hex
return f"#{adjusted[0]:02x}{adjusted[1]:02x}{adjusted[2]:02x}"
def on_window_resize(self, event): def on_window_resize(self, event):
"""Handle window resize events for responsive layout""" """Handle window resize events for responsive layout"""
if event.widget == self.root: if event.widget == self.root:
@ -491,15 +721,18 @@ class MainApplication:
self.file_label.config(text=filename) self.file_label.config(text=filename)
# Update shorts generator # Update shorts generator
if self.shorts_generator: generator = self.get_shorts_generator()
self.shorts_generator.video_path = file_path if generator:
self.shorts_generator.video_label.config(text=os.path.basename(file_path)) generator.video_path = file_path
if hasattr(generator, 'video_label'):
generator.video_label.config(text=os.path.basename(file_path))
self.status_label.config(text=f"Video loaded: {filename}") self.status_label.config(text=f"Video loaded: {filename}")
def preview_clips_threaded(self): def preview_clips_threaded(self):
"""Run preview clips with progress window""" """Run preview clips with progress window"""
if not self.shorts_generator or not self.shorts_generator.video_path: generator = self.get_shorts_generator()
if not generator or not hasattr(generator, 'video_path') or not generator.video_path:
messagebox.showwarning("No Video", "Please select a video file first.") messagebox.showwarning("No Video", "Please select a video file first.")
return return
@ -521,7 +754,11 @@ class MainApplication:
detect_audio_peaks_with_progress, detect_combined_intensity_with_progress, detect_audio_peaks_with_progress, detect_combined_intensity_with_progress,
validate_video) validate_video)
video_path = self.shorts_generator.video_path generator = self.get_shorts_generator()
if not generator or not hasattr(generator, 'video_path'):
raise Exception("ShortsGeneratorGUI not properly initialized")
video_path = generator.video_path
clip_duration = 5 # Fixed clip duration since we removed the setting clip_duration = 5 # Fixed clip duration since we removed the setting
detection_mode = self.detection_var.get() detection_mode = self.detection_var.get()
@ -610,7 +847,8 @@ class MainApplication:
def generate_shorts_threaded(self): def generate_shorts_threaded(self):
"""Run generate shorts with progress window""" """Run generate shorts with progress window"""
if not self.shorts_generator or not self.shorts_generator.video_path: generator = self.get_shorts_generator()
if not generator or not hasattr(generator, 'video_path') or not generator.video_path:
messagebox.showwarning("No Video", "Please select a video file first.") messagebox.showwarning("No Video", "Please select a video file first.")
return return
@ -629,7 +867,11 @@ class MainApplication:
try: try:
from shorts_generator2 import generate_shorts from shorts_generator2 import generate_shorts
video_path = self.shorts_generator.video_path generator = self.get_shorts_generator()
if not generator or not hasattr(generator, 'video_path'):
raise Exception("ShortsGeneratorGUI not properly initialized")
video_path = generator.video_path
detection_mode = self.detection_var.get() detection_mode = self.detection_var.get()
clip_duration = 5 # Default duration clip_duration = 5 # Default duration
@ -687,7 +929,8 @@ class MainApplication:
def generate_selected_clips(self, selected_clips): def generate_selected_clips(self, selected_clips):
"""Generate only the selected clips""" """Generate only the selected clips"""
if not self.shorts_generator or not self.shorts_generator.video_path: generator = self.get_shorts_generator()
if not generator or not hasattr(generator, 'video_path') or not generator.video_path:
messagebox.showerror("Error", "No video selected.") messagebox.showerror("Error", "No video selected.")
return return
@ -696,7 +939,11 @@ class MainApplication:
def run_selected_generation(): def run_selected_generation():
try: try:
video_path = self.shorts_generator.video_path generator = self.get_shorts_generator()
if not generator or not hasattr(generator, 'video_path'):
raise Exception("ShortsGeneratorGUI not properly initialized")
video_path = generator.video_path
# Thread-safe progress callback with cancellation checks # Thread-safe progress callback with cancellation checks
def progress_callback(message, percent): def progress_callback(message, percent):
@ -812,51 +1059,33 @@ class MainApplication:
def update_shorts_generator_settings(self): def update_shorts_generator_settings(self):
"""Update the shorts generator with current settings""" """Update the shorts generator with current settings"""
if self.shorts_generator: generator = self.get_shorts_generator()
self.shorts_generator.detection_mode_var.set(self.detection_var.get()) if generator and hasattr(generator, 'detection_mode_var'):
generator.detection_mode_var.set(self.detection_var.get())
def open_editor(self): def open_editor(self):
"""Open the shorts editor""" """Open the shorts editor"""
print("DEBUG: open_editor called")
if self.shorts_generator:
print("DEBUG: shorts_generator exists")
try: try:
print("DEBUG: Attempting to call open_shorts_editor()") # Import and create the editor directly
if hasattr(self.shorts_generator, 'open_shorts_editor'):
print("DEBUG: open_shorts_editor method exists")
print(f"DEBUG: shorts_generator root: {self.shorts_generator.root}")
print(f"DEBUG: shorts_generator output_folder: {getattr(self.shorts_generator, 'output_folder', 'NOT SET')}")
# Create the editor with the main window as parent instead of hidden root
from shorts_generator2 import ShortsEditorGUI from shorts_generator2 import ShortsEditorGUI
editor = ShortsEditorGUI(self.root, self.shorts_generator.output_folder)
# Get the output folder from generator if available, otherwise use default
generator = self.get_shorts_generator()
output_folder = getattr(generator, 'output_folder', 'shorts') if generator else 'shorts'
# Create and open the editor
editor = ShortsEditorGUI(self.root, output_folder)
editor.open_editor() editor.open_editor()
print("DEBUG: Editor opened successfully")
else:
print("DEBUG: open_shorts_editor method does NOT exist")
messagebox.showerror("Editor Error", "The open_shorts_editor method is not available in ShortsGeneratorGUI")
except Exception as e: except Exception as e:
print(f"DEBUG: Exception in open_editor: {e}") print(f"Editor Error: {e}")
import traceback import traceback
traceback.print_exc() traceback.print_exc()
messagebox.showerror("Editor Error", f"Could not open editor: {e}") messagebox.showerror("Editor Error", f"Could not open editor: {e}")
else:
print("DEBUG: shorts_generator is None")
messagebox.showerror("Editor Error", "ShortsGeneratorGUI is not initialized")
def open_thumbnails(self): def open_thumbnails(self):
"""Open the thumbnail editor""" """Open the thumbnail editor"""
print("DEBUG: open_thumbnails called")
if self.shorts_generator:
print("DEBUG: shorts_generator exists")
try: try:
print("DEBUG: Attempting to call open_thumbnail_editor()")
if hasattr(self.shorts_generator, 'open_thumbnail_editor'):
print("DEBUG: open_thumbnail_editor method exists")
# Call the method directly but handle the parent window issue
# Let's import and call the thumbnail editor function directly
import os import os
import glob import glob
@ -864,12 +1093,14 @@ class MainApplication:
video_files = [] video_files = []
# Check for original video # Check for original video
if self.shorts_generator.video_path: generator = self.get_shorts_generator()
video_files.append(("Original Video", self.shorts_generator.video_path)) if generator and hasattr(generator, 'video_path') and generator.video_path:
video_files.append(("Original Video", generator.video_path))
# Check for generated shorts # Check for generated shorts
if os.path.exists(self.shorts_generator.output_folder): output_folder = getattr(generator, 'output_folder', 'shorts') if generator else 'shorts'
shorts = glob.glob(os.path.join(self.shorts_generator.output_folder, "*.mp4")) if os.path.exists(output_folder):
shorts = glob.glob(os.path.join(output_folder, "*.mp4"))
for short in shorts: for short in shorts:
video_files.append((os.path.basename(short), short)) video_files.append((os.path.basename(short), short))
@ -888,9 +1119,11 @@ class MainApplication:
choice_window.geometry("400x300") choice_window.geometry("400x300")
choice_window.transient(self.root) choice_window.transient(self.root)
choice_window.grab_set() choice_window.grab_set()
choice_window.configure(bg=self.colors['bg_primary'])
tk.Label(choice_window, text="📸 Select Video for Thumbnail Creation", tk.Label(choice_window, text="📸 Select Video for Thumbnail Creation",
font=("Arial", 12, "bold")).pack(pady=10) font=("Segoe UI", 12, "bold"), bg=self.colors['bg_primary'],
fg=self.colors['text_primary']).pack(pady=20)
selected_video = None selected_video = None
@ -899,15 +1132,21 @@ class MainApplication:
selected_video = video_path selected_video = video_path
choice_window.destroy() choice_window.destroy()
# Create list of videos # Create list of videos with modern styling
for display_name, video_path in video_files: for display_name, video_path in video_files:
btn = tk.Button(choice_window, text=f"📹 {display_name}", btn = tk.Button(choice_window, text=f"📹 {display_name}",
command=lambda vp=video_path: on_video_select(vp), command=lambda vp=video_path: on_video_select(vp),
font=("Arial", 10), pady=5, width=40) font=("Segoe UI", 10), pady=8, width=40,
btn.pack(pady=2, padx=20, fill="x") bg=self.colors['accent_blue'], fg='white',
relief="flat", bd=0, cursor="hand2")
btn.pack(pady=3, padx=20, fill="x")
tk.Button(choice_window, text="Cancel", cancel_btn = tk.Button(choice_window, text="Cancel",
command=choice_window.destroy).pack(pady=10) command=choice_window.destroy,
font=("Segoe UI", 10), pady=8,
bg=self.colors['accent_red'], fg='white',
relief="flat", bd=0, cursor="hand2")
cancel_btn.pack(pady=15)
# Wait for selection # Wait for selection
choice_window.wait_window() choice_window.wait_window()
@ -919,18 +1158,11 @@ class MainApplication:
from thumbnail_editor import open_thumbnail_editor from thumbnail_editor import open_thumbnail_editor
open_thumbnail_editor(selected_video) open_thumbnail_editor(selected_video)
print("DEBUG: Thumbnail editor opened successfully")
else:
print("DEBUG: open_thumbnail_editor method does NOT exist")
messagebox.showerror("Thumbnail Error", "The open_thumbnail_editor method is not available in ShortsGeneratorGUI")
except Exception as e: except Exception as e:
print(f"DEBUG: Exception in open_thumbnails: {e}") print(f"Thumbnail Error: {e}")
import traceback import traceback
traceback.print_exc() traceback.print_exc()
messagebox.showerror("Thumbnail Error", f"Could not open thumbnail editor: {e}") messagebox.showerror("Thumbnail Error", f"Could not open thumbnail editor: {e}")
else:
print("DEBUG: shorts_generator is None")
messagebox.showerror("Thumbnail Error", "ShortsGeneratorGUI is not initialized")
def run(self): def run(self):
"""Start the main application""" """Start the main application"""

452
shorts_generator2.py
View File

@ -1140,17 +1140,19 @@ class VideoEditor:
settings = quality_settings.get(quality, quality_settings["medium"]) settings = quality_settings.get(quality, quality_settings["medium"])
# Export with progress callback # Export with progress callback
if progress_callback: try:
# Try with newer MoviePy parameters first
self.video_clip.write_videofile( self.video_clip.write_videofile(
output_path, output_path,
codec="libx264", codec="libx264",
audio_codec="aac", audio_codec="aac",
bitrate=settings["bitrate"], bitrate=settings["bitrate"],
audio_bitrate=settings["audio_bitrate"], audio_bitrate=settings["audio_bitrate"],
verbose=False,
logger=None logger=None
) )
else: except TypeError as e:
if "verbose" in str(e):
# Fallback for older MoviePy versions
self.video_clip.write_videofile( self.video_clip.write_videofile(
output_path, output_path,
codec="libx264", codec="libx264",
@ -1158,6 +1160,8 @@ class VideoEditor:
bitrate=settings["bitrate"], bitrate=settings["bitrate"],
audio_bitrate=settings["audio_bitrate"] audio_bitrate=settings["audio_bitrate"]
) )
else:
raise e
@staticmethod @staticmethod
def trim_video(video_path, start_time, end_time, output_path): def trim_video(video_path, start_time, end_time, output_path):
@ -1308,7 +1312,6 @@ class VideoEditor:
audio_codec="aac", audio_codec="aac",
temp_audiofile='temp-audio.m4a', temp_audiofile='temp-audio.m4a',
remove_temp=True, remove_temp=True,
verbose=False, # Reduce console output
logger=None, # Disable logging for speed logger=None, # Disable logging for speed
preset='ultrafast', # Fastest encoding preset preset='ultrafast', # Fastest encoding preset
threads=4 # Use multiple threads threads=4 # Use multiple threads
@ -1718,11 +1721,11 @@ class VideoEditor:
temp_output = output_path.replace('.mp4', '_temp.mp4') temp_output = output_path.replace('.mp4', '_temp.mp4')
try: try:
# Try with verbose parameter (newer MoviePy) # Try with logger parameter (newer MoviePy)
final_video.write_videofile(temp_output, codec="libx264", audio_codec="aac", final_video.write_videofile(temp_output, codec="libx264", audio_codec="aac",
verbose=False, logger=None) logger=None)
except TypeError: except TypeError:
# Fallback for older MoviePy versions without verbose parameter # Fallback for older MoviePy versions without logger parameter
final_video.write_videofile(temp_output, codec="libx264", audio_codec="aac") final_video.write_videofile(temp_output, codec="libx264", audio_codec="aac")
# Replace original with final version # Replace original with final version
@ -1783,8 +1786,8 @@ class ShortsEditorGUI:
# Create editor window # Create editor window
self.editor_window = tk.Toplevel(self.parent) self.editor_window = tk.Toplevel(self.parent)
self.editor_window.title("🎬 Shorts Editor - Professional Video Editing") self.editor_window.title("🎬 Shorts Editor - Professional Video Editing")
self.editor_window.geometry("800x700") self.editor_window.geometry("1200x800") # Increased width to show all panels
self.editor_window.minsize(600, 500) # Set minimum size self.editor_window.minsize(1000, 700) # Increased minimum size
self.editor_window.resizable(True, True) self.editor_window.resizable(True, True)
self.editor_window.transient(self.parent) self.editor_window.transient(self.parent)
@ -1818,7 +1821,7 @@ class ShortsEditorGUI:
"""Create the main editor interface with video player""" """Create the main editor interface with video player"""
# Title # Title
title_frame = tk.Frame(self.editor_window) title_frame = tk.Frame(self.editor_window)
title_frame.grid(row=0, column=0, padx=20, pady=10, sticky="ew") title_frame.pack(fill="x", padx=20, pady=10)
tk.Label(title_frame, text="🎬 Professional Shorts Editor", tk.Label(title_frame, text="🎬 Professional Shorts Editor",
font=("Arial", 16, "bold")).pack() font=("Arial", 16, "bold")).pack()
@ -1827,18 +1830,15 @@ class ShortsEditorGUI:
# Main content frame # Main content frame
main_frame = tk.Frame(self.editor_window) main_frame = tk.Frame(self.editor_window)
main_frame.grid(row=1, column=0, padx=20, pady=10, sticky="nsew") main_frame.pack(fill="both", expand=True, padx=20, pady=10)
main_frame.rowconfigure(0, weight=1)
main_frame.columnconfigure(1, weight=1)
# Left panel - Video selection and info # Left panel - Video selection and info
left_panel = tk.Frame(main_frame) left_panel = tk.Frame(main_frame)
left_panel.grid(row=0, column=0, sticky="nsew", padx=(0, 10)) left_panel.pack(side="left", fill="y", padx=(0, 10))
left_panel.rowconfigure(1, weight=1)
# Video selection frame # Video selection frame
selection_frame = tk.LabelFrame(left_panel, text="📁 Select Short to Edit", padx=10, pady=10) selection_frame = tk.LabelFrame(left_panel, text="📁 Select Short to Edit", padx=10, pady=10)
selection_frame.grid(row=0, column=0, pady=(0, 10), sticky="ew") selection_frame.pack(fill="x", pady=(0, 10))
# Video list with preview info # Video list with preview info
list_frame = tk.Frame(selection_frame) list_frame = tk.Frame(selection_frame)
@ -1871,13 +1871,6 @@ class ShortsEditorGUI:
except Exception as e: except Exception as e:
print(f"Error reading {video_file}: {e}") print(f"Error reading {video_file}: {e}")
# Video player frame (center)
player_frame = tk.Frame(main_frame)
player_frame.pack(side="left", fill="both", expand=True, padx=10)
# Video player
self.create_video_player(player_frame)
# Video selection handler # Video selection handler
def on_video_select(event): def on_video_select(event):
selection = self.video_listbox.curselection() selection = self.video_listbox.curselection()
@ -1898,9 +1891,17 @@ class ShortsEditorGUI:
font=("Courier", 9), justify="left") font=("Courier", 9), justify="left")
self.info_label.pack(anchor="w") self.info_label.pack(anchor="w")
# Editing tools frame (right panel) # Video player frame (center)
self.tools_frame = tk.LabelFrame(main_frame, text="🛠️ Professional Editing Tools", padx=10, pady=10) player_frame = tk.Frame(main_frame)
self.tools_frame.pack(side="right", fill="y", padx=(10, 0)) player_frame.pack(side="left", fill="both", expand=True, padx=10)
# Video player
self.create_video_player(player_frame)
# Editing tools frame (right panel) - Fixed width to ensure visibility
self.tools_frame = tk.LabelFrame(main_frame, text="<EFBFBD>️ Professional Editing Tools", padx=10, pady=10)
self.tools_frame.pack(side="right", fill="both", padx=(10, 0), ipadx=10)
self.tools_frame.config(width=300) # Set minimum width for tools panel
self.create_editing_tools() self.create_editing_tools()
@ -1922,16 +1923,19 @@ class ShortsEditorGUI:
# Action buttons # Action buttons
button_frame = tk.Frame(action_frame) button_frame = tk.Frame(action_frame)
button_frame.pack(fill="x", pady=10) button_frame.pack(fill="x", pady=15) # Increased padding for better visibility
tk.Button(button_frame, text="🔄 Refresh List", tk.Button(button_frame, text="🔄 Refresh List",
command=self.refresh_video_list, bg="#2196F3", fg="white").pack(side="left", padx=5) command=self.refresh_video_list, bg="#2196F3", fg="white",
font=("Arial", 10), pady=5).pack(side="left", padx=8)
tk.Button(button_frame, text="📂 Open Shorts Folder", tk.Button(button_frame, text="📂 Open Shorts Folder",
command=self.open_shorts_folder, bg="#FF9800", fg="white").pack(side="left", padx=5) command=self.open_shorts_folder, bg="#FF9800", fg="white",
font=("Arial", 10), pady=5).pack(side="left", padx=8)
tk.Button(button_frame, text="❌ Close Editor", tk.Button(button_frame, text="❌ Close Editor",
command=self.close_editor, bg="#F44336", fg="white").pack(side="right", padx=5) command=self.close_editor, bg="#F44336", fg="white",
font=("Arial", 10), pady=5).pack(side="right", padx=8)
def create_video_player(self, parent_frame): def create_video_player(self, parent_frame):
"""Create the video player with timeline controls""" """Create the video player with timeline controls"""
@ -2699,8 +2703,10 @@ class ShortsEditorGUI:
import subprocess import subprocess
try: try:
subprocess.run(['explorer', os.path.abspath(self.shorts_folder)], check=True) subprocess.run(['explorer', os.path.abspath(self.shorts_folder)], check=True)
except: except Exception as e:
messagebox.showinfo("Folder Location", f"Shorts folder: {os.path.abspath(self.shorts_folder)}") # Silently fail - no need to show dialog for folder opening issues
print(f"Could not open folder: {e}")
pass
def get_output_path(self, suffix): def get_output_path(self, suffix):
"""Generate output path with timestamp""" """Generate output path with timestamp"""
@ -2876,8 +2882,37 @@ class ShortsGeneratorGUI:
def __init__(self, root): def __init__(self, root):
self.root = root self.root = root
self.root.title("🎬 AI Shorts Generator - Advanced Video Moment Detection") self.root.title("🎬 AI Shorts Generator - Advanced Video Moment Detection")
self.root.geometry("650x650") # Reduced height to eliminate empty space self.root.geometry("750x800")
self.root.minsize(500, 500) # Set minimum size for responsiveness self.root.minsize(600, 650)
# Modern color scheme
self.colors = {
'bg_primary': '#1a1a1a', # Dark background
'bg_secondary': '#2d2d2d', # Card backgrounds
'bg_tertiary': '#3d3d3d', # Elevated elements
'accent_blue': '#007acc', # Primary blue
'accent_green': '#28a745', # Success green
'accent_orange': '#fd7e14', # Warning orange
'accent_purple': '#6f42c1', # Secondary purple
'accent_red': '#dc3545', # Error red
'text_primary': '#ffffff', # Primary text
'text_secondary': '#b8b8b8', # Secondary text
'text_muted': '#6c757d', # Muted text
'border': '#404040', # Border color
'hover': '#4a4a4a' # Hover state
}
self.root.configure(bg=self.colors['bg_primary'])
# Modern fonts
self.fonts = {
'title': ('Segoe UI', 20, 'bold'),
'heading': ('Segoe UI', 14, 'bold'),
'subheading': ('Segoe UI', 12, 'bold'),
'body': ('Segoe UI', 10),
'caption': ('Segoe UI', 9),
'button': ('Segoe UI', 10, 'bold')
}
# Make window responsive # Make window responsive
self.root.rowconfigure(0, weight=1) self.root.rowconfigure(0, weight=1)
@ -2895,16 +2930,29 @@ class ShortsGeneratorGUI:
self.create_widgets() self.create_widgets()
def create_widgets(self): def create_widgets(self):
# Create main scrollable container # Create main scrollable container with modern styling
main_container = tk.Frame(self.root) main_container = tk.Frame(self.root, bg=self.colors['bg_primary'])
main_container.pack(fill="both", expand=True, padx=10, pady=10) main_container.pack(fill="both", expand=True, padx=25, pady=25)
main_container.rowconfigure(0, weight=1) main_container.rowconfigure(0, weight=1)
main_container.columnconfigure(0, weight=1) main_container.columnconfigure(0, weight=1)
# Create canvas and scrollbar for scrolling # Create canvas and scrollbar for scrolling
canvas = tk.Canvas(main_container) canvas = tk.Canvas(main_container, bg=self.colors['bg_primary'], highlightthickness=0)
scrollbar = ttk.Scrollbar(main_container, orient="vertical", command=canvas.yview)
scrollable_frame = tk.Frame(canvas) # Modern scrollbar styling
style = ttk.Style()
style.theme_use('clam')
style.configure("Modern.Vertical.TScrollbar",
background=self.colors['bg_tertiary'],
troughcolor=self.colors['bg_secondary'],
borderwidth=0,
arrowcolor=self.colors['text_secondary'],
darkcolor=self.colors['bg_tertiary'],
lightcolor=self.colors['bg_tertiary'])
scrollbar = ttk.Scrollbar(main_container, orient="vertical", command=canvas.yview,
style="Modern.Vertical.TScrollbar")
scrollable_frame = tk.Frame(canvas, bg=self.colors['bg_primary'])
scrollable_frame.bind( scrollable_frame.bind(
"<Configure>", "<Configure>",
@ -2917,39 +2965,313 @@ class ShortsGeneratorGUI:
# Make scrollable frame responsive # Make scrollable frame responsive
scrollable_frame.columnconfigure(0, weight=1) scrollable_frame.columnconfigure(0, weight=1)
# Title # Modern header section
title_label = tk.Label(scrollable_frame, text="🎬 AI Shorts Generator", font=("Arial", 16, "bold")) header_frame = tk.Frame(scrollable_frame, bg=self.colors['bg_primary'])
title_label.grid(row=0, column=0, pady=10, sticky="ew") header_frame.grid(row=0, column=0, pady=(0, 30), sticky="ew")
# Video selection # Main title with modern typography
video_frame = tk.Frame(scrollable_frame) title_label = tk.Label(header_frame, text="🎬 AI Shorts Generator",
video_frame.grid(row=1, column=0, pady=10, sticky="ew") font=self.fonts['title'], bg=self.colors['bg_primary'],
video_frame.columnconfigure(0, weight=1) fg=self.colors['text_primary'])
title_label.pack()
tk.Label(video_frame, text="Select Video File:").grid(row=0, column=0, sticky="w") # Subtitle
video_select_frame = tk.Frame(video_frame) subtitle_label = tk.Label(header_frame, text="Advanced Video Moment Detection & Generation",
video_select_frame.grid(row=1, column=0, pady=5, sticky="ew") font=self.fonts['caption'], bg=self.colors['bg_primary'],
video_select_frame.columnconfigure(0, weight=1) fg=self.colors['text_secondary'])
subtitle_label.pack(pady=(5, 0))
self.video_label = tk.Label(video_select_frame, text="No video selected", bg="white", relief="sunken") # Video selection card
self.video_label.grid(row=0, column=0, sticky="ew", padx=(0, 5)) video_card = self.create_modern_card(scrollable_frame, "📁 Video Input")
video_card.grid(row=1, column=0, pady=15, sticky="ew")
tk.Button(video_select_frame, text="Browse", command=self.select_video).grid(row=0, column=1) # Output folder card
output_card = self.create_modern_card(scrollable_frame, "📂 Output Settings")
output_card.grid(row=2, column=0, pady=15, sticky="ew")
# Output folder selection # Add content to video card
output_frame = tk.Frame(scrollable_frame) self.setup_video_selection(video_card)
output_frame.grid(row=2, column=0, pady=10, sticky="ew")
output_frame.columnconfigure(0, weight=1)
tk.Label(output_frame, text="Output Folder:").grid(row=0, column=0, sticky="w") # Add content to output card
output_select_frame = tk.Frame(output_frame) self.setup_output_selection(output_card)
output_select_frame.grid(row=1, column=0, pady=5, sticky="ew")
output_select_frame.columnconfigure(0, weight=1)
self.output_label = tk.Label(output_select_frame, text="shorts/", bg="white", relief="sunken") # Settings card
self.output_label.grid(row=0, column=0, sticky="ew", padx=(0, 5)) settings_card = self.create_modern_card(scrollable_frame, "⚙️ Generation Settings")
settings_card.grid(row=3, column=0, pady=15, sticky="ew")
self.setup_settings_panel(settings_card)
tk.Button(output_select_frame, text="Browse", command=self.select_output_folder).grid(row=0, column=1) # Action buttons card
actions_card = self.create_modern_card(scrollable_frame, "🚀 Actions")
actions_card.grid(row=4, column=0, pady=15, sticky="ew")
self.setup_action_buttons(actions_card)
# Progress card
progress_card = self.create_modern_card(scrollable_frame, "📊 Progress")
progress_card.grid(row=5, column=0, pady=15, sticky="ew")
self.setup_progress_panel(progress_card)
# Pack the canvas and scrollbar
canvas.grid(row=0, column=0, sticky="nsew")
scrollbar.grid(row=0, column=1, sticky="ns")
def create_modern_card(self, parent, title):
"""Create a modern card-style container"""
card_frame = tk.Frame(parent, bg=self.colors['bg_secondary'], relief="flat", bd=0)
# Card header with modern styling
header_frame = tk.Frame(card_frame, bg=self.colors['bg_secondary'])
header_frame.pack(fill="x", padx=25, pady=(20, 10))
header_label = tk.Label(header_frame, text=title, font=self.fonts['heading'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'])
header_label.pack(anchor="w")
# Separator line
separator = tk.Frame(card_frame, bg=self.colors['border'], height=1)
separator.pack(fill="x", padx=25)
# Card content area
content_frame = tk.Frame(card_frame, bg=self.colors['bg_secondary'])
content_frame.pack(fill="both", expand=True, padx=25, pady=(15, 25))
return content_frame
def create_modern_button(self, parent, text, command, color, large=False):
"""Create a modern button with hover effects"""
font = self.fonts['button'] if not large else ('Segoe UI', 12, 'bold')
pady = 12 if not large else 16
button = tk.Button(parent, text=text, command=command,
bg=color, fg='white', font=font,
relief="flat", bd=0, pady=pady,
activebackground=self.adjust_color(color, -20),
activeforeground='white',
cursor="hand2")
# Add hover effects
def on_enter(e):
button.config(bg=self.adjust_color(color, 15))
def on_leave(e):
button.config(bg=color)
button.bind("<Enter>", on_enter)
button.bind("<Leave>", on_leave)
return button
def adjust_color(self, hex_color, adjustment):
"""Adjust color brightness for hover effects"""
hex_color = hex_color.lstrip('#')
rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
adjusted = tuple(max(0, min(255, c + adjustment)) for c in rgb)
return f"#{adjusted[0]:02x}{adjusted[1]:02x}{adjusted[2]:02x}"
def setup_video_selection(self, parent):
"""Setup the video selection interface"""
parent.columnconfigure(0, weight=1)
self.video_label = tk.Label(parent, text="No video selected",
font=self.fonts['body'], bg=self.colors['bg_tertiary'],
fg=self.colors['text_secondary'], relief="flat",
anchor="w", pady=12, padx=15, bd=1,
highlightbackground=self.colors['border'],
highlightthickness=1)
self.video_label.grid(row=0, column=0, sticky="ew", pady=(0, 15))
browse_btn = self.create_modern_button(parent, "📁 Browse Video",
self.select_video, self.colors['accent_blue'])
browse_btn.grid(row=1, column=0, sticky="ew")
def setup_output_selection(self, parent):
"""Setup the output folder selection interface"""
parent.columnconfigure(0, weight=1)
self.output_label = tk.Label(parent, text="shorts/",
font=self.fonts['body'], bg=self.colors['bg_tertiary'],
fg=self.colors['text_secondary'], relief="flat",
anchor="w", pady=12, padx=15, bd=1,
highlightbackground=self.colors['border'],
highlightthickness=1)
self.output_label.grid(row=0, column=0, sticky="ew", pady=(0, 15))
browse_btn = self.create_modern_button(parent, "📂 Browse Folder",
self.select_output_folder, self.colors['accent_blue'])
browse_btn.grid(row=1, column=0, sticky="ew")
def setup_settings_panel(self, parent):
"""Setup the settings panel with modern styling"""
parent.columnconfigure(0, weight=1)
# Max clips setting
clips_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
clips_frame.grid(row=0, column=0, sticky="ew", pady=(0, 20))
clips_frame.columnconfigure(1, weight=1)
self.use_max_clips = tk.BooleanVar(value=True)
clips_checkbox = tk.Checkbutton(clips_frame, variable=self.use_max_clips,
text="Limit clips:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary'],
selectcolor=self.colors['accent_blue'], relief="flat", bd=0)
clips_checkbox.grid(row=0, column=0, sticky="w", padx=(0, 15))
self.clips_var = tk.IntVar(value=3)
self.clips_spinbox = tk.Spinbox(clips_frame, from_=1, to=10, width=8,
textvariable=self.clips_var, font=self.fonts['body'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
relief="flat", bd=1, highlightbackground=self.colors['border'])
self.clips_spinbox.grid(row=0, column=2, sticky="e")
# Detection mode
detection_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
detection_frame.grid(row=1, column=0, sticky="ew", pady=(0, 20))
detection_frame.columnconfigure(1, weight=1)
tk.Label(detection_frame, text="Detection Mode:", font=self.fonts['subheading'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary']).grid(row=0, column=0, sticky="w")
self.detection_mode_var = tk.StringVar(value="loud")
self.detection_display_var = tk.StringVar(value="🔊 Loud Moments")
# Modern combobox styling
detection_style = ttk.Style()
detection_style.configure("Modern.TCombobox",
fieldbackground=self.colors['bg_tertiary'],
background=self.colors['bg_tertiary'],
foreground=self.colors['text_primary'],
arrowcolor=self.colors['text_secondary'],
borderwidth=1,
relief="flat")
detection_dropdown = ttk.Combobox(detection_frame, textvariable=self.detection_display_var,
values=["🔊 Loud Moments", "🎬 Scene Changes", "🏃 Motion Intensity",
"😄 Emotional Speech", "🎵 Audio Peaks", "🎯 Smart Combined"],
state="readonly", width=25, font=self.fonts['body'],
style="Modern.TCombobox")
detection_dropdown.grid(row=0, column=1, sticky="e")
# Store the mapping between display text and internal values
self.mode_mapping = {
"🔊 Loud Moments": "loud",
"🎬 Scene Changes": "scene",
"🏃 Motion Intensity": "motion",
"😄 Emotional Speech": "speech",
"🎵 Audio Peaks": "peaks",
"🎯 Smart Combined": "combined"
}
# Audio threshold (for loud moments)
self.threshold_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
self.threshold_frame.grid(row=2, column=0, sticky="ew", pady=(0, 20))
self.threshold_frame.columnconfigure(1, weight=1)
tk.Label(self.threshold_frame, text="Audio Threshold (dB):", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary']).grid(row=0, column=0, sticky="w")
self.threshold_var = tk.IntVar(value=-30)
threshold_spinbox = tk.Spinbox(self.threshold_frame, from_=-50, to=0, width=8,
textvariable=self.threshold_var, font=self.fonts['body'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
relief="flat", bd=1, highlightbackground=self.colors['border'])
threshold_spinbox.grid(row=0, column=2, sticky="e")
# Clip duration
duration_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
duration_frame.grid(row=3, column=0, sticky="ew")
duration_frame.columnconfigure(1, weight=1)
tk.Label(duration_frame, text="Clip Duration (seconds):", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary']).grid(row=0, column=0, sticky="w")
self.duration_var = tk.IntVar(value=5)
duration_spinbox = tk.Spinbox(duration_frame, from_=3, to=120, width=8,
textvariable=self.duration_var, font=self.fonts['body'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
relief="flat", bd=1, highlightbackground=self.colors['border'])
duration_spinbox.grid(row=0, column=2, sticky="e")
# Bind dropdown change event
def on_detection_change(event):
selection = detection_dropdown.get()
self.detection_mode_var.set(self.mode_mapping.get(selection, "loud"))
# Show/hide threshold setting based on mode
if selection == "🔊 Loud Moments":
self.threshold_frame.grid(row=2, column=0, sticky="ew", pady=(0, 20))
else:
self.threshold_frame.grid_remove()
detection_dropdown.bind("<<ComboboxSelected>>", on_detection_change)
# Bind checkbox to enable/disable spinbox
def toggle_clips_limit():
if self.use_max_clips.get():
self.clips_spinbox.config(state="normal")
else:
self.clips_spinbox.config(state="disabled")
self.use_max_clips.trace("w", lambda *args: toggle_clips_limit())
clips_checkbox.config(command=toggle_clips_limit)
def setup_action_buttons(self, parent):
"""Setup the action buttons with modern styling"""
parent.columnconfigure(0, weight=1)
# Preview button
self.preview_btn = self.create_modern_button(parent, "🔍 Preview Clips",
self.preview_clips, self.colors['accent_blue'])
self.preview_btn.grid(row=0, column=0, sticky="ew", pady=(0, 10))
# Generate button - primary action
self.generate_btn = self.create_modern_button(parent, "🎬 Generate Shorts",
self.start_generation, self.colors['accent_green'],
large=True)
self.generate_btn.grid(row=1, column=0, sticky="ew", pady=(0, 15))
# Secondary actions
button_grid = tk.Frame(parent, bg=self.colors['bg_secondary'])
button_grid.grid(row=2, column=0, sticky="ew")
button_grid.columnconfigure(0, weight=1)
button_grid.columnconfigure(1, weight=1)
self.edit_btn = self.create_modern_button(button_grid, "✏️ Edit Shorts",
self.open_shorts_editor, self.colors['accent_orange'])
self.edit_btn.grid(row=0, column=0, sticky="ew", padx=(0, 5))
self.thumbnail_btn = self.create_modern_button(button_grid, "📸 Thumbnails",
self.open_thumbnail_editor, self.colors['accent_purple'])
self.thumbnail_btn.grid(row=0, column=1, sticky="ew", padx=(5, 0))
def setup_progress_panel(self, parent):
"""Setup the progress panel with modern styling"""
parent.columnconfigure(0, weight=1)
# Progress info
self.progress_label = tk.Label(parent, text="Ready to generate shorts",
font=self.fonts['body'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
self.progress_label.grid(row=0, column=0, sticky="ew", pady=(0, 10))
# Modern progress bar
progress_style = ttk.Style()
progress_style.configure("Modern.Horizontal.TProgressbar",
background=self.colors['accent_green'],
troughcolor=self.colors['bg_tertiary'],
borderwidth=0, lightcolor=self.colors['accent_green'],
darkcolor=self.colors['accent_green'])
self.progress_bar = ttk.Progressbar(parent, length=400, mode="determinate",
style="Modern.Horizontal.TProgressbar")
self.progress_bar.grid(row=1, column=0, sticky="ew", pady=(0, 10))
# Detection progress (initially hidden)
self.detection_progress_label = tk.Label(parent, text="", font=self.fonts['caption'],
bg=self.colors['bg_secondary'], fg=self.colors['accent_blue'])
self.detection_progress_bar = ttk.Progressbar(parent, length=400, mode="determinate",
style="Modern.Horizontal.TProgressbar")
# Initially hide detection progress
self.detection_progress_label.grid_remove()
self.detection_progress_bar.grid_remove()
# Settings frame # Settings frame
settings_frame = tk.LabelFrame(scrollable_frame, text="Settings", padx=10, pady=10) settings_frame = tk.LabelFrame(scrollable_frame, text="Settings", padx=10, pady=10)

897
thumbnail_editor.py
View File

@ -1,286 +1,631 @@
import os import os
import tkinter as tk import tkinter as tk
from tkinter import filedialog, simpledialog, colorchooser, messagebox from tkinter import filedialog, simpledialog, colorchooser, messagebox, ttk
from moviepy import VideoFileClip from moviepy import VideoFileClip
from PIL import Image, ImageTk, ImageDraw, ImageFont from PIL import Image, ImageTk, ImageDraw, ImageFont
# Enhanced Thumbnail Editor with Frame Slider + Default Emoji Pack + Text Adding # Modern Thumbnail Editor with Professional UI Design
def open_thumbnail_editor(video_path): class ModernThumbnailEditor:
try: def __init__(self, video_path):
editor = tk.Toplevel() self.video_path = video_path
editor.title("📸 Professional Thumbnail Editor") self.clip = None
editor.geometry("1200x800") self.current_frame_img = None
self.canvas_items = []
self.drag_data = {"item": None, "x": 0, "y": 0}
# Modern color scheme
self.colors = {
'bg_primary': '#1a1a1a', # Dark background
'bg_secondary': '#2d2d2d', # Card backgrounds
'bg_tertiary': '#3d3d3d', # Elevated elements
'accent_blue': '#007acc', # Primary blue
'accent_green': '#28a745', # Success green
'accent_orange': '#fd7e14', # Warning orange
'accent_purple': '#6f42c1', # Secondary purple
'accent_red': '#dc3545', # Error red
'text_primary': '#ffffff', # Primary text
'text_secondary': '#b8b8b8', # Secondary text
'text_muted': '#6c757d', # Muted text
'border': '#404040', # Border color
'hover': '#4a4a4a' # Hover state
}
# Modern fonts
self.fonts = {
'title': ('Segoe UI', 18, 'bold'),
'heading': ('Segoe UI', 14, 'bold'),
'subheading': ('Segoe UI', 12, 'bold'),
'body': ('Segoe UI', 10),
'caption': ('Segoe UI', 9),
'button': ('Segoe UI', 10, 'bold')
}
self.setup_ui()
def setup_ui(self):
self.editor = tk.Toplevel()
self.editor.title("📸 Professional Thumbnail Editor")
self.editor.geometry("1200x800") # Reduced window size to match smaller canvas
self.editor.minsize(1000, 700) # Reduced minimum size
self.editor.configure(bg=self.colors['bg_primary'])
# Load video # Load video
print(f"📹 Loading video: {os.path.basename(video_path)}")
clip = VideoFileClip(video_path)
duration = int(clip.duration)
# Default emoji pack folder
stickers_folder = os.path.join(os.path.dirname(__file__), "stickers")
os.makedirs(stickers_folder, exist_ok=True)
# Create default stickers if folder is empty
create_default_stickers(stickers_folder)
# Main layout
main_frame = tk.Frame(editor)
main_frame.pack(fill="both", expand=True, padx=10, pady=10)
# Canvas setup (left side)
canvas_frame = tk.Frame(main_frame)
canvas_frame.pack(side="left", fill="both", expand=True)
tk.Label(canvas_frame, text="🎬 Thumbnail Preview", font=("Arial", 12, "bold")).pack()
canvas = tk.Canvas(canvas_frame, width=720, height=405, bg="black", relief="sunken", bd=2)
canvas.pack(pady=10)
# Track items for dragging
drag_data = {"item": None, "x": 0, "y": 0}
def capture_frame_at(time_sec):
try: try:
frame = clip.get_frame(max(0, min(time_sec, clip.duration - 0.1))) print(f"📹 Loading video: {os.path.basename(self.video_path)}")
self.clip = VideoFileClip(self.video_path)
self.duration = int(self.clip.duration)
except Exception as e:
messagebox.showerror("Video Error", f"Failed to load video: {e}")
self.editor.destroy()
return
# Setup stickers folder
self.stickers_folder = os.path.join(os.path.dirname(__file__), "stickers")
os.makedirs(self.stickers_folder, exist_ok=True)
self.create_default_stickers()
self.create_modern_interface()
def create_modern_interface(self):
"""Create the modern thumbnail editor interface"""
# Header
header_frame = tk.Frame(self.editor, bg=self.colors['bg_secondary'], height=70)
header_frame.pack(fill="x", padx=0, pady=0)
header_frame.pack_propagate(False)
title_frame = tk.Frame(header_frame, bg=self.colors['bg_secondary'])
title_frame.pack(expand=True, fill="both", padx=30, pady=15)
title_label = tk.Label(title_frame, text="📸 Professional Thumbnail Editor",
font=self.fonts['title'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
title_label.pack(side="left")
# Video info
video_name = os.path.basename(self.video_path)
info_label = tk.Label(title_frame, text=f"Editing: {video_name}",
font=self.fonts['caption'], bg=self.colors['bg_secondary'],
fg=self.colors['text_secondary'])
info_label.pack(side="right")
# Main content area
main_container = tk.Frame(self.editor, bg=self.colors['bg_primary'])
main_container.pack(fill="both", expand=True, padx=20, pady=20)
# Left panel - Canvas area
left_panel = tk.Frame(main_container, bg=self.colors['bg_secondary'])
left_panel.pack(side="left", fill="both", expand=True, padx=(0, 10))
self.setup_canvas_area(left_panel)
# Right panel - Controls
right_panel = tk.Frame(main_container, bg=self.colors['bg_secondary'], width=350)
right_panel.pack(side="right", fill="y")
right_panel.pack_propagate(False)
self.setup_controls_panel(right_panel)
def setup_canvas_area(self, parent):
"""Setup the main canvas area with modern styling"""
# Canvas header
canvas_header = tk.Frame(parent, bg=self.colors['bg_secondary'])
canvas_header.pack(fill="x", padx=20, pady=(20, 10))
canvas_title = tk.Label(canvas_header, text="🎬 Thumbnail Preview",
font=self.fonts['heading'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
canvas_title.pack(side="left")
# Canvas container
canvas_container = tk.Frame(parent, bg=self.colors['bg_tertiary'], relief="flat", bd=2)
canvas_container.pack(fill="both", expand=True, padx=20, pady=(0, 20))
# Calculate proper canvas size based on video dimensions
video_width, video_height = self.clip.size
aspect_ratio = video_width / video_height
# Set canvas size to maintain video aspect ratio (reduced to match video player)
max_width, max_height = 480, 360 # Smaller size for better interface fit
if aspect_ratio > max_width / max_height:
# Video is wider
canvas_width = max_width
canvas_height = int(max_width / aspect_ratio)
else:
# Video is taller
canvas_height = max_height
canvas_width = int(max_height * aspect_ratio)
# Modern canvas with proper video proportions
self.canvas = tk.Canvas(canvas_container, bg='#000000', highlightthickness=0,
relief="flat", bd=0, width=canvas_width, height=canvas_height)
self.canvas.pack(padx=10, pady=10) # Remove expand=True to maintain fixed size
# Store canvas dimensions for boundary checking
self.canvas_width = canvas_width
self.canvas_height = canvas_height
# Store center coordinates for consistent frame positioning
self.canvas_center_x = canvas_width // 2
self.canvas_center_y = canvas_height // 2
# Add visual border to show canvas boundaries
self.canvas.create_rectangle(2, 2, canvas_width-2, canvas_height-2,
outline='#333333', width=1, tags="border")
# Bind canvas events for dragging
self.canvas.bind("<Button-1>", self.on_canvas_click)
self.canvas.bind("<B1-Motion>", self.on_canvas_drag)
self.canvas.bind("<ButtonRelease-1>", self.on_canvas_release)
# Frame timeline slider
timeline_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
timeline_frame.pack(fill="x", padx=20, pady=(0, 20))
tk.Label(timeline_frame, text="⏱️ Timeline", font=self.fonts['subheading'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary']).pack(anchor="w", pady=(0, 10))
# Modern slider styling
style = ttk.Style()
style.configure("Modern.Horizontal.TScale",
background=self.colors['bg_secondary'],
troughcolor=self.colors['bg_tertiary'],
sliderlength=20,
sliderrelief="flat")
self.time_var = tk.DoubleVar(value=0)
self.time_slider = ttk.Scale(timeline_frame, from_=0, to=self.duration,
orient="horizontal", variable=self.time_var,
command=self.on_time_change, style="Modern.Horizontal.TScale")
self.time_slider.pack(fill="x", pady=(0, 5))
# Time display
time_display_frame = tk.Frame(timeline_frame, bg=self.colors['bg_secondary'])
time_display_frame.pack(fill="x")
self.time_label = tk.Label(time_display_frame, text="00:00",
font=self.fonts['body'], bg=self.colors['bg_secondary'],
fg=self.colors['text_secondary'])
self.time_label.pack(side="left")
duration_label = tk.Label(time_display_frame, text=f"/ {self.duration//60:02d}:{self.duration%60:02d}",
font=self.fonts['body'], bg=self.colors['bg_secondary'],
fg=self.colors['text_muted'])
duration_label.pack(side="right")
# Load initial frame
self.update_canvas_frame(0)
def setup_controls_panel(self, parent):
"""Setup the right panel controls with modern design"""
# Scroll container for controls
scroll_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
scroll_frame.pack(fill="both", expand=True, padx=20, pady=20)
# Title
controls_title = tk.Label(scroll_frame, text="🎨 Editing Tools",
font=self.fonts['heading'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
controls_title.pack(anchor="w", pady=(0, 20))
# Text Tools Card
self.create_text_tools_card(scroll_frame)
# Stickers Card
self.create_stickers_card(scroll_frame)
# Export Card
self.create_export_card(scroll_frame)
def create_text_tools_card(self, parent):
"""Create modern text tools card"""
text_card = self.create_modern_card(parent, "✍️ Text Tools")
# Add text button
add_text_btn = self.create_modern_button(text_card, "➕ Add Text",
self.colors['accent_blue'], self.add_text)
add_text_btn.pack(fill="x", pady=(0, 10))
# Text style options
style_frame = tk.Frame(text_card, bg=self.colors['bg_secondary'])
style_frame.pack(fill="x", pady=(0, 10))
tk.Label(style_frame, text="Text Size:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w")
# Replace limited buttons with spinbox for any size
size_control_frame = tk.Frame(style_frame, bg=self.colors['bg_secondary'])
size_control_frame.pack(fill="x", pady=(5, 0))
self.text_size_var = tk.IntVar(value=36)
size_spinbox = tk.Spinbox(size_control_frame, from_=8, to=200, increment=1,
textvariable=self.text_size_var, width=10,
font=self.fonts['body'], bg=self.colors['bg_tertiary'],
fg=self.colors['text_primary'], insertbackground=self.colors['text_primary'],
buttonbackground=self.colors['accent_blue'],
relief="flat", bd=1, highlightthickness=1,
highlightcolor=self.colors['accent_blue'],
command=self.update_selected_text_size)
size_spinbox.pack(side="left", padx=(0, 10))
# Bind spinbox value changes
self.text_size_var.trace('w', lambda *args: self.update_selected_text_size())
# Quick size buttons for common sizes
quick_sizes_frame = tk.Frame(size_control_frame, bg=self.colors['bg_secondary'])
quick_sizes_frame.pack(side="left")
tk.Label(quick_sizes_frame, text="Quick:", font=self.fonts['caption'],
bg=self.colors['bg_secondary'], fg=self.colors['text_muted']).pack(side="left", padx=(0, 5))
for size in [24, 36, 48, 64, 80]:
btn = tk.Button(quick_sizes_frame, text=str(size), font=self.fonts['caption'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
relief="flat", bd=0, padx=8, pady=3,
activebackground=self.colors['hover'],
command=lambda s=size: self.text_size_var.set(s))
btn.pack(side="left", padx=(0, 3))
self.add_hover_effect(btn)
# Text color
color_frame = tk.Frame(text_card, bg=self.colors['bg_secondary'])
color_frame.pack(fill="x", pady=(10, 0))
tk.Label(color_frame, text="Text Color:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w")
self.text_color_btn = self.create_modern_button(color_frame, "🎨 Choose Color",
self.colors['accent_purple'], self.choose_text_color)
self.text_color_btn.pack(fill="x", pady=(5, 0))
self.current_text_color = "#FFFFFF"
def create_stickers_card(self, parent):
"""Create modern stickers card"""
stickers_card = self.create_modern_card(parent, "😊 Stickers & Emojis")
# Load stickers button
load_btn = self.create_modern_button(stickers_card, "📁 Load Custom Sticker",
self.colors['accent_green'], self.load_custom_sticker)
load_btn.pack(fill="x", pady=(0, 15))
# Default stickers grid
stickers_frame = tk.Frame(stickers_card, bg=self.colors['bg_secondary'])
stickers_frame.pack(fill="x")
tk.Label(stickers_frame, text="Default Stickers:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w", pady=(0, 10))
# Create grid for stickers
self.create_stickers_grid(stickers_frame)
def create_stickers_grid(self, parent):
"""Create a grid of default stickers"""
sticker_files = [f for f in os.listdir(self.stickers_folder) if f.endswith(('.png', '.jpg', '.jpeg'))]
grid_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
grid_frame.pack(fill="x")
cols = 3
for i, sticker_file in enumerate(sticker_files[:12]): # Limit to 12 stickers
row = i // cols
col = i % cols
try:
sticker_path = os.path.join(self.stickers_folder, sticker_file)
img = Image.open(sticker_path)
img.thumbnail((40, 40), Image.Resampling.LANCZOS)
photo = ImageTk.PhotoImage(img)
btn = tk.Button(grid_frame, image=photo,
bg=self.colors['bg_tertiary'], relief="flat", bd=0,
activebackground=self.colors['hover'],
command=lambda path=sticker_path: self.add_sticker(path))
btn.image = photo # Keep reference
btn.grid(row=row, column=col, padx=5, pady=5, sticky="nsew")
self.add_hover_effect(btn)
# Configure grid weights
grid_frame.grid_columnconfigure(col, weight=1)
except Exception as e:
print(f"⚠️ Error loading sticker {sticker_file}: {e}")
def create_export_card(self, parent):
"""Create modern export options card"""
export_card = self.create_modern_card(parent, "💾 Export Options")
# Clear all button
clear_btn = self.create_modern_button(export_card, "🗑️ Clear All Elements",
self.colors['accent_orange'], self.clear_all_elements)
clear_btn.pack(fill="x", pady=(0, 10))
# Save thumbnail button
save_btn = self.create_modern_button(export_card, "💾 Save Thumbnail",
self.colors['accent_green'], self.save_thumbnail)
save_btn.pack(fill="x", pady=(0, 10))
# Close editor button
close_btn = self.create_modern_button(export_card, "❌ Close Editor",
self.colors['accent_red'], self.close_editor)
close_btn.pack(fill="x")
def create_modern_card(self, parent, title):
"""Create a modern card container"""
card_frame = tk.Frame(parent, bg=self.colors['bg_tertiary'], relief="flat", bd=0)
card_frame.pack(fill="x", pady=(0, 20))
# Card header
header_frame = tk.Frame(card_frame, bg=self.colors['bg_tertiary'])
header_frame.pack(fill="x", padx=15, pady=(15, 10))
title_label = tk.Label(header_frame, text=title, font=self.fonts['subheading'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'])
title_label.pack(anchor="w")
# Card content
content_frame = tk.Frame(card_frame, bg=self.colors['bg_secondary'])
content_frame.pack(fill="both", expand=True, padx=15, pady=(0, 15))
return content_frame
def create_modern_button(self, parent, text, color, command):
"""Create a modern styled button"""
btn = tk.Button(parent, text=text, font=self.fonts['button'],
bg=color, fg=self.colors['text_primary'],
relief="flat", bd=0, padx=20, pady=12,
activebackground=self.colors['hover'],
command=command, cursor="hand2")
self.add_hover_effect(btn, color)
return btn
def add_hover_effect(self, widget, base_color=None):
"""Add hover effect to widget"""
if base_color is None:
base_color = self.colors['bg_tertiary']
def on_enter(e):
widget.configure(bg=self.colors['hover'])
def on_leave(e):
widget.configure(bg=base_color)
widget.bind("<Enter>", on_enter)
widget.bind("<Leave>", on_leave)
def capture_frame_at(self, time_sec):
"""Capture frame from video at specific time, sized for canvas"""
try:
frame = self.clip.get_frame(max(0, min(time_sec, self.clip.duration - 0.1)))
img = Image.fromarray(frame) img = Image.fromarray(frame)
# Maintain aspect ratio while fitting in canvas # Maintain aspect ratio while fitting in the smaller canvas
img.thumbnail((720, 405), Image.Resampling.LANCZOS) img.thumbnail((self.canvas_width, self.canvas_height), Image.Resampling.LANCZOS)
return img return img
except Exception as e: except Exception as e:
print(f"⚠️ Error capturing frame: {e}") print(f"⚠️ Error capturing frame: {e}")
# Create a placeholder image # Create a placeholder image sized for canvas
img = Image.new('RGB', (720, 405), color='black') img = Image.new('RGB', (self.canvas_width, self.canvas_height), color='black')
return img return img
# Displayed image def update_canvas_frame(self, time_sec):
current_frame = capture_frame_at(duration // 2) """Update canvas with frame at specific time, centered within bounds"""
tk_frame_img = ImageTk.PhotoImage(current_frame)
image_item = canvas.create_image(360, 202, image=tk_frame_img)
canvas.image = tk_frame_img
# Items data
sticker_items = []
text_items = []
def update_canvas_frame(val):
nonlocal current_frame, tk_frame_img
try: try:
sec = float(val) self.current_frame_img = self.capture_frame_at(time_sec)
current_frame = capture_frame_at(sec) self.tk_frame_img = ImageTk.PhotoImage(self.current_frame_img)
tk_frame_img = ImageTk.PhotoImage(current_frame)
canvas.itemconfig(image_item, image=tk_frame_img) # Clear canvas and add new frame, centered within canvas bounds
canvas.image = tk_frame_img self.canvas.delete("frame")
# Use stored center coordinates for consistent positioning
self.canvas.create_image(self.canvas_center_x, self.canvas_center_y,
image=self.tk_frame_img, tags="frame")
self.canvas.image = self.tk_frame_img
# Update time display
minutes = int(time_sec) // 60
seconds = int(time_sec) % 60
self.time_label.config(text=f"{minutes:02d}:{seconds:02d}")
except Exception as e: except Exception as e:
print(f"⚠️ Error updating frame: {e}") print(f"⚠️ Error updating frame: {e}")
# Frame controls def on_time_change(self, val):
controls_frame = tk.Frame(canvas_frame) """Handle timeline slider change"""
controls_frame.pack(fill="x", pady=5) self.update_canvas_frame(float(val))
tk.Label(controls_frame, text="⏱️ Frame Time (seconds):").pack() # Canvas interaction methods
frame_slider = tk.Scale(controls_frame, from_=0, to=duration, orient="horizontal", def on_canvas_click(self, event):
command=update_canvas_frame, length=600, resolution=0.1) """Handle canvas click for dragging (excluding video frame)"""
frame_slider.set(duration // 2) item = self.canvas.find_closest(event.x, event.y)[0]
frame_slider.pack(fill="x", pady=5) # Prevent dragging the video frame or border
if item and item not in self.canvas.find_withtag("frame") and item not in self.canvas.find_withtag("border"):
self.drag_data["item"] = item
self.drag_data["x"] = event.x
self.drag_data["y"] = event.y
# Tools panel (right side) def on_canvas_drag(self, event):
tools_frame = tk.Frame(main_frame, width=300, relief="groove", bd=2) """Handle canvas dragging with boundary constraints"""
tools_frame.pack(side="right", fill="y", padx=(10, 0)) if self.drag_data["item"]:
tools_frame.pack_propagate(False) dx = event.x - self.drag_data["x"]
dy = event.y - self.drag_data["y"]
tk.Label(tools_frame, text="🛠️ Editing Tools", font=("Arial", 14, "bold")).pack(pady=10) # Get current item position and bounds
item = self.drag_data["item"]
bbox = self.canvas.bbox(item)
# Stickers section if bbox:
stickers_label_frame = tk.LabelFrame(tools_frame, text="🎭 Stickers & Emojis", padx=10, pady=5) x1, y1, x2, y2 = bbox
stickers_label_frame.pack(fill="x", padx=10, pady=5)
# Create scrollable frame for stickers # Calculate new position
stickers_canvas = tk.Canvas(stickers_label_frame, height=200) new_x1 = x1 + dx
stickers_scrollbar = tk.Scrollbar(stickers_label_frame, orient="vertical", command=stickers_canvas.yview) new_y1 = y1 + dy
stickers_scrollable_frame = tk.Frame(stickers_canvas) new_x2 = x2 + dx
new_y2 = y2 + dy
stickers_scrollable_frame.bind( # Check boundaries and constrain movement
"<Configure>", if new_x1 < 0:
lambda e: stickers_canvas.configure(scrollregion=stickers_canvas.bbox("all")) dx = -x1
) elif new_x2 > self.canvas_width:
dx = self.canvas_width - x2
stickers_canvas.create_window((0, 0), window=stickers_scrollable_frame, anchor="nw") if new_y1 < 0:
stickers_canvas.configure(yscrollcommand=stickers_scrollbar.set) dy = -y1
elif new_y2 > self.canvas_height:
dy = self.canvas_height - y2
stickers_canvas.pack(side="left", fill="both", expand=True) # Move item with constraints
stickers_scrollbar.pack(side="right", fill="y") self.canvas.move(item, dx, dy)
self.drag_data["x"] = event.x
self.drag_data["y"] = event.y
def add_sticker(path): def on_canvas_release(self, event):
"""Handle canvas release"""
self.drag_data["item"] = None
# Editing functionality
def add_text(self):
"""Add text to the canvas within boundaries"""
text = simpledialog.askstring("Add Text", "Enter text:")
if text:
try:
size = self.text_size_var.get()
# Center text but ensure it's within canvas bounds
x = min(self.canvas_width // 2, self.canvas_width - 50)
y = min(self.canvas_height // 2, self.canvas_height - 30)
item = self.canvas.create_text(x, y, text=text, fill=self.current_text_color,
font=("Arial", size, "bold"), tags="draggable")
self.canvas_items.append(("text", item, text, self.current_text_color, size))
print(f"✅ Added text: {text}")
except Exception as e:
print(f"⚠️ Error adding text: {e}")
def update_selected_text_size(self):
"""Update the size of selected text items"""
try:
new_size = self.text_size_var.get()
# Update all selected text items or the last added text
for i, (item_type, item_id, text, color, size) in enumerate(self.canvas_items):
if item_type == "text":
# Update the font size
current_font = self.canvas.itemcget(item_id, "font")
if isinstance(current_font, str):
font_parts = current_font.split()
if len(font_parts) >= 2:
font_family = font_parts[0]
font_style = font_parts[2] if len(font_parts) > 2 else "bold"
new_font = (font_family, new_size, font_style)
else:
new_font = ("Arial", new_size, "bold")
else:
new_font = ("Arial", new_size, "bold")
self.canvas.itemconfig(item_id, font=new_font)
# Update the stored size in canvas_items
self.canvas_items[i] = (item_type, item_id, text, color, new_size)
except Exception as e:
print(f"⚠️ Error updating text size: {e}")
def choose_text_color(self):
"""Choose text color"""
color = colorchooser.askcolor(title="Choose text color")
if color[1]:
self.current_text_color = color[1]
# Update button color to show current selection
self.text_color_btn.config(bg=self.current_text_color)
def add_sticker(self, path):
"""Add sticker to canvas within boundaries"""
try: try:
img = Image.open(path).convert("RGBA") img = Image.open(path).convert("RGBA")
img.thumbnail((60, 60), Image.Resampling.LANCZOS) img.thumbnail((60, 60), Image.Resampling.LANCZOS)
tk_img = ImageTk.PhotoImage(img) tk_img = ImageTk.PhotoImage(img)
item = canvas.create_image(360, 200, image=tk_img)
# Place sticker within canvas bounds
x = min(self.canvas_width // 2, self.canvas_width - 30)
y = min(self.canvas_height // 2, self.canvas_height - 30)
item = self.canvas.create_image(x, y, image=tk_img, tags="draggable")
# Keep reference to prevent garbage collection # Keep reference to prevent garbage collection
if not hasattr(canvas, 'images'): if not hasattr(self.canvas, 'images'):
canvas.images = [] self.canvas.images = []
canvas.images.append(tk_img) self.canvas.images.append(tk_img)
sticker_items.append((item, img)) self.canvas_items.append(("sticker", item, img, path))
print(f"✅ Added sticker: {os.path.basename(path)}") print(f"✅ Added sticker: {os.path.basename(path)}")
except Exception as e: except Exception as e:
print(f"⚠️ Failed to load sticker {path}: {e}") print(f"⚠️ Failed to load sticker {path}: {e}")
# Load default stickers def load_custom_sticker(self):
sticker_count = 0 """Load custom sticker file"""
stickers_row_frame = None
for file in os.listdir(stickers_folder):
if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
try:
if sticker_count % 4 == 0: # 4 stickers per row
stickers_row_frame = tk.Frame(stickers_scrollable_frame)
stickers_row_frame.pack(fill="x", pady=2)
btn_img = Image.open(os.path.join(stickers_folder, file)).convert("RGBA")
btn_img.thumbnail((40, 40), Image.Resampling.LANCZOS)
tk_btn_img = ImageTk.PhotoImage(btn_img)
b = tk.Button(stickers_row_frame, image=tk_btn_img,
command=lambda f=file: add_sticker(os.path.join(stickers_folder, f)))
b.image = tk_btn_img
b.pack(side="left", padx=2)
sticker_count += 1
except Exception as e:
print(f"⚠️ Failed to load sticker {file}: {e}")
# Add custom sticker button
tk.Button(stickers_label_frame, text="📁 Add Custom Sticker",
command=lambda: add_custom_sticker()).pack(pady=5)
def add_custom_sticker():
file_path = filedialog.askopenfilename( file_path = filedialog.askopenfilename(
title="Select Sticker Image", title="Select Sticker",
filetypes=[("Image files", "*.png *.jpg *.jpeg *.gif"), ("All files", "*.*")] filetypes=[("Image files", "*.png *.jpg *.jpeg *.gif *.bmp")]
) )
if file_path: if file_path:
add_sticker(file_path) self.add_sticker(file_path)
# Text section def clear_all_elements(self):
text_label_frame = tk.LabelFrame(tools_frame, text="📝 Text Tools", padx=10, pady=5) """Clear all added elements"""
text_label_frame.pack(fill="x", padx=10, pady=5) # Clear all draggable items
self.canvas.delete("draggable")
self.canvas_items.clear()
if hasattr(self.canvas, 'images'):
self.canvas.images.clear()
print("🗑️ Cleared all elements")
def add_text(): def save_thumbnail(self):
text_value = simpledialog.askstring("Add Text", "Enter text:") """Save the current thumbnail"""
if not text_value: if not self.current_frame_img:
messagebox.showerror("Error", "No frame loaded")
return return
color_result = colorchooser.askcolor(title="Choose text color")
color = color_result[1] if color_result[1] else "white"
size = simpledialog.askinteger("Font size", "Enter font size:",
initialvalue=48, minvalue=8, maxvalue=200)
if not size:
size = 48
try:
item = canvas.create_text(360, 200, text=text_value, fill=color,
font=("Arial", size, "bold"), anchor="center")
text_items.append((item, text_value, color, size))
print(f"✅ Added text: '{text_value}'")
except Exception as e:
print(f"⚠️ Error adding text: {e}")
tk.Button(text_label_frame, text="➕ Add Text", command=add_text,
bg="#4CAF50", fg="white", font=("Arial", 10, "bold")).pack(pady=5, fill="x")
# Clear all button
def clear_all():
if messagebox.askyesno("Clear All", "Remove all stickers and text?"):
for item_id, _ in sticker_items + text_items:
canvas.delete(item_id)
sticker_items.clear()
text_items.clear()
print("🗑️ Cleared all items")
tk.Button(text_label_frame, text="🗑️ Clear All", command=clear_all,
bg="#F44336", fg="white").pack(pady=5, fill="x")
# Drag handling
def on_drag_start(event):
items = canvas.find_overlapping(event.x, event.y, event.x, event.y)
items = [i for i in items if i != image_item]
if not items:
return
item = items[-1] # topmost
drag_data["item"] = item
drag_data["x"] = event.x
drag_data["y"] = event.y
def on_drag_motion(event):
if drag_data["item"] is None:
return
dx = event.x - drag_data["x"]
dy = event.y - drag_data["y"]
canvas.move(drag_data["item"], dx, dy)
drag_data["x"] = event.x
drag_data["y"] = event.y
def on_drag_release(event):
drag_data["item"] = None
canvas.bind("<Button-1>", on_drag_start)
canvas.bind("<B1-Motion>", on_drag_motion)
canvas.bind("<ButtonRelease-1>", on_drag_release)
# Save section
save_frame = tk.LabelFrame(tools_frame, text="💾 Export Options", padx=10, pady=5)
save_frame.pack(fill="x", padx=10, pady=5)
def save_thumbnail():
try:
save_path = filedialog.asksaveasfilename( save_path = filedialog.asksaveasfilename(
title="Save Thumbnail",
defaultextension=".jpg", defaultextension=".jpg",
filetypes=[("JPEG", "*.jpg"), ("PNG", "*.png"), ("All files", "*.*")], filetypes=[("JPEG files", "*.jpg"), ("PNG files", "*.png")]
title="Save Thumbnail As"
) )
if not save_path: if not save_path:
return return
print("💾 Generating high-quality thumbnail...") try:
# Create a copy of the current frame
# Get the current frame at full resolution frame = self.current_frame_img.copy().convert("RGBA")
sec = float(frame_slider.get()) canvas_width = self.canvas.winfo_width()
frame = Image.fromarray(clip.get_frame(sec)).convert("RGBA") canvas_height = self.canvas.winfo_height()
# Calculate scaling factors # Calculate scaling factors
canvas_w, canvas_h = 720, 405 scale_x = frame.width / canvas_width
scale_x = frame.width / canvas_w scale_y = frame.height / canvas_height
scale_y = frame.height / canvas_h
# Add stickers draw = ImageDraw.Draw(frame)
for item_id, sticker_img in sticker_items:
coords = canvas.coords(item_id) # Process all canvas items
for item_type, item_id, *data in self.canvas_items:
coords = self.canvas.coords(item_id)
if not coords: if not coords:
continue continue
if item_type == "sticker":
# Handle sticker overlay
img_data, path = data
x, y = coords[0], coords[1] x, y = coords[0], coords[1]
# Convert canvas coordinates to frame coordinates
px = int(x * scale_x) px = int(x * scale_x)
py = int(y * scale_y) py = int(y * scale_y)
# Scale sticker size # Scale sticker size
target_w = int(sticker_img.width * scale_x) sticker_img = img_data.copy()
target_h = int(sticker_img.height * scale_y) new_size = (int(60 * scale_x), int(60 * scale_y))
sticker_img = sticker_img.resize(new_size, Image.Resampling.LANCZOS)
if target_w > 0 and target_h > 0: # Calculate position to center the sticker
sticker_resized = sticker_img.resize((target_w, target_h), Image.Resampling.LANCZOS) paste_x = px - sticker_img.width // 2
# Paste with alpha blending paste_y = py - sticker_img.height // 2
frame.paste(sticker_resized, (px - target_w//2, py - target_h//2), sticker_resized)
# Add text frame.paste(sticker_img, (paste_x, paste_y), sticker_img)
draw = ImageDraw.Draw(frame)
for item_id, text_value, color, font_size in text_items:
coords = canvas.coords(item_id)
if not coords:
continue
elif item_type == "text":
# Handle text overlay
text_value, color, font_size = data
x, y = coords[0], coords[1] x, y = coords[0], coords[1]
px = int(x * scale_x) px = int(x * scale_x)
py = int(y * scale_y) py = int(y * scale_y)
@ -325,70 +670,68 @@ def open_thumbnail_editor(video_path):
print(f"❌ Error saving thumbnail: {e}") print(f"❌ Error saving thumbnail: {e}")
messagebox.showerror("Error", f"Failed to save thumbnail:\n{str(e)}") messagebox.showerror("Error", f"Failed to save thumbnail:\n{str(e)}")
tk.Button(save_frame, text="💾 Save Thumbnail", command=save_thumbnail, def close_editor(self):
bg="#2196F3", fg="white", font=("Arial", 12, "bold")).pack(pady=5, fill="x") """Close the editor"""
# Info label
info_text = f"📹 Video: {os.path.basename(video_path)}\n⏱️ Duration: {duration}s\n📐 Size: {clip.size[0]}x{clip.size[1]}"
tk.Label(save_frame, text=info_text, font=("Arial", 8), justify="left").pack(pady=5)
print(f"✅ Thumbnail editor loaded successfully!")
except Exception as e:
print(f"❌ Error opening thumbnail editor: {e}")
messagebox.showerror("Error", f"Failed to open thumbnail editor:\n{str(e)}")
def create_default_stickers(stickers_folder):
"""Create some default emoji stickers if folder is empty"""
if os.listdir(stickers_folder):
return # Already has stickers
try: try:
from PIL import Image, ImageDraw if self.clip:
self.clip.close()
except:
pass
self.editor.destroy()
# Create simple emoji stickers def create_default_stickers(self):
emojis = [ """Create default emoji stickers"""
("😀", (255, 255, 0)), # Happy face stickers_data = {
("❤️", (255, 0, 0)), # Heart "smile.png": "😊",
("👍", (255, 220, 177)), # Thumbs up "laugh.png": "😂",
("🔥", (255, 100, 0)), # Fire "happy-face.png": "😀",
("⭐", (255, 215, 0)), # Star "sad-face.png": "😢",
("💯", (0, 255, 0)), # 100 "confused.png": "😕",
] "party.png": "🎉",
"emoji.png": "👍",
"emoji (1).png": "❤️",
"smile (1).png": "😄"
}
for i, (emoji, color) in enumerate(emojis): for filename, emoji in stickers_data.items():
# Create a simple colored circle as placeholder filepath = os.path.join(self.stickers_folder, filename)
img = Image.new('RGBA', (80, 80), (0, 0, 0, 0)) if not os.path.exists(filepath):
try:
# Create simple emoji images
img = Image.new('RGBA', (64, 64), (255, 255, 255, 0))
draw = ImageDraw.Draw(img) draw = ImageDraw.Draw(img)
draw.ellipse([10, 10, 70, 70], fill=color)
# Save as PNG # Try to use a font for emoji, fallback to colored rectangles
img.save(os.path.join(stickers_folder, f"emoji_{i+1}.png"))
print("✅ Created default sticker pack")
except Exception as e:
print(f"⚠️ Could not create default stickers: {e}")
# Main execution
if __name__ == '__main__':
root = tk.Tk()
root.withdraw()
video_path = filedialog.askopenfilename(
title='Select a video file',
filetypes=[('Video files', '*.mp4 *.mov *.avi *.mkv'), ('All files', '*.*')]
)
if video_path:
try: try:
root.deiconify() # Show root window font = ImageFont.truetype("seguiemj.ttf", 48)
root.title("Thumbnail Editor") draw.text((8, 8), emoji, font=font, fill="black")
open_thumbnail_editor(video_path) except:
root.mainloop() # Fallback: create colored circles/shapes
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD', '#98D8C8', '#F7DC6F', '#BB8FCE']
color = colors[hash(filename) % len(colors)]
draw.ellipse([8, 8, 56, 56], fill=color)
draw.text((20, 20), emoji[:2], fill="white", font=ImageFont.load_default())
img.save(filepath, 'PNG')
print(f"✅ Created default sticker: {filename}")
except Exception as e: except Exception as e:
print(f"❌ Error: {e}") print(f"⚠️ Error creating sticker {filename}: {e}")
messagebox.showerror("Error", f"Failed to start thumbnail editor:\n{str(e)}")
# Legacy function to maintain compatibility
def open_thumbnail_editor(video_path):
"""Legacy function for backward compatibility"""
editor = ModernThumbnailEditor(video_path)
return editor
if __name__ == "__main__":
# Test the editor
test_video = "myvideo.mp4" # Replace with actual video path
if os.path.exists(test_video):
root = tk.Tk()
root.withdraw() # Hide main window
editor = ModernThumbnailEditor(test_video)
root.mainloop()
else: else:
print('No video selected.') print("Please provide a valid video file path")
root.destroy()

626
thumbnail_editor_modern.py Normal file
View File

@ -0,0 +1,626 @@
import os
import tkinter as tk
from tkinter import filedialog, simpledialog, colorchooser, messagebox, ttk
from moviepy import VideoFileClip
from PIL import Image, ImageTk, ImageDraw, ImageFont
# Modern Thumbnail Editor with Professional UI Design
class ModernThumbnailEditor:
def __init__(self, video_path):
self.video_path = video_path
self.clip = None
self.current_frame_img = None
self.canvas_items = []
self.drag_data = {"item": None, "x": 0, "y": 0}
# Modern color scheme
self.colors = {
'bg_primary': '#1a1a1a', # Dark background
'bg_secondary': '#2d2d2d', # Card backgrounds
'bg_tertiary': '#3d3d3d', # Elevated elements
'accent_blue': '#007acc', # Primary blue
'accent_green': '#28a745', # Success green
'accent_orange': '#fd7e14', # Warning orange
'accent_purple': '#6f42c1', # Secondary purple
'accent_red': '#dc3545', # Error red
'text_primary': '#ffffff', # Primary text
'text_secondary': '#b8b8b8', # Secondary text
'text_muted': '#6c757d', # Muted text
'border': '#404040', # Border color
'hover': '#4a4a4a' # Hover state
}
# Modern fonts
self.fonts = {
'title': ('Segoe UI', 18, 'bold'),
'heading': ('Segoe UI', 14, 'bold'),
'subheading': ('Segoe UI', 12, 'bold'),
'body': ('Segoe UI', 10),
'caption': ('Segoe UI', 9),
'button': ('Segoe UI', 10, 'bold')
}
self.setup_ui()
def setup_ui(self):
self.editor = tk.Toplevel()
self.editor.title("📸 Professional Thumbnail Editor")
self.editor.geometry("1400x900")
self.editor.minsize(1200, 800)
self.editor.configure(bg=self.colors['bg_primary'])
# Load video
try:
print(f"📹 Loading video: {os.path.basename(self.video_path)}")
self.clip = VideoFileClip(self.video_path)
self.duration = int(self.clip.duration)
except Exception as e:
messagebox.showerror("Video Error", f"Failed to load video: {e}")
self.editor.destroy()
return
# Setup stickers folder
self.stickers_folder = os.path.join(os.path.dirname(__file__), "stickers")
os.makedirs(self.stickers_folder, exist_ok=True)
self.create_default_stickers()
self.create_modern_interface()
def create_modern_interface(self):
"""Create the modern thumbnail editor interface"""
# Header
header_frame = tk.Frame(self.editor, bg=self.colors['bg_secondary'], height=70)
header_frame.pack(fill="x", padx=0, pady=0)
header_frame.pack_propagate(False)
title_frame = tk.Frame(header_frame, bg=self.colors['bg_secondary'])
title_frame.pack(expand=True, fill="both", padx=30, pady=15)
title_label = tk.Label(title_frame, text="📸 Professional Thumbnail Editor",
font=self.fonts['title'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
title_label.pack(side="left")
# Video info
video_name = os.path.basename(self.video_path)
info_label = tk.Label(title_frame, text=f"Editing: {video_name}",
font=self.fonts['caption'], bg=self.colors['bg_secondary'],
fg=self.colors['text_secondary'])
info_label.pack(side="right")
# Main content area
main_container = tk.Frame(self.editor, bg=self.colors['bg_primary'])
main_container.pack(fill="both", expand=True, padx=20, pady=20)
# Left panel - Canvas area
left_panel = tk.Frame(main_container, bg=self.colors['bg_secondary'])
left_panel.pack(side="left", fill="both", expand=True, padx=(0, 10))
self.setup_canvas_area(left_panel)
# Right panel - Controls
right_panel = tk.Frame(main_container, bg=self.colors['bg_secondary'], width=350)
right_panel.pack(side="right", fill="y")
right_panel.pack_propagate(False)
self.setup_controls_panel(right_panel)
def setup_canvas_area(self, parent):
"""Setup the main canvas area with modern styling"""
# Canvas header
canvas_header = tk.Frame(parent, bg=self.colors['bg_secondary'])
canvas_header.pack(fill="x", padx=20, pady=(20, 10))
canvas_title = tk.Label(canvas_header, text="🎬 Thumbnail Preview",
font=self.fonts['heading'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
canvas_title.pack(side="left")
# Canvas container
canvas_container = tk.Frame(parent, bg=self.colors['bg_tertiary'], relief="flat", bd=2)
canvas_container.pack(fill="both", expand=True, padx=20, pady=(0, 20))
# Modern canvas with dark theme
self.canvas = tk.Canvas(canvas_container, bg='#000000', highlightthickness=0,
relief="flat", bd=0)
self.canvas.pack(fill="both", expand=True, padx=10, pady=10)
# Bind canvas events for dragging
self.canvas.bind("<Button-1>", self.on_canvas_click)
self.canvas.bind("<B1-Motion>", self.on_canvas_drag)
self.canvas.bind("<ButtonRelease-1>", self.on_canvas_release)
# Frame timeline slider
timeline_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
timeline_frame.pack(fill="x", padx=20, pady=(0, 20))
tk.Label(timeline_frame, text="⏱️ Timeline", font=self.fonts['subheading'],
bg=self.colors['bg_secondary'], fg=self.colors['text_primary']).pack(anchor="w", pady=(0, 10))
# Modern slider styling
style = ttk.Style()
style.configure("Modern.Horizontal.TScale",
background=self.colors['bg_secondary'],
troughcolor=self.colors['bg_tertiary'],
sliderlength=20,
sliderrelief="flat")
self.time_var = tk.DoubleVar(value=0)
self.time_slider = ttk.Scale(timeline_frame, from_=0, to=self.duration,
orient="horizontal", variable=self.time_var,
command=self.on_time_change, style="Modern.Horizontal.TScale")
self.time_slider.pack(fill="x", pady=(0, 5))
# Time display
time_display_frame = tk.Frame(timeline_frame, bg=self.colors['bg_secondary'])
time_display_frame.pack(fill="x")
self.time_label = tk.Label(time_display_frame, text="00:00",
font=self.fonts['body'], bg=self.colors['bg_secondary'],
fg=self.colors['text_secondary'])
self.time_label.pack(side="left")
duration_label = tk.Label(time_display_frame, text=f"/ {self.duration//60:02d}:{self.duration%60:02d}",
font=self.fonts['body'], bg=self.colors['bg_secondary'],
fg=self.colors['text_muted'])
duration_label.pack(side="right")
# Load initial frame
self.update_canvas_frame(0)
def setup_controls_panel(self, parent):
"""Setup the right panel controls with modern design"""
# Scroll container for controls
scroll_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
scroll_frame.pack(fill="both", expand=True, padx=20, pady=20)
# Title
controls_title = tk.Label(scroll_frame, text="🎨 Editing Tools",
font=self.fonts['heading'], bg=self.colors['bg_secondary'],
fg=self.colors['text_primary'])
controls_title.pack(anchor="w", pady=(0, 20))
# Text Tools Card
self.create_text_tools_card(scroll_frame)
# Stickers Card
self.create_stickers_card(scroll_frame)
# Export Card
self.create_export_card(scroll_frame)
def create_text_tools_card(self, parent):
"""Create modern text tools card"""
text_card = self.create_modern_card(parent, "✍️ Text Tools")
# Add text button
add_text_btn = self.create_modern_button(text_card, "➕ Add Text",
self.colors['accent_blue'], self.add_text)
add_text_btn.pack(fill="x", pady=(0, 10))
# Text style options
style_frame = tk.Frame(text_card, bg=self.colors['bg_secondary'])
style_frame.pack(fill="x", pady=(0, 10))
tk.Label(style_frame, text="Text Size:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w")
self.text_size_var = tk.IntVar(value=36)
size_frame = tk.Frame(style_frame, bg=self.colors['bg_secondary'])
size_frame.pack(fill="x", pady=(5, 0))
for size in [24, 36, 48, 64]:
btn = tk.Button(size_frame, text=str(size), font=self.fonts['caption'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'],
relief="flat", bd=0, padx=10, pady=5,
activebackground=self.colors['hover'],
command=lambda s=size: self.text_size_var.set(s))
btn.pack(side="left", padx=(0, 5))
self.add_hover_effect(btn)
# Text color
color_frame = tk.Frame(text_card, bg=self.colors['bg_secondary'])
color_frame.pack(fill="x", pady=(10, 0))
tk.Label(color_frame, text="Text Color:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w")
self.text_color_btn = self.create_modern_button(color_frame, "🎨 Choose Color",
self.colors['accent_purple'], self.choose_text_color)
self.text_color_btn.pack(fill="x", pady=(5, 0))
self.current_text_color = "#FFFFFF"
def create_stickers_card(self, parent):
"""Create modern stickers card"""
stickers_card = self.create_modern_card(parent, "😊 Stickers & Emojis")
# Load stickers button
load_btn = self.create_modern_button(stickers_card, "📁 Load Custom Sticker",
self.colors['accent_green'], self.load_custom_sticker)
load_btn.pack(fill="x", pady=(0, 15))
# Default stickers grid
stickers_frame = tk.Frame(stickers_card, bg=self.colors['bg_secondary'])
stickers_frame.pack(fill="x")
tk.Label(stickers_frame, text="Default Stickers:", font=self.fonts['body'],
bg=self.colors['bg_secondary'], fg=self.colors['text_secondary']).pack(anchor="w", pady=(0, 10))
# Create grid for stickers
self.create_stickers_grid(stickers_frame)
def create_stickers_grid(self, parent):
"""Create a grid of default stickers"""
sticker_files = [f for f in os.listdir(self.stickers_folder) if f.endswith(('.png', '.jpg', '.jpeg'))]
grid_frame = tk.Frame(parent, bg=self.colors['bg_secondary'])
grid_frame.pack(fill="x")
cols = 3
for i, sticker_file in enumerate(sticker_files[:12]): # Limit to 12 stickers
row = i // cols
col = i % cols
try:
sticker_path = os.path.join(self.stickers_folder, sticker_file)
img = Image.open(sticker_path)
img.thumbnail((40, 40), Image.Resampling.LANCZOS)
photo = ImageTk.PhotoImage(img)
btn = tk.Button(grid_frame, image=photo,
bg=self.colors['bg_tertiary'], relief="flat", bd=0,
activebackground=self.colors['hover'],
command=lambda path=sticker_path: self.add_sticker(path))
btn.image = photo # Keep reference
btn.grid(row=row, column=col, padx=5, pady=5, sticky="nsew")
self.add_hover_effect(btn)
# Configure grid weights
grid_frame.grid_columnconfigure(col, weight=1)
except Exception as e:
print(f"⚠️ Error loading sticker {sticker_file}: {e}")
def create_export_card(self, parent):
"""Create modern export options card"""
export_card = self.create_modern_card(parent, "💾 Export Options")
# Clear all button
clear_btn = self.create_modern_button(export_card, "🗑️ Clear All Elements",
self.colors['accent_orange'], self.clear_all_elements)
clear_btn.pack(fill="x", pady=(0, 10))
# Save thumbnail button
save_btn = self.create_modern_button(export_card, "💾 Save Thumbnail",
self.colors['accent_green'], self.save_thumbnail)
save_btn.pack(fill="x", pady=(0, 10))
# Close editor button
close_btn = self.create_modern_button(export_card, "❌ Close Editor",
self.colors['accent_red'], self.close_editor)
close_btn.pack(fill="x")
def create_modern_card(self, parent, title):
"""Create a modern card container"""
card_frame = tk.Frame(parent, bg=self.colors['bg_tertiary'], relief="flat", bd=0)
card_frame.pack(fill="x", pady=(0, 20))
# Card header
header_frame = tk.Frame(card_frame, bg=self.colors['bg_tertiary'])
header_frame.pack(fill="x", padx=15, pady=(15, 10))
title_label = tk.Label(header_frame, text=title, font=self.fonts['subheading'],
bg=self.colors['bg_tertiary'], fg=self.colors['text_primary'])
title_label.pack(anchor="w")
# Card content
content_frame = tk.Frame(card_frame, bg=self.colors['bg_secondary'])
content_frame.pack(fill="both", expand=True, padx=15, pady=(0, 15))
return content_frame
def create_modern_button(self, parent, text, color, command):
"""Create a modern styled button"""
btn = tk.Button(parent, text=text, font=self.fonts['button'],
bg=color, fg=self.colors['text_primary'],
relief="flat", bd=0, padx=20, pady=12,
activebackground=self.colors['hover'],
command=command, cursor="hand2")
self.add_hover_effect(btn, color)
return btn
def add_hover_effect(self, widget, base_color=None):
"""Add hover effect to widget"""
if base_color is None:
base_color = self.colors['bg_tertiary']
def on_enter(e):
widget.configure(bg=self.colors['hover'])
def on_leave(e):
widget.configure(bg=base_color)
widget.bind("<Enter>", on_enter)
widget.bind("<Leave>", on_leave)
def capture_frame_at(self, time_sec):
"""Capture frame from video at specific time"""
try:
frame = self.clip.get_frame(max(0, min(time_sec, self.clip.duration - 0.1)))
img = Image.fromarray(frame)
# Maintain aspect ratio while fitting in canvas
img.thumbnail((720, 405), Image.Resampling.LANCZOS)
return img
except Exception as e:
print(f"⚠️ Error capturing frame: {e}")
# Create a placeholder image
img = Image.new('RGB', (720, 405), color='black')
return img
def update_canvas_frame(self, time_sec):
"""Update canvas with frame at specific time"""
try:
self.current_frame_img = self.capture_frame_at(time_sec)
self.tk_frame_img = ImageTk.PhotoImage(self.current_frame_img)
# Clear canvas and add new frame
self.canvas.delete("frame")
self.canvas.create_image(360, 202, image=self.tk_frame_img, tags="frame")
self.canvas.image = self.tk_frame_img
# Update time display
minutes = int(time_sec) // 60
seconds = int(time_sec) % 60
self.time_label.config(text=f"{minutes:02d}:{seconds:02d}")
except Exception as e:
print(f"⚠️ Error updating frame: {e}")
def on_time_change(self, val):
"""Handle timeline slider change"""
self.update_canvas_frame(float(val))
# Canvas interaction methods
def on_canvas_click(self, event):
"""Handle canvas click for dragging"""
item = self.canvas.find_closest(event.x, event.y)[0]
if item and item != self.canvas.find_withtag("frame"):
self.drag_data["item"] = item
self.drag_data["x"] = event.x
self.drag_data["y"] = event.y
def on_canvas_drag(self, event):
"""Handle canvas dragging"""
if self.drag_data["item"]:
dx = event.x - self.drag_data["x"]
dy = event.y - self.drag_data["y"]
self.canvas.move(self.drag_data["item"], dx, dy)
self.drag_data["x"] = event.x
self.drag_data["y"] = event.y
def on_canvas_release(self, event):
"""Handle canvas release"""
self.drag_data["item"] = None
# Editing functionality
def add_text(self):
"""Add text to the canvas"""
text = simpledialog.askstring("Add Text", "Enter text:")
if text:
try:
size = self.text_size_var.get()
item = self.canvas.create_text(360, 200, text=text, fill=self.current_text_color,
font=("Arial", size, "bold"), tags="draggable")
self.canvas_items.append(("text", item, text, self.current_text_color, size))
print(f"✅ Added text: {text}")
except Exception as e:
print(f"⚠️ Error adding text: {e}")
def choose_text_color(self):
"""Choose text color"""
color = colorchooser.askcolor(title="Choose text color")
if color[1]:
self.current_text_color = color[1]
# Update button color to show current selection
self.text_color_btn.config(bg=self.current_text_color)
def add_sticker(self, path):
"""Add sticker to canvas"""
try:
img = Image.open(path).convert("RGBA")
img.thumbnail((60, 60), Image.Resampling.LANCZOS)
tk_img = ImageTk.PhotoImage(img)
item = self.canvas.create_image(360, 200, image=tk_img, tags="draggable")
# Keep reference to prevent garbage collection
if not hasattr(self.canvas, 'images'):
self.canvas.images = []
self.canvas.images.append(tk_img)
self.canvas_items.append(("sticker", item, img, path))
print(f"✅ Added sticker: {os.path.basename(path)}")
except Exception as e:
print(f"⚠️ Failed to load sticker {path}: {e}")
def load_custom_sticker(self):
"""Load custom sticker file"""
file_path = filedialog.askopenfilename(
title="Select Sticker",
filetypes=[("Image files", "*.png *.jpg *.jpeg *.gif *.bmp")]
)
if file_path:
self.add_sticker(file_path)
def clear_all_elements(self):
"""Clear all added elements"""
# Clear all draggable items
self.canvas.delete("draggable")
self.canvas_items.clear()
if hasattr(self.canvas, 'images'):
self.canvas.images.clear()
print("🗑️ Cleared all elements")
def save_thumbnail(self):
"""Save the current thumbnail"""
if not self.current_frame_img:
messagebox.showerror("Error", "No frame loaded")
return
save_path = filedialog.asksaveasfilename(
title="Save Thumbnail",
defaultextension=".jpg",
filetypes=[("JPEG files", "*.jpg"), ("PNG files", "*.png")]
)
if not save_path:
return
try:
# Create a copy of the current frame
frame = self.current_frame_img.copy().convert("RGBA")
canvas_width = self.canvas.winfo_width()
canvas_height = self.canvas.winfo_height()
# Calculate scaling factors
scale_x = frame.width / canvas_width
scale_y = frame.height / canvas_height
draw = ImageDraw.Draw(frame)
# Process all canvas items
for item_type, item_id, *data in self.canvas_items:
coords = self.canvas.coords(item_id)
if not coords:
continue
if item_type == "sticker":
# Handle sticker overlay
img_data, path = data
x, y = coords[0], coords[1]
px = int(x * scale_x)
py = int(y * scale_y)
# Scale sticker size
sticker_img = img_data.copy()
new_size = (int(60 * scale_x), int(60 * scale_y))
sticker_img = sticker_img.resize(new_size, Image.Resampling.LANCZOS)
# Calculate position to center the sticker
paste_x = px - sticker_img.width // 2
paste_y = py - sticker_img.height // 2
frame.paste(sticker_img, (paste_x, paste_y), sticker_img)
elif item_type == "text":
# Handle text overlay
text_value, color, font_size = data
x, y = coords[0], coords[1]
px = int(x * scale_x)
py = int(y * scale_y)
# Scale font size
scaled_font_size = int(font_size * scale_x)
try:
font = ImageFont.truetype("arial.ttf", scaled_font_size)
except:
try:
font = ImageFont.truetype("calibri.ttf", scaled_font_size)
except:
font = ImageFont.load_default()
# Get text bounding box for centering
bbox = draw.textbbox((0, 0), text_value, font=font)
text_w = bbox[2] - bbox[0]
text_h = bbox[3] - bbox[1]
# Draw text with outline
outline_w = max(2, scaled_font_size // 15)
for dx in range(-outline_w, outline_w + 1):
for dy in range(-outline_w, outline_w + 1):
draw.text((px - text_w//2 + dx, py - text_h//2 + dy),
text_value, font=font, fill="black")
draw.text((px - text_w//2, py - text_h//2), text_value, font=font, fill=color)
# Convert to RGB and save
if save_path.lower().endswith('.png'):
frame.save(save_path, "PNG", quality=95)
else:
background = Image.new("RGB", frame.size, (255, 255, 255))
background.paste(frame, mask=frame.split()[3] if frame.mode == 'RGBA' else None)
background.save(save_path, "JPEG", quality=95)
print(f"✅ Thumbnail saved: {save_path}")
messagebox.showinfo("Success", f"Thumbnail saved successfully!\n{save_path}")
except Exception as e:
print(f"❌ Error saving thumbnail: {e}")
messagebox.showerror("Error", f"Failed to save thumbnail:\n{str(e)}")
def close_editor(self):
"""Close the editor"""
try:
if self.clip:
self.clip.close()
except:
pass
self.editor.destroy()
def create_default_stickers(self):
"""Create default emoji stickers"""
stickers_data = {
"smile.png": "😊",
"laugh.png": "😂",
"happy-face.png": "😀",
"sad-face.png": "😢",
"confused.png": "😕",
"party.png": "🎉",
"emoji.png": "👍",
"emoji (1).png": "❤️",
"smile (1).png": "😄"
}
for filename, emoji in stickers_data.items():
filepath = os.path.join(self.stickers_folder, filename)
if not os.path.exists(filepath):
try:
# Create simple emoji images
img = Image.new('RGBA', (64, 64), (255, 255, 255, 0))
draw = ImageDraw.Draw(img)
# Try to use a font for emoji, fallback to colored rectangles
try:
font = ImageFont.truetype("seguiemj.ttf", 48)
draw.text((8, 8), emoji, font=font, fill="black")
except:
# Fallback: create colored circles/shapes
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD', '#98D8C8', '#F7DC6F', '#BB8FCE']
color = colors[hash(filename) % len(colors)]
draw.ellipse([8, 8, 56, 56], fill=color)
draw.text((20, 20), emoji[:2], fill="white", font=ImageFont.load_default())
img.save(filepath, 'PNG')
print(f"✅ Created default sticker: {filename}")
except Exception as e:
print(f"⚠️ Error creating sticker {filename}: {e}")
# Legacy function to maintain compatibility
def open_thumbnail_editor(video_path):
"""Legacy function for backward compatibility"""
editor = ModernThumbnailEditor(video_path)
return editor
if __name__ == "__main__":
# Test the editor
test_video = "myvideo.mp4" # Replace with actual video path
if os.path.exists(test_video):
root = tk.Tk()
root.withdraw() # Hide main window
editor = ModernThumbnailEditor(test_video)
root.mainloop()
else:
print("Please provide a valid video file path")