in the script below, we monitor the clipboard for any changes and then automatically send any text copied into clipboard towards gpt to get translated, and the script also create a window with two paned_window to show both the untranslated text and the translated text. i want you to add another paned_window that we can use to edit the prompt = f"Translate the following text:{text_to_translate}".

import time
import pyperclip
import openai
import json
import tkinter as tk
import threading
from tkinter import font, Menu
from tkinter import font

# Set your OpenAI API key and base
openai.api_base = ""
openai.api_key = ""

# Toggleable features
KEEP_LOGS = False

# Initialize dictionary to store translated texts
translated_dict = {}

# Define JSON file to store translations
jsonfile = "translations.json"

# Load existing translations from JSON file
try:
    with open(jsonfile, "r", encoding="utf-8") as f:
        translated_dict = json.load(f)
except FileNotFoundError:
    pass

def translate_text(text_to_translate):
    prompt = f"Translate the following text:{text_to_translate}"

    try:
        completion = openai.ChatCompletion.create(
            model="gpt-3.5",
            temperature=1,
            messages=[
                {
                    "role": "user",
                    "content": f"{prompt}",
                }
            ],
        )
        translated_text = (
            completion["choices"][0]
            .get("message")
            .get("content")
            .encode("utf8")
            .decode()
        )

    except Exception as e:
        print(e, "Connection Error")

    return translated_text

def update_display(display, text):
    display.delete(1.0, tk.END)
    display.insert(tk.END, text)

def retranslate():
    untranslated_text = untranslated_textbox.get(1.0, tk.END).strip()
    if untranslated_text:
        pyperclip.copy(untranslated_text)

def clipboard_monitor():
    old_clipboard = ""

    while True:
        new_clipboard = pyperclip.paste()
        
        # Remove line breaks from new_clipboard
        # new_clipboard = new_clipboard.replace('\n', '').replace('\r', '')

        # Compare new_clipboard with old_clipboard to detect changes
        if new_clipboard != old_clipboard:
            old_clipboard = new_clipboard
            if new_clipboard in translated_dict:
                translated_text = translated_dict[new_clipboard]
            else:
                try:
                    translated_text = translate_text(new_clipboard)
                except Exception as e:
                    print(e, "Connection Error. Retrying in 5 seconds...")
                    time.sleep(5)
                    continue

                translated_dict[new_clipboard] = translated_text
                if KEEP_LOGS:
                    with open(jsonfile, "w", encoding="utf-8") as f:
                        json.dump(translated_dict, f, ensure_ascii=False, indent=4)

            update_display(untranslated_textbox, new_clipboard)
            update_display(translated_textbox, translated_text)

        time.sleep(1)

def toggle_translated():
    current_bg = translated_textbox.cget("background")
    if current_bg == "black":
        translated_textbox.configure(background="white")
        translated_textbox.delete(1.0, tk.END)
        translated_textbox.insert(tk.END, translated_dict[untranslated_textbox.get(1.0, tk.END).strip()])
    else:
        translated_textbox.configure(background="black")
        translated_textbox.delete(1.0, tk.END)

def set_always_on_top():
    root.attributes("-topmost", always_on_top_var.get())

def increase_opacity():
    opacity = root.attributes("-alpha")
    opacity = min(opacity + 0.1, 1.0)
    root.attributes("-alpha", opacity)

def decrease_opacity():
    opacity = root.attributes("-alpha")
    opacity = max(opacity - 0.1, 0.1)
    root.attributes("-alpha", opacity)

def font_window():
    global current_font
    current_font = {
        "family": font.Font(font=untranslated_textbox["font"]).actual("family"),
        "size": font.Font(font=untranslated_textbox["font"]).actual("size"),
        "color": untranslated_textbox.cget("foreground")
    }

    font_window = tk.Toplevel()
    font_window.title("Font Settings")
    font_window.geometry("150x150")

    font_family = tk.StringVar()
    font_family_label = tk.Label(font_window, text="Font Family")
    font_family_label.pack()
    font_family_entry = tk.Entry(font_window, textvariable=font_family)
    font_family_entry.insert(0, current_font["family"])
    font_family_entry.pack()

    font_size = tk.StringVar()
    font_size_label = tk.Label(font_window, text="Font Size")
    font_size_label.pack()
    font_size_entry = tk.Entry(font_window, textvariable=font_size)
    font_size_entry.insert(0, current_font["size"])
    font_size_entry.pack()

    font_color = tk.StringVar()
    font_color_label = tk.Label(font_window, text="Font Color")
    font_color_label.pack()
    font_color_entry = tk.Entry(font_window, textvariable=font_color)
    font_color_entry.insert(0, current_font["color"])
    font_color_entry.pack()

    def apply_changes():
        new_font_family = font_family.get() or current_font["family"]
        new_font_size = font_size.get() or current_font["size"]
        new_font_color = font_color.get() or current_font["color"]
        current_font = {"family": new_font_family, "size": new_font_size, "color": new_font_color}

        untranslated_textbox.configure(font=(current_font["family"], current_font["size"]), fg=current_font["color"])
        translated_textbox.configure(font=(current_font["family"], current_font["size"]), fg=current_font["color"])
        font_window.destroy()

    apply_button = tk.Button(font_window, text="Apply", command=apply_changes)
    apply_button.pack()

    cancel_button = tk.Button(font_window, text="Cancel", command=font_window.destroy)
    cancel_button.pack()

root = tk.Tk()
root.title("Clipboard Translator")
root.geometry("400x200")

menu_bar = Menu(root)

# Add Options menu
options_menu = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Options", menu=options_menu)

# Add Always on top option to Options menu
always_on_top_var = tk.BooleanVar(value=False)
options_menu.add_checkbutton(label="Always on top", variable=always_on_top_var, command=set_always_on_top)

# Add Increase opacity option to Options menu
options_menu.add_command(label="Increase opacity", command=increase_opacity)

# Add Decrease opacity option to Options menu
options_menu.add_command(label="Decrease opacity", command=decrease_opacity)

# Add Font option to Options menu
options_menu.add_command(label="Font", command=font_window)

root.config(menu=menu_bar)

paned_window = tk.PanedWindow(root, sashrelief="groove", sashwidth=5, orient="horizontal")
paned_window.pack(expand=True, fill="both")

untranslated_textbox = tk.Text(paned_window, wrap="word")
paned_window.add(untranslated_textbox)

translated_textbox = tk.Text(paned_window, wrap="word")
paned_window.add(translated_textbox)

retranslate_button = tk.Button(root, text="Retranslate", command=retranslate)
retranslate_button.place(relx=0, rely=1, anchor="sw")

toggle_button = tk.Button(root, text="Hide", command=toggle_translated)
toggle_button.place(relx=1, rely=1, anchor="se")

if __name__ == "__main__":
    print("Starting Clipboard Translator…\n")
    clipboard_monitor_thread = threading.Thread(target=clipboard_monitor)
    clipboard_monitor_thread.start()
    root.mainloop()