import subprocess

from typing import TypedDict

import keyboard

import webbrowser

import tkinter as tk

from tkinter import filedialog as fd

from tkinter import ttk

import sv_ttk

import pywinstyles

import sys # Do not delete - prevents a 'super' error from tktoolip.

from tktooltip import ToolTip # In requirements.txt as 'tkinter-tooltip'.

from EDAPCalibration import Calibration

from EDAPColonizeEditor import ColonizeEditorTab

from ED_AP import *

from EDAPWaypointEditor import WaypointEditorTab

from EDlogger import logger

from RPYLineEditor import line_editor

EDAP_VERSION = "V1.9.3"

FORM_TYPE_CHECKBOX = 0

FORM_TYPE_SPINBOX = 1

FORM_TYPE_ENTRY = 2

def str_to_float(input_str: str) -> float:

try:

return float(input_str)

except ValueError:

return 0.0 # Assign a default value on error

class SubRegion(TypedDict):

""" """

rect: list[float]

text: str

class Objects(TypedDict):

""" """

width: float

height: float

text: str

class MyRegion(TypedDict):

""" """

rect: list[float]

text: str

readonly: bool

regions: dict[str, SubRegion]

objects: dict[str, Objects]

class APGui:

def __init__(self, root):

self.statusbar = None

self.root = root

root.title("EDAutopilot " + EDAP_VERSION)

# root.overrideredirect(True)

# root.geometry("400x550")

# root.configure(bg="blue")

root.protocol("WM_DELETE_WINDOW", self.close_window)

root.resizable(False, False)

self.tooltips = {

'FSD Route Assist': "Will execute your route. \nAt each jump the sequence will perform some fuel scooping.",

'Supercruise Assist': "Will keep your ship pointed to target, \nyou target can only be a station for the autodocking to work.",

'Waypoint Assist': "When selected, will prompt for the waypoint file. \nThe waypoint file contains System names that \nwill be entered into Galaxy Map and route plotted.",

'Robigo Assist': "",

'DSS Assist': "When selected, will perform DSS scans while you are traveling between stars.",

'Single Waypoint Assist': "",

'ELW Scanner': "Will perform FSS scans while FSD Assist is traveling between stars. \nIf the FSS shows a signal in the region of Earth, \nWater or Ammonia type worlds, it will announce that discovery.",

'AFK Combat Assist': "Used with a AFK Combat ship in a Rez Zone.",

'RollRate': "Roll rate your ship has in deg/sec. Higher the number the more maneuverable the ship.",

'PitchRate': "Pitch (up/down) rate your ship has in deg/sec. Higher the number the more maneuverable the ship.",

'YawRate': "Yaw rate (rudder) your ship has in deg/sec. Higher the number the more maneuverable the ship.",

'SunPitchUp+Time': "This field are for ship that tend to overheat. \nProviding 1-2 more seconds of Pitch up when avoiding the Sun \nwill overcome this problem.",

'Sun Bright Threshold': "The low level for brightness detection, \nrange 0-255, want to mask out darker items",

'Nav Align Tries': "How many attempts the ap should make at alignment.",

'Jump Tries': "How many attempts the ap should make to jump.",

'Docking Retries': "How many attempts to make to dock.",

'Wait For Autodock': "After docking granted, \nwait this amount of time for us to get docked with autodocking",

'Start FSD': "Button to start FSD route assist.",

'Start SC': "Button to start Supercruise assist.",

'Start Robigo': "Button to start Robigo assist.",

'Stop All': "Button to stop all assists.",

'Refuel Threshold': "If fuel level get below this level, \nit will attempt refuel.",

'Scoop Timeout': "Number of second to wait for full tank, \nmight mean we are not scooping well or got a small scooper",

'Fuel Threshold Abort': "Level at which AP will terminate, \nbecause we are not scooping well.",

'X Offset': "Offset left the screen to start place overlay text.",

'Y Offset': "Offset down the screen to start place overlay text.",

'Font Size': "Font size of the overlay.",

'Calibrate': "Will iterate through a set of scaling values \ngetting the best match for your system. \nSee HOWTO-Calibrate.md",

'Cap Mouse XY': "This will provide the StationCoord value of the Station in the SystemMap. \nSelecting this button and then clicking on the Station in the SystemMap \nwill return the x,y value that can be pasted in the waypoints file",

'Debug Overlay': "Enables debug data to be displayed over the \nElite Dangerous screen while playing the game.",

'Debug OCR': "Enables OCR debug output to be stored in the 'ocr_output' folder.",

'Debug Images': "Enables debug images to be stored in the 'debug_output' folder.",

'Modifier Key Delay': "Delay for key modifiers to ensure modifier is detected before/after the key.",

'Default Hold Time': "Default hold time for a key press.",

'Repeat Key Delay': "Delay between key press repeats.",

}

self.gui_loaded = False

self.log_buffer = queue.Queue()

self.callback('log', f'Starting ED Autopilot {EDAP_VERSION}.')

self.ed_ap = EDAutopilot(cb=self.callback)

self.ed_ap.robigo.set_single_loop(self.ed_ap.config['Robigo_Single_Loop'])

# self.calibrator = RegionCalibration(root, self.ed_ap, cb=self.callback)

self.calibration = None

self.ocr_calibration_data = {}

self.mouse = MousePoint()

self.checkboxvar = {}

self.radiobuttonvar = {}

self.entries = {}

self.lab_ck = {}

self.single_waypoint_system = tk.StringVar()

self.single_waypoint_station = tk.StringVar()

self.throttle_var = tk.StringVar()

self.throttle_combo = None

self.throttle_keys = []

self._global_shopping_list_tab = None

self.waypoint_editor_tab = None

self.colonize_tab = None

self._nb = None

self.FSD_A_running = False

self.SC_A_running = False

self.WP_A_running = False

self.RO_A_running = False

self.DSS_A_running = False

self.SWP_A_running = False

self.cv_view = False

self.msgList = self.gui_gen(root)

self.checkboxvar['Enable Randomness'].set(self.ed_ap.config['EnableRandomness'])

self.checkboxvar['Activate Elite for each key'].set(self.ed_ap.config['ActivateEliteEachKey'])

self.checkboxvar['Automatic logout'].set(self.ed_ap.config['AutomaticLogout'])

self.checkboxvar['Enable Overlay'].set(self.ed_ap.config['OverlayTextEnable'])

self.checkboxvar['Enable Voice'].set(self.ed_ap.config['VoiceEnable'])

self.checkboxvar['ELW Scanner'].set(self.ed_ap.config['ElwScannerEnable'])

self.checkboxvar['Enable Hotkeys'].set(self.ed_ap.config['HotkeysEnable'])

self.checkboxvar['Debug Overlay'].set(self.ed_ap.config['DebugOverlay'])

self.checkboxvar['Debug OCR'].set(self.ed_ap.config['DebugOCR'])

self.checkboxvar['Debug Images'].set(self.ed_ap.config['DebugImages'])

self.checkboxvar['AFKCombat AttackAtWill'].set(self.ed_ap.config['AFKCombat_AttackAtWill'])

self.radiobuttonvar['dss_button'].set(self.ed_ap.config['DSSButton'])

self.entries['ship']['SunPitchUp+Time'].delete(0, tk.END)

self.entries['autopilot']['Sun Bright Threshold'].delete(0, tk.END)

self.entries['autopilot']['Nav Align Tries'].delete(0, tk.END)

self.entries['autopilot']['Jump Tries'].delete(0, tk.END)

self.entries['autopilot']['Docking Retries'].delete(0, tk.END)

self.entries['autopilot']['Wait For Autodock'].delete(0, tk.END)

self.entries['refuel']['Refuel Threshold'].delete(0, tk.END)

self.entries['refuel']['Scoop Timeout'].delete(0, tk.END)

self.entries['refuel']['Fuel Threshold Abort'].delete(0, tk.END)

self.entries['overlay']['X Offset'].delete(0, tk.END)

self.entries['overlay']['Y Offset'].delete(0, tk.END)

self.entries['overlay']['Font Size'].delete(0, tk.END)

self.entries['buttons']['Start FSD'].delete(0, tk.END)

self.entries['buttons']['Start SC'].delete(0, tk.END)

self.entries['buttons']['Start Robigo'].delete(0, tk.END)

self.entries['buttons']['Stop All'].delete(0, tk.END)

self.entries['keys']['Modifier Key Delay'].delete(0, tk.END)

self.entries['keys']['Default Hold Time'].delete(0, tk.END)

self.entries['keys']['Repeat Key Delay'].delete(0, tk.END)

self.entries['ship']['SunPitchUp+Time'].insert(0, float(self.ed_ap.sunpitchuptime))

self.entries['autopilot']['Sun Bright Threshold'].insert(0, int(self.ed_ap.config['SunBrightThreshold']))

self.entries['autopilot']['Nav Align Tries'].insert(0, int(self.ed_ap.config['NavAlignTries']))

self.entries['autopilot']['Jump Tries'].insert(0, int(self.ed_ap.config['JumpTries']))

self.entries['autopilot']['Docking Retries'].insert(0, int(self.ed_ap.config['DockingRetries']))

self.entries['autopilot']['Wait For Autodock'].insert(0, int(self.ed_ap.config['WaitForAutoDockTimer']))

self.entries['refuel']['Refuel Threshold'].insert(0, int(self.ed_ap.config['RefuelThreshold']))

self.entries['refuel']['Scoop Timeout'].insert(0, int(self.ed_ap.config['FuelScoopTimeOut']))

self.entries['refuel']['Fuel Threshold Abort'].insert(0, int(self.ed_ap.config['FuelThreasholdAbortAP']))

self.entries['overlay']['X Offset'].insert(0, int(self.ed_ap.config['OverlayTextXOffset']))

self.entries['overlay']['Y Offset'].insert(0, int(self.ed_ap.config['OverlayTextYOffset']))

self.entries['overlay']['Font Size'].insert(0, int(self.ed_ap.config['OverlayTextFontSize']))

self.entries['buttons']['Start FSD'].insert(0, str(self.ed_ap.config['HotKey_StartFSD']))

self.entries['buttons']['Start SC'].insert(0, str(self.ed_ap.config['HotKey_StartSC']))

self.entries['buttons']['Start Robigo'].insert(0, str(self.ed_ap.config['HotKey_StartRobigo']))

self.entries['buttons']['Stop All'].insert(0, str(self.ed_ap.config['HotKey_StopAllAssists']))

self.entries['keys']['Modifier Key Delay'].insert(0, float(self.ed_ap.config['Key_ModDelay']))

self.entries['keys']['Default Hold Time'].insert(0, float(self.ed_ap.config['Key_DefHoldTime']))

self.entries['keys']['Repeat Key Delay'].insert(0, float(self.ed_ap.config['Key_RepeatDelay']))

if self.ed_ap.config['LogDEBUG']:

self.radiobuttonvar['debug_mode'].set("Debug")

elif self.ed_ap.config['LogINFO']:

self.radiobuttonvar['debug_mode'].set("Info")

else:

self.radiobuttonvar['debug_mode'].set("Error")

# Hotkeys

self.setup_hotkeys()

# check for updates

self.check_updates()

sleep(0.25) # Added because the custom tkinter takes longer to load? Without, you occasionally get errors

# that the main thread is not in main loop.

self.ed_ap.gui_loaded = True

self.gui_loaded = True

# Send a log entry which will flush out the buffer.

self.callback('log', 'ED Autopilot loaded successfully.')

def setup_hotkeys(self):

""" Enable or disable hotkeys.

# Remove all the hotkeys. Adding a dummy hotkey will eliminate an error if none had been configured.

keyboard.add_hotkey(' ', print)

keyboard.remove_all_hotkeys()

if self.ed_ap.config['HotkeysEnable']:

# Add the desired hotkeys

keyboard.add_hotkey(self.ed_ap.config['HotKey_StopAllAssists'], self.stop_all_assists)

keyboard.add_hotkey(self.ed_ap.config['HotKey_StartFSD'], self.callback, args=('fsd_start', None))

keyboard.add_hotkey(self.ed_ap.config['HotKey_StartSC'], self.callback, args=('sc_start', None))

keyboard.add_hotkey(self.ed_ap.config['HotKey_StartRobigo'], self.callback, args=('robigo_start', None))

# TODO - Enable these to allow pips to be controlled by EDAP when using the defined keys (tbd).

# keyboard.add_hotkey('up', self.callback, args=('up', None))

# keyboard.add_hotkey('down', self.callback, args=('down', None))

# keyboard.add_hotkey('left', self.callback, args=('left', None))

# keyboard.add_hotkey('right', self.callback, args=('right', None))

# callback from the EDAP, to configure GUI items

def callback(self, msg, body=None):

if msg == 'log':

self.log_msg(body)

elif msg == 'log+vce':

self.log_msg(body)

self.ed_ap.vce.say(body)

elif msg == 'statusline':

self.update_statusline(body)

elif msg == 'fsd_stop':

logger.debug("Detected 'fsd_stop' callback msg")

self.checkboxvar['FSD Route Assist'].set(0)

self.check_cb('FSD Route Assist')

elif msg == 'fsd_start':

self.checkboxvar['FSD Route Assist'].set(1)

self.check_cb('FSD Route Assist')

elif msg == 'sc_stop':

logger.debug("Detected 'sc_stop' callback msg")

self.checkboxvar['Supercruise Assist'].set(0)

self.check_cb('Supercruise Assist')

elif msg == 'sc_start':

self.checkboxvar['Supercruise Assist'].set(1)

self.check_cb('Supercruise Assist')

elif msg == 'waypoint_stop':

logger.debug("Detected 'waypoint_stop' callback msg")

self.checkboxvar['Waypoint Assist'].set(0)

self.check_cb('Waypoint Assist')

elif msg == 'waypoint_start':

self.checkboxvar['Waypoint Assist'].set(1)

self.check_cb('Waypoint Assist')

elif msg == 'robigo_stop':

logger.debug("Detected 'robigo_stop' callback msg")

self.checkboxvar['Robigo Assist'].set(0)

self.check_cb('Robigo Assist')

elif msg == 'robigo_start':

self.checkboxvar['Robigo Assist'].set(1)

self.check_cb('Robigo Assist')

elif msg == 'afk_stop':

logger.debug("Detected 'afk_stop' callback msg")

self.checkboxvar['AFK Combat Assist'].set(0)

self.check_cb('AFK Combat Assist')

elif msg == 'dss_start':

logger.debug("Detected 'dss_start' callback msg")

self.checkboxvar['DSS Assist'].set(1)

self.check_cb('DSS Assist')

elif msg == 'dss_stop':

logger.debug("Detected 'dss_stop' callback msg")

self.checkboxvar['DSS Assist'].set(0)

self.check_cb('DSS Assist')

elif msg == 'single_waypoint_stop':

logger.debug("Detected 'single_waypoint_stop' callback msg")

self.checkboxvar['Single Waypoint Assist'].set(0)

self.check_cb('Single Waypoint Assist')

elif msg == 'stop_all_assists':

logger.debug("Detected 'stop_all_assists' callback msg")

self.checkboxvar['FSD Route Assist'].set(0)

self.check_cb('FSD Route Assist')

self.checkboxvar['Supercruise Assist'].set(0)

self.check_cb('Supercruise Assist')

self.checkboxvar['Waypoint Assist'].set(0)

self.check_cb('Waypoint Assist')

self.checkboxvar['Robigo Assist'].set(0)

self.check_cb('Robigo Assist')

self.checkboxvar['AFK Combat Assist'].set(0)

self.check_cb('AFK Combat Assist')

self.checkboxvar['DSS Assist'].set(0)

self.check_cb('DSS Assist')

self.checkboxvar['Single Waypoint Assist'].set(0)

self.check_cb('Single Waypoint Assist')

elif msg == 'jumpcount':

self.update_jumpcount(body)

elif msg == 'update_ship_cfg':

self.root.after(0, self.update_ship_cfg)

elif msg == 'load_waypoints':

# TODO - Enable this at some point to auto load the previous waypoints on startup. Not called at the moment.

self.waypoint_editor_tab.editor_load_waypoint_file(body)

elif msg == 'up':

# TODO - Enable these to allow pips to be controlled by EDAP when using the defined keys (tbd). Not called at the moment.

print('up')

if ((self.ed_ap.status.get_flag(FlagsInMainShip) or self.ed_ap.status.get_flag(FlagsInFighter))

and self.ed_ap.status.get_gui_focus() == GuiFocusNoFocus):

self.ed_ap.keys.send('ResetPowerDistribution')

self.ed_ap.keys.send('IncreaseEnginesPower', repeat=3)

elif msg == 'down':

print('down')

if ((self.ed_ap.status.get_flag(FlagsInMainShip) or self.ed_ap.status.get_flag(FlagsInFighter))

and self.ed_ap.status.get_gui_focus() == GuiFocusNoFocus):

self.ed_ap.keys.send('ResetPowerDistribution')

elif msg == 'left':

print('left')

if ((self.ed_ap.status.get_flag(FlagsInMainShip) or self.ed_ap.status.get_flag(FlagsInFighter))

and self.ed_ap.status.get_gui_focus() == GuiFocusNoFocus):

self.ed_ap.keys.send('ResetPowerDistribution')

self.ed_ap.keys.send('IncreaseSystemsPower', repeat=3)

elif msg == 'right':

print('right')

if ((self.ed_ap.status.get_flag(FlagsInMainShip) or self.ed_ap.status.get_flag(FlagsInFighter))

and self.ed_ap.status.get_gui_focus() == GuiFocusNoFocus):

self.ed_ap.keys.send('ResetPowerDistribution')

self.ed_ap.keys.send('IncreaseWeaponsPower', repeat=3)

def update_ship_cfg(self):

"""

self.entries['ship']['SunPitchUp+Time'].delete(0, tk.END)

self.entries['ship']['SunPitchUp+Time'].insert(0, self.ed_ap.sunpitchuptime)

if self.ed_ap.current_ship_cfg:

self.throttle_keys = [key for key, value in self.ed_ap.current_ship_cfg.items() if 'Speed' in key]

self.throttle_combo['values'] = self.throttle_keys

def calibrate_callback(self):

self.ed_ap.calibrate_target()

def quit(self):

logger.debug("Entered: quit")

self.close_window()

def close_window(self):

logger.debug("Entered: close_window")

self.stop_fsd()

self.stop_sc()

self.ed_ap.quit()

sleep(0.1)

self.root.destroy()

# this routine is to stop any current autopilot activity

def stop_all_assists(self):

logger.debug("Entered: stop_all_assists")

self.callback('stop_all_assists')

def start_fsd(self):

logger.debug("Entered: start_fsd")

self.ed_ap.set_fsd_assist(True)

self.FSD_A_running = True

self.log_msg("FSD Route Assist start")

self.ed_ap.vce.say("FSD Route Assist On")

def stop_fsd(self):

logger.debug("Entered: stop_fsd")

self.ed_ap.set_fsd_assist(False)

self.FSD_A_running = False

self.log_msg("FSD Route Assist stop")

self.ed_ap.vce.say("FSD Route Assist Off")

self.update_statusline("Idle")

def start_sc(self):

logger.debug("Entered: start_sc")

self.ed_ap.set_sc_assist(True)

self.SC_A_running = True

self.log_msg("SC Assist start")

self.ed_ap.vce.say("Supercruise Assist On")

def stop_sc(self):

logger.debug("Entered: stop_sc")

self.ed_ap.set_sc_assist(False)

self.SC_A_running = False

self.log_msg("SC Assist stop")

self.ed_ap.vce.say("Supercruise Assist Off")

self.update_statusline("Idle")

def start_waypoint(self):

logger.debug("Entered: start_waypoint")

self.ed_ap.set_waypoint_assist(True)

self.WP_A_running = True

self.log_msg("Waypoint Assist start")

self.ed_ap.vce.say("Waypoint Assist On")

def stop_waypoint(self):

logger.debug("Entered: stop_waypoint")

self.ed_ap.set_waypoint_assist(False)

self.WP_A_running = False

self.log_msg("Waypoint Assist stop")

self.ed_ap.vce.say("Waypoint Assist Off")

self.update_statusline("Idle")

def start_robigo(self):

logger.debug("Entered: start_robigo")

self.ed_ap.set_robigo_assist(True)

self.RO_A_running = True

self.log_msg("Robigo Assist start")

self.ed_ap.vce.say("Robigo Assist On")

def stop_robigo(self):

logger.debug("Entered: stop_robigo")

self.ed_ap.set_robigo_assist(False)

self.RO_A_running = False

self.log_msg("Robigo Assist stop")

self.ed_ap.vce.say("Robigo Assist Off")

self.update_statusline("Idle")

def start_dss(self):

logger.debug("Entered: start_dss")

self.ed_ap.set_dss_assist(True)

self.DSS_A_running = True

self.log_msg("DSS Assist start")

self.ed_ap.vce.say("DSS Assist On")

def stop_dss(self):

logger.debug("Entered: stop_dss")

self.ed_ap.set_dss_assist(False)

self.DSS_A_running = False

self.log_msg("DSS Assist stop")

self.ed_ap.vce.say("DSS Assist Off")

self.update_statusline("Idle")

def start_single_waypoint_assist(self):

""" The debug command to go to a system or station or both."""

logger.debug("Entered: start_single_waypoint_assist")

system = self.single_waypoint_system.get()

station = self.single_waypoint_station.get()

if system != "" or station != "":

self.ed_ap.set_single_waypoint_assist(system, station, True)

self.SWP_A_running = True

self.log_msg("Single Waypoint Assist start")

self.ed_ap.vce.say("Single Waypoint Assist On")

def stop_single_waypoint_assist(self):

""" The debug command to go to a system or station or both."""

logger.debug("Entered: stop_single_waypoint_assist")

self.ed_ap.set_single_waypoint_assist("", "", False)

self.SWP_A_running = False

self.log_msg("Single Waypoint Assist stop")

self.ed_ap.vce.say("Single Waypoint Assist Off")

self.update_statusline("Idle")

def about(self):

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui")

def check_for_updates(self, repo_path):

try:

# Fetch the latest changes from the remote repository

subprocess.run(["git", "fetch"], cwd=repo_path, check=True, capture_output=True)

# Get the current commit hash of the local repository

local_hash = subprocess.run(["git", "rev-parse", "HEAD"], cwd=repo_path, capture_output=True, text=True,

check=True).stdout.strip()

# Get the commit hash of the remote repository

remote_hash = subprocess.run(["git", "rev-parse", "origin/HEAD"], cwd=repo_path, capture_output=True,

text=True, check=True).stdout.strip()

# Compare the commit hashes

if local_hash != remote_hash:

print("The repository has been updated. Please clone it again to get the latest version.")

return True

else:

print("The repository is up to date.")

return False

except subprocess.CalledProcessError as e:

print(f"Error checking for updates: {e}")

return False

except FileNotFoundError:

print("Git command not found. Please ensure Git is installed and in your system's PATH.")

return False

def check_updates(self):

# response = requests.get("https://api.github.com/repos/SumZer0-git/EDAPGui/releases/latest")

# if EDAP_VERSION != response.json()["name"]:

# mb = messagebox.askokcancel("Update Check", "A new release version is available. Download now?")

# if mb == True:

# webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/releases/latest")

# Example usage:

# repo_path = "/path/to/your/local/repo"

repo_path = "./"

updates_available = self.check_for_updates(repo_path)

if updates_available:

# Optionally, provide further instructions or automate the cloning process

self.log_msg("=====================================================")

self.log_msg("========== An update to EDAP is available ===========")

self.log_msg("==== Click 'Check for Updates' on the Debug tab, ====")

self.log_msg("====== or go directly to the EDAP Github page =======")

self.log_msg("=====================================================")

# print("You can use the following command to clone the repository again:")

# print("git clone <repository_url> <new_directory_name>")

else:

self.log_msg("You have the latest version of EDAP!")

def on_throttle_select(self, event):

# The actual logi cis done on the edit curve buttons.

pass

def open_changelog(self):

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/ChangeLog.md")

def open_discord(self):

webbrowser.open_new("https://discord.gg/HCgkfSc")

def open_logfile(self):

os.startfile('autopilot.log')

def log_msg(self, msg):

message = datetime.now().strftime("%H:%M:%S: ") + msg

try:

if not self.gui_loaded:

# Store message in queue

self.log_buffer.put(message)

logger.info(msg)

else:

# Add queued messages to the list

while not self.log_buffer.empty():

self.msgList.insert(tk.END, self.log_buffer.get())

self.msgList.insert(tk.END, message)

self.msgList.yview(tk.END)

logger.info(msg)

except:

# Store message in queue

self.log_buffer.put(message)

logger.info(msg)

def set_statusbar(self, txt):

self.statusbar.configure(text=txt)

def update_jumpcount(self, txt):

self.jumpcount.configure(text=txt)

def update_statusline(self, txt):

self.status.configure(text="Status: " + txt)

self.log_msg(f"Status update: {txt}")

def ship_throttle_0(self):

self.ed_ap.set_throttle_0()

def ship_throttle_50(self):

self.ed_ap.set_throttle_50()

def ship_throttle_100(self):

self.ed_ap.set_throttle_100()

def edit_roll_curve(self):

# Get current ship roll curve

if self.ed_ap.current_ship_cfg:

# Get the selected speed from the combobox

selected_throttle = self.throttle_var.get() # i.e. SCSpeed50 etc.

if selected_throttle in self.ed_ap.current_ship_cfg:

spd_dmd_dict = self.ed_ap.current_ship_cfg[selected_throttle]

if 'RollRate' in spd_dmd_dict:

curve = spd_dmd_dict['RollRate']

# Edit the curve

new_curve = line_editor(curve, f"{selected_throttle} - Roll curve")

if new_curve is not None:

if messagebox.askyesno("RPY curve", "Keep the changes made to curve? If Yes, remember to save."):

spd_dmd_dict['RollRate'] = new_curve

else:

messagebox.showinfo("EDAP", "Select a Throttle setting in the dropdown above.")

def edit_pit_curve(self):

# Get current ship pitch curve

if self.ed_ap.current_ship_cfg:

# Get the selected speed from the combobox

selected_throttle = self.throttle_var.get() # i.e. SCSpeed50 etc.

if selected_throttle in self.ed_ap.current_ship_cfg:

spd_dmd_dict = self.ed_ap.current_ship_cfg[selected_throttle]

if 'PitchRate' in spd_dmd_dict:

curve = spd_dmd_dict['PitchRate']

# Edit the curve

new_curve = line_editor(curve, f"{selected_throttle} - Pitch curve")

if new_curve is not None:

if messagebox.askyesno("RPY curve", "Keep the changes made to curve? If Yes, remember to save."):

spd_dmd_dict['PitchRate'] = new_curve

else:

messagebox.showinfo("EDAP", "Select a Throttle setting in the dropdown above.")

def edit_yaw_curve(self):

# Get current ship yaw curve

if self.ed_ap.current_ship_cfg:

# Get the selected speed from the combobox

selected_throttle = self.throttle_var.get() # i.e. SCSpeed50 etc.

if selected_throttle in self.ed_ap.current_ship_cfg:

spd_dmd_dict = self.ed_ap.current_ship_cfg[selected_throttle]

if 'YawRate' in spd_dmd_dict:

curve = spd_dmd_dict['YawRate']

# Edit the curve

new_curve = line_editor(curve, f"{selected_throttle} - Pitch curve")

if new_curve is not None:

if messagebox.askyesno("RPY curve", "Keep the changes made to curve? If Yes, remember to save."):

spd_dmd_dict['YawRate'] = new_curve

else:

messagebox.showinfo("EDAP", "Select a Throttle setting in the dropdown above.")

def tuning_align_target(self):

"""

self.ed_ap.compass_align(self.ed_ap.scrReg)

def save_settings(self):

self.entry_update(None)

self.ed_ap.update_config()

self.ed_ap.update_ship_configs()

self.calibration.save_ocr_calibration_data()

self.log_msg("Saved all settings.")

def load_settings(self):

self.ed_ap.load_ship_configs()

def open_help(self):

# Determine the active Tab

tab_text = self._nb.tab(self._nb.select(), "text")

if tab_text == "Main":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/Main.md")

elif tab_text == "Settings":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/Settings.md")

elif tab_text == "Debug/Test":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/DebugTest.md")

elif tab_text == "Calibration":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/Calibration.md")

elif tab_text == "Waypoints":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/WaypointEditor.md")

elif tab_text == "Colonization":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/ColonizationEditor.md")

elif tab_text == "TCE":

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/TCE.md")

else:

messagebox.showwarning("Warning", f"No match for tab text '{tab_text}'. Please report to developers.")

webbrowser.open_new("https://github.com/SumZer0-git/EDAPGui/blob/main/docs/Main.md")

def entry_update(self, event):

"""

try:

self.ed_ap.sunpitchuptime = float(self.entries['ship']['SunPitchUp+Time'].get())

self.ed_ap.config['SunBrightThreshold'] = int(self.entries['autopilot']['Sun Bright Threshold'].get())

self.ed_ap.config['NavAlignTries'] = int(self.entries['autopilot']['Nav Align Tries'].get())

self.ed_ap.config['JumpTries'] = int(self.entries['autopilot']['Jump Tries'].get())

self.ed_ap.config['DockingRetries'] = int(self.entries['autopilot']['Docking Retries'].get())

self.ed_ap.config['WaitForAutoDockTimer'] = int(self.entries['autopilot']['Wait For Autodock'].get())

self.ed_ap.config['RefuelThreshold'] = int(self.entries['refuel']['Refuel Threshold'].get())

self.ed_ap.config['FuelScoopTimeOut'] = int(self.entries['refuel']['Scoop Timeout'].get())

self.ed_ap.config['FuelThreasholdAbortAP'] = int(self.entries['refuel']['Fuel Threshold Abort'].get())

self.ed_ap.config['OverlayTextXOffset'] = int(self.entries['overlay']['X Offset'].get())

self.ed_ap.config['OverlayTextYOffset'] = int(self.entries['overlay']['Y Offset'].get())

self.ed_ap.config['OverlayTextFontSize'] = int(self.entries['overlay']['Font Size'].get())

self.ed_ap.config['HotKey_StartFSD'] = str(self.entries['buttons']['Start FSD'].get())

self.ed_ap.config['HotKey_StartSC'] = str(self.entries['buttons']['Start SC'].get())

self.ed_ap.config['HotKey_StartRobigo'] = str(self.entries['buttons']['Start Robigo'].get())

self.ed_ap.config['HotKey_StopAllAssists'] = str(self.entries['buttons']['Stop All'].get())

self.ed_ap.config['VoiceEnable'] = self.checkboxvar['Enable Voice'].get()

self.ed_ap.config['ElwScannerEnable'] = self.checkboxvar['ELW Scanner'].get()

self.ed_ap.config['DebugOverlay'] = self.checkboxvar['Debug Overlay'].get()

self.ed_ap.config['AFKCombat_AttackAtWill'] = self.checkboxvar['AFKCombat AttackAtWill'].get()

self.ed_ap.config['HotkeysEnable'] = self.checkboxvar['Enable Hotkeys'].get()

self.ed_ap.config['DebugOCR'] = self.checkboxvar['Debug OCR'].get()

self.ed_ap.config['DebugImages'] = self.checkboxvar['Debug Images'].get()

self.ed_ap.config['Key_ModDelay'] = float(self.entries['keys']['Modifier Key Delay'].get())

self.ed_ap.config['Key_DefHoldTime'] = float(self.entries['keys']['Default Hold Time'].get())

self.ed_ap.config['Key_RepeatDelay'] = float(self.entries['keys']['Repeat Key Delay'].get())

self.ed_ap.config['AutoTuneRPYRates'] = self.checkboxvar['Enable Auto-tune RPY'].get()

# Process config[] settings to update classes as necessary

self.ed_ap.process_config_settings()

except:

messagebox.showinfo("Exception", "Invalid float entered")

def check_cb(self, field):

""" Check checkbox

# print("got event:", checkboxvar['FSD Route Assist'].get(), " ", str(FSD_A_running))

if field == 'FSD Route Assist':

if self.checkboxvar['FSD Route Assist'].get() == 1 and self.FSD_A_running == False:

self.lab_ck['AFK Combat Assist'].config(state='disabled')

self.lab_ck['Supercruise Assist'].config(state='disabled')

self.lab_ck['Waypoint Assist'].config(state='disabled')

self.lab_ck['Robigo Assist'].config(state='disabled')

self.lab_ck['DSS Assist'].config(state='disabled')

self.start_fsd()

elif self.checkboxvar['FSD Route Assist'].get() == 0 and self.FSD_A_running == True:

self.stop_fsd()

self.lab_ck['Supercruise Assist'].config(state='active')

self.lab_ck['AFK Combat Assist'].config(state='active')

self.lab_ck['Waypoint Assist'].config(state='active')

self.lab_ck['Robigo Assist'].config(state='active')

self.lab_ck['DSS Assist'].config(state='active')

if field == 'Supercruise Assist':

if self.checkboxvar['Supercruise Assist'].get() == 1 and self.SC_A_running == False:

self.lab_ck['FSD Route Assist'].config(state='disabled')

self.lab_ck['AFK Combat Assist'].config(state='disabled')

self.lab_ck['Waypoint Assist'].config(state='disabled')

self.lab_ck['Robigo Assist'].config(state='disabled')

self.lab_ck['DSS Assist'].config(state='disabled')

self.start_sc()

elif self.checkboxvar['Supercruise Assist'].get() == 0 and self.SC_A_running == True:

self.stop_sc()

self.lab_ck['FSD Route Assist'].config(state='active')

self.lab_ck['AFK Combat Assist'].config(state='active')

self.lab_ck['Waypoint Assist'].config(state='active')

self.lab_ck['Robigo Assist'].config(state='active')

self.lab_ck['DSS Assist'].config(state='active')

if field == 'Waypoint Assist':

if self.checkboxvar['Waypoint Assist'].get() == 1 and self.WP_A_running == False:

self.lab_ck['FSD Route Assist'].config(state='disabled')

self.lab_ck['Supercruise Assist'].config(state='disabled')

self.lab_ck['AFK Combat Assist'].config(state='disabled')

self.lab_ck['Robigo Assist'].config(state='disabled')

self.lab_ck['DSS Assist'].config(state='disabled')

self.start_waypoint()

elif self.checkboxvar['Waypoint Assist'].get() == 0 and self.WP_A_running == True:

self.stop_waypoint()

self.lab_ck['FSD Route Assist'].config(state='active')

self.lab_ck['Supercruise Assist'].config(state='active')

self.lab_ck['AFK Combat Assist'].config(state='active')

self.lab_ck['Robigo Assist'].config(state='active')

self.lab_ck['DSS Assist'].config(state='active')

if field == 'Robigo Assist':

if self.checkboxvar['Robigo Assist'].get() == 1 and self.RO_A_running == False:

self.lab_ck['FSD Route Assist'].config(state='disabled')

self.lab_ck['Supercruise Assist'].config(state='disabled')

self.lab_ck['AFK Combat Assist'].config(state='disabled')

self.lab_ck['Waypoint Assist'].config(state='disabled')

self.lab_ck['DSS Assist'].config(state='disabled')

self.start_robigo()

elif self.checkboxvar['Robigo Assist'].get() == 0 and self.RO_A_running == True:

self.stop_robigo()

self.lab_ck['FSD Route Assist'].config(state='active')

self.lab_ck['Supercruise Assist'].config(state='active')

self.lab_ck['AFK Combat Assist'].config(state='active')

self.lab_ck['Waypoint Assist'].config(state='active')

self.lab_ck['DSS Assist'].config(state='active')

if field == 'AFK Combat Assist':

if self.checkboxvar['AFK Combat Assist'].get() == 1:

self.ed_ap.set_afk_combat_assist(True)

self.log_msg("AFK Combat Assist start")

self.lab_ck['FSD Route Assist'].config(state='disabled')

self.lab_ck['Supercruise Assist'].config(state='disabled')

self.lab_ck['Waypoint Assist'].config(state='disabled')

self.lab_ck['Robigo Assist'].config(state='disabled')

self.lab_ck['DSS Assist'].config(state='disabled')

elif self.checkboxvar['AFK Combat Assist'].get() == 0:

self.ed_ap.set_afk_combat_assist(False)

self.log_msg("AFK Combat Assist stop")

self.lab_ck['FSD Route Assist'].config(state='active')

self.lab_ck['Supercruise Assist'].config(state='active')

self.lab_ck['Waypoint Assist'].config(state='active')

self.lab_ck['Robigo Assist'].config(state='active')

self.lab_ck['DSS Assist'].config(state='active')

if field == 'DSS Assist':

if self.checkboxvar['DSS Assist'].get() == 1:

self.lab_ck['FSD Route Assist'].config(state='disabled')

self.lab_ck['AFK Combat Assist'].config(state='disabled')

self.lab_ck['Supercruise Assist'].config(state='disabled')

self.lab_ck['Waypoint Assist'].config(state='disabled')

self.lab_ck['Robigo Assist'].config(state='disabled')

self.start_dss()

elif self.checkboxvar['DSS Assist'].get() == 0:

self.stop_dss()

self.lab_ck['FSD Route Assist'].config(state='active')

self.lab_ck['Supercruise Assist'].config(state='active')

self.lab_ck['AFK Combat Assist'].config(state='active')

self.lab_ck['Waypoint Assist'].config(state='active')

self.lab_ck['Robigo Assist'].config(state='active')

if self.checkboxvar['Enable Randomness'].get():

self.ed_ap.set_randomness(True)

else:

self.ed_ap.set_randomness(False)

if self.checkboxvar['Activate Elite for each key'].get():

self.ed_ap.set_activate_elite_eachkey(True)

self.ed_ap.keys.activate_window = True

else:

self.ed_ap.set_activate_elite_eachkey(False)

self.ed_ap.keys.activate_window = False

if self.checkboxvar['Automatic logout'].get():

self.ed_ap.set_automatic_logout(True)

else:

self.ed_ap.set_automatic_logout(False)

if self.checkboxvar['Enable Overlay'].get():

self.ed_ap.set_overlay(True)

else:

self.ed_ap.set_overlay(False)

if self.checkboxvar['Enable Voice'].get():

self.ed_ap.set_voice(True)

else:

self.ed_ap.set_voice(False)

if self.checkboxvar['ELW Scanner'].get():

self.ed_ap.set_fss_scan(True)

else:

self.ed_ap.set_fss_scan(False)

if self.checkboxvar['Enable CV View'].get() == 1:

self.cv_view = True

x = self.root.winfo_x() + self.root.winfo_width() + 4

y = self.root.winfo_y()

self.ed_ap.set_cv_view(True, x, y)

else:

self.cv_view = False

self.ed_ap.set_cv_view(False)

self.ed_ap.config['DSSButton'] = self.radiobuttonvar['dss_button'].get()

if self.radiobuttonvar['debug_mode'].get() == "Error":

self.ed_ap.set_log_error(True)

elif self.radiobuttonvar['debug_mode'].get() == "Debug":

self.ed_ap.set_log_debug(True)

elif self.radiobuttonvar['debug_mode'].get() == "Info":

self.ed_ap.set_log_info(True)

if field == 'Single Waypoint Assist':

if self.checkboxvar['Single Waypoint Assist'].get() == 1 and self.SWP_A_running == False:

self.start_single_waypoint_assist()

elif self.checkboxvar['Single Waypoint Assist'].get() == 0 and self.SWP_A_running == True:

self.stop_single_waypoint_assist()

if field == 'Debug Overlay':

if self.checkboxvar['Debug Overlay'].get():

self.ed_ap.debug_overlay = True

else:

self.ed_ap.debug_overlay = False

self.ed_ap.config['AFKCombat_AttackAtWill'] = self.checkboxvar['AFKCombat AttackAtWill'].get()

if field == 'Enable Hotkeys':

self.ed_ap.config['HotkeysEnable'] = self.checkboxvar['Enable Hotkeys'].get()

self.setup_hotkeys()

if field == 'Debug OCR':

self.ed_ap.debug_ocr = self.checkboxvar['Debug OCR'].get()

if field == 'Debug Images':

self.ed_ap.debug_images = self.checkboxvar['Debug Images'].get()

if field == 'Enable Auto-tune RPY':

self.ed_ap.config['AutoTuneRPYRates'] = self.checkboxvar['Enable Auto-tune RPY'].get()

def makeform(self, win: ttk.LabelFrame, f_type: int, fields, r: int = 0, inc: float = 1, r_from: float = 0,

rto: float = 1000):

entries = {}

win.columnconfigure(1, weight=1)

for fld in fields:

if f_type == FORM_TYPE_CHECKBOX:

self.checkboxvar[fld] = tk.IntVar()

lab = ttk.Checkbutton(win, text=fld, variable=self.checkboxvar[fld],

command=(lambda field=fld: self.check_cb(field)))

self.lab_ck[fld] = lab

lab.grid(row=r, column=0, columnspan=2, padx=2, pady=2, sticky=tk.W)

else:

lab = ttk.Label(win, text=fld + ": ")

if f_type == FORM_TYPE_SPINBOX:

ent = ttk.Spinbox(win, width=10, from_=r_from, to=rto, increment=inc, justify=tk.RIGHT)

else:

ent = ttk.Entry(win, width=10, justify=tk.RIGHT)

ent.bind('<FocusOut>', self.entry_update)

ent.insert(0, "0")

lab.grid(row=r, column=0, padx=2, pady=2, sticky=tk.W)