575 lines
19 KiB
Python
575 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
|
|
from datetime import datetime
|
|
import tkinter as tk
|
|
import tkinter.ttk as ttk
|
|
import tkinter.messagebox
|
|
try:
|
|
import spiceapi
|
|
except ModuleNotFoundError:
|
|
raise RuntimeError("spiceapi module not installed")
|
|
|
|
|
|
NSEW = tk.N+tk.S+tk.E+tk.W
|
|
|
|
|
|
def api_action(func):
|
|
def wrapper(*args, **kwargs):
|
|
try:
|
|
func(*args, **kwargs)
|
|
except spiceapi.APIError as e:
|
|
tk.messagebox.showerror(title="API Error", message=str(e))
|
|
except ValueError as e:
|
|
tk.messagebox.showerror(title="Input Error", message=str(e))
|
|
except (ConnectionResetError, BrokenPipeError, RuntimeError) as e:
|
|
tk.messagebox.showerror(title="Connection Error", message=str(e))
|
|
except AttributeError:
|
|
tk.messagebox.showerror(title="Error", message="No active connection.")
|
|
except BaseException as e:
|
|
tk.messagebox.showerror(title="Exception", message=str(e))
|
|
return wrapper
|
|
|
|
|
|
class TextField(ttk.Frame):
|
|
"""Simple text field with a scroll bar to the right."""
|
|
|
|
def __init__(self, parent, read_only=False, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.parent = parent
|
|
self.read_only = read_only
|
|
|
|
# create scroll bar
|
|
self.scroll = ttk.Scrollbar(self)
|
|
self.scroll.pack(side=tk.RIGHT, fill=tk.Y)
|
|
|
|
# create text field
|
|
self.contents = tk.Text(self, height=1, width=50,
|
|
foreground="black", background="#E8E6E0",
|
|
insertbackground="black")
|
|
self.contents.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)
|
|
|
|
# link scroll bar with text field
|
|
self.scroll.config(command=self.contents.yview)
|
|
self.contents.config(yscrollcommand=self.scroll.set)
|
|
|
|
# read only setting
|
|
if self.read_only:
|
|
self.contents.config(state=tk.DISABLED)
|
|
|
|
def get_text(self):
|
|
"""Get the current text content as string.
|
|
|
|
:return: text content
|
|
"""
|
|
return self.contents.get("1.0", tk.END+"-1c")
|
|
|
|
def set_text(self, text):
|
|
"""Set the current text content.
|
|
|
|
:param text: text content
|
|
:return: None
|
|
"""
|
|
|
|
# enable if read only
|
|
if self.read_only:
|
|
self.contents.config(state=tk.NORMAL)
|
|
|
|
# delete old content and insert replacement text
|
|
self.contents.delete("1.0", tk.END)
|
|
self.contents.insert(tk.END, text)
|
|
|
|
# disable if read only
|
|
if self.read_only:
|
|
self.contents.config(state=tk.DISABLED)
|
|
|
|
|
|
class ManualTab(ttk.Frame):
|
|
"""Manual JSON request/response functinality."""
|
|
|
|
def __init__(self, app, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.app = app
|
|
self.parent = parent
|
|
self.rowconfigure(0, weight=1)
|
|
self.rowconfigure(1, weight=1)
|
|
self.columnconfigure(0, weight=1)
|
|
|
|
# request text field
|
|
self.txt_request = TextField(self, read_only=False)
|
|
self.txt_request.grid(row=0, column=0, sticky=NSEW, padx=2, pady=2)
|
|
self.txt_request.set_text(
|
|
'{\n'
|
|
' "id": 1,\n'
|
|
' "module": "coin",\n'
|
|
' "function": "insert",\n'
|
|
' "params": []\n'
|
|
'}\n'
|
|
)
|
|
|
|
# response text field
|
|
self.txt_response = TextField(self, read_only=False)
|
|
self.txt_response.grid(row=1, column=0, sticky=NSEW, padx=2, pady=2)
|
|
#self.txt_response.contents.config(state=tk.DISABLED)
|
|
|
|
# send button
|
|
self.btn_send = ttk.Button(self, text="Send", command=self.action_send)
|
|
self.btn_send.grid(row=2, column=0, sticky=tk.W+tk.E, padx=2, pady=2)
|
|
|
|
def action_send(self):
|
|
"""Gets called when the send button is pressed."""
|
|
|
|
# check connection
|
|
if self.app.connection:
|
|
|
|
# send request and get response
|
|
self.txt_response.set_text("Sending...")
|
|
try:
|
|
|
|
# build request
|
|
request = spiceapi.Request.from_json(self.txt_request.get_text())
|
|
|
|
# send request and get response, measure time
|
|
t1 = datetime.now()
|
|
response = self.app.connection.request(request)
|
|
t2 = datetime.now()
|
|
|
|
# set response text
|
|
self.txt_response.set_text("{}\n\nElapsed time: {} seconds".format(
|
|
response.to_json(),
|
|
(t2 - t1).total_seconds())
|
|
)
|
|
|
|
except spiceapi.APIError as e:
|
|
self.txt_response.set_text(f"Server returned error:\n{e}")
|
|
except spiceapi.MalformedRequestException:
|
|
self.txt_response.set_text("Malformed request detected.")
|
|
except (ConnectionResetError, BrokenPipeError, RuntimeError) as e:
|
|
self.txt_response.set_text("Error sending request: " + str(e))
|
|
except BaseException as e:
|
|
self.txt_response.set_text("General Exception: " + str(e))
|
|
|
|
else:
|
|
|
|
# print error
|
|
self.txt_response.set_text("No active connection.")
|
|
|
|
|
|
class ControlTab(ttk.Frame):
|
|
"""Main control tab."""
|
|
|
|
def __init__(self, app, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.app = app
|
|
self.parent = parent
|
|
|
|
# scale grid
|
|
self.columnconfigure(0, weight=1)
|
|
|
|
# card
|
|
self.card = ttk.Frame(self, padding=(8, 8, 8, 8))
|
|
self.card.grid(row=0, column=0, sticky=tk.E+tk.W)
|
|
self.card.columnconfigure(0, weight=1)
|
|
self.card.columnconfigure(1, weight=1)
|
|
self.card_lbl = ttk.Label(self.card, text="Card")
|
|
self.card_lbl.grid(row=0, columnspan=2)
|
|
self.card_entry = ttk.Entry(self.card)
|
|
self.card_entry.insert(tk.END, "E004010000000000")
|
|
self.card_entry.grid(row=1, columnspan=2, sticky=NSEW, padx=2, pady=2)
|
|
self.card_insert_p1 = ttk.Button(self.card, text="Insert P1", command=self.action_insert_p1)
|
|
self.card_insert_p1.grid(row=2, column=0, sticky=NSEW, padx=2, pady=2)
|
|
self.card_insert_p2 = ttk.Button(self.card, text="Insert P2", command=self.action_insert_p2)
|
|
self.card_insert_p2.grid(row=2, column=1, sticky=NSEW, padx=2, pady=2)
|
|
|
|
# coin
|
|
self.coin = ttk.Frame(self, padding=(8, 8, 8, 8))
|
|
self.coin.grid(row=1, column=0, sticky=tk.E+tk.W)
|
|
self.coin.columnconfigure(0, weight=1)
|
|
self.coin.columnconfigure(1, weight=1)
|
|
self.coin.columnconfigure(2, weight=1)
|
|
self.coin_lbl = ttk.Label(self.coin, text="Coins")
|
|
self.coin_lbl.grid(row=0, columnspan=3)
|
|
self.coin_entry = ttk.Entry(self.coin)
|
|
self.coin_entry.insert(tk.END, "1")
|
|
self.coin_entry.grid(row=1, columnspan=3, sticky=NSEW, padx=2, pady=2)
|
|
self.coin_set = ttk.Button(self.coin, text="Set to Amount", command=self.action_coin_set)
|
|
self.coin_set.grid(row=2, column=0, sticky=NSEW, padx=2, pady=2)
|
|
self.coin_insert = ttk.Button(self.coin, text="Insert Amount", command=self.action_coin_insert)
|
|
self.coin_insert.grid(row=2, column=1, sticky=NSEW, padx=2, pady=2)
|
|
self.coin_insert = ttk.Button(self.coin, text="Insert Single", command=self.action_coin_insert_single)
|
|
self.coin_insert.grid(row=2, column=2, sticky=NSEW, padx=2, pady=2)
|
|
|
|
@api_action
|
|
def action_insert(self, unit: int):
|
|
spiceapi.card_insert(self.app.connection, unit, self.card_entry.get())
|
|
|
|
@api_action
|
|
def action_insert_p1(self):
|
|
return self.action_insert(0)
|
|
|
|
@api_action
|
|
def action_insert_p2(self):
|
|
return self.action_insert(1)
|
|
|
|
@api_action
|
|
def action_coin_set(self):
|
|
spiceapi.coin_set(self.app.connection, int(self.coin_entry.get()))
|
|
|
|
@api_action
|
|
def action_coin_insert(self):
|
|
spiceapi.coin_insert(self.app.connection, int(self.coin_entry.get()))
|
|
|
|
@api_action
|
|
def action_coin_insert_single(self):
|
|
spiceapi.coin_insert(self.app.connection)
|
|
|
|
|
|
class InfoTab(ttk.Frame):
|
|
"""The info tab."""
|
|
|
|
def __init__(self, app, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.app = app
|
|
self.parent = parent
|
|
self.rowconfigure(0, weight=1)
|
|
self.columnconfigure(0, weight=1)
|
|
|
|
# info text field
|
|
self.txt_info = TextField(self, read_only=True)
|
|
self.txt_info.grid(row=0, column=0, sticky=NSEW, padx=2, pady=2)
|
|
|
|
# refresh button
|
|
self.btn_refresh = ttk.Button(self, text="Refresh", command=self.action_refresh)
|
|
self.btn_refresh.grid(row=1, column=0, sticky=tk.W+tk.E, padx=2, pady=2)
|
|
|
|
@api_action
|
|
def action_refresh(self):
|
|
|
|
# get information
|
|
avs = spiceapi.info_avs(self.app.connection)
|
|
launcher = spiceapi.info_launcher(self.app.connection)
|
|
memory = spiceapi.info_memory(self.app.connection)
|
|
|
|
# build text
|
|
avs_text = ""
|
|
for k, v in avs.items():
|
|
avs_text += f"{k}: {v}\n"
|
|
launcher_text = ""
|
|
for k, v in launcher.items():
|
|
if isinstance(v, list):
|
|
launcher_text += f"{k}:\n"
|
|
for i in v:
|
|
launcher_text += f" {i}\n"
|
|
else:
|
|
launcher_text += f"{k}: {v}\n"
|
|
memory_text = ""
|
|
for k, v in memory.items():
|
|
memory_text += f"{k}: {v}\n"
|
|
|
|
# set text
|
|
self.txt_info.set_text(
|
|
f"AVS:\n{avs_text}\n"
|
|
f"Launcher:\n{launcher_text}\n"
|
|
f"Memory:\n{memory_text}"
|
|
)
|
|
|
|
|
|
class ButtonsTab(ttk.Frame):
|
|
"""The buttons tab."""
|
|
|
|
def __init__(self, app, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.app = app
|
|
self.parent = parent
|
|
self.rowconfigure(0, weight=1)
|
|
self.columnconfigure(0, weight=1)
|
|
|
|
# button text field
|
|
self.txt_buttons = TextField(self, read_only=True)
|
|
self.txt_buttons.grid(row=0, column=0, sticky=NSEW, padx=2, pady=2)
|
|
|
|
# refresh button
|
|
self.btn_refresh = ttk.Button(self, text="Refresh", command=self.action_refresh)
|
|
self.btn_refresh.grid(row=1, column=0, sticky=tk.W+tk.E, padx=2, pady=2)
|
|
|
|
@api_action
|
|
def action_refresh(self):
|
|
|
|
# get states
|
|
states = spiceapi.buttons_read(self.app.connection)
|
|
|
|
# build text
|
|
txt = ""
|
|
for name, velocity, active in states:
|
|
state = "on" if velocity > 0 else "off"
|
|
active_txt = "" if active else " (inactive)"
|
|
txt += f"{name}: {state}{active_txt}\n"
|
|
if len(states) == 0:
|
|
txt = "No buttons available."
|
|
|
|
# set text
|
|
self.txt_buttons.set_text(txt)
|
|
|
|
|
|
class AnalogsTab(ttk.Frame):
|
|
"""The analogs tab."""
|
|
|
|
def __init__(self, app, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.app = app
|
|
self.parent = parent
|
|
self.rowconfigure(0, weight=1)
|
|
self.columnconfigure(0, weight=1)
|
|
|
|
# button text field
|
|
self.txt_analogs = TextField(self, read_only=True)
|
|
self.txt_analogs.grid(row=0, column=0, sticky=NSEW, padx=2, pady=2)
|
|
|
|
# refresh button
|
|
self.btn_refresh = ttk.Button(self, text="Refresh", command=self.action_refresh)
|
|
self.btn_refresh.grid(row=1, column=0, sticky=tk.W+tk.E, padx=2, pady=2)
|
|
|
|
@api_action
|
|
def action_refresh(self):
|
|
|
|
# get states
|
|
states = spiceapi.analogs_read(self.app.connection)
|
|
|
|
# build text
|
|
txt = ""
|
|
for name, value, active in states:
|
|
value_txt = round(value, 2)
|
|
active_txt = "" if active else " (inactive)"
|
|
txt += f"{name}: {value_txt}{active_txt}\n"
|
|
if len(states) == 0:
|
|
txt = "No analogs available."
|
|
|
|
# set text
|
|
self.txt_analogs.set_text(txt)
|
|
|
|
|
|
class LightsTab(ttk.Frame):
|
|
"""The lights tab."""
|
|
|
|
def __init__(self, app, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.app = app
|
|
self.parent = parent
|
|
self.rowconfigure(0, weight=1)
|
|
self.columnconfigure(0, weight=1)
|
|
|
|
# light text field
|
|
self.txt_lights = TextField(self, read_only=True)
|
|
self.txt_lights.grid(row=0, column=0, sticky=NSEW, padx=2, pady=2)
|
|
|
|
# refresh button
|
|
self.btn_refresh = ttk.Button(self, text="Refresh", command=self.action_refresh)
|
|
self.btn_refresh.grid(row=1, column=0, sticky=tk.W+tk.E, padx=2, pady=2)
|
|
|
|
@api_action
|
|
def action_refresh(self):
|
|
|
|
# get states
|
|
states = spiceapi.lights_read(self.app.connection)
|
|
|
|
# build text
|
|
txt = ""
|
|
for name, value, active in states:
|
|
value_txt = round(value, 2)
|
|
active_txt = "" if active else " (inactive)"
|
|
txt += f"{name}: {value_txt}{active_txt}\n"
|
|
if len(states) == 0:
|
|
txt = "No lights available."
|
|
|
|
# set text
|
|
self.txt_lights.set_text(txt)
|
|
|
|
|
|
class MainApp(ttk.Frame):
|
|
"""The main application frame."""
|
|
|
|
def __init__(self, parent, **kwargs):
|
|
|
|
# init frame
|
|
ttk.Frame.__init__(self, parent, **kwargs)
|
|
self.parent = parent
|
|
self.connection = None
|
|
|
|
self.tabs = ttk.Notebook(self)
|
|
self.tab_control = ControlTab(self, self.tabs)
|
|
self.tabs.add(self.tab_control, text="Control")
|
|
self.tab_info = InfoTab(self, self.tabs)
|
|
self.tabs.add(self.tab_info, text="Info")
|
|
self.tab_buttons = ButtonsTab(self, self.tabs)
|
|
self.tabs.add(self.tab_buttons, text="Buttons")
|
|
self.tab_analogs = AnalogsTab(self, self.tabs)
|
|
self.tabs.add(self.tab_analogs, text="Analogs")
|
|
self.tab_lights = LightsTab(self, self.tabs)
|
|
self.tabs.add(self.tab_lights, text="Lights")
|
|
self.tab_manual = ManualTab(self, self.tabs)
|
|
self.tabs.add(self.tab_manual, text="Manual")
|
|
self.tabs.pack(expand=True, fill=tk.BOTH)
|
|
|
|
# connection panel
|
|
self.frm_connection = ttk.Frame(self)
|
|
|
|
# host: [field]
|
|
self.lbl_host = ttk.Label(self.frm_connection, text="Host:")
|
|
self.txt_host = ttk.Entry(self.frm_connection, width=15)
|
|
self.lbl_host.columnconfigure(0, weight=1)
|
|
self.txt_host.columnconfigure(1, weight=1)
|
|
self.txt_host.insert(tk.END, "localhost")
|
|
|
|
# port: [field]
|
|
self.lbl_port = ttk.Label(self.frm_connection, text="Port:")
|
|
self.txt_port = ttk.Entry(self.frm_connection, width=5)
|
|
self.lbl_port.columnconfigure(2, weight=1)
|
|
self.txt_port.columnconfigure(3, weight=1)
|
|
self.txt_port.insert(tk.END, "1337")
|
|
|
|
# pass: [field]
|
|
self.lbl_pw = ttk.Label(self.frm_connection, text="Pass:")
|
|
self.txt_pw = ttk.Entry(self.frm_connection, width=10)
|
|
self.lbl_pw.columnconfigure(4, weight=1)
|
|
self.txt_pw.columnconfigure(5, weight=1)
|
|
self.txt_pw.insert(tk.END, "debug")
|
|
|
|
# grid setup
|
|
self.lbl_host.grid(row=0, column=0, sticky=tk.W+tk.E, padx=2)
|
|
self.txt_host.grid(row=0, column=1, sticky=tk.W+tk.E, padx=2)
|
|
self.lbl_port.grid(row=0, column=2, sticky=tk.W+tk.E, padx=2)
|
|
self.txt_port.grid(row=0, column=3, sticky=tk.W+tk.E, padx=2)
|
|
self.lbl_pw.grid(row=0, column=4, sticky=tk.W+tk.E, padx=2)
|
|
self.txt_pw.grid(row=0, column=5, sticky=tk.W+tk.E, padx=2)
|
|
self.frm_connection.pack(fill=tk.NONE, pady=2)
|
|
|
|
# send/connect/disconnect buttons panel
|
|
self.frm_connect = ttk.Frame(self)
|
|
|
|
# connect button
|
|
self.btn_connect = ttk.Button(
|
|
self.frm_connect,
|
|
text="Connect",
|
|
command=self.action_connect,
|
|
width=10)
|
|
|
|
# disconnect button
|
|
self.btn_disconnect = ttk.Button(
|
|
self.frm_connect,
|
|
text="Disconnect",
|
|
command=self.action_disconnect,
|
|
width=10)
|
|
|
|
# kill button
|
|
self.btn_kill = ttk.Button(
|
|
self.frm_connect,
|
|
text="Kill",
|
|
command=self.action_kill,
|
|
width=10)
|
|
|
|
# restart button
|
|
self.btn_restart = ttk.Button(
|
|
self.frm_connect,
|
|
text="Restart",
|
|
command=self.action_restart,
|
|
width=10)
|
|
|
|
# grid setup
|
|
self.btn_connect.grid(row=0, column=1, sticky=tk.W+tk.E, padx=2)
|
|
self.btn_disconnect.grid(row=0, column=2, sticky=tk.W+tk.E, padx=2)
|
|
self.btn_kill.grid(row=0, column=3, sticky=tk.W+tk.E, padx=2)
|
|
self.btn_restart.grid(row=0, column=4, sticky=tk.W+tk.E, padx=2)
|
|
self.frm_connect.pack(fill=tk.NONE, pady=2)
|
|
|
|
def action_connect(self):
|
|
"""Gets called when the connect button is pressed."""
|
|
|
|
# retrieve connection info
|
|
host = self.txt_host.get()
|
|
port = self.txt_port.get()
|
|
password = self.txt_pw.get()
|
|
|
|
# check input
|
|
if not port.isdigit():
|
|
tk.messagebox.showerror("Connection Error", f"Port '{port}' is not a valid number.")
|
|
return
|
|
|
|
# create a new connection
|
|
try:
|
|
self.connection = spiceapi.Connection(host=host, port=int(port), password=password)
|
|
except OSError as e:
|
|
tk.messagebox.showerror("Connection Error", "Failed to connect: " + str(e))
|
|
return
|
|
|
|
# print success
|
|
tk.messagebox.showinfo("Success", "Connected.")
|
|
|
|
def action_disconnect(self):
|
|
"""Gets called when the disconnect button is pressed."""
|
|
|
|
# check connection
|
|
if self.connection:
|
|
|
|
# close connection
|
|
self.connection.close()
|
|
self.connection = None
|
|
tk.messagebox.showinfo("Success", "Closed connection.")
|
|
|
|
else:
|
|
|
|
# print error
|
|
tk.messagebox.showinfo("Error", "No active connection.")
|
|
|
|
def action_kill(self):
|
|
"""Gets called when the kill button is pressed."""
|
|
|
|
# check connection
|
|
if self.connection:
|
|
spiceapi.control_exit(self.connection)
|
|
self.connection = None
|
|
else:
|
|
tk.messagebox.showinfo("Error", "No active connection.")
|
|
|
|
def action_restart(self):
|
|
"""Gets called when the restart button is pressed."""
|
|
|
|
# check connection
|
|
if self.connection:
|
|
spiceapi.control_restart(self.connection)
|
|
self.connection = None
|
|
else:
|
|
tk.messagebox.showinfo("Error", "No active connection.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
# create root
|
|
root = tk.Tk()
|
|
root.title("SpiceRemote")
|
|
root.geometry("500x300")
|
|
|
|
# set theme
|
|
preferred_theme = "clam"
|
|
s = ttk.Style(root)
|
|
if preferred_theme in s.theme_names():
|
|
s.theme_use(preferred_theme)
|
|
|
|
# add application
|
|
MainApp(root).pack(side=tk.TOP, fill=tk.BOTH, expand=True)
|
|
|
|
# run root
|
|
root.mainloop()
|