380 lines
11 KiB
Python
380 lines
11 KiB
Python
from datetime import datetime
|
|
import sys
|
|
import gi
|
|
import os
|
|
|
|
from usbdev import USBDevices
|
|
|
|
gi.require_version("Gtk", "4.0")
|
|
gi.require_version("Gdk", "4.0")
|
|
from gi.repository import Gdk, GLib, Gtk
|
|
|
|
class UIController:
|
|
def __init__(
|
|
self,
|
|
ui_file="window.ui",
|
|
css_file="style.css",
|
|
system_checks=None,
|
|
power_action_callback=None,
|
|
service_action_callback=None,
|
|
services = None
|
|
):
|
|
self.builder = Gtk.Builder.new_from_file(ui_file)
|
|
self.window = self.builder.get_object("main_window")
|
|
self._load_styles(css_file)
|
|
self._setup_clock()
|
|
self._initialise_usb_options()
|
|
self._initialise_power_options()
|
|
self.power_action_callback = power_action_callback
|
|
self.system_checks = system_checks
|
|
self.service_action_callback = service_action_callback
|
|
self.services = services or []
|
|
|
|
self._cards_created = False
|
|
self._services_visible = False
|
|
self.usb_devices = []
|
|
|
|
if self.system_checks:
|
|
self._setup_system_status()
|
|
|
|
if not self._cards_created:
|
|
self._create_cards()
|
|
self._cards_created = True
|
|
|
|
def _setup_system_status(self):
|
|
"""Monitor SystemChecks state from GTK Main thread"""
|
|
self._update_system_status()
|
|
GLib.timeout_add_seconds(
|
|
1,
|
|
self._update_system_status
|
|
)
|
|
|
|
def _update_system_status(self):
|
|
"""Update Status display and create cards when system is ready"""
|
|
network = self.system_checks.network_online
|
|
ziti = self.system_checks.ziti_online
|
|
|
|
if network is None:
|
|
self._update_label(
|
|
"net_status",
|
|
"Net: Checking",
|
|
None,
|
|
)
|
|
else:
|
|
self._update_label(
|
|
"net_status",
|
|
"Net: Connected" if network else "Net: Disconnected",
|
|
network,
|
|
)
|
|
|
|
if ziti is None:
|
|
self._update_label(
|
|
"ziti_status",
|
|
"Ziti: Checking",
|
|
None,
|
|
)
|
|
else :
|
|
self._update_label(
|
|
"ziti_status",
|
|
"Ziti: Connected" if ziti else "Ziti: Disconnected",
|
|
ziti,
|
|
)
|
|
|
|
if self.system_checks.ready and not self._services_visible:
|
|
self.builder.get_object("startup_revealer").set_reveal_child(False)
|
|
self.builder.get_object("cards_revealer").set_reveal_child(True)
|
|
|
|
self._services_visible = True
|
|
|
|
return True
|
|
|
|
|
|
def _update_label(self, widget_id, text, is_healthy):
|
|
label = self.builder.get_object(widget_id)
|
|
if label:
|
|
label.set_text(text)
|
|
if is_healthy:
|
|
label.remove_css_class("error-label")
|
|
label.add_css_class("ok-label")
|
|
else:
|
|
label.remove_css_class("ok-label")
|
|
label.add_css_class("error-label")
|
|
|
|
def _create_cards(self):
|
|
"""Create Service Cards"""
|
|
|
|
for service in self.services:
|
|
title = service.get("title", "Service")
|
|
desc = service.get("desc", "")
|
|
bg_img = service.get("bg_image", "")
|
|
|
|
self.add_card(
|
|
title,
|
|
desc,
|
|
bg_img,
|
|
lambda svc=service: self.service_action_callback(svc, self.usb_devices),
|
|
)
|
|
|
|
def _load_styles(self, css_file):
|
|
css_provider = Gtk.CssProvider()
|
|
css_provider.load_from_path(css_file)
|
|
Gtk.StyleContext.add_provider_for_display(
|
|
Gdk.Display.get_default(),
|
|
css_provider,
|
|
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
|
|
)
|
|
|
|
def _setup_clock(self):
|
|
clock_label = self.builder.get_object("clock_label")
|
|
date_label = self.builder.get_object("date_label")
|
|
|
|
def update():
|
|
now = datetime.now()
|
|
clock_label.set_text(now.strftime("%H:%M"))
|
|
date_label.set_text(now.strftime("%A %d/%m/%Y"))
|
|
return True
|
|
|
|
update()
|
|
GLib.timeout_add_seconds(10, update)
|
|
|
|
def _initialise_usb_options(self):
|
|
btn_usb = self.builder.get_object("usb_menu_button")
|
|
|
|
if btn_usb:
|
|
btn_usb.connect(
|
|
"clicked",
|
|
lambda _: self._show_usb_selection()
|
|
)
|
|
|
|
def _initialise_power_options(self):
|
|
btn_reboot = self.builder.get_object("btn_reboot")
|
|
btn_shutdown = self.builder.get_object("btn_shutdown")
|
|
|
|
if btn_reboot:
|
|
btn_reboot.connect(
|
|
"clicked", lambda _: self.power_action_callback("reboot")
|
|
)
|
|
|
|
if btn_shutdown:
|
|
btn_shutdown.connect(
|
|
"clicked", lambda _: self.power_action_callback("shutdown")
|
|
)
|
|
|
|
def set_app_title(self, title):
|
|
title_label = self.builder.get_object("app_title_label")
|
|
title_label.set_text(title)
|
|
|
|
def add_card(self, title_text, desc_text, bg_path, on_click_callback):
|
|
container = self.builder.get_object("cards_flow")
|
|
|
|
button = Gtk.Button()
|
|
button.add_css_class("image-card") # Switched to our new image-card class
|
|
button.connect("clicked", lambda *_: on_click_callback())
|
|
|
|
# Main overlay container
|
|
overlay = Gtk.Overlay()
|
|
|
|
# 1. Background Image Layer
|
|
if bg_path and os.path.exists(bg_path):
|
|
picture = Gtk.Picture.new_for_filename(bg_path)
|
|
picture.set_content_fit(Gtk.ContentFit.COVER)
|
|
else:
|
|
picture = Gtk.Box()
|
|
picture.add_css_class("card-fallback-bg")
|
|
|
|
overlay.set_child(picture)
|
|
|
|
# 2. Dark Gradient Tint Layer for legibility
|
|
tint_box = Gtk.Box()
|
|
tint_box.add_css_class("card-tint-overlay")
|
|
overlay.add_overlay(tint_box)
|
|
|
|
# 3. Text Content Layer (anchored to the bottom)
|
|
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
|
|
box.add_css_class("card-content-box")
|
|
box.set_valign(Gtk.Align.END)
|
|
|
|
title = Gtk.Label(label=title_text)
|
|
title.set_xalign(0.0)
|
|
title.add_css_class("card-title-shadowed")
|
|
|
|
desc = Gtk.Label(label=desc_text)
|
|
desc.set_xalign(0.0)
|
|
desc.set_wrap(True)
|
|
desc.add_css_class("card-desc-shadowed")
|
|
|
|
box.append(title)
|
|
box.append(desc)
|
|
|
|
overlay.add_overlay(box)
|
|
button.set_child(overlay)
|
|
|
|
container.append(button)
|
|
|
|
def setup_exit_shortcut(self, quit_callback):
|
|
controller = Gtk.EventControllerKey.new()
|
|
|
|
def on_key_pressed(_, keyval, __, ___):
|
|
if keyval == Gdk.KEY_Escape:
|
|
quit_callback()
|
|
return True
|
|
return False
|
|
|
|
controller.connect("key-pressed", on_key_pressed)
|
|
self.window.add_controller(controller)
|
|
|
|
def present(self, app):
|
|
self.window.set_application(app)
|
|
self.window.present()
|
|
|
|
def _show_usb_selection(self):
|
|
usb_devices = USBDevices()
|
|
devices = usb_devices.enumerate()
|
|
|
|
dialog = USBSelectionDialog(
|
|
self.window,
|
|
devices,
|
|
self.usb_devices,
|
|
)
|
|
|
|
def on_response(dialog, response):
|
|
if response == Gtk.ResponseType.OK:
|
|
self.usb_devices = dialog.get_selected_devices()
|
|
|
|
print("Selected USB devices:", self.usb_devices)
|
|
|
|
dialog.destroy()
|
|
|
|
dialog.connect("response", on_response)
|
|
dialog.present()
|
|
|
|
class USBSelectionDialog(Gtk.Dialog):
|
|
def __init__(self, parent, devices, selected_devices):
|
|
super().__init__(
|
|
transient_for=parent,
|
|
modal=True,
|
|
title="",
|
|
)
|
|
|
|
self.set_decorated(False)
|
|
self.add_css_class("usb-dialog")
|
|
|
|
self.devices = devices
|
|
self.selected_devices = selected_devices
|
|
|
|
self.set_default_size(450, 350)
|
|
|
|
self.content = self.get_content_area()
|
|
self.content.add_css_class("usb-dialog-content")
|
|
|
|
info_label = Gtk.Label(
|
|
label="Select the USB devices you wish to make available "
|
|
"to Windows RDP sessions."
|
|
)
|
|
info_label.set_wrap(True)
|
|
info_label.set_xalign(0.0)
|
|
info_label.add_css_class("usb-dialog-description")
|
|
self.content.append(info_label)
|
|
|
|
self.list_box = Gtk.ListBox()
|
|
self.list_box.set_vexpand(True)
|
|
self.list_box.set_selection_mode(Gtk.SelectionMode.NONE)
|
|
self.list_box.add_css_class("usb-device-list")
|
|
|
|
self.content.append(self.list_box)
|
|
|
|
self._populate_devices()
|
|
|
|
## Button Box
|
|
button_box = Gtk.Box(
|
|
orientation=Gtk.Orientation.HORIZONTAL,
|
|
spacing=12,
|
|
)
|
|
|
|
button_box.set_halign(Gtk.Align.CENTER)
|
|
button_box.add_css_class("usb-dialog-buttons")
|
|
|
|
cancel_button = Gtk.Button(label="Cancel")
|
|
cancel_button.add_css_class("usb-dialog-cancel")
|
|
cancel_button.connect(
|
|
"clicked",
|
|
lambda _: self.response(Gtk.ResponseType.CANCEL),
|
|
)
|
|
|
|
select_button = Gtk.Button(label="Select")
|
|
select_button.add_css_class("usb-dialog-select")
|
|
select_button.connect(
|
|
"clicked",
|
|
lambda _: self.response(Gtk.ResponseType.OK),
|
|
)
|
|
|
|
button_box.append(cancel_button)
|
|
button_box.append(select_button)
|
|
|
|
self.content.append(button_box)
|
|
##
|
|
|
|
def _populate_devices(self):
|
|
for device in self.devices:
|
|
check_button = Gtk.CheckButton(label=device.name)
|
|
check_button.add_css_class("usb-device-checkbox")
|
|
|
|
check_button.usb_device = device
|
|
|
|
if (device.vendor_id, device.product_id) in self.selected_devices:
|
|
check_button.set_active(True)
|
|
|
|
self.list_box.append(check_button)
|
|
|
|
row = check_button.get_parent()
|
|
row.add_css_class("usb-device-row")
|
|
|
|
def get_selected_devices(self):
|
|
selected_devices = []
|
|
|
|
row = self.list_box.get_first_child()
|
|
|
|
while row:
|
|
check_button = row.get_child()
|
|
|
|
if check_button.get_active():
|
|
device = check_button.usb_device
|
|
|
|
selected_devices.append(
|
|
(device.vendor_id, device.product_id)
|
|
)
|
|
|
|
row = row.get_next_sibling()
|
|
|
|
return selected_devices
|
|
|
|
# Allow direct execution for isolated UI testing
|
|
if __name__ == "__main__":
|
|
|
|
class TestApp(Gtk.Application):
|
|
|
|
def __init__(self):
|
|
super().__init__(application_id="com.local.UITest")
|
|
self.ui = None
|
|
|
|
def do_activate(self):
|
|
self.ui = UIController()
|
|
self.ui.set_app_title("UI Test Mode")
|
|
|
|
# Add mock test cards
|
|
self.ui.add_card(
|
|
"Test Card 1",
|
|
"Verifying layout rendering",
|
|
lambda: print("Clicked Test 1"),
|
|
)
|
|
self.ui.add_card(
|
|
"Test Card 2",
|
|
"Checking flowbox constraints",
|
|
lambda: print("Clicked Test 2"),
|
|
)
|
|
|
|
self.ui.setup_exit_shortcut(self.quit)
|
|
self.ui.present(self)
|
|
|
|
app = TestApp()
|
|
sys.exit(app.run(sys.argv)) |