tray_manager

¿Qué es Tray_Manager?

tray_manager es un paquete utilizado para crear un icono de bandeja del sistema, basado en Pystray (https://github.com/moses-palmer/pystray por Moses Palmér), este paquete es una versión "más fácil" de Pystray para manipular como se basa en el uso de objetos.

¿Cómo lo instalo?

tray_manager se publica en Pypi (https://pypi.org/project/tray-manager/) y se puede descargar utilizando el siguiente comando en su terminal:

pip install tray-manager

Nota

Necesita tener instalado Python en su computadora

Uso

1. Crear y usar un objeto TrayManager
2. Crear e interactuar con los elementos
3. Agregar elementos al menú
4. Personalizar el objeto TrayManager
5. Personalizar y editar los elementos
6. Verifique las funciones compatibles con el sistema operativo
7. Notificaciones [actualmente insegura]
8. Configuración avanzada

Crear y usar un objeto TrayManager

El objeto principal de la librairy es el objeto tray_manager.TrayManager , es el elemento central y puede considerarse como el icono en la bandeja del sistema en sí, contiene todos los elementos de nuestra aplicación.

Para crear uno, debe importar la clase tray_manager.TrayManager y crear un objeto de bandeja como se siguió:

 from tray_manager import TrayManager
my_tray = TrayManager ( app_name = "My App" )

Para detener la aplicación, debe usar la función .kill() como seguía:

Nota

La función .kill() devuelve todos los elementos que están contenidos en el menú como una lista de elementos

 from tray_manager import TrayManager , Label , Button

my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )
my_menu = my_tray . menu

def my_callback ():
  print ( "Hello" )

my_label = Label ( "My Label" )
my_button = Button ( "My Button" , my_callback )

my_menu . add ( my_label )
my_menu . add ( my_button )

my_tray . kill ()
- > [ my_label , my_button ]

Importante

El menú y los objetos de TrayManager que has matado se volverán inútiles

Advertencia

La creación de un objeto tray_manager.TrayManager se ejecutará su bucle interno tan pronto como se cree. Esto significa que crear un objeto tray_manager.TrayManager bloqueará el resto de su código. Para evitar que eso suceda, tiene 2 opciones:

1. Puede especificar una función como el argumento setup del objeto tray_manager.TrayManager , esta función se iniciará en un nuevo hilo al crear su objeto.

2. (Solo Windows) Si está en Windows y no se preocupa por la compatibilidad con otras plataformas, puede establecer el argumento run_in_separate_thread del objeto tray_manager.TrayManager a True , esto comenzará el bucle tray_manager en un nuevo hilo y el resto de su código se ejecutará correctamente en el bucle principal.

Crear e interactuar con los elementos

Los elementos son los elementos de su aplicación, se mostrarán en el menú al que se agregan. Son diferentes tipos de elementos que funcionan de manera similar, pero cada uno tiene algunas especificidades.

Aquí está la lista de todos los elementos:

1. Etiqueta
2. Botón
3. Caja
4. Separador
5. Submenú

Etiqueta

La etiqueta es el elemento más básico, solo se constituye de un texto.

Para crear uno, use la clase tray_manager.Label como se siguió:

 from tray_manager import Label
my_label = Label ( "My Label" )

Botón

El botón es como el elemento de la etiqueta, pero puede agregar un argumento de devolución de llamada (FunctionType) que se llamará cuando el usuario haga clic en el botón. También puede especificar algunos argumentos como una tupla que se pasará a su función cuando se haga clic en el botón.

Para crear uno, use la clase tray_manager.Button como siguió:

 from tray_manager import Button
def my_callback ( text : str ) -> None :
  print ( text )

my_button = Button ( "My Button" , my_callback , args = ( "Hello" ,))

Caja

El elemento de la casilla de verificación es un poco más complejo que un botón normal, tiene 2 devoluciones de llamada diferentes en lugar de 1 y diferentes argumentos para cada uno, uno para cuando la casilla de verificación cambia del estado 'desactivado' al estado 'habilitado' (no se verifica para verificar), y uno para cuando cambia de 'habilitado' a 'deshabilitado' (verificado no verificado).

Puede 'deshabilitar' las interacciones con su casilla de verificación configurando el valor de check_default a None .

Nota

La devolución de llamada no se ejecutará si el usuario hace clic en la casilla de verificación cuando está deshabilitado.

Para crear uno, use la clase tray_manager.CheckBox como siguió:

 from tray_manager import CheckBox

def checked ( text : str ) -> None :
  print ( f"In procedure 'checked' : { text } " )

def unchecked ( text : str ) -> None :
  print ( f"In procedure 'unchecked' : { text } " )

my_checkbox = CheckBox ( "My CheckBox" , check_default = False , checked_callback = checked , checked_callback_args = ( "I'm now checked" ,),
                        unchecked_callback = unchecked , unchecked_callback_args = ( "I'm now unchecked" ,))

Para obtener el estado actual de la casilla de verificación, puede usar la función .get_status() como seguía:

 from tray_manager import CheckBox

my_checkbox = CheckBox ( "My CheckBox" )

my_checkbox . get_status ()
- > bool | None

También puede establecer el estado de la casilla de verificación utilizando la función .set_status() como seguía:

 from tray_manager import CheckBox

my_checkbox = CheckBox ( "My CheckBox" )

my_checkbox . set_status ( True )
- > Checked
my_checkbox . set_status ( False )
- > Unchecked
my_checkbox . set_status ( None )
- > Disabled 

Nota

Caja	Estado
Comprobado	True
Desenfrenado	False
Desactivado	None

Cuando la casilla de verificación está deshabilitada, permanece en su estado anterior y deja de interactuar, esto significa que si la casilla de verificación se verificó antes de deshabilitarse, la casilla de verificación permanecerá marcada, pero no sucederá nada si el usuario hace clic en ella.

Separador

El separador es un objeto incorporado de Pystray, no tiene ningún parámetro.

Para crear uno, use la clase tray_manager.Separator como se siguió:

 from tray_manager import Separator
my_separator = Separator ()

Submenú

El submenú es como un objeto tray_manager.Menu y puede contener otros elementos, incluido otro submenú.

Precaución

Sea carro cuando se agregue submenú a los demás, ya que agregar un submenú a un submenú que esté contenido en el submenú que está agregando generará un error tray_manager.CircularAddException .

 TD de diagrama de flujo
   A {mi submenu} -> b (mi etiqueta)
   A -> c (mi botón)
   A -> d {mi segundo submenu}
   D -> E (mi segunda etiqueta)
   D -> F (mi casilla de verificación)
   D -> | TRAY_MANAGER.CircularAdDexception | A

Para crear uno, use el tray_manager.Submenu como siguió:

 from tray_manager import Submenu
my_submenu = Submenu ( "My Submenu" )

Para agregar un elemento al submenú, use la función .add() como seguía:

 from tray_manager import Submenu , Label
my_submenu = Submenu ( "My Submenu" )
my_label = Label ( "My Label" )

my_submenu . add ( my_label )

Para eliminar un elemento del submenú, use la función .remove() como seguía:

 from tray_manager import Submenu , Label
my_submenu = Submenu ( "My Submenu" )
my_label = Label ( "My Label" )

my_submenu . add ( my_label )

my_submenu . remove ( my_label )
- > my_label 

Nota

La función .remove() devuelve el elemento que se eliminó

Para obtener los elementos contenidos en un submenú, use la función .get_items() como seguía:

 from tray_manager import Submenu , Label , Button

def my_callback ()
  print ( "Hello" )

my_submenu = Submenu ( "My Submenu" )
my_label = Label ( "My Label" )
my_button = Button ( "My Button" , my_callback )

my_submenu . add ( my_label )
my_submenu . add ( my_button )

my_submenu . get_items ()
- > [ my_label , my_button ]

Agregue los elementos al menú

tray_manager.Menu es uno de los elementos centrales de esta biblioteca, funciona como un submenú y se crea automáticamente cuando crea un objeto tray_manager.TrayManager como el objeto tray_manager.TrayManager.menu y no se puede eliminar.

Advertencia

Compruebe tray_manager.OsSupport.HAS_MENU para la disponibilidad en su sistema operativo, si su sistema operativo no admite el menú, el objeto tray_manager.TrayManager.menu será ninguno.

Para usar el menú, accede al objeto tray_manager.TrayManager.menu como se siguió:

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )
my_menu = my_tray . menu

Para agregar un elemento al menú, use la función .add() como seguía:

 from tray_manager import TrayManager , Label
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )
my_menu = my_tray . menu

my_label = Label ( "My Label" )

my_menu . add ( my_label )

Para eliminar un elemento del menú, puede usar la función .remove() como seguía:

 from tray_manager import TrayManager , Label
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )
my_menu = my_tray . menu

my_label = Label ( "My Label" )
my_menu . add ( my_label )

my_menu . remove ( my_label )
- > my_label 

Nota

La función .remove() devuelve el elemento que se eliminó.

Para obtener los elementos contenidos en un menú, puede usar la función .get_items() como seguía:

 from tray_manager import TrayManager , Menu , Label , Button

def my_callback ()
  print ( "Hello" )

my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )
my_menu = my_tray . menu

my_label = Label ( "My Label" )
my_button = Button ( "My Button" , my_callback )

my_menu . add ( my_label )
my_menu . add ( my_button )

my_menu . get_items ()
- > [ my_label , my_button ]

Para actualizar los elementos del menú (los elementos contenidos dentro del menú), use la función .update() .

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )
my_menu = my_tray . menu

my_menu . update ()

Nota

La función .update() se activa automáticamente cada vez que edita, agrega o elimina un elemento del menú.

Personalizar el objeto TrayManager

Puede personalizar su objeto TrayManager de diferentes maneras, como:

1. Configurar un nuevo nombre para la aplicación
2. Configuración de un nuevo icono para la aplicación
3. Ocultar / mostrar la aplicación en la bandeja del sistema

Configurar un nuevo nombre para la aplicación

Para establecer un nuevo nombre para su aplicación, use la función .set_app_name() como seguía:

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )

my_tray . set_app_name ( "My new App" )

Configuración de un nuevo icono para la aplicación

tray_manager Use un sistema de memoria para iconos, para configurar un nuevo icono para su aplicación, primero debe cargarlo usando la función .load_icon() , luego configure el icono como el nuevo icono usando la función .set_icon() del objeto tray_manager.TrayManager .

Nota

Por defecto, el icono es un cuadrado blanco de 32x32 píxeles. El icono predeterminado siempre se carga en la memoria y se puede configurar nuevamente pasando el tray_manager.Values.DEFAULT como el argumento name de la función .set_icon() .

Para cargar un icono, use la función .load_icon() y pase una ruta de archivo, una imagen codificada, un objeto PIL.Image o cualquier archivo que pueda ser leído e interpretado como una imagen por PIL . También debe pasar un nombre que se utilizará como clave en los iconos DictionNary para retener su icono.

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )

my_tray . load_icon ( "my_icon_file_path.png" , "my_new_icon" )

Advertencia

tray_manager Use una DictionNary para guardar sus iconos cargados, esto significa que cargar una imagen usando un nombre que ya se usó sobrescribirá la imagen que previamente se cargó con ese nombre. La única excepción a esto es el icono predeterminado que no se puede editar.

Para establecer un icono, use la función .set_icon() y pase el nombre (clave) de su icono que establece cuando cargó el icono.

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )

my_tray . load_icon ( "my_icon_file_path.png" , "my_new_icon" )
my_tray . set_icon ( "my_new_icon" )

Ocultar / mostrar la aplicación en la bandeja del sistema

En lugar de matar el objeto tray_manager.TrayManager cuando desea que deje de mostrarse en la bandeja del sistema y crear uno nuevo una vez que lo necesite nuevamente, puede usar las funciones .show() y .hide() del objeto tray_manager.TrayManager para controlar si la aplicación es visible en la bola del sistema o no.

Nota

Puede establecer el argumento default_show del objeto tray_manager.TrayManager en True o False al crear su objeto tray_manager.TrayManager para definir si el icono de la bandeja del sistema se mostrará o no una vez que se cree el objeto.

Para mostrar la aplicación en la bandeja del sistema, use la función .show() del objeto tray_manager.TrayManager como se siguió:

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )

my_tray . show ()

Para ocultar la aplicación en la bandeja del sistema, use la función .hide() del objeto tray_manager.TrayManager como se siguió:

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_seperate_thread = True )

my_tray . hide ()

Personalizar y editar los elementos

Para editar un elemento ya creado, use la función .edit() del elemento, al hacerlo, solo necesita especificar qué argumentos desea cambiar, y los otros se mantendrán igual que ellos.

Para editar un elemento, haz lo que siguió:

 from tray_manager import Button

def my_first_callback ():
  print ( "Hello" )
  my_button . edit ( callback = my_second_callback )

def my_second_callback ():
  print ( "World !" )

my_button = Button ( "My Button" , my_first_callback )

# When clicking on the button, this will display :
# First click
- > Hello
# Second click
- > World !

Puede personalizar los elementos de diferentes maneras, como:

1. Habilitar / deshabilitar el elemento (aspecto gris y no responder)
2. Configuración del atributo predeterminado al elemento (Bold Look)
3. Configurar la apariencia de radio en la casilla de verificación (un punto en lugar de una marca cruzada)

Habilitar / deshabilitar el elemento (aspecto gris y no responder)

Si desea mostrar el elemento pero desea que no responda (para el botón, la casilla de verificación y el submenú) y parezca un elemento deshabilitado, puede usar las funciones .enable() y .disable() del elemento.

Nota

Por defecto, todos los elementos están habilitados

Cada elemento se puede deshabilitar excepto el separador.

Para habilitar su elemento, use la función .enable() del elemento como se siguió:

 from tray_manager import CheckBox

def checked_callback ():
  print ( "Checked" )

def unchecked_callback ():
  print ( "Unchecked" )

my_checkbox = CheckBox ( "My CheckBox" , checked_callback = checked_callback , unchecked_callback = unchecked_callback )

my_checkbox . enable ()

Para deshabilitar su elemento, use la función .disable() del elemento como se siguió:

 from tray_manager import CheckBox

def checked_callback ():
  print ( "Checked" )

def unchecked_callback ():
  print ( "Unchecked" )

my_checkbox = CheckBox ( "My CheckBox" , checked_callback = checked_callback , unchecked_callback = unchecked_callback )

my_checkbox . disable ()

Configuración del atributo predeterminado al elemento (Bold Look)

Para hacer de su elemento el elemento predeterminado del menú / submenú y darle un aspecto audaz, puede establecer el atributo default al crear / editar el elemento a True .

Nota

Solo puede tener 1 elemento predeterminado por menú / submenú. Por defecto, no hay un elemento predeterminado.

Para establecer el atributo default del elemento, haz lo que siguió:

Al crear el elemento:

 from tray_manager import Label
my_label = Label ( "My Label" , default = True )

Al editar el artículo:

 from tray_manager import Label
my_label = Label ( "My Label" )
my_label . edit ( default = True )

Configurar la apariencia de radio en la casilla de verificación (un punto en lugar de una marca cruzada)

Si desea dar un nuevo aspecto a su casilla de verificación regular Crossmark, puede establecer el atributo use_radio_look de la casilla de verificación en True al crear / editar la casilla de verificación.

Para establecer el atributo use_radio_look del elemento, haga lo siguiente:

Al crear el elemento:

 from tray_manager import CheckBox

def checked_callback ():
  print ( "Checked" )

def unchecked_callback ():
  print ( "Unchecked" )

my_checkbox = CheckBox ( "My CheckBox" , checked_callback = checked_callback , unchecked_callback = unchecked_callback , use_radio_look = True )

Al editar el artículo:

 from tray_manager import CheckBox

def checked_callback ():
  print ( "Checked" )

def unchecked_callback ():
  print ( "Unchecked" )

my_checkbox = CheckBox ( "My CheckBox" , checked_callback = checked_callback , unchecked_callback = unchecked_callback )
my_checkbox . edit ( use_radio_look = True )

Verifique las funciones compatibles con el sistema operativo

Antes de usar las características del tray_manager package , debe verificar si son compatibles con su sistema operativo. Para hacerlo, use el objeto tray_manager.Os_Support . Hay 4 características diferentes que debe verificar antes de usar:

1. Os_support.support_menu
2. Os_support.support_default
3. Os_support.support_radio
4. OS_Support.Support_Notification [Actualmente no)

Para saber si su sistema operativo admite una característica, la variable Os_Support correspondiente debe ser verdadera.

Ejemplo, para verificar si su sistema operativo admite el menú, haga lo seguido:

 from tray_manager import Os_Support
if Os_Support . SUPPORT_MENU :
  print ( "The menu is supported by your OS" )
else :
  print ( "The menu isn't supported by your OS" )

Nota

Aquí hay una tabla de las características que se suponen y que no se supone que deben ser compatibles con cada sistema operativo y backends.

Característica os y backend	Windows (Win32)	Linux (GTK)	Linux (AppIndicator)	Linux (Ayatana-Appindicator)	Linux (Xorg)	MacOS (Darwin)
Menú	Compatible	Compatible	Compatible	Compatible	No compatible	Compatible
Por defecto	Compatible	Compatible	No compatible	No compatible	Compatible	No compatible
Radio	Compatible	Compatible	Compatible	Compatible	Compatible	No compatible
Notificación	Actualmente no	Desconocido	Eres conocido	Desconocido	No compatible	No compatible

Notificaciones [actualmente insegura]

Si desea crear una notificación en la pantalla del usuario, puede usar el objeto tray_manager.TrayManager.notification .

Para crear una notificación, use la función .notify() del objeto de tray_manager.TrayManager.notification .

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_separate_thread = True )
notification = my_tray . notification

notification . notify ( "My App" , "Hello World !" )

Puede especificar un retraso después de lo cual la notificación se eliminará pasando un valor en segundos a la función .notify() como el remove_after_s como se siguió:

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_separate_thread = True )
notification = my_tray . notification

notification . notify ( "My App" , "Hello World !" , remove_after_s = 10 )
# The notification will close by itself after 10 seconds

También puede usar la función .remove_notification() para eliminar manualmente la notificación como se siguió:

 from tray_manager import TrayManager
my_tray = TrayManager ( "My App" , run_in_separate_thread = True )
notification = my_tray . notification

notification . notify ( "My App" , " Hello World !)

# Some code here

notification . remove_notification ()

Precaución

Por defecto, la notificación nunca cerrará por sí misma, asegúrese de cerrarla antes de crear una nueva.

Configuración avanzada

Seleccionando un backend

Si necesita funciones específicas, puede establecer el argumento backend del objeto tray_manager.TrayManager a uno de los valores tray_manager.Backends .

Nota

Por defecto, Pystray utilizará el mejor avaible de backend en su sistema operativo.

Precaución

Debe usar el backend de la clase tray_manager.Backends , pasando el valor de uno de los objetos de la clase aumentará un error.

También debe usar un backend compatible con su sistema operativo.

Sistema operativo	Backends
Windows	win32
Macosa	darwin
Linux	gtk , appindicator , ayatana-appindicator , xorg