psgtray.py

import pystray, io, base64, threading, time
from PIL import Image
import PySimpleGUI as sg

"""
    A System Tray Icon implementation that can work with the tkinter port of PySimpleGUI!

    To use, add this import to your code:
    from psgtray import SystemTray
    
    Make sure the psgtray.py file is in the same folder as your app or is on your Python path

    Because this code is entirely in the user's space it's possible to use the pystray package
    to implement the system tray icon feature.  You need to install pystray and PIL.
    
    As of this date, the latest version of pystray is 0.17.3
    
    This code works well under Windows.
    
    On Linux there are some challenges.  Some changes were
    needed in order to get pystray to run as a thread using gtk as the backend.
    The separator '---' caused problems so it is now ignored.  Unknown why it caused the
    menu to not show at all, but it does.

    A sample bit of code is at the bottom for your reference.
    
    Your window will receive events from the system tray thread.
    
    In addition to the init, these are the class methods available:
        change_icon
        hide_icon
        show_icon
        set_tooltip
        notify
        
    In your code, you will receive events from tray with key SystemTray.key
    The value will be the choice made or a click event.  This is the magic statement:
        window.write_event_value(tray.key, item.text)
        
    Extra Special thanks to FireDM for the design pattern that made this work.
    (https://github.com/firedm/FireDM)
    Copyright 2021 PySimpleGUI
"""


class SystemTray:
    DOUBLE_CLICK_THRESHOLD = 500  # time in milliseconds to determine double clicks
    DEFAULT_KEY = '-TRAY-'          # the default key that will be used to send events to your window
    key_counter = 0

    def __init__(self, menu=None, icon=None, tooltip='', single_click_events=False, window=None, key=DEFAULT_KEY):
        """
        A System Tray Icon

        Initializing the object is all that is required to make the tray icon and start the thread.

        :param menu: The PySimpleGUI menu data structure
        :type menu: List[List[Tuple[str, List[str]]]
        :param icon: Icon to show in the system tray.  Can be a file or a BASE64 byte string
        :type icon: str | bytes
        :param tooltip: Tooltip that is shown when mouse hovers over the system tray icon
        :type tooltip: str
        :param single_click_events: If True then both single click and double click events will be generated
        :type single_click_events: bool
        :param window: The window where the events will be sent using window.write_event_value
        :type window: sg.Window
        """
        self.title = tooltip
        self.tray_icon = None  # type: pystray.Icon
        self.window = window
        self.tooltip = tooltip
        self.menu_items = self._convert_psg_menu_to_tray(menu[1])
        self.key = key if SystemTray.key_counter == 0 else key+str(SystemTray.key_counter)
        SystemTray.key_counter += 1
        self.double_click_timer = 0
        self.single_click_events_enabled = single_click_events
        if icon is None:
            self.icon = sg.DEFAULT_BASE64_ICON
        else:
            self.icon = icon

        self.thread_started = False
        self.thread = threading.Thread(target=self._pystray_thread, daemon=True)
        self.thread.start()
        while not self.thread_started:      # wait for the thread to begin
            time.sleep(.2)
        time.sleep(.2)                      # one more slight delay to allow things to actually get running

    def change_icon(self, icon=None):
        """
        Change the icon shown in the tray to a file or a BASE64 byte string.
        :param icon: The icon to change to
        :type icon: str | bytes
        """
        if icon is not None:
            self.tray_icon.icon = self._create_image(icon)

    def hide_icon(self):
        """
        Hides the icon
        """
        self.tray_icon.visible = False

    def show_icon(self):
        """
        Shows a previously hidden icon
        """
        self.tray_icon.visible = True

    def set_tooltip(self, tooltip):
        """
        Set the tooltip that is shown when hovering over the icon in the system tray
        """
        self.tray_icon.title = tooltip

    def show_message(self, title=None, message=None):
        """
        Show a notification message balloon in the system tray
        :param title: Title that is shown at the top of the balloon
        :type title: str
        :param message: Main message to be displayed
        :type message: str
        """
        self.tray_icon.notify(title=str(title) if title is not None else '', message=str(message) if message is not None else '')

    def close(self):
        """
        Whlie not required, calling close will remove the icon from the tray right away.
        """
        self.tray_icon.visible = False      # hiding will close any message bubbles that may hold up the removal of icon from tray
        self.tray_icon.stop()

    # --------------------------- The methods below this point are not meant to be user callable ---------------------------
    def _on_clicked(self, icon, item: pystray.MenuItem):
        self.window.write_event_value(self.key, item.text)

    def _convert_psg_menu_to_tray(self, psg_menu):
        menu_items = []
        i = 0
        if isinstance(psg_menu, list):
            while i < len(psg_menu):
                item = psg_menu[i]
                look_ahead = item
                if i != (len(psg_menu) - 1):
                    look_ahead = psg_menu[i + 1]
                if not isinstance(item, list) and not isinstance(look_ahead, list):
                    disabled = False
                    if item == sg.MENU_SEPARATOR_LINE:
                        item = pystray.Menu.SEPARATOR
                    elif item.startswith(sg.MENU_DISABLED_CHARACTER):
                        disabled = True
                        item = item[1:]
                    if not (item == pystray.Menu.SEPARATOR and sg.running_linux()):
                        menu_items.append(pystray.MenuItem(item, self._on_clicked, enabled=not disabled, default=False))
                elif look_ahead != item:
                    if isinstance(look_ahead, list):
                        if menu_items is None:
                            menu_items = pystray.MenuItem(item, pystray.Menu(*self._convert_psg_menu_to_tray(look_ahead)))
                        else:
                            menu_items.append(pystray.MenuItem(item, pystray.Menu(*self._convert_psg_menu_to_tray(look_ahead))))
                i += 1
        # important item - this is where clicking the icon itself will go
        menu_items.append(pystray.MenuItem('default', self._default_action_callback, enabled=True, default=True, visible=False))

        return menu_items

    def _default_action_callback(self):
        delta = (time.time() - self.double_click_timer) * 1000
        if delta < self.DOUBLE_CLICK_THRESHOLD:  # if last click was recent, then this click is a double-click
            self.window.write_event_value(self.key, sg.EVENT_SYSTEM_TRAY_ICON_DOUBLE_CLICKED)
            self.double_click_timer = 0
        else:
            if self.single_click_events_enabled:
                self.window.write_event_value(self.key, sg.EVENT_SYSTEM_TRAY_ICON_ACTIVATED)
            self.double_click_timer = time.time()

    def _pystray_thread(self):
        self.tray_icon = pystray.Icon(self.title, self._create_image(self.icon))
        self.tray_icon.default_action = self._default_action_callback
        self.tray_icon.menu = pystray.Menu(*self.menu_items)
        self.tray_icon.title = self.tooltip  # tooltip for the icon
        self.thread_started = True
        self.tray_icon.run()

    def _create_image(self, icon):
        if isinstance(icon, bytes):
            buffer = io.BytesIO(base64.b64decode(icon))
            img = Image.open(buffer)
        elif isinstance(icon, str):
            img = Image.open(icon)
        else:
            img = None
        return img


# MM""""""""`M                                       dP
# MM  mmmmmmmM                                       88
# M`      MMMM dP.  .dP .d8888b. 88d8b.d8b. 88d888b. 88 .d8888b.
# MM  MMMMMMMM  `8bd8'  88'  `88 88'`88'`88 88'  `88 88 88ooood8
# MM  MMMMMMMM  .d88b.  88.  .88 88  88  88 88.  .88 88 88.  ...
# MM        .M dP'  `dP `88888P8 dP  dP  dP 88Y888P' dP `88888P'
# MMMMMMMMMMMM                              88
#                                           dP
# M""MMMMM""M
# M  MMMMM  M
# M  MMMMM  M .d8888b. .d8888b.
# M  MMMMM  M Y8ooooo. 88ooood8
# M  `MMM'  M       88 88.  ...
# Mb       dM `88888P' `88888P'
# MMMMMMMMMMM


def main():
    # This example shows using TWO tray icons together

    menu = ['', ['Show Window', 'Hide Window', '---', '!Disabled Item', 'Change Icon', ['Happy', 'Sad', 'Plain'], 'Exit']]
    tooltip = 'Tooltip'

    layout = [[sg.Text('My PySimpleGUI Window with a Tray Icon - X will minimize to tray')],
              [sg.Text('Note - you are running a file that is meant to be imported')],
              [sg.T('Change Icon Tooltip:'), sg.Input(tooltip, key='-IN-', s=(20,1)), sg.B('Change Tooltip')],
              [sg.Multiline(size=(60,10), reroute_stdout=False, reroute_cprint=True, write_only=True, key='-OUT-')],
              [sg.Button('Go'), sg.B('Hide Icon'), sg.B('Show Icon'), sg.B('Hide Window'), sg.B('Close Tray'), sg.Button('Exit')]]

    window = sg.Window('Window Title', layout, finalize=True, enable_close_attempted_event=True)


    tray1 = SystemTray(menu, single_click_events=False, window=window, tooltip=tooltip, icon=sg.DEFAULT_BASE64_ICON)
    tray2 = SystemTray(menu, single_click_events=False, window=window, tooltip=tooltip, icon=sg.EMOJI_BASE64_HAPPY_JOY)
    time.sleep(.5)      # wait just a little bit since TWO are being started at once
    tray2.show_message('Started', 'Both tray icons started')

    while True:
        event, values = window.read()
        print(event, values)
        # IMPORTANT step. It's not required, but convenient.
        # if it's a tray event, change the event variable to be whatever the tray sent
        # This will make your event loop homogeneous with event conditionals all using the same event variable
        if event in (tray1.key, tray2.key):
            sg.cprint(f'System Tray Event = ', values[event], c='white on red')
            tray = tray1 if event == tray1.key else tray2
            event = values[event]       # use the System Tray's event as if was from the window
        else:
            tray = tray1                # if wasn't a tray event, there's still a tray varaible used, so default to "first" tray created

        if event in (sg.WIN_CLOSED, 'Exit'):
            break

        sg.cprint(event, values)
        tray.show_message(title=event, message=values)
        tray.set_tooltip(values['-IN-'])

        if event in ('Show Window', sg.EVENT_SYSTEM_TRAY_ICON_DOUBLE_CLICKED):
            window.un_hide()
            window.bring_to_front()
        elif event in ('Hide Window', sg.WIN_CLOSE_ATTEMPTED_EVENT):
            window.hide()
            tray.show_icon()        # if hiding window, better make sure the icon is visible
            # tray.notify('System Tray Item Chosen', f'You chose {event}')
        elif event == 'Happy':
            tray.change_icon(sg.EMOJI_BASE64_HAPPY_JOY)
        elif event == 'Sad':
            tray.change_icon(sg.EMOJI_BASE64_FRUSTRATED)
        elif event == 'Plain':
            tray.change_icon(sg.DEFAULT_BASE64_ICON)
        elif event == 'Hide Icon':
            tray.hide_icon()
        elif event == 'Show Icon':
            tray.show_icon()
        elif event == 'Close Tray':
            tray.close()
        elif event == 'Change Tooltip':
            tray.set_tooltip(values['-IN-'])

    tray1.close()
    tray2.close()
    window.close()


if __name__ == '__main__':
    # Normally this file is not "run"
    main()