+ Application mode feature

Current options: Do nothing | Apply inversion rules (default)

Author: MaxBQb

active_window_checker.py

@@ -14,6 +14,7 @@
 import sys
 from asyncio import to_thread
 from dataclasses import dataclass
+from enum import Enum, auto
 from functools import cached_property
 import inject
 import win32con
@@ -193,6 +194,11 @@ def listen_switch_events(callback, close_manager: AppCloseManager):
     ole32.CoUninitialize()
 
 
+class AppMode(Enum):
+    DISABLE = auto()
+    RULES = auto()
+
+
 @dataclass
 class WinTrackerSettings:
     """
@@ -205,6 +211,13 @@ class WinTrackerSettings:
        [{default!r}] Display all window switch events
     """, locals())
 
+    mode: AppMode = AppMode.RULES
+    _comments_.add(f"""
+        [{{default.name}}] How to process events: {' | '.join(e.name for e in AppMode)}
+        \t{AppMode.DISABLE.name} - Ignore all events
+        \t{AppMode.RULES.name} - Use rules to determine what to do
+    """, locals())
+
 
 class FilterStateController:
     config = inject.attr(WinTrackerSettings)
@@ -249,4 +262,8 @@ def on_active_window_switched(self,
     def update_filter_state(self, winfo: WindowInfo = None):
         if winfo is None:
             winfo = self.last_active_window
-        color_filter.set_active(self.rules.is_inversion_required(winfo))
+
+        mode = self.config.mode
+
+        if mode == AppMode.RULES:
+            color_filter.set_active(self.rules.is_inversion_required(winfo))

app_start.py

@@ -9,7 +9,7 @@
 from inversion_rules import InversionRulesController
 from main_thread_loop import MainExecutor
 from settings import UserSettings, UserSettingsController
-from tray import Tray
+from tray.tray import Tray
 
 
 class AppStartManager:

tray/__init__.py

@@ -1,39 +1,23 @@
 from asyncio import to_thread
+from traceback import print_exc
 import inject
 import win32gui
 from win32con import SW_HIDE, SW_SHOW
 import win32console
 from PIL import Image
 from pystray import Menu, MenuItem, Icon
 import _meta as app
+from active_window_checker import AppMode
+from tray.utils import ref, make_toggle, make_radiobutton
 from uac import has_admin_rights
 from app_close import AppCloseManager
 from auto_update import AutoUpdater
 from interaction import InteractionManager
 from inversion_rules import InversionRulesController
-from settings import UserSettingsController
+from settings import UserSettingsController, UserSettings, OPTION_PATH, OPTION_CHANGE_HANDLER, T
 from utils import explore, app_abs_path
 
 
-def make_toggle(out_func=None, default_value=False):
-    def decorator(func):
-        def wrapper(self):
-            value = [default_value]
-
-            def get_value(item):
-                return value[0]
-
-            def toggle():
-                value[0] ^= True
-                func(self, value[0])
-
-            return toggle, get_value
-        return wrapper
-    if out_func:
-        return decorator(out_func)
-    return decorator
-
-
 class Tray:
     settings_controller = inject.attr(UserSettingsController)
     inversion_rules = inject.attr(InversionRulesController)
@@ -56,12 +40,16 @@ def setup(self):
         win32gui.ShowWindow(self.console_hwnd, SW_HIDE)
 
     def run(self):
-        self.tray = Icon(
-            app.__product_name__,
-            Image.open(app_abs_path(app.__icon__)),
-            menu=self.build_menu()
-        )
-        self.tray.run()
+        try:
+            self.tray = Icon(
+                app.__product_name__,
+                Image.open(app_abs_path(app.__icon__)),
+                menu=self.build_menu()
+            )
+            self.tray.run()
+        except:
+            print_exc()
+            raise
 
     async def run_async(self):
         try:
@@ -82,14 +70,12 @@ def _wrapper(*ignore):
         def _open(path):
             return callback(explore, path)
 
-        def ref(text: str):
-            """
-            Make first letter underscored, also
-            mark this letter as shortcut for system tray,
-            so you may press this letter on keyboard
-            to select corresponding menu item
-            """
-            return f'&{text[0]}\u0332{text[1:]}'
+        change_mode_menu, change_mode_setter = self.change_mode()
+
+        self._link_with_settings(
+            lambda settings: settings.win_tracker.mode,
+            change_mode_setter
+        )
 
         im = self.im
         return Menu(
@@ -102,6 +88,10 @@ def ref(text: str):
                 ref("Show console"),
                 *self.toggle_console()
             ),
+            MenuItem(
+                ref("Mode"),
+                change_mode_menu
+            ),
             Menu.SEPARATOR,
             MenuItem(
                 ref('Open'),
@@ -124,7 +114,7 @@ def ref(text: str):
                     MenuItem(ref('Settings file'),
                              callback(self.settings_controller.load)),
                     MenuItem(ref('Inversion rules file'),
-                             callback(self.settings_controller.load)),
+                             callback(self.inversion_rules.load)),
                 )
             ),
             Menu.SEPARATOR,
@@ -140,9 +130,29 @@ def ref(text: str):
                      callback(self.close_manager.close)),
         )
 
+    def _link_with_settings(self,
+                            path: OPTION_PATH,
+                            handler: OPTION_CHANGE_HANDLER,):
+        def new_handler(value: T):
+            handler(value)
+            if self.tray:
+                self.tray.update_menu()
+
+        self.settings_controller.add_option_change_handler(
+            path, new_handler, True
+        )
+
     @make_toggle
     def toggle_console(self, value):
         win32gui.ShowWindow(
             self.console_hwnd,
             SW_SHOW if value else SW_HIDE
         )
+
+    @make_radiobutton({
+        AppMode.DISABLE: ref("Ignore All"),
+        AppMode.RULES: ref("According with rules"),
+    }, AppMode.RULES)
+    def change_mode(self, value: AppMode):
+        self.settings_controller.settings.win_tracker.mode = value
+        self.settings_controller.save()

tray.py tray/tray.pytray.py renamed to tray/tray.py

@@ -0,0 +1,56 @@
+from enum import Enum
+from typing import Type, Hashable
+
+from pystray import Menu, MenuItem
+
+
+def ref(text: str):
+    """
+    Make first letter underscored, also
+    mark this letter as shortcut for system tray,
+    so you may press this letter on keyboard
+    to select corresponding menu item
+    """
+    return f'&{text[0]}\u0332{text[1:]}'
+
+
+def make_toggle(out_func=None, default_value=False):
+    def decorator(func):
+        def wrapper(self):
+            value = [default_value]
+
+            def get_value(item):
+                return value[0]
+
+            def toggle():
+                value[0] ^= True
+                func(self, value[0])
+
+            return toggle, get_value
+        return wrapper
+    if out_func:
+        return decorator(out_func)
+    return decorator
+
+
+def make_radiobutton(values: dict[Hashable, str],
+                     default_value=None,
+                     ):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            value_ref = [default_value or next(iter(values))]
+
+            def change(value):
+                value_ref[0] = value
+                func(*args, value=value_ref[0], **kwargs)
+
+            return Menu(*[
+                MenuItem(
+                    name,
+                    lambda *_, value=value: change(value),
+                    lambda *_, value=value: value_ref[0] == value,
+                    True
+                ) for value, name in values.items()
+            ]), change
+        return wrapper
+    return decorator