360 lines
12 KiB
Python
360 lines
12 KiB
Python
"""
|
|
Base class for overlay sub-applications.
|
|
|
|
This provides a common interface for all overlay types (TOC, Settings, Navigation, etc.)
|
|
Each overlay is a self-contained sub-application that handles its own rendering and gestures.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
from abc import ABC, abstractmethod
|
|
from typing import TYPE_CHECKING, Optional, Dict, Any, Tuple
|
|
from PIL import Image
|
|
|
|
from ..gesture import GestureResponse, ActionType
|
|
from ..state import OverlayState
|
|
|
|
if TYPE_CHECKING:
|
|
from ..application import EbookReader
|
|
|
|
|
|
class OverlaySubApplication(ABC):
|
|
"""
|
|
Base class for overlay sub-applications.
|
|
|
|
Each overlay type extends this class and implements:
|
|
- open(): Generate HTML, render, and return composited image
|
|
- handle_tap(): Process tap gestures within the overlay
|
|
- close(): Clean up and return base page
|
|
- get_overlay_type(): Return the OverlayState enum value
|
|
|
|
The base class provides:
|
|
- Common rendering infrastructure (HTML to image conversion)
|
|
- Coordinate translation (screen to overlay panel)
|
|
- Query pixel support (detecting interactive elements)
|
|
- Compositing (darkened background + centered panel)
|
|
"""
|
|
|
|
def __init__(self, reader: 'EbookReader'):
|
|
"""
|
|
Initialize overlay sub-application.
|
|
|
|
Args:
|
|
reader: Reference to parent EbookReader instance
|
|
"""
|
|
self.reader = reader
|
|
self.page_size = reader.page_size
|
|
|
|
# Overlay rendering state
|
|
self._overlay_reader: Optional['EbookReader'] = None
|
|
self._cached_base_page: Optional[Image.Image] = None
|
|
self._cached_overlay_image: Optional[Image.Image] = None
|
|
self._overlay_panel_offset: Tuple[int, int] = (0, 0)
|
|
self._panel_size: Tuple[int, int] = (0, 0)
|
|
|
|
@abstractmethod
|
|
def get_overlay_type(self) -> OverlayState:
|
|
"""
|
|
Get the overlay type identifier.
|
|
|
|
Returns:
|
|
OverlayState enum value for this overlay
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def open(self, base_page: Image.Image, **kwargs) -> Image.Image:
|
|
"""
|
|
Open the overlay and return composited image.
|
|
|
|
Args:
|
|
base_page: Current reading page to show underneath
|
|
**kwargs: Overlay-specific parameters
|
|
|
|
Returns:
|
|
Composited image with overlay on top of base page
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def handle_tap(self, x: int, y: int) -> GestureResponse:
|
|
"""
|
|
Handle tap gesture within the overlay.
|
|
|
|
Args:
|
|
x, y: Screen coordinates of tap
|
|
|
|
Returns:
|
|
GestureResponse indicating what action to take
|
|
"""
|
|
pass
|
|
|
|
def close(self) -> Optional[Image.Image]:
|
|
"""
|
|
Close the overlay and clean up resources.
|
|
|
|
Returns:
|
|
Base page image (without overlay), or None if not open
|
|
"""
|
|
base_page = self._cached_base_page
|
|
|
|
# Clear caches
|
|
self._cached_base_page = None
|
|
self._cached_overlay_image = None
|
|
self._overlay_panel_offset = (0, 0)
|
|
self._panel_size = (0, 0)
|
|
|
|
# Close overlay reader
|
|
if self._overlay_reader:
|
|
self._overlay_reader.close()
|
|
self._overlay_reader = None
|
|
|
|
return base_page
|
|
|
|
# ===================================================================
|
|
# Common Infrastructure Methods
|
|
# ===================================================================
|
|
|
|
def render_html_to_image(self, html: str, panel_size: Tuple[int, int]) -> Image.Image:
|
|
"""
|
|
Render HTML to image using a temporary EbookReader.
|
|
|
|
Args:
|
|
html: HTML content to render
|
|
panel_size: Size for the overlay panel (width, height)
|
|
|
|
Returns:
|
|
Rendered PIL Image of the HTML
|
|
"""
|
|
# Import here to avoid circular dependency
|
|
from ..application import EbookReader
|
|
|
|
# Create or reuse overlay reader
|
|
if self._overlay_reader:
|
|
self._overlay_reader.close()
|
|
|
|
self._overlay_reader = EbookReader(
|
|
page_size=panel_size,
|
|
margin=15,
|
|
background_color=(255, 255, 255)
|
|
)
|
|
|
|
# Load the HTML content
|
|
success = self._overlay_reader.load_html(
|
|
html_string=html,
|
|
title=f"{self.get_overlay_type().name} Overlay",
|
|
author="",
|
|
document_id=f"{self.get_overlay_type().name.lower()}_overlay"
|
|
)
|
|
|
|
if not success:
|
|
raise ValueError(f"Failed to load {self.get_overlay_type().name} overlay HTML")
|
|
|
|
# Get the rendered page
|
|
return self._overlay_reader.get_current_page()
|
|
|
|
def composite_overlay(self, base_page: Image.Image, overlay_panel: Image.Image) -> Image.Image:
|
|
"""
|
|
Composite overlay panel on top of base page with darkened background.
|
|
|
|
Creates popup effect by:
|
|
1. Darkening the base image (70% brightness for e-ink visibility)
|
|
2. Placing the overlay panel centered on top with a border
|
|
|
|
Args:
|
|
base_page: Base reading page
|
|
overlay_panel: Rendered overlay panel
|
|
|
|
Returns:
|
|
Composited PIL Image with popup effect
|
|
"""
|
|
from PIL import ImageDraw, ImageEnhance
|
|
import os
|
|
|
|
# Convert base image to RGB
|
|
result = base_page.convert('RGB').copy()
|
|
|
|
# Lighten the background slightly (70% brightness for e-ink visibility)
|
|
enhancer = ImageEnhance.Brightness(result)
|
|
result = enhancer.enhance(0.7)
|
|
|
|
# Convert overlay panel to RGB
|
|
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)
|
|
|
|
# Store panel position and size for coordinate translation
|
|
self._overlay_panel_offset = (panel_x, panel_y)
|
|
self._panel_size = (overlay_panel.width, overlay_panel.height)
|
|
|
|
# Add a thick black border around the panel for e-ink clarity
|
|
draw = ImageDraw.Draw(result)
|
|
border_width = 3
|
|
draw.rectangle(
|
|
[panel_x - border_width, panel_y - border_width,
|
|
panel_x + overlay_panel.width + border_width,
|
|
panel_y + overlay_panel.height + border_width],
|
|
outline=(0, 0, 0),
|
|
width=border_width
|
|
)
|
|
|
|
# Paste the panel onto the dimmed background
|
|
result.paste(overlay_panel, (panel_x, panel_y))
|
|
|
|
return result
|
|
|
|
def query_overlay_pixel(self, x: int, y: int) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
Query a pixel in the overlay to detect interactive elements.
|
|
|
|
Uses pyWebLayout's query_point() to detect tapped elements,
|
|
including link targets and data attributes.
|
|
|
|
Args:
|
|
x, y: Screen coordinates to query
|
|
|
|
Returns:
|
|
Dictionary with query result (text, link_target, is_interactive),
|
|
or None if query failed or coordinates outside overlay
|
|
"""
|
|
if not self._overlay_reader:
|
|
return None
|
|
|
|
# Translate screen coordinates to overlay panel coordinates
|
|
panel_x, panel_y = self._overlay_panel_offset
|
|
overlay_x = x - panel_x
|
|
overlay_y = y - panel_y
|
|
|
|
# Check if coordinates are within the overlay panel
|
|
if overlay_x < 0 or overlay_y < 0:
|
|
return None
|
|
|
|
panel_width, panel_height = self._panel_size
|
|
if overlay_x >= panel_width or overlay_y >= panel_height:
|
|
return None
|
|
|
|
# Get the current page from the overlay reader
|
|
if not self._overlay_reader.manager:
|
|
return None
|
|
|
|
current_page = self._overlay_reader.manager.get_current_page()
|
|
if not current_page:
|
|
return None
|
|
|
|
# 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
|
|
|
|
# Extract relevant data from QueryResult
|
|
return {
|
|
"text": result.text,
|
|
"link_target": result.link_target,
|
|
"is_interactive": result.is_interactive,
|
|
"bounds": result.bounds,
|
|
"object_type": result.object_type
|
|
}
|
|
|
|
def _calculate_panel_size(self, width_ratio: float = 0.6, height_ratio: float = 0.7) -> Tuple[int, int]:
|
|
"""
|
|
Calculate overlay panel size as a percentage of screen size.
|
|
|
|
Args:
|
|
width_ratio: Panel width as ratio of screen width (default 60%)
|
|
height_ratio: Panel height as ratio of screen height (default 70%)
|
|
|
|
Returns:
|
|
Tuple of (panel_width, panel_height) in pixels
|
|
"""
|
|
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
|