def setPreferences(self):
# make menu items for a list of times and add them to the menu
# changing times here won't affect the original times, will have to
# redefine in callbacks too
titleUpdateTimes = [
rumps.MenuItem(time, callback=self.onTitleTimeClick)
for time in ['5 sec', '10 sec', '30 sec', '60 sec']
]
marketsUpdateTimes = [
rumps.MenuItem(time, callback=self.onMarketsTimeClick)
for time in ['30 min', '1 hour', '2 hours', 'on startup only']
]
self.menu.add(rumps.MenuItem('Price update time'))
self.menu['Price update time'].update(titleUpdateTimes)
self.menu.add(rumps.MenuItem('Markets update time'))
self.menu['Markets update time'].update(marketsUpdateTimes)
self.menu['Price update time'][self.title_update_time.__str__() +
' sec'].state = 1
if (self.markets_update_time == 1800):
self.menu['Markets update time']['30 min'].state = 1
elif (self.markets_update_time == 3600):
self.menu['Markets update time']['1 hour'].state = 1
elif (self.markets_update_time == 7200):
self.menu['Markets update time']['2 hours'].state = 1
else:
self.menu['Markets update time']['on startup only'] = 1
def insert_folder_into_menu(self, folder, path):
keys = [x for i, x in enumerate(self.folders.keys()) if i > 2]
menu = rumps.MenuItem(folder,
callback=self.make_folder_callback(folder, path))
def callback(sender):
folders = self.settings.get("folders", {})
if folder in folders.keys() and folder in self.folders.keys():
del self.folders[folder]
del folders[folder]
self.settings = {'folders': folders}
self.notify('Deleted', subtitle=folder)
remove_menu = rumps.MenuItem("Delete", callback=callback)
menu.add(remove_menu)
keys.append(folder)
key_to_use = None
for key in sorted(keys, key=lambda k: str(k).lower()):
if key == folder:
break
key_to_use = key
if key_to_use:
self.folders.insert_after(key_to_use, menu)
else:
self.folders.add(menu)
def main():
"""
Main application.
"""
global app, app_path, username, password, toggle_setting, info
logger.info('Reading config')
config_parser = ConfigParser.SafeConfigParser()
with open(CONF_TEMPLATE_PATH.format(app_path, APP_CONF), 'rb') as config_file:
config_parser.readfp(config_file)
username = config_parser.get(CONF_DEFAULT_SECTION, CONF_USERNAME)
password = config_parser.get(CONF_DEFAULT_SECTION, CONF_PASSWORD)
toggle_setting = config_parser.get(CONF_DEFAULT_SECTION, CONF_TOGGLE)
logger.info('Username: '******'Toggle setting: ' + toggle_setting)
refresh_menu = rumps.MenuItem(title=REFRESH_MENU,
callback=refresh_callback,
icon=ICONS_TEMPLATE_PATH.format(app_path, REFRESH_ICON),
dimensions=(16, 16))
toggle_menu = rumps.MenuItem(title=TOGGLE_MENU,
callback=toggle_callback)
app = rumps.App(APP_NAME,
icon=ICONS_TEMPLATE_PATH.format(app_path, APP_ICON),
menu=(refresh_menu, toggle_menu, None))
logger.info('Running')
app.title = APP_NAME
app.menu[TOGGLE_MENU].title = TOGGLE_TEMPLATE.format(_toggle(toggle_setting))
app.run()
def insert_extension_into_menu(self, extension, parent):
keys = [x for i, x in enumerate(parent.keys())
if i > 2] # The number of non-extension menus at the top
menu = rumps.MenuItem(extension,
callback=self.make_toggle_of_extension(
extension, parent.title))
menu.state = self.fs.extensions[parent.title][0][extension]
def callback(sender):
if self.fs.delete_extension_from_group(parent.title, extension):
del parent[extension]
self.notify('Extension Deleted', subtitle=parent.title)
remove_menu = rumps.MenuItem("Delete", callback=callback)
menu.add(remove_menu)
keys.append(extension)
key_to_use = None
for key in sorted(keys):
if key == extension:
break
key_to_use = key
if key_to_use:
parent.insert_after(key_to_use, menu)
else:
parent.add(menu)
def render_menu(self):
quit_button = self.menu.get('Quit')
self.menu.clear()
self.menu.add(
rumps.MenuItem(self.ABOUT,
lambda _: webbrowser.open(self.GITHUB_ULR)))
self.menu.add(self.render_settings_item())
self.menu.add(rumps.separator)
# Active jobs sorted by created time
jobs = sorted(
self.client.get_active_jobs(),
key=lambda it: datetime.fromisoformat(it.history.created_at))
if jobs:
for job in jobs:
self.menu.add(self.render_job_item(job))
else:
self.menu.add(rumps.MenuItem('No active jobs'))
self.menu.add(rumps.separator)
self.menu.add(rumps.MenuItem('Create job...', self.create_job))
self.menu.add(self.render_presets_item())
self.menu.add(rumps.separator)
self.menu.add(quit_button)
def addPortItem(self, parent, item_dict, namespace):
names = item_dict.keys()
names.sort()
for name in names:
rmi = rumps.MenuItem('/%s' % name)
rmi.port = namespace + name
parent.add(rmi)
# add children
if item_dict[name]:
self.addPortItem(rmi, item_dict[name], namespace + name + '/')
# or add a callback function
else:
if 'yarpTab' not in namespace:
rmi.set_callback(self.callPort)
# create sub menus
rmiIO = rumps.MenuItem('Image Output', self.callIO)
rmiIO.port = namespace + name
rmi.add(rmiIO)
rmiTO = rumps.MenuItem('Text Output', self.callTO)
rmiTO.port = namespace + name
rmi.add(rmiTO)
rmiTI = rumps.MenuItem('Text Input', self.callTI)
rmiTI.port = namespace + name
rmi.add(rmiTI)
def __init__(self):
self.config = {
'app_name': 'Virtual School Controller',
'join_class_title': 'Class Options'
}
self.app = rumps.App(self.config['app_name'], '📅')
self.text = rumps.MenuItem(None)
self.pauseButton = rumps.MenuItem(title='Pause', callback=self.pause)
self.app.menu.add(self.text)
self.app.menu.add(None)
self.app.menu.add(
rumps.MenuItem(title=self.config['join_class_title']))
self.app.menu.add(None)
self.app.menu.add(self.pauseButton)
self.app.menu.add(
rumps.MenuItem(title="Set config file path",
callback=self.set_config_path))
self.links = {}
global weekDays
global schoolController
schoolController = self
self.update()
def preferences_menu_item(self):
return {
'Preferences': [
rumps.MenuItem('Edit', callback=self.hook_open_preferences),
rumps.MenuItem('Reload', callback=self.hook_reload_preferences)
]
}
def __init__(self):
self.config = {
"app_name": "Pomodoro",
"start": "Bắt Đầu 🏁",
"pause": "Tạm Dừng ⏸",
"continue": "Tiếp Tục ▶️",
"stop": "Dừng Lại 🛑",
"break_message": "25 phút đã trôi qua! +1 🍅",
"interval": 1500,
"reset_round": "Đặt Lại Số Lượt 🍅",
"work_mode": "Tập Trung 💪",
"rest_mode": "Giải Lao 💤"
}
self.round = 0
self.app = rumps.App(self.config["app_name"])
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.count = 0
self.interval = self.config["interval"]
self.start_pause_button = rumps.MenuItem(title=self.config["start"],
callback=self.start_timer)
self.stop_button = rumps.MenuItem(title=self.config["stop"],
callback=None)
self.set_up_menu()
self.is_in_mode = self.config["work_mode"]
self.reset_round_button = rumps.MenuItem(
title=self.config["reset_round"], callback=self.reset_round)
self.mode_button = rumps.MenuItem(title=self.config["rest_mode"],
callback=self.rest)
self.app.menu = [
self.start_pause_button, self.stop_button, self.reset_round_button,
self.mode_button
]
def _start_event(self):
self.debug(f"Inserting data into database \
{self.key_input.text()} as command\
{self.paste_input.text()} as key")
keypaste = Keypaste(
self.key_input.text(),
self.paste_input.text()
)
try:
self.pickle.append_and_reload(keypaste)
except KeyPasteException:
self.debug("Key is already in there")
self.window.close()
self.debug("Successfully ran query into database")
self.debug("Updating app with new entries")
pastes = self.menu.get("Pastes")
if not self.copy_clipboard:
self.debug("Config says to use write to screen")
menu_add = rumps.MenuItem(
title=keypaste.get_command(),
callback=keypaste.write
)
else:
self.debug("Config says to copy to buffer")
menu_add = rumps.MenuItem(
title=keypaste.get_command(),
callback=keypaste.copy_to_clipboard
)
pastes.add(menu_add)
self.debug("Killing Entry app cause operation is done")
self.window.close()
def __init__(self, timer_interval=1):
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.stop() # timer running when initialized
self.timer.count = 0
self.app = rumps.App("Timebox", "🥊")
self.start_pause_button = rumps.MenuItem(title='Start Timer',
callback=lambda _: self.start_timer(_, self.interval))
self.stop_button = rumps.MenuItem(title='Stop Timer',
callback=None)
self.buttons = {}
self.buttons_callback = {}
for i in [5, 10, 15, 20, 25]:
title = str(i) + ' Minutes'
callback = lambda _, j=i: self.set_mins(_, j)
self.buttons["btn_" + str(i)] = rumps.MenuItem(title=title, callback=callback)
self.buttons_callback[title] = callback
self.interval = get_things_min()*SEC_TO_MIN
self.button_things = rumps.MenuItem(title="Things Interval ("+str(round(self.interval/SEC_TO_MIN))+"min)", callback=lambda _: self.set_things_mins(_))
self.button_things.state = True
self.app.menu = [
self.start_pause_button,
None,
self.button_things,
None,
*self.buttons.values(),
None,
self.stop_button]
def post_history_menu_options():
mgdl = rumps.MenuItem('mg/dL', callback=choose_units_mgdl)
mgdl.state = not config.get_use_mmol()
mmol = rumps.MenuItem('mmol/L', callback=choose_units_mmol)
mmol.state = config.get_use_mmol()
open_ns_url = rumps.MenuItem('Open Nightscout site...', callback=None)
if config.get_host():
open_ns_url.set_callback(open_nightscout_url)
items = [
None,
[
'Settings',
[
mgdl,
mmol,
None,
rumps.MenuItem('Set Nightscout URL...', callback=configuration_window),
rumps.MenuItem('Help...', callback=open_project_homepage),
None,
"Version {}".format(VERSION)
],
],
None,
open_ns_url,
None,
]
return items
def __init__(self):
super().__init__("AirConnectMenu", title=off)
locations = []
# create cached if it doesn't exit otherwise parse
if not cached.parent.exists():
cached.parent.mkdir(parents=True)
if not cached.exists():
cached.touch()
with open(cached) as fp:
for line in fp.readlines():
loc = parseip(line)
if loc is not None:
locations.append(loc)
self.locations = locations
self.previous = rumps.MenuItem('Previous')
self.menu.add(self.previous)
self.menu.add(
rumps.MenuItem(title='New Server IP', callback=self.serverip))
self.menu.add(rumps.MenuItem(title='Stop', callback=self.stop))
self.menu.add(rumps.separator)
self.setMenus()
self.connected = False
def __init__(self, timer_interval=1):
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.stop() # timer running when initialized
self.timer.count = 0
self.app = rumps.App("Raindrop", "🍅")
self.start_pause_button = rumps.MenuItem(
title='Start Timer',
callback=lambda _: self.start_timer(_, self.interval))
self.stop_button = rumps.MenuItem(title='Stop Timer', callback=None)
self.buttons = {}
self.buttons_callback = {}
for i in [5, 10, 15, 20, 25]:
title = str(i) + ' Minutes'
callback = lambda _, j=i: self.set_mins(_, j)
self.buttons["btn_" + str(i)] = rumps.MenuItem(title=title,
callback=callback)
self.buttons_callback[title] = callback
self.interval = 5 * SEC_TO_MIN # current 5 min by default
self.buttons['btn_5'].state = True
self.app.menu = [
self.start_pause_button,
None,
# self.button_things,
# None,
*self.buttons.values(),
None,
self.stop_button
]
def create_country_listing(self, country):
data = self.get_country_data(country.title)
for k, v in data.items():
self.app.menu.add(rumps.MenuItem(self.string_mapper(k, v)))
current_time = datetime.datetime.now().strftime("%H:%M")
self.app.menu.add(rumps.MenuItem(title=f"Updated at {current_time}"))
self.timer = rumps.Timer(self.on_update, self.update_interval)
self.timer.start()
def __init__(self):
self.app = rumps.App("twenny")
self.timer = rumps.Timer(self.ticker, 1)
self.interval = 1200
self.bau_menu()
self.start_knopf = rumps.MenuItem(title="Start Timer", callback=self.start_timer)
self.stopuhr = rumps.MenuItem(title="20:00")
self.app.menu = [self.stopuhr, self.start_knopf]
def load_all_sessions(self):
"""This method is for initializing the sessions from the init function."""
session_names = self.get_session_names()
for name in session_names:
load_item = rumps.MenuItem(name, callback=self.load_session)
delete_item = rumps.MenuItem(name, callback=self.delete_session)
self.load_menu.append(load_item)
self.delete_menu.append(delete_item)
def setup(self, province_list, default_province):
for province in province_list:
self.provinces.add(
rumps.MenuItem(title=f"{province}",
callback=self.update_province_listing))
self.create_province_listing(
rumps.MenuItem(title=f"{self.default_province}"))
def __init__(self):
super(Pomodoro, self).__init__("20Twenty20",icon="data/icon.tiff")
self.work_menu = rumps.MenuItem("work", callback=self.work)
self.rest_menu = rumps.MenuItem("rest",callback=None)
self.menu = [self.work_menu, self.rest_menu, None]
self.alarm_time = [int(i) * 60 for i in Flags.notice_interval]
self.time_idx = 0
self.mainloopStart()
def setup(self, country_list, default_country):
for country in country_list:
self.countries.add(
rumps.MenuItem(title=f"{country}",
callback=self.update_country_listing))
self.create_country_listing(
rumps.MenuItem(title=f"{self.default_country}"))
def __init__(self):
self.app = rumps.App("BaconPaper", "🥓")
self.set_up_menu()
self.changeFromURLButton = rumps.MenuItem(title="Change From URL",
callback=self.changeFromURL)
self.changeFromFileButton = rumps.MenuItem(
title="Change From File", callback=self.changeFromFile)
self.app.menu = [self.changeFromURLButton, self.changeFromFileButton]
def __init__(self):
self.app = rumps.App("Strainy the Elf", icon='normal_eye.ico')
self.interval_minutes = 20
self.last_break = datetime.strftime(datetime.now(), '%d %B %Y %I:%M%p')
self.next_break = datetime.strftime(datetime.now() + timedelta(minutes=self.interval_minutes), '%d %B %Y %I:%M%p')
self.menu = self.app.menu = [
rumps.MenuItem('Back from break'),
rumps.MenuItem(f"Next break @ {self.next_break.split()[-1]}"),
]
def insert_unload_reload(ar: rumps.MenuItem, j: launchd.LaunchdJob):
print(j.plistfilename)
ar.add(
rumps.MenuItem("Unload",
callback=lambda x: launchd.unload(j.plistfilename)))
ar.add(
rumps.MenuItem("Reload",
callback=lambda x: launchd.unload(j.plistfilename) and
launchd.load(j.plistfilename)))
def insert_log_menu_items(ar: rumps.MenuItem, ag):
log = ag['StandardOutPath']
log_cb = lambda x: subprocess.call(["open", "-a", "Console", log])
err = ag['StandardErrorPath']
err_cb = lambda x: subprocess.call(["open", "-a", "Console", err])
ar.add(rumps.separator)
ar.add(rumps.MenuItem("View Log", callback=log_cb if log else None))
ar.add(rumps.MenuItem("View Error Log", callback=err_cb if err else None))
ar.add(rumps.separator)
def __init__(self):
su = StatusUtility()
self.app = rumps.App("SystemId", "ℹ️")
self.app.title = "ℹ️ " + su.get_hostname()
self.open_panel_button = rumps.MenuItem(title="Show Panel", callback=self.manage_floating_window)
self.user_button = rumps.MenuItem(title=su.get_user())
self.uptime_button = rumps.MenuItem(title=su.get_uptime())
self.ip_button = rumps.MenuItem(title=su.get_ip())
self.app.menu = [self.open_panel_button, None, self.user_button, self.uptime_button, self.ip_button, None]
def __init__(self):
super(UnplugMe, self).__init__("UnplugMe")
self.icon = '/Users/januszpolowczyk/Documents/StatusBarApp/icons/charging_station.png'
self.menu.add(rumps.MenuItem(title = "Charge: "))
self.menu.add(rumps.MenuItem(title = "Current Threshold: 85%"))
self.menu.add(rumps.MenuItem(title = "Plugged in: "))
self.menu.add(rumps.MenuItem(title = "Change Threshold"))
self.menu.add(rumps.separator)
self.menu.add(rumps.MenuItem(title = "About"))
self.battery = psutil.sensors_battery()
def create_province_listing(self, province):
# print("Creating")
data = self.get_province_data(province.title)
for k, v in data.items():
self.app.menu.add(rumps.MenuItem(self.string_mapper(k, v)))
current_time = datetime.datetime.now().strftime("%H:%M")
self.app.menu.add(rumps.MenuItem(title=f"Updated at {current_time}"))
# print("Created")
self.timer = rumps.Timer(self.on_update, self.update_interval)
self.timer.start()
def __init__(self):
super(App, self).__init__("🍺")
self.menu.add(rumps.MenuItem(title='Version: 1.0'))
self.menu.add(rumps.MenuItem(title='Updated:'))
self.menu.add(rumps.MenuItem(title='Install Program'))
self.menu.add(rumps.MenuItem(title='Update All'))
self.menu.add(rumps.separator)
self.menu.add(rumps.MenuItem(title='Info'))
self.bm = BrewManager()
self.scraper = Scraper()
self.get_last_refresh()
def __init__(self, app):
super().__init__(Menus.time_period())
self.app = app
self[TimePeriods.today()] = rumps.MenuItem(
TimePeriods.today(), callback=self._set_time_period)
# HACK: would love a cleaner way to do this default menu setting
self[TimePeriods.today()].state = MenuState.on()
self[TimePeriods.this_week()] = rumps.MenuItem(
TimePeriods.this_week(), callback=self._set_time_period)
self[TimePeriods.this_month()] = rumps.MenuItem(
TimePeriods.this_month(), callback=self._set_time_period)
def __init__(self):
self.config = {
"app_name": "My Todos",
}
self.app = rumps.App(self.config["app_name"])
self.app.quit_button = None
self.app.title = "💻"
self.quit_button = rumps.MenuItem(title="Quit 👋🏻")
self.refresh_button = rumps.MenuItem(title="Refresh ⚡️",
callback=self.get_data)
self.get_data(BOOTSTRAP)
