Coverage for pyWebLayout/concrete/functional.py: 87%
165 statements
« prev ^ index » next coverage.py v7.11.2, created at 2025-11-12 12:02 +0000
1from __future__ import annotations
2from typing import Optional, Tuple
3import numpy as np
4from PIL import ImageDraw
6from pyWebLayout.core.base import Interactable, Queriable
7from pyWebLayout.abstract.functional import Link, Button, FormField, LinkType, FormFieldType
8from pyWebLayout.style import Font, TextDecoration
9from .text import Text
12class LinkText(Text, Interactable, Queriable):
13 """
14 A Text subclass that can handle Link interactions.
15 Combines text rendering with clickable link functionality.
16 """
18 def __init__(self, link: Link, text: str, font: Font, draw: ImageDraw.Draw,
19 source=None, line=None, page=None):
20 """
21 Initialize a linkable text object.
23 Args:
24 link: The abstract Link object to handle interactions
25 text: The text content to render
26 font: The base font style
27 draw: The drawing context
28 source: Optional source object
29 line: Optional line container
30 page: Optional parent page (for dirty flag management)
31 """
32 # Create link-styled font (underlined and colored based on link type)
33 link_font = font.with_decoration(TextDecoration.UNDERLINE)
34 if link.link_type == LinkType.INTERNAL:
35 link_font = link_font.with_colour((0, 0, 200)) # Blue for internal links
36 elif link.link_type == LinkType.EXTERNAL:
37 link_font = link_font.with_colour(
38 (0, 0, 180)) # Darker blue for external links
39 elif link.link_type == LinkType.API:
40 link_font = link_font.with_colour((150, 0, 0)) # Red for API links
41 elif link.link_type == LinkType.FUNCTION: 41 ↛ 45line 41 didn't jump to line 45 because the condition on line 41 was always true
42 link_font = link_font.with_colour((0, 120, 0)) # Green for function links
44 # Initialize Text with the styled font
45 Text.__init__(self, text, link_font, draw, source, line)
47 # Initialize Interactable with the link's execute method
48 Interactable.__init__(self, link.execute)
50 # Store the link object and page reference
51 self._link = link
52 self._page = page
53 self._hovered = False
54 self._pressed = False
56 # Ensure _origin is initialized as numpy array
57 if not hasattr(self, '_origin') or self._origin is None: 57 ↛ 58line 57 didn't jump to line 58 because the condition on line 57 was never true
58 self._origin = np.array([0, 0])
60 @property
61 def link(self) -> Link:
62 """Get the associated Link object"""
63 return self._link
65 def set_hovered(self, hovered: bool):
66 """Set the hover state for visual feedback"""
67 self._hovered = hovered
68 self._mark_page_dirty()
70 def set_pressed(self, pressed: bool):
71 """Set the pressed state for visual feedback"""
72 self._pressed = pressed
73 self._mark_page_dirty()
75 def _mark_page_dirty(self):
76 """Mark the parent page as dirty if available"""
77 if self._page and hasattr(self._page, 'mark_dirty'): 77 ↛ 78line 77 didn't jump to line 78 because the condition on line 77 was never true
78 self._page.mark_dirty()
80 def render(self, next_text: Optional['Text'] = None, spacing: int = 0):
81 """
82 Render the link text with optional hover and pressed effects.
84 Args:
85 next_text: The next Text object in the line (if any)
86 spacing: The spacing to the next text object
87 """
88 # Handle mock objects in tests
89 size = self.size
90 if hasattr(size, '__call__'): # It's a Mock 90 ↛ 92line 90 didn't jump to line 92 because the condition on line 90 was never true
91 # Use default size for tests
92 size = np.array([100, 20])
93 else:
94 size = np.array(size)
96 # Ensure origin is a numpy array
97 origin = np.array(
98 self._origin) if not isinstance(
99 self._origin,
100 np.ndarray) else self._origin
102 # Draw background based on state (before text is rendered)
103 if self._pressed: 103 ↛ 105line 103 didn't jump to line 105 because the condition on line 103 was never true
104 # Pressed state - stronger, darker highlight
105 bg_color = (180, 180, 255, 180) # Stronger blue with more opacity
106 self._draw.rectangle([origin, origin + size], fill=bg_color)
107 elif self._hovered: 107 ↛ 109line 107 didn't jump to line 109 because the condition on line 107 was never true
108 # Hover state - subtle highlight
109 bg_color = (220, 220, 255, 100) # Light blue with alpha
110 self._draw.rectangle([origin, origin + size], fill=bg_color)
112 # Call the parent Text render method with parameters
113 super().render(next_text, spacing)
116class ButtonText(Text, Interactable, Queriable):
117 """
118 A Text subclass that can handle Button interactions.
119 Renders text as a clickable button with visual states.
120 """
122 def __init__(self, button: Button, font: Font, draw: ImageDraw.Draw,
123 padding: Tuple[int, int, int, int] = (4, 8, 4, 8),
124 source=None, line=None, page=None):
125 """
126 Initialize a button text object.
128 Args:
129 button: The abstract Button object to handle interactions
130 font: The base font style
131 draw: The drawing context
132 padding: Padding around the button text (top, right, bottom, left)
133 source: Optional source object
134 line: Optional line container
135 page: Optional parent page (for dirty flag management)
136 """
137 # Initialize Text with the button label
138 Text.__init__(self, button.label, font, draw, source, line)
140 # Initialize Interactable with the button's execute method
141 Interactable.__init__(self, button.execute)
143 # Store button properties
144 self._button = button
145 self._padding = padding
146 self._page = page
147 self._pressed = False
148 self._hovered = False
150 # Recalculate dimensions to include padding
151 # Use getattr to handle mock objects in tests
152 text_width = getattr(
153 self, '_width', 0) if not hasattr(
154 self._width, '__call__') else 0
155 self._padded_width = text_width + padding[1] + padding[3]
156 self._padded_height = self._style.font_size + padding[0] + padding[2]
158 @property
159 def button(self) -> Button:
160 """Get the associated Button object"""
161 return self._button
163 @property
164 def size(self) -> np.ndarray:
165 """Get the padded size of the button"""
166 return np.array([self._padded_width, self._padded_height])
168 def set_pressed(self, pressed: bool):
169 """Set the pressed state"""
170 self._pressed = pressed
171 self._mark_page_dirty()
173 def set_hovered(self, hovered: bool):
174 """Set the hover state"""
175 self._hovered = hovered
176 self._mark_page_dirty()
178 def set_page(self, page):
179 """
180 Set the parent page reference for dirty flag management.
182 Args:
183 page: The Page object containing this element
184 """
185 self._page = page
187 def _mark_page_dirty(self):
188 """Mark the parent page as dirty if available"""
189 if self._page and hasattr(self._page, 'mark_dirty'): 189 ↛ 190line 189 didn't jump to line 190 because the condition on line 189 was never true
190 self._page.mark_dirty()
192 def render(self):
193 """
194 Render the button with background, border, and text.
195 """
196 # Determine button colors based on state
197 if not self._button.enabled:
198 # Disabled button
199 bg_color = (200, 200, 200)
200 border_color = (150, 150, 150)
201 text_color = (100, 100, 100)
202 elif self._pressed: 202 ↛ 204line 202 didn't jump to line 204 because the condition on line 202 was never true
203 # Pressed button
204 bg_color = (70, 130, 180)
205 border_color = (50, 100, 150)
206 text_color = (255, 255, 255)
207 elif self._hovered: 207 ↛ 209line 207 didn't jump to line 209 because the condition on line 207 was never true
208 # Hovered button
209 bg_color = (100, 160, 220)
210 border_color = (70, 130, 180)
211 text_color = (255, 255, 255)
212 else:
213 # Normal button
214 bg_color = (100, 150, 200)
215 border_color = (70, 120, 170)
216 text_color = (255, 255, 255)
218 # Draw button background with rounded corners
219 # rounded_rectangle expects [x0, y0, x1, y1] format
220 button_rect = [
221 int(self._origin[0]),
222 int(self._origin[1]),
223 int(self._origin[0] + self.size[0]),
224 int(self._origin[1] + self.size[1])
225 ]
226 self._draw.rounded_rectangle(button_rect, fill=bg_color,
227 outline=border_color, width=1, radius=4)
229 # Update text color and render text centered within padding
230 self._style = self._style.with_colour(text_color)
231 text_x = self._origin[0] + self._padding[3] # left padding
233 # Center text vertically within button
234 # Get font metrics to properly center the baseline
235 ascent, descent = self._style.font.getmetrics()
237 # Total button height minus top and bottom padding gives us text area height
238 text_area_height = self._padded_height - self._padding[0] - self._padding[2]
240 # Center the text visual height (ascent + descent) within the text area
241 # The y position is where the baseline sits
242 # Visual center = area_height/2, baseline should be at center + descent/2
243 vertical_center = text_area_height / 2
244 text_y = self._origin[1] + self._padding[0] + vertical_center + (descent / 2)
246 # Temporarily set origin for text rendering
247 original_origin = self._origin.copy()
248 self._origin = np.array([text_x, text_y])
250 # Call parent render method for the text
251 super().render()
253 # Restore original origin
254 self._origin = original_origin
256 def in_object(self, point) -> bool:
257 """
258 Check if a point is within this button.
260 Args:
261 point: The coordinates to check
263 Returns:
264 True if the point is within the button bounds (including padding)
265 """
266 point_array = np.array(point)
267 relative_point = point_array - self._origin
269 # Check if the point is within the padded button boundaries
270 return (0 <= relative_point[0] < self._padded_width and
271 0 <= relative_point[1] < self._padded_height)
274class FormFieldText(Text, Interactable, Queriable):
275 """
276 A Text subclass that can handle FormField interactions.
277 Renders form field labels and input areas.
278 """
280 def __init__(self, field: FormField, font: Font, draw: ImageDraw.Draw,
281 field_height: int = 24, source=None, line=None):
282 """
283 Initialize a form field text object.
285 Args:
286 field: The abstract FormField object to handle interactions
287 font: The base font style for the label
288 draw: The drawing context
289 field_height: Height of the input field area
290 source: Optional source object
291 line: Optional line container
292 """
293 # Initialize Text with the field label
294 Text.__init__(self, field.label, font, draw, source, line)
296 # Initialize Interactable - form fields don't have direct callbacks
297 # but can notify of focus/value changes
298 Interactable.__init__(self, None)
300 # Store field properties
301 self._field = field
302 self._field_height = field_height
303 self._focused = False
305 # Calculate total height (label + gap + field)
306 self._total_height = self._style.font_size + 5 + field_height
308 # Field width should be at least as wide as the label
309 # Use getattr to handle mock objects in tests
310 text_width = getattr(
311 self, '_width', 0) if not hasattr(
312 self._width, '__call__') else 0
313 self._field_width = max(text_width, 150)
315 @property
316 def field(self) -> FormField:
317 """Get the associated FormField object"""
318 return self._field
320 @property
321 def size(self) -> np.ndarray:
322 """Get the total size including label and field"""
323 return np.array([self._field_width, self._total_height])
325 def set_focused(self, focused: bool):
326 """Set the focus state"""
327 self._focused = focused
329 def render(self):
330 """
331 Render the form field with label and input area.
332 """
333 # Render the label
334 super().render()
336 # Calculate field position (below label with 5px gap)
337 field_x = self._origin[0]
338 field_y = self._origin[1] + self._style.font_size + 5
340 # Draw field background and border
341 bg_color = (255, 255, 255)
342 border_color = (100, 150, 200) if self._focused else (200, 200, 200)
344 field_rect = [(field_x, field_y),
345 (field_x + self._field_width, field_y + self._field_height)]
346 self._draw.rectangle(field_rect, fill=bg_color, outline=border_color, width=1)
348 # Render field value if present
349 if self._field.value is not None:
350 value_text = str(self._field.value)
352 # For password fields, mask the text
353 if self._field.field_type == FormFieldType.PASSWORD:
354 value_text = "•" * len(value_text)
356 # Create a temporary Text object for the value
357 value_font = self._style.with_colour((0, 0, 0))
359 # Position value text within field (with some padding)
360 # Get font metrics to properly center the baseline
361 ascent, descent = value_font.font.getmetrics()
363 # Center the text vertically within the field
364 # The y coordinate is where the baseline sits (anchor="ls")
365 vertical_center = self._field_height / 2
366 value_x = field_x + 5
367 value_y = field_y + vertical_center + (descent / 2)
369 # Draw the value text
370 self._draw.text((value_x, value_y), value_text,
371 font=value_font.font, fill=value_font.colour, anchor="ls")
373 def handle_click(self, point) -> bool:
374 """
375 Handle clicks on the form field.
377 Args:
378 point: The click coordinates relative to this field
380 Returns:
381 True if the field was clicked and focused
382 """
383 # Calculate field area
384 field_y = self._style.font_size + 5
386 # Check if click is within the input field area (not just the label)
387 if (0 <= point[0] <= self._field_width and
388 field_y <= point[1] <= field_y + self._field_height):
389 self.set_focused(True)
390 return True
392 return False
394 def in_object(self, point) -> bool:
395 """
396 Check if a point is within this form field (including label and input area).
398 Args:
399 point: The coordinates to check
401 Returns:
402 True if the point is within the field bounds
403 """
404 point_array = np.array(point)
405 relative_point = point_array - self._origin
407 # Check if the point is within the total field area
408 return (0 <= relative_point[0] < self._field_width and
409 0 <= relative_point[1] < self._total_height)
412# Factory functions for creating functional text objects
413def create_link_text(link: Link, text: str, font: Font,
414 draw: ImageDraw.Draw) -> LinkText:
415 """
416 Factory function to create a LinkText object.
418 Args:
419 link: The Link object to associate with the text
420 text: The text content to display
421 font: The base font style
422 draw: The drawing context
424 Returns:
425 A LinkText object ready for rendering and interaction
426 """
427 return LinkText(link, text, font, draw)
430def create_button_text(button: Button, font: Font, draw: ImageDraw.Draw,
431 padding: Tuple[int, int, int, int] = (4, 8, 4, 8)) -> ButtonText:
432 """
433 Factory function to create a ButtonText object.
435 Args:
436 button: The Button object to associate with the text
437 font: The base font style
438 draw: The drawing context
439 padding: Padding around the button text
441 Returns:
442 A ButtonText object ready for rendering and interaction
443 """
444 return ButtonText(button, font, draw, padding)
447def create_form_field_text(field: FormField, font: Font, draw: ImageDraw.Draw,
448 field_height: int = 24) -> FormFieldText:
449 """
450 Factory function to create a FormFieldText object.
452 Args:
453 field: The FormField object to associate with the text
454 font: The base font style for the label
455 draw: The drawing context
456 field_height: Height of the input field area
458 Returns:
459 A FormFieldText object ready for rendering and interaction
460 """
461 return FormFieldText(field, font, draw, field_height)