moved utils --> libs

src/libs/settings_manager/__init__.py

@@ -0,0 +1,4 @@
+"""
+    Settings module
+"""
+from .manager import SettingsManager

src/libs/settings_manager/manager.py

@@ -0,0 +1,193 @@
+# Python imports
+import signal
+import io
+import json
+import inspect
+import zipfile
+
+from os import path
+from os import mkdir
+
+# Lib imports
+
+# Application imports
+from ..singleton import Singleton
+from .start_check_mixin import StartCheckMixin
+from .markdown_template_mixin import MarkdownTemplateMixin
+from .options.settings import Settings
+
+
+
+class MissingConfigError(Exception):
+    pass
+
+
+
+class SettingsManager(StartCheckMixin, MarkdownTemplateMixin, Singleton):
+    def __init__(self):
+        self._SCRIPT_PTH        = path.dirname(path.realpath(__file__))
+        self._USER_HOME         = path.expanduser('~')
+        self._HOME_CONFIG_PATH  = f"{self._USER_HOME}/.config/{app_name.lower()}"
+        self._USR_PATH          = f"/usr/share/{app_name.lower()}"
+        self._USR_CONFIG_FILE   = f"{self._USR_PATH}/settings.json"
+
+        self._CONTEXT_PATH      = f"{self._HOME_CONFIG_PATH}/context_path"
+        self._PLUGINS_PATH      = f"{self._HOME_CONFIG_PATH}/plugins"
+        self._DEFAULT_ICONS     = f"{self._HOME_CONFIG_PATH}/icons"
+        self._CONFIG_FILE       = f"{self._HOME_CONFIG_PATH}/settings.json"
+        self._GLADE_FILE        = f"{self._HOME_CONFIG_PATH}/Main_Window.glade"
+        self._CSS_FILE          = f"{self._HOME_CONFIG_PATH}/stylesheet.css"
+        self._KEY_BINDINGS_FILE = f"{self._HOME_CONFIG_PATH}/key-bindings.json"
+        self._PID_FILE          = f"{self._HOME_CONFIG_PATH}/{app_name.lower()}.pid"
+        self._UI_WIDEGTS_PATH   = f"{self._HOME_CONFIG_PATH}/ui_widgets"
+        self._CONTEXT_MENU      = f"{self._HOME_CONFIG_PATH}/contexct_menu.json"
+        self._WINDOW_ICON       = f"{self._DEFAULT_ICONS}/{app_name.lower()}.png"
+
+        # self._USR_CONFIG_FILE   = f"{self._USR_PATH}/settings.json"
+        # self._PLUGINS_PATH      = f"plugins"
+        # self._CONFIG_FILE       = f"settings.json"
+        # self._GLADE_FILE        = f"Main_Window.glade"
+        # self._CSS_FILE          = f"stylesheet.css"
+        # self._KEY_BINDINGS_FILE = f"key-bindings.json"
+        # self._PID_FILE          = f"{app_name.lower()}.pid"
+        # self._WINDOW_ICON       = f"{app_name.lower()}.png"
+        # self._UI_WIDEGTS_PATH   = f"ui_widgets"
+        # self._CONTEXT_MENU      = f"contexct_menu.json"
+        # self._DEFAULT_ICONS     = f"icons"
+
+
+        # with zipfile.ZipFile("files.zip", mode="r", allowZip64=True) as zf:
+        #     with io.TextIOWrapper(zf.open("text1.txt"), encoding="utf-8") as f:
+
+
+        if not path.exists(self._HOME_CONFIG_PATH):
+            mkdir(self._HOME_CONFIG_PATH)
+        if not path.exists(self._PLUGINS_PATH):
+            mkdir(self._PLUGINS_PATH)
+
+        if not path.exists(self._DEFAULT_ICONS):
+            self._DEFAULT_ICONS = f"{self._USR_PATH}/icons"
+            if not path.exists(self._DEFAULT_ICONS):
+                raise MissingConfigError("Unable to find the application icons directory.")
+        if not path.exists(self._GLADE_FILE):
+            self._GLADE_FILE   = f"{self._USR_PATH}/Main_Window.glade"
+            if not path.exists(self._GLADE_FILE):
+                raise MissingConfigError("Unable to find the application Glade file.")
+        if not path.exists(self._KEY_BINDINGS_FILE):
+            self._KEY_BINDINGS_FILE = f"{self._USR_PATH}/key-bindings.json"
+            if not path.exists(self._KEY_BINDINGS_FILE):
+                raise MissingConfigError("Unable to find the application Keybindings file.")
+        if not path.exists(self._CSS_FILE):
+            self._CSS_FILE     = f"{self._USR_PATH}/stylesheet.css"
+            if not path.exists(self._CSS_FILE):
+                raise MissingConfigError("Unable to find the application Stylesheet file.")
+        if not path.exists(self._WINDOW_ICON):
+            self._WINDOW_ICON  = f"{self._USR_PATH}/icons/{app_name.lower()}.png"
+            if not path.exists(self._WINDOW_ICON):
+                raise MissingConfigError("Unable to find the application icon.")
+        if not path.exists(self._UI_WIDEGTS_PATH):
+            self._UI_WIDEGTS_PATH  = f"{self._USR_PATH}/ui_widgets"
+        if not path.exists(self._CONTEXT_MENU):
+            self._CONTEXT_MENU  = f"{self._USR_PATH}/contexct_menu.json"
+
+
+        try:
+            with open(self._KEY_BINDINGS_FILE) as file:
+                bindings = json.load(file)["keybindings"]
+                keybindings.configure(bindings)
+        except Exception as e:
+            print( f"Settings Manager: {self._KEY_BINDINGS_FILE}\n\t\t{repr(e)}" )
+
+        try:
+            with open(self._CONTEXT_MENU) as file:
+                self._context_menu_data = json.load(file)
+        except Exception as e:
+            print( f"Settings Manager: {self._CONTEXT_MENU}\n\t\t{repr(e)}" )
+
+
+        self.settings: Settings = None
+        self._main_window       = None
+        self._builder           = None
+        self.PAINT_BG_COLOR     = (0, 0, 0, 0.0)
+
+        self._trace_debug       = False
+        self._debug             = False
+        self._dirty_start       = False
+
+
+    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 set_main_window(self, window): self._main_window  = window
+    def set_builder(self, builder) -> any:  self._builder = builder
+
+
+    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_glade_file(self)         -> str: return self._GLADE_FILE
+    def get_ui_widgets_path(self)    -> str: return self._UI_WIDEGTS_PATH
+    def get_context_menu_data(self)  -> str: return self._context_menu_data
+
+    def get_context_path(self)     -> str:   return self._CONTEXT_PATH
+    def get_plugins_path(self)     -> str:   return self._PLUGINS_PATH
+    def get_icon_theme(self)       -> str:   return self._ICON_THEME
+    def get_css_file(self)         -> str:   return self._CSS_FILE
+    def get_home_config_path(self) -> str:   return self._HOME_CONFIG_PATH
+    def get_window_icon(self)      -> str:   return self._WINDOW_ICON
+    def get_home_path(self)        -> str:   return self._USER_HOME
+
+    def is_trace_debug(self)       -> str:   return self._trace_debug
+    def is_debug(self)             -> str:   return self._debug
+
+    def call_method(self, target_class = None, _method_name = None, data = 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 set_main_window_x(self, x = 0):  self.settings.config.main_window_x  = x
+    def set_main_window_y(self, y = 0):  self.settings.config.main_window_y  = y
+    def set_main_window_width(self, width = 800):   self.settings.config.main_window_width  = width
+    def set_main_window_height(self, height = 600): self.settings.config.main_window_height = height
+    def set_main_window_min_width(self, width = 720):   self.settings.config.main_window_min_width  = width
+    def set_main_window_min_height(self, height = 480): self.settings.config.main_window_min_height = height
+
+    def set_trace_debug(self, trace_debug):
+        self._trace_debug = trace_debug
+
+    def set_debug(self, debug):
+        self._debug = debug
+
+
+    def load_settings(self):
+        if not path.exists(self._CONFIG_FILE):
+            self.settings = Settings()
+            return
+
+        with open(self._CONFIG_FILE) as file:
+            data          = json.load(file)
+            data["load_defaults"] = False
+            self.settings = Settings(**data)
+
+    def save_settings(self):
+        with open(self._CONFIG_FILE, 'w') as outfile:
+            json.dump(self.settings.as_dict(), outfile, separators=(',', ':'), indent=4)

src/libs/settings_manager/markdown_template_mixin.py

@@ -0,0 +1,60 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+
+
+
+class MarkdownTemplateMixin:
+    def wrap_html_to_body(self, html):
+        return f"""\
+<!DOCTYPE html>
+<html lang="en" dir="ltr">
+<head>
+    <meta charset="utf-8">
+    <title>Markdown View</title>
+    <style media="screen">
+        html, body {{
+            display: block;
+            background-color: #32383e00;
+            color: #ffffff;
+            text-wrap: wrap;
+        }}
+        
+        img {{
+            width: 100%;
+            height: auto;
+        }}
+        
+        code {{
+            border: 1px solid #32383e;
+            background-color: #32383e;
+            padding: 4px;
+        }}
+    </style>
+
+</head>
+<body>
+
+    {html}
+    <span>Button in WebView
+        <button onclick="say_hello()">Button in WebView</button>
+    </span>
+
+
+    <!-- For internal scripts... -->
+    <script src="js/libs/jquery-3.7.1.min.js"></script>
+
+    <!-- For Bootstrap... -->
+    <script src="resources/js/libs/bootstrap5/bootstrap.bundle.min.js"></script>
+
+    <!-- For Application... -->
+    <script src="resources/js/ui-logic.js"></script>
+    <script src="resources/js/post-ajax.js"></script>
+    <script src="resources/js/ajax.js"></script>
+    <script src="resources/js/events.js"></script>
+</body>
+</html>
+
+"""

src/libs/settings_manager/options/__init__.py

@@ -0,0 +1,8 @@
+"""
+    Options module
+"""
+from .settings import Settings
+from .config import Config
+from .filters import Filters
+from .theming import Theming
+from .debugging import Debugging

src/libs/settings_manager/options/config.py

@@ -0,0 +1,39 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+
+
+@dataclass
+class Config:
+    base_of_home: str                = ""
+    hide_hidden_files: str           = "true"
+    thumbnailer_path: str            = "ffmpegthumbnailer"
+    blender_thumbnailer_path: str    = ""
+    go_past_home: str                = "true"
+    lock_folder: str                 = "false"
+    locked_folders: list               = field(default_factory=lambda: [ "venv", "flasks" ])
+    mplayer_options: str             = "-quiet -really-quiet -xy 1600 -geometry 50%:50%",
+    music_app: str                   = "/opt/deadbeef/bin/deadbeef"
+    media_app: str                   = "mpv"
+    image_app: str                   = "mirage"
+    office_app: str                  = "libreoffice"
+    pdf_app: str                     = "evince"
+    code_app: str                    = "atom"
+    text_app: str                    = "leafpad"
+    file_manager_app: str            = "solarfm"
+    terminal_app: str                = "terminator"
+    remux_folder_max_disk_usage: str = "8589934592"
+    make_transparent: int            = 0
+    main_window_x: int               = 721
+    main_window_y: int               = 465
+    main_window_min_width: int       = 720
+    main_window_min_height: int      = 480
+    main_window_width: int           = 800
+    main_window_height: int          = 600
+    application_dirs: list           = field(default_factory=lambda: [
+        "/usr/share/applications",
+        f"{settings_manager.get_home_path()}/.local/share/applications"
+    ])

src/libs/settings_manager/options/debugging.py

@@ -0,0 +1,12 @@
+# Python imports
+from dataclasses import dataclass
+
+# Lib imports
+
+# Application imports
+
+
+@dataclass
+class Debugging:
+   ch_log_lvl: int = 10
+   fh_log_lvl: int = 20

src/libs/settings_manager/options/filters.py

@@ -0,0 +1,90 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+
+
+@dataclass
+class Filters:
+    meshs: list = field(default_factory=lambda: [
+        ".blend",
+        ".dae",
+        ".fbx",
+        ".gltf",
+        ".obj",
+        ".stl"
+    ])
+    code: list = field(default_factory=lambda: [
+        ".cpp",
+        ".css",
+        ".c",
+        ".go",
+        ".html",
+        ".htm",
+        ".java",
+        ".js",
+        ".json",
+        ".lua",
+        ".md",
+        ".py",
+        ".rs",
+        ".toml",
+        ".xml",
+        ".pom"
+    ])
+    videos: list = field(default_factory=lambda:[
+        ".mkv",
+        ".mp4",
+        ".webm",
+        ".avi",
+        ".mov",
+        ".m4v",
+        ".mpg",
+        ".mpeg",
+        ".wmv",
+        ".flv"
+    ])
+    office: list = field(default_factory=lambda: [
+        ".doc",
+        ".docx",
+        ".xls",
+        ".xlsx",
+        ".xlt",
+        ".xltx",
+        ".xlm",
+        ".ppt",
+        ".pptx",
+        ".pps",
+        ".ppsx",
+        ".odt",
+        ".rtf"
+    ])
+    images: list = field(default_factory=lambda: [
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".ico",
+        ".tga",
+        ".webp"
+    ])
+    text: list = field(default_factory=lambda: [
+        ".txt",
+        ".text",
+        ".sh",
+        ".cfg",
+        ".conf",
+        ".log"
+    ])
+    music: list = field(default_factory=lambda: [
+        ".psf",
+        ".mp3",
+        ".ogg",
+        ".flac",
+        ".m4a"
+    ])
+    pdf: list = field(default_factory=lambda: [
+        ".pdf"
+    ])

src/libs/settings_manager/options/settings.py

@@ -0,0 +1,31 @@
+# Python imports
+from dataclasses import dataclass, field
+from dataclasses import asdict
+
+# Gtk imports
+
+# Application imports
+from .config import Config
+from .filters import Filters
+from .theming import Theming
+from .debugging import Debugging
+
+
+@dataclass
+class Settings:
+    load_defaults: bool  = True
+    config: Config       = field(default_factory=lambda: Config())
+    filters: Filters     = field(default_factory=lambda: Filters())
+    theming: Theming     = field(default_factory=lambda: Theming())
+    debugging: Debugging = field(default_factory=lambda: Debugging())
+
+    def __post_init__(self):
+        if not self.load_defaults:
+            self.load_defaults = False
+            self.config        = Config(**self.config)
+            self.filters       = Filters(**self.filters)
+            self.theming       = Theming(**self.theming)
+            self.debugging     = Debugging(**self.debugging)
+
+    def as_dict(self):
+        return asdict(self)

src/libs/settings_manager/options/theming.py

@@ -0,0 +1,14 @@
+# Python imports
+from dataclasses import dataclass
+
+# Lib imports
+
+# Application imports
+
+
+@dataclass
+class Theming:
+    transparency: int  = 64
+    success_color: str = "#88cc27"
+    warning_color: str = "#ffa800"
+    error_color: str   = "#ff0000"

src/libs/settings_manager/start_check_mixin.py

@@ -0,0 +1,63 @@
+# Python imports
+import os
+import json
+import inspect
+
+# Lib imports
+
+# Application imports
+
+
+
+
+class StartCheckMixin:
+    def is_dirty_start(self) -> bool:
+        return self._dirty_start
+
+    def clear_pid(self):
+        if not self.is_trace_debug():
+            self._clean_pid()
+
+    def do_dirty_start_check(self):
+        if self.is_trace_debug():
+            pid = os.getpid()
+            self._print_pid(pid)
+            return
+
+        if os.path.exists(self._PID_FILE):
+            with open(self._PID_FILE, "r") as f:
+                pid = f.readline().strip()
+                if pid not in ("", None):
+                    if self.is_pid_alive( int(pid) ):
+                        print("PID file exists and PID is alive... Letting downstream errors (sans debug args) handle app closure propigation.")
+                        return
+
+        self._write_new_pid()
+
+    """ Check For the existence of a unix pid. """
+    def is_pid_alive(self, pid):
+        print(f"PID Found: {pid}")
+
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            print(f"{app_name} PID file exists but PID is irrelevant; starting dirty...")
+            self._dirty_start = True
+            return False
+
+        return True
+
+    def _write_new_pid(self):
+        pid = os.getpid()
+        self._write_pid(pid)
+        self._print_pid(pid)
+
+    def _print_pid(self, pid):
+        print(f"{app_name} PID:  {pid}")
+
+    def _clean_pid(self):
+        os.unlink(self._PID_FILE)
+
+    def _write_pid(self, pid):
+        with open(self._PID_FILE, "w") as _pid:
+            _pid.write(f"{pid}")