246 lines
7.2 KiB
Python
246 lines
7.2 KiB
Python
from datetime import datetime
|
|
import sys
|
|
import gi
|
|
import os
|
|
|
|
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_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
|
|
|
|
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),
|
|
)
|
|
|
|
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_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("power", "reboot")
|
|
)
|
|
|
|
if btn_shutdown:
|
|
btn_shutdown.connect(
|
|
"clicked", lambda _: self.power_action_callback("power", "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()
|
|
|
|
# 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)) |