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 start():
import ctypes
if not ctypes.windll.shell32.IsUserAnAdmin():
script_name = sys.argv[0]
if not script_name.endswith(".py"):
script_name = "-m pylewm"
argument_str = " ".join((script_name, *sys.argv[1:]))
ctypes.windll.shell32.ShellExecuteW(None, "runas", find_pythonw_executable(), argument_str, None, 1)
sys.exit()
return
else:
# Set up registry variables for running PyleWM correctly
init_registry_vars()
pylewm.config.apply()
for fun in InitFunctions:
fun()
threading.Thread(target=key_process_thread, daemon=True).start()
global tray_icon
tray_icon = pystray.Icon('PyleWM')
png_path = os.path.join(os.path.dirname(__file__), "PyleWM.png")
tray_icon.icon = Image.open(png_path)
tray_icon.title = "PyleWM"
tray_icon.menu = pystray.Menu(
pystray.MenuItem("Open Config Directory", lambda: run_pyle_command(pylewm.execution.open_config)),
pystray.MenuItem("Restart", lambda: run_pyle_command(restart)),
pystray.MenuItem("Quit", lambda: run_pyle_command(quit)),
)
tray_icon.run()
def setIconMenu():
global icon
icon.menu = pystray.Menu(
getToggleMenu(), pystray.Menu.SEPARATOR,
pystray.MenuItem('Info', onCredits),
pystray.MenuItem('Donate', onDonate),
pystray.MenuItem('Exit ' + hv.shortcut_exit, onQuit))
def build_tray(self):
"""
Creates the system tray icon.
"""
try:
image = Image.open('kodi-icon.ico')
except FileNotFoundError:
image = Image.new('RGB', (64, 64))
menu = pystray.Menu(
pystray.MenuItem("KoDiscord v{version}".format(
version=Path('version').read_text().strip()),
self.reload_settings,
enabled=False),
pystray.MenuItem(
"Settings",
self.open_settings,
),
pystray.MenuItem("Autoboot",
self.auto_start_on_boot,
checked=lambda item: state),
pystray.MenuItem(
"Reload Settings",
self.reload_settings,
),
pystray.MenuItem("Exit", self.exit_app),
)
self._tray = pystray.Icon("KoDiscord", image, "KoDiscord", menu)
self._tray.run()
def start_tray(background_function, shutdown_function):
"""Add an tray icon and is blocking the program. Must be called from the main thread."""
global tray
def background_wrapper(icon_):
background_function()
def _stop():
"""
Stops synchronization. Tray keeps open
"""
shutdown_function()
def _close():
"""
Stops synchronization and stops the tray.
"""
shutdown_function()
stop_tray()
image = PIL.Image.open(c_paths.normalize_path(c_paths.ASSETS, "Logo.png"))
menu = pystray.Menu(pystray.MenuItem("Open", _open_gui),
pystray.MenuItem("Stop", _stop),
pystray.MenuItem("Close", _close))
tray = pystray.Icon("OpenDrive", image, "OpenDrive", menu)
tray.icon = image
tray.visible = True
tray.run(background_wrapper)
def withdraw_window(self):
self.root.withdraw()
image = Image.open(self.resource_path("mirror_assets/logo.png"))
menu = pystray.Menu(item('Quit', self.quit_window),
item('Show', self.show_window, default=True))
icon = pystray.Icon("Mirror", image, "Mirror", menu)
icon.run()
def __init__(self, title=program_settings.names['Program name']):
self.running = False
self.visible = False
# Create icon
self.icon = pystray.Icon(name=title, icon=title, title=title)
# Use provided image as icon or generate default one
try:
image = Image.open('icon.ico')
except IOError:
print("Could not find icon file")
image = None
if image is not None:
try:
self.icon.icon = image
except Exception as e:
print(e)
self.icon.icon = generate_icon()
else:
self.icon.icon = generate_icon()
# Add entries to 'right click' menu
self.icon.menu = pystray.Menu(pystray.MenuItem(text=program_settings.names['Program name'], action=lambda: None, default=True),
pystray.MenuItem(text="Capture text", action=lambda: self.capture_text()),
pystray.MenuItem(text="Exit", action=lambda: self.exit_program()))
def start_client(self, addr):
"""Start up the client app
"""
self.client = self.client_cls()
self.loop = asyncio.new_event_loop()
@net.protect_ssl(addr, retry=self.start_client)
def target(addr):
asyncio.set_event_loop(self.loop)
self.loop.run_until_complete(self.client.connect(addr))
logger.debug('Starting client thread')
self.thread = threading.Thread(target=target)
self.thread.start()
logger.debug('Updating menu')
menu = pystray.Menu(
pystray.MenuItem("pymouseshift", None),
pystray.MenuItem(f'Disconnect from {addr}', self.stop),
pystray.MenuItem("Quit", self.quit))
self.icon.menu = menu
self.icon.update_menu()
self.icon.icon = icon_filled
def run_sys_tray():
import webbrowser
import pystray
from PIL import Image
def _sys_tray_main(_icon: pystray.Icon):
_icon.visible = True
threading.Thread(target=_wait_server_ready,
args=[_open_browser]).start()
run_server()
def _open_browser():
webbrowser.open(SERVER_URL)
def _sys_tray_stop():
shutdown_server()
icon.visible = False
icon.stop()
icon = pystray.Icon(name='neteasy',
icon=Image.open('neteasy/static/image/logo-64.png'),
title='Neteasy Music Server',
menu=pystray.Menu(
pystray.MenuItem('Open',
_open_browser,
default=True),
pystray.MenuItem('Stop Server', _sys_tray_stop)))
icon.run(_sys_tray_main)
def __init__(self, title, menu):
self.activates = {i: m.get('activate', self.activate) for i, m in enumerate(menu)}
self.deactivates = {i: m.get('deactivate', self.deactivate) for i, m in enumerate(menu)}
self.menu = []
for m in menu:
item = pystray.MenuItem(
text=f'啟動 {m["title"]}',
action=self.on_clicked,
checked=lambda item: item.state
)
item.function = m.get('function', self.function)
item.activate = m.get('activate', self.activate)
item.deactivate = m.get('deactivate', self.deactivate)
if m.get('function'):
item.state = None
else:
item.state = True
self.menu.append(item)
self.icon = pystray.Icon(
title,
icon=Image.open('icon.png'),
menu=pystray.Menu(*self.menu, pystray.MenuItem(text='關閉', action=self.stop))
)
def createApp(io):
def connectToServer():
url = 'http://localhost:3333'
headers = {'usertype': 'desktop', 'password': '******'}
response = requests.get(url, headers=headers)
jsonResponse = response.json()
if (jsonResponse["status"] == 'permission accepted'):
io.connect('http://localhost:3333')
else:
print(jsonResponse["status"])
def disconnectFromServer(app):
io.disconnect()
app.stop()
connectItem = pystray.MenuItem('Conectar', connectToServer)
closeItem = pystray.MenuItem('Fechar', disconnectFromServer)
menuApp = pystray.Menu(connectItem, closeItem)
filename = abspath('assets/icon.png')
iconImage = Image.open(filename)
app = pystray.Icon('Mobile Keyboard', iconImage, menu=menuApp)
return app
def createSystemTray():
"""
Sends the script to run in the system tray.
This method runs infinitely, until the program is stopped.
"""
image = Image.open("icon-64.png")
menu = tray.Menu(
tray.MenuItem("VI Arrow Keys", lambda: 1,
enabled=False), # inactive item with the program's title
tray.MenuItem('Enabled',
trayEnabledChanged,
checked=lambda item: gstate['enabled']),
tray.MenuItem('Restart', trayRestartButton),
tray.MenuItem('Quit/Exit', lambda: gstate['icon'].stop()
), # just calls icon.stop(), steps the whole program
)
gstate['icon'] = tray.Icon(
"VI Arrow Keys", image, "VI Arrow Keys",
menu) # originally stored in "icon", stored globally though
gstate['icon'].visible = True
gstate['icon'].run(
setup=traySetup
) # this creates an infinite loops and runs forever until exit here
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 init_icon(self):
self.withdraw()
menu = []
for name, lst in engine.tray_buttons.items():
menu.append(MenuItem(name, partial(lst[0], self), **lst[1]))
self.tray_icon = pystray.Icon("AutoClicker", self.tray_ico,
"AutoClicker", pystray.Menu(*menu))
self.tray_icon.run()
def main():
image = Image.open("icon.png")
menu = pystray.Menu(
item('Clipboard Scrubber', scrub, default=True, enabled=False),
pystray.Menu.SEPARATOR, item('Exit', exit))
icon = pystray.Icon('clipboardscrubber', image, 'Clipboard Scrubber', menu)
icon.run()
def default_menu(self):
#generate all the previous servers
servers = []
for server in config['servers']:
def connect(icon, item):
self.start_client(server)
servers.append(pystray.MenuItem(server, connect))
servers.append(pystray.MenuItem("+ Add new server", self.connect))
client_menu = pystray.Menu(*servers)
return pystray.Menu(
pystray.MenuItem("pymouseshift", None),
pystray.MenuItem("Start Server", self.start_server),
pystray.MenuItem("Connect as client", client_menu),
pystray.MenuItem("Quit", self.quit),
)
def generateTrayIcon(release_func):
global icon, icon_exist
icon_exist = True
icon = pystray.Icon('Speak Screenshot')
ico = Image.open("../src/icon.ico")
icon.icon = ico
icon.menu = pystray.Menu(
pystray.MenuItem('Resume', lambda: resume(release_func)))
icon.run()
def create_menu(self):
self.menu = pystray.Menu(
pystray.MenuItem('Settings', self.launch_settings),
pystray.MenuItem(
'Enabled',
self.on_enabled,
checked=lambda item: self.enabled
),
pystray.MenuItem('Exit', self.terminate)
)
def __init__(self, config):
self.config = config
self.cwd = pathlib.WindowsPath(self.config['cwd'])
self.status = 0
# Prepare Tor
self.password = uuid.uuid4().hex
self.relay = tor.Tor(self.config['tor'], self.config['data'])
# torrc
torrc = pathlib.Path(config['data']) / 'torrc' / 'torrc'
self.torrc = torrc.resolve()
# The Onion Box
self.box = box.TheOnionBox(config)
# Stop signal, to terminate our run_loop
self.stop = threading.Event()
# the Tray icon
self.tray = pystray.Icon('theonionpack', title='The Onion Pack')
self.tray.icon = Image.open(str(self.cwd / 'icons' / 'top16.ico'))
self.tray.menu = pystray.Menu(
pystray.MenuItem('Monitor...',
action=self.on_monitor,
default=True), pystray.Menu.SEPARATOR,
pystray.MenuItem(
'Relay Control',
pystray.Menu(
pystray.MenuItem('Edit configuration file...',
action=self.on_open_torrc),
pystray.MenuItem('Show logfile...',
action=self.on_show_messages),
pystray.Menu.SEPARATOR,
pystray.MenuItem('Reload relay configuration',
action=self.on_reload_config))),
pystray.Menu.SEPARATOR,
pystray.MenuItem('Stop!', action=self.on_quit))
def create_icon():
icon = pystray.Icon('AutoMO')
icon.icon = Image.open(
os.path.join(basedir, 'app', 'static', 'images', 'icon.ico'))
icon.menu = pystray.Menu(
pystray.MenuItem('Open {}:{}'.format(SERVER_HOST, SERVER_PORT),
on_open_site,
default=True), pystray.Menu.SEPARATOR,
pystray.MenuItem('Exit', on_menu_exit))
return icon
def create_tray_icon():
def tray_exit_cb(icon):
icon.visible = False
icon.stop()
icon = pystray.Icon('cafeden')
icon.menu = pystray.Menu(
pystray.MenuItem('Exit', lambda: tray_exit_cb(icon)), )
icon.icon = Image.open(io.BytesIO(base64.b64decode(APP_ICO)))
icon.title = 'cafeden'
return icon
def __init__(self):
icon = pystray.Icon(
"KSCollector",
menu=pystray.Menu(
pystray.MenuItem(
"Enabled",
on_activate,
default=True,
checked=lambda item: self.enabled,
),
pystray.MenuItem("Quit", on_quit),
),
)
icon.icon = self.__generate_icon()
img = self.__generate_icon("yellow")
img.save("N.ico")
self.icon = icon
self.sequence = None
self.actors = []
self.stop_event = Event()
self.user = g_user
self.enabled = True
self.dnaref = ActorSystem().createActor(
DisplayNotificationActorNew, globalName="DisplayNotification")
self.datastore = ActorSystem().createActor(DataStoreActor,
globalName="DataStore")
self.downKeys = {}
self.filters = []
# Ugly hack that needs to be fixed eventually
global KSAPP
KSAPP = self
if os.path.exists('filters.ini'):
#Load the config file to get the filtered apps
cfg = configparser.ConfigParser()
cfg.read("filters.ini")
if 'Filters' in cfg:
if 'Apps' in cfg['Filters']:
apps = cfg['Filters']['Apps']
apps = list(map(lambda x: x.strip(), apps.split(',')))
for a in apps:
if a == '':
continue
self.filters.append(a)
else:
cfg = configparser.ConfigParser()
cfg['Filters'] = {'Apps': ''}
with open('filters.ini', 'w') as cfile:
cfg.write(cfile)
def __init__(self, app):
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, 'midi_keyboard_white.ico')
img = PIL.Image.open(filename, 'r')
print(filename)
pystray.Icon.__init__(self, "Miduino", img, "Miduino")
self.app = app
max_btn = pystray.MenuItem("Maximize window", self.max_win)
quit_btn = pystray.MenuItem("Quit", self.quit_app)
self.menu = pystray.Menu(max_btn, quit_btn)
def tasks_menu():
for task in self.tasks:
task_menu = pystray.Menu(
pystray.MenuItem(task.description, on_log_click(task)),
pystray.Menu.SEPARATOR,
pystray.MenuItem(f"Next run: {time_diff(task.next_run)}",
lambda: 1),
pystray.MenuItem(f"Last run: {time_diff(task.last_run)}",
on_log_click(task)),
pystray.Menu.SEPARATOR,
pystray.MenuItem("Run Now", on_run_now_click(task)),
)
yield pystray.MenuItem(task.name, task_menu)
def run_systray_icon():
icon = pystray.Icon('test name')
icon.title = APP_NAME
icon.icon = Image.open(resource_path('src/icon.png'))
icon.menu = pystray.Menu(
pystray.MenuItem(text='Options', action=open_ui, default=True),
pystray.MenuItem(text='Next photo', action=Options.set_wallpaper_next),
pystray.MenuItem(text='Previous photo',
action=Options.set_wallpaper_prev),
pystray.MenuItem(text='Random photo',
action=Options.set_wallpaper_random))
icon.run()
def main():
global all_processes, icon
multiprocessing.freeze_support()
all_processes = []
icon = pystray.Icon('test name',
Image.open(tray_icon_fp),
menu=pystray.Menu(
pystray.MenuItem('Quit', quit),
pystray.MenuItem('Refresh', reload),
pystray.MenuItem('Settings', settings_click),
))
icon.run(setup=setup)
def __init__(self):
print('starting ED watcher...')
self.terminate = False
# test if config path and file exists
Path(CONFIG_DIR).mkdir(exist_ok=True, parents=True)
if not Path(CONFIG_PATH).exists():
with open(CONFIG_PATH, 'w') as f:
f.write(
json.dumps({
'last_submitted': '',
'notifications': True,
}))
self.conf = None
try:
with open(CONFIG_PATH, 'r') as f:
self.conf = json.loads(f.read())
except:
print('ERROR: Can not parse config file.')
quit(1)
print('last submitted entry was %s' % self.conf['last_submitted'])
self.watch_file = None
self.entries_to_submit = []
self.submit_entry_lock = Lock()
self.last_submitted_lock = Lock()
self.file_watcher = None
self.notifier = ToastNotifier()
self.submit_watcher = SubmitWatcher(self.update_last_submitted,
self.notifier,
self.conf['notifications'])
t = Thread(target=self.submit_watcher.loop)
self.threads = [t]
t.start()
icon_image = Image.open(ICON_PATH)
exit_item = pystray.MenuItem(enabled=True,
text='Exit',
action=self.exit)
notification_item = pystray.MenuItem(
enabled=True,
text='Notifications',
action=self.toggle_notifications,
checked=lambda item: self.conf['notifications'])
tray_menu = pystray.Menu(exit_item, notification_item)
self.icon = pystray.Icon(name='EDWatcher',
icon=icon_image,
title="EDWatcher",
menu=tray_menu)
def interactive(msg: str):
icon = pystray.Icon("ytpldiff",
icon=_make_icon(),
title="ytpldiff",
menu=pystray.Menu(
pystray.MenuItem("continue",
lambda icon, _: icon.stop(),
default=True)))
def setup(icon):
icon.visible = True
icon.notify(msg)
icon.run(setup=setup)
def sicon_thread(self):
self._log.debug("Icon image wird gezeichnet...")
img, colors = self.image()
self._log.debug("Erstelle initales Menü...")
items: list[pystray.MenuItem] = []
items.append(pystray.MenuItem("Warte auf verbindung...", None))
items.append(pystray.Menu.SEPARATOR)
items.append(pystray.MenuItem("Beenden", self.killPluginManager))
self._menuItemsInit = tuple(items)
self._menu = pystray.Menu(*items)
self._log.debug("Beginne mit dem mainloop von pysystray...")
self._sicon = pystray.Icon("mqttScripts", icon=img, menu=self._menu)
self._sicon.run(setup=self.icon_created)
