tray_manager

Qu'est-ce que Tray_Manager?

tray_manager est un package utilisé pour créer une icône de plateau système, basé sur Pystray (https://github.com/moses-palmer/pystray par Moses Palmér), ce package est une version "plus facile" de Pystray à manipuler car elle est basée sur l'utilisation des objets.

Comment l'installer?

tray_manager est publiquehd sur PYPI (https://pypi.org/project/tray-manager/) et peut être téléchargé en utilisant la commande suivante dans votre terminal:

pip install tray-manager

Note

Vous devez faire installer Python sur votre ordinateur

Usage

1. Créer et utiliser un objet TrayManager
2. Créer et interagir avec les éléments
3. Ajouter des éléments au menu
4. Personnalisez l'objet TrayManager
5. Personnaliser et modifier les éléments
6. Vérifiez les fonctionnalités prises en charge du système d'exploitation
7. Notifications [actuellement invraibles]
8. Paramètres avancés

Créer et utiliser un objet TrayManager

L'objet principal du Librairy est l'objet tray_manager.TrayManager , c'est l'élément central et peut être considéré comme l'icône dans le plateau système lui-même, il contient tous les éléments de notre application.

Pour en créer un, vous devez importer la classe tray_manager.TrayManager et créer un objet de plateau comme suivi:

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

Pour arrêter l'application, vous devez utiliser la fonction .kill() comme suivi:

Note

La fonction .kill() renvoie tous les éléments contenus dans le menu comme une liste d'éléments

 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 ]

Important

Le menu et les objets TrayManager que vous avez tués deviendront inutiles

Avertissement

La création d'un objet tray_manager.TrayManager exécutera sa boucle intérieure dès sa création. Cela signifie que la création d'un objet tray_manager.TrayManager bloquera le reste de votre code. Pour éviter que cela ne se produise, vous avez 2 options:

1. Vous pouvez spécifier une fonction comme l'argument setup de l'objet tray_manager.TrayManager , cette fonction sera démarrée dans un nouveau thread lors de la création de votre objet.

2. (Windows uniquement) Si vous êtes sous Windows et que vous ne vous inquiétez pas de la compatibilité avec d'autres plates-formes, vous pouvez définir l'argument run_in_separate_thread de l'objet tray_manager.TrayManager sur True , cela commencera la boucle tray_manager dans un nouveau thread et le reste de votre code sera correctement exécuté dans la boucle principale.

Créer et interagir avec les éléments

Les éléments sont les éléments de votre application, ils seront affichés dans le menu auquel ils sont ajoutés. Ce sont différents types d'articles qui fonctionnent tous de manière similaire, mais chacun a des spécificités.

Voici la liste de tous les éléments:

1. Étiquette
2. Bouton
3. Cocher
4. Séparateur
5. Sous-menu

Étiquette

L'étiquette est l'élément le plus élémentaire, il n'est constitué que d'un texte.

Pour en créer un, utilisez la classe tray_manager.Label comme suivi:

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

Bouton

Le bouton est comme l'élément d'étiquette, mais vous pouvez ajouter un argument de rappel (FunctionType) qui sera appelé lorsque l'utilisateur clique sur le bouton. Vous pouvez également spécifier certains arguments en tant que tuple qui sera transmis à votre fonction lorsque le bouton est cliqué.

Pour en créer un, utilisez la classe tray_manager.Button comme suivi:

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

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

Cocher

L'élément de case à cocher est un peu plus complexe qu'un bouton régulier, il a 2 rappels différents au lieu de 1 et différents arguments pour chacun, un pour le moment où la case à cocher passe de l'état `` désactivé '' à `` activé '' (non vérifié à cocher), et un pour le passage de l'état `` activé '' à `` désactivé '' (vérifié à ne pas vérifier).

Vous pouvez «désactiver» les interactions avec votre case à cocher en définissant la valeur de check_default sur None .

Note

Le rappel ne sera pas exécuté si l'utilisateur clique sur la case à cocher lorsqu'il est désactivé.

Pour en créer un, utilisez la classe tray_manager.CheckBox comme suivi:

 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" ,))

Pour obtenir l'état actuel de la case à cocher, vous pouvez utiliser la fonction .get_status() comme suivi:

 from tray_manager import CheckBox

my_checkbox = CheckBox ( "My CheckBox" )

my_checkbox . get_status ()
- > bool | None

Vous pouvez également définir l'état de la case à cocher en utilisant la fonction .set_status() comme suivi:

 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 

Note

Cocher	Statut
À carreaux	True
Incontrôlé	False
Désactivé	None

Lorsque la case à cocher est désactivée, elle reste dans son état précédent et arrête d'interagir, cela signifie que si la case à cocher était cochée avant d'être désactivée, la case à cocher restera cochée mais rien ne se passera si l'utilisateur clique dessus.

Séparateur

Le séparateur est un objet intégré de Pystray, il n'a aucun paramètre.

Pour en créer un, utilisez la classe tray_manager.Separator comme suivi:

 from tray_manager import Separator
my_separator = Separator ()

Sous-menu

Le sous-menu est comme un objet tray_manager.Menu et peut contenir d'autres éléments, y compris d'autres sous-mens.

Prudence

Soyez Carreful lorsque vous ajoutez un sous-menu les uns dans les autres comme ajoutant un sous-menu à un sous-menu qui est contenu dans le sous-menu que vous ajoutez génère une erreur tray_manager.CircularAddException .

 Organigramme TD
   Un {mon sous-menu} -> b (mon label)
   A -> c (mon bouton)
   A -> d {mon deuxième sous-menu}
   D -> E (ma deuxième étiquette)
   D -> f (ma case)
   D -> | Tray_manager.circularAddexception | UN

Pour en créer un, utilisez le tray_manager.Submenu comme suivi:

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

Pour ajouter un élément au sous-menu, utilisez la fonction .add() comme suivi:

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

my_submenu . add ( my_label )

Pour supprimer un élément du sous-menu, utilisez la fonction .remove() comme suivi:

 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 

Note

La fonction .remove() renvoie l'élément qui a été supprimé

Pour obtenir les éléments contenus dans un sous-menu, utilisez la fonction .get_items() comme suivi:

 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 ]

Ajouter les éléments au menu

Le tray_manager.Menu est l'un des éléments centraux de cette bibliothèque, il fonctionne comme un sous-menu et est créé automatiquement lorsque vous créez un objet tray_manager.TrayManager comme objet tray_manager.TrayManager.menu et ne peut pas être supprimé.

Avertissement

Vérifiez tray_manager.OsSupport.HAS_MENU pour la discipabilité sur votre système d'exploitation, si votre système d'exploitation ne prend pas en charge le menu, l'objet tray_manager.TrayManager.menu n'en sera pas.

Pour utiliser le menu, accuse l'objet tray_manager.TrayManager.menu comme suivi:

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

Pour ajouter un élément au menu, utilisez la fonction .add() comme suivi:

 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 )

Pour supprimer un élément du menu, vous pouvez utiliser la fonction .remove() comme suivi:

 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 

Note

La fonction .remove() renvoie l'élément qui a été supprimé.

Pour obtenir les éléments contenus dans un menu, vous pouvez utiliser la fonction .get_items() comme suivi:

 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 ]

Pour mettre à jour les éléments du menu (les éléments contenus dans le menu), utilisez la fonction .update() .

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

my_menu . update ()

Note

La fonction .update() est déclenchée automatiquement chaque fois que vous modifiez, ajoutez ou supprimez un élément du menu.

Personnalisez l'objet TrayManager

Vous pouvez personnaliser votre objet TrayManager de différentes manières telles que:

1. Définir un nouveau nom pour l'application
2. Définir une nouvelle icône pour l'application
3. Cacher / afficher l'application dans le plateau système

Définir un nouveau nom pour l'application

Pour définir un nouveau nom pour votre application, utilisez la fonction .set_app_name() comme suivi:

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

my_tray . set_app_name ( "My new App" )

Définir une nouvelle icône pour l'application

tray_manager utilise un système de mémoire pour les icônes, pour définir une nouvelle icône pour votre application, vous devez d'abord le charger à l'aide de la fonction .load_icon() , puis définissez l'icône comme nouvelle icône à l'aide de la fonction .set_icon() de l'objet tray_manager.TrayManager .

Note

Par défaut, l'icône est un carré blanc de 32x32 pixels. L'icône par défaut est toujours chargée en mémoire et peut être relevée en passant à nouveau la fonction tray_manager.Values.DEFAULT comme argument name de la fonction .set_icon() .

Pour charger une icône, utilisez la fonction .load_icon() et passez-la un chemin de fichier, une image codée, un objet PIL.Image ou tout fichier qui peut être lu et interprété comme une image par PIL . Vous devez également passer un nom qui sera utilisé comme clé dans les icônes DictionNary pour retarder votre icône.

 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" )

Avertissement

tray_manager utilise un DictionNary pour enregistrer vos icônes chargées, cela signifie que le chargement d'une image à l'aide d'un nom qui a déjà été utilisé écrasera l'image qui était auparavant chargée de ce nom. La seule exception à cela est l'icône par défaut qui ne peut pas être modifiée.

Pour définir une icône, utilisez la fonction .set_icon() et passez-la le nom (clé) de votre icône que vous définissez lorsque vous avez chargé l'icône.

 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" )

Cacher / afficher l'application dans le plateau système

Au lieu de tuer l'objet tray_manager.TrayManager lorsque vous voulez qu'il cesse d'être affiché dans le plateau système et en créant un nouveau une fois que vous en avez besoin, vous pouvez utiliser l'objet .show() et .hide() du tray_manager.TrayManager pour contrôler si l'application est visible dans le plateau système ou non.

Note

Vous pouvez définir l'argument default_show de l'objet tray_manager.TrayManager sur True ou False lors de la création de votre objet tray_manager.TrayManager pour définir si l'icône du plateau système sera affichée ou non une fois l'objet créé.

Pour afficher l'application dans le plateau système, utilisez la fonction .show() de l'objet tray_manager.TrayManager comme suivi:

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

my_tray . show ()

Pour masquer l'application dans le plateau système, utilisez la fonction .hide() de l'objet tray_manager.TrayManager comme suivi:

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

my_tray . hide ()

Personnaliser et modifier les éléments

Pour modifier un élément déjà créé, utilisez la fonction .edit() de l'élément, ce qui le fait, il vous suffit de spécifier les arguments que vous souhaitez modifier, et les autres resteront les mêmes qu'ils l'étaient.

Pour modifier un article, faites comme suivi:

 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 !

Vous pouvez personnaliser les éléments de différentes manières telles que:

1. Activer / désactiver l'élément (look gris et non réactif)
2. Définition de l'attribution par défaut à l'élément (look gras)
3. Définition de l'aspect radio sur la case à cocher (un point au lieu d'un crossmark)

Activer / désactiver l'élément (look gris et non réactif)

Si vous souhaitez afficher l'élément, mais que vous voulez qu'il ne soit pas sensible (pour le bouton, la case à cocher et le sous-menu) et ressemble à un élément désactivé, vous pouvez utiliser les fonctions .enable() et .disable() de l'élément.

Note

Par défaut, tous les éléments sont activés

Chaque élément peut être désactivé à l'exception du séparateur.

Pour activer votre article, utilisez la fonction .enable() de l'élément comme suivi:

 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 ()

Pour désactiver votre article, utilisez la fonction .disable() de l'élément comme suivi:

 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 ()

Définition de l'attribution par défaut à l'élément (look gras)

Pour faire de votre élément l'élément par défaut du menu / sous-menu et lui donner un aspect audacieux, vous pouvez définir l'attribution default lors de la création / modification de l'élément sur True .

Note

Vous ne pouvez avoir qu'un seul élément par défaut par menu / sous-menu. Par défaut, il n'y a pas d'élément par défaut.

Pour définir l'attribution default de l'élément, faites comme suivi:

Lors de la création de l'élément:

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

Lors de la modification de l'article:

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

Définition de l'aspect radio sur la case à cocher (un point au lieu d'un crossmark)

Si vous souhaitez donner un nouveau look à votre CROSSMARK à cocher ordinaire, vous pouvez définir l'attribution use_radio_look de la case à cocher sur True lors de la création / modification de la case à cocher.

Pour définir l'attribution use_radio_look de l'élément, faites comme suivi:

Lors de la création de l'élément:

 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 )

Lors de la modification de l'article:

 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 )

Vérifiez les fonctionnalités prises en charge du système d'exploitation

Avant d'utiliser les fonctionnalités du tray_manager package , vous devez vérifier s'ils sont compatibles avec votre système d'exploitation. Pour ce faire, utilisez l'objet tray_manager.Os_Support . Il y a 4 fonctionnalités différentes que vous devez vérifier avant d'utiliser:

1. Os_support.support_menu
2. Os_support.support_default
3. Os_support.support_radio
4. Os_support.support_notification [actuellement unavailbe]

Pour savoir si votre système d'exploitation prend en charge une fonctionnalité, la variable Os_Support correspondante doit être vraie.

Exemple, pour vérifier si votre système d'exploitation prend en charge le menu, faites comme suivi:

 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" )

Note

Voici un graphique des fonctionnalités supposées et non censées être prises en charge par chaque système d'exploitation et backends.

Fonctionnalité os et backend	Windows (Win32)	Linux (GTK)	Linux (appindicator)	Linux (Ayatana-Appindicator)	Linux (Xorg)	MacOS (darwin)
Menu	Soutenu	Soutenu	Soutenu	Soutenu	Non pris en charge	Soutenu
Défaut	Soutenu	Soutenu	Non pris en charge	Non pris en charge	Soutenu	Non pris en charge
Radio	Soutenu	Soutenu	Soutenu	Soutenu	Soutenu	Non pris en charge
Notification	Actuellement Unavailbe	Inconnu	Connu	Inconnu	Non pris en charge	Non pris en charge

Notifications [actuellement invraibles]

Si vous souhaitez créer une notification sur l'écran de l'utilisateur, vous pouvez utiliser l'objet tray_manager.TrayManager.notification .

Pour créer une notification, utilisez la fonction .notify() de l'objet tray_manager.TrayManager.notification comme suivi:

 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 !" )

Vous pouvez spécifier un délai, après quoi la notification sera supprimée en passant une valeur en secondes à la fonction .notify() comme le remove_after_s comme suivi:

 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

Vous pouvez également utiliser la fonction .remove_notification() pour supprimer manuellement la notification comme suivi:

 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 ()

Prudence

Par défaut, la notification ne se terminera jamais par elle-même, assurez-vous de la fermer avant d'en créer une nouvelle.

Paramètres avancés

Sélection d'un backend

Si vous avez besoin de fonctionnalités spécifiques, vous pouvez définir l'argument backend de l'objet tray_manager.TrayManager sur l'une des valeurs tray_manager.Backends .

Note

Par défaut, Pystray utilisera le meilleur backend AVAIble sur votre système d'exploitation.

Prudence

Vous devez utiliser le backend à partir de la classe tray_manager.Backends , passant la valeur de l'un des objets de la classe augmentera une erreur.

Vous devez également utiliser un backend compatible avec votre système d'exploitation.

OS	Backends
Fenêtre	win32
Macos	darwin
Linux	gtk , appindicator , ayatana-appindicator , xorg