Download do tray_manager - tray_manager do download do código fonte

O que é tray_manager?

tray_manager é um pacote usado para criar um ícone da bandeja do sistema, baseado em Pystray (https://github.com/moses-palmer/pystray por Moses Palmér), este pacote é uma versão "mais fácil" do Pystray para manipular, pois é baseado no uso de objetos.

Como faço para instalá -lo?

tray_manager é publicado no Pypi (https://pypi.org/project/tray-manager/) e pode ser baixado usando o seguinte comando em seu terminal:

pip install tray-manager

Observação

Você precisa ter o python instalado em seu computador

Uso

Crie e use um objeto TrayManager
Criar e interagir com itens
Adicione itens ao menu
Personalize o objeto TrayManager
Personalize e edite os itens
Verifique se há recursos suportados pelo sistema operacional
Notificações [atualmente inevicíveis]
Configurações avançadas

Crie e use um objeto TrayManager

O objeto principal do Libribairy é o objeto tray_manager.TrayManager , é o elemento central e pode ser considerado como o ícone na própria bandeja do sistema, ele contém todos os elementos do nosso aplicativo.

Para criar um, você precisa importar a classe tray_manager.TrayManager e criar um objeto de bandeja como seguido:

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

Para interromper o aplicativo, você precisa usar a função .kill() como seguinte:

Observação

A função .kill() retorna todos os itens que estão contidos no menu como uma lista de itens

 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

O cardápio e os objetos de bandeja que você matou se tornarão inúteis

Aviso

Criar um objeto tray_manager.TrayManager executará seu loop interno assim que for criado. Isso significa que a criação de um objeto tray_manager.TrayManager bloqueará o restante do seu código. Para evitar que isso aconteça, você tem 2 opções:

Você pode especificar uma função como o argumento setup do objeto tray_manager.TrayManager , essa função será iniciada em um novo thread ao criar seu objeto.
(Somente Windows) Se você estiver no Windows e não se preocupe com a compatibilidade com outras plataformas, você pode definir o argumento run_in_separate_thread do tray_manager.TrayManager se opor a True , isso iniciará o loop tray_manager em um novo thread e o restante do seu código será executado corretamente no loop principal.

Criar e interagir com itens

Os itens são os elementos do seu aplicativo, eles serão exibidos no menu em que são adicionados. Seus tipos diferentes de itens que funcionam de maneira semelhante, mas cada um tem algumas especificidades.

Aqui está a lista de todos os itens:

Rótulo
Botão
Caixa de seleção
Separador
Submenu

Rótulo

O rótulo é o item mais básico, é constituído apenas em um texto.

Para criar um, use a classe tray_manager.Label como seguinte:

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

Botão

O botão é como o item da etiqueta, mas você pode adicionar um argumento de retorno de chamada (FunctionType) que será chamado quando o usuário clicar no botão. Você também pode especificar alguns argumentos como uma tupla que será passada para sua função quando o botão for clicado.

Para criar um, use a classe tray_manager.Button como a seguir:

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

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

Caixa de seleção

O item da caixa de seleção é um pouco mais complexo que um botão regular, ele possui 2 retornos de chamada diferentes em vez de 1 e argumentos diferentes para cada um, um para quando a caixa de seleção interruira do estado 'desabilitado' para 'ativado' (não verificado para verificação) e um para quando alterar do estado 'habilitado' para 'desativado' (verificado para não ser verificado).

Você pode 'desativar' as interações com sua caixa de seleção, definindo o valor de check_default para None .

Observação

O retorno de chamada não será executado se o usuário clicar na caixa de seleção quando estiver desativado.

Para criar um, use a classe tray_manager.CheckBox como seguida:

 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 obter o estado atual da caixa de seleção, você pode usar a função .get_status() como seguinte:

 from tray_manager import CheckBox

my_checkbox = CheckBox ( "My CheckBox" )

my_checkbox . get_status ()
- > bool | None

Você também pode definir o estado da caixa de seleção usando a função .set_status() como seguido:

 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

Observação

Caixa de seleção	Status
Verificado	`True`
Sem controle	`False`
Desabilitado	`None`

Quando a caixa de seleção está desativada, ela permanece em seu estado anterior e pare de interagir, isso significa que, se a caixa de seleção foi verificada antes de ser desativada, a caixa de seleção ficará verificada, mas nada acontecerá se o usuário clicar nele.

Separador

O separador é um objeto embutido de Pystray, não possui parâmetros.

Para criar um, use a classe tray_manager.Separator como seguido:

 from tray_manager import Separator
my_separator = Separator ()

Submenu

O submenu é como um objeto tray_manager.Menu e pode contém outros itens, incluindo outros submenu.

Cuidado

Seja carreado ao adicionar submenu ao outro como adicionar um submenu a um submenu que está contido no submenu que você está adicionando, gerará um erro tray_manager.CircularAddException .

 Fluxograma TD
   A {meu submenu} -> b (meu rótulo)
   A -> C (meu botão)
   A -> d {meu segundo submenu}
   D -> E (minha segunda etiqueta)
   D -> F (minha caixa de seleção)
   D -> | tray_manager.circularAdDexception | UM

Para criar um, use o tray_manager.Submenu como seguido:

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

Para adicionar um item ao submenu, use a função .add() como seguido:

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

my_submenu . add ( my_label )

Para remover um item do submenu, use a função .remove() como a seguir:

 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

Observação

A função .remove() retorna o item que foi removido

Para obter os itens contidos em um submenu, use a função .get_items() como seguinte:

 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 ]

Adicione os itens ao menu

O tray_manager.Menu é um dos elementos centrais desta biblioteca, funciona como um submenu e é criado automaticamente quando você cria um objeto tray_manager.TrayManager como o objeto tray_manager.TrayManager.menu e não pode ser removido.

Aviso

Verifique tray_manager.OsSupport.HAS_MENU para obter descarga no seu sistema operacional, se o seu sistema operacional não suportar o menu, o objeto tray_manager.TrayManager.menu será nenhum.

Para usar o menu, accem o objeto tray_manager.TrayManager.menu como a seguir:

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

Para adicionar um item ao menu, use a função .add() como seguinte:

 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 remover um item do menu, você pode usar a função .remove() como seguinte:

 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

Observação

A função .remove() retorna o item que foi removido.

Para obter os itens contidos em um menu, você pode usar a função .get_items() como seguinte:

 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 atualizar os itens do menu (os itens contidos no menu), use a função .update() .

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

my_menu . update ()

Observação

A função .update() é acionada automaticamente sempre que você editar, adicionar ou remover um item do menu.

Personalize o objeto TrayManager

Você pode personalizar seu objeto TrayManager de diferentes maneiras, como:

Definindo um novo nome para o aplicativo
Definindo um novo ícone para o aplicativo
Escondendo / mostrando o aplicativo na bandeja do sistema

Definindo um novo nome para o aplicativo

Para definir um novo nome para o seu aplicativo, use a função .set_app_name() como seguinte:

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

my_tray . set_app_name ( "My new App" )

Definindo um novo ícone para o aplicativo

tray_manager Use um sistema de memória para ícones, para definir um novo ícone para o seu aplicativo, primeiro você precisa carregá -lo usando a função .load_icon() e, em seguida, defina o ícone como o novo ícone usando a função .set_icon() do objeto tray_manager.TrayManager .

Observação

Por padrão, o ícone é um quadrado branco de 32x32 pixels. O ícone padrão é sempre carregado na memória e pode ser definido novamente, passando a name da função tray_manager.Values.DEFAULT .set_icon() .

Para carregar um ícone, use a função .load_icon() e passe um caminho de arquivo, uma imagem codificada, um objeto PIL.Image ou qualquer arquivo que possa ser lido e interpretado como uma imagem por PIL . Você também precisa passar por um nome que será usado como chave no ícones DictionNary para recuperar seu ícone.

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

Aviso

tray_manager Use um DictionNary para salvar seus ícones carregados, isso significa que carregar uma imagem usando um nome que já foi usado substituirá a imagem que foi carregada anteriormente com esse nome. A única exceção a isso é o ícone padrão que não pode ser editado.

Para definir um ícone, use a função .set_icon() e passe o nome (chave) do seu ícone que você definiu quando carregou o ícone.

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

Escondendo / mostrando o aplicativo na bandeja do sistema

Em vez de matar o objeto tray_manager.TrayManager quando você deseja que ele pare de ser exibido na bandeja do sistema e criando um novo quando precisar novamente, você pode usar as funções .show() e .hide() da bandeja do tray_manager.TrayManager ou não.

Observação

Você pode definir o argumento default_show do the tray_manager.TrayManager Objeta -se para True ou False ao criar seu objeto tray_manager.TrayManager para definir se o ícone da bandeja do sistema será exibido ou não uma vez que o objeto for criado.

Para mostrar o aplicativo na bandeja do sistema, use a função .show() do objeto tray_manager.TrayManager como a seguir:

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

my_tray . show ()

Para ocultar o aplicativo na bandeja do sistema, use a função .hide() do objeto tray_manager.TrayManager como a seguir:

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

my_tray . hide ()

Personalize e edite os itens

Para editar um item já criado, use a função .edit() do item, ao fazê -lo, você só precisa especificar quais argumentos deseja alterar e os outros permanecerão os mesmos que eram.

Para editar um item, faça o seguinte:

 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 !

Você pode personalizar os itens de diferentes maneiras, como:

Ativar / desativar o item (aparência cinza e não responsiva)
Definindo o atribuição padrão ao item (visualização em negrito)
Definir a aparência de rádio na caixa de seleção (um ponto em vez de uma marka

Ativar / desativar o item (aparência cinza e não responsiva)

Se você deseja exibir o item, mas deseja que ele seja responsivo (para botão, caixa de seleção e submenu) e parecer um item desativado, você pode usar as funções .enable() e .disable() do item.

Observação

Por padrão, todos os itens estão ativados

Cada item pode ser desativado, exceto o separador.

Para ativar seu item, use a função .enable() do item como seguido:

 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 desativar seu item, use a função .disable() do item como seguido:

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

Definindo o atribuição padrão ao item (visualização em negrito)

Para tornar seu item o item padrão do menu / submenu e dar uma aparência ousada, você pode definir o atribuições default ao criar / editar o item como True .

Observação

Você só pode ter 1 item padrão por menu / submenu. Por padrão, não há item padrão.

Para definir o atributo default do item, faça o seguinte:

Ao criar o item:

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

Ao editar o item:

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

Definir a aparência de rádio na caixa de seleção (um ponto em vez de uma marka

Se você deseja dar uma nova aparência à sua caixa de seleção Regular CrossMark, pode True o atribuição use_radio_look da caixa de seleção para criar / editar a caixa de seleção.

Para definir o atribuição do item use_radio_look , faça o seguinte:

Ao criar o item:

 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 )

Ao editar o item:

 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 se há recursos suportados pelo sistema operacional

Antes de usar os recursos do tray_manager package , você deve verificar se eles são compatíveis com seu sistema operacional. Para fazer isso, use o objeto tray_manager.Os_Support . Existem 4 recursos diferentes que você precisa verificar antes de usar:

Os_support.support_menu
Os_support.support_default
Os_support.support_radio
Os_support.support_notification [atualmente descondera]

Para saber se seu sistema operacional suporta um recurso, a variável Os_Support correspondente deve ser verdadeira.

Exemplo, para verificar se o seu sistema operacional suporta o menu, faça o seguinte:

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

Observação

Aqui está um gráfico dos recursos que se supõem e não deveriam ser suportados por cada sistema operacional e back -ends.

Recurso os e back -end	Windows (Win32)	Linux (GTK)	Linux (Appindicator)	Linux (Ayatana-Apincindicator)	Linux (Xorg)	MacOS (Darwin)
Menu	Suportado	Suportado	Suportado	Suportado	Não suportado	Suportado
Padrão	Suportado	Suportado	Não suportado	Não suportado	Suportado	Não suportado
Rádio	Suportado	Suportado	Suportado	Suportado	Suportado	Não suportado
Notificação	Atualmente desconhecido	Desconhecido	Uknown	Desconhecido	Não suportado	Não suportado

Notificações [atualmente inevicíveis]

Se você deseja criar uma notificação na tela do usuário, pode usar o objeto tray_manager.TrayManager.notification .

Para criar uma notificação, use a função .notify() do objeto tray_manager.TrayManager.notification como a seguir:

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

Você pode especificar um atraso, após o qual a notificação será removida passando um valor em segundos para a função .notify() como remove_after_s como seguido:

 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

Você também pode usar a função .remove_notification() para remover manualmente a notificação como seguido:

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

Cuidado

Por padrão, a notificação nunca se fechará por si só, feche -a antes de criar uma nova.

Configurações avançadas

Selecionando um back -end

Se você precisar de recursos específicos, poderá definir o argumento de backend do tray_manager.TrayManager para um dos valores tray_manager.Backends .

Observação

Por padrão, o Pystray usará o melhor back -end em seu sistema operacional.

Cuidado

Você deve usar o back -end da classe tray_manager.Backends , passando o valor de um dos objetos da classe aumentará um erro.

Você também deve usar um back -end compatível com você.