" Classes Method and Functions for lx Apps " import signal import base64 from contextlib import contextmanager from .logger import app_logger from subprocess import CompletedProcess, run import gettext import locale import re import sys import shutil import tkinter as tk from tkinter import ttk import os from typing import Optional, Dict, Any, NoReturn from pathlib import Path class CryptoUtil: """ This class is for the creation of the folders and files required by Wire-Py, as well as for decryption the tunnel from the user's home directory """ @staticmethod def decrypt(user) -> None: """ Starts SSL dencrypt """ process: CompletedProcess[str] = run( ["pkexec", "/usr/local/bin/ssl_decrypt.py", "--user", user], capture_output=True, text=True, check=False, ) # Output from Openssl Error if process.stderr: app_logger.log(process.stderr) if process.returncode == 0: app_logger.log("Files successfully decrypted...") else: app_logger.log( f"Error process decrypt: Code {process.returncode}" ) @staticmethod def encrypt(user) -> None: """ Starts SSL encryption """ process: CompletedProcess[str] = run( ["pkexec", "/usr/local/bin/ssl_encrypt.py", "--user", user], capture_output=True, text=True, check=False, ) # Output from Openssl Error if process.stderr: app_logger.log(process.stderr) if process.returncode == 0: app_logger.log("Files successfully encrypted...") else: app_logger.log( f"Error process encrypt: Code {process.returncode}" ) @staticmethod def find_key(key: str = "") -> bool: """ Checks if the private key already exists in the system using an external script. Returns True only if the full key is found exactly (no partial match). """ process: CompletedProcess[str] = run( ["pkexec", "/usr/local/bin/match_found.py", key], capture_output=True, text=True, check=False, ) if "True" in process.stdout: return True elif "False" in process.stdout: return False app_logger.log( f"Unexpected output from the external script:\nSTDOUT: {process.stdout}\nSTDERR: {process.stderr}" ) return False @staticmethod def is_valid_base64(key: str) -> bool: """ Validates if the input is a valid Base64 string (WireGuard private key format). Returns True only for non-empty strings that match the expected length. """ # Check for empty string if not key or key.strip() == "": return False # Regex pattern to validate Base64: [A-Za-z0-9+/]+={0,2} base64_pattern = r"^[A-Za-z0-9+/]+={0,2}$" if not re.match(base64_pattern, key): return False try: # Decode and check length (WireGuard private keys are 32 bytes long) decoded = base64.b64decode(key) if len(decoded) != 32: # 32 bytes = 256 bits return False except Exception as e: app_logger.log(f"Error on decode Base64: {e}") return False return True class LxTools: """ Class LinuxTools methods that can also be used for other apps """ def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) @staticmethod def center_window_cross_platform(window, width, height): """ Centers a window on the primary monitor in a way that works on both X11 and Wayland Args: window: The tkinter window to center width: Window width height: Window height """ # Calculate the position before showing the window # First attempt: Try to use GDK if available (works on both X11 and Wayland) try: import gi gi.require_version("Gdk", "3.0") from gi.repository import Gdk display = Gdk.Display.get_default() monitor = display.get_primary_monitor() or display.get_monitor(0) geometry = monitor.get_geometry() scale_factor = monitor.get_scale_factor() # Calculate center position on the primary monitor x = geometry.x + (geometry.width - width // scale_factor) // 2 y = geometry.y + (geometry.height - height // scale_factor) // 2 # Set window geometry window.geometry(f"{width}x{height}+{x}+{y}") return except (ImportError, AttributeError): pass # Second attempt: Try xrandr for X11 try: import subprocess output = subprocess.check_output( ["xrandr", "--query"], universal_newlines=True ) # Parse the output to find the primary monitor primary_info = None for line in output.splitlines(): if "primary" in line: parts = line.split() for part in parts: if "x" in part and "+" in part: primary_info = part break break if primary_info: # Parse the geometry: WIDTH x HEIGHT+X+Y geometry = primary_info.split("+") dimensions = geometry[0].split("x") primary_width = int(dimensions[0]) primary_height = int(dimensions[1]) primary_x = int(geometry[1]) primary_y = int(geometry[2]) # Calculate center position on the primary monitor x = primary_x + (primary_width - width) // 2 y = primary_y + (primary_height - height) // 2 # Set window geometry window.geometry(f"{width}x{height}+{x}+{y}") return except (ImportError, IndexError, ValueError): pass # Final fallback: Use standard Tkinter method screen_width = window.winfo_screenwidth() screen_height = window.winfo_screenheight() # Try to make an educated guess for multi-monitor setups # If screen width is much larger than height, assume multiple monitors side by side if ( screen_width > screen_height * 1.8 ): # Heuristic for detecting multiple monitors # Assume the primary monitor is on the left half screen_width = screen_width // 2 x = (screen_width - width) // 2 y = (screen_height - height) // 2 window.geometry(f"{width}x{height}+{x}+{y}") @staticmethod def clean_files(tmp_dir: Path = None, file: Path = None) -> None: """ Deletes temporary files and directories for cleanup when exiting the application. This method safely removes an optional directory defined by `AppConfig.TEMP_DIR` and a single file to free up resources at the end of the program's execution. All operations are performed securely, and errors such as `FileNotFoundError` are ignored if the target files or directories do not exist. :param tmp_dir: (Path, optional): Path to the temporary directory that should be deleted. If `None`, the value of `AppConfig.TEMP_DIR` is used. :param file: (Path, optional): Path to the file that should be deleted. If `None`, no additional file will be deleted. Returns: None: The method does not return any value. """ if tmp_dir is not None: shutil.rmtree(tmp_dir, ignore_errors=True) try: if file is not None: Path.unlink(file) except FileNotFoundError: pass @staticmethod def sigi(file_path: Optional[Path] = None, file: Optional[Path] = None) -> None: """ Function for cleanup after a program interruption :param file: Optional - File to be deleted :param file_path: Optional - Directory to be deleted """ def signal_handler(signum: int, frame: Any) -> NoReturn: """ Determines clear text names for signal numbers and handles signals Args: signum: The signal number frame: The current stack frame Returns: NoReturn since the function either exits the program or continues execution """ signals_to_names_dict: Dict[int, str] = dict( (getattr(signal, n), n) for n in dir(signal) if n.startswith("SIG") and "_" not in n ) signal_name: str = signals_to_names_dict.get( signum, f"Unnamed signal: {signum}" ) # End program for certain signals, report to others only reception if signum in (signal.SIGINT, signal.SIGTERM): exit_code: int = 1 app_logger.log( f"\nSignal {signal_name} {signum} received. => Aborting with exit code {exit_code}." ) LxTools.clean_files(file_path, file) app_logger.log("Breakdown by user...") sys.exit(exit_code) else: app_logger.log(f"Signal {signum} received and ignored.") LxTools.clean_files(file_path, file) app_logger.log("Process unexpectedly ended...") # Register signal handlers for various signals signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) signal.signal(signal.SIGHUP, signal_handler) # ConfigManager with caching class ConfigManager: """ Universal class for managing configuration files with caching support. This class provides a general solution to load, save, and manage configuration files across different projects. It uses a caching system to optimize access efficiency. The `init()` method initializes the configuration file path, while `load()` and `save()` synchronize data between the file and internal memory structures. Key Features: - Caching to minimize I/O operations. - Default values for missing or corrupted configuration files. - Reusability across different projects and use cases. The class is designed for central application configuration management, working closely with `ThemeManager` to dynamically manage themes or other settings. """ _config = None _config_file = None @classmethod def init(cls, config_file): """Initial the Configmanager with the given config file""" cls._config_file = config_file cls._config = None # Reset the cache @classmethod def load(cls): """Load the config file and return the config as dict""" if not cls._config: try: lines = Path(cls._config_file).read_text( encoding="utf-8").splitlines() cls._config = { "updates": lines[1].strip(), "theme": lines[3].strip(), "tooltips": lines[5].strip() == "True", # is converted here to boolean!!! "autostart": lines[7].strip() if len(lines) > 7 else "off", } except (IndexError, FileNotFoundError): # DeDefault values in case of error cls._config = { "updates": "on", "theme": "light", "tooltips": "True", # Default Value as string! "autostart": "off", } return cls._config @classmethod def save(cls): """Save the config to the config file""" if cls._config: lines = [ "# Configuration\n", f"{cls._config['updates']}\n", "# Theme\n", f"{cls._config['theme']}\n", "# Tooltips\n", f"{str(cls._config['tooltips'])}\n", "# Autostart\n", f"{cls._config['autostart']}\n", ] Path(cls._config_file).write_text("".join(lines), encoding="utf-8") @classmethod def set(cls, key, value): """Sets a configuration value and saves the change""" cls.load() cls._config[key] = value cls.save() @classmethod def get(cls, key, default=None): """Returns a configuration value""" config = cls.load() return config.get(key, default) class ThemeManager: """ Class for central theme management and UI customization. This static class allows dynamic adjustment of the application's appearance. The method `change_theme()` updates the current theme and saves the selection in the configuration file via `ConfigManager`. It ensures a consistent visual design across the entire project. Key Features: - Central control over themes. - Automatic saving of theme settings to the configuration file. - Tight integration with `ConfigManager` for persistent storage of preferences. The class is designed to apply themes consistently throughout the application, ensuring that changes are traceable and uniform across all parts of the project. """ @staticmethod def change_theme(root, theme_in_use, theme_name=None): """ Change application theme centrally. Args: root: The root Tkinter window. theme_in_use (str): The name of the theme to apply. theme_name (Optional[str]): The name of the theme to save in the config. If None, the theme is not saved. """ root.tk.call("set_theme", theme_in_use) if theme_in_use == theme_name: ConfigManager.set("theme", theme_in_use) class Tooltip: """ A flexible tooltip class for Tkinter widgets that supports dynamic activation/deactivation. This class provides customizable tooltips that appear when the mouse hovers over a widget. It can be used for simple, always-active tooltips or for tooltips whose visibility is controlled by a `tk.BooleanVar`, allowing for global enable/disable functionality. Attributes: widget (tk.Widget): The Tkinter widget to which the tooltip is attached. text (str): The text to display in the tooltip. wraplength (int): The maximum line length for the tooltip text before wrapping. state_var (Optional[tk.BooleanVar]): An optional Tkinter BooleanVar that controls the visibility of the tooltip. If True, the tooltip is active; if False, it is inactive. If None, the tooltip is always active. tooltip_window (Optional[tk.Toplevel]): The Toplevel window used to display the tooltip. id (Optional[str]): The ID of the `after` job used to schedule the tooltip display. Usage Examples: # 1. Simple Tooltip (always active): # Tooltip(my_button, "This is a simple tooltip.") # 2. State-Controlled Tooltip (can be enabled/disabled globally): # tooltip_state = tk.BooleanVar(value=True) # Tooltip(my_button, "This tooltip can be turned off!", state_var=tooltip_state) # # To toggle visibility: # # tooltip_state.set(False) # Tooltips will hide # # tooltip_state.set(True) # Tooltips will show again """ def __init__(self, widget, text, wraplength=250, state_var=None): self.widget = widget self.text = text self.wraplength = wraplength self.state_var = state_var self.tooltip_window = None self.id = None self.update_bindings() if self.state_var: self.state_var.trace_add("write", self.update_bindings) # Add bindings to the top-level window to hide the tooltip when the # main window loses focus or is iconified. toplevel = self.widget.winfo_toplevel() toplevel.bind("", self.leave, add="+") toplevel.bind("", self.leave, add="+") def update_bindings(self, *args): """ Updates the event bindings for the widget based on the current state_var. If state_var is True or None, the , , and events are bound to show/hide the tooltip. Otherwise, they are unbound. """ self.widget.unbind("") self.widget.unbind("") self.widget.unbind("") if self.state_var is None or self.state_var.get(): self.widget.bind("", self.enter) self.widget.bind("", self.leave) self.widget.bind("", self.leave) def enter(self, event=None): """ Handles the event. Schedules the tooltip to be shown after a delay if tooltips are enabled (via state_var). """ # Do not show tooltips if a grab is active on a different window. # This prevents tooltips from appearing over other modal dialogs. toplevel = self.widget.winfo_toplevel() grab_widget = toplevel.grab_current() if grab_widget is not None and grab_widget != toplevel: return if self.state_var is None or self.state_var.get(): self.schedule() def leave(self, event=None): """ Handles the event. Unschedules any pending tooltip display and immediately hides any visible tooltip. """ self.unschedule() self.hide_tooltip() def schedule(self): """ Schedules the `show_tooltip` method to be called after a short delay. Cancels any previously scheduled calls to prevent flickering. """ self.unschedule() self.id = self.widget.after(250, self.show_tooltip) def unschedule(self): """ Cancels any pending `show_tooltip` calls. """ id = self.id self.id = None if id: self.widget.after_cancel(id) def show_tooltip(self, event=None): """ Displays the tooltip window. The tooltip is a Toplevel window containing a ttk.Label. It is positioned near the widget and styled for readability. """ if self.tooltip_window: return text_to_show = self.text() if callable(self.text) else self.text if not text_to_show: return try: # Position the tooltip just below the widget. # Using winfo_rootx/y is more reliable than bbox. x = self.widget.winfo_rootx() y = self.widget.winfo_rooty() + self.widget.winfo_height() + 5 except tk.TclError: # This can happen if the widget is destroyed while the tooltip is scheduled. return self.tooltip_window = tw = tk.Toplevel(self.widget) tw.wm_overrideredirect(True) tw.wm_geometry(f"+" + str(x) + "+" + str(y)) label = ttk.Label(tw, text=text_to_show, justify=tk.LEFT, background="#FFFFE0", foreground="black", relief=tk.SOLID, borderwidth=1, wraplength=self.wraplength, padding=(4, 2, 4, 2)) label.pack(ipadx=1) def hide_tooltip(self): """ Hides and destroys the tooltip window if it is currently visible. """ tw = self.tooltip_window self.tooltip_window = None if tw: tw.destroy() class LogConfig: """ A static class for configuring application-wide logging. This class provides a convenient way to set up file-based logging for the application. It ensures that log messages are written to a specified file with a consistent format. Methods: logger(file_path: str) -> None: Configures the root logger to write messages to the specified file. Usage Example: # Assuming LOG_FILE_PATH is defined elsewhere (e.g., in a config file) # LogConfig.logger(LOG_FILE_PATH) # logging.info("This message will be written to the log file.") """ @staticmethod def logger(file_path) -> None: """ Configures the root logger to write messages to the specified file. Args: file_path (str): The absolute path to the log file. """ file_handler = logging.FileHandler( filename=f"{file_path}", mode="a", encoding="utf-8", ) formatter = logging.Formatter( "%(asctime)s - %(levelname)s - %(message)s") file_handler.setFormatter(formatter) file_handler.setLevel(logging.DEBUG) logger = logging.getLogger() logger.setLevel(logging.DEBUG) # Set the root logger level logger.addHandler(file_handler) class IconManager: """ A class for central management and loading of application icons. This class loads Tkinter PhotoImage objects from a specified base path, organizing them by logical names and providing a convenient way to retrieve them. It handles potential errors during image loading by creating a blank image placeholder. Attributes: base_path (str): The base directory where icon subfolders (e.g., '16', '32', '48', '64') are located. icons (Dict[str, tk.PhotoImage]): A dictionary storing loaded PhotoImage objects, keyed by their logical names (e.g., 'computer_small', 'folder_large'). Methods: get_icon(name: str) -> Optional[tk.PhotoImage]: Retrieves a loaded icon by its logical name. Usage Example: # Initialize the IconManager with the path to your icon directory # icon_manager = IconManager(base_path="/usr/share/icons/lx-icons/") # Retrieve an icon # computer_icon = icon_manager.get_icon("computer_small") # if computer_icon: # my_label = tk.Label(root, image=computer_icon) # my_label.pack() """ def __init__(self, base_path='/usr/share/icons/lx-icons/'): self.base_path = base_path self.icons = {} self._define_icon_paths() self._load_all() def _define_icon_paths(self): self.icon_paths = { # 16x16 'settings_16': '16/settings.png', # 32x32 'back': '32/arrow-left.png', 'forward': '32/arrow-right.png', 'up': '32/arrow-up.png', 'copy': '32/copy.png', 'stair': '32/stair.png', 'star': '32/star.png', 'connect': '32/connect.png', 'audio_small': '32/audio.png', 'icon_view': '32/carrel.png', 'computer_small': '32/computer.png', 'device_small': '32/device.png', 'file_small': '32/document.png', 'download_error_small': '32/download_error.png', 'download_small': '32/download.png', 'error_small': '32/error.png', 'python_small': '32/file-python.png', 'documents_small': '32/folder-water-documents.png', 'downloads_small': '32/folder-water-download.png', 'music_small': '32/folder-water-music.png', 'pictures_small': '32/folder-water-pictures.png', 'folder_small': '32/folder-water.png', 'video_small': '32/folder-water-video.png', 'hide': '32/hide.png', 'home': '32/home.png', 'about': '32/about.png', 'info_small': '32/info.png', 'light_small': '32/light.png', 'dark_small': '32/dark.png', 'update_small': '32/update.png', 'no_update_small': '32/no_update.png', 'tooltip_small': '32/tip.png', 'no_tooltip_small': '32/no_tip.png', 'list_view': '32/list.png', 'log_small': '32/log.png', 'log_blue_small': '32/log_blue.png', 'lunix_tools_small': '32/Lunix_Tools.png', 'key_small': '32/lxtools_key.png', 'iso_small': '32/media-optical.png', 'new_document_small': '32/new-document.png', 'new_folder_small': '32/new-folder.png', 'pdf_small': '32/pdf.png', 'picture_small': '32/picture.png', 'question_mark_small': '32/question_mark.png', 'recursive_small': '32/recursive.png', 'search_small': '32/search.png', 'settings_small': '32/settings.png', 'settings-2_small': '32/settings-2.png', 'archive_small': '32/tar.png', 'unhide': '32/unhide.png', 'usb_small': '32/usb.png', 'video_small_file': '32/video.png', 'warning_small': '32/warning.png', 'export_small': '32/wg_export.png', 'import_small': '32/wg_import.png', 'message_small': '32/wg_msg.png', 'trash_small': '32/wg_trash.png', 'trash_small2': '32/trash.png', 'vpn_small': '32/wg_vpn.png', 'vpn_start_small': '32/wg_vpn-start.png', 'vpn_stop_small': '32/wg_vpn-stop.png', # 48x48 'back_large': '48/arrow-left.png', 'forward_large': '48/arrow-right.png', 'up_large': '48/arrow-up.png', 'copy_large': '48/copy.png', 'stair_large': '48/stair.png', 'star_large': '48/star.png', 'connect_large': '48/connect.png', 'icon_view_large': '48/carrel.png', 'computer_large': '48/computer.png', 'device_large': '48/device.png', 'download_error_large': '48/download_error.png', 'download_large': '48/download.png', 'error_large': '48/error.png', 'documents_large': '48/folder-water-documents.png', 'downloads_large': '48/folder-water-download.png', 'music_large': '48/folder-water-music.png', 'pictures_large': '48/folder-water-pictures.png', 'folder_large_48': '48/folder-water.png', 'video_large_folder': '48/folder-water-video.png', 'hide_large': '48/hide.png', 'home_large': '48/home.png', 'info_large': '48/info.png', 'light_large': '48/light.png', 'dark_large': '48/dark.png', 'update_large': '48/update.png', 'no_update_large': '48/no_update.png', 'tooltip_large': '48/tip.png', 'no_tooltip_large': '48/no_tip.png', 'about_large': '48/about.png', 'list_view_large': '48/list.png', 'log_large': '48/log.png', 'log_blue_large': '48/log_blue.png', 'lunix_tools_large': '48/Lunix_Tools.png', 'new_document_large': '48/new-document.png', 'new_folder_large': '48/new-folder.png', 'question_mark_large': '48/question_mark.png', 'search_large_48': '48/search.png', 'settings_large': '48/settings.png', 'unhide_large': '48/unhide.png', 'usb_large': '48/usb.png', 'warning_large_48': '48/warning.png', 'export_large': '48/wg_export.png', 'import_large': '48/wg_import.png', 'message_large': '48/wg_msg.png', 'trash_large': '48/wg_trash.png', 'trash_large2': '48/trash.png', 'vpn_large': '48/wg_vpn.png', 'vpn_start_large': '48/wg_vpn-start.png', 'vpn_stop_large': '48/wg_vpn-stop.png', # 64x64 'back_extralarge': '64/arrow-left.png', 'forward_extralarge': '64/arrow-right.png', 'up_extralarge': '64/arrow-up.png', 'copy_extralarge': '64/copy.png', 'stair_extralarge': '64/stair.png', 'star_extralarge': '64/star.png', 'connect_extralarge': '64/connect.png', 'audio_large': '64/audio.png', 'icon_view_extralarge': '64/carrel.png', 'computer_extralarge': '64/computer.png', 'device_extralarge': '64/device.png', 'file_large': '64/document.png', 'download_error_extralarge': '64/download_error.png', 'download_extralarge': '64/download.png', 'error_extralarge': '64/error.png', 'python_large': '64/file-python.png', 'documents_extralarge': '64/folder-water-documents.png', 'downloads_extralarge': '64/folder-water-download.png', 'music_extralarge': '64/folder-water-music.png', 'pictures_extralarge': '64/folder-water-pictures.png', 'folder_large': '64/folder-water.png', 'video_extralarge_folder': '64/folder-water-video.png', 'hide_extralarge': '64/hide.png', 'home_extralarge': '64/home.png', 'info_extralarge': '64/info.png', 'light_extralarge': '64/light.png', 'dark_extralarge': '64/dark.png', 'update_extralarge': '64/update.png', 'no_update_extralarge': '64/no_update.png', 'tooltip_extralarge': '64/tip.png', 'no_tooltip_extralarge': '64/no_tip.png', 'about_extralarge': '64/about.png', 'list_view_extralarge': '64/list.png', 'log_extralarge': '64/log.png', 'log_blue_extralarge': '64/log_blue.png', 'lunix_tools_extralarge': '64/Lunix_Tools.png', 'iso_large': '64/media-optical.png', 'new_document_extralarge': '64/new-document.png', 'new_folder_extralarge': '64/new-folder.png', 'pdf_large': '64/pdf.png', 'picture_large': '64/picture.png', 'question_mark_extralarge': '64/question_mark.png', 'recursive_large': '64/recursive.png', 'search_large': '64/search.png', 'settings_extralarge': '64/settings.png', 'archive_large': '64/tar.png', 'unhide_extralarge': '64/unhide.png', 'usb_extralarge': '64/usb.png', 'video_large': '64/video.png', 'warning_large': '64/warning.png', 'export_extralarge': '64/wg_export.png', 'import_extralarge': '64/wg_import.png', 'message_extralarge': '64/wg_msg.png', 'trash_extralarge': '64/wg_trash.png', 'trash_extralarge2': '64/trash.png', 'vpn_extralarge': '64/wg_vpn.png', 'vpn_start_extralarge': '64/wg_vpn-start.png', 'vpn_stop_extralarge': '64/wg_vpn-stop.png', } def _load_all(self): for key, rel_path in self.icon_paths.items(): full_path = os.path.join(self.base_path, rel_path) try: self.icons[key] = tk.PhotoImage(file=full_path) except tk.TclError as e: print(f"Error loading icon '{key}' from '{full_path}': {e}") size = 32 # Default size if '16' in rel_path: size = 16 elif '48' in rel_path: size = 48 elif '64' in rel_path: size = 64 self.icons[key] = tk.PhotoImage(width=size, height=size) def get_icon(self, name): return self.icons.get(name) class Translate: @staticmethod def setup_translations(app_name: str, locale_dir="/usr/share/locale/") -> gettext.gettext: """ Initialize translations and set the translation function Special method for translating strings in this file Returns: The gettext translation function """ locale.bindtextdomain(app_name, locale_dir) gettext.bindtextdomain(app_name, locale_dir) gettext.textdomain(app_name) return gettext.gettext @contextmanager def message_box_animation(animated_icon): """ A context manager to handle pausing and resuming an animated icon around an operation like showing a message box. Args: animated_icon: The animated icon object with pause() and resume() methods. """ if animated_icon: animated_icon.pause() try: yield finally: if animated_icon: animated_icon.resume()