def show_alert(message, image_name):
logging.info("Show the break screen")
notification.close()
plugins_data = plugins.pre_break(context)
break_screen.show_message(message, Utility.get_resource_path(image_name), plugins_data)
if config['strict_break'] and is_active:
Utility.execute_main_thread(tray_icon.unlock_menu)
def show_notification():
"""
Receive the signal from core and pass it to the Notification.
"""
if config['strict_break']:
Utility.execute_main_thread(tray_icon.lock_menu)
plugins.pre_notification(context)
notification.show(config['pre_break_warning_time'])
def __schedule_resume(self, time_minutes):
self.idle_condition.acquire()
self.idle_condition.wait(time_minutes * 60) # Convert to seconds
self.idle_condition.release()
with self.lock:
if not self.active:
Utility.execute_main_thread(self.item_enable.activate)
def __wait_until_prepare(self):
logging.info("Wait for %d seconds before the break",
self.pre_break_warning_time)
# Wait for the pre break warning period
self.__wait_for(self.pre_break_warning_time)
if not self.running:
return
Utility.execute_main_thread(self.__fire_start_break)
def __scheduler_job(self):
"""
Scheduler task to execute during every interval
"""
if not self.__is_running():
return
time_to_wait = self.break_interval # In minutes
if self.context['postponed']:
# Reduce the break count by 1 to show the same break again
if self.break_count == 0:
self.break_count = -1
else:
self.break_count = ((self.break_count - 1) %
self.no_of_short_breaks_per_long_break)
if self.__is_long_break():
self.long_break_message_index = (
self.long_break_message_index - 1) % len(
self.long_break_exercises)
else:
self.short_break_message_index = (
self.short_break_message_index - 1) % len(
self.short_break_exercises)
# Wait until the postpone time
time_to_wait = self.postpone_duration
self.context['postponed'] = False
next_break_time = datetime.datetime.now() + datetime.timedelta(
minutes=time_to_wait)
self.update_next_break_info(next_break_time)
self.break_count = ((self.break_count + 1) %
self.no_of_short_breaks_per_long_break)
if self.__is_long_break():
self.context['break_type'] = 'long'
else:
self.context['break_type'] = 'short'
# Wait for the pre break warning period
logging.info("Pre-break waiting for {} minutes".format(time_to_wait))
self.notification_condition.acquire()
self.notification_condition.wait(time_to_wait *
60) # Convert to seconds
self.notification_condition.release()
logging.info("Pre-break waiting is over")
if not self.__is_running():
return
logging.info("Ready to show the break")
self.is_before_break = False
Utility.execute_main_thread(self.__check_active_window)
def __scheduler_job(self):
"""
Scheduler task to execute during every interval
"""
if not self.running:
return
self.context['state'] = State.WAITING
time_to_wait = self.break_interval
current_time = datetime.datetime.now()
current_timestamp = current_time.timestamp()
if self.context['postponed']:
# Previous break was postponed
logging.info('Prepare for postponed break')
time_to_wait = self.postpone_duration
self.context['postponed'] = False
elif self.paused_time > -1 and self.__is_long_break():
# Safe Eyes was paused earlier and next break is long
paused_duration = int(current_timestamp - self.paused_time)
self.paused_time = -1
if paused_duration > self.breaks[self.next_break_index].time:
logging.info(
'Skip next long break due to the pause longer than break duration'
)
# Skip the next long break
self.__select_next_break()
if current_timestamp < self.scheduled_next_break_timestamp:
time_to_wait = round(self.scheduled_next_break_timestamp -
current_timestamp)
self.scheduled_next_break_timestamp = -1
self.scheduled_next_break_time = current_time + datetime.timedelta(
seconds=time_to_wait)
Utility.execute_main_thread(self.__fire_on_update_next_break,
self.scheduled_next_break_time)
if self.__is_long_break():
self.context['break_type'] = 'long'
else:
self.context['break_type'] = 'short'
# Wait for the pre break warning period
logging.info("Waiting for %d minutes until next break",
(time_to_wait / 60))
self.__wait_for(time_to_wait)
logging.info("Pre-break waiting is over")
if not self.running:
return
self.context['new_cycle'] = self.next_break_index == 0
Utility.execute_main_thread(self.__fire_pre_break)
def start_animation(self):
if not self.active or not self.animate:
return
Utility.execute_main_thread(lambda: self.indicator.set_icon("safeeyes_disabled"))
time.sleep(0.5)
Utility.execute_main_thread(lambda: self.indicator.set_icon("safeeyes_enabled"))
if self.animate and self.active:
time.sleep(0.5)
if self.animate and self.active:
Utility.start_thread(self.start_animation)
def __schedule_resume(self, time_minutes):
"""
Schedule a local timer to enable Safe Eyes after the given timeout.
"""
self.idle_condition.acquire()
self.idle_condition.wait(time_minutes * 60) # Convert to seconds
self.idle_condition.release()
with self.lock:
if not self.active:
Utility.execute_main_thread(self.item_enable.activate)
def __set_next_break_info(self):
formatted_time = Utility.format_time(self.dateTime)
message = self.language['messages']['next_break_at'].format(
formatted_time)
# Update the tray icon label
if self.config.get('show_time_in_tray', False):
self.indicator.set_label(formatted_time, '')
else:
self.indicator.set_label('', '')
# Update the menu item label
Utility.execute_main_thread(self.item_info.set_label, message)
def __show_notification(self):
# Show the notification
self.show_notification()
logging.info("Wait for {} seconds which is the time to prepare".format(self.pre_break_warning_time))
# Wait for the pre break warning period
self.notification_condition.acquire()
self.notification_condition.wait(self.pre_break_warning_time)
self.notification_condition.release()
self.is_before_break = True
Utility.execute_main_thread(self.__check_active_window)
def __set_next_break_info(self):
"""
A private method to be called within this class to update the next break information using self.dateTime.
"""
formatted_time = Utility.format_time(self.date_time)
message = _('Next break at %s') % (formatted_time)
# Update the menu item label
Utility.execute_main_thread(self.item_info.set_label, message)
# Update the tray icon label
if self.plugin_config.get('show_time_in_tray', False):
self.indicator.set_label(formatted_time, '')
else:
self.indicator.set_label('', '')
def __evaluate_arguments(args, safe_eyes):
"""
Evaluate the arguments and execute the operations.
"""
if args.about:
Utility.execute_main_thread(safe_eyes.show_about)
elif args.disable:
Utility.execute_main_thread(safe_eyes.disable_safeeyes)
elif args.enable:
Utility.execute_main_thread(safe_eyes.enable_safeeyes)
elif args.settings:
Utility.execute_main_thread(safe_eyes.show_settings)
elif args.take_break:
Utility.execute_main_thread(safe_eyes.take_break)
def __start_break(self):
"""
Start the break screen.
"""
self.context['state'] = State.BREAK
break_obj = self.breaks[self.next_break_index]
countdown = break_obj.time
total_break_time = countdown
while countdown and self.running and not self.context[
'skipped'] and not self.context['postponed']:
seconds = total_break_time - countdown
self.on_count_down.fire(countdown, seconds)
time.sleep(1) # Sleep for 1 second
countdown -= 1
Utility.execute_main_thread(self.__fire_stop_break)
def __scheduler_job(self):
"""
Scheduler task to execute during every interval
"""
if not self.running:
return
self.context['state'] = State.WAITING
time_to_wait = self.break_interval
if self.context['postponed']:
# Wait until the postpone time
time_to_wait = self.postpone_duration
self.context['postponed'] = False
current_time = datetime.datetime.now()
current_timestamp = current_time.timestamp()
if current_timestamp < self.scheduled_next_break_time:
time_to_wait = round(self.scheduled_next_break_time -
current_timestamp)
self.scheduled_next_break_time = -1
next_break_time = current_time + datetime.timedelta(
seconds=time_to_wait)
Utility.execute_main_thread(self.__fire_on_update_next_break,
next_break_time)
if self.__is_long_break():
self.context['break_type'] = 'long'
else:
self.context['break_type'] = 'short'
# Wait for the pre break warning period
logging.info("Waiting for %d minutes until next break",
(time_to_wait / 60))
self.__wait_for(time_to_wait)
logging.info("Pre-break waiting is over")
if not self.running:
return
self.context['new_cycle'] = self.next_break_index == 0
Utility.execute_main_thread(self.__fire_pre_break)
def __take_break(self):
"""
Show the next break screen
"""
logging.info('Take a break due to external request')
with self.lock:
if not self.running:
return
logging.info("Stop the scheduler")
# Stop the break thread
self.waiting_condition.acquire()
self.running = False
self.waiting_condition.notify_all()
self.waiting_condition.release()
time.sleep(1) # Wait for 1 sec to ensure the sceduler is dead
self.running = True
Utility.execute_main_thread(self.__fire_start_break)
def __init__(self, system_locale, config):
self.active = False
self.break_screen = None
self.safe_eyes_core = None
self.config = config
self.context = {}
self.plugins_manager = None
self.settings_dialog_active = False
self.rpc_server = None
self._status = ''
# Initialize the Safe Eyes Context
self.context['version'] = SAFE_EYES_VERSION
self.context['desktop'] = Utility.desktop_environment()
self.context['locale'] = system_locale
self.context['api'] = {}
self.context['api'][
'show_settings'] = lambda: Utility.execute_main_thread(
self.show_settings)
self.context['api'][
'show_about'] = lambda: Utility.execute_main_thread(self.show_about
)
self.context['api'][
'enable_safeeyes'] = lambda next_break_time=-1: Utility.execute_main_thread(
self.enable_safeeyes, next_break_time)
self.context['api'][
'disable_safeeyes'] = lambda status: Utility.execute_main_thread(
self.disable_safeeyes, status)
self.context['api']['status'] = self.status
self.context['api']['quit'] = lambda: Utility.execute_main_thread(self.
quit)
if self.config.get('persist_state'):
self.context['session'] = Utility.open_session()
else:
self.context['session'] = {'plugin': {}}
self.break_screen = BreakScreen(self.context, self.on_skipped,
self.on_postponed,
Utility.STYLE_SHEET_PATH)
self.break_screen.initialize(self.config)
self.plugins_manager = PluginManager(self.context, self.config)
self.safe_eyes_core = SafeEyesCore(self.context)
self.safe_eyes_core.on_pre_break += self.plugins_manager.pre_break
self.safe_eyes_core.on_start_break += self.on_start_break
self.safe_eyes_core.start_break += self.start_break
self.safe_eyes_core.on_count_down += self.countdown
self.safe_eyes_core.on_stop_break += self.stop_break
self.safe_eyes_core.on_update_next_break += self.update_next_break
self.safe_eyes_core.initialize(self.config)
self.context['api'][
'take_break'] = lambda: Utility.execute_main_thread(
self.safe_eyes_core.take_break)
self.context['api']['has_breaks'] = self.safe_eyes_core.has_breaks
self.context['api']['postpone'] = self.safe_eyes_core.postpone
self.plugins_manager.init(self.context, self.config)
atexit.register(self.persist_session)
self.rpc_server = RPCServer(self.config.get('rpc_port'), self.context)
self.rpc_server.start()
def __postpone_break(self):
self.__wait_for(self.postpone_duration)
Utility.execute_main_thread(self.__fire_start_break)
def show_icon(self):
Utility.execute_main_thread(self.indicator.set_status,
appindicator.IndicatorStatus.ACTIVE)
def hide_icon(self):
Utility.execute_main_thread(self.indicator.set_status,
appindicator.IndicatorStatus.PASSIVE)
def __unlock_menu():
"""
Unlock the menu
"""
Utility.execute_main_thread(tray_icon.unlock_menu)
def __set_next_break_info(self):
formatted_time = Utility.format_time(self.dateTime)
message = self.language['messages']['next_break_at'].format(
formatted_time)
Utility.execute_main_thread(self.item_info.set_label, message)
def hide_icon(self):
"""
Hide the tray icon.
"""
Utility.execute_main_thread(self.indicator.set_status,
appindicator.IndicatorStatus.PASSIVE)
def show_icon(self):
"""
Show the tray icon.
"""
Utility.execute_main_thread(self.indicator.set_status,
appindicator.IndicatorStatus.ACTIVE)
def stop_animation(self):
self.animate = False
if self.active:
Utility.execute_main_thread(lambda: self.indicator.set_icon("safeeyes_enabled"))
else:
Utility.execute_main_thread(lambda: self.indicator.set_icon("safeeyes_disabled"))
def show_notification(): if config['strict_break']: Utility.execute_main_thread(tray_icon.lock_menu) plugins.pre_notification(context) notification.show(config['pre_break_warning_time'])
def quite(self):
"""
Uninitialize the notification. Call this method when closing the application.
"""
logging.info('Uninitialize Safe Eyes notification')
Utility.execute_main_thread(Notify.uninit)
