108 lines
3.7 KiB
Python
Executable File
108 lines
3.7 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import dbus
|
|
import dbus.mainloop.glib
|
|
import os
|
|
from gi.repository import GLib
|
|
|
|
# Define the paths to the PNG icons
|
|
ICON_PATHS = {
|
|
"nvidia": "/home/teraflops/Icons/nvidia-icon.svg",
|
|
"integrated": "/home/teraflops/Icons/amd.png",
|
|
}
|
|
|
|
# Function to interpret the numerical status into a clearer message
|
|
def interpret_gpu_status(status):
|
|
if status == 0:
|
|
return "nvidia"
|
|
elif status == 1:
|
|
return "integrated"
|
|
else:
|
|
return None # Ignore "switching mode" and other unknown statuses
|
|
|
|
# Function to send the signal using `os.system()`
|
|
def send_signal_to_waybar():
|
|
try:
|
|
print("Enviando señal RTMIN+3 a Waybar usando os.system") # Mensaje de depuración
|
|
os.system("/usr/bin/pkill -RTMIN+3 waybar")
|
|
except Exception as e:
|
|
print(f"Error al enviar la señal con os.system: {e}")
|
|
|
|
# Función para escribir el script shell con la ruta de la imagen y el tooltip en /tmp/gpu.sh
|
|
def write_gpu_icon_script(status_message):
|
|
try:
|
|
icon_path = ICON_PATHS.get(status_message)
|
|
if icon_path:
|
|
# Define el texto del tooltip basado en el estado
|
|
tooltip_text = f"GPU: {status_message.capitalize()}"
|
|
|
|
print(f"Escribiendo en /tmp/gpu.sh:")
|
|
print(f"Ruta de la imagen: {icon_path}")
|
|
print(f"Texto del tooltip: {tooltip_text}")
|
|
|
|
# Escribe dos líneas: una para la ruta de la imagen y otra para el tooltip
|
|
with open("/tmp/gpu.sh", "w") as file:
|
|
file.write("#!/bin/sh\n")
|
|
file.write(f'echo "{icon_path}"\n')
|
|
file.write(f'echo "{tooltip_text}"\n')
|
|
|
|
# Hace que el script sea ejecutable
|
|
os.chmod("/tmp/gpu.sh", 0o755)
|
|
print("Script /tmp/gpu.sh actualizado correctamente.")
|
|
else:
|
|
print(f"No se encontró un icono para el estado: {status_message}")
|
|
except Exception as e:
|
|
print(f"Error al escribir el script en /tmp/gpu.sh: {e}")
|
|
|
|
# Callback para `NotifyGfxStatus`
|
|
def on_notify_gfx_status(status):
|
|
print(f"Callback `on_notify_gfx_status` invocado con status: {status}") # Depuración
|
|
status_message = interpret_gpu_status(status)
|
|
|
|
# Si el estado no es "nvidia" o "integrated", ignorarlo
|
|
if status_message:
|
|
print(f"Estado de GPU cambiado: {status_message}")
|
|
|
|
# Guarda el script shell con la ruta de la imagen y el tooltip en /tmp/gpu.sh
|
|
write_gpu_icon_script(status_message)
|
|
|
|
# Envía la señal a Waybar usando os.system
|
|
send_signal_to_waybar()
|
|
else:
|
|
print("Estado intermedio detectado, no se tomará ninguna acción.")
|
|
|
|
# Callback para `NotifyGfx`
|
|
def on_notify_gfx(vendor):
|
|
print(f"Callback `on_notify_gfx` invocado con vendor: {vendor}")
|
|
|
|
# Callback para `NotifyAction`
|
|
def on_notify_action(action):
|
|
print(f"Callback `on_notify_action` invocado con action: {action}")
|
|
|
|
# Inicializa el loop de D-Bus
|
|
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
|
|
|
|
# Conecta al bus del sistema y obtiene el objeto
|
|
bus = dbus.SystemBus()
|
|
proxy = bus.get_object("org.supergfxctl.Daemon", "/org/supergfxctl/Gfx")
|
|
|
|
# Suscribirse a las señales `NotifyGfxStatus`, `NotifyGfx` y `NotifyAction`
|
|
bus.add_signal_receiver(on_notify_gfx_status,
|
|
dbus_interface="org.supergfxctl.Daemon",
|
|
signal_name="NotifyGfxStatus")
|
|
|
|
bus.add_signal_receiver(on_notify_gfx,
|
|
dbus_interface="org.supergfxctl.Daemon",
|
|
signal_name="NotifyGfx")
|
|
|
|
bus.add_signal_receiver(on_notify_action,
|
|
dbus_interface="org.supergfxctl.Daemon",
|
|
signal_name="NotifyAction")
|
|
|
|
print("Monitoreando señales de GPU...")
|
|
|
|
# Inicia el loop principal
|
|
loop = GLib.MainLoop()
|
|
loop.run()
|
|
|