ProperTree.py

#!/usr/bin/env python
import sys, os, binascii, base64, json, re, subprocess, webbrowser, multiprocessing, signal, ctypes
from collections import OrderedDict
try:
    import Tkinter as tk
    import ttk
    import tkFileDialog as fd
    import tkMessageBox as mb
    from tkFont import Font, families
    from tkColorChooser import askcolor as ac
except:
    import tkinter as tk
    import tkinter.ttk as ttk
    from tkinter import filedialog as fd
    from tkinter import messagebox as mb
    from tkinter.font import Font, families
    from tkinter.colorchooser import askcolor as ac
try:
    unicode
except NameError:  # Python 3
    unicode = str
# Add this script's dir to the local PATH var - may improve import consistency
sys.path.append(os.path.abspath(os.path.dirname(__file__)))
from Scripts import plist, plistwindow, downloader

def _check_for_update(queue, version_url = None, user_initiated = False):
    args = [sys.executable]
    file_path = os.path.join(os.path.abspath(os.path.dirname(__file__)),"Scripts","update_check.py")
    if os.path.exists(file_path):
        args.append(file_path)
    else:
        return queue.put({
            "exception":"Could not locate update_check.py.",
            "error":"Missing Required Files",
            "user_initiated":user_initiated
        })
    if version_url: args.extend(["-u",version_url])
    proc = subprocess.Popen(args,stdout=subprocess.PIPE)
    o,e = proc.communicate()
    if sys.version_info >= (3,0): o = o.decode("utf-8")
    try:
        json_data = json.loads(o)
        # Append/update our user_initiated value
        json_data["user_initiated"] = user_initiated
    except:
        return queue.put({
            "exception":"Could not serialize returned JSON data.",
            "error":"An Error Occurred Checking For Updates",
            "user_initiated":user_initiated
        })
    queue.put(json_data)

def _update_tex(queue, tex_url = None, tex_path = None):
    args = [sys.executable]
    file_path = os.path.join(os.path.abspath(os.path.dirname(__file__)),"Scripts","update_check.py")
    if os.path.exists(file_path):
        args.extend([file_path,"-m","tex","-t",tex_path])
    else:
        return queue.put({
            "exception":"Could not locate update_check.py.",
            "error":"Missing Required Files"
        })
    if tex_url: args.extend(["-u",tex_url])
    proc = subprocess.Popen(args,stdout=subprocess.PIPE)
    o,e = proc.communicate()
    if sys.version_info >= (3,0): o = o.decode("utf-8")
    try:
        json_data = json.loads(o)
    except:
        return queue.put({
            "exception":"Could not serialize returned JSON data.",
            "error":"An Error Occurred Downloading Configuration.tex"
        })
    queue.put(json_data)

class ProperTree:
    def __init__(self, plists = []):
        # Create new queues for multiprocessing
        self.queue = multiprocessing.Queue()
        self.tex_queue = multiprocessing.Queue()
        self.creating_window = False
        # Create the new tk object
        self.tk = tk.Tk()
        self.tk.withdraw() # Try to remove before it's drawn
        self.tk.title("Convert Values")
        self.tk.minsize(width=640,height=130)
        self.tk.resizable(True, False)
        self.tk.columnconfigure(2,weight=1)
        self.tk.columnconfigure(3,weight=1)
        # Build the Hex <--> Base64 converter
        f_label = tk.Label(self.tk, text="From:")
        f_label.grid(row=0,column=0,sticky="e",padx=10,pady=10)
        t_label = tk.Label(self.tk, text="To:")
        t_label.grid(row=1,column=0,sticky="e",padx=10,pady=10)

        # Create the settings window
        self.settings_window = tk.Toplevel(self.tk)
        self.settings_window.withdraw() # Try to remove before it's drawn
        self.settings_window.title("ProperTree Settings")
        self.settings_window.resizable(False, False)
        self.settings_window.columnconfigure(0,weight=1)
        self.settings_window.columnconfigure(2,weight=1)
        self.settings_window.columnconfigure(4,weight=1)
        self.settings_window.columnconfigure(6,weight=1)

        # Set the default max undo/redo steps to retain
        self.max_undo = 200
        
        # Set up our defaults for our option lists
        self.allowed_types = ("XML","Binary")
        self.allowed_data  = ("Hex","Base64")
        self.allowed_int   = ("Decimal","Hex")
        self.allowed_bool  = ("True/False","YES/NO","On/Off","1/0",u"\u2714/\u274c")
        self.allowed_conv  = ("Ascii","Base64","Decimal","Hex","Binary")

        # If should_set_header_text() returns None, we're running in macOS
        # with a window that does not support native dark mode.  The result
        # of which is that some ttk widget backgrounds do not match the
        # window background.  We'll try to work around that by using tk in
        # those cases.
        tk_or_ttk = tk if self.should_set_header_text() is None else ttk

        # Left side - functional elements:
        
        # Let's add some checkboxes and stuffs
        sep_func = ttk.Separator(self.settings_window,orient="horizontal")
        sep_func.grid(row=0,column=1,columnspan=2,sticky="we",padx=10,pady=10)
        func_label = tk.Label(self.settings_window,text="Functionality Options:")
        func_label.grid(row=0,column=0,sticky="w",padx=10,pady=10)

        self.expand_on_open = tk.IntVar()
        self.use_xcode_data = tk.IntVar()
        self.sort_dict_keys = tk.IntVar()
        self.comment_ignore_case = tk.IntVar()
        self.comment_check_string = tk.IntVar()
        self.force_schema = tk.IntVar()
        self.expand_check = tk_or_ttk.Checkbutton(self.settings_window,text="Expand Children When Opening Plist",variable=self.expand_on_open,command=self.expand_command)
        self.xcode_check = tk_or_ttk.Checkbutton(self.settings_window,text="Use Xcode-Style <data> Tags (Inline) in XML Plists",variable=self.use_xcode_data,command=self.xcode_command)
        self.sort_check = tk_or_ttk.Checkbutton(self.settings_window,text="Ignore Dictionary Key Order",variable=self.sort_dict_keys,command=self.sort_command)
        self.ignore_case_check = tk_or_ttk.Checkbutton(self.settings_window,text="Ignore Case When Stripping Comments",variable=self.comment_ignore_case,command=self.ignore_case_command)
        self.check_string_check = tk_or_ttk.Checkbutton(self.settings_window,text="Check String Values When Stripping Comments",variable=self.comment_check_string,command=self.check_string_command)
        self.expand_check.grid(row=1,column=0,columnspan=3,sticky="w",padx=10)
        self.xcode_check.grid(row=2,column=0,columnspan=3,sticky="w",padx=10)
        self.sort_check.grid(row=3,column=0,columnspan=3,sticky="w",padx=10)
        self.ignore_case_check.grid(row=4,column=0,columnspan=3,sticky="w",padx=10)
        self.check_string_check.grid(row=5,column=0,columnspan=3,sticky="w",padx=10)
        comment_prefix_label = tk.Label(self.settings_window,text="Comment Prefix (default is #):")
        comment_prefix_label.grid(row=6,column=0,sticky="w",padx=10)
        self.comment_prefix_text = plistwindow.EntryPlus(self.settings_window,self.tk,self)
        self.comment_prefix_text.grid(row=6,column=1,columnspan=2,sticky="we",padx=10)
        self.plist_type_string = tk.StringVar(self.settings_window)
        self.plist_type_menu = tk_or_ttk.OptionMenu(self.settings_window, self.plist_type_string, *self.get_option_menu_list(self.allowed_types), command=self.change_plist_type)
        plist_label = tk.Label(self.settings_window,text="Default New Plist Type:")
        plist_label.grid(row=7,column=0,sticky="w",padx=10)
        self.plist_type_menu.grid(row=7,column=1,columnspan=2,sticky="we",padx=10)
        self.data_type_string = tk.StringVar(self.settings_window)
        self.data_type_menu = tk_or_ttk.OptionMenu(self.settings_window, self.data_type_string, *self.get_option_menu_list(self.allowed_data), command=self.change_data_type)
        data_label = tk.Label(self.settings_window,text="Data Display Default:")
        data_label.grid(row=8,column=0,sticky="w",padx=10)
        self.data_type_menu.grid(row=8,column=1,columnspan=2,sticky="we",padx=10)
        self.int_type_string = tk.StringVar(self.settings_window)
        self.int_type_menu = tk_or_ttk.OptionMenu(self.settings_window, self.int_type_string, *self.get_option_menu_list(self.allowed_int), command=self.change_int_type)
        int_label = tk.Label(self.settings_window,text="Integer Display Default:")
        int_label.grid(row=9,column=0,sticky="w",padx=10)
        self.int_type_menu.grid(row=9,column=1,columnspan=2,sticky="we",padx=10)
        self.bool_type_string = tk.StringVar(self.settings_window)
        self.bool_type_menu = tk_or_ttk.OptionMenu(self.settings_window, self.bool_type_string, *self.get_option_menu_list(self.allowed_bool), command=self.change_bool_type)
        bool_label = tk.Label(self.settings_window,text="Boolean Display Default:")
        bool_label.grid(row=10,column=0,sticky="w",padx=10)
        self.bool_type_menu.grid(row=10,column=1,columnspan=2,sticky="we",padx=10)
        self.snapshot_string = tk.StringVar(self.settings_window)
        self.snapshot_menu = tk_or_ttk.OptionMenu(self.settings_window, self.snapshot_string, "Auto-detect", command=self.change_snapshot_version)
        snapshot_label = tk.Label(self.settings_window,text="OC Snapshot Target Version:")
        snapshot_label.grid(row=11,column=0,sticky="w",padx=10)
        self.snapshot_menu.grid(row=11,column=1,columnspan=2,sticky="we",padx=10)
        self.schema_check = tk_or_ttk.Checkbutton(self.settings_window,text="Force Update Snapshot Schema",variable=self.force_schema,command=self.schema_command)
        self.schema_check.grid(row=12,column=0,columnspan=3,sticky="w",padx=10)
        self.mod_check = tk.IntVar()
        self.enable_mod_check = tk_or_ttk.Checkbutton(self.settings_window,text="Warn If Files Are Externally Modified",variable=self.mod_check,command=self.mod_check_command)
        self.enable_mod_check.grid(row=13,column=0,columnspan=3,stick="w",padx=10)
        self.first_check = tk.IntVar()
        self.enable_first_check = tk_or_ttk.Checkbutton(self.settings_window,text="Enter Edits Values Before Keys Where Possible",variable=self.first_check,command=self.first_check_command)
        self.enable_first_check.grid(row=14,column=0,columnspan=3,stick="w",padx=10)
        self.enable_drag_and_drop = tk.BooleanVar()
        self.toggle_drag_drop = tk_or_ttk.Checkbutton(self.settings_window,text="Enable Row Drag & Drop", variable=self.enable_drag_and_drop,command=self.drag_drop_command)
        self.toggle_drag_drop.grid(row=15,column=0,columnspan=3,sticky="w",padx=10)
        self.drag_label = tk.Label(self.settings_window,text="Drag Dead Zone (1-100 pixels):")
        self.drag_label.grid(row=16,column=0,sticky="w",padx=10)
        self.drag_pixels = tk.Label(self.settings_window,text="20")
        self.drag_pixels.grid(row=16,column=1,sticky="w",padx=(10,0))
        self.drag_scale = tk_or_ttk.Scale(self.settings_window,from_=1,to=100,orient=tk.HORIZONTAL,command=self.scale_command)
        # Try to hide the value if using tk - will throw an exception in ttk
        try: self.drag_scale.configure(showvalue=False)
        except tk.TclError: pass
        self.drag_scale.grid(row=16,column=2,sticky="we",padx=(0,10))
        self.drag_disabled = tk.Label(self.settings_window,text="[ Drag & Drop Disabled ]")
        self.drag_disabled.configure(state="disabled")
        self.drag_disabled.grid(row=16,column=1,columnspan=2,sticky="we",padx=10)
        undo_max_label = tk.Label(self.settings_window,text="Max Undo (0=unlim, {}=default):".format(self.max_undo))
        undo_max_label.grid(row=17,column=0,sticky="w",padx=10)
        self.undo_max_text = plistwindow.EntryPlus(self.settings_window,self.tk,self)
        self.undo_max_text.grid(row=17,column=1,columnspan=2,sticky="we",padx=10)
        
        # Left/right separator:
        sep = ttk.Separator(self.settings_window,orient="vertical")
        sep.grid(row=1,column=3,rowspan=17,sticky="ns",padx=10)

        # Right side - theme elements:
        t_func = ttk.Separator(self.settings_window,orient="horizontal")
        t_func.grid(row=0,column=5,columnspan=2,sticky="we",padx=10,pady=10)
        tfunc_label = tk.Label(self.settings_window,text="Appearance Options:")
        tfunc_label.grid(row=0,column=4,sticky="w",padx=10,pady=10)

        self.op_label = tk.Label(self.settings_window,text="Window Opacity (25-100%):")
        self.op_label.grid(row=1,column=4,sticky="w",padx=10)
        self.op_perc = tk.Label(self.settings_window,text="100")
        self.op_perc.grid(row=1,column=5,sticky="w",padx=(10,0))
        self.op_scale = tk_or_ttk.Scale(self.settings_window,from_=25,to=100,orient=tk.HORIZONTAL,command=self.update_opacity)
        # Try to hide the value if using tk - will throw an exception in ttk
        try: self.op_scale.configure(showvalue=False)
        except tk.TclError: pass
        self.op_scale.grid(row=1,column=6,sticky="we",padx=10)
        r4_label = tk.Label(self.settings_window,text="Highlight Color:")
        r4_label.grid(row=2,column=4,sticky="w",padx=10)
        self.hl_canvas = tk.Canvas(self.settings_window, height=20, width=30, background="black", relief="groove", bd=2)
        self.hl_canvas.grid(row=2,column=5,columnspan=2,sticky="we",padx=10)
        r1_label = tk.Label(self.settings_window,text="Alternating Row Color #1:")
        r1_label.grid(row=3,column=4,sticky="w",padx=10)
        self.r1_canvas = tk.Canvas(self.settings_window, height=20, width=30, background="black", relief="groove", bd=2)
        self.r1_canvas.grid(row=3,column=5,columnspan=2,sticky="we",padx=10)
        r2_label = tk.Label(self.settings_window,text="Alternating Row Color #2:")
        r2_label.grid(row=4,column=4,sticky="w",padx=10)
        self.r2_canvas = tk.Canvas(self.settings_window, height=20, width=30, background="black", relief="groove", bd=2)
        self.r2_canvas.grid(row=4,column=5,columnspan=2,sticky="we",padx=10)
        r3_label = tk.Label(self.settings_window,text="Column Header/BG Color:")
        r3_label.grid(row=5,column=4,sticky="w",padx=10)
        self.bg_canvas = tk.Canvas(self.settings_window, height=20, width=30, background="black", relief="groove", bd=2)
        self.bg_canvas.grid(row=5,column=5,columnspan=2,sticky="we",padx=10)
        self.ig_bg_check = tk.IntVar()
        self.ig_bg = tk_or_ttk.Checkbutton(self.settings_window,text="Header Text Ignores BG Color",variable=self.ig_bg_check,command=self.check_ig_bg_command)
        self.ig_bg.grid(row=6,column=4,sticky="w",padx=10)
        self.bg_inv_check = tk.IntVar()
        self.bg_inv = tk_or_ttk.Checkbutton(self.settings_window,text="Invert Header Text Color",variable=self.bg_inv_check,command=self.check_bg_invert_command)
        self.bg_inv.grid(row=6,column=5,columnspan=2,sticky="w",padx=10)
        self.r1_inv_check = tk.IntVar()
        self.r1_inv = tk_or_ttk.Checkbutton(self.settings_window,text="Invert Row #1 Text Color",variable=self.r1_inv_check,command=self.check_r1_invert_command)
        self.r1_inv.grid(row=7,column=5,columnspan=2,sticky="w",padx=10)
        self.r2_inv_check = tk.IntVar()
        self.r2_inv = tk_or_ttk.Checkbutton(self.settings_window,text="Invert Row #2 Text Color",variable=self.r2_inv_check,command=self.check_r2_invert_command)
        self.r2_inv.grid(row=8,column=5,columnspan=2,sticky="w",padx=10)
        self.hl_inv_check = tk.IntVar()
        self.hl_inv = tk_or_ttk.Checkbutton(self.settings_window,text="Invert Highlight Text Color",variable=self.hl_inv_check,command=self.check_hl_invert_command)
        self.hl_inv.grid(row=9,column=5,columnspan=2,sticky="w",padx=10)

        self.default_font = Font(font='TkTextFont')
        self.custom_font = tk.IntVar()
        self.font_check = tk_or_ttk.Checkbutton(self.settings_window,text="Use Custom Font Size",variable=self.custom_font,command=self.font_command)
        self.font_string = tk.StringVar()
        self.font_spinbox = tk.Spinbox(self.settings_window,from_=1,to=128,textvariable=self.font_string)
        try:
            self.font_string.trace_add("write",self.update_font)
        except AttributeError:
            self.font_string.trace("w",self.update_font)
        self.font_check.grid(row=10,column=4,sticky="w",padx=10)
        self.font_spinbox.grid(row=10,column=5,columnspan=2,sticky="we",padx=10)

        # Custom font picker - wacky implementation.
        self.font_var = tk.IntVar()
        self.font_family  = tk.StringVar()
        self.font_custom_check = tk_or_ttk.Checkbutton(self.settings_window,text="Use Custom Font",variable=self.font_var,command=self.font_select)
        self.font_custom = ttk.Combobox(self.settings_window,state="readonly",textvariable=self.font_family,values=sorted(families()))
        self.font_custom.bind('<<ComboboxSelected>>',self.font_pick)
        try:
            self.font_family.trace_add("write",self.update_font_family)
        except AttributeError:
            self.font_family.trace("w",self.update_font_family)
        self.font_custom_check.grid(row=11,column=4,stick="w",padx=10)
        self.font_custom.grid(row=11,column=5,columnspan=2,sticky="we",padx=10)

        r5_label = tk.Label(self.settings_window,text="Restore Appearance Defaults:")
        r5_label.grid(row=12,column=4,sticky="w",padx=10)
        dt_func = ttk.Separator(self.settings_window,orient="horizontal")
        dt_func.grid(row=12,column=5,columnspan=2,sticky="we",padx=10)

        default_font = tk_or_ttk.Button(self.settings_window,text="Font Defaults",command=self.font_defaults)
        default_font.grid(row=13,column=4,sticky="we",padx=10)
        default_high = tk_or_ttk.Button(self.settings_window,text="Highlight Color",command=lambda:self.swap_colors("highlight"))
        default_high.grid(row=14,column=4,sticky="we",padx=10)
        default_light = tk_or_ttk.Button(self.settings_window,text="Light Mode Colors",command=lambda:self.swap_colors("light"))
        default_light.grid(row=13,column=5,columnspan=2,sticky="we",padx=10)
        default_dark = tk_or_ttk.Button(self.settings_window,text="Dark Mode Colors",command=lambda:self.swap_colors("dark"))
        default_dark.grid(row=14,column=5,columnspan=2,sticky="we",padx=10)

        sep_theme = ttk.Separator(self.settings_window,orient="horizontal")
        sep_theme.grid(row=18,column=0,columnspan=7,sticky="we",padx=10,pady=(10,0))

        # Add the check for updates checkbox and button
        self.update_int = tk.IntVar()
        self.update_check = tk_or_ttk.Checkbutton(self.settings_window,text="Check For Updates At Start",variable=self.update_int,command=self.update_command)
        self.update_check.grid(row=19,column=0,sticky="w",padx=10,pady=(5,0))
        self.notify_once_int = tk.IntVar()
        self.notify_once_check = tk_or_ttk.Checkbutton(self.settings_window,text="Only Notify Once Per Version",variable=self.notify_once_int,command=self.notify_once)
        self.notify_once_check.grid(row=20,column=0,sticky="w",padx=10,pady=(0,10))
        self.update_button = tk_or_ttk.Button(self.settings_window,text="Check Now",command=lambda:self.check_for_updates(user_initiated=True))
        self.update_button.grid(row=20,column=1,columnspan=2,sticky="w",padx=10,pady=(0,10))
        self.tex_button = tk_or_ttk.Button(self.settings_window,text="Get Configuration.tex",command=self.get_latest_tex)
        self.tex_button.grid(row=20,column=4,sticky="we",padx=10,pady=(0,10))
        reset_settings = tk_or_ttk.Button(self.settings_window,text="Restore All Defaults",command=self.reset_settings)
        reset_settings.grid(row=20,column=5,columnspan=2,sticky="we",padx=10,pady=(0,10))

        # Setup the color picker click methods
        self.r1_canvas.bind("<ButtonRelease-1>",lambda x:self.pick_color("alternating_color_1",self.r1_canvas))
        self.r2_canvas.bind("<ButtonRelease-1>",lambda x:self.pick_color("alternating_color_2",self.r2_canvas))
        self.hl_canvas.bind("<ButtonRelease-1>",lambda x:self.pick_color("highlight_color",self.hl_canvas))
        self.bg_canvas.bind("<ButtonRelease-1>",lambda x:self.pick_color("background_color",self.bg_canvas))

        # Setup some canvas connections
        self.canvas_connect = {
            self.bg_canvas: {"invert":self.bg_inv_check},
            self.r1_canvas: {"invert":self.r1_inv_check},
            self.r2_canvas: {"invert":self.r2_inv_check},
            self.hl_canvas: {"invert":self.hl_inv_check}
        }
        
        self.default_dark  = {
            "alternating_color_1":"#161616",
            "alternating_color_2":"#202020",
            "highlight_color":"#1E90FF",
            "background_color":"#161616",
            "invert_background_text_color":False,
            "invert_row1_text_color":False,
            "invert_row2_text_color":False
        }
        self.default_light = {
            "alternating_color_1":"#F0F1F1",
            "alternating_color_2":"#FEFEFE",
            "highlight_color":"#1E90FF",
            "background_color":"#FEFEFE",
            "invert_background_text_color":False,
            "invert_row1_text_color":False,
            "invert_row2_text_color":False
        }

        # Setup the from/to option menus
        self.f_title = tk.StringVar(self.tk)
        self.t_title = tk.StringVar(self.tk)
        f_option = tk_or_ttk.OptionMenu(self.tk, self.f_title, *self.get_option_menu_list(self.allowed_conv), command=self.change_from_type)
        t_option = tk_or_ttk.OptionMenu(self.tk, self.t_title, *self.get_option_menu_list(self.allowed_conv), command=self.change_to_type)
        f_option.grid(row=0,column=1,sticky="we")
        t_option.grid(row=1,column=1,sticky="we")

        self.f_text = plistwindow.EntryPlus(self.tk,self.tk,self)
        self.f_text.delete(0,tk.END)
        self.f_text.insert(0,"")
        self.f_text.grid(row=0,column=2,columnspan=3,sticky="we",padx=10,pady=10)

        self.t_text = plistwindow.EntryPlus(self.tk,self.tk,self)
        self.t_text.configure(state='normal')
        self.t_text.delete(0,tk.END)
        self.t_text.insert(0,"")
        self.t_text.configure(state='readonly')
        self.t_text.grid(row=1,column=2,columnspan=3,sticky="we",padx=10,pady=10)

        self.c_button = tk_or_ttk.Button(self.tk, text="Convert", command=self.convert_values)
        self.c_button.grid(row=2,column=4,sticky="e",padx=10,pady=10)
        self.s_button = tk_or_ttk.Button(self.tk, text="To <--> From", command=self.swap_convert)
        self.s_button.grid(row=2,column=0,columnspan=2,sticky="w",padx=10,pady=10)

        self.f_text.bind("<Return>", self.convert_values)
        self.f_text.bind("<KP_Enter>", self.convert_values)

        self.start_window = None

        # Regex to find the processor serial numbers when
        # opened from the Finder
        self.regexp = re.compile(r"^-psn_[0-9]+_[0-9]+$")

        # Setup the menu-related keybinds - and change the app name if needed
        key="Control"
        sign = "Ctrl+"
        self.use_dark = self.get_dark()
        if str(sys.platform) == "darwin":
            # Remap the quit function to our own
            self.tk.createcommand('::tk::mac::Quit', self.quit)
            self.tk.createcommand("::tk::mac::OpenDocument", self.open_plist_from_app)
            self.tk.createcommand("::tk::mac::ShowPreferences", lambda:self.show_window(self.settings_window))
            # Import the needed modules to change the bundle name and force focus
            try:
                from Foundation import NSBundle
                from Cocoa import NSRunningApplication, NSApplicationActivateIgnoringOtherApps
                app = NSRunningApplication.runningApplicationWithProcessIdentifier_(os.getpid())
                app.activateWithOptions_(NSApplicationActivateIgnoringOtherApps)
                bundle = NSBundle.mainBundle()
                if bundle:
                    info = bundle.localizedInfoDictionary() or bundle.infoDictionary()
                    if info and info['CFBundleName'] == 'Python':
                        info['CFBundleName'] = "ProperTree"
            except:
                pass
            key="Command"
            sign=key+"+"

        self.tk.protocol("WM_DELETE_WINDOW", lambda x=self.tk: self.close_window(window=x))
        self.settings_window.protocol("WM_DELETE_WINDOW", lambda x=self.settings_window: self.close_window(window=x))

        self.default_windows = (self.tk,self.settings_window)

        self.recent_menu = None
        self.main_menu = None
        if str(sys.platform) == "darwin":
            # Setup the top level menu
            file_menu = tk.Menu(self.tk)
            self.main_menu = tk.Menu(self.tk)
            self.recent_menu = tk.Menu(self.tk)
            self.main_menu.add_cascade(label="File", menu=file_menu)
            file_menu.add_command(label="New (Cmd+N)", command=self.new_plist)
            file_menu.add_command(label="Open (Cmd+O)", command=self.open_plist)
            file_menu.add_cascade(label="Open Recent", menu=self.recent_menu, command=self.open_recent)
            file_menu.add_command(label="Save (Cmd+S)", command=self.save_plist)
            file_menu.add_command(label="Save As... (Cmd+Shift+S)", command=self.save_plist_as)
            file_menu.add_command(label="Duplicate (Cmd+D)", command=self.duplicate_plist)
            file_menu.add_command(label="Reload From Disk (Cmd+L)", command=self.reload_from_disk)
            file_menu.add_separator()
            file_menu.add_command(label="OC Snapshot (Cmd+R)", command=self.oc_snapshot)
            file_menu.add_command(label="OC Clean Snapshot (Cmd+Shift+R)", command=self.oc_clean_snapshot)
            file_menu.add_separator()
            file_menu.add_command(label="Convert Window (Cmd+T)", command=lambda:self.show_window(self.tk))
            file_menu.add_command(label="Strip Comments (Cmd+M)", command=self.strip_comments)
            file_menu.add_command(label="Strip Disabled Entries (Cmd+E)", command=self.strip_disabled)
            file_menu.add_command(label="Strip Surrounding Whitespace from Keys & Values (Cmd+K)", command=lambda:self.strip_whitespace(keys=True,values=True))
            file_menu.add_separator()
            file_menu.add_command(label="Settings (Cmd+,)",command=lambda:self.show_window(self.settings_window))
            file_menu.add_separator()
            file_menu.add_command(label="Toggle Find/Replace Pane (Cmd+F)",command=self.hide_show_find)
            file_menu.add_command(label="Toggle Plist/Data/Int Type Pane (Cmd+P)",command=self.hide_show_type)
            file_menu.add_separator()
            file_menu.add_command(label="Quit (Cmd+Q)", command=self.quit)
            self.tk.config(menu=self.main_menu)
            self.settings_window.config(menu=self.main_menu)

        # Set bindings
        # on at least macOS, tk 8.5 works with <Command-Z>, but 8.6 requires <Shift-Command-z>
        # Can be bypassed by including both Shift and the capital letter
        self.tk.bind("<{}-w>".format(key), self.close_window)
        self.settings_window.bind("<{}-w>".format(key), self.close_window)
        self.tk.bind_all("<{}-n>".format(key), self.new_plist)
        self.tk.bind_all("<{}-o>".format(key), self.open_plist)
        self.tk.bind_all("<{}-s>".format(key), self.save_plist)
        self.tk.bind_all("<{}-Shift-S>".format(key), self.save_plist_as)
        self.tk.bind_all("<{}-d>".format(key), self.duplicate_plist)
        self.tk.bind_all("<{}-t>".format(key), lambda event, x=self.tk: self.show_window(x))
        self.tk.bind_all("<{}-z>".format(key), self.undo)
        self.tk.bind_all("<{}-Shift-Z>".format(key), self.redo)
        self.tk.bind_all("<{}-m>".format(key), self.strip_comments)
        self.tk.bind_all("<{}-e>".format(key), self.strip_disabled)
        self.tk.bind_all("<{}-k>".format(key), lambda x:self.strip_whitespace(keys=True,values=True))
        self.tk.bind_all("<{}-r>".format(key), self.oc_snapshot)
        self.tk.bind_all("<{}-Shift-R>".format(key), self.oc_clean_snapshot)
        self.tk.bind_all("<{}-l>".format(key), self.reload_from_disk)
        if not str(sys.platform) == "darwin":
            # Rewrite the default Command-Q command
            self.tk.bind_all("<{}-q>".format(key), self.quit)
            self.tk.bind_all("<{}-comma>".format(key), lambda event, x=self.settings_window:self.show_window(x))

        self.tk.bind("<KeyPress>", self.handle_keypress)
        self.settings_window.bind("<KeyPress>", self.handle_keypress)
        
        cwd = os.getcwd()
        os.chdir(os.path.abspath(os.path.dirname(__file__)))
        #
        # Load the settings - current available settings are:
        # 
        # last_window_width:            width value (default is 640)
        # last_window_height:           height value (default is 480)
        # expand_all_items_on_open:     bool
        # sort_dict:                    bool, false = OrderedDict
        # xcode_data:                   bool, true = <data>XXXX</data>, false = different lines
        # comment_strip_prefix:         string, defaults to #
        # comment_strip_ignore_case:    bool, true = ignore case when stripping comments
        # comment_strip_check_string:   bool, true = consider string values as well as keys
        # new_plist_default_type:       string, XML/Binary
        # display_data_as:              string, Hex/Base64
        # display_int_as:               string, Decimal/Hex
        # snapshot_version:             string, X.X.X version number, or Latest
        # force_snapshot_schema:        bool
        # alternating_color_1:          string, Dark: #161616 - Light: #F0F1F1
        # alternating_color_2:          string, Dark: #202020 - Light: #FEFEFE
        # highlight_color:              string, Dark: #1E90FF - Light: #1E90FF
        # background_color:             string, Dark: #161616 - Light: #FEFEFE
        # header_text_ignore_bg_color:  bool
        # invert_background_text_color: bool
        # invert_row1_text_color:       bool
        # invert_row2_text_color:       bool
        # invert_hl_text_color:         bool
        # warn_if_modified:             bool
        # edit_values_before_keys:      bool
        # enable_drag_and_drop:         bool
        # drag_dead_zone:               pixel distance before drag starts (default is 20)
        # open_recent:                  list, paths recently opened
        # recent_max:                   int, max number of recent items
        # max_undo:                     int, max undo history - 0 = unlimited
        # check_for_updates_at_startup: bool
        # notify_once_per_version:      bool
        # last_version_checked:         str
        # opacity                       int, 10-100 (default is 100)
        #

        self.settings = {}
        if os.path.exists("Scripts/settings.json"):
            try:
                self.settings = json.load(open("Scripts/settings.json"))
            except:
                pass
        # Also load the snapshot defaults
        self.snapshot_data = {}
        if os.path.exists("Scripts/snapshot.plist"):
            try:
                with open("Scripts/snapshot.plist","rb") as f:
                    self.snapshot_data = plist.load(f)
            except:
                pass
        # And finally, load the version.json if it exists
        self.version = {}
        if os.path.exists("Scripts/version.json"):
            try: self.version = json.load(open("Scripts/version.json"))
            except: pass
        os.chdir(cwd)

        # Apply the version to the update and tex buttons
        self.reset_update_button()
        self.reset_tex_button()

        # Setup the settings page to reflect our settings.json file
        self.update_settings()

        self.case_insensitive = self.get_case_insensitive()
        # Normalize the pathing for Open Recents
        self.normpath_recents()
        if str(sys.platform) == "darwin": self.update_recents()
        self.check_dark_mode()

        self.version_url = "https://raw.githubusercontent.com/corpnewt/ProperTree/master/Scripts/version.json"
        self.tex_url = "https://raw.githubusercontent.com/acidanthera/OpenCorePkg/master/Docs/Configuration.tex"
        self.repo_url = "https://github.com/corpnewt/ProperTree"

        # Windows running python 2 seems to have issues with multiprocessing
        # if the case of the main script's name is incorrect:
        # e.g. Downloader.py vs downloader.py
        #
        # To work around this, we try to scrape for the correct case if
        # possible.
        try:
            path = os.path.abspath(sys.modules["__main__"].__file__)
            if os.path.isfile(path):
                name = os.path.basename(path).lower()
                fldr = os.path.dirname(path)
                for f in os.listdir(fldr):
                    if f.lower() == name:
                        sys.modules["__main__"].__file__ = os.path.join(fldr,f)
                        break
        except AttributeError as e:
            # This likely means we're running from the interpreter directly
            pass

        # Implement a simple boolean lock, and check for updates if needed
        self.is_checking_for_updates = False
        if self.settings.get("check_for_updates_at_startup",True):
            self.tk.after(0, lambda:self.check_for_updates(user_initiated=False))

        # Prior implementations tried to wait 250ms to give open_plist_from_app()
        # enough time to parse anything double-clicked.  The issue was that both
        # check_open() and open_plist_from_app() would fire at roughly the same
        # time - resulting in one opening a blank doc, and the other opening the
        # double-clicked plist(s).  We now use the is_opening lock to determine
        # if one function is currently working - and the other will check in 5ms
        # intervals until the lock is lifted before processing.  This allows us
        # to overtake a blank doc opened by one with the other - hopefully fixing
        # the issue of multiple documents spawning on double-click in macOS.
        self.is_opening = False
        self.is_quitting = False
        self.check_open(plists)
        
        # Set up a signal handler for SIGINT that pipes to our quit() function
        signal.signal(signal.SIGINT,self.quit)
        # Set up our event loop "poker" to keep the event loop processing
        self.tk.after(200,self.sigint_check)

        # Set our titlebar colors
        for w in (self.tk, self.settings_window):
            self.set_win_titlebar(windows=w)

        # Start our run loop
        tk.mainloop()

    def _clipboard_append(self, clipboard_string = None):
        # Tkinter has issues copying to the system clipboard as evident in this bug report:
        # https://bugs.python.org/issue40452
        #
        # There are some workarounds that require compiling a new tk binary - but we can
        # ensure the system clipboard is updated by calling either clip or pbcopy depending
        # on the current OS.
        #
        # First we clear the tkinter clipboard
        self.tk.clipboard_clear()
        # Only write to the tkinter clipboard if we have a value
        if clipboard_string: self.tk.clipboard_append(clipboard_string)
        else: clipboard_string = "" # Ensure we have at least an empty string
        # Gather our args for the potential clipboard commands Windows -> macOS -> Linux
        for args in (["clip"],) if os.name=="nt" else (["pbcopy"],) if sys.platform=="darwin" else (["xclip","-sel","c"],["xsel","-ib"],):
            # Try to start a subprocess to mirror the tkinter clipboard contents
            try:
                clipboard = subprocess.Popen(
                    args,
                    stdin=subprocess.PIPE,
                    stderr=getattr(subprocess,"DEVNULL",open(os.devnull,"w")),
                    stdout=getattr(subprocess,"DEVNULL",open(os.devnull,"w"))
                )
            except:
                continue
            # Dirty py2 check to see if we need to encode the data or not
            clipboard.stdin.write(clipboard_string if 2/3==0 else clipboard_string.encode())
            clipboard.stdin.flush() # Flush the buffer
            clipboard.stdin.close() # Close the pipe
            break # Break out of the loop as needed

    def sigint_check(self):
        # Helper to keep the event loop moving in order to ensure we can catch
        # KeyboardInterrupts as needed
        self.tk.after(200,self.sigint_check)

    def get_case_insensitive(self):
        # Helper function to check our file path, change case, and see if os.path.exists() still works
        our_path = os.path.abspath(__file__)
        # Walk our chars and find the first alpha character
        # then reverse it's case - and see if the path still exists
        for i,x in enumerate(our_path):
            if x.isalpha():
                x = x.upper() if x.islower() else x.lower()
                return os.path.exists(our_path[:i]+x+our_path[i+1:])
        # If we got here - there were no alpha chars in the path - we'll just uh... return False to be safe
        return False

    def check_dark_mode(self):
        check_dark = self.get_dark()
        if check_dark != self.use_dark and any((x not in self.settings for x in ("alternating_color_1","alternating_color_2","background_color"))):
            # Mode changed
            # Update colors as needed
            color_check = [x for x in self.default_dark if not x in self.settings]
            if color_check: # We have something to animate
                color_list = []
                from_dict,to_dict = (self.default_dark,self.default_light) if self.use_dark \
                               else (self.default_light,self.default_dark)
                for name in color_check:
                    if name.startswith("invert_"):
                        continue # Skip boolean checks
                    color_list.append((
                        name,
                        from_dict[name],
                        to_dict[name]
                    ))
                # Queue up the animations
                self.color_animate(color_list)
            self.use_dark = check_dark
            if os.name == "nt":
                # Iterate all the windows
                self.set_win_titlebar()
        # Continue the loop every 3 seconds
        self.tk.after(1500, lambda:self.check_dark_mode())

    def set_win_titlebar(self, windows=None, mode=None):
        if not os.name == "nt":
            return # Only change on Windows
        if windows is None:
            windows = self.stackorder(self.tk, include_defaults=True)
        elif not isinstance(windows,(list,tuple)):
            windows = [windows]
        try:
            # Set up the values
            if mode is None:
                mode = int(self.use_dark)
            value = ctypes.c_int(mode) # Mode is 0 for light, 1 for dark
            # Configure the window attributes
            DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 = 19
            DWMWA_USE_IMMERSIVE_DARK_MODE = 20
            set_window_attribute = ctypes.windll.dwmapi.DwmSetWindowAttribute
            get_parent = ctypes.windll.user32.GetParent
        except:
            # Something went wrong - bail
            return
        for window in windows:
            try:
                # Update the window
                window.update()
                hwnd_inst = get_parent(window.winfo_id())
                set_window_attribute(hwnd_inst, DWMWA_USE_IMMERSIVE_DARK_MODE, ctypes.byref(value),
                                    ctypes.sizeof(value))
                set_window_attribute(hwnd_inst, DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1, ctypes.byref(value),
                                    ctypes.sizeof(value))
                # Update the Window size to ensure the changes happen
                for x in (1,-1):
                    window.geometry("{}x{}".format(
                        window.winfo_width()+x,
                        window.winfo_height()+x
                    ))
                    window.update()
            except:
                # Something went wrong - but this is cosmetic only,
                # so we just continue on as normal
                continue

    def color_animate(self, colors, step=1, steps=5, delay=35):
        for name,start,end in colors:
            # Get the start and end as ints #rrggbb
            start_r = int(start[1:3],16)
            start_g = int(start[3:5],16)
            start_b = int(start[5:7],16)
            end_r = int(end[1:3],16)
            end_g = int(end[3:5],16)
            end_b = int(end[5:7],16)
            # Get and apply the steps
            r_now = int((((end_r-start_r)/steps)*step)+start_r)
            g_now = int((((end_g-start_g)/steps)*step)+start_g)
            b_now = int((((end_b-start_b)/steps)*step)+start_b)
            # Set our target color
            result = "#{}{}{}".format(
                hex(r_now)[2:].upper(),
                hex(g_now)[2:].upper(),
                hex(b_now)[2:].upper()
            )
            self.settings[name] = result
        # Update the windows
        if step < steps:
            self.update_canvases()
            self.tk.after(delay, lambda:self.color_animate(
                colors, step=step+1, steps=steps, delay=delay
            ))
        else:
            # Remove the adjusted colors from the settings
            for c in colors:
                self.settings.pop(c[0],None)
            self.update_settings()

    def get_option_menu_list(self, option_list):
        # Helper to return OptionMenu lists depending on whether
        # we're using tk or ttk.  The latter requires the default
        # element listed - for which we'll just pick the first
        # element in the option_list
        if self.should_set_header_text() is None:
            # This should only happen on macOS when the window
            # doesn't support native dark mode - this results in
            # the background of some ttk widgets not matching the
            # window background
            return option_list
        # We should be using ttk, which requires the default element
        # before the options
        return [option_list[0]]+list(option_list)

    def should_set_header_text(self):
        # In macOS, the header colors are only affected by the background
        # when in dark mode on specific python build
        # We'll try to get the system's actual dark mode here
        if str(sys.platform) != "darwin": return True # Don't make changes on Windows/Linux
        try:
            # Ask the window if it's in dark mode - only works when supported
            return bool(self.tk.call("tk::unsupported::MacWindowStyle","isdark",self.tk))
        except Exception as e:
            return None # If this fails, window doesn't support dark mode

    def get_dark(self):
        if os.name=="nt":
            # Get the registry entry to tell us if we're in dark/light mode
            p = subprocess.Popen(["reg","query","HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize","/v","AppsUseLightTheme"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            c = p.communicate()
            return c[0].decode("utf-8", "ignore").strip().lower().split(" ")[-1] in ("","0x0")
        elif str(sys.platform) != "darwin":
            return True # Default to dark mode on Linux platforms
        # Get the macOS version - and see if dark mode is a thing
        p = subprocess.Popen(["sw_vers","-productVersion"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        c = p.communicate()
        p_vers = c[0].decode("utf-8", "ignore").strip().lower()
        if p_vers < "10.14.0": return True # Default to dark on anything prior to 
        # At this point - we have an OS that supports dark mode, let's check our value
        p = subprocess.Popen(["defaults","read","-g","AppleInterfaceStyle"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        c = p.communicate()
        return c[0].decode("utf-8", "ignore").strip().lower() == "dark"

    def compare_version(self, v1, v2):
        # Splits the version numbers by periods and compare each value
        # Allows 0.0.10 > 0.0.9 where normal string comparison would return false
        # Also strips out any non-numeric values from each segment to avoid conflicts
        #
        # Returns True if v1 > v2, None if v1 == v2, and False if v1 < v2
        if not all((isinstance(x,str) for x in (v1,v2))):
            # Wrong types
            return False
        v1_seg = v1.split(".")
        v2_seg = v2.split(".")
        # Pad with 0s to ensure common length
        v1_seg += ["0"]*(len(v2_seg)-len(v1_seg))
        v2_seg += ["0"]*(len(v1_seg)-len(v2_seg))
        # Compare each segment - stripping non-numbers as needed
        for i in range(len(v1_seg)):
            a,b = v1_seg[i],v2_seg[i]
            try: a = int("".join([x for x in a if x.isdigit()]))
            except: a = 0
            try: b = int("".join([x for x in b if x.isdigit()]))
            except: b = 0
            if a > b: return True
            if a < b: return False
        # If we're here, both versions are the same
        return None

    def check_for_updates(self, user_initiated = False):
        if self.is_checking_for_updates: # Already checking
            if user_initiated:
                # We pressed the button - but another check is in progress
                self.tk.bell()
                mb.showerror("Already Checking For Updates","An update check is already in progress.  If you consistently get this error when manually checking for updates - it may indicate a netowrk issue.")
                self.lift_window()
            return
        self.is_checking_for_updates = True # Lock out other update checks
        self.update_button.configure(
            state="disabled",
            text="Checking... ({})".format(self.version.get("version","?.?.?"))
        )
        # We'll leverage multiprocessing to avoid UI locks if the update checks take too long
        p = multiprocessing.Process(target=_check_for_update,args=(self.queue,self.version_url,user_initiated))
        p.daemon = True
        p.start()
        self.check_update_process(p)

    def reset_update_button(self):
        self.update_button.configure(
            state="normal",
            text="Check Now ({})".format(self.version.get("version","?.?.?"))
        )

    def check_update_process(self, p):
        # Helper to watch until an update is done
        if p.is_alive():
            self.tk.after(100,self.check_update_process,p)
            return
        # Join the process to ensure resources are returned
        p.join()
        # We've returned - reset our bool lock
        self.is_checking_for_updates = False
        # Check if we got anything from the queue
        if self.queue.empty(): # Nothing in the queue, bail
            return self.reset_update_button()
        # Retrieve any returned value and parse
        output_dict = self.queue.get()
        user_initiated = output_dict.get("user_initiated",False)
        # Check if we got an error or exception
        if "exception" in output_dict or "error" in output_dict:
            error = output_dict.get("error","An Error Occurred Checking For Updates")
            excep = output_dict.get("exception","Something went wrong when checking for updates.")
            if user_initiated:
                self.tk.bell()
                mb.showerror(error,excep)
                self.lift_window()
            return self.reset_update_button()
        # Parse the output returned
        version_dict = output_dict.get("json",{})
        if not version_dict.get("version"):
            if user_initiated:
                self.tk.bell()
                mb.showerror("An Error Occurred Checking For Updates","Data returned was malformed or nonexistent.")
                self.lift_window()
            return self.reset_update_button()
        # At this point - we should have json data containing the version key/value
        check_version = str(version_dict["version"]).lower()
        our_version   = str(self.version.get("version","0.0.0")).lower()
        notify_once   = self.settings.get("notify_once_per_version",True)
        last_version  = str(self.settings.get("last_version_checked","0.0.0")).lower()
        if self.compare_version(check_version,our_version) is True:
            if notify_once and last_version == check_version and not user_initiated:
                # Already notified about this version - ignore
                return self.reset_update_button()
            # Save the last version checked
            self.settings["last_version_checked"] = check_version
            # We got an update we're not ignoring - let's prompt
            self.tk.bell()
            result = mb.askyesno(
                title="New ProperTree Version Available",
                message="Version {} is available (currently on {}).\n\nWhat's new in {}:\n{}\n\nVisit ProperTree's github repo now?".format(
                    check_version,
                    our_version,
                    check_version,
                    version_dict.get("changes","No changes listed.")
                )
            )
            if result: # Open the url in the default browser
                webbrowser.open(self.repo_url)

        elif user_initiated:
            # No new updates - but we need to tell the user
            mb.showinfo(
                title="No Updates Available",
                message="You are currently running the latest version of ProperTree ({}).".format(our_version)
            )
        
        else:
            # Nothing to notify about - and not user initiated
            return self.reset_update_button()
        
        # Reset the update button after notifying
        self.reset_update_button()
        # If we got here - we displayed some message, let's lift our window to the top
        self.lift_window()

    def get_best_tex_path(self):
        pt_path = os.path.abspath(os.path.dirname(__file__))
        # Add a check for next to the script
        config_tex_paths = [os.path.join(pt_path,"Configuration.tex")]
        pt_path_parts = pt_path.split(os.sep)
        if len(pt_path_parts) >= 3 and pt_path_parts[-2:] == ["Contents","MacOS"] \
            and pt_path_parts[-3].lower().endswith(".app"):
            for x in range(3):
                # Remove the last 3 path components as we're in a .app bundle
                pt_path = os.path.dirname(pt_path)
                # Add a check for next to the .app bundle
                config_tex_paths.append(os.path.join(pt_path,"Configuration.tex"))
        # Iterate any paths we need to check and return the first match
        for path in config_tex_paths:
            if os.path.isfile(path):
                return path
        # If none were found - return the first entry
        if config_tex_paths:
            return config_tex_paths[0]

    def get_tex_version(self, file_path = None):
        file_path = file_path or self.get_best_tex_path()
        if not file_path or not os.path.isfile(file_path):
            return None
        try:
            with open(file_path,"r") as f:
                t = f.read()
            for line in t.split("\n"):
                line = line.strip().lower()
                if line.startswith("reference manual (") and line.endswith(")"):
                    return line.split("(")[-1].split(")")[0]
        except: pass
        return None

    def reset_tex_button(self, version = None):
        tex_version = version or self.get_tex_version()
        self.tex_button.configure(
            state="normal",
            text="Get Configuration.tex{}".format(
                " ({})".format(tex_version) if tex_version else ""
            )
        )

    def get_latest_tex(self):
        tex_version = self.get_tex_version()
        self.tex_button.configure(
            state="disabled",
            text="Downloading...{}".format(
                " ({})".format(tex_version) if tex_version else ""
            )
        )
        # We'll leverage multiprocessing to avoid UI locks if the update checks take too long
        p = multiprocessing.Process(target=_update_tex,args=(self.tex_queue,self.tex_url,self.get_best_tex_path()))
        p.daemon = True
        p.start()
        self.check_tex_process(p)

    def check_tex_process(self, p):
        # Helper to watch until an update is done
        if p.is_alive():
            self.tk.after(100,self.check_tex_process,p)
            return
        # Join the process to ensure resources are returned
        p.join()
        # Check if we got anything from the queue
        if self.tex_queue.empty(): # Nothing in the queue, bail
            return self.reset_tex_button()
        output_dict = self.tex_queue.get()
        # Check if we got an error or exception
        if "exception" in output_dict or "error" in output_dict:
            error = output_dict.get("error","An Error Occurred Downloading Configuration.tex")
            excep = output_dict.get("exception","Something went wrong when getting the latest Configuration.tex.")
            self.tk.bell()
            mb.showerror(error,excep)
        else:
            tex_path = self.get_best_tex_path()
            if os.path.isfile(tex_path):
                version = self.get_tex_version(file_path=tex_path)
                if not version:
                    self.tk.bell()
                    mb.showerror(
                        title="An Error Occurred Downloading Configuration.tex",
                        message="Something went wrong when getting the latest Configuration.tex."
                    )
                else:
                    mb.showinfo(
                        title="Updated Configuration.tex",
                        message="Configuration.tex ({}) saved to:\n\n{}".format(version,tex_path)
                    )
        self.reset_tex_button()
        # If we got here - we displayed some message, let's lift our window to the top
        self.lift_window()

    def handle_keypress(self, event, generate=True):
        if event.state & 0x2 and event.keysym != "Caps_Lock":
            # Check which OS we're on and strip mod keys we don't
            # care about
            state_bitmask = 0xFFFFFFFF
            if os.name == "nt":
                state_bitmask -= 0x8  # Num Lock
                state_bitmask -= 0x20 # Scroll Lock
            elif sys.platform == "darwin":
                state_bitmask -= 0x20 # Num Lock
            else: # Assume Linux
                state_bitmask -= 0x10 # Num Lock
            state_bitmask -= 0x2 # Strip Caps Lock on all platforms
            event.state &= state_bitmask
            # Build our sequence - modified from:
            #  - https://github.com/python/cpython/blob/3.13/Lib/tkinter/__init__.py
            mods = ('Shift', 'Lock', 'Control',
                    'Mod1', 'Mod2', 'Mod3', 'Mod4', 'Mod5',
                    'Button1', 'Button2', 'Button3', 'Button4', 'Button5')
            s = []
            for i, n in enumerate(mods):
                if event.state & (1 << i):
                    s.append(n)
            # Get the lowercase keysym if it's just one char
            keysym = event.keysym.lower() if len(event.keysym)==1 else event.keysym
            sequence = "<{}{}Key-{}>".format(
                "-".join(s),
                "-" if s else "",
                keysym
            )
            # Check bind_all for the sequence we built first
            if sequence in event.widget.bind_all():
                # Just propagate the event
                event.widget.event_generate(sequence)
                return "break"
            # Walk each widget and its parents looking for the
            # bind sequence we just built
            parent = event.widget
            while True:
                if sequence in parent.bind():
                    parent.event_generate(sequence)
                    return "break"
                parent_name = parent.winfo_parent()
                if not parent_name:
                    return # Bail - out of widgets
                parent = parent._nametowidget(parent_name)

    def text_color(self, hex_color, invert = False):
        hex_color = hex_color.lower()
        if hex_color.startswith("0x"): hex_color = hex_color[2:]
        if hex_color.startswith("#"): hex_color = hex_color[1:]
        # Check for bogus hex and return "black" by default
        if len(hex_color) != 6 or not all((x in "0123456789abcdef" for x in hex_color)):
            return "white" if invert else "black"
        # Get the r, g, and b values and determine our fake luminance
        r = float(int(hex_color[0:2],16))
        g = float(int(hex_color[2:4],16))
        b = float(int(hex_color[4:6],16))
        l = (r*0.299 + g*0.587 + b*0.114) > 186
        if l: return "white" if invert else "black"
        return "black" if invert else "white"

    def set_window_opacity(self, opacity=None, window=None):
        if opacity is None:
            try: opacity = min(100,max(int(self.settings.get("opacity",100)),25))
            except: opacity = 100 # failsafe
        if window:
            # Only use the passed window(s)
            if isinstance(window,(list,tuple)):
                windows = window
            else: # Wrap it up in a tuple
                windows = (window,)
        else:
            # Make sure we set opacity on the default windows whether they're
            # visible or not
            windows = self.stackorder(self.tk,include_defaults=False) + [self.tk, self.settings_window]
        for window in windows:
            window.attributes("-alpha",float(opacity)/float(100))

    def update_opacity(self, event = None):
        self.settings["opacity"] = self.op_scale.get()
        self.set_window_opacity(self.settings["opacity"])
        self.op_perc.configure(
            text="{}".format(str(int(self.op_scale.get())).rjust(3))
        )

    def expand_command(self, event = None):
        self.settings["expand_all_items_on_open"] = True if self.expand_on_open.get() else False

    def xcode_command(self, event = None):
        self.settings["xcode_data"] = True if self.use_xcode_data.get() else False

    def sort_command(self, event = None):
        self.settings["sort_dict"] = True if self.sort_dict_keys.get() else False

    def ignore_case_command(self, event = None):
        self.settings["comment_strip_ignore_case"] = True if self.comment_ignore_case.get() else False

    def check_string_command(self, event = None):
        self.settings["comment_strip_check_string"] = True if self.comment_check_string.get() else False

    def drag_drop_command(self, event = None):
        self.settings["enable_drag_and_drop"] = True if self.enable_drag_and_drop.get() else False
        self.scale_command() # Ensure the scale is reflected
        if self.enable_drag_and_drop.get():
            self.drag_scale.grid()
            self.drag_disabled.grid_remove()
        else:
            self.drag_disabled.grid()
            self.drag_scale.grid_remove()

    def scale_command(self, event = None):
        self.settings["drag_dead_zone"] = self.drag_scale.get()
        self.drag_pixels.configure(
            text="{}".format(str(int(self.drag_scale.get())).rjust(3)) if self.enable_drag_and_drop.get() else ""
        )

    def check_ig_bg_command(self, event = None):
        self.settings["header_text_ignore_bg_color"] = True if self.ig_bg_check.get() else False
        self.update_colors()

    def check_bg_invert_command(self, event = None):
        self.settings["invert_background_text_color"] = True if self.bg_inv_check.get() else False
        self.update_colors()

    def check_r1_invert_command(self, event = None):
        self.settings["invert_row1_text_color"] = True if self.r1_inv_check.get() else False
        self.update_colors()

    def check_r2_invert_command(self, event = None):
        self.settings["invert_row2_text_color"] = True if self.r2_inv_check.get() else False
        self.update_colors()

    def check_hl_invert_command(self, event = None):
        self.settings["invert_hl_text_color"] = True if self.hl_inv_check.get() else False
        self.update_colors()

    def schema_command(self, event = None):
        self.settings["force_snapshot_schema"] = True if self.force_schema.get() else False

    def mod_check_command(self, event = None):
        self.settings["warn_if_modified"] = True if self.mod_check.get() else False

    def first_check_command(self, event = None):
        self.settings["edit_values_before_keys"] = True if self.first_check.get() else False

    def update_command(self, event = None):
        self.settings["check_for_updates_at_startup"] = True if self.update_int.get() else False
        self.update_notify()

    def notify_once(self, event = None):
        self.settings["notify_once_per_version"] = True if self.notify_once_int.get() else False

    def update_notify(self):
        self.notify_once_check.configure(state="normal" if self.update_int.get() else "disabled")

    def change_plist_type(self, event = None):
        self.settings["new_plist_default_type"] = self.plist_type_string.get()

    def change_data_type(self, event = None):
        self.settings["display_data_as"] = self.data_type_string.get()

    def change_int_type(self, event = None):
        self.settings["display_int_as"] = self.int_type_string.get()

    def change_bool_type(self, event = None):
        self.settings["display_bool_as"] = self.bool_type_string.get()

    def change_snapshot_version(self, event = None):
        self.settings["snapshot_version"] = self.snapshot_string.get().split(" ")[0]

    def font_command(self, event = None):
        if self.custom_font.get():
            self.settings["use_custom_font_size"] = True
            self.font_spinbox.configure(state="normal")
        else:
            self.settings["use_custom_font_size"] = False
            self.font_spinbox.configure(state="disabled")
            # self.font_string.set(self.default_font["size"])
            self.settings.pop("font_size",None)
        self.update_font()

    def font_select(self, event = None):
        if self.font_var.get():
            self.settings["use_custom_font"] = True
            self.settings["font_family"] = self.font_family.get()
            self.font_custom.configure(state='readonly')
        else:
            self.settings["use_custom_font"] = False
            self.font_custom.configure(state='disabled')
            self.settings.pop("font_family",None)
        self.update_font_family()

    def font_pick(self, event = None):
        font_family = self.font_family.get()
        if self.settings["font_family"] == font_family:
            return
        self.settings["font_family"] = font_family
        self.update_font_family()

    def update_font(self, var = None, blank = None, trace_mode = None):
        try:
            input_size = int(self.font_string.get())
            font_size = max(min(128,input_size),1)
            if font_size != input_size:
                self.font_string.set(str(font_size))
        except:
            return
        self.settings["font_size"] = font_size
        self.update_fonts()

    def update_font_family(self, event = None, blank = None, trace_mode = None):
        windows = self.stackorder(self.tk)
        if not len(windows): return
        for window in windows:
            if window in self.default_windows: continue
            window.set_font_family()

    def font_defaults(self, event = None):
        self.settings["use_custom_font"] = False
        self.settings.pop("font_family",None)
        self.settings["use_custom_font_size"] = False
        self.settings.pop("font_size",None)
        self.update_settings()

    def pick_color(self, color_name = None, canvas = None):
        if not color_name or not canvas: return # uh wut?
        _,color = ac(color=canvas["background"])
        if not color: return # User bailed
        self.settings[color_name] = color
        canvas.configure(background=color)
        self.update_colors()

    def swap_colors(self, color_type = None):
        if not isinstance(color_type,str): return
        color_type = color_type.lower()
        if color_type == "highlight":
            self.settings.pop("highlight_color",None)
            self.settings.pop("invert_hl_text_color",None)
            return self.update_settings()
        # Find out if we're setting it to light or dark mode - and if on macOS/Windows + using the system's current settings,
        # remove them to use defaults
        self.use_dark = self.get_dark()
        color_dict = self.default_light if color_type == "light" else self.default_dark
        to_remove = (self.use_dark and color_type == "dark") or (not self.use_dark and color_type != "dark")
        for x in color_dict:
            if color_type != "highlight" and x.lower() == "highlight_color": continue
            if to_remove: self.settings.pop(x,None)
            else: self.settings[x] = color_dict[x]
        self.update_settings()

    def update_canvases(self):
        default_color = self.default_dark if self.use_dark else self.default_light
        color_1 = "".join([x for x in self.settings.get("alternating_color_1",default_color["alternating_color_1"]) if x.lower() in "0123456789abcdef"])
        color_2 = "".join([x for x in self.settings.get("alternating_color_2",default_color["alternating_color_2"]) if x.lower() in "0123456789abcdef"])
        color_h = "".join([x for x in self.settings.get("highlight_color"    ,default_color["highlight_color"    ]) if x.lower() in "0123456789abcdef"])
        color_b = "".join([x for x in self.settings.get("background_color"   ,default_color["background_color"   ]) if x.lower() in "0123456789abcdef"])
        self.r1_canvas.configure(background="#"+color_1 if len(color_1) == 6 else default_color["alternating_color_1"])
        self.r2_canvas.configure(background="#"+color_2 if len(color_2) == 6 else default_color["alternating_color_2"])
        self.hl_canvas.configure(background="#"+color_h if len(color_h) == 6 else default_color["highlight_color"])
        self.bg_canvas.configure(background="#"+color_b if len(color_b) == 6 else default_color["background_color"])
        self.ig_bg_check.set(self.settings.get("header_text_ignore_bg_color",False))
        self.bg_inv_check.set(self.settings.get("invert_background_text_color",False))
        self.r1_inv_check.set(self.settings.get("invert_row1_text_color",False))
        self.r2_inv_check.set(self.settings.get("invert_row2_text_color",False))
        self.hl_inv_check.set(self.settings.get("invert_hl_text_color",False))
        self.update_colors()

    def reset_settings(self, event = None):
        self.settings = {}
        self.update_settings()

    def update_settings(self):
        self.expand_on_open.set(self.settings.get("expand_all_items_on_open",True))
        self.use_xcode_data.set(self.settings.get("xcode_data",True))
        self.sort_dict_keys.set(self.settings.get("sort_dict",False))
        def_type = self.settings.get("new_plist_default_type",self.allowed_types[0])
        self.plist_type_string.set(def_type if def_type in self.allowed_types else self.allowed_types[0])
        dat_type = self.settings.get("display_data_as",self.allowed_data[0])
        self.data_type_string.set(dat_type if dat_type in self.allowed_data else self.allowed_data[0])
        int_type = self.settings.get("display_int_as",self.allowed_int[0])
        self.int_type_string.set(int_type if int_type in self.allowed_int else self.allowed_int[0])
        bool_type = self.settings.get("display_bool_as",self.allowed_bool[0])
        self.bool_type_string.set(bool_type if bool_type in self.allowed_bool else self.allowed_bool[0])
        conv_f_type = self.settings.get("convert_from_type",self.allowed_conv[1])
        self.f_title.set(conv_f_type if conv_f_type in self.allowed_conv else self.allowed_conv[1])
        conv_t_type = self.settings.get("convert_to_type",self.allowed_conv[-1])
        self.t_title.set(conv_t_type if conv_t_type in self.allowed_conv else self.allowed_conv[-1])
        self.snapshot_menu["menu"].delete(0,"end")
        snapshot_versions = ["{} -> {}".format(x["min_version"],x.get("max_version","Current")) if x["min_version"]!=x.get("max_version","Current") else x["min_version"] for x in self.snapshot_data if "min_version" in x and len(x["min_version"])]
        snapshot_choices = ["Auto-detect","Latest"] + sorted(snapshot_versions,reverse=True)
        for choice in snapshot_choices:
            self.snapshot_menu["menu"].add_command(label=choice,command=tk._setit(self.snapshot_string,choice,self.change_snapshot_version))
        snapshot_vers = self.settings.get("snapshot_version","Auto-detect")
        snapshot_name = next((x for x in snapshot_choices if x.split(" ")[0] == snapshot_vers),None)
        self.snapshot_string.set(snapshot_name if snapshot_name in snapshot_choices else "Auto-detect")
        self.force_schema.set(self.settings.get("force_snapshot_schema",False))
        self.mod_check.set(self.settings.get("warn_if_modified",True))
        self.first_check.set(self.settings.get("edit_values_before_keys",False))
        self.comment_ignore_case.set(self.settings.get("comment_strip_ignore_case",False))
        self.comment_check_string.set(self.settings.get("comment_strip_check_string",True))
        self.update_int.set(self.settings.get("check_for_updates_at_startup",True))
        self.notify_once_int.set(self.settings.get("notify_once_per_version",True))
        self.update_notify()
        self.comment_prefix_text.delete(0,tk.END)
        prefix = self.settings.get("comment_strip_prefix","#")
        prefix = "#" if not prefix else prefix
        self.comment_prefix_text.insert(0,prefix)
        self.undo_max_text.delete(0,tk.END)
        max_undo = self.settings.get("max_undo",self.max_undo)
        max_undo = self.max_undo if not isinstance(max_undo,int) or max_undo < 0 else max_undo
        self.undo_max_text.insert(0,str(max_undo))
        try: opacity = min(100,max(int(self.settings.get("opacity",100)),25))
        except: opacity = 100 # failsafe
        self.op_scale.set(opacity)
        self.set_window_opacity(opacity)
        self.enable_drag_and_drop.set(self.settings.get("enable_drag_and_drop",True))
        self.drag_scale.set(self.settings.get("drag_dead_zone",20))
        self.drag_drop_command() # Ensure the drag_scale state is updated as needed
        try:
            font_size = max(min(128,int(self.settings.get("font_size"))),1)
        except:
            font_size = self.default_font["size"]
        self.font_string.set(font_size)
        self.custom_font.set(self.settings.get("use_custom_font_size",False))
        self.font_family.set(self.settings.get("font_family",self.default_font.actual()["family"]))
        self.font_var.set(self.settings.get("use_custom_font",False))
        self.font_command()
        self.font_select()
        self.update_canvases()

    def update_canvas_text(self, canvas = None):
        if canvas is None: # Update all
            canvas = (self.bg_canvas,self.r1_canvas,self.r2_canvas,self.hl_canvas)
        if not isinstance(canvas, (tuple,list)): canvas = (canvas,)
        for c in canvas:
            if not c in self.canvas_connect: continue # Not a recognized canvas - skip
            # Update each canvas as needed - but mind the text color
            color = self.text_color(c["background"],self.canvas_connect[c]["invert"].get())
            if self.canvas_connect[c].get("text_id",None) is None: # We haven't drawn it yet - try to
                # Get the size
                w = self.settings_window.winfo_width()
                h = c.winfo_height()
                if w==1==h: # Request width as we haven't drawn yet
                    w = self.settings_window.winfo_reqwidth()
                    h = c.winfo_reqheight()
                    cw = c.winfo_reqwidth()
                    # Not drawn - estimate position and pad for macOS and Win/Linux with best-guess
                    rw = int(w/2) if str(sys.platform)=="darwin" else int(w/2-cw/2)
                else:
                    # It's been drawn, calculate the new way - width of the widget/2 gives us the halfway point
                    cw = c.winfo_width()
                    rw = int(cw/2)
                self.canvas_connect[c]["text_id"] = c.create_text(rw,int(h/2),text="Sample Text")
            # Set the color
            c.itemconfig(self.canvas_connect[c]["text_id"], fill=color)

    def update_fonts(self):
        windows = self.stackorder(self.tk,include_defaults=True)
        if not len(windows): return
        font = Font(family=self.font_family.get()) if self.font_var.get() else Font(font="TkTextFont")
        font["size"] = self.font_string.get() if self.custom_font.get() else self.default_font["size"]
        for window in windows:
            if window in self.default_windows: continue
            form_text = next((x for x in window.winfo_children() if str(x).endswith("!formattedtext")),None)
            if form_text: # We need to manually set the text colors here
                form_text.update_font(font)
            else:
                window.set_font_size()

    def update_colors(self):
        self.update_canvas_text()
        # Update all windows' colors
        windows = self.stackorder(self.tk,include_defaults=True)
        if not len(windows):
            # Nothing to do
            return
        # Get the text colors for the FormattedText widgets as needed
        r1  = self.r1_canvas["background"]
        r1t = self.text_color(r1,invert=self.r1_inv_check.get())
        for window in windows:
            if window in self.default_windows: continue
            form_text = next((x for x in window.winfo_children() if str(x).endswith("!formattedtext")),None)
            if form_text: # We need to manually set the text colors here
                form_text.configure(bg=r1,fg=r1t)
            else: # Just have a standard window - no formatted text to update
                window.set_colors()

    def compare_paths(self,check,path):
        if not isinstance(path,(str,unicode,list)): return False
        if self.case_insensitive:
            check = check.lower()
            path = path.lower() if isinstance(path,(str,unicode)) else [x.lower() for x in path]
        return check in path if isinstance(path,list) else check == path

    def normpath_recents(self):
        normalized = [os.path.normpath(x) for x in self.settings.get("open_recent",[])]
        new_paths = []
        for path in normalized:
            if self.compare_paths(path,new_paths): continue # Don't add duplicates
            new_paths.append(path)
        self.settings["open_recent"] = new_paths

    def update_recents(self):
        # Helper to figure out which menu(s) to update, and actually update them
        targets = [self] if str(sys.platform) == "darwin" else [w for w in self.stackorder(self.tk) if not w in self.default_windows]
        for target in targets:
            self.update_recents_for_target(target)

    def update_recents_for_target(self,target):
        if not hasattr(target,"recent_menu"): return # Invalid target?
        # Helper to setup the Open Resent menu for the target menu
        recents = self.settings.get("open_recent",[])
        target.recent_menu.delete(0,tk.END)
        if not len(recents):
            target.recent_menu.add_command(label="No Recently Opened Files", state=tk.DISABLED)
        else:
            for recent in recents:
                target.recent_menu.add_command(label=recent, command=lambda x=recent:self.open_recent(x))
        # Add the separator and clear option
        target.recent_menu.add_separator()
        target.recent_menu.add_command(label="Clear Recently Opened", command=self.clear_recents)

    def add_recent(self,recent):
        # Add a new item to our Open Recent list, and make sure our list
        # doesn't grow beyond the recent_max value
        recent = os.path.normpath(recent) # Normalize the pathing
        recents = [x for x in self.settings.get("open_recent",[]) if not self.compare_paths(recent,x)]
        recents.insert(0,recent)
        recent_max = self.settings.get("recent_max",10)
        recents = recents[:recent_max]
        self.settings["open_recent"] = recents
        self.update_recents()

    def rem_recent(self,recent):
        # Removes a recent from the Open Recent list if it exists
        recent = os.path.normpath(recent) # Normalize the pathing
        recents = [x for x in self.settings.get("open_recent",[]) if not x == recent]
        self.settings["open_recent"] = recents
        self.update_recents()

    def clear_recents(self):
        self.settings.pop("open_recent",None)
        self.update_recents()

    def open_recent(self, path=None):
        # First check if the file exists - if not, throw an error, and remove it
        # from the recents menu
        if path is None: # Try getting the first item from settings
            paths = self.settings.get("open_recent",[])
            if paths: path = paths[0]
        if path is None: # Couldn't get any recents - bail
            return
        path = os.path.normpath(path)
        if not (os.path.exists(path) and os.path.isfile(path)):
            self.tk.bell()
            mb.showerror("An Error Occurred While Opening {}".format(os.path.basename(path)), "The path '{}' does not exist.".format(path))
            self.lift_window()
            return
        return self.pre_open_with_path(path)

    def check_open(self, plists = []):
        if self.is_opening: # Already opening - loop until we're not
            self.tk.after(5, lambda:self.check_open(plists))
            return
        self.is_opening = True
        try:
            plists = [x for x in plists if not self.regexp.search(x)]
            if isinstance(plists, list) and len(plists):
                at_least_one = False
                # Iterate the passed plists and open them
                for p in set(plists):
                    window = self.pre_open_with_path(p)
                    if not window: continue
                    at_least_one = True
                    if self.start_window is None:
                        self.start_window = window
                if not at_least_one: # If none of them opened, open a fresh plist
                    windows = self.stackorder(self.tk)
                    if not len(windows):
                        self.start_window = self.new_plist()
            elif not len(self.stackorder(self.tk)):
                # create a fresh plist to start
                self.start_window = self.new_plist()
        except Exception as e:
            self.tk.bell()
            mb.showerror("Error in check_open() function",repr(e))
            self.lift_window()
        self.is_opening = False

    def open_plist_from_app(self, *args):
        if self.is_opening: # Already opening - loop until we're not
            self.tk.after(5, lambda:self.open_plist_from_app(*args))
            return
        self.is_opening = True
        try:
            if isinstance(args, str):
                args = [args]
            args = [x for x in args if not self.regexp.search(x)]
            for arg in args:
                windows = self.stackorder(self.tk)
                # Verify that no other window has that file selected already
                existing_window = next((window for window in windows if not window in self.default_windows and window.current_plist==arg),None)
                if existing_window:
                    self.lift_window(existing_window)
                    existing_window.reload_from_disk(None)
                    continue
                if len(windows) == 1 and windows[0] == self.start_window and windows[0].edited == False and windows[0].current_plist is None:
                    # Fresh window - replace the contents
                    current_window = windows[0]
                else:
                    current_window = None
                # Let's load the plist
                window = self.pre_open_with_path(arg,current_window)
                if self.start_window is None: self.start_window = window
        except Exception as e:
            self.tk.bell()
            mb.showerror("Error in open_plist_from_app() function",repr(e))
            self.lift_window()
        self.is_opening = False

    def change_hd_type(self, value):
        self.hd_type = value

    def reload_from_disk(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.reload_from_disk(event)

    def change_data_display(self, new_data = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.change_data_display(new_data)

    def oc_clean_snapshot(self, event = None):
        self.oc_snapshot(event,True)

    def oc_snapshot(self, event = None, clean = False):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.oc_snapshot(event,clean)

    def hide_show_find(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.hide_show_find(event)

    def hide_show_type(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.hide_show_type(event)

    def close_window(self, event = None, window = None, check_close = True):
        if window: window.withdraw()
        else:
            # Remove the default window that comes from it
            windows = self.stackorder(self.tk,include_defaults=True)
            if windows: windows[-1].withdraw()
        if check_close: self.check_close()
    
    def check_close(self, lift_last = True):
        windows = self.stackorder(self.tk,include_defaults=True)
        if not windows:
            self.quit()
        elif lift_last:
            self.lift_window(windows[-1])

    def strip_comments(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.strip_comments(event)

    def strip_disabled(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.strip_disabled(event)

    def strip_whitespace(self, event = None, keys = False, values = False):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.strip_whitespace(event,keys=keys,values=values)

    def change_to_type(self, value):
        self.settings["convert_to_type"] = value
        self.convert_values()

    def change_from_type(self, value):
        self.settings["convert_from_type"] = value

    def show_window(self, window, event = None):
        if not window.winfo_viewable():
            # Let's center the window
            w = window.winfo_width()
            h = window.winfo_height()
            if w==1==h: # Request width as we haven't drawn yet
                if window == self.tk: # Use the defaults
                    w, h = 640, 130
                else: # Try to approximate
                    w = window.winfo_reqwidth()
                    h = window.winfo_reqheight()
            x = window.winfo_screenwidth() // 2 - w // 2
            y = window.winfo_screenheight() // 2 - h // 2
            window.geometry("+{}+{}".format(x, y))
            window.deiconify()
        self.lift_window(window)
        if window == self.tk:
            # Only set the focus if we're showing the convert window
            self.f_text.focus_set()

    def get_bytes(self, value):
        if sys.version_info >= (3,0) and not isinstance(value,bytes):
            # Convert to bytes
            value = value.encode("utf-8")
        return value

    def get_string(self, value):
        if sys.version_info >= (3,0) and not isinstance(value,(str,unicode)):
            # Convert from bytes
            value = value.decode("utf-8")
        return value

    def swap_convert(self, event = None):
        # Swaps the values of the to and from conversion dropdown menus
        t,f = self.t_title.get(),self.f_title.get()
        self.settings["convert_to_type"] = f
        self.settings["convert_from_type"] = t
        self.t_title.set(f)
        self.f_title.set(t)
        # Move any data from the To to the From, and run the conversion
        self.f_text.delete(0,tk.END)
        self.f_text.insert(0,self.t_text.get())
        self.convert_values()

    def convert_values(self, event = None):
        from_value = self.f_text.get()
        if not len(from_value):
            # Empty - nothing to convert
            return
        # Pre-check for hex potential issues
        from_type = self.f_title.get().lower()
        to_type   = self.t_title.get().lower()
        if from_type == "hex":
            if from_value.lower().startswith("0x"):
                from_value = from_value[2:]
            from_value = from_value.replace(" ","").replace("<","").replace(">","")
            if [x for x in from_value if x.lower() not in "0123456789abcdef"]:
                self.tk.bell()
                mb.showerror("Invalid Hex Data","Invalid character in passed hex data.") # ,parent=self.tk)
                self.lift_window()
                return
        try:
            if from_type in ("decimal","binary"):
                # Convert to hex bytes
                from_value = "".join(from_value.split()) # Remove whitespace
                from_value = "{:x}".format(int(from_value,10 if from_type=="decimal" else 2))
                if len(from_value) % 2:
                    from_value = "0"+from_value
            # Handle the from data
            if from_type == "base64":
                padded_from = from_value
                from_stripped = from_value.rstrip("=")
                if len(from_stripped) % 4 > 1: # Pad to a multiple of 4
                    padded_from = from_stripped + "="*(4-len(from_stripped)%4)
                if padded_from != from_value:
                    # Changed it - update the from box, and set the from value
                    from_value = padded_from
                    self.f_text.delete(0,tk.END)
                    self.f_text.insert(0,from_value)
                from_value = base64.b64decode(self.get_bytes(from_value))
            elif from_type in ("hex","decimal","binary"):
                if len(from_value) % 2:
                    # Ensure we pad our hex
                    from_value = "0"+from_value
                    # Reflect it visually for all cases that need it
                    if to_type not in ("hex","decimal"):
                        self.f_text.delete(0,tk.END)
                        self.f_text.insert(0,from_value)
                from_value = binascii.unhexlify(self.get_bytes(from_value))
            # Let's get the data converted
            to_value = self.get_bytes(from_value)
            if to_type == "base64":
                to_value = base64.b64encode(self.get_bytes(from_value))
            elif to_type == "hex":
                to_value = binascii.hexlify(self.get_bytes(from_value))
            elif to_type == "decimal":
                to_value = str(int(binascii.hexlify(self.get_bytes(from_value)),16))
            elif to_type == "binary":
                to_value = "{:b}".format(int(binascii.hexlify(self.get_bytes(from_value)),16))
            if not to_type in ("decimal","binary"):
                to_value = self.get_string(to_value)
            if to_type == "hex":
                # Capitalize it, and pad with spaces
                to_value = " ".join((to_value[0+i:8+i] for i in range(0, len(to_value), 8))).upper()
            # Set the text box
            self.t_text.configure(state='normal')
            self.t_text.delete(0,tk.END)
            self.t_text.insert(0,to_value)
            self.t_text.configure(state='readonly')
        except Exception as e:
            # Clear the text box
            self.t_text.configure(state='normal')
            self.t_text.delete(0,tk.END)
            self.t_text.configure(state='readonly')
            self.tk.bell()
            mb.showerror("Conversion Error",str(e)) # ,parent=self.tk)
            self.lift_window()

    ###                       ###
    # Save/Load Plist Functions #
    ###                       ###

    def duplicate_plist(self, event = None):
        if self.creating_window:
            return
        self.creating_window = True
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            self.creating_window = False
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            self.creating_window = False
            return
        # Ensure the title is unique
        title = self._get_unique_title(title="Untitled.plist")
        # Get the info from the current window and create a new one
        plist_data = window.nodes_to_values()
        new_window = plistwindow.PlistWindow(self, self.tk)
        # Ensure the window titlebar color is updated
        if os.name == "nt": self.set_win_titlebar(windows=new_window)
        # Ensure our duplicated plist and data types are reflected
        new_window.plist_type_string.set(window.plist_type_string.get())
        new_window.data_type_string.set(window.data_type_string.get())
        new_window.int_type_string.set(window.int_type_string.get())
        new_window.bool_type_string.set(window.bool_type_string.get())
        # Populate the new window with the plist data - ensuring it's "edited"
        new_window.open_plist(
            None,
            plist_data,
            auto_expand=self.settings.get("expand_all_items_on_open",True),
            title=title
        )
        # Update the Open Recent menu
        if str(sys.platform) != "darwin": self.update_recents_for_target(new_window)
        self.lift_window(new_window)
        self.creating_window = False

    def save_plist(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        if window.save_plist(event):
            # Saved correctly, let's ensure the path is saved in recents
            self.add_recent(window.current_plist)
            self.lift_window(window)
    
    def save_plist_as(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        if window.save_plist_as(event):
            # Saved correctly, let's ensure the path is saved in recents
            self.add_recent(window.current_plist)
            self.lift_window(window)

    def undo(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.reundo(event)

    def redo(self, event = None):
        windows = self.stackorder(self.tk)
        if not len(windows):
            # Nothing to do
            return
        window = windows[-1] # Get the last item (most recent)
        if window in self.default_windows:
            return
        window.reundo(event,False)

    def _get_unique_title(self, title="Untitled.plist", suffix=""):
        # Let's try to create a unique name (if Untitled.plist is used, add a number)
        if "." in title:
            # Consider an extension - and keep the leading period
            final_title = ".".join(title.split(".")[:-1])
            ext = "."+title.split(".")[-1]
        else:
            # No extension - just use the title as-is
            final_title = title
            ext = ""
        titles = set([x.title().lower() for x in self.stackorder(self.tk)])
        number = 0
        while True:
            temp = "{}{}{}{}".format(
                final_title,
                suffix,
                "" if number == 0 else "-"+str(number),
                ext)
            temp_edit = temp + " - edited"
            temp_lower,temp_edit_lower = temp.lower(),temp_edit.lower()
            if not any((x in titles for x in (temp_lower,temp_edit_lower))):
                final_title = temp
                break
            number += 1
        return final_title
    
    def new_plist(self, event = None):
        if self.creating_window:
            return
        self.creating_window = True
        # Creates a new plistwindow object
        title = self._get_unique_title(title="Untitled.plist")
        window = plistwindow.PlistWindow(self, self.tk)
        # Update the Open Recent menu
        if str(sys.platform) != "darwin": self.update_recents_for_target(window)
        # Ensure the window titlebar color is updated
        if os.name == "nt": self.set_win_titlebar(windows=window)
        # Ensure our default plist and data types are reflected
        window.plist_type_string.set(self.plist_type_string.get())
        window.data_type_string.set(self.data_type_string.get())
        window.int_type_string.set(self.int_type_string.get())
        window.bool_type_string.set(self.bool_type_string.get())
        window.open_plist(title,{}) # Created an empty root
        window.current_plist = None # Ensure it's initialized as new
        self.lift_window(window)
        self.creating_window = False
        return window

    def open_plist(self, event=None):
        # Prompt the user to open a plist, attempt to load it, and if successful,
        # set its path as our current_plist value
        path = fd.askopenfilename(title = "Select plist file") # ,parent=current_window) # Apparently parent here breaks on 10.15?
        if not len(path):
            # Lift the last window that was focused
            self.lift_window()
            return # User cancelled - bail
        path = os.path.abspath(os.path.expanduser(path))
        return self.pre_open_with_path(path)

    def pre_open_with_path(self, path, current_window = None):
        if not path: return # Hmmm... shouldn't happen, but just in case
        path = os.path.abspath(os.path.expanduser(path))
        windows = self.stackorder(self.tk)
        if current_window is None and len(windows) == 1 and windows[0] == self.start_window and windows[0].edited == False and windows[0].current_plist is None:
            # Fresh window - replace the contents
            current_window = windows[0]
        # Verify that no other window has that file selected already
        for window in windows[::-1]:
            if window in self.default_windows: continue
            if window.current_plist == path:
                # found one - just lift it and reload from disk instead
                self.lift_window(window)
                window.reload_from_disk(None)
                return
        return self.open_plist_with_path(None,path,current_window)

    def open_plist_with_path(self, event = None, path = None, current_window = None):
        if not path: return # Uh... wut?
        path = os.path.abspath(os.path.expanduser(path))
        # Let's try to load the plist
        try:
            with open(path,"rb") as f:
                plist_type = "Binary" if plist._is_binary(f) else "XML"
                plist_data = plist.load(f,dict_type=dict if self.settings.get("sort_dict",False) else OrderedDict)
        except Exception as e:
            # Had an issue, throw up a display box
            self.tk.bell()
            mb.showerror("An Error Occurred While Opening {}".format(os.path.basename(path)), str(e)) # ,parent=current_window)
            self.lift_window()
            return
        # Opened it correctly - let's load it, and set our values
        if not current_window:
            # Need to create one first
            current_window = plistwindow.PlistWindow(self, self.tk)
        # Ensure the window titlebar color is updated
        if os.name == "nt": self.set_win_titlebar(windows=current_window)
        # Ensure our default data type is reflected
        current_window.data_type_string.set(self.data_type_string.get())
        current_window.int_type_string.set(self.int_type_string.get())
        current_window.bool_type_string.set(self.bool_type_string.get())
        current_window.open_plist(
            path,
            plist_data,
            plist_type=plist_type,
            auto_expand=self.settings.get("expand_all_items_on_open",True)
        )
        self.lift_window(current_window)
        # Add it to our Open Recent list
        self.add_recent(path)
        return current_window

    def stackorder(self, root = None, include_defaults = False):
        """return a list of root and toplevel windows in stacking order (topmost is last)"""
        root = root or self.tk
        check_types = (tk.Toplevel,tk.Tk) if include_defaults else plistwindow.PlistWindow
        c = root.children
        s = root.tk.eval('wm stackorder {}'.format(root))
        L = [x.lstrip('.') for x in s.split()]
        # Remove any non-needed widgets
        w = {}
        for x in list(c):
            if isinstance(c.get(x),check_types):
                w[x] = c[x] # Retain the valid types
        if "" in L and isinstance(root,check_types):
            # We also need to append the root
            w[""] = root
        # Build a list of just the tkinter classes that follow the stack order
        stack_order = [w[x] for x in L if x in w]
        # Add any missing windows (might be minimized)
        stack_order = [x for x in w.values() if not x in stack_order] + stack_order
        # Return the list, omitting any windows that are withdrawn
        return [x for x in stack_order if x.wm_state() != "withdrawn"]

    def lift_window(self, window=None, deiconify=False):
        if window is None:
            windows = self.stackorder(self.tk,include_defaults=True)
            if windows: # Get the last window we saw
                window = windows[-1]
        if window is None: return # No windows in the stack order?
        if deiconify and window.state() == "iconic":
            window.deiconify() # Lift minimized windows as well
        if sys.platform != "darwin":
            # For all non-macOS platforms, lift the window
            # whether deiconifying or not.  Don't lift on
            # macOS as it deiconifies windows.
            window.lift()
        window.focus_force()
        try: window._tree.focus_force()
        except: pass
        window.attributes("-topmost",True)
        self.tk.after_idle(window.attributes,"-topmost",False)

    def quit(self, event_or_signum=None, frame=None):
        if self.is_quitting: return # Already quitting - don't try to do this twice at once
        self.is_quitting = True # Lock this to one quit attempt at a time
        if isinstance(event_or_signum,int) and frame is not None:
            print("KeyboardInterrupt caught - cleaning up...")
        # Get a list of all windows with unsaved changes
        unsaved = [x for x in self.stackorder(self.tk) if x.edited]
        ask_to_save = True
        if len(unsaved) > 1: # Ask for review
            answer = mb.askyesnocancel(
                "Unsaved Changes",
                "You have {:,} document{} with unsaved changes.\nWould you like to review?\n(If you don't review, all unsaved changes will be lost)".format(
                    len(unsaved),
                    "" if len(unsaved)==1 else "s"
                ))
            if answer is None:
                # Unlock quitting and return - user canceled
                self.is_quitting = False
                self.lift_window()
                return
            ask_to_save = answer # Iterate the windows and ask to save as needed
        # Walk through the windows and close them - reviewing changes as needed
        if ask_to_save:
            for window in self.stackorder(self.tk)[::-1]:
                if window in self.default_windows or not window.edited:
                    continue
                self.lift_window(window,deiconify=True)
                if not window.close_window(check_saving=ask_to_save,check_close=False):
                    self.is_quitting = False # Unlock the quit
                    return # User cancelled or we failed to save, bail
        # Make sure we retain any non-event updated settings
        prefix = self.comment_prefix_text.get()
        prefix = "#" if not prefix else prefix
        self.settings["comment_strip_prefix"] = prefix
        try:
            max_undo = int(self.undo_max_text.get())
            assert max_undo >= 0
        except:
            max_undo = self.max_undo
        self.settings["max_undo"] = max_undo
        # Actually quit the tkinter session
        self.tk.destroy()
        # Attempt to save the settings
        cwd = os.getcwd()
        os.chdir(os.path.abspath(os.path.dirname(__file__)))
        try:
            json.dump(self.settings,open("Scripts/settings.json","w"),indent=4)
        except:
            pass
        os.chdir(cwd)

if __name__ == '__main__':
    plists = []
    if len(sys.argv) > 1:
        plists = sys.argv[1:]
    p = ProperTree(plists)