| |
| """Interactive Sonnenuhr control tab for ClaudeCodePanel.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| import socket |
| import threading |
| import time |
| from datetime import datetime |
| from pathlib import Path |
|
|
| import gi |
|
|
| gi.require_version("Gtk", "3.0") |
| from gi.repository import GLib, Gtk, Pango |
|
|
| from theme import get_palette |
|
|
| STATE_PATH = Path("/tmp/sonnenuhr-state.json") |
| SOCKET_PATH = Path("/tmp/sonnenuhr.sock") |
| SOCKET_TIMEOUT_SECONDS = 2.0 |
| SLIDER_DEBOUNCE_MS = 300 |
| OFFSET_MIN = -50 |
| OFFSET_MAX = 50 |
|
|
| |
| |
| |
| _header_label: Gtk.Label | None = None |
| _mode_badge: Gtk.Label | None = None |
| _refresh_button: Gtk.Button | None = None |
| _timeline_bar: Gtk.ProgressBar | None = None |
| _timeline_label: Gtk.Label | None = None |
| _brightness_value: Gtk.Label | None = None |
| _brightness_scale: Gtk.Scale | None = None |
| _temp_value: Gtk.Label | None = None |
| _temp_scale: Gtk.Scale | None = None |
| _temp_rgb: Gtk.Label | None = None |
| _displays_box: Gtk.Box | None = None |
| _footer_update: Gtk.Label | None = None |
| _footer_theme: Gtk.Label | None = None |
| _footer_status: Gtk.Label | None = None |
|
|
| _mode_buttons: dict[str, Gtk.RadioButton] = {} |
| _theme_buttons: dict[str, Gtk.RadioButton] = {} |
| _debounce_sources: dict[str, int] = {} |
| _last_state: dict | None = None |
| _ui_syncing = False |
| _last_user_interaction: float = 0.0 |
| INTERACTION_COOLDOWN = 3.0 |
|
|
|
|
| |
| |
| |
|
|
| def _load_state() -> dict | None: |
| if not STATE_PATH.exists(): |
| return None |
| try: |
| with STATE_PATH.open(encoding="utf-8") as fh: |
| data = json.load(fh) |
| return data if isinstance(data, dict) else None |
| except (OSError, json.JSONDecodeError): |
| return None |
|
|
|
|
| def _extract_state(payload: dict | None) -> dict | None: |
| if not isinstance(payload, dict): |
| return None |
| state = payload.get("state", payload) |
| return state if isinstance(state, dict) else None |
|
|
|
|
| def _send_socket_command(command: dict) -> dict: |
| try: |
| sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) |
| sock.settimeout(SOCKET_TIMEOUT_SECONDS) |
| try: |
| sock.connect(str(SOCKET_PATH)) |
| sock.sendall(json.dumps(command).encode() + b"\n") |
| sock.shutdown(socket.SHUT_WR) |
| response = b"" |
| while True: |
| chunk = sock.recv(4096) |
| if not chunk: |
| break |
| response += chunk |
| finally: |
| sock.close() |
| except OSError as exc: |
| return {"ok": False, "error": f"daemon not reachable: {exc}"} |
|
|
| if not response: |
| return {"ok": False, "error": "daemon returned empty response"} |
|
|
| try: |
| return json.loads(response.decode()) |
| except json.JSONDecodeError as exc: |
| return {"ok": False, "error": f"invalid daemon response: {exc}"} |
|
|
|
|
| def _schedule_command(key: str, callback, delay_ms: int = SLIDER_DEBOUNCE_MS) -> None: |
| source_id = _debounce_sources.pop(key, None) |
| if source_id: |
| GLib.source_remove(source_id) |
|
|
| def _fire() -> bool: |
| _debounce_sources.pop(key, None) |
| callback() |
| return False |
|
|
| _debounce_sources[key] = GLib.timeout_add(delay_ms, _fire) |
|
|
|
|
| def _run_command_async(commands: list[dict] | dict, pending_text: str) -> None: |
| _set_status_text(pending_text, "busy") |
| command_list = commands if isinstance(commands, list) else [commands] |
|
|
| def worker() -> None: |
| last_result = {"ok": True} |
| for command in command_list: |
| last_result = _send_socket_command(command) |
| if not last_result.get("ok", True): |
| GLib.idle_add(_handle_command_result, None, last_result) |
| return |
|
|
| GLib.idle_add(_handle_command_result, _load_state(), last_result) |
|
|
| threading.Thread( |
| target=worker, |
| daemon=True, |
| name="claude-panel-sonnenuhr-command", |
| ).start() |
|
|
|
|
| def _refresh_from_daemon_async(_button=None) -> None: |
| _set_status_text("Status wird geladen…", "busy") |
|
|
| def worker() -> None: |
| result = _send_socket_command({"cmd": "status"}) |
| if result.get("ok", True) and "message" not in result: |
| result = dict(result) |
| result["message"] = "Status aktualisiert" |
| state = _extract_state(result) if result.get("ok", True) else None |
| if state is None: |
| state = _load_state() |
| GLib.idle_add(_handle_command_result, state, result) |
|
|
| threading.Thread( |
| target=worker, |
| daemon=True, |
| name="claude-panel-sonnenuhr-refresh", |
| ).start() |
|
|
|
|
| def _handle_command_result(state: dict | None, result: dict) -> bool: |
| global _last_user_interaction |
| if result and not result.get("ok", True): |
| _set_status_text(result.get("error", "Unbekannter Fehler"), "error") |
| return False |
|
|
| |
| _last_user_interaction = 0.0 |
| if state is not None: |
| _apply_state_to_ui(state, force=True) |
| else: |
| _apply_state_to_ui(_load_state(), force=True) |
|
|
| message = result.get("message") or "Einstellung übernommen" |
| _set_status_text(message, "ok") |
| return False |
|
|
|
|
| def _set_status_text(text: str, tone: str = "dim") -> None: |
| if _footer_status is None: |
| return |
| palette = get_palette() |
| color = { |
| "ok": palette["green"], |
| "error": palette["red"], |
| "busy": palette["yellow"], |
| "dim": palette["dim"], |
| }.get(tone, palette["dim"]) |
| escaped = GLib.markup_escape_text(text) |
| _footer_status.set_markup( |
| f'<span foreground="{color}" size="small">{escaped}</span>' |
| ) |
|
|
|
|
| def _fmt(iso: str | None, fmt: str = "%H:%M") -> str: |
| if not iso: |
| return "—" |
| try: |
| return datetime.fromisoformat(iso).strftime(fmt) |
| except (TypeError, ValueError): |
| return "—" |
|
|
|
|
| def _day_progress(state: dict) -> float: |
| try: |
| sun = state["sun_times"] |
| sunrise = datetime.fromisoformat(sun["sunrise"]) |
| sunset = datetime.fromisoformat(sun["sunset"]) |
| now = datetime.now(tz=sunrise.tzinfo) |
| if now <= sunrise: |
| return 0.0 |
| if now >= sunset: |
| return 1.0 |
| return (now - sunrise).total_seconds() / (sunset - sunrise).total_seconds() |
| except Exception: |
| return 0.0 |
|
|
|
|
| def _section(title: str) -> Gtk.Box: |
| box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8) |
| box.get_style_context().add_class("section-frame") |
| box.set_margin_bottom(10) |
| label = Gtk.Label(label=title) |
| label.get_style_context().add_class("section-title") |
| label.set_halign(Gtk.Align.START) |
| box.pack_start(label, False, False, 0) |
| return box |
|
|
|
|
| def _lbl(markup: str, halign: Gtk.Align = Gtk.Align.START) -> Gtk.Label: |
| label = Gtk.Label() |
| label.set_markup(markup) |
| label.set_halign(halign) |
| label.set_xalign(0.0 if halign != Gtk.Align.END else 1.0) |
| return label |
|
|
|
|
| def _build_radio_row(options: list[tuple[str, str]], callback) -> tuple[Gtk.Box, dict[str, Gtk.RadioButton]]: |
| row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6) |
| buttons: dict[str, Gtk.RadioButton] = {} |
| group: Gtk.RadioButton | None = None |
|
|
| for key, label in options: |
| button = Gtk.RadioButton.new_with_label_from_widget(group, label) |
| button.set_can_focus(False) |
| button.connect("toggled", callback, key) |
| row.pack_start(button, False, False, 0) |
| buttons[key] = button |
| if group is None: |
| group = button |
|
|
| return row, buttons |
|
|
|
|
| def _set_fixed_controls_sensitive(enabled: bool) -> None: |
| if _refresh_button is not None: |
| _refresh_button.set_sensitive(True) |
| for button in _mode_buttons.values(): |
| button.set_sensitive(enabled) |
| for button in _theme_buttons.values(): |
| button.set_sensitive(enabled) |
| if _brightness_scale is not None: |
| _brightness_scale.set_sensitive(enabled) |
| if _temp_scale is not None: |
| _temp_scale.set_sensitive(enabled) |
|
|
|
|
| def _set_brightness_value_markup(value: int) -> None: |
| if _brightness_value is None: |
| return |
| palette = get_palette() |
| _brightness_value.set_markup( |
| f'<span foreground="{palette["peach"]}" font_size="22000" font_weight="bold">' |
| f"{value}%</span>" |
| ) |
|
|
|
|
| def _set_temp_value_markup(value: int) -> None: |
| if _temp_value is None: |
| return |
| palette = get_palette() |
| _temp_value.set_markup( |
| f'<span foreground="{palette["yellow"]}" font_size="22000" font_weight="bold">' |
| f"{value} K</span>" |
| ) |
|
|
|
|
| def _on_mode_toggled(button: Gtk.RadioButton, mode: str) -> None: |
| global _last_user_interaction |
| if _ui_syncing or not button.get_active(): |
| return |
| _last_user_interaction = time.monotonic() |
|
|
| if mode == "auto": |
| command = {"cmd": "auto"} |
| elif mode == "disabled": |
| command = {"cmd": "disable"} |
| else: |
| minutes = int((_last_state or {}).get("override_duration_minutes", 120)) |
| command = {"cmd": "override", "minutes": minutes} |
|
|
| _run_command_async(command, "Modus wird gesetzt…") |
|
|
|
|
| def _on_theme_toggled(button: Gtk.RadioButton, mode: str) -> None: |
| global _last_user_interaction |
| if _ui_syncing or not button.get_active(): |
| return |
| _last_user_interaction = time.monotonic() |
| _run_command_async({"cmd": "theme", "mode": mode}, "Theme wird gesetzt…") |
|
|
|
|
| def _on_global_brightness_changed(scale: Gtk.Scale) -> None: |
| global _last_user_interaction |
| if _ui_syncing: |
| return |
| _last_user_interaction = time.monotonic() |
|
|
| value = int(round(scale.get_value())) |
| _set_brightness_value_markup(value) |
| _schedule_command( |
| "global_brightness", |
| lambda: _run_command_async( |
| {"cmd": "set", "brightness": value}, |
| "Globale Helligkeit wird gesetzt…", |
| ), |
| ) |
|
|
|
|
| def _on_global_temp_changed(scale: Gtk.Scale) -> None: |
| global _last_user_interaction |
| if _ui_syncing: |
| return |
| _last_user_interaction = time.monotonic() |
|
|
| value = int(round(scale.get_value() / 50.0) * 50) |
| _set_temp_value_markup(value) |
| _schedule_command( |
| "global_temp", |
| lambda: _run_command_async( |
| {"cmd": "color", "kelvin": value}, |
| "Globale Farbtemperatur wird gesetzt…", |
| ), |
| ) |
|
|
|
|
| def _on_display_brightness_changed( |
| scale: Gtk.Scale, |
| display_name: str, |
| value_label: Gtk.Label, |
| ) -> None: |
| global _last_user_interaction |
| _last_user_interaction = time.monotonic() |
| value = int(round(scale.get_value())) |
| palette = get_palette() |
| value_label.set_markup( |
| f'<tt><span foreground="{palette["peach"]}" size="small">{value}%</span></tt>' |
| ) |
| _schedule_command( |
| f"display-brightness:{display_name}", |
| lambda: _run_command_async( |
| {"cmd": "set_display", "display": display_name, "brightness": value}, |
| f"{display_name} wird angepasst…", |
| ), |
| ) |
|
|
|
|
| def _on_display_offset_changed( |
| scale: Gtk.Scale, |
| display_name: str, |
| value_label: Gtk.Label, |
| ) -> None: |
| global _last_user_interaction |
| _last_user_interaction = time.monotonic() |
| value = int(round(scale.get_value())) |
| palette = get_palette() |
| value_label.set_markup( |
| f'<tt><span foreground="{palette["overlay"]}" size="small">{value:+d}</span></tt>' |
| ) |
| _schedule_command( |
| f"display-offset:{display_name}", |
| lambda: _run_command_async( |
| {"cmd": "set_display_offset", "display": display_name, "offset": value}, |
| f"{display_name} Korrektur wird gespeichert…", |
| ), |
| delay_ms=500, |
| ) |
|
|
|
|
| def _on_display_enabled_changed( |
| switch: Gtk.Switch, |
| _pspec, |
| display_name: str, |
| ) -> None: |
| global _last_user_interaction |
| _last_user_interaction = time.monotonic() |
| _run_command_async( |
| { |
| "cmd": "set_display_enabled", |
| "display": display_name, |
| "enabled": switch.get_active(), |
| }, |
| f"{display_name} wird aktualisiert…", |
| ) |
|
|
|
|
| def _build_display_row(display: dict, palette: dict, base_brightness: int) -> Gtk.Box: |
| card = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6) |
| card.get_style_context().add_class("section-frame") |
| card.set_margin_bottom(8) |
| card.set_margin_top(2) |
| card.set_margin_start(4) |
| card.set_margin_end(4) |
|
|
| display_name = display.get("name", "unknown") |
| connected = bool(display.get("connected", False)) |
| enabled = bool(display.get("enabled", True)) |
| brightness = display.get("brightness") |
| brightness = int(brightness) if isinstance(brightness, int) else base_brightness |
| offset = int(display.get("brightness_offset", 0)) |
| rgb = display.get("rgb") |
|
|
| top = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8) |
| dot_color = palette["green"] if (connected and enabled) else ( |
| palette["yellow"] if connected else palette["red"] |
| ) |
| dot = "✓" if (connected and enabled) else ("○" if connected else "✗") |
| top.pack_start( |
| _lbl(f'<span foreground="{dot_color}">{dot}</span>'), |
| False, |
| False, |
| 0, |
| ) |
|
|
| name = _lbl( |
| f'<tt><span foreground="{palette["subtext1"]}" size="small">' |
| f"{GLib.markup_escape_text(display_name)}</span></tt>" |
| ) |
| name.set_ellipsize(Pango.EllipsizeMode.MIDDLE) |
| name.set_max_width_chars(38) |
| top.pack_start(name, True, True, 0) |
|
|
| connected_text = "verbunden" if connected else "getrennt" |
| top.pack_end( |
| _lbl( |
| f'<span foreground="{dot_color}" size="small">{connected_text}</span>', |
| Gtk.Align.END, |
| ), |
| False, |
| False, |
| 0, |
| ) |
| card.pack_start(top, False, False, 0) |
|
|
| brightness_header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8) |
| brightness_header.pack_start( |
| _lbl(f'<span foreground="{palette["overlay"]}" size="small">Monitor-Helligkeit</span>'), |
| False, |
| False, |
| 0, |
| ) |
| brightness_value = _lbl( |
| f'<tt><span foreground="{palette["peach"]}" size="small">{brightness}%</span></tt>', |
| Gtk.Align.END, |
| ) |
| brightness_header.pack_end(brightness_value, False, False, 0) |
| card.pack_start(brightness_header, False, False, 0) |
|
|
| brightness_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 0, 100, 1) |
| brightness_scale.set_draw_value(False) |
| brightness_scale.set_value(float(brightness)) |
| brightness_scale.connect( |
| "value-changed", |
| _on_display_brightness_changed, |
| display_name, |
| brightness_value, |
| ) |
| card.pack_start(brightness_scale, False, False, 0) |
|
|
| offset_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12) |
| offset_row.pack_start( |
| _lbl(f'<span foreground="{palette["overlay"]}" size="small">Offset</span>'), |
| False, |
| False, |
| 0, |
| ) |
| offset_value = _lbl( |
| f'<tt><span foreground="{palette["overlay"]}" size="small">{offset:+d}</span></tt>' |
| ) |
| offset_row.pack_end(offset_value, False, False, 0) |
| card.pack_start(offset_row, False, False, 0) |
|
|
| offset_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, OFFSET_MIN, OFFSET_MAX, 1) |
| offset_scale.set_draw_value(False) |
| offset_scale.set_value(float(offset)) |
| offset_scale.connect( |
| "value-changed", |
| _on_display_offset_changed, |
| display_name, |
| offset_value, |
| ) |
| card.pack_start(offset_scale, False, False, 0) |
|
|
| footer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8) |
| enabled_label = _lbl( |
| f'<span foreground="{palette["overlay"]}" size="small">aktiv</span>' |
| ) |
| enabled_switch = Gtk.Switch() |
| enabled_switch.set_active(enabled) |
| enabled_switch.connect("notify::active", _on_display_enabled_changed, display_name) |
| footer.pack_start(enabled_label, False, False, 0) |
| footer.pack_start(enabled_switch, False, False, 0) |
|
|
| if rgb is not None and len(rgb) == 3: |
| footer.pack_end( |
| _lbl( |
| f'<tt><span foreground="{palette["dim"]}" size="small">' |
| f"RGB {rgb[0]}/{rgb[1]}/{rgb[2]}</span></tt>", |
| Gtk.Align.END, |
| ), |
| False, |
| False, |
| 0, |
| ) |
|
|
| card.pack_start(footer, False, False, 0) |
| return card |
|
|
|
|
| def _apply_state_to_ui(state: dict | None, force: bool = False) -> None: |
| global _last_state, _ui_syncing |
|
|
| palette = get_palette() |
| offline = state is None |
| |
| |
| skip_controls = not force and (time.monotonic() - _last_user_interaction) < INTERACTION_COOLDOWN |
| if not offline: |
| _last_state = state |
|
|
| if _header_label is not None: |
| _header_label.set_markup("<b>☀ Sonnenuhr</b>") |
|
|
| if offline: |
| if _mode_badge is not None: |
| _mode_badge.set_markup( |
| f'<span foreground="{palette["red"]}" size="small">● offline</span>' |
| ) |
| if _timeline_label is not None: |
| _timeline_label.set_markup( |
| f'<span foreground="{palette["red"]}" size="small">Daemon nicht aktiv</span>' |
| ) |
| if _timeline_bar is not None: |
| _timeline_bar.set_fraction(0.0) |
| _timeline_bar.set_text("—") |
| _set_brightness_value_markup(0) |
| _set_temp_value_markup(0) |
| if _temp_rgb is not None: |
| _temp_rgb.set_markup(f'<span foreground="{palette["dim"]}" size="small">—</span>') |
| if _footer_update is not None: |
| _footer_update.set_markup( |
| f'<span foreground="{palette["dim"]}" size="small">Letzte Aktualisierung: —</span>' |
| ) |
| if _footer_theme is not None: |
| _footer_theme.set_markup( |
| f'<span foreground="{palette["dim"]}" size="small">Theme: —</span>' |
| ) |
| if _displays_box is not None: |
| for child in _displays_box.get_children(): |
| _displays_box.remove(child) |
| _displays_box.pack_start( |
| _lbl(f'<span foreground="{palette["dim"]}">Keine Displays</span>'), |
| False, |
| False, |
| 0, |
| ) |
| _displays_box.show_all() |
| _set_fixed_controls_sensitive(False) |
| return |
|
|
| mode = state.get("mode", "unknown") |
| brightness = int(state.get("brightness", 0)) |
| color_temp = int(state.get("color_temp", 6500)) |
| sun = state.get("sun_times", {}) |
| is_daytime = bool(state.get("is_daytime", False)) |
| displays = state.get("displays", []) |
| theme_name = state.get("theme", "—") |
| theme_locked = bool(state.get("theme_locked", False)) |
| theme_auto_switch = bool(state.get("theme_auto_switch", True)) |
| override_minutes = int(state.get("override_duration_minutes", 120)) |
|
|
| if _mode_badge is not None: |
| badge_color = { |
| "auto": palette["green"], |
| "override": palette["yellow"], |
| "disabled": palette["red"], |
| }.get(mode, palette["red"]) |
| _mode_badge.set_markup( |
| f'<span foreground="{badge_color}" size="small">● {mode}</span>' |
| ) |
|
|
| if _timeline_label is not None: |
| day_text = "☀ Tag" if is_daytime else "☾ Nacht" |
| _timeline_label.set_markup( |
| f'<span foreground="{palette["overlay"]}" size="small">' |
| f"↑ {_fmt(sun.get('sunrise'))} {day_text} ↓ {_fmt(sun.get('sunset'))}</span>" |
| ) |
| if _timeline_bar is not None: |
| _timeline_bar.set_fraction(_day_progress(state)) |
| _timeline_bar.set_text(f"{_fmt(sun.get('sunrise'))} → {_fmt(sun.get('sunset'))}") |
|
|
| _set_brightness_value_markup(brightness) |
| _set_temp_value_markup(color_temp) |
|
|
| rgb = next((d.get("rgb") for d in displays if d.get("rgb") is not None), None) |
| if _temp_rgb is not None: |
| rgb_text = f"RGB: {rgb[0]} / {rgb[1]} / {rgb[2]}" if rgb else "—" |
| _temp_rgb.set_markup( |
| f'<span foreground="{palette["overlay"]}" size="small">{rgb_text}</span>' |
| ) |
|
|
| _ui_syncing = True |
| try: |
| _set_fixed_controls_sensitive(True) |
| if not skip_controls: |
| if _brightness_scale is not None: |
| _brightness_scale.set_value(float(brightness)) |
| if _temp_scale is not None: |
| _temp_scale.set_value(float(color_temp)) |
|
|
| for key, button in _mode_buttons.items(): |
| button.set_active(key == mode) |
|
|
| selected_theme = "auto" if not theme_locked else theme_name |
| for key, button in _theme_buttons.items(): |
| button.set_active(key == selected_theme) |
| finally: |
| _ui_syncing = False |
|
|
| if _displays_box is not None and not skip_controls: |
| for child in _displays_box.get_children(): |
| _displays_box.remove(child) |
| if displays: |
| for display in displays: |
| _displays_box.pack_start( |
| _build_display_row(display, palette, brightness), |
| False, |
| False, |
| 0, |
| ) |
| else: |
| _displays_box.pack_start( |
| _lbl(f'<span foreground="{palette["dim"]}">Keine Displays gefunden</span>'), |
| False, |
| False, |
| 0, |
| ) |
| _displays_box.show_all() |
|
|
| if _footer_update is not None: |
| _footer_update.set_markup( |
| f'<span foreground="{palette["dim"]}" size="small">' |
| f"Letzte Aktualisierung: {_fmt(state.get('last_update'), '%H:%M:%S')}</span>" |
| ) |
| if _footer_theme is not None: |
| theme_mode = "gesperrt" if theme_locked else "auto" |
| suffix = "" if theme_locked or theme_auto_switch else ", Wechsel aus" |
| _footer_theme.set_markup( |
| f'<span foreground="{palette["dim"]}" size="small">' |
| f"Theme: {theme_name} ({theme_mode}{suffix}) · Override: {override_minutes} min</span>" |
| ) |
|
|
|
|
| |
| |
| |
|
|
| def _do_refresh() -> bool: |
| _apply_state_to_ui(_load_state()) |
| return False |
|
|
|
|
| def refresh_brightness(_tab=None) -> bool: |
| GLib.idle_add(_do_refresh) |
| return True |
|
|
|
|
| def build_brightness_tab() -> Gtk.ScrolledWindow: |
| global _header_label, _mode_badge, _refresh_button, _timeline_bar, _timeline_label |
| global _brightness_value, _brightness_scale, _temp_value, _temp_scale, _temp_rgb |
| global _displays_box, _footer_update, _footer_theme, _footer_status |
| global _mode_buttons, _theme_buttons |
|
|
| scrolled = Gtk.ScrolledWindow() |
| scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) |
| scrolled.set_hexpand(True) |
| scrolled.set_vexpand(True) |
|
|
| root = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) |
| root.set_margin_top(10) |
| root.set_margin_bottom(10) |
| root.set_margin_start(10) |
| root.set_margin_end(10) |
| scrolled.add(root) |
|
|
| palette = get_palette() |
|
|
| header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8) |
| header.set_margin_bottom(8) |
| _header_label = _lbl("<b>☀ Sonnenuhr</b>") |
| attrs = Pango.AttrList() |
| attrs.insert(Pango.attr_scale_new(1.1)) |
| _header_label.set_attributes(attrs) |
| header.pack_start(_header_label, True, True, 0) |
|
|
| _mode_badge = _lbl( |
| f'<span foreground="{palette["dim"]}" size="small">● lade…</span>', |
| Gtk.Align.END, |
| ) |
| header.pack_end(_mode_badge, False, False, 0) |
|
|
| _refresh_button = Gtk.Button(label="Aktualisieren") |
| _refresh_button.set_can_focus(False) |
| _refresh_button.connect("clicked", _refresh_from_daemon_async) |
| header.pack_end(_refresh_button, False, False, 0) |
| root.pack_start(header, False, False, 0) |
|
|
| timeline = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4) |
| timeline.get_style_context().add_class("section-frame") |
| timeline.set_margin_bottom(10) |
| _timeline_label = _lbl( |
| f'<span foreground="{palette["overlay"]}" size="small">Lade…</span>', |
| Gtk.Align.CENTER, |
| ) |
| timeline.pack_start(_timeline_label, False, False, 0) |
| _timeline_bar = Gtk.ProgressBar() |
| _timeline_bar.set_show_text(True) |
| _timeline_bar.set_fraction(0.0) |
| _timeline_bar.set_text("—") |
| timeline.pack_start(_timeline_bar, False, False, 0) |
| root.pack_start(timeline, False, False, 0) |
|
|
| mode_section = _section("Modus") |
| mode_row, _mode_buttons = _build_radio_row( |
| [("auto", "Auto"), ("override", "Override"), ("disabled", "Disabled")], |
| _on_mode_toggled, |
| ) |
| mode_section.pack_start(mode_row, False, False, 0) |
| root.pack_start(mode_section, False, False, 0) |
|
|
| theme_section = _section("Theme") |
| theme_row, _theme_buttons = _build_radio_row( |
| [("dark", "Dark"), ("light", "Light"), ("auto", "Auto")], |
| _on_theme_toggled, |
| ) |
| theme_section.pack_start(theme_row, False, False, 0) |
| root.pack_start(theme_section, False, False, 0) |
|
|
| brightness_section = _section("Globale Helligkeit") |
| _brightness_value = _lbl( |
| f'<span foreground="{palette["peach"]}" font_size="22000" font_weight="bold">—</span>' |
| ) |
| brightness_section.pack_start(_brightness_value, False, False, 0) |
| _brightness_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 0, 100, 1) |
| _brightness_scale.set_draw_value(False) |
| _brightness_scale.set_value(0) |
| _brightness_scale.connect("value-changed", _on_global_brightness_changed) |
| brightness_section.pack_start(_brightness_scale, False, False, 0) |
| root.pack_start(brightness_section, False, False, 0) |
|
|
| temp_section = _section("Globale Farbtemperatur") |
| _temp_value = _lbl( |
| f'<span foreground="{palette["yellow"]}" font_size="22000" font_weight="bold">—</span>' |
| ) |
| temp_section.pack_start(_temp_value, False, False, 0) |
| _temp_scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 2700, 6500, 50) |
| _temp_scale.set_draw_value(False) |
| _temp_scale.set_value(6500) |
| _temp_scale.connect("value-changed", _on_global_temp_changed) |
| temp_section.pack_start(_temp_scale, False, False, 0) |
| _temp_rgb = _lbl(f'<span foreground="{palette["overlay"]}" size="small">—</span>') |
| temp_section.pack_start(_temp_rgb, False, False, 0) |
| root.pack_start(temp_section, False, False, 0) |
|
|
| displays_section = _section("Displays") |
| _displays_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2) |
| displays_section.pack_start(_displays_box, False, False, 0) |
| root.pack_start(displays_section, False, False, 0) |
|
|
| separator = Gtk.Separator() |
| separator.set_margin_top(4) |
| separator.set_margin_bottom(6) |
| root.pack_start(separator, False, False, 0) |
|
|
| _footer_update = _lbl( |
| f'<span foreground="{palette["dim"]}" size="small">Letzte Aktualisierung: —</span>' |
| ) |
| root.pack_start(_footer_update, False, False, 0) |
| _footer_theme = _lbl( |
| f'<span foreground="{palette["dim"]}" size="small">Theme: —</span>' |
| ) |
| root.pack_start(_footer_theme, False, False, 0) |
| _footer_status = _lbl( |
| f'<span foreground="{palette["dim"]}" size="small">Bereit</span>' |
| ) |
| root.pack_start(_footer_status, False, False, 0) |
|
|
| GLib.idle_add(_do_refresh) |
| scrolled.show_all() |
| return scrolled |
|
|
