def __init__(self):
self.__main_gui = None
self.__notifier = sh.Command("/usr/bin/notify-send")
self.__running = True
self.__updater = threading.Thread(target=self.__update_loop)
self.__scheduler = sched.scheduler(time.time, time.sleep)
self.__config = config.AppConfig('dnfdragora')
self.__updateInterval = 180
if self.__config.systemSettings:
settings = {}
if 'settings' in self.__config.systemSettings.keys():
settings = self.__config.systemSettings['settings']
if 'update_interval' in settings.keys():
self.__updateInterval = int(settings['update_interval'])
if self.__config.userPreferences:
if 'settings' in self.__config.userPreferences.keys():
settings = self.__config.userPreferences['settings']
if 'interval for checking updates' in settings.keys():
self.__updateInterval = int(
settings['interval for checking updates'])
icon_path = '/usr/share/icons/hicolor/128x128/apps/dnfdragora.png'
try:
self.__backend = dnfdaemon.client.Client()
except dnfdaemon.client.DaemonError as error:
print(_('Error starting dnfdaemon service: [%s]'), str(error))
sys.exit(1)
try:
from gi.repository import Gtk
icon_theme = Gtk.IconTheme.get_default()
icon_path = icon_theme.lookup_icon("dnfdragora", 128,
0).get_filename()
except:
pass
self.__icon = Image.open(icon_path)
self.__menu = Menu(
MenuItem(_('Update'), self.__run_update),
MenuItem(_('Open dnfdragora dialog'), self.__run_dnfdragora),
MenuItem(_('Check for updates'), self.__get_updates_forced),
MenuItem(_('Exit'), self.__shutdown))
self.__name = 'dnfdragora-updater'
self.__tray = Tray(self.__name, self.__icon, self.__name, self.__menu)
def generateProfilesMenu(self):
result = [
MenuItem(_('New Profile'), self._redirectTo(self._newProfile))
]
for profile in ProxyTrayConfig.getProfiles():
result.append(
MenuItem(
profile['name'],
Menu(lambda: (MenuItem(
_('Apply'),
self._redirectTo(self._applyProfile, profile['name'])),
MenuItem(
_('Edit'),
self._redirectTo(self._modifyProfile,
profile['name']))))))
return result
def run(self):
# not supported on mac
if config.operating_system == 'Darwin':
log('Systray is not supported on mac yet')
return
options_map = {
'Show': self.show_main_window,
'Minimize to Systray': self.minimize_to_systray,
'Quit': self.quit
}
# make our own Gtk statusIcon, since pystray failed to run icon properly on Gtk 3.0 from a thread
if config.operating_system == 'Linux':
try:
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
self.Gtk = Gtk
def icon_right_click(icon, button, time):
menu = Gtk.Menu()
for option, callback in options_map.items():
item = Gtk.MenuItem(label=option)
item.connect('activate', callback)
menu.append(item)
menu.show_all()
menu.popup(None, None, None, icon, button, time)
icon = Gtk.StatusIcon()
icon.set_from_file(self.tray_icon_path)
icon.connect("popup-menu", icon_right_click)
icon.connect('activate', self.show_main_window)
self.active = True
Gtk.main()
return
except:
self.active = False
# let pystray decide which icon to run
try:
from pystray import Icon, Menu, MenuItem
items = []
for option, callback in options_map.items():
items.append(
MenuItem(option,
callback,
default=True if option == 'Show' else False))
menu = Menu(*items)
self.icon = Icon('PyIDM', self.tray_icon, menu=menu)
self.active = True
self.icon.run()
except Exception as e:
log('systray: - run() - ', e)
self.active = False
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 init_icon():
icon = pystray.Icon('Status')
icon.menu = Menu(
MenuItem('Available', lambda: ButtonClickAvail(User)),
MenuItem('Webex', lambda: ButtonClickWebex(User)),
MenuItem('Logs/ESRS', lambda: ButtonClickLogs(User)),
MenuItem('No Bandwidth', lambda: ButtonClickNoBW(User)),
MenuItem('Away', lambda: ButtonClickAway(User)),
MenuItem('In Call', lambda: ButtonClickIncall(User)),
MenuItem('Out of office', lambda: ButtonClickOOO(User)),
)
icon.icon = Image.open(resource_path('./images/icon.png'))
icon.title = 'Status Update'
def setup(icon):
icon.visible = True
app = IsilonStatus()
app.mainloop()
# while icon.visible==True:
# flags, hcursor, (prevx,prevy) = win32gui.GetCursorInfo()
# self.after(1000 * 10, self.inactive(prevx, prevy))
icon.run(setup)
return icon
def main():
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s', level=logging.INFO)
logging.info('URL Trimmer boot!')
global thread
thread = ClipboardThread(WindowsTextClipboard(), DEFAULT_FILTERS)
logging.info('Starting clipboard thread')
thread.start()
image = Image.open('icon.png')
icon = Icon('URL Trimmer', icon=image, menu=Menu(
MenuItem('Settings', lambda icon, item: None),
MenuItem('Exit', close_app)
))
logging.info('Starting system tray icon')
icon.run()
def add(self, text: str, selected: bool = False):
index: int = len(self.items)
if selected: RadioButtonGroup.state = index
btn: MenuItem = MenuItem(text=text,
action=RadioButtonGroup.set_state(index),
checked=RadioButtonGroup.get_state(index),
radio=True)
self.items.append(btn)
return btn
def init_icon():
icon = pystray.Icon('Network downtime detector')
icon.menu = Menu(MenuItem('Exit', lambda: exit_action(icon)))
icon.icon = create_image(down, "Start", 12, white)
icon.title = 'Network downtime detector'
icon.run(setup)
def __init__(self):
self.cs = CapSwitch()
#Run CapSwitch when it is opened
self.init_thread(target=self.cs.start_listener)
# *** Attributes ***
self.icon_path = "icon.png"
# *** Setup Menu ***
self.menu_items = [
MenuItem(self.check_status, self.toggle),
MenuItem("Exit", self.exit),
]
self.menu = Menu(*self.menu_items)
# *** Create System Tray Icon ***
self.icon = Icon("CapSwitch", menu=self.menu)
self.icon.icon = Image.open(self.icon_path)
self.icon.run()
def start(self):
def on_clicked(icon, _):
logging.info('[APP] Closing. Source: TrayIcon')
states.running = False
icon.stop()
def clicked_display(_, item):
states.displayed = item.checked
tray_icon = Icon('chesscord',
title='chesscord',
icon=Image.open(RESOURCES_DIR / 'logo.png'))
tray_icon.menu = Menu(
MenuItem('update config', utils.open_webpage),
MenuItem('hide',
clicked_display,
checked=lambda item: not states.displayed),
MenuItem('Exit', on_clicked))
tray_icon.run()
def run(self):
def get_wrapper(command):
def wrapper():
self.r_queue.put((command, None))
return wrapper
def die():
self.icon_stop()
menu_items = [
MenuItem("Show Console", get_wrapper("show_console")),
MenuItem("Application Menu", get_wrapper("open_player_menu")),
MenuItem("Open Config Folder", get_wrapper("open_config_brs")),
MenuItem("Quit", die)
]
icon = Icon(APP_NAME, menu=Menu(*menu_items))
icon.icon = Image.open(icon_file)
self.icon_stop = icon.stop
icon.run()
self.r_queue.put(("die", None))
def add_button(
self,
text: str,
action: Callable,
args=None,
default: bool = False,
checked: Callable[[Any], bool] = lambda icon: False) -> MenuItem:
self.add(btn := MenuItem(text=text,
action=lambda: action(*(args or ())),
default=default,
checked=checked))
return btn
def __init__(self, config):
self.config = config
self.proxySettings = config.proxySettings
self.proxySettings.onChangedMode(self._changedProxyMode)
self.iconNoProxy = Image.open(
os.path.abspath(self.config.path + '/icons/no_proxy.png'))
self.iconProxyMan = Image.open(
os.path.abspath(self.config.path + '/icons/proxy_man.png'))
self.iconProxyAuto = Image.open(
os.path.abspath(self.config.path + '/icons/proxy_auto.png'))
self.menu = Menu(lambda: (
MenuItem(self.modeLabel, None, enabled=False), Menu.SEPARATOR,
MenuItem(_('Deactivate Proxy'),
self._redirectTo(self._noProxy),
enabled=not self.mode.isNone()),
MenuItem(_('Activate Manual Proxy'),
self._redirectTo(self._proxyMan),
enabled=not self.mode.isManual()),
MenuItem(_('Activate Automatic Proxy'),
self._redirectTo(self._proxyAuto),
enabled=not self.mode.isAuto()), Menu.SEPARATOR,
MenuItem(_('Proxy Profiles'),
Menu(lambda: self.generateProfilesMenu())), Menu.
SEPARATOR, MenuItem(_('Exit Tray'), self._redirectTo(self.quit))))
self.profileEditor = ProfileEditor(self.config)
self.profileEditor.onSaveCallback(self.update_menu)
self.profileEditor.onDeleteCallback(self.update_menu)
self.pystray = Icon('ProxyTray', self.iconProxyMan, menu=self.menu)
self._refreshProxyMode()
self.pystray.run()
def __init__(self, icon, menu=[], exit=None, schedule=None):
self.icon = pystray.Icon("mon")
self.icon.title = "Tooltip"
self.icon.icon = Image.open(icon)
self.schedule = schedule
menu.append(("Exit", lambda: self.exit()))
menu_items = []
for name, action in menu:
menu_items.append(MenuItem(name, action))
self.icon.menu = Menu(*menu_items)
if exit:
self.exit = exit
def create_commands(commands_dict):
def create_callable(command):
def run(*_):
# you probably want to replace this with
# the subprocess module later:
os.system(command)
return run
commands = [
MenuItem(text, create_callable(command), default=default)
for text, command, default in COMMANDS
]
return commands
def tray():
global icon, thread
icon = None
thread = None
name = 'ED - Autopilot'
icon = Icon(name=name, title=name)
logo = Image.open(resource_path('src/logo.png'))
icon.icon = logo
icon.menu = Menu(MenuItem('Exit', lambda: exit_action()), )
keyboard.add_hotkey('home', start_action)
keyboard.add_hotkey('end', stop_action)
icon.run(setup)
def configure_systray():
def setup(icon):
icon.visible = True
def exit_action(icon):
icon.visible = False
icon.stop()
os._exit(1)
image = Image.open(os.path.join("images", "snappy_systray.png"))
icon = Icon("snappy", icon=image, title="snappy")
menu = Menu(MenuItem("exit", lambda: exit_action(icon)))
icon.menu = menu
icon.run(setup)
def add_menu_item(
self,
text: str = None,
action: Callable = None,
menu_item: 'MenuItem' = None,
index: int = None,
**kwargs,
):
"""
Add a menu item byt passing its text and function, or pass a created MenuItem. Force position by sending index
"""
if not any(v for v in (menu_item, text)):
raise ValueError(f"Either 'text' or 'menu_item' are required")
menu_item = menu_item or MenuItem(text=text, action=action, **kwargs)
if index is not None:
self.menu_items.insert(index, menu_item)
else:
self.menu_items.append(menu_item)
def run(self):
# not supported on mac
if config.operating_system == 'Darwin':
log('Systray is not supported on mac yet')
return
options_map = {'Show': self.show_main_window,
'Minimize to Systray': self.minimize_to_systray,
'Quit': self.quit}
# make our own Gtk statusIcon, since pystray failed to run icon properly on Gtk 3.0 from a thread
if config.operating_system == 'Linux':
try:
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
self.Gtk = Gtk
# delete previous icon file (it might contains an icon file for old firedm versions)
delete_file(self.tray_icon_path)
# save file to settings folder
self.tray_icon.save(self.tray_icon_path, format='png')
# creating menu
menu = Gtk.Menu()
for option, callback in options_map.items():
item = Gtk.MenuItem(label=option)
item.connect('activate', callback)
menu.append(item)
menu.show_all()
APPINDICATOR_ID = config.APP_NAME
# setup notify system, will be used in self.notify()
gi.require_version('Notify', '0.7')
from gi.repository import Notify as notify
self.Gtk_notify = notify # get reference for later deinitialize when quit systray
self.Gtk_notify.init(APPINDICATOR_ID) # initialize first
# try appindicator
try:
gi.require_version('AppIndicator3', '0.1')
from gi.repository import AppIndicator3 as appindicator
indicator = appindicator.Indicator.new(APPINDICATOR_ID, self.tray_icon_path, appindicator.IndicatorCategory.APPLICATION_STATUS)
indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
indicator.set_menu(menu)
# use .set_name to prevent error, Gdk-CRITICAL **: gdk_window_thaw_toplevel_updates: assertion 'window->update_and_descendants_freeze_count > 0' failed
indicator.set_name = APPINDICATOR_ID
# can set label beside systray icon
# indicator.set_label('1.2 MB/s', '')
self.active = True
log('Systray active backend: Gtk.AppIndicator')
Gtk.main()
return
except:
pass
# try GTK StatusIcon
def icon_right_click(icon, button, time):
menu.popup(None, None, None, icon, button, time)
icon = Gtk.StatusIcon()
icon.set_from_file(self.tray_icon_path) # DeprecationWarning: Gtk.StatusIcon.set_from_file is deprecated
icon.connect("popup-menu", icon_right_click) # right click
icon.connect('activate', self.show_main_window) # left click
icon.set_name = APPINDICATOR_ID
self.active = True
log('Systray active backend: Gtk.StatusIcon')
Gtk.main()
return
except Exception as e:
log('Systray Gtk 3.0:', e, log_level=2)
self.active = False
else:
# let pystray run for other platforms, basically windows
try:
from pystray import Icon, Menu, MenuItem
items = []
for option, callback in options_map.items():
items.append(MenuItem(option, callback, default=True if option == 'Show' else False))
menu = Menu(*items)
self.icon = Icon(config.APP_NAME, self.tray_icon, menu=menu)
self.active = True
self.icon.run()
except Exception as e:
log('systray: - run() - ', e)
self.active = False
def on_launch_app(icon, item):
print("LAUNCHING APP FROM : ", config.get('path', f'app_{sys.platform}'))
subprocess.Popen(config.get('path', f'app_{sys.platform}'))
icon = Icon(
'Mist ERP',
Image.open(resource_path(f'assets{os.sep}icons{os.sep}favicon.ico')),
menu=Menu(
MenuItem(
"Launch APP",
on_launch_app,
default=True,
enabled=True,
visible=True
)
)
)
def run_systray_app():
logging.debug('initialize icon')
global icon
icon.run()
@atexit.register
def stop_app_process():
def __init__(self, worker: Worker):
# save worker reference
self._worker = worker
# create the icon
self._icon = Icon("Mover")
# set the image
self._icon.icon = MOVER_ICON
# set actions
# - set source
# - set destination
# - number of backlogs
# - start/stop
# - exit
self._start_stop = MenuItem("Start", self.on_start_stop,
enabled=False) # initial state
self._set_source = MenuItem("Set Source", self.on_set_source)
self._set_destination = MenuItem("Set Destination",
self.on_set_destination)
self._number_of_backlogs = MenuItem(
"Number of Backlogs",
Menu(
MenuItem("Immediate",
partial(self.on_number_of_backlogs_changed, 0)),
MenuItem("5", partial(self.on_number_of_backlogs_changed, 5)),
MenuItem("10", partial(self.on_number_of_backlogs_changed,
10)),
MenuItem("25", partial(self.on_number_of_backlogs_changed,
25)),
),
)
self._timeout = MenuItem(
'Timeout',
Menu(MenuItem('Never', partial(self.on_timeout_changed, 0)),
MenuItem('30 s', partial(self.on_timeout_changed, 30))))
self._exit = MenuItem("Exit", self.on_exit)
self._icon.menu = Menu(
self._start_stop,
Menu.SEPARATOR,
self._set_source,
self._set_destination,
self._number_of_backlogs,
Menu.SEPARATOR,
self._exit,
)
def item_checkable():
return MenuItem(
'Checkable',
on_clicked,
checked=lambda item: state
)
info('Ответ!')
signal.signal(signal.SIGKILL, signal.SIG_DFL)
# Создаем инстанс приложения
from os.path import join, abspath
from os import getcwd
app = Icon('Quantify',
Image.open(
join(
getcwd() if system() == 'Windows' else
abspath(__file__).replace(join('uis', 'universal.py'), ''),
'assets', 'toolbar_icon.png')),
menu=Menu(
MenuItem(text='Мышь',
action=on_clicked,
checked=lambda x: config.get_value('mouse')),
MenuItem(text='Клавиатура',
action=on_clicked,
checked=lambda x: config.get_value('keyboard')
if system() != 'Darwin' else False,
enabled=system() != 'Darwin'),
MenuItem(text='Процессы',
action=on_clicked,
checked=lambda x: config.get_value('processes')),
MenuItem(text='Другое',
action=Menu(
MenuItem(text='Получить код 2FA',
action=get_auth_code)))))
def setup(icon: Icon):
icon.visible = True
is_up_to_date = True
while True:
output = []
wrong_output = []
# TODO: Please do it better...
repos, wrong_paths = utils.get_repos_and_wrong_paths(args.file)
if wrong_paths:
wrong_output.extend(["", "Those directories does not exist:"])
for path in wrong_paths:
wrong_output.append(f"- {path}")
for repo in repos:
if repo_is_up_to_date(repo):
continue
text = f"- {repo.path} ({repo.branch})"
repo.can_ff = can_do_fast_forward(repo)
if repo.can_ff:
text += " [FF]"
output.append(text)
was_up_to_date = is_up_to_date
is_up_to_date = not bool(output)
if is_up_to_date:
_icon = icon_ok
_items = [
MenuItem("All existing repositories are up to date",
action=void)
]
else:
_icon = icon_fail
_items = [MenuItem(f"{MESSAGE}:", action=void)] + [
MenuItem(f"{text}", action=void) for text in output
]
if any(repo.can_ff for repo in repos):
_items.extend([
MenuItem("", action=void),
MenuItem(
text=
"Pull changes for fast forwardable repositories marked with [FF]",
action=pull_changes_for_list_of_repos(repos),
),
])
if was_up_to_date:
n = Notifier()
n.send_notification(output + wrong_output)
if wrong_paths:
_items.extend(
[MenuItem(f"{text}", action=void) for text in wrong_output])
_menu = Menu(*_items)
icon.icon = _icon
icon.menu = _menu
time.sleep(args.delay)
_items.extend([
MenuItem("", action=void),
MenuItem(
text=
"Pull changes for fast forwardable repositories marked with [FF]",
action=pull_changes_for_list_of_repos(repos),
),
])
if was_up_to_date:
n = Notifier()
n.send_notification(output + wrong_output)
if wrong_paths:
_items.extend(
[MenuItem(f"{text}", action=void) for text in wrong_output])
_menu = Menu(*_items)
icon.icon = _icon
icon.menu = _menu
time.sleep(args.delay)
menu = Menu(MenuItem(text="Checking repositories...", action=void))
icon = Icon(name=MESSAGE, icon=icon_loading, menu=menu)
icon.run(setup)
image = Image.new('RGB', (width, height))
dc = ImageDraw.Draw(image)
dc.ellipse((0, 0, 120, 120), fill='red')
dc.ellipse((20, 20, 100, 100), fill='blue')
dc.ellipse((40, 40, 80, 80), fill='green')
def turnOnOrOff(icon, item):
global ambientOn
ambientOn = not item.checked
if ambientOn:
ambientOnEvent.set()
else:
ambientOnEvent.clear()
icon = Icon(
"Ambient RGB Light", image, "Ambient RGB Light",
Menu(
MenuItem('Ambient On',
action=turnOnOrOff,
checked=lambda item: ambientOn)))
def iconCallback(icon):
icon.visible = True
main()
icon.run(iconCallback)
# Called after icon is set up due to threading issues.
spotify_helper = SpotifyHelper()
def run_spotify_helper(icon_callback):
try:
icon_callback.visible = True
spotify_helper.run()
except Exception as e:
logging.error('{}:{}'.format(e, traceback.format_exc()))
traceback.print_exc()
def stop_program(icon_callback):
icon_callback.stop()
spotify_helper.stop()
icon_image = Image.open(
os.path.join(os.path.dirname(__file__), 'resources/spo.png'))
icon = Icon('spotify-helper',
icon_image,
menu=Menu(
MenuItem(text='Edit bindings', action=open_bindings_file),
Menu.SEPARATOR,
MenuItem(text='Quit', action=lambda: stop_program(icon)),
))
# After icon starts running, we start the keyboard listener thread (together with the main
# Spotify Helper code), since on macOS pystray won't work if pynput runs first, as the latter seems
# to call a Mac _MainThread function which pystray then tries to call again but is not allowed - running
# pystray first seems to be ok though.
icon.run(setup=run_spotify_helper)
def update_menu():
global icon
try:
icon.menu = Menu(
MenuItem('Messages(s) : '+str(nb_of_msgs_to_read), lambda : display_browser('https://www.koreus.com/modules/mpmanager/msgbox.php')),
MenuItem('Notification(s) : '+str(nb_of_notifs), lambda : display_browser('https://www.koreus.com/notifs.php')),
MenuItem('Article(s) : '+str(new_art), lambda : display_browser('https://www.koreus.com/modules/news/')),
Menu.SEPARATOR,
MenuItem('Paramètre', Menu( MenuItem('Paramètres avancés', lambda : threading.Thread(target=parametrer_wnd).start()),
Menu.SEPARATOR,
MenuItem('%s'%("Ne plus afficher les notifications" if show else "Réafficher les notifications"), able_notif),
MenuItem('%s'%("Ne plus afficher les erreurs" if show_wrong else "Réafficher les erreurs"), show_error),
Menu.SEPARATOR,
MenuItem( 'Activer la connexion Test non-sécurisée %s'%("(En cours)" if parameters[0] else ""), lambda:mod_parameters(1,0,0), enabled=1-parameters[0]),
MenuItem( 'Activer la connexion Firefox sécurisée %s'%("(En cours)" if parameters[1] else ""), lambda:mod_parameters(0,1,0), enabled=1-parameters[1]),
MenuItem( 'Activer la connexion Chrome sécurisée %s'%("(En cours)" if parameters[2] else ""), lambda:mod_parameters(0,0,1), enabled=1-parameters[2]))),
MenuItem('%s'%("Déconnexion" if pwd else "Connexion"), lambda : redeconnexion()),
MenuItem('Quitter', lambda : exit_action(icon)),
)
except:
traceback.print_exc()
def item_quit():
return MenuItem(
'Quit',
on_quit
)
def run_webview():
window = webview.create_window('Webview',
'https://pywebview.flowrl.com/hello')
webview.start()
if __name__ == '__main__':
def start_webview_process():
global webview_process
webview_process = Process(target=run_webview)
webview_process.start()
def on_open(icon, item):
global webview_process
if not webview_process.is_alive():
start_webview_process()
def on_exit(icon, item):
icon.stop()
start_webview_process()
image = Image.open('logo/logo.png')
menu = Menu(MenuItem('Open', on_open), MenuItem('Exit', on_exit))
icon = Icon('Pystray', image, menu=menu)
icon.run()
webview_process.terminate()
