Test appplication for offdevice testing

dreader/overlays/base.py

@@ -168,6 +168,7 @@ class OverlaySubApplication(ABC):
             Composited PIL Image with popup effect
         """
         from PIL import ImageDraw, ImageEnhance
+        import os
 
         # Convert base image to RGB
         result = base_page.convert('RGB').copy()
@@ -180,6 +181,11 @@ class OverlaySubApplication(ABC):
         if overlay_panel.mode != 'RGB':
             overlay_panel = overlay_panel.convert('RGB')
 
+        # DEBUG: Draw bounding boxes on interactive elements if debug mode enabled
+        debug_mode = os.environ.get('DREADER_DEBUG_OVERLAY', '0') == '1'
+        if debug_mode:
+            overlay_panel = self._draw_debug_bounding_boxes(overlay_panel.copy())
+
         # Calculate centered position for the panel
         panel_x = int((self.page_size[0] - overlay_panel.width) / 2)
         panel_y = int((self.page_size[1] - overlay_panel.height) / 2)
@@ -245,6 +251,13 @@ class OverlaySubApplication(ABC):
         # Query the point
         result = current_page.query_point((overlay_x, overlay_y))
 
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"[OVERLAY_BASE] query_point({overlay_x}, {overlay_y}) returned: {result}")
+        if result:
+            logger.info(f"[OVERLAY_BASE]   text={result.text}, link_target={result.link_target}, is_interactive={result.is_interactive}")
+            logger.info(f"[OVERLAY_BASE]   bounds={result.bounds}, object_type={result.object_type}")
+
         if not result:
             return None
 
@@ -271,3 +284,76 @@ class OverlaySubApplication(ABC):
         panel_width = int(self.page_size[0] * width_ratio)
         panel_height = int(self.page_size[1] * height_ratio)
         return (panel_width, panel_height)
+
+    def _draw_debug_bounding_boxes(self, overlay_panel: Image.Image) -> Image.Image:
+        """
+        Draw bounding boxes around all interactive elements for debugging.
+
+        This scans the overlay panel and draws red rectangles around all
+        clickable elements to help visualize where users need to click.
+
+        Args:
+            overlay_panel: Overlay panel image to annotate
+
+        Returns:
+            Annotated overlay panel with bounding boxes
+        """
+        from PIL import ImageDraw, ImageFont
+        import logging
+
+        logger = logging.getLogger(__name__)
+
+        if not self._overlay_reader or not self._overlay_reader.manager:
+            logger.warning("[DEBUG] No overlay reader available for debug visualization")
+            return overlay_panel
+
+        page = self._overlay_reader.manager.get_current_page()
+        if not page:
+            logger.warning("[DEBUG] No page available for debug visualization")
+            return overlay_panel
+
+        # Scan for all interactive elements
+        panel_width, panel_height = overlay_panel.size
+        link_regions = {}  # link_target -> (min_x, min_y, max_x, max_y)
+
+        logger.info(f"[DEBUG] Scanning {panel_width}x{panel_height} overlay for interactive elements...")
+
+        # Scan with fine granularity to find all interactive pixels
+        for y in range(0, panel_height, 2):
+            for x in range(0, panel_width, 2):
+                result = page.query_point((x, y))
+                if result and result.link_target:
+                    if result.link_target not in link_regions:
+                        link_regions[result.link_target] = [x, y, x, y]
+                    else:
+                        # Expand bounding box
+                        link_regions[result.link_target][0] = min(link_regions[result.link_target][0], x)
+                        link_regions[result.link_target][1] = min(link_regions[result.link_target][1], y)
+                        link_regions[result.link_target][2] = max(link_regions[result.link_target][2], x)
+                        link_regions[result.link_target][3] = max(link_regions[result.link_target][3], y)
+
+        # Draw bounding boxes
+        draw = ImageDraw.Draw(overlay_panel)
+
+        try:
+            font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 10)
+        except:
+            font = ImageFont.load_default()
+
+        logger.info(f"[DEBUG] Found {len(link_regions)} interactive regions")
+
+        for link_target, (min_x, min_y, max_x, max_y) in link_regions.items():
+            # Draw red bounding box
+            draw.rectangle(
+                [min_x, min_y, max_x, max_y],
+                outline=(255, 0, 0),
+                width=2
+            )
+
+            # Draw label
+            label = link_target[:20]  # Truncate if too long
+            draw.text((min_x + 2, min_y - 12), label, fill=(255, 0, 0), font=font)
+
+            logger.info(f"[DEBUG]   {link_target}: ({min_x}, {min_y}) to ({max_x}, {max_y})")
+
+        return overlay_panel

dreader/overlays/navigation.py

@@ -107,16 +107,25 @@ class NavigationOverlay(OverlaySubApplication):
         Returns:
             GestureResponse with appropriate action
         """
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"[NAV_OVERLAY] Handling tap at ({x}, {y})")
+        logger.info(f"[NAV_OVERLAY] Panel offset: {self._overlay_panel_offset}, Panel size: {self._panel_size}")
+
         # Query the overlay to see what was tapped
         query_result = self.query_overlay_pixel(x, y)
 
-        # If query failed (tap outside overlay), close it
-        if not query_result:
+        logger.info(f"[NAV_OVERLAY] Query result: {query_result}")
+
+        # If query failed (tap outside overlay panel), close it
+        if query_result is None:
+            logger.info(f"[NAV_OVERLAY] Tap outside overlay panel, closing")
             return GestureResponse(ActionType.OVERLAY_CLOSED, {})
 
         # Check if tapped on a link
         if query_result.get("is_interactive") and query_result.get("link_target"):
             link_target = query_result["link_target"]
+            logger.info(f"[NAV_OVERLAY] Found interactive link: {link_target}")
 
             # Parse "tab:tabname" format for tab switching
             if link_target.startswith("tab:"):
@@ -168,10 +177,12 @@ class NavigationOverlay(OverlaySubApplication):
             elif link_target.startswith("action:"):
                 action = link_target.split(":", 1)[1]
                 if action == "close":
+                    logger.info(f"[NAV_OVERLAY] Close button clicked")
                     return GestureResponse(ActionType.OVERLAY_CLOSED, {})
 
-        # Not an interactive element, close overlay
-        return GestureResponse(ActionType.OVERLAY_CLOSED, {})
+        # Tap inside overlay but not on interactive element - keep overlay open
+        logger.info(f"[NAV_OVERLAY] Tap on non-interactive area inside overlay, ignoring")
+        return GestureResponse(ActionType.NONE, {})
 
     def switch_tab(self, new_tab: str) -> Optional[Image.Image]:
         """

dreader/overlays/settings.py

@@ -90,20 +90,30 @@ class SettingsOverlay(OverlaySubApplication):
         Returns:
             GestureResponse with appropriate action
         """
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"[SETTINGS_OVERLAY] Handling tap at ({x}, {y})")
+        logger.info(f"[SETTINGS_OVERLAY] Panel offset: {self._overlay_panel_offset}, Panel size: {self._panel_size}")
+
         # Query the overlay to see what was tapped
         query_result = self.query_overlay_pixel(x, y)
 
-        # If query failed (tap outside overlay), close it
-        if not query_result:
+        logger.info(f"[SETTINGS_OVERLAY] Query result: {query_result}")
+
+        # If query failed (tap outside overlay panel), close it
+        if query_result is None:
+            logger.info(f"[SETTINGS_OVERLAY] Tap outside overlay panel, closing")
             return GestureResponse(ActionType.OVERLAY_CLOSED, {})
 
         # Check if tapped on a settings control link
         if query_result.get("is_interactive") and query_result.get("link_target"):
             link_target = query_result["link_target"]
+            logger.info(f"[SETTINGS_OVERLAY] Found interactive link: {link_target}")
 
             # Parse "setting:action" format
             if link_target.startswith("setting:"):
                 action = link_target.split(":", 1)[1]
+                logger.info(f"[SETTINGS_OVERLAY] Applying setting change: {action}")
                 return self._apply_setting_change(action)
 
             # Parse "action:command" format for other actions
@@ -111,10 +121,12 @@ class SettingsOverlay(OverlaySubApplication):
                 action = link_target.split(":", 1)[1]
 
                 if action == "back_to_library":
+                    logger.info(f"[SETTINGS_OVERLAY] Back to library clicked")
                     return GestureResponse(ActionType.BACK_TO_LIBRARY, {})
 
-        # Not a setting control, close overlay
-        return GestureResponse(ActionType.OVERLAY_CLOSED, {})
+        # Tap inside overlay but not on interactive element - keep overlay open
+        logger.info(f"[SETTINGS_OVERLAY] Tap on non-interactive area inside overlay, ignoring")
+        return GestureResponse(ActionType.NONE, {})
 
     def refresh(self, updated_base_page: Image.Image,
                 font_scale: float,