break screen: add types

Author: deltragon

safeeyes/ui/break_screen.py

@@ -20,10 +20,11 @@
 import logging
 import os
 import time
+import typing
 
 import gi
 from safeeyes import utility
-from safeeyes.model import TrayAction
+from safeeyes.model import Break, Config, TrayAction
 from safeeyes.translations import translate as _
 import Xlib
 from Xlib.display import Display
@@ -44,7 +45,15 @@ class BreakScreen:
     This class creates and manages the fullscreen windows for every monitor.
     """
 
-    def __init__(self, application, context, on_skipped, on_postponed):
+    windows: list["BreakScreenWindow"]
+
+    def __init__(
+        self,
+        application: Gtk.Application,
+        context,
+        on_skipped: typing.Callable[[], None],
+        on_postponed: typing.Callable[[], None],
+    ):
         self.application = application
         self.context = context
         self.x11_display = None
@@ -64,7 +73,7 @@ def __init__(self, application, context, on_skipped, on_postponed):
         if not self.context["is_wayland"]:
             self.x11_display = Display()
 
-    def initialize(self, config):
+    def initialize(self, config: Config) -> None:
         """Initialize the internal properties from configuration."""
         logging.info("Initialize the break screen")
         self.enable_postpone = config.get("allow_postpone", False)
@@ -84,36 +93,38 @@ def initialize(self, config):
         self.shortcut_disable_time = config.get("shortcut_disable_time", 2)
         self.strict_break = config.get("strict_break", False)
 
-    def skip_break(self):
+    def skip_break(self) -> None:
         """Skip the break from the break screen."""
         logging.info("User skipped the break")
         # Must call on_skipped before close to lock screen before closing the break
         # screen
         self.on_skipped()
         self.close()
 
-    def postpone_break(self):
+    def postpone_break(self) -> None:
         """Postpone the break from the break screen."""
         logging.info("User postponed the break")
         self.on_postponed()
         self.close()
 
-    def on_skip_clicked(self, button):
+    def on_skip_clicked(self, button) -> None:
         """Skip button press event handler."""
         self.skip_break()
 
-    def on_postpone_clicked(self, button):
+    def on_postpone_clicked(self, button) -> None:
         """Postpone button press event handler."""
         self.postpone_break()
 
-    def show_count_down(self, countdown, seconds):
+    def show_count_down(self, countdown: int, seconds: int) -> None:
         """Show/update the count down on all screens."""
         self.enable_shortcut = self.shortcut_disable_time <= seconds
         mins, secs = divmod(countdown, 60)
         timeformat = "{:02d}:{:02d}".format(mins, secs)
         GLib.idle_add(lambda: self.__update_count_down(timeformat))
 
-    def show_message(self, break_obj, widget, tray_actions=[]):
+    def show_message(
+        self, break_obj: Break, widget: str, tray_actions: list[TrayAction] = []
+    ) -> None:
         """Show the break screen with the given message on all displays."""
         message = break_obj.name
         image_path = break_obj.image
@@ -122,7 +133,7 @@ def show_message(self, break_obj, widget, tray_actions=[]):
             lambda: self.__show_break_screen(message, image_path, widget, tray_actions)
         )
 
-    def close(self):
+    def close(self) -> None:
         """Hide the break screen from active window and destroy all other
         windows.
         """
@@ -133,14 +144,24 @@ def close(self):
         # Destroy other windows if exists
         GLib.idle_add(lambda: self.__destroy_all_screens())
 
-    def __show_break_screen(self, message, image_path, widget, tray_actions):
+    def __show_break_screen(
+        self,
+        message: str,
+        image_path: typing.Optional[str],
+        widget: str,
+        tray_actions: list[TrayAction],
+    ) -> None:
         """Show an empty break screen on all screens."""
         # Lock the keyboard
         if not self.context["is_wayland"]:
             utility.start_thread(self.__lock_keyboard_x11)
 
         display = Gdk.Display.get_default()
-        monitors = display.get_monitors()
+
+        if display is None:
+            raise Exception("display not found")
+
+        monitors = typing.cast(typing.Sequence[Gdk.Monitor], display.get_monitors())
         logging.info("Show break screens in %d display(s)", len(monitors))
 
         skip_button_disabled = self.context.get("skip_button_disabled", False)
@@ -196,17 +217,22 @@ def __show_break_screen(self, message, image_path, widget, tray_actions):
 
             if self.context["is_wayland"]:
                 # this may or may not be granted by the window system
-                window.get_surface().inhibit_system_shortcuts(None)
+                surface = window.get_surface()
+                if surface is not None:
+                    typing.cast(Gdk.Toplevel, surface).inhibit_system_shortcuts(None)
 
             i = i + 1
 
-    def __update_count_down(self, count):
+    def __update_count_down(self, count: str) -> None:
         """Update the countdown on all break screens."""
         for window in self.windows:
             window.set_count_down(count)
 
-    def __window_set_keep_above_x11(self, window):
+    def __window_set_keep_above_x11(self, window: "BreakScreenWindow") -> None:
         """Use EWMH hints to keep window above and on all desktops."""
+        if self.x11_display is None:
+            return
+
         NET_WM_STATE = self.x11_display.intern_atom("_NET_WM_STATE")
         NET_WM_STATE_ABOVE = self.x11_display.intern_atom("_NET_WM_STATE_ABOVE")
         NET_WM_STATE_STICKY = self.x11_display.intern_atom("_NET_WM_STATE_STICKY")
@@ -216,7 +242,12 @@ def __window_set_keep_above_x11(self, window):
         # See https://specifications.freedesktop.org/wm-spec/1.3/ar01s05.html#id-1.6.8
         root_window = self.x11_display.screen().root
 
-        xid = GdkX11.X11Surface.get_xid(window.get_surface())
+        surface = window.get_surface()
+
+        if surface is None or not isinstance(surface, GdkX11.X11Surface):
+            return
+
+        xid = GdkX11.X11Surface.get_xid(surface)
 
         root_window.send_event(
             Xlib.protocol.event.ClientMessage(
@@ -240,11 +271,14 @@ def __window_set_keep_above_x11(self, window):
 
         self.x11_display.sync()
 
-    def __lock_keyboard_x11(self):
+    def __lock_keyboard_x11(self) -> None:
         """Lock the keyboard to prevent the user from using keyboard shortcuts.
 
         (X11 only)
         """
+        if self.x11_display is None:
+            return
+
         logging.info("Lock the keyboard")
         self.lock_keyboard = True
 
@@ -275,7 +309,9 @@ def __lock_keyboard_x11(self):
                 # Reduce the CPU usage by sleeping for a second
                 time.sleep(1)
 
-    def on_key_pressed_wayland(self, event_controller_key, keyval, keycode, state):
+    def on_key_pressed_wayland(
+        self, event_controller_key, keyval, keycode, state
+    ) -> bool:
         if self.enable_shortcut:
             if keyval == Gdk.KEY_space and self.show_postpone_button:
                 self.postpone_break()
@@ -286,14 +322,17 @@ def on_key_pressed_wayland(self, event_controller_key, keyval, keycode, state):
 
         return False
 
-    def __release_keyboard_x11(self):
+    def __release_keyboard_x11(self) -> None:
         """Release the locked keyboard."""
+        if self.x11_display is None:
+            return
+
         logging.info("Unlock the keyboard")
         self.lock_keyboard = False
         self.x11_display.ungrab_keyboard(X.CurrentTime)
         self.x11_display.flush()
 
-    def __destroy_all_screens(self):
+    def __destroy_all_screens(self) -> None:
         """Close all the break screens."""
         for win in self.windows:
             win.destroy()
@@ -309,25 +348,25 @@ class BreakScreenWindow(Gtk.Window):
 
     __gtype_name__ = "BreakScreenWindow"
 
-    lbl_message = Gtk.Template.Child()
-    lbl_count = Gtk.Template.Child()
-    lbl_widget = Gtk.Template.Child()
-    img_break = Gtk.Template.Child()
-    box_buttons = Gtk.Template.Child()
-    toolbar = Gtk.Template.Child()
+    lbl_message: Gtk.Label = Gtk.Template.Child()
+    lbl_count: Gtk.Label = Gtk.Template.Child()
+    lbl_widget: Gtk.Label = Gtk.Template.Child()
+    img_break: Gtk.Image = Gtk.Template.Child()
+    box_buttons: Gtk.Box = Gtk.Template.Child()
+    toolbar: Gtk.Box = Gtk.Template.Child()
 
     def __init__(
         self,
-        application,
-        message,
-        image_path,
-        widget,
-        tray_actions,
-        on_close,
-        show_postpone,
-        on_postpone,
-        show_skip,
-        on_skip,
+        application: Gtk.Application,
+        message: str,
+        image_path: typing.Optional[str],
+        widget: str,
+        tray_actions: list[TrayAction],
+        on_close: typing.Callable[[], None],
+        show_postpone: bool,
+        on_postpone: typing.Callable[[Gtk.Button], None],
+        show_skip: bool,
+        on_skip: typing.Callable[[Gtk.Button], None],
     ):
         super().__init__(application=application)
 
@@ -372,10 +411,10 @@ def __init__(
         self.lbl_message.set_label(message)
         self.lbl_widget.set_markup(widget)
 
-    def set_count_down(self, count):
+    def set_count_down(self, count: str) -> None:
         self.lbl_count.set_text(count)
 
-    def __tray_action(self, button, tray_action: TrayAction):
+    def __tray_action(self, button, tray_action: TrayAction) -> None:
         """Tray action handler.
 
         Hides all toolbar buttons for this action and call the action
@@ -386,7 +425,7 @@ def __tray_action(self, button, tray_action: TrayAction):
         tray_action.action()
 
     @Gtk.Template.Callback()
-    def on_window_delete(self, *args):
+    def on_window_delete(self, *args) -> None:
         """Window close event handler."""
         logging.info("Closing the break screen")
         self.on_close()