+ "Ignore" rules

Author: MaxBQb

color_filter.py

@@ -47,6 +47,9 @@ def get_filter_type():
 
 
 def set_active(value):
+    if value is None:
+        return
+
     if value != is_active():
         toggle()
 

gui.py

@@ -7,7 +7,7 @@
 import utils
 from active_window_checker import WindowInfo
 from custom_gui_elements import MultiStateButton, PageSwitchController, Switcher
-from inversion_rules import InversionRule, InversionRulesController, LookForTitle
+from inversion_rules import InversionRule, InversionRulesController, LookForTitle, RuleType
 
 
 class RuleCreationWindow(guitils.BaseInteractiveWindow):
@@ -66,7 +66,7 @@ def __init__(self, winfo: WindowInfo):
         self.path_button: MultiStateButton = None
         self.title_button: MultiStateButton = None
         self.look_for_title_button: MultiStateButton = None
-        self.exclusive_rule: Switcher = None
+        self.rule_type: MultiStateButton = None
         self.remember_processes: Switcher = None
         self.name: str = None
         self.rule: InversionRule = None
@@ -106,17 +106,21 @@ def build_layout(self):
             self.ID.BUTTON_LOOK_FOR_TITLE,
             self.common_options,
         )
-        self.exclusive_rule = Switcher(
-            dict(
-                tooltip="DISABLE color inversion filter if window match",
-                button_text="EXCLUDE",
-                button_color="#2F4F4F",
-            ),
-            dict(
-                tooltip="ENABLE color inversion filter if window match",
-                button_text="INCLUDE",
-                button_color="#FF4500",
-            ),
+        self.rule_type = MultiStateButton(
+            {
+                RuleType.INCLUDE: dict(
+                    tooltip="ENABLE color inversion filter if window match",
+                    button_color="#FF4500",
+                ),
+                RuleType.EXCLUDE: dict(
+                    tooltip="DISABLE color inversion filter if window match",
+                    button_color="#8B0000",
+                ),
+                RuleType.IGNORE: dict(
+                    tooltip="DON'T CHANGE color inversion filter if window match",
+                    button_color="#2F4F4F",
+                ),
+            },
             self.ID.BUTTON_EXCLUSIVE_RULE,
             self.common_options,
         )
@@ -162,7 +166,7 @@ def build_layout(self):
                     key=self.ID.INPUT_NAME,
                     **guitils.INPUT_DEFAULTS
                 ),
-                self.exclusive_rule.button,
+                self.rule_type.button,
             ],
             [
                 sg.Text(
@@ -286,8 +290,8 @@ def set_handlers(self):
             self.look_for_title_button.event_handler
         )
         self.add_event_handlers(
-            self.exclusive_rule.key,
-            self.exclusive_rule.event_handler
+            self.rule_type.key,
+            self.rule_type.event_handler
         )
         self.add_event_handlers(
             self.remember_processes.key,
@@ -341,7 +345,7 @@ def get_keys(button, key):
             *get_keys(self.path_button, self.ID.INPUT_PATH),
             *get_keys(self.title_button, self.ID.INPUT_TITLE),
             self.look_for_title_button.selected,
-            self.exclusive_rule.selected,
+            self.rule_type.selected,
             self.remember_processes.selected
         )
         self.close()

inversion_rules.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from enum import Enum, auto
 from re import compile
-from typing import TYPE_CHECKING, TextIO
+from typing import TYPE_CHECKING, TextIO, Optional
 from commented_config import CommentsHolder, get_comments_holder
 from file_tracker import DataFileSyncer, Syncable
 
@@ -15,6 +15,12 @@ class LookForTitle(Enum):
     ROOT = auto()
 
 
+class RuleType(Enum):
+    INCLUDE = auto()
+    EXCLUDE = auto()
+    IGNORE = auto()
+
+
 @dataclass
 class InversionRule:
     """
@@ -58,11 +64,13 @@ class InversionRule:
         \t{LookForTitle.CURRENT.name} - Current window (or text element)
     """, LookForTitle.ANY.name), locals())
 
-    exclude: bool = None
-    _comments_.add(__comment_base.format("""
-        If this rule is active, 
-        then no inversion needed
-    """, "false"), locals())
+    type: RuleType = None
+    _comments_.add(__comment_base.format(f"""
+         Type of rule: {' | '.join(e.name for e in RuleType)}
+        \t{RuleType.INCLUDE.name} - if this rule is active, then inversion needed
+        \t{RuleType.EXCLUDE.name} - if this rule is active, then no inversion needed
+        \t{RuleType.IGNORE.name} - if this rule is active, then do nothing
+    """, RuleType.INCLUDE.name), locals())
 
     remember_processes: bool = None
     _comments_.add(__comment_base.format("""
@@ -74,7 +82,9 @@ def __post_init__(self):
         if self.remember_processes:
             self._pids = set()
 
-        self.exclude = self.exclude or None
+        self._type = self.type or RuleType.INCLUDE
+        if self.type == RuleType.INCLUDE:
+            self.type = None
 
         if self.path is not None:
             self.path_regex = None
@@ -91,6 +101,9 @@ def __post_init__(self):
         self._title_regex = try_compile(self.title_regex)
         self._path_regex = try_compile(self.path_regex)
 
+    def get_type(self):
+        return self._type
+
     def is_active(self, info: 'WindowInfo') -> bool:
         active = (self.check_path(info)
                   and self.check_title(info))
@@ -134,12 +147,15 @@ class InversionRulesController(Syncable):
     if no active rules found or
     if there are some excluded active rules
     Recommends to turn filter off, otherwise: on
+    if there are some ignored active rules
+    Recommends to do nothing
     """
 
     def __init__(self):
         self.rules: RULES = dict()
         self.included: RULES = dict()
         self.excluded: RULES = dict()
+        self.ignored: RULES = dict()
         super().__init__(RulesSyncer("inversion_rules", self.rules, RULES))
         self._syncer.on_file_reloaded = lambda: self.load_rules(self._syncer.data)
 
@@ -149,7 +165,7 @@ def setup(self):
 
     def load_rules(self, rules: RULES):
         self.rules = rules
-        self.included, self.excluded = dict(), dict()
+        self.included, self.excluded, self.ignored = dict(), dict(), dict()
         for name, rule in rules.items():
             self._detect_accessory(rule)[name] = rule
         self.on_rules_changed()
@@ -170,11 +186,16 @@ def remove_rules(self, names: set[str]):
         self._syncer.save_file()
         self.on_rules_changed()
 
-    def is_inversion_required(self, info: 'WindowInfo'):
-        return (
-            self.has_active_rules(info, self.included) and
-            not self.has_active_rules(info, self.excluded)
+    def is_inversion_required(self, info: 'WindowInfo') -> Optional[bool]:
+        possibilities = (
+            (self.ignored, None),
+            (self.excluded, False),
+            (self.included, True),
         )
+        for rules, result in possibilities:
+            if self.has_active_rules(info, rules):
+                return result
+        return False
 
     def has_active_rules(self, info: 'WindowInfo', rules: RULES = None):
         if rules is None:
@@ -187,9 +208,11 @@ def get_active_rules(info: 'WindowInfo', rules: RULES):
                 if rules[name].is_active(info))
 
     def _detect_accessory(self, rule: InversionRule):
-        if rule.exclude:
-            return self.excluded
-        return self.included
+        return {
+            RuleType.INCLUDE: self.included,
+            RuleType.EXCLUDE: self.excluded,
+            RuleType.IGNORE: self.ignored,
+        }.get(rule.get_type())
 
     def on_rules_changed(self):
         pass