app.py

import tkinter as tk
from tkinter import filedialog, ttk
from PIL import Image, ImageDraw, ImageFont, ImageTk
import os
import sys
import sv_ttk
from emoji import emojis
import webbrowser

class App:
    def __init__(self, root):
        self.root = root
        self.root.title("Snapchat Caption Creator")
        self.root.geometry("1000x800")
        self.theme = tk.StringVar(value="Dark")
        sv_ttk.set_theme(self.theme.get())


        self.path = None
        self.img = None
        self.disp_img = None
        self.txt = tk.StringVar()
        self.y_pos = tk.DoubleVar(value=0.5)
        self.font_size = tk.IntVar(value=24)
        self.opacity = tk.IntVar(value=165)
        self.size = tk.DoubleVar(value=1)
        self.show_advanced = False
        self.auto_caption = True
        self.advanced_frame = None 
        self.initfonts()
        self.GUI()
        
    def initfonts(self):
        self.sf_pro_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "SFPRODISPLAYREGULAR.OTF")
        if not os.path.exists(self.sf_pro_path):
            self.sf_pro_path = None
        self.emoji_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "emoji")

    def textv(self, event=None):
        if self.auto_caption:
            text_content = self.text_widget.get()
            self.txt.set(text_content)
            self.update()

    def toggleadv(self):
        self.show_advanced = not self.show_advanced
        
        if self.show_advanced:
            self.advanced_btn.config(text="Hide Advanced")
            self.advanced_frame.pack(fill=tk.X, pady=10)
        else:
            self.advanced_btn.config(text="Show Advanced")
            self.advanced_frame.pack_forget()

    def togglecap(self):
        self.auto_caption = not self.auto_caption

        if self.auto_caption:
            self.textv()
            self.auto_caption_btn.config(text="Disable Update")
        else:
            self.auto_caption_btn.config(text="Enable Update")
    
    def toggle_theme(self, *args):
        sv_ttk.set_theme(self.theme.get())
        if self.theme.get() == "light":
            self.canvas.config(bg="#f0f0f0")
        else:
            self.canvas.config(bg="#2d2d2d")
        
    def open(self):
        path = filedialog.askopenfilename(filetypes=[("Image files", "*.jpg *.jpeg *.png *.gif *.bmp")]) 
        if path:
            try:
                self.path = path
                self.img = Image.open(path)
                self.update()
                self.status.config(text=f"Image loaded {os.path.basename(path)}")
            except Exception as e:
                self.status.config(text=f"Error loading image: {str(e)}")
    
    def get(self):
        size = self.font_size.get()
        
        try:
            if self.sf_pro_path and os.path.exists(self.sf_pro_path):
                return ImageFont.truetype(self.sf_pro_path, size)
            else:
                for font_name in ["Arial", "Helvetica", "Segoe UI", "Roboto", "San Francisco"]:
                    try:
                        return ImageFont.truetype(font_name, size)
                    except:
                        continue
                
                return ImageFont.load_default()
        except Exception:
            return ImageFont.load_default()
    
    def caption(self, img, text, y_pos):
        result = img.copy()
        draw = ImageDraw.Draw(result)
        
        width, height = result.size
        cap_h = int((height * 0.0877 * 0.5) * self.size.get())
        cap_w = width 
        y_pos = int(y_pos * (height - cap_h))
        opacity = self.opacity.get()
        overlay = Image.new('RGBA', (cap_w, cap_h), (0, 0, 0, opacity))
        
        result.paste(overlay, (0, y_pos), overlay)
        font = self.get()
        
        total_width = 0
        for char in text:
            if char in emojis:
                emoji_size = self.font_size.get()
                total_width += emoji_size
            else:
                if hasattr(draw, 'textlength'):
                    total_width += draw.textlength(char, font=font)
                else:
                    char_width, _ = draw.textsize(char, font=font)
                    total_width += char_width

        text_x = (cap_w - total_width) // 2
        try:
            ascent, descent = font.getmetrics()
            text_y = y_pos + (cap_h - ascent - descent) // 2
        except:
            text_y = y_pos + (cap_h - self.font_size.get()) // 2

        current_x = text_x
        for char in text:
            if char in emojis:
                try:
                    emoji_path = os.path.join(self.emoji_dir, emojis[char])
                    if os.path.exists(emoji_path):
                        emoji_img = Image.open(emoji_path).convert('RGBA')
                        emoji_size = self.font_size.get()
                        emoji_img = emoji_img.resize((emoji_size, emoji_size), Image.Resampling.LANCZOS)
                        emoji_y = (text_y + (ascent - emoji_size)//2) + 4
                        result.paste(emoji_img, (int(current_x), int(emoji_y)), emoji_img)
                        current_x += emoji_size
                except Exception:
                    pass
            else:
                draw.text((current_x, text_y), char, fill=(255, 255, 255), font=font)
                if hasattr(draw, 'textlength'):
                    current_x += draw.textlength(char, font=font)
                else:
                    char_width, _ = draw.textsize(char, font=font)
                    current_x += char_width
        
        return result
    
    def update(self, *args):
        if self.img and self.auto_caption == True:
            try:
                cap_img = self.caption(self.img, self.txt.get(), self.y_pos.get())
                
                if cap_img.mode == 'RGBA':
                    cap_img = cap_img.convert('RGB')
                
                c_width = self.canvas.winfo_width()
                c_height = self.canvas.winfo_height()
                img_width, img_height = cap_img.size
                
                scale = min(c_width/img_width, c_height/img_height)
                
                new_width = int(img_width * scale)
                new_height = int(img_height * scale)
                
                if new_width > 0 and new_height > 0:
                    resized = cap_img.resize((new_width, new_height), Image.Resampling.LANCZOS)
                    
                    self.disp_img = ImageTk.PhotoImage(resized)
                    
                    self.canvas.delete("all")
                    self.canvas.create_image(
                        c_width//2, 
                        c_height//2, 
                        anchor=tk.CENTER,
                        image=self.disp_img
                    )
                    
            except Exception as e:
                self.status.config(text=f"Error: {str(e)}")
    
    def url(self, url, event=None):
        try:
            webbrowser.open_new(url)
            self.status.config(text="Opening link...")
        except Exception as e:
            self.status.config(text=f"Error opening link: {str(e)}")
    
    def save(self):
        if self.img:
            try:
                final = self.caption(self.img, self.txt.get(), self.y_pos.get())
                
                path = filedialog.asksaveasfilename(
                    defaultextension=".png",
                    filetypes=[
                        ("PNG files", "*.png"),
                        ("JPEG files", "*.jpg"),
                        ("All files", "*.*")
                    ]
                )
                
                if path:
                    final.save(path)
                    self.status.config(text=f"Image saved to {os.path.basename(path)}")
            except Exception as e:
                self.status.config(text=f"Error saving image - {str(e)}")

    def GUI(self):
        ctrl = ttk.Frame(self.root, width=300)
        ctrl.pack(side=tk.LEFT, fill=tk.Y, padx=10, pady=10)
        disp = ttk.Frame(self.root)
        disp.pack(side=tk.RIGHT, expand=True, fill=tk.BOTH, padx=10, pady=10)
        self.canvas = tk.Canvas(disp, bg="#2d2d2d", width=700, height=700)
        self.canvas.pack(expand=True, fill=tk.BOTH)
        ttk.Label(ctrl, text="Caption:").pack(anchor=tk.W, pady=(0, 5))
        self.text_widget = ttk.Entry(ctrl, width=30)
        self.text_widget.pack(fill=tk.X, pady=(0, 10))
        self.text_widget.bind("<KeyRelease>", self.textv)
        
        ttk.Label(ctrl, text="Position:").pack(anchor=tk.W, pady=(0, 5))
        self.slider = ttk.Scale(
            ctrl, 
            variable=self.y_pos,
            from_=0.0, 
            to=1.0,
            orient=tk.HORIZONTAL,
            command=self.update
        )
        self.slider.pack(fill=tk.X, pady=(0, 10))
        self.advanced_btn = ttk.Button(ctrl, text="Show Advanced", command=self.toggleadv)
        self.advanced_btn.pack(fill=tk.X, pady=10)
        self.advanced_frame = ttk.LabelFrame(ctrl, text="Advanced Options")
        ttk.Label(self.advanced_frame, text="Font Size:").pack(anchor=tk.W, pady=(0, 5))
        self.font_size_slider = ttk.Scale(
            self.advanced_frame, 
            variable=self.font_size,
            from_=12, 
            to=72,
            orient=tk.HORIZONTAL,
            command=self.update
        )
        self.font_size_slider.pack(fill=tk.X, pady=(0, 10))
        ttk.Label(self.advanced_frame, text="Opacity:").pack(anchor=tk.W, pady=(0, 5))
        self.opacity_slider = ttk.Scale(
            self.advanced_frame, 
            variable=self.opacity,
            from_=0, 
            to=255,
            orient=tk.HORIZONTAL,
            command=self.update
        )
        self.opacity_slider.pack(fill=tk.X, pady=(0, 10))
        ttk.Label(self.advanced_frame, text="Size:").pack(anchor=tk.W, pady=(0, 5))
        self.size_slider = ttk.Scale(
            self.advanced_frame, 
            variable=self.size,
            from_=1.00,
            to=5.00,
            orient=tk.HORIZONTAL,
            command=self.update
        )
        self.size_slider.pack(fill=tk.X, pady=(0, 10))
        self.opacity_slider.pack(fill=tk.X, pady=(0, 10))
        self.auto_caption_btn = ttk.Button(self.advanced_frame, command=self.togglecap, text="Disable Update")
        self.auto_caption_btn.pack(anchor=tk.W, pady=(0, 5))
        ttk.Separator(ctrl, orient="horizontal").pack(fill=tk.X, pady=(20, 10))
        ttk.Button(ctrl, text="Open", command=self.open).pack(fill=tk.X, pady=5)
        ttk.Button(ctrl, text="Export", command=self.save).pack(fill=tk.X, pady=5)
        self.status = ttk.Label(ctrl, text="", anchor=tk.W, wraplength=280)
        self.status.pack(fill=tk.X, pady=(20, 0))
        theme_frame = ttk.Frame(ctrl)
        theme_frame.pack(fill=tk.X, side=tk.BOTTOM, pady=(0, 10))
        ttk.Label(theme_frame, text="Theme:").pack(side=tk.LEFT, padx=(0, 10))
        theme_menu = ttk.Combobox(
            theme_frame, 
            textvariable=self.theme,
            values=["Light", "Dark"],
            state="readonly",
            width=10
        )
        theme_menu.pack(side=tk.RIGHT, fill=tk.X, expand=True)
        self.theme.trace_add("write", self.toggle_theme)

if __name__ == "__main__":
    root = tk.Tk()

    app = App(root)
    previous = (root.winfo_width(), root.winfo_height())
    def on_resize(event):
        global previous
        new = (event.width, event.height)
        if new != previous: 
            previous = new
            app.update()
    root.bind("<Configure>", on_resize)
    
    try:
        root.iconbitmap(os.path.join(os.path.dirname(os.path.abspath(__file__)), "icon.ico"))
    except:
        pass
        
    root.mainloop()