tray_manager Download - tray_manager Quellcode Download

Was ist Tray_Manager?

tray_manager ist ein Paket, das zum Erstellen eines Systemablettungssymbols verwendet wird, das auf PyRTAY (https://github.com/mose-palmer/pystray von Moses Palmér) basiert. Dieses Paket ist eine "einfachere" Version von Pystriy, um es zu manipulieren, da es auf der Verwendung von Objekten basiert.

Wie installiere ich es?

tray_manager ist PubliSHD auf PYPI (https://pypi.org/project/tray-manager/) und kann mit dem folgenden Befehl in Ihrem Terminal heruntergeladen werden:

pip install tray-manager

Notiz

Sie müssen Python auf Ihrem Computer installieren lassen

Verwendung

Erstellen und verwenden Sie ein Traymanager -Objekt
Elemente erstellen und interagieren
Fügen Sie Elemente zum Menü hinzu
Passen Sie das Traymanager -Objekt an
Passen Sie die Elemente an und bearbeiten Sie sie
Überprüfen Sie die Funktionen für Betriebssysteme, die unterstützt werden
Benachrichtigungen [derzeit nicht vorab]
Erweiterte Einstellungen

Erstellen und verwenden Sie ein Traymanager -Objekt

Das Hauptziel der Librairy ist das Objekt tray_manager.TrayManager , es ist das zentrale Element und kann als Symbol in der Systemschale selbst betrachtet werden. Es enthält alle Elemente unserer App.

Um eine zu erstellen, müssen Sie die Klasse der tray_manager.TrayManager importieren und ein Tray -Objekt erstellen, wie befolgt:

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

Um die App zu stoppen, müssen Sie die folgende .kill() -Funktion verwenden:

Notiz

Die Funktion .kill() gibt alle Elemente zurück, die im Menü als Liste der Elemente enthalten sind

 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 ]

Wichtig

Die von Ihnen getöteten Menü- und Traymanager -Objekte werden nutzlos

Warnung

Das Erstellen eines tray_manager.TrayManager -Objekts wird seine innere Schleife ausgeführt, sobald es erstellt wird. Dies bedeutet, dass das Erstellen eines Objekts tray_manager.TrayManager den Rest Ihres Codes blockiert. Um dies zu verhindern, haben Sie 2 Optionen:

Sie können eine Funktion als setup -Argument des Objekts von tray_manager.TrayManager angeben. Diese Funktion wird beim Erstellen Ihres Objekts in einem neuen Thread gestartet.
(Nur Windows) Wenn Sie unter Windows sind und sich keine Sorgen über die tray_manager mit anderen Plattformen machen, können Sie das Argument run_in_separate_thread des tray_manager.TrayManager -Objekts auf True einstellen.

Elemente erstellen und interagieren

Die Elemente sind die Elemente Ihrer App, die im Menü angezeigt werden, zu dem sie hinzugefügt werden. Es ist unterschiedliche Arten von Gegenständen, die alle auf ähnliche Weise funktionieren, aber alle haben einige Spezifitäten.

Hier ist die Liste aller Elemente:

Etikett
Taste
Kontrollkästchen
Separator
Untermenü

Etikett

Das Etikett ist das grundlegendste Element, es wird nur aus einem Text bestimmen.

Um eine zu erstellen, verwenden Sie die folgende tray_manager.Label -Klasse:

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

Taste

Die Schaltfläche ist wie das Beschriftungselement, aber Sie können ein Rückrufargument (FunctionType) hinzufügen, das aufgerufen wird, wenn der Benutzer auf die Schaltfläche klickt. Sie können auch einige Argumente als Tupel angeben, die beim Klicken der Schaltfläche an Ihre Funktion übergeben werden.

Verwenden Sie zum Erstellen eines den folgenden tray_manager.Button -Klasse:

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

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

Kontrollkästchen

Das Kontrollkästchen -Element ist etwas komplexer als eine reguläre Taste. Es verfügt über 2 unterschiedliche Rückrufe anstelle von 1 und für jeweils unterschiedliche Argumente, eine für einen Zeitpunkt, an dem der Kontrollkästchen -Schalter vom "deaktivierten" Status "aktiviert" (nicht überprüft) und einer für den Schalter "aktiviert" zum "deaktivierten" Zustand (überprüft) (überprüft) (überprüft).

Sie können die Interaktionen mit Ihrem Kontrollkästchen "deaktivieren", indem Sie den Wert von check_default auf None festlegen.

Notiz

Der Rückruf wird nicht ausgeführt, wenn der Benutzer beim Deaktivieren auf das Kontrollkästchen klickt.

Um eine zu erstellen, verwenden Sie die folgende tray_manager.CheckBox -Klasse:

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

Um den aktuellen Status des Kontrollkästchens zu erhalten, können Sie die folgende Funktion .get_status() verwenden:

 from tray_manager import CheckBox

my_checkbox = CheckBox ( "My CheckBox" )

my_checkbox . get_status ()
- > bool | None

Sie können auch den Status des Kontrollkästchens festlegen, indem Sie die Funktion .set_status() wie befolgt verwenden:

 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

Notiz

Kontrollkästchen	Status
Überprüft	`True`
Deaktiviert	`False`
Deaktiviert	`None`

Wenn das Kontrollkästchen deaktiviert ist, bleibt es im vorherigen Status und die Interaktion der Interaktion der Interaktion. Wenn das Kontrollkästchen vor dem Deaktivieren überprüft wurde, bleibt das Kontrollkästchen überprüft, aber nichts passiert, wenn der Benutzer darauf klickt.

Separator

Das Separator ist ein integriertes Objekt von Pystrey, es hat keine Parameter.

Um eine zu erstellen, verwenden Sie die Klassen tray_manager.Separator wie folgt:

 from tray_manager import Separator
my_separator = Separator ()

Untermenü

Das Untermenü ist wie ein Objekt tray_manager.Menu und kann andere Elemente, einschließlich anderer Untermenü, enthält.

Vorsicht

Seien Sie karreful, wenn Sie ein Untermenü hinzufügen, wenn ein Untermenü zu einem Untermenü hinzugefügt wird, das in tray_manager.CircularAddException von Ihnen hinzugefügten Untermenü enthalten ist.

 Flussdiagramm TD
   A {mein Untermenü} -> b (mein Etikett)
   A -> C (mein Knopf)
   A -> d {mein zweites Untermenü}
   D -> e (mein zweites Label)
   D -> F (mein Kontrollkästchen)
   D -> | Tray_Manager.CircularadDexception | A

Verwenden Sie zum Erstellen eines den folgenden tray_manager.Submenu :

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

Verwenden Sie die Funktion .add() , um dem Untermenü ein Element hinzuzufügen, wie folgt:

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

my_submenu . add ( my_label )

Verwenden Sie die Funktion .remove() um ein Element aus dem Untermenü zu entfernen, wie folgt:

 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

Notiz

Die Funktion .remove() gibt das von der Entfernung entferntes Element zurück

Um die in einem Untermenü enthaltenen Elemente zu erhalten, verwenden Sie die Funktion .get_items() wie folgt:

 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 ]

Fügen Sie die Elemente zum Menü hinzu

Das tray_manager.Menu ist eines der zentralen Elemente dieser Bibliothek. Es funktioniert wie ein Untermenü und wird automatisch erstellt, wenn Sie ein tray_manager.TrayManager -Objekt als tray_manager.TrayManager.menu -Objekt erstellen und können nicht entfernt werden.

Warnung

Überprüfen Sie, ob Sie tray_manager.OsSupport.HAS_MENU auf Disponibilität in Ihrem Betriebssystem aufnehmen können. Wenn Ihr Betriebssystem das Menü nicht unterstützt, ist das Objekt tray_manager.TrayManager.menu keine.

Um das Menü zu verwenden, ägt das Objekt tray_manager.TrayManager.menu wie befolgt:

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

Um dem Menü ein Element hinzuzufügen, verwenden Sie die Funktion .add() wie befolgt:

 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 )

Um ein Element aus dem Menü zu entfernen, können Sie die folgende Funktion .remove() verwenden:

 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

Notiz

Die Funktion .remove() gibt das von entnommene Element zurück.

Um die in einem Menü enthaltenen Elemente zu erhalten, können Sie die folgende Funktion .get_items() verwenden:

 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 ]

Um die Menüelemente (die im Menü enthaltenen Elemente) zu aktualisieren, verwenden Sie die Funktion .update() .

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

my_menu . update ()

Notiz

Die Funktion .update() wird jedes Mal automatisch ausgelöst, wenn Sie ein Element aus dem Menü bearbeiten, hinzufügen oder entfernen.

Passen Sie das Traymanager -Objekt an

Sie können Ihr Traymanager -Objekt auf unterschiedliche Weise anpassen, wie z. B.:

Festlegen eines neuen Namens für die App
Festlegen eines neuen Symbols für die App
Versteck / Anzeige der App im Systemfach

Festlegen eines neuen Namens für die App

Um einen neuen Namen für Ihre App festzulegen, verwenden Sie die Funktion .set_app_name() wie folgt:

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

my_tray . set_app_name ( "My new App" )

Festlegen eines neuen Symbols für die App

tray_manager Verwenden .load_icon() .set_icon() Speichersystem für Symbole, um ein neues Symbol tray_manager.TrayManager Ihre App festzulegen.

Notiz

Standardmäßig ist das Symbol ein weißes Quadrat von 32 x 32 Pixel. Das Standardsymbol wird immer in den Speicher geladen und kann erneut festgelegt werden, indem Sie die Funktion von tray_manager.Values.DEFAULT als name der Funktion .set_icon() übergeben.

Verwenden Sie zum Laden eines Symbols die Funktion .load_icon() und übergeben Sie es einen Dateipfad, ein codiertes Bild, ein PIL.Image -Objekt oder eine beliebige Datei, die von PIL als Bild gelesen und interpretiert werden kann . Sie müssen auch einen Namen übergeben, der als Schlüssel in der Icons DictionNary verwendet wird, um Ihr Symbol zu retreive.

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

Warnung

tray_manager Verwendet ein DiktionNary, um Ihre geladenen Symbole zu speichern. Dies bedeutet, dass das Laden eines Bildes mit einem bereits verwendeten Namen das Bild überschreibt, das zuvor mit diesem Namen geladen wurde. Die einzige Ausnahme ist das Standardsymbol, das nicht bearbeitet werden kann.

Um ein Symbol festzulegen, verwenden Sie die Funktion .set_icon() und übergeben Sie den Namen (Schlüssel) Ihres Symbols, das Sie beim Laden des Symbols festgelegt haben.

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

Versteck / Anzeige der App im Systemfach

Anstatt das Objekt tray_manager.TrayManager zu töten, wenn Sie möchten, dass es nicht mehr in der Systemschale angezeigt wird und eine neue erstellt wird, sobald Sie es erneut benötigen, können Sie die Funktionen .show() und .hide() Funktionen des tray_manager.TrayManager -Objekts verwenden, um zu steuern, ob die App im Systemsträum sichtbar ist oder nicht.

Notiz

Sie können das Argument default_show des Objekts tray_manager.TrayManager auf True oder False festlegen, wenn Sie Ihr tray_manager.TrayManager -Objekt erstellen, um zu definieren, ob das Symbol für das Systemabgenerat angezeigt wird oder nicht, wenn das Objekt erstellt wird.

Um die App im Systemfach anzuzeigen, verwenden Sie die Funktion .show() des Objekts des tray_manager.TrayManager wie folgt:

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

my_tray . show ()

Um die App im Systemfach auszublenden, verwenden Sie die Funktion .hide() des Objekts des tray_manager.TrayManager wie folgt:

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

my_tray . hide ()

Passen Sie die Elemente an und bearbeiten Sie sie

Um ein bereits erstelltes Element zu bearbeiten, verwenden Sie die Funktion .edit() des Elements. Wenn Sie dies tun, müssen Sie nur angeben, welche Argumente Sie ändern möchten, und die anderen bleiben genauso wie sie.

Um einen Artikel zu bearbeiten, tun Sie dies wie folgt:

 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 !

Sie können die Elemente auf unterschiedliche Weise anstellen, z. B.:

Aktivieren / Deaktivieren des Elements (grauer Look und nicht reagierender)
Festlegen der Standardattribut auf das Element (mutiges Aussehen)
Festlegen des Radio -Looks auf dem Kontrollkästchen (ein Punkt anstelle eines Crossmarks)

Aktivieren / Deaktivieren des Elements (grauer Look und nicht reagierender)

Wenn Sie das Element anzeigen möchten, aber möchten, dass es nicht reagierend ist (für Schaltfläche, Kontrollkästchen und Untermenü) und wie ein deaktiviertes Element aussehen, können Sie die Funktionen .enable() und .disable() des Elements verwenden.

Notiz

Standardmäßig sind alle Elemente aktiviert

Jedes Element kann außer dem Trennzeichen deaktiviert werden.

Verwenden Sie, um Ihr Element zu aktivieren, die Funktion .enable() des Elements wie befolgt:

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

Verwenden Sie, um Ihr Element zu deaktivieren, die Funktion von .disable() des Elements wie befolgt:

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

Festlegen der Standardattribut auf das Element (mutiges Aussehen)

Um Ihr Element zum Standardelement des Menüs / des Untermenus zu machen und ihm einen mutigen Look zu verleihen, können Sie das default beim Erstellen / Bearbeiten des Elements auf True festlegen.

Notiz

Sie können nur 1 Standardelement für Menü / Untermenü haben. Standardmäßig gibt es kein Standardelement.

Um die default des Elements festzulegen, tun Sie dies wie folgt:

Beim Erstellen des Elements:

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

Beim Bearbeiten des Elements:

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

Festlegen des Radio -Looks auf dem Kontrollkästchen (ein Punkt anstelle eines Crossmarks)

Wenn Sie Ihrem regulären Kontrollkästchen Crossmark einen neuen Blick darauf geben möchten, können Sie das Kontrollkästchen use_radio_look " des Kontrollkästchens auf True einstellen, wenn Sie das Kontrollkästchen erstellen / bearbeiten.

Um die Attribut des use_radio_look des Elements festzulegen, tun Sie dies befolgt:

Beim Erstellen des Elements:

 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 )

Beim Bearbeiten des Elements:

 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 )

Überprüfen Sie die Funktionen für Betriebssysteme, die unterstützt werden

Bevor Sie Funktionen des tray_manager package verwenden, müssen Sie überprüfen, ob sie mit Ihrem Betriebssystem kompatibel sind. Verwenden Sie dazu das Objekt tray_manager.Os_Support . Es gibt 4 verschiedene Funktionen, die Sie überprüfen müssen, bevor Sie verwenden:

OS_SUPPORT.SUPPORT_MENU
OS_SUPPORT.SUPPORT_DEFAULT
OS_SUPPORT.SUPPORT_RADIO
Os_support.support_notification [derzeit nicht verfügbar]

Um zu wissen, ob Ihr Betriebssystem eine Funktion unterstützt, muss die entsprechende Os_Support -Variable wahr sein.

Beispiel, um zu prüfen, ob Ihr Betriebssystem das Menü unterstützt, wie folgt:

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

Notiz

Hier ist ein Diagramm der Merkmale, die von jedem Betriebssystem und jeder Backends unterstützt werden sollen .

Feature os und Backend	Windows (Win32)	Linux (GTK)	Linux (Appindicator)	Linux (Ayatana-Appindicator)	Linux (xorg)	Macos (Darwin)
Speisekarte	Unterstützt	Unterstützt	Unterstützt	Unterstützt	Nicht unterstützt	Unterstützt
Standard	Unterstützt	Unterstützt	Nicht unterstützt	Nicht unterstützt	Unterstützt	Nicht unterstützt
Radio	Unterstützt	Unterstützt	Unterstützt	Unterstützt	Unterstützt	Nicht unterstützt
Benachrichtigung	Derzeit nicht verfügbar	Unbekannt	UNKANN	Unbekannt	Nicht unterstützt	Nicht unterstützt

Benachrichtigungen [derzeit nicht vorab]

Wenn Sie eine Benachrichtigung auf dem Bildschirm des Benutzers erstellen möchten, können Sie das Objekt tray_manager.TrayManager.notification verwenden.

Verwenden Sie, um eine Benachrichtigung zu erstellen, die Funktion .notify() des tray_manager.TrayManager.notification -Objekts wie befolgt:

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

Sie können eine Verzögerung angeben, nach der die Benachrichtigung entfernt wird, indem ein Wert in Sekunden an die Funktion .notify() als remove_after_s wie befolgt weitergeleitet wird:

 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

Sie können auch die Funktion .remove_notification() verwenden, um die folgende Benachrichtigung manuell zu entfernen:

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

Vorsicht

Standardmäßig wird die Benachrichtigung niemals von selbst geschlossen. Schließen Sie sie, bevor Sie eine neue erstellen.

Erweiterte Einstellungen

Auswählen eines Backends

Wenn Sie bestimmte Funktionen benötigen, können Sie das backend -Argument des Objekts von tray_manager.TrayManager auf einen der tray_manager.Backends -Werte festlegen.

Notiz

Standardmäßig verwendet PystRay den besten Backend Avaible unter Ihrem Betriebssystem.

Vorsicht

Sie müssen das Backend aus der Klasse tray_manager.Backends verwenden. Wenn Sie den Wert eines Objekts der Klasse übergeben, erhöht er einen Fehler.

Sie müssen auch ein Backend verwenden, das mit Ihrem Betriebssystem kompatibel ist.