ClobDex.py

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, simpledialog
import os
import random
from datetime import datetime, timedelta
import string

root = tk.Tk()
root.title("ClobDex Backrooms Documentor")
root.protocol("WM_DELETE_WINDOW", lambda: hide_to_system_tray(root))

class TextEditor(ttk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.master = master
        self.master.title("ClobDex Backrooms Documentor")
        self.create_widgets()

    def create_widgets(self):
        # Text area
        self.text = tk.Text(self.master, wrap="word", undo=True)
        self.text.grid(row=0, column=0, sticky="nsew")

        # Menu bar
        self.menu_bar = tk.Menu(self.master)
        self.master.config(menu=self.menu_bar)

        # File menu
        file_menu = tk.Menu(self.menu_bar, tearoff=False)
        file_menu.add_command(label="Open", command=self.open_file, accelerator="Ctrl+O")
        file_menu.add_command(label="Save", command=self.save_file, accelerator="Ctrl+S")
        file_menu.add_command(label="Save As...", command=self.save_file_as, accelerator="Ctrl+Shift+S")
        file_menu.add_separator()
        file_menu.add_command(label="Clear", command=self.clear, accelerator="Ctrl+R")
        file_menu.add_command(label="Exit", command=self.quit)
        self.menu_bar.add_cascade(label="File", menu=file_menu)

        # Edit menu
        edit_menu = tk.Menu(self.menu_bar, tearoff=False)
        edit_menu.add_command(label="Find", command=self.find_text)
        edit_menu.add_command(label="Replace", command=self.replace_text)
        edit_menu.add_separator()
        edit_menu.add_command(label="Undo", command=self.undo, accelerator="Ctrl+Z")
        edit_menu.add_command(label="Redo", command=self.redo, accelerator="Ctrl+Y")
        self.menu_bar.add_cascade(label="Edit", menu=edit_menu)

        # Generate menu
        generate_menu = tk.Menu(self.menu_bar, tearoff=False)

        # Time section
        time_menu = tk.Menu(generate_menu, tearoff=False)
        time_menu.add_command(label="Random Date", command=self.generate_random_date)
        time_menu.add_command(label="Random Time", command=self.generate_random_time)
        time_menu.add_command(label="Date In Range", command=self.set_date_range)
        time_menu.add_command(label="Current Time", command=self.generate_current_time)
        time_menu.add_command(label="Current Date", command=self.generate_current_date)

        # Name section
        name_menu = tk.Menu(generate_menu, tearoff=False)
        name_menu.add_command(label="First Name", command=self.generate_first_name)
        name_menu.add_command(label="Middle Name", command=self.generate_middle_name)
        name_menu.add_command(label="Last Name", command=self.generate_last_name)
        name_menu.add_command(label="Full Name", command=self.generate_full_name)

        # Number section
        number_menu = tk.Menu(generate_menu, tearoff=False)
        number_menu.add_command(label="Generate Number", command=self.generate_number)
        number_menu.add_command(label="Number Range", command=self.generate_number_range)

        # Task Section
        task_menu = tk.Menu(generate_menu, tearoff=False)
        task_menu.add_command(label="Cleaning Task", command=self.generate_cleaning_task)
        task_menu.add_command(label="Gaming Task", command=self.generate_gaming_task)
        task_menu.add_command(label="Vlog Task", command=self.generate_vlog_task)
        task_menu.add_command(label="Coding Task", command=self.generate_coding_task)

        generate_menu.add_cascade(label="Time", menu=time_menu)
        generate_menu.add_cascade(label="Name", menu=name_menu)
        generate_menu.add_cascade(label="Number", menu=number_menu)
        generate_menu.add_cascade(label="Task", menu=number_menu)

        self.menu_bar.add_cascade(label="Generate", menu=generate_menu)

        # Templates menu
        template_menu = tk.Menu(self.menu_bar, tearoff=False)

        backrooms_submenu = tk.Menu(template_menu, tearoff=False)
        backrooms_submenu.add_command(label="Object", command=lambda: self.load_template("temps/object.temp"))
        backrooms_submenu.add_command(label="Level", command=lambda: self.load_template("temps/level.temp"))
        backrooms_submenu.add_command(label="Entity", command=lambda: self.load_template("temps/entity.temp"))
        backrooms_submenu.add_command(label="Phenomena", command=lambda: self.load_template("temps/phenomena.temp"))
        backrooms_submenu.add_command(label="Group", command=lambda: self.load_template("temps/group.temp"))
        backrooms_submenu.add_command(label="Cleaning Services Agreement", command=lambda: self.load_template("temps/cleaning services agreement.temp"))
        backrooms_submenu.add_command(label="Website Privacy Policy", command=lambda: self.load_template("temps/website privacy policy.temp"))

        legal_menu = tk.Menu(template_menu, tearoff=False)
        legal_menu.add_command(label="Resume", command=lambda: self.load_template("temps/resume.temp"))
        legal_menu.add_command(label="Contract", command=lambda: self.load_template("temps/contract.temp"))
        legal_menu.add_command(label="NDA", command=lambda: self.load_template("temps/nda.temp"))
        legal_menu.add_command(label="Employment Agreement", command=lambda: self.load_template("temps/empoyment agreement.temp"))

        backrooms_submenu.add_command(label="Shopping List", command=lambda: self.load_template("temps/shopping list.temp"))

        template_menu.add_cascade(label="Backrooms", menu=backrooms_submenu)
        template_menu.add_cascade(label="Legal", menu=legal_menu)
        template_menu.add_cascade(label="Miscelanious", menu=legal_menu)
        
        self.menu_bar.add_cascade(label="Templates", menu=template_menu)

    def clear(self):
        self.text.delete("1.0", "end")

    def generate_current_time(self):
        current_time = datetime.now().strftime("%I:%M %p")
        self.text.insert("insert", current_time)

    def generate_current_date(self):
        current_date = datetime.now().strftime("%B %d, %Y")
        self.text.insert("insert", current_date)

    def load_template(self, filepath):
        if os.path.exists(filepath):
            with open(filepath, "r") as file:
                self.text.delete("1.0", "end")
                self.text.insert("1.0", file.read())
        else:
            messagebox.showerror("Error", "Template not found!")

    # All other methods are the same as before
    def open_file(self, event=None):
        filepath = filedialog.askopenfilename()
        if filepath:
            with open(filepath, "r") as f:
                text = f.read()
                self.text.delete("1.0", tk.END)
                self.text.insert("1.0", text)
            self.filepath = filepath

    def save_file(self, event=None):
        if self.filepath:
            with open(self.filepath, "w") as f:
                text = self.text.get("1.0", tk.END)
                f.write(text)
        else:
            self.save_file_as()

    def save_file_as(self, event=None):
        filepath = filedialog.asksaveasfilename()
        if filepath:
            with open(filepath, "w") as f:
                text = self.text.get("1.0", tk.END)
                f.write(text)
                self.filepath = filepath

    def find_text(self):
        query = simpledialog.askstring("Find", "Enter text to find:")
        if query:
            idx = self.text.search(query, "1.0", tk.END)
            if idx:
                self.text.tag_remove("highlight", "1.0", tk.END)
                while idx:
                    end_idx = f"{idx}+{len(query)}c"
                    self.text.tag_add("highlight", idx, end_idx)
                    idx = self.text.search(query, end_idx, tk.END)

            self.text.tag_configure("highlight", background="yellow")

    def replace_text(self):
        query = simpledialog.askstring("Replace", "Enter text to replace:")
        if query:
            replace_with = simpledialog.askstring("Replace", "Replace with:")
            if replace_with:
                idx = self.text.search(query, "1.0", tk.END)
                if idx:
                    answer = messagebox.askyesno(
                        "Replace",
                        f"Replace '{query}' with '{replace_with}'?"
                    )
                    if answer:
                        while idx:
                            end_idx = f"{idx}+{len(query)}c"
                            self.text.delete(idx, end_idx)
                            self.text.insert(idx, replace_with)
                            idx = self.text.search(query, tk.END)

    def undo(self, event=None):
        self.text.edit_undo()

    def redo(self, event=None):
        self.text.edit_redo()

    def generate_random_date(self):
        start_date = simpledialog.askstring("Set Date Range", "Enter start date (MM/DD/YYYY):")
        end_date = simpledialog.askstring("Set Date Range", "Enter end date (MM/DD/YYYY):")
        if start_date and end_date:
            start_date = datetime.strptime(start_date, "%m/%d/%Y")
            end_date = datetime.strptime(end_date, "%m/%d/%Y")
            delta = (end_date - start_date).days
            random_days = random.randint(0, delta)
            random_date = start_date + timedelta(days=random_days)
            random_date = max(random_date, start_date)
            random_date = min(random_date, end_date)

        if random_date < start_date or random_date > end_date:
            print(f"Generated date {random_date.strftime('%B %d, %Y')} is not within the given range.")
            self.generate_random_date()
        else:
            self.text.insert("insert", random_date.strftime("%B %d, %Y"))
            print(f"Generated date: {random_date.strftime('%B %d, %Y')}")

    def generate_random_time(self):
        random_time = f"{random.randint(1, 12):02d}:{random.randint(0, 59):02d}"
        self.text.insert("insert", random_time)

    def generate_full_name(self):
        with open("generate/first.name", "r") as file:
            first_names = file.read().splitlines()
            first_name = random.choice(first_names)

        with open("generate/middle.name", "r") as file:
            middle_names = file.read().splitlines()
            middle_name = random.choice(middle_names)

        with open("generate/last.name", "r") as file:
            last_names = file.read().splitlines()
            last_name = random.choice(last_names)

        random_name = f"{first_name} {middle_name} {last_name}."
        self.text.insert("insert", random_name)

    def generate_first_name(self):
        with open("generate/first.name", "r") as file:
            first_names = file.read().splitlines()
            first_name = random.choice(first_names)
            self.text.insert("insert", first_name)

    def generate_last_name(self):
        with open("generate/last.name", "r") as file:
            last_name = file.read().splitlines()
            last_name = random.choice(last_name)
            self.text.insert("insert", last_name)

    def generate_middle_name(self):
        with open("generate/middle.name", "r") as file:
            middle_name = file.read().splitlines()
            middle_name = random.choice(middle_name)
            self.text.insert("insert", middle_name)

    def generate_coding_task(self):
        with open("generate/codin.task", "r") as file:
            coding_task = file.read().splitlines()
            coding_task = random.choice(coding_task)
            self.text.insert("insert", coding_task)

    def generate_vlog_task(self):
        with open("generate/vlog.task", "r") as file:
            coding_task = file.read().splitlines()
            coding_task = random.choice(coding_task)
            self.text.insert("insert", coding_task)

    def generate_cleaning_task(self):
        with open("generate/codin.task", "r") as file:
            coding_task = file.read().splitlines()
            coding_task = random.choice(coding_task)
            self.text.insert("insert", coding_task)

    def generate_gaming_task(self):
        with open("generate/codin.task", "r") as file:
            coding_task = file.read().splitlines()
            coding_task = random.choice(coding_task)
            self.text.insert("insert", coding_task)

    def generate_number(self):
        random_num = random.randint(-2147483648, 2147483647)
        self.text.insert(tk.INSERT, str(random_num))

    def generate_number_range(self):
        min_num = simpledialog.askinteger("Generate Number Range", "Enter minimum number:")
        max_num = simpledialog.askinteger("Generate Number Range", "Enter maximum number:")
        if min_num is not None and max_num is not None and min_num <= max_num:
            random_num = random.randint(min_num, max_num)
            self.text.insert(tk.INSERT, str(random_num))
        else:
            messagebox.showerror("Error", "Invalid range supplied.")

    def set_date_range(self):
        start_date = simpledialog.askstring("Set Date Range", "Enter start date (MM/DD/YYYY):")
        end_date = simpledialog.askstring("Set Date Range", "Enter end date (MM/DD/YYYY):")
        if start_date and end_date:
            try:
                start_date = datetime.strptime(start_date, "%m/%d/%Y")
                end_date = datetime.strptime(end_date, "%m/%d/%Y")
                if start_date > end_date:
                    raise ValueError("Start date must be earlier than end date")
                days_since_1250 = (end_date.date() - datetime(1250, 1, 1).date()).days
                if days_since_1250 < 0:
                    raise ValueError("The year cannot be earlier than 1250.")
                random_days = random.randint(0, days_since_1250)
                random_date = end_date - timedelta(days=random_days)
                self.text.insert("insert", random_date.strftime("%B %d, %Y"))
            except ValueError as e:
                messagebox.showerror("Error", str(e))

# Create the root window
editor = TextEditor(root)
editor.grid(row=0, column=0, sticky="nsew")

# Configure the grid weights to make the text widget fill the entire window
root.grid_columnconfigure(0, weight=1)
root.grid_rowconfigure(0, weight=1)

# Bind the keyboard shortcuts
root.bind("<Control-o>", lambda event: editor.open_file())
root.bind("<Control-s>", lambda event: editor.save_file())
root.bind("<Control-S>", lambda event: editor.save_file_as())
root.bind("<Control-R>", lambda event: editor.clear())

root.update()
root.deiconify()
root.mainloop()