update text bounds calculations and add logger

Author: AlexanderVanhee

data/be.alexandervanhee.gradia.desktop.in

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Name=Gradia
 Comment=Make your images ready for the world
-Exec=gradia %f
+Exec=gradia
 Icon=be.alexandervanhee.gradia
 Terminal=false
 Type=Application

gradia/backend/__init__.py

@@ -0,0 +1,190 @@
+# Copyright (C) 2022 Gradience Team
+# Copyright 2023-2025, tfuxu <https://github.com/tfuxu>
+# Copyright (C) 2025 Alexander Vanhee
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import sys
+import logging
+import traceback
+
+class Logger(logging.getLoggerClass()):
+    """
+    This is a wrapper of `logging` module. It provides
+    custom formatting for log messages.
+
+    Attributes
+    ----------
+    issue_footer_levels : list, optional
+        Custom list of levels on which to show issue footer.
+        [Allowed values: warning, error, traceback_error, critical]
+    formatter : str, optional
+        Custom formatter for the logger.
+    """
+
+    log_colors = {
+        "debug": 32,
+        "info": 36,
+        "warning": 33,
+        "error": 31,
+        "critical": 41
+    }
+
+    log_format = {
+        'fmt': '%(message)s'
+    }
+
+    issue_footer = "If you are reporting an issue, please copy the logs printed above to the issue body."
+
+    issue_footer_levels = [
+        "error",
+        "traceback_error",
+        "critical"
+    ]
+
+    def __set_traceback_info(self, exception: BaseException | None = None) -> str:
+        if not exception:
+            exception = sys.exc_info()[1]
+        traceback = self.get_traceback(exception)
+
+        message_head = "\n\t\033[1mTraceback:\033[0m"
+        message_body = f"\n\033[90m{traceback}\033[0m"
+        message_body = message_body.replace("\n", "\n\t\t")
+
+        return message_head + message_body
+
+    def __set_exception_info(self, exception: BaseException | None = None) -> str:
+        if not exception:
+            exception = sys.exc_info()[1]
+
+        message_head = "\n\t\033[1mException:\033[0m"
+        message_body = f"\n{exception}"
+        message_body = message_body.replace("\n", "\n\t\t")
+
+        return message_head + message_body
+
+    def __set_level_color(self, level: str, message: str) -> str:
+        color_id = self.log_colors[level]
+
+        return f"[\033[1;{color_id}m{level.upper()}\033[0m] {message}"
+
+    def __init__(self, issue_footer_levels: list | None = None, fmt: str | None = None):
+        """
+        The constructor for Logger class.
+        """
+
+        super().__init__(name="Gradia")
+
+        if issue_footer_levels:
+            self.issue_footer_levels = issue_footer_levels
+
+        formatter = logging.Formatter(self.log_format["fmt"])
+        if fmt:
+            formatter = logging.Formatter(fmt)
+
+        self.root.setLevel(logging.DEBUG)
+
+        self.root.handlers = []
+
+        handler = logging.StreamHandler()
+        handler.setFormatter(formatter)
+        self.root.addHandler(handler)
+
+    def debug(self, message: str, *args, **kwargs) -> None:
+        self.root.debug(self.__set_level_color("debug", str(message)))
+
+    def info(self, message: str, *args, **kwargs) -> None:
+        self.root.info(self.__set_level_color("info", str(message)))
+
+    def warning(self, message: str, exception: BaseException | None = None,
+                    show_exception: bool = False, show_traceback: bool = False, *args, **kwargs) -> None:
+        if show_exception:
+            message += self.__set_exception_info(exception)
+        if show_traceback:
+            message += self.__set_traceback_info(exception)
+
+        self.root.warning(self.__set_level_color("warning", str(message)))
+        if "warning" in self.issue_footer_levels:
+            self.print_issue_footer()
+
+    def error(self, message: str, exception: BaseException | None = None,
+                show_exception: bool = False, show_traceback: bool = False, *args, **kwargs) -> None:
+        if show_exception:
+            message += self.__set_exception_info(exception)
+        if show_traceback:
+            message += self.__set_traceback_info(exception)
+
+        self.root.error(self.__set_level_color("error", str(message)))
+        if "error" in self.issue_footer_levels:
+            self.print_issue_footer()
+
+    def traceback_error(self, message: str, exception: BaseException | None = None,
+                            show_exception: bool = False) -> None:
+        if show_exception:
+            message += self.__set_exception_info(exception)
+        message += self.__set_traceback_info(exception)
+
+        self.root.error(self.__set_level_color("error", str(message)))
+        if "traceback_error" in self.issue_footer_levels:
+            self.print_issue_footer()
+
+    def critical(self, message: str, exception: BaseException | None = None,
+                    show_exception: bool = False, show_traceback: bool = True, *args, **kwargs) -> None:
+        if show_exception:
+            message += self.__set_exception_info(exception)
+        if show_traceback:
+            message += self.__set_traceback_info(exception)
+
+        self.root.critical(self.__set_level_color("critical", str(message)))
+        if "critical" in self.issue_footer_levels:
+            self.print_issue_footer()
+
+    def set_silent(self) -> None:
+        self.root.handlers = []
+
+    def print_issue_footer(self) -> None:
+        self.root.info(self.__set_level_color("info", self.issue_footer))
+
+    def get_traceback(self, exception: BaseException | None) -> str | None:
+        if not exception:
+            return
+
+        traceback_list = traceback.format_exception(exception)
+        exception_tb = "".join(traceback_list)
+
+        return exception_tb
+
+
+"""
+Use for testing only.
+How to execute: python -m gradia.backend.logger
+"""
+# pylint: disable=W0719,W0718,W0707
+if __name__ == "__main__":
+    logging = Logger()
+
+    logging.info("This is an information.")
+    logging.debug("This is a debug message.")
+
+    try:
+        raise ArithmeticError("Arithmetic Error")
+    except Exception:
+        try:
+            raise Exception("General Exception")
+        except Exception as e:
+            logging.traceback_error("This is an test error.", exception=e, show_exception=True)
+
+            print(f"Retrieved traceback: {logging.get_traceback(e)}")

gradia/backend/logger.py

@@ -14,6 +14,7 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
+
 import sys
 import os
 import tempfile
@@ -25,7 +26,9 @@
 from gi.repository import Adw, Gio
 
 from gradia.ui.window import GradientWindow
+from gradia.backend.logger import Logger
 
+logging = Logger()
 
 class GradiaApp(Adw.Application):
     __gtype_name__ = "GradiaApp"
@@ -35,65 +38,90 @@ def __init__(self, version: str):
             application_id="be.alexandervanhee.gradia",
             flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE | Gio.ApplicationFlags.HANDLES_OPEN
         )
-        self.temp_dir = tempfile.mkdtemp()
         self.version = version
-        self.init_with_screenshot = False
-        self.file_to_open: Optional[str] = None
+        self.screenshot_mode = False
+        self.temp_dirs: list[str] = []
+
+        # Connect to shutdown signal for cleanup
+        self.connect("shutdown", self.on_shutdown)
 
     def do_command_line(self, command_line: Gio.ApplicationCommandLine) -> int:
         args = command_line.get_arguments()[1:]
 
-        self.init_with_screenshot = "--screenshot" in args
+        logging.debug(f"Command line arguments: {args}")
+
+        self.screenshot_mode = "--screenshot" in args
+        files_to_open = []
 
-        # Extract the first non-option argument
         for arg in args:
             if not arg.startswith("--"):
                 try:
                     file = Gio.File.new_for_commandline_arg(arg)
                     path = file.get_path()
                     if path:
-                        self.file_to_open = path
-                        break
+                        files_to_open.append(path)
+                        logging.debug(f"File to open detected: {path}")
+                    else:
+                        logging.warning(f"Argument {arg} does not have a valid path.")
                 except Exception as e:
-                    print(f"Failed to parse file URI {arg}: {e}")
+                    logging.warning(f"Failed to parse file URI {arg}.", exception=e, show_exception=True)
+
+        if files_to_open:
+            for path in files_to_open:
+                self._open_window(path)
+        else:
+            self._open_window(None)
 
-        self.activate()
         return 0
 
+    def do_open(self, files: Sequence[Gio.File], hint: str):
+        logging.debug(f"do_open called with files: {[file.get_path() for file in files]} and hint: {hint}")
+        for file in files:
+            path = file.get_path()
+            if path:
+                logging.debug(f"Opening file from do_open: {path}")
+                self._open_window(path)
+
     def do_activate(self):
-        self.ui = GradientWindow(
-            self.temp_dir,
+        logging.debug("do_activate called")
+        # Fallback if app is run without args and not via do_open/command_line
+        self._open_window(None)
+
+    def _open_window(self, file_path: Optional[str]):
+        logging.debug(f"Opening window with file_path={file_path}, screenshot_mode={self.screenshot_mode}")
+        temp_dir = tempfile.mkdtemp()
+        logging.debug(f"Created temp directory: {temp_dir}")
+        self.temp_dirs.append(temp_dir)
+
+        window = GradientWindow(
+            temp_dir=temp_dir,
             version=self.version,
             application=self,
-            init_with_screenshot=self.init_with_screenshot,
-            file_path=self.file_to_open
+            init_with_screenshot=self.screenshot_mode,
+            file_path=file_path
         )
-        print(self.file_to_open)
-        self.ui.build_ui()
-        self.ui.show()
+        window.build_ui()
+        window.show()
 
-    def do_open(self, files: Sequence[Gio.File], hint: str):
-        if files:
-            path = files[0].get_path()
-            if path:
-                self.file_to_open = path
-        self.activate()
-
-    def do_shutdown(self):
-        try:
-            if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
-                shutil.rmtree(self.temp_dir)
-        except Exception as e:
-            print(f"Warning: Failed to clean up temporary directory: {e}")
-        finally:
-            Gio.Application.do_shutdown(self)
+    def on_shutdown(self, application):
+        logging.info("Application shutdown started, cleaning temp directories...")
+        for temp_dir in self.temp_dirs:
+            try:
+                if os.path.exists(temp_dir):
+                    shutil.rmtree(temp_dir)
+                    logging.debug(f"Deleted temp dir: {temp_dir}")
+            except Exception as e:
+                logging.warning(f"Failed to clean up temp dir {temp_dir}.", exception=e, show_exception=True)
+        logging.info("Cleanup complete.")
 
 
 def main(version: str):
     try:
+        logging.info("Application starting...")
+
         app = GradiaApp(version=version)
         return app.run(sys.argv)
     except Exception as e:
-        print('Application closed with an exception:', e)
+        logging.critical("Application closed with an exception.", exception=e, show_exception=True)
         return 1
 

gradia/main.py

@@ -45,4 +45,5 @@ gradia_sources = [
 install_data(gradia_sources, install_dir: moduledir)
 
 install_subdir('graphics', install_dir: moduledir)
-install_subdir('ui', install_dir: moduledir)
+install_subdir('ui', install_dir: moduledir)
+install_subdir('backend', install_dir: moduledir)