initial commit

src/libs/settings/manager.py

@@ -0,0 +1,126 @@
+# Python imports
+import inspect
+import time
+
+# Lib imports
+
+# Application imports
+from ..singleton import Singleton
+from .start_check_mixin import StartCheckMixin
+
+from .path_manager import PathManager
+from .options.settings import Settings
+
+
+
+class SettingsManager(StartCheckMixin, Singleton):
+    def __init__(self):
+        self.path_manager: PathManager = PathManager()
+        self.settings: Settings        = None
+
+        self._main_window              = None
+        self._builder                  = None
+
+        self._trace_debug: bool        = False
+        self._debug: bool              = False
+        self._dirty_start: bool        = False
+        self._passed_in_file: bool     = False
+        self._starting_files: list     = []
+
+        self.PAINT_BG_COLOR: tuple     = (0, 0, 0, 0.0)
+
+        self.load_keybindings()
+        self.load_context_menu_data()
+
+
+    def get_monitor_data(self) -> list:
+        screen = self._main_window.get_screen()
+        monitors = []
+        for m in range(screen.get_n_monitors()):
+            monitors.append(screen.get_monitor_geometry(m))
+            print("{}x{}+{}+{}".format(monitor.width, monitor.height, monitor.x, monitor.y))
+
+        return monitors
+
+    def get_main_window(self)        -> any: return self._main_window
+    def get_builder(self)            -> any: return self._builder
+    def get_paint_bg_color(self)     -> any: return self.PAINT_BG_COLOR
+    def get_context_menu_data(self)  -> str: return self._context_menu_data
+
+    def get_icon_theme(self)       -> str:   return self._ICON_THEME
+    def get_starting_files(self)   -> list:  return self._starting_files
+    def get_guake_key(self)        -> tuple: return self._guake_key
+
+    def get_starting_args(self):
+        return self.args, self.unknownargs
+
+    def set_main_window(self, window): self._main_window  = window
+    def set_builder(self, builder) -> any:  self._builder = builder
+
+    def set_main_window_x(self, x: int = 0):                 self.settings.config.main_window_x  = x
+    def set_main_window_y(self, y: int = 0):                 self.settings.config.main_window_y  = y
+    def set_main_window_width(self, width: int = 800):       self.settings.config.main_window_width  = width
+    def set_main_window_height(self, height: int = 600):     self.settings.config.main_window_height = height
+    def set_main_window_min_width(self, width: int = 720):   self.settings.config.main_window_min_width  = width
+    def set_main_window_min_height(self, height: int = 480): self.settings.config.main_window_min_height = height
+    def set_starting_files(self, files: list):               self._starting_files = files
+    def set_start_load_time(self): self._start_load_time = time.perf_counter()
+    def set_end_load_time(self):   self._end_load_time   = time.perf_counter()
+
+    def set_starting_args(self, args, unknownargs):
+        self.args = args
+        self.unknownargs = unknownargs
+
+    def set_trace_debug(self, trace_debug: bool):
+        self._trace_debug = trace_debug
+
+    def set_debug(self, debug: bool):
+        self._debug = debug
+
+    def set_is_starting_with_file(self, is_passed_in_file: bool = False):
+        self._passed_in_file = is_passed_in_file
+
+    def is_trace_debug(self)       -> str:   return self._trace_debug
+    def is_debug(self)             -> str:   return self._debug
+    def is_starting_with_file(self) -> bool: return self._passed_in_file
+
+    def log_load_time(self):       logger.info( f"Load Time: {self._end_load_time - self._start_load_time}" )
+
+
+    def register_signals_to_builder(self, classes = None):
+        handlers = {}
+
+        for c in classes:
+            methods = None
+            try:
+                methods = inspect.getmembers(c, predicate = inspect.ismethod)
+                handlers.update(methods)
+            except Exception as e:
+                ...
+
+        self._builder.connect_signals(handlers)
+
+    def call_method(self, target_class: any = None, _method_name: str = "", data: any = None):
+        method_name = str(_method_name)
+        method      = getattr(target_class, method_name, lambda data: f"No valid key passed...\nkey={method_name}\nargs={data}")
+        return method(data) if data else method()
+
+    def load_keybindings(self):
+        bindings = self.path_manager.load_keybindings()
+        self._guake_key = bindings["guake_key"]
+
+        keybindings.configure(bindings)
+
+    def load_context_menu_data(self):
+        self._context_menu_data = self.path_manager.load_context_menu_data()
+
+    def load_settings(self):
+        data = self.path_manager.load_settings()
+        if not data:
+            self.settings = Settings()
+            return
+
+        self.settings = Settings(**data)
+
+    def save_settings(self):
+        self.path_manager.save_settings(self.settings)