borgend: comparison borgend/ui.py

-:8fe3cf6487f8
+:ec8014a2ee7a
 import time
 import datetime
 import logging
 import objc
 import math
-from threading import Lock, Timer
+from threading import Lock
+from Foundation import (NSDate, NSTimer, NSRunLoop, NSDefaultRunLoopMode)
+from AppKit import (NSEventTrackingRunLoopMode)
 from . import backup
 from . import dreamtime
 from . import branding
 from . import loggers
 return traynames_ok[state]
 def combine_state(a, b):
 return (max(a[0], b[0]), max(a[1], b[1]))
-# Refresh the menu at most once a second to reduce flicker
+# Refresh the menu at most twice a second
-refresh_interval=1.0
+refresh_interval=0.5
 # Workaround to rumps brokenness;
 # see https://github.com/jaredks/rumps/issues/59
 def notification_workaround(title, subtitle, message):
 try:
 else:
 title=status.name
 return title, (status.state, status.errors), this_refresh_time
+class EventTrackingTimer(rumps.Timer):
+"""
+Variant of rumps.Timer changed to
+a) use *both* NSEventTrackingRunLoopMode (for when menu open) and
+NSDefaultRunLoopMode (for when menu closed),
+b) in the mainRunLoop, to allow creating timers there from other threads.
+"""
+def start(self):
+"""Start the timer thread loop."""
+if not self._status:
+self._nsdate = NSDate.date()
+self._nstimer = NSTimer.alloc().initWithFireDate_interval_target_selector_userInfo_repeats_(
+self._nsdate, self._interval, self, 'callback:', None, True)
+NSRunLoop.mainRunLoop().addTimer_forMode_(self._nstimer, NSEventTrackingRunLoopMode)
+NSRunLoop.mainRunLoop().addTimer_forMode_(self._nstimer, NSDefaultRunLoopMode)
+#rumps._TIMERS[self] = None
+self._status = True
 class BorgendTray(rumps.App):
 def __init__(self, backups):
 self.lock=Lock()
 self.backups=backups
-self.refresh_timer=None
+self.refresh_timer=EventTrackingTimer(self.__refresh_callback, refresh_interval)
-self.refresh_timer_time=None
+self.updated_recently=False
 self.statuses=[None]*len(backups)
 for index in range(len(backups)):
 self.statuses[index]=backups[index].status()
-menu, title=self.build_menu_and_timer()
+itemlist, title=self.build_menu_and_timer()
-super().__init__(title, menu=menu, quit_button=None)
+super().__init__(title, menu=itemlist, quit_button=None)
 for index in range(len(backups)):
 # Python closures suck dog's balls; hence the _index=index hack
 # See also http://math.andrej.com/2009/04/09/pythons-lambda-is-broken/
 cb=(lambda status, errorlog=None, _index=index:
 self.__status_callback(_index, status, errorlog=errorlog))
 backups[index].set_status_update_callback(cb)
 dreamtime.add_callback(self, self.__sleepwake_callback)
-def __rebuild_menu(self):
+def __rebuild_menu(self, update):
-menu=[]
+if not update:
+self.itemlist=[]
+itemlist=self.itemlist
 state=(backup.State.INACTIVE, backup.Errors.OK)
 refresh_time=None
 all_paused=True
 for index in range(len(self.backups)):
 title, this_state, this_refresh_time=make_title(self.statuses[index])
 # Python closures suck dog's balls...
 # first and the last program I write in Python until somebody
 # fixes this brain damage
 cbm=lambda sender, _b=b: self.__menu_select_backup(sender, _b)
-item=rumps.MenuItem(title, callback=cbm)
+itemstate=0
 if not this_state[1].ok():
-item.state=-1
+itemstate=-1
 elif this_state[0]==backup.State.SCHEDULED or this_state[0]==backup.State.QUEUED:
-item.state=1
+itemstate=1
-menu.append(item)
+if update:
+item=itemlist[index]
+if item.title!=title:
+item.title=title
+if item.state!=itemstate:
+item.state=itemstate
+else:
+item=rumps.MenuItem(title, callback=cbm)
+item.state=itemstate
+itemlist.append(item)
 state=combine_state(state, this_state)
 all_paused=(all_paused and this_state[0]==backup.State.PAUSED)
 # Do we have to automatically update menu display?
 if not refresh_time:
 refresh_time=this_refresh_time
 elif this_refresh_time:
 refresh_time=min(refresh_time, this_refresh_time)
-menu_log=rumps.MenuItem("Show log", callback=lambda _: showlog())
+index = len(self.backups)
-menu.append(menu_log)
 if all_paused:
 pausename='Resume all'
 else:
 pausename="Pause all"
-menu_pause=rumps.MenuItem(pausename, callback=lambda _: self.pause_resume_all())
+if update:
-menu.append(menu_pause)
+item=itemlist[index]
+if item.title!=pausename:
-if not settings['no_quit_menu_entry']:
+item.title=pausename
-menu_quit=rumps.MenuItem("Quit...", callback=lambda _: self.quit())
+else:
-menu.append(menu_quit)
+menu_pause=rumps.MenuItem(pausename, callback=lambda _: self.pause_resume_all())
+itemlist.append(menu_pause)
-return menu, state, refresh_time
+if not update:
-def build_menu_and_timer(self):
+menu_log=rumps.MenuItem("Show log", callback=lambda _: showlog())
-if self.refresh_timer:
+itemlist.append(menu_log)
-self.refresh_timer.cancel()
+if not settings['no_quit_menu_entry']:
-self.refresh_timer=None
+menu_quit=rumps.MenuItem("Quit...", callback=lambda _: self.quit())
-self.refresh_timer_time=None
+itemlist.append(menu_quit)
+return itemlist, state, refresh_time
+def build_menu_and_timer(self, update=False):
 logger.debug('Rebuilding menu')
-menu, state, refresh_time=self.__rebuild_menu()
+itemlist, state, refresh_time=self.__rebuild_menu(update)
 title=trayname(state)
-if refresh_time:
+if update and self.title!=title:
+logger.debug("set title %s" % title)
+self.title=title
+if not self.updated_recently and not refresh_time:
+self.refresh_timer.stop()
+elif self.updated_recently:
+self.updated_recently=False
+if self.refresh_timer.interval>refresh_interval:
+self.refresh_timer.stop()
+self.refresh_timer.interval=refresh_interval
+self.refresh_timer.start()
+else:
 # Need to time a refresh due to content display changing,
 # e.g., 'tomorrow' changing to a more specific hour.
 when=time.mktime(refresh_time.timetuple())
-delay=when-time.time()
+delay=max(when-time.time(), refresh_interval)
-if delay>0:
+logger.debug('Timing menu refresh in %s seconds' % delay)
-logger.debug('Timing menu refresh in %s seconds' % delay)
+self.refresh_timer.stop()
-self.refresh_timer=Timer(delay, self.refresh_ui)
+self.refresh_timer.interval=delay
-self.refresh_timer_time=refresh_time
+self.refresh_timer.start()
-self.refresh_timer.start()
+return itemlist, title
-return menu, title
 # Callbacks -- exception-protected to get any indications of errors
 @protect_noreturn
-def refresh_ui(self):
+def __refresh_callback(self, timer):
 with self.lock:
-menu, title=self.build_menu_and_timer()
+self.build_menu_and_timer(True)
-self.menu.clear()
-self.menu.update(menu)
-self.title=title
 @protect_noreturn
 def __status_callback(self, index, status, errorlog=None):
 logger.debug("Tray status callback")
 with self.lock:
 self.statuses[index]=status
+self.updated_recently=True
 # Time the refresh if it has not been timed, or if the timer
 # is timing for the "long-term" (refresh_timer_time set)
-if not self.refresh_timer or self.refresh_timer_time:
+if self.refresh_timer.interval>refresh_interval:
-# logger.debug("Timing refresh")
+self.refresh_timer.stop()
-self.refresh_timer=Timer(refresh_interval, self.refresh_ui)
+self.refresh_timer.interval=refresh_interval
-# refresh_timer_time is only set for "long-term timers"
+self.refresh_timer.start()
-self.refresh_timer_time=None
-self.refresh_timer.start()
 # if errorlog:
 #     if 'msgid' not in errorlog or not isinstance(errorlog['msgid'], str):
 #         msgid='UnknownError'
 #     else:

Mercurial > repos > borgend / file comparison

comparison: borgend/ui.py

borgend/ui.py