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 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 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): """ 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.break_queue.get_break() countdown = break_obj.duration 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 # Convert to seconds time_to_wait = self.break_queue.get_break().time * 60 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.break_queue.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.break_queue.get_break().duration: logging.info('Skip next long break due to the pause longer than break duration') # Skip the next long break self.break_queue.next() 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) # 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 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['is_wayland'] = utility.is_wayland() 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, reset_breaks=False: \ utility.execute_main_thread(self.enable_safeeyes, next_break_time, reset_breaks) 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.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)
def __postpone_break(self): self.__wait_for(self.postpone_duration) utility.execute_main_thread(self.__fire_start_break)