notepad.py

# C0de by Twiez :))

import customtkinter as ctk
import tkinter as tk
from tkinter import filedialog, messagebox
import json
from pathlib import Path
import webbrowser
from tkinter import font

class TwiezNotepad:
    def __init__(self):
        self.root = ctk.CTk()
        self.root.title("Twiez Notepad")
        self.root.geometry("1000x600")
        
        # Available fonts
        self.available_fonts = sorted([f for f in font.families() if not f.startswith("@")])
        
        # Load settings
        self.settings = self.load_settings()
        
        # Set theme
        ctk.set_appearance_mode(self.settings.get("theme", "dark"))
        
        # Create main container
        self.main_container = ctk.CTkFrame(self.root)
        self.main_container.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Create autosave timer
        self.autosave_id = None
        self.modified = False
        
        self.create_gui()
        
    def create_gui(self):
        # Create toolbar
        self.create_toolbar()
        
        # Create text area
        self.create_text_area()
        
    def create_toolbar(self):
        toolbar = ctk.CTkFrame(self.main_container)
        toolbar.pack(fill=tk.X, padx=5, pady=(0, 5))
        
        # Left side controls
        left_frame = ctk.CTkFrame(toolbar)
        left_frame.pack(side=tk.LEFT, fill=tk.X)
        
        # File operations
        new_btn = ctk.CTkButton(left_frame, text="New", command=self.new_file, width=70)
        new_btn.pack(side=tk.LEFT, padx=5)
        
        open_btn = ctk.CTkButton(left_frame, text="Open", command=self.open_file, width=70)
        open_btn.pack(side=tk.LEFT, padx=5)
        
        save_btn = ctk.CTkButton(left_frame, text="Save", command=self.save_file, width=70)
        save_btn.pack(side=tk.LEFT, padx=5)
        
        # Right side controls
        right_frame = ctk.CTkFrame(toolbar)
        right_frame.pack(side=tk.RIGHT, fill=tk.X)
        
        # Font selector
        font_label = ctk.CTkLabel(right_frame, text="Font:")
        font_label.pack(side=tk.LEFT, padx=(5, 0))
        
        self.font_var = ctk.StringVar(value=self.settings.get("font_family", "Consolas"))
        font_menu = ctk.CTkOptionMenu(
            right_frame,
            values=self.available_fonts,
            command=self.change_font,
            variable=self.font_var,
            width=150
        )
        font_menu.pack(side=tk.LEFT, padx=5)
        
        # About button
        about_btn = ctk.CTkButton(right_frame, text="About", command=self.open_github, width=70)
        about_btn.pack(side=tk.LEFT, padx=5)
        
        # Theme switcher
        theme_label = ctk.CTkLabel(right_frame, text="Theme:")
        theme_label.pack(side=tk.LEFT, padx=(5, 0))
        
        self.theme_var = ctk.StringVar(value=self.settings.get("theme", "dark"))
        theme_menu = ctk.CTkOptionMenu(
            right_frame,
            values=["light", "dark", "system"],
            command=self.change_theme,
            variable=self.theme_var,
            width=100
        )
        theme_menu.pack(side=tk.LEFT, padx=5)
        
        # Word count label
        self.word_count_label = ctk.CTkLabel(toolbar, text="Words: 0 | Characters: 0")
        self.word_count_label.pack(side=tk.LEFT, padx=20)
        
    def create_text_area(self):
        # Create text area
        self.text_frame = ctk.CTkFrame(self.main_container)
        self.text_frame.pack(fill=tk.BOTH, expand=True)
        
        # Main text area
        self.text_area = ctk.CTkTextbox(
            self.text_frame,
            font=(self.settings.get("font_family", "Consolas"), 
                  self.settings.get("font_size", 12)),
            wrap=tk.NONE,
            undo=True
        )
        self.text_area.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # Scrollbars
        y_scrollbar = ctk.CTkScrollbar(self.text_frame, command=self.text_area.yview)
        y_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        x_scrollbar = ctk.CTkScrollbar(
            self.main_container,
            orientation=tk.HORIZONTAL,
            command=self.text_area.xview
        )
        x_scrollbar.pack(fill=tk.X)
        
        self.text_area.configure(
            yscrollcommand=y_scrollbar.set,
            xscrollcommand=x_scrollbar.set
        )
        
        # Bind events
        self.text_area.bind("<Control-MouseWheel>", self.handle_zoom)
        self.text_area.bind("<KeyRelease>", self.update_word_count)
        self.text_area.bind("<Control-s>", lambda e: self.save_file())
        self.text_area.bind("<Control-o>", lambda e: self.open_file())
        self.text_area.bind("<Control-n>", lambda e: self.new_file())
        self.text_area.bind("<<Modified>>", self.handle_modification)
        
    def handle_modification(self, event=None):
        if self.text_area.edit_modified():
            self.modified = True
            self.schedule_autosave()
            self.text_area.edit_modified(False)
            
    def schedule_autosave(self):
        if self.autosave_id:
            self.root.after_cancel(self.autosave_id)
        self.autosave_id = self.root.after(30000, self.autosave)  # 30 seconds
        
    def autosave(self):
        if self.modified:
            try:
                backup_file = Path("backup.txt")
                with open(backup_file, 'w', encoding='utf-8') as f:
                    f.write(self.text_area.get("1.0", tk.END))
                self.modified = False
            except Exception as e:
                print(f"Autosave failed: {e}")
        
    def update_word_count(self, event=None):
        content = self.text_area.get("1.0", tk.END).strip()
        words = len(content.split())
        chars = len(content)
        self.word_count_label.configure(text=f"Words: {words} | Characters: {chars}")
        
    def handle_zoom(self, event):
        if event.delta > 0:
            self.increase_font_size()
        else:
            self.decrease_font_size()
        return "break"
        
    def new_file(self):
        if messagebox.askyesno("New File", "Do you want to create a new file? Any unsaved changes will be lost."):
            self.text_area.delete("1.0", tk.END)
            self.root.title("Twiez Notepad - Untitled")
            self.modified = False
            
    def open_file(self):
        file_path = filedialog.askopenfilename(
            defaultextension=".txt",
            filetypes=[
                ("Text files", "*.txt"),
                ("Python files", "*.py"),
                ("All files", "*.*")
            ]
        )
        if file_path:
            try:
                with open(file_path, 'r', encoding='utf-8') as file:
                    self.text_area.delete("1.0", tk.END)
                    self.text_area.insert("1.0", file.read())
                self.root.title(f"Twiez Notepad - {Path(file_path).name}")
                self.modified = False
                self.update_word_count()
            except Exception as e:
                messagebox.showerror("Error", f"Could not open file: {str(e)}")
                
    def save_file(self):
        file_path = filedialog.asksaveasfilename(
            defaultextension=".txt",
            filetypes=[
                ("Text files", "*.txt"),
                ("Python files", "*.py"),
                ("All files", "*.*")
            ]
        )
        if file_path:
            try:
                with open(file_path, 'w', encoding='utf-8') as file:
                    file.write(self.text_area.get("1.0", tk.END))
                self.root.title(f"Twiez Notepad - {Path(file_path).name}")
                self.modified = False
            except Exception as e:
                messagebox.showerror("Error", f"Could not save file: {str(e)}")
                
    def change_theme(self, new_theme):
        ctk.set_appearance_mode(new_theme)
        self.settings["theme"] = new_theme
        self.save_settings()
        
    def change_font(self, new_font):
        self.settings["font_family"] = new_font
        self.update_font()
        self.save_settings()
        
    def increase_font_size(self):
        current_size = self.settings.get("font_size", 12)
        new_size = min(72, current_size + 2)
        self.update_font_size(new_size)
        
    def decrease_font_size(self):
        current_size = self.settings.get("font_size", 12)
        new_size = max(8, current_size - 2)
        self.update_font_size(new_size)
        
    def update_font_size(self, size):
        self.settings["font_size"] = size
        self.update_font()
        self.save_settings()
        
    def update_font(self):
        self.text_area.configure(font=(
            self.settings.get("font_family", "Consolas"),
            self.settings.get("font_size", 12)
        ))
        
    def open_github(self):
        webbrowser.open("https://github.com/twiez")
        
    def load_settings(self):
        try:
            with open("settings.json", "r") as f:
                return json.load(f)
        except FileNotFoundError:
            return {
                "theme": "dark",
                "font_size": 12,
                "font_family": "Consolas"
            }
            
    def save_settings(self):
        with open("settings.json", "w") as f:
            json.dump(self.settings, f)
            
    def run(self):
        self.root.mainloop()

if __name__ == "__main__":
    app = TwiezNotepad()
    app.run()