add highlighter

Author: AlexanderVanhee

data/icons/scalable/actions/marker-symbolic.svg

@@ -11,6 +11,7 @@
     <file preprocess="xml-stripblanks">icons/scalable/actions/text-insert2-symbolic.svg</file>
     <file preprocess="xml-stripblanks">icons/scalable/actions/pointer-primary-click-symbolic.svg</file>
     <file preprocess="xml-stripblanks">icons/scalable/actions/screenshooter-symbolic.svg</file>
+    <file preprocess="xml-stripblanks">icons/scalable/actions/marker-symbolic.svg</file>
 
   </gresource>
 </gresources>

data/resources.data.gresource.xml.in

@@ -1,4 +1,4 @@
-#Copyright (C) 2025 Alexander Vanhee
+# 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
@@ -18,7 +18,6 @@
 from gi.repository import Gtk, Gdk, Gio, cairo, Pango, PangoCairo
 from enum import Enum
 import math
-import re
 
 class DrawingMode(Enum):
     PEN = "pen"
@@ -28,38 +27,38 @@ class DrawingMode(Enum):
     CIRCLE = "circle"
     TEXT = "text"
     SELECT = "select"
+    HIGHLIGHTER = "highlighter"
 
 class DrawingAction:
+    DEFAULT_PADDING = 0.02
+
     def draw(self, cr: cairo.Context, image_to_widget_coords, scale: float):
         raise NotImplementedError
 
     def get_bounds(self):
         raise NotImplementedError
 
+    def apply_padding(self, bounds, extra_padding=0.0):
+        min_x, min_y, max_x, max_y = bounds
+        padding = self.DEFAULT_PADDING + extra_padding
+        return (min_x - padding, min_y - padding, max_x + padding, max_y + padding)
+
     def contains_point(self, x, y):
         min_x, min_y, max_x, max_y = self.get_bounds()
-        tolerance_x = (max_x - min_x) * 0.1 if (max_x - min_x) > 0 else 0.01
-        tolerance_y = (max_y - min_y) * 0.1 if (max_y - min_y) > 0 else 0.01
-
         if isinstance(self, (LineAction, ArrowAction)):
             px, py = x, y
             x1, y1 = self.start
             x2, y2 = self.end
-
-            line_len_sq = (x2 - x1)**2 + (y2 - y1)**2
+            line_len_sq = (x2 - x1) ** 2 + (y2 - y1) ** 2
             if line_len_sq == 0:
-                return math.hypot(px - x1, py - y1) < tolerance_x
-
+                return math.hypot(px - x1, py - y1) < self.DEFAULT_PADDING
             t = ((px - x1) * (x2 - x1) + (py - y1) * (y2 - y1)) / line_len_sq
             t = max(0, min(1, t))
-
             closest_x = x1 + t * (x2 - x1)
             closest_y = y1 + t * (y2 - y1)
-
             dist_sq = (px - closest_x)**2 + (py - closest_y)**2
             return dist_sq < (0.01 + self.width / 200.0)**2
-
-        return min_x - tolerance_x <= x <= max_x + tolerance_x and min_y - tolerance_y <= y <= max_y + tolerance_y
+        return min_x <= x <= max_x and min_y <= y <= max_y
 
     def translate(self, dx, dy):
         raise NotImplementedError
@@ -83,11 +82,9 @@ def draw(self, cr, image_to_widget_coords, scale):
 
     def get_bounds(self):
         if not self.stroke:
-            return 0, 0, 0, 0
-        xs = [p[0] for p in self.stroke]
-        ys = [p[1] for p in self.stroke]
-        padding = self.pen_size / 200.0
-        return min(xs) - padding, min(ys) - padding, max(xs) + padding, max(ys) + padding
+            return (0, 0, 0, 0)
+        xs, ys = zip(*self.stroke)
+        return self.apply_padding((min(xs), min(ys), max(xs), max(ys)))
 
     def translate(self, dx, dy):
         self.stroke = [(x + dx, y + dy) for x, y in self.stroke]
@@ -129,8 +126,7 @@ def get_bounds(self):
         max_x = max(self.start[0], self.end[0])
         min_y = min(self.start[1], self.end[1])
         max_y = max(self.start[1], self.end[1])
-        padding = 0.025
-        return min_x - padding, min_y - padding, max_x + padding, max_y + padding
+        return self.apply_padding((min_x, min_y, max_x, max_y))
 
     def translate(self, dx, dy):
         self.start = (self.start[0] + dx, self.start[1] + dy)
@@ -147,72 +143,38 @@ def __init__(self, position, text, color, font_size, font_family="Sans"):
     def draw(self, cr, image_to_widget_coords, scale):
         if not self.text.strip():
             return
-
         x, y = image_to_widget_coords(*self.position)
         cr.set_source_rgba(*self.color)
-
         layout = PangoCairo.create_layout(cr)
         font_desc = Pango.FontDescription()
         font_desc.set_family(self.font_family)
         font_desc.set_size(int(self.font_size * scale * Pango.SCALE))
         layout.set_font_description(font_desc)
         layout.set_text(self.text, -1)
-
-        ink_rect, logical_rect = layout.get_extents()
+        _, logical_rect = layout.get_extents()
         text_width = logical_rect.width / Pango.SCALE
         text_height = logical_rect.height / Pango.SCALE
-
-        adjusted_x = x - (text_width / 2)
-        adjusted_y = y - text_height
-
-        cr.move_to(adjusted_x, adjusted_y)
+        cr.move_to(x - text_width / 2, y - text_height)
         PangoCairo.show_layout(cr, layout)
 
     def get_bounds(self):
         char_width_factor = 0.6
-        estimated_text_width_img_units = len(self.text) * self.font_size * char_width_factor / 800.0
-        estimated_text_height_img_units = self.font_size / 400.0
-
+        width = len(self.text) * self.font_size * char_width_factor / 800.0
+        height = self.font_size / 400.0
         x, y = self.position
-
-        min_x = x - estimated_text_width_img_units / 2
-        max_x = x + estimated_text_width_img_units / 2
-        min_y = y - estimated_text_height_img_units
-        max_y = y
-
-        return (min_x, min_y, max_x, max_y)
+        return self.apply_padding((x - width / 2, y - height, x + width / 2, y))
 
     def translate(self, dx, dy):
         self.position = (self.position[0] + dx, self.position[1] + dy)
 
-class LineAction(DrawingAction):
-    def __init__(self, start, end, color, width):
-        self.start = start
-        self.end = end
-        self.color = color
-        self.width = width
-
+class LineAction(ArrowAction):
     def draw(self, cr, image_to_widget_coords, scale):
         cr.set_source_rgba(*self.color)
         cr.set_line_width(self.width * scale)
-        start_x, start_y = image_to_widget_coords(*self.start)
-        end_x, end_y = image_to_widget_coords(*self.end)
-        cr.move_to(start_x, start_y)
-        cr.line_to(end_x, end_y)
+        cr.move_to(*image_to_widget_coords(*self.start))
+        cr.line_to(*image_to_widget_coords(*self.end))
         cr.stroke()
 
-    def get_bounds(self):
-        min_x = min(self.start[0], self.end[0])
-        max_x = max(self.start[0], self.end[0])
-        min_y = min(self.start[1], self.end[1])
-        max_y = max(self.start[1], self.end[1])
-        padding = self.width / 200.0
-        return min_x - padding, min_y - padding, max_x + padding, max_y + padding
-
-    def translate(self, dx, dy):
-        self.start = (self.start[0] + dx, self.start[1] + dy)
-        self.end = (self.end[0] + dx, self.end[1] + dy)
-
 class RectAction(DrawingAction):
     def __init__(self, start, end, color, width, fill_color=None):
         self.start = start
@@ -224,74 +186,61 @@ def __init__(self, start, end, color, width, fill_color=None):
     def draw(self, cr, image_to_widget_coords, scale):
         x1, y1 = image_to_widget_coords(*self.start)
         x2, y2 = image_to_widget_coords(*self.end)
-        rect_x = min(x1, x2)
-        rect_y = min(y1, y2)
-        rect_w = abs(x2 - x1)
-        rect_h = abs(y2 - y1)
-
+        x, y = min(x1, x2), min(y1, y2)
+        w, h = abs(x2 - x1), abs(y2 - y1)
         if self.fill_color:
             cr.set_source_rgba(*self.fill_color)
-            cr.rectangle(rect_x, rect_y, rect_w, rect_h)
+            cr.rectangle(x, y, w, h)
             cr.fill()
-
         cr.set_source_rgba(*self.color)
         cr.set_line_width(self.width * scale)
-        cr.rectangle(rect_x, rect_y, rect_w, rect_h)
+        cr.rectangle(x, y, w, h)
         cr.stroke()
 
     def get_bounds(self):
         min_x = min(self.start[0], self.end[0])
         max_x = max(self.start[0], self.end[0])
         min_y = min(self.start[1], self.end[1])
         max_y = max(self.start[1], self.end[1])
-        padding = self.width / 200.0
-        return min_x - padding, min_y - padding, max_x + padding, max_y + padding
+        return self.apply_padding((min_x, min_y, max_x, max_y))
 
     def translate(self, dx, dy):
         self.start = (self.start[0] + dx, self.start[1] + dy)
         self.end = (self.end[0] + dx, self.end[1] + dy)
 
-class CircleAction(DrawingAction):
-    def __init__(self, start, end, color, width, fill_color=None):
-        self.start = start
-        self.end = end
-        self.color = color
-        self.width = width
-        self.fill_color = fill_color
-
+class CircleAction(RectAction):
     def draw(self, cr, image_to_widget_coords, scale):
         x1, y1 = image_to_widget_coords(*self.start)
         x2, y2 = image_to_widget_coords(*self.end)
-        cx = (x1 + x2) / 2
-        cy = (y1 + y2) / 2
-        rx = abs(x2 - x1) / 2
-        ry = abs(y2 - y1) / 2
+        cx, cy = (x1 + x2) / 2, (y1 + y2) / 2
+        rx, ry = abs(x2 - x1) / 2, abs(y2 - y1) / 2
         if rx < 1e-3 or ry < 1e-3:
             return
-
         cr.save()
         cr.translate(cx, cy)
         cr.scale(rx, ry)
         cr.arc(0, 0, 1, 0, 2 * math.pi)
         cr.restore()
-
         if self.fill_color:
             cr.set_source_rgba(*self.fill_color)
             cr.fill_preserve()
-
         cr.set_source_rgba(*self.color)
         cr.set_line_width(self.width * scale)
         cr.stroke()
 
-    def get_bounds(self):
-        min_x = min(self.start[0], self.end[0])
-        max_x = max(self.start[0], self.end[0])
-        min_y = min(self.start[1], self.end[1])
-        max_y = max(self.start[1], self.end[1])
-        padding = self.width / 200.0
-        return min_x - padding, min_y - padding, max_x + padding, max_y + padding
-
-    def translate(self, dx, dy):
-        self.start = (self.start[0] + dx, self.start[1] + dy)
-        self.end = (self.end[0] + dx, self.end[1] + dy)
+class HighlighterAction(StrokeAction):
+    def draw(self, cr, image_to_widget_coords, scale):
+        if len(self.stroke) < 2:
+            return
+        coords = [image_to_widget_coords(x, y) for x, y in self.stroke]
+        cr.set_operator(cairo.Operator.MULTIPLY)
+        cr.set_source_rgba(*self.color)
+        cr.set_line_width(self.pen_size * scale)
+        cr.set_line_cap(cairo.LineCap.BUTT)
+        cr.move_to(*coords[0])
+        for point in coords[1:]:
+            cr.line_to(*point)
+        cr.stroke()
+        cr.set_operator(cairo.Operator.OVER)
+        cr.set_line_cap(cairo.LineCap.ROUND)
 

gradia/ui/drawing_actions.py

@@ -27,6 +27,7 @@
 DEFAULT_FONT_SIZE = 22.0
 DEFAULT_FONT_FAMILY = "Caveat"
 DEFAULT_PEN_COLOR = (1.0, 1.0, 1.0, 0.8)
+DEFAULT_HIGHLIGHTER_SIZE = 12.0
 
 class DrawingOverlay(Gtk.DrawingArea):
     def __init__(self):
@@ -40,6 +41,7 @@ def __init__(self):
         self.font_size = DEFAULT_FONT_SIZE
         self.font_family = DEFAULT_FONT_FAMILY
         self.pen_color = DEFAULT_PEN_COLOR
+        self.highlighter_size = DEFAULT_HIGHLIGHTER_SIZE
         self.fill_color = None
         self.is_drawing = False
         self.current_stroke = []
@@ -107,7 +109,6 @@ def _setup_actions(self):
             if hasattr(root, "add_action"):
                 root.add_action(action)
 
-
     def remove_selected_action(self) -> bool :
         if self.selected_action and self.selected_action in self.actions:
             self.actions.remove(self.selected_action)
@@ -325,7 +326,7 @@ def _on_drag_begin(self, gesture, x, y):
 
         self.is_drawing = True
         rel = self._widget_to_image_coords(x, y)
-        if self.drawing_mode == DrawingMode.PEN:
+        if self.drawing_mode == DrawingMode.PEN or self.drawing_mode == DrawingMode.HIGHLIGHTER:
             self.current_stroke = [rel]
         else:
             self.start_point = rel
@@ -351,7 +352,7 @@ def _on_drag_update(self, gesture, dx, dy):
         if not self.is_drawing:
             return
 
-        if self.drawing_mode == DrawingMode.PEN:
+        if self.drawing_mode == DrawingMode.PEN or self.drawing_mode == DrawingMode.HIGHLIGHTER:
             self.current_stroke.append((rel_x, rel_y))
         else:
             self.end_point = (rel_x, rel_y)
@@ -371,14 +372,18 @@ def _on_drag_end(self, gesture, dx, dy):
 
         self.is_drawing = False
         mode = self.drawing_mode
-        if mode == DrawingMode.PEN and len(self.current_stroke) > 1:
-            self.actions.append(StrokeAction(self.current_stroke.copy(), self.pen_color, self.pen_size))
+        if (mode == DrawingMode.PEN or mode == DrawingMode.HIGHLIGHTER) and len(self.current_stroke) > 1:
+            if mode == DrawingMode.PEN:
+                self.actions.append(StrokeAction(self.current_stroke.copy(), self.pen_color, self.pen_size))
+            else:
+                highlighter_color = (self.pen_color[0], self.pen_color[1], self.pen_color[2], 0.3)
+                self.actions.append(HighlighterAction(self.current_stroke.copy(), highlighter_color, self.highlighter_size))
             self.current_stroke.clear()
         elif self.start_point and self.end_point:
             if mode == DrawingMode.ARROW:
                 self.actions.append(ArrowAction(self.start_point, self.end_point, self.pen_color, self.arrow_head_size, self.pen_size))
             elif mode == DrawingMode.LINE:
-                self.actions.append(LineAction(self.start_point, self.end_point, self.pen_color, self.pen_size))
+                self.actions.append(LineAction(self.start_point, self.end_point, self.pen_color, 0,self.pen_size))
             elif mode == DrawingMode.SQUARE:
                 self.actions.append(RectAction(self.start_point, self.end_point, self.pen_color, self.pen_size, self.fill_color))
             elif mode == DrawingMode.CIRCLE:
@@ -400,7 +405,7 @@ def _on_motion(self, controller, x, y):
             else:
                 name = "default"
         else:
-            name = "crosshair" if self.drawing_mode == DrawingMode.PEN else "cell"
+            name = "crosshair" if self.drawing_mode == DrawingMode.PEN or self.drawing_mode == DrawingMode.HIGHLIGHTER else "cell"
             if not self._is_point_in_image(x, y):
                 name = "default"
         self.set_cursor(Gdk.Cursor.new_from_name(name, None))
@@ -420,11 +425,14 @@ def _on_draw(self, area, cr, width, height):
             cr.set_source_rgba(*self.pen_color)
             if self.drawing_mode == DrawingMode.PEN and len(self.current_stroke) > 1:
                 StrokeAction(self.current_stroke, self.pen_color, self.pen_size).draw(cr, self._image_to_widget_coords, scale)
+            elif self.drawing_mode == DrawingMode.HIGHLIGHTER and len(self.current_stroke) > 1:
+                highlighter_color = (self.pen_color[0], self.pen_color[1], self.pen_color[2], 0.3)
+                HighlighterAction(self.current_stroke, highlighter_color, self.highlighter_size).draw(cr, self._image_to_widget_coords, scale)
             elif self.start_point and self.end_point:
                 if self.drawing_mode == DrawingMode.ARROW:
                     ArrowAction(self.start_point, self.end_point, self.pen_color, self.arrow_head_size, self.pen_size).draw(cr, self._image_to_widget_coords, scale)
                 elif self.drawing_mode == DrawingMode.LINE:
-                    LineAction(self.start_point, self.end_point, self.pen_color, self.pen_size).draw(cr, self._image_to_widget_coords, scale)
+                    LineAction(self.start_point, self.end_point, self.pen_color, 0, self.pen_size).draw(cr, self._image_to_widget_coords, scale)
                 elif self.drawing_mode == DrawingMode.SQUARE:
                     RectAction(self.start_point, self.end_point, self.pen_color, self.pen_size, self.fill_color).draw(cr, self._image_to_widget_coords, scale)
                 elif self.drawing_mode == DrawingMode.CIRCLE:
@@ -501,6 +509,9 @@ def set_font_size(self, size):
     def set_font_family(self, family):
         self.font_family = family if family else "Sans"
 
+    def set_highlighter_size(self, s):
+        self.highlighter_size = max(1.0, s)
+
     def set_drawing_visible(self, v):
         self.set_visible(v)
 

gradia/ui/drawing_overlay.py

@@ -298,6 +298,7 @@ def create_drawing_tools_group() -> Adw.PreferencesGroup:
         (DrawingMode.ARROW, "arrow1-top-right-symbolic", 4, 0),
         (DrawingMode.SQUARE, "box-small-outline-symbolic", 0, 1),
         (DrawingMode.CIRCLE, "circle-outline-thick-symbolic", 1, 1),
+        (DrawingMode.HIGHLIGHTER, "marker-symbolic", 2, 1),
     ]
 
     fill_sensitive_modes = {DrawingMode.SQUARE, DrawingMode.CIRCLE}