weasyprint 65.1__py3-none-any.whl → 67.0__py3-none-any.whl

weasyprint/formatting_structure/build.py

@@ -142,6 +142,8 @@ def element_to_box(element, style_for, get_image_from_uri, base_url,
             style['display'] = ('inline', 'flow')
 
     box = make_box(element.tag, style, [], element)
+    box.first_letter_style = style_for(element, 'first-letter')
+    box.first_line_style = style_for(element, 'first-line')
 
     if state is None:
         # use a list to have a shared mutable object
@@ -162,9 +164,6 @@ def element_to_box(element, style_for, get_image_from_uri, base_url,
     # names will be in this new list
     counter_scopes.append(set())
 
-    box.first_letter_style = style_for(element, 'first-letter')
-    box.first_line_style = style_for(element, 'first-line')
-
     marker_boxes = []
     if 'list-item' in style['display']:
         marker_boxes = list(marker_to_box(
@@ -195,9 +194,10 @@ def element_to_box(element, style_for, get_image_from_uri, base_url,
             footnote = child_boxes[0]
             footnote.style['float'] = 'none'
             footnotes.append(footnote)
-            call_style = style_for(element, 'footnote-call')
+            call_style = style_for(footnote.element, 'footnote-call')
             footnote_call = make_box(
-                f'{element.tag}::footnote-call', call_style, [], element)
+                f'{footnote.element.tag}::footnote-call', call_style, [],
+                footnote.element)
             footnote_call.children = content_to_boxes(
                 call_style, footnote_call, quote_depth, counter_values,
                 get_image_from_uri, target_collector, counter_style)
@@ -250,7 +250,7 @@ def element_to_box(element, style_for, get_image_from_uri, base_url,
         marker = make_box(
             f'{element.tag}::footnote-marker', marker_style, [], element)
         marker.children = content_to_boxes(
-            marker_style, box, quote_depth, counter_values, get_image_from_uri,
+            marker_style, marker, quote_depth, counter_values, get_image_from_uri,
             target_collector, counter_style)
         box.children.insert(0, marker)
 
@@ -344,7 +344,6 @@ def marker_to_box(element, state, parent_style, style_for, get_image_from_uri,
         if not children and style['list_style_type'] != 'none':
             counter_value = counter_values.get('list-item', [0])[-1]
             counter_type = style['list_style_type']
-            # TODO: rtl numbered list has the dot on the left
             if marker_text := counter_style.render_marker(counter_type, counter_value):
                 box = boxes.TextBox.anonymous_from(box, marker_text)
                 box.style['white_space'] = 'pre-wrap'
@@ -358,13 +357,7 @@ def marker_to_box(element, state, parent_style, style_for, get_image_from_uri,
         # We can safely edit everything that can't be changed by user style
         # See https://drafts.csswg.org/css-pseudo-4/#marker-pseudo
         marker_box.style['position'] = 'absolute'
-        if parent_style['direction'] == 'ltr':
-            translate_x = properties.Dimension(-100, '%')
-        else:
-            translate_x = properties.Dimension(100, '%')
-        translate_y = properties.ZERO_PIXELS
-        marker_box.style['transform'] = (
-            ('translate', (translate_x, translate_y)),)
+        marker_box.is_outside_marker = True
     else:
         marker_box = boxes.InlineBox.anonymous_from(box, children)
     yield marker_box
@@ -421,7 +414,7 @@ def compute_content_list(content_list, parent_box, counter_values, css_token,
         elif type_ == 'url' and get_image_from_uri is not None:
             origin, uri = value
             if origin != 'external':
-                # Embedding internal references is impossible
+                # Embedding internal references is impossible.
                 continue
             image = get_image_from_uri(
                 url=uri, orientation=parent_box.style['image_orientation'])
@@ -431,12 +424,12 @@ def compute_content_list(content_list, parent_box, counter_values, css_token,
         elif type_ == 'content()':
             added_text = extract_text(value, parent_box)
             # Simulate the step of white space processing
-            # (normally done during the layout)
+            # (normally done during the layout).
             add_text(added_text.strip())
         elif type_ == 'string()':
             if not in_page_context:
-                # string() is currently only valid in @page context
-                # See https://github.com/Kozea/WeasyPrint/issues/723
+                # string() is currently only valid in @page context.
+                # See issue #723.
                 LOGGER.warning(
                     '"string(%s)" is only allowed in page margins',
                     ' '.join(value))
@@ -810,9 +803,9 @@ def table_boxes_children(box, children):
     children = [
         child
         for prev_child, child, next_child in zip(
-            [None] + children[:-1],
+            [None, *children[:-1]],
             children,
-            children[1:] + [None]
+            [*children[1:], None]
         )
         if not (
             # Ignore some whitespace: rule 1.4
@@ -990,6 +983,24 @@ def wrap_table(box, children):
     return wrapper
 
 
+def blockify(box, layout):
+    """Turn an inline box into a block box."""
+    # See https://drafts.csswg.org/css-display-4/#blockify.
+    if isinstance(box, boxes.InlineBlockBox):
+        anonymous = boxes.BlockBox.anonymous_from(box, box.children)
+    elif isinstance(box, boxes.InlineReplacedBox):
+        replacement = box.replacement
+        anonymous = boxes.BlockReplacedBox.anonymous_from(box, replacement)
+    elif isinstance(box, boxes.InlineLevelBox):
+        anonymous = boxes.BlockBox.anonymous_from(box, [box])
+        setattr(box, f'is_{layout}_item', False)
+    else:
+        return box
+    anonymous.style = box.style
+    setattr(anonymous, f'is_{layout}_item', True)
+    return anonymous
+
+
 def flex_boxes(box):
     """Remove and add boxes according to the flex model.
 
@@ -1019,18 +1030,7 @@ def flex_children(box, children):
                 # affected by the white-space property"
                 # https://www.w3.org/TR/css-flexbox-1/#flex-items
                 continue
-            if isinstance(child, boxes.InlineBlockBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, child.children)
-                anonymous.style = child.style
-                anonymous.is_flex_item = True
-                flex_children.append(anonymous)
-            elif isinstance(child, boxes.InlineLevelBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, [child])
-                anonymous.style = child.style
-                anonymous.is_flex_item = True
-                flex_children.append(anonymous)
-            else:
-                flex_children.append(child)
+            flex_children.append(blockify(child, 'flex'))
         return flex_children
     else:
         return children
@@ -1064,19 +1064,7 @@ def grid_children(box, children):
                 # affected by the white-space property"
                 # https://drafts.csswg.org/css-grid-2/#grid-item
                 continue
-            if isinstance(child, boxes.InlineBlockBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, child.children)
-                anonymous.style = child.style
-                anonymous.is_grid_item = True
-                grid_children.append(anonymous)
-            elif isinstance(child, boxes.InlineLevelBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, [child])
-                anonymous.style = child.style
-                child.is_grid_item = False
-                anonymous.is_grid_item = True
-                grid_children.append(anonymous)
-            else:
-                grid_children.append(child)
+            grid_children.append(blockify(child, 'grid'))
         return grid_children
     else:
         return children

weasyprint/images.py

@@ -6,15 +6,12 @@ import struct
 from hashlib import md5
 from io import BytesIO
 from itertools import cycle
-from math import inf
 from pathlib import Path
-from urllib.parse import urlparse
-from urllib.request import url2pathname
 from xml.etree import ElementTree
 
 import pydyf
 from PIL import Image, ImageFile, ImageOps
-from tinycss2.color4 import parse_color
+from tinycss2.color5 import parse_color
 
 from . import DEFAULT_OPTIONS
 from .layout.percent import percentage
@@ -65,12 +62,12 @@ class RasterImage:
         self.mode = pillow_image.mode
         self.width = pillow_image.width
         self.height = pillow_image.height
-        self.ratio = (self.width / self.height) if self.height != 0 else inf
+        self.ratio = (self.width / self.height) if self.height != 0 else math.inf
         self.optimize = optimize = options['optimize_images']
 
         # The presence of the APP14 segment indicates an Adobe image with
         # inverted CMYK data. Specify a Decode Array to invert it again back to
-        # normal. See https://github.com/Kozea/WeasyPrint/pull/2179.
+        # normal. See PR #2179.
         app14 = getattr(original_pillow_image, 'app', {}).get('APP14')
         self.invert_colors = self.mode == 'CMYK' and app14 is not None
 
@@ -96,10 +93,11 @@ class RasterImage:
     def get_intrinsic_size(self, resolution, font_size):
         return self.width / resolution, self.height / resolution, self.ratio
 
-    def draw(self, stream, concrete_width, concrete_height, image_rendering):
+    def draw(self, stream, concrete_width, concrete_height, style):
         if self.width <= 0 or self.height <= 0:
             return
 
+        image_rendering = style['image_rendering']
         interpolate = image_rendering == 'auto'
         ratio = 1
         if self._dpi:
@@ -258,7 +256,8 @@ class LazyLocalImage(pydyf.Object):
 
 class SVGImage:
     def __init__(self, tree, base_url, url_fetcher, context):
-        self._svg = SVG(tree, base_url)
+        font_config = context.font_config if context else None
+        self._svg = SVG(tree, base_url, font_config)
         self._base_url = base_url
         self._url_fetcher = url_fetcher
         self._context = context
@@ -281,7 +280,7 @@ class SVGImage:
             ratio = 1
         return width, height, ratio
 
-    def draw(self, stream, concrete_width, concrete_height, image_rendering):
+    def draw(self, stream, concrete_width, concrete_height, _style):
         try:
             self._svg.draw(
                 stream, concrete_width, concrete_height, self._base_url,
@@ -299,11 +298,6 @@ def get_image_from_uri(cache, url_fetcher, options, url, forced_mime_type=None,
 
     try:
         with fetch(url_fetcher, url) as result:
-            parsed_url = urlparse(result.get('redirected_url'))
-            if parsed_url.scheme == 'file':
-                filename = url2pathname(parsed_url.path)
-            else:
-                filename = None
             if 'string' in result:
                 string = result['string']
             else:
@@ -337,9 +331,9 @@ def get_image_from_uri(cache, url_fetcher, options, url, forced_mime_type=None,
             else:
                 # Store image id to enable cache in Stream.add_image
                 image_id = md5(url.encode(), usedforsecurity=False).hexdigest()
+                path = result.get('path')
                 image = RasterImage(
-                    pillow_image, image_id, string, filename, cache,
-                    orientation, options)
+                    pillow_image, image_id, string, path, cache, orientation, options)
 
     except (URLFetchingError, ImageLoadingError) as exception:
         LOGGER.error('Failed to load image at %r: %s', url, exception)
@@ -374,8 +368,8 @@ def rotate_pillow_image(pillow_image, orientation):
     return pillow_image
 
 
-def process_color_stops(vector_length, positions):
-    """Give color stops positions on the gradient vector.
+def process_color_stops(vector_length, positions, hints, style):
+    """Give color stops positions and hints on the gradient vector.
 
     ``vector_length`` is the distance between the starting point and ending
     point of the vector gradient.
@@ -388,16 +382,17 @@ def process_color_stops(vector_length, positions):
     Return processed color stops, as a list of floats in px.
 
     """
-    # Resolve percentages
-    positions = [percentage(position, vector_length) for position in positions]
+    # Resolve percentages.
+    positions = [percentage(position, style, vector_length) for position in positions]
+    hints = [percentage(hint, style, vector_length) / vector_length for hint in hints]
 
-    # First and last default to 100%
+    # First and last default to 100%.
     if positions[0] is None:
         positions[0] = 0
     if positions[-1] is None:
         positions[-1] = vector_length
 
-    # Make sure positions are increasing
+    # Make sure positions are increasing.
     previous_pos = positions[0]
     for i, position in enumerate(positions):
         if position is not None:
@@ -406,7 +401,7 @@ def process_color_stops(vector_length, positions):
             else:
                 previous_pos = position
 
-    # Assign missing values
+    # Assign missing values.
     previous_i = -1
     for i, position in enumerate(positions):
         if position is not None:
@@ -416,7 +411,13 @@ def process_color_stops(vector_length, positions):
                 positions[j] = base + j * increment
             previous_i = i
 
-    return positions
+    # Calculate exponential value for PDF hints, avoid big numbers.
+    hints = [
+        0 if hint <= 0 else
+        2 ** 32 if hint >= 1 else
+        min(2 ** 32, math.log(0.5, hint)) for hint in hints]
+
+    return positions, hints
 
 
 def normalize_stop_positions(positions):
@@ -473,21 +474,23 @@ def gradient_average_color(colors, positions):
 
 
 class Gradient:
-    def __init__(self, color_stops, repeating):
+    def __init__(self, color_stops, repeating, color_hints):
         assert color_stops
         # List of (r, g, b, a)
         self.colors = tuple(color for color, _ in color_stops)
         # List of Dimensions
         self.stop_positions = tuple(position for _, position in color_stops)
+        # List of Dimensions
+        self.color_hints = color_hints
         # Boolean
         self.repeating = repeating
 
     def get_intrinsic_size(self, image_resolution, font_size):
         return None, None, None
 
-    def draw(self, stream, concrete_width, concrete_height, _image_rendering):
-        scale_y, type_, points, positions, colors = self.layout(
-            concrete_width, concrete_height)
+    def draw(self, stream, concrete_width, concrete_height, style):
+        scale_y, type_, points, positions, colors, color_hints = self.layout(
+            concrete_width, concrete_height, style)
 
         if type_ == 'solid':
             stream.rectangle(0, 0, concrete_width, concrete_height)
@@ -497,11 +500,11 @@ class Gradient:
 
         alphas = [color[3] for color in colors]
         alpha_couples = [
-            (alphas[i], alphas[i + 1])
+            [alphas[i], alphas[i + 1], color_hints[i]]
             for i in range(len(alphas) - 1)]
         # TODO: handle other color spaces.
         color_couples = [
-            [colors[i].to('srgb')[:3], colors[i + 1].to('srgb')[:3], 1]
+            [colors[i].to('srgb')[:3], colors[i + 1].to('srgb')[:3], color_hints[i]]
             for i in range(len(colors) - 1)]
 
         # Premultiply colors
@@ -511,7 +514,7 @@ class Gradient:
                     color_couples[i - 1][1] = color_couples[i - 1][0]
                 if i < len(colors) - 1:
                     color_couples[i][0] = color_couples[i][1]
-        for i, (a0, a1) in enumerate(alpha_couples):
+        for i, (a0, a1, hint) in enumerate(alpha_couples):
             if 0 not in (a0, a1) and (a0, a1) != (1, 1):
                 color_couples[i][2] = a0 / a1
 
@@ -521,8 +524,8 @@ class Gradient:
         encode = (len(colors) - 1) * (0, 1)
         bounds = positions[1:-1]
         sub_functions = (
-            stream.create_interpolation_function((0, 1), c0, c1, n)
-            for c0, c1, n in color_couples)
+            stream.create_interpolation_function((0, 1), c0, c1, hint)
+            for c0, c1, hint in color_couples)
         function = stream.create_stitching_function(
             domain, encode, bounds, sub_functions)
         # TODO: handle other color spaces.
@@ -536,8 +539,8 @@ class Gradient:
 
             shading_type = 2 if type_ == 'linear' else 3
             sub_functions = (
-                stream.create_interpolation_function((0, 1), (c0,), (c1,), 1)
-                for c0, c1 in alpha_couples)
+                stream.create_interpolation_function((0, 1), (c0,), (c1,), hint)
+                for c0, c1, hint in alpha_couples)
             function = stream.create_stitching_function(
                 domain, encode, bounds, sub_functions)
             alpha_shading = alpha_stream.add_shading(
@@ -547,10 +550,11 @@ class Gradient:
 
         stream.paint_shading(shading.id)
 
-    def layout(self, width, height):
+    def layout(self, width, height, style):
         """Get layout information about the gradient.
 
         width, height: Gradient box. Top-left is at coordinates (0, 0).
+        style: box computed style.
 
         Returns (scale_y, type_, points, positions, colors).
 
@@ -572,15 +576,15 @@ class Gradient:
 
 
 class LinearGradient(Gradient):
-    def __init__(self, color_stops, direction, repeating):
-        Gradient.__init__(self, color_stops, repeating)
+    def __init__(self, color_stops, direction, repeating, color_hints):
+        super().__init__(color_stops, repeating, color_hints)
         # ('corner', keyword) or ('angle', radians)
         self.direction_type, self.direction = direction
 
-    def layout(self, width, height):
+    def layout(self, width, height, style):
         # Only one color, render the gradient as a solid color
         if len(self.colors) == 1:
-            return 1, 'solid', None, [], [self.colors[0]]
+            return 1, 'solid', None, [], [self.colors[0]], []
 
         # Define the (dx, dy) unit vector giving the direction of the gradient.
         # Positive dx: right, positive dy: down.
@@ -606,16 +610,19 @@ class LinearGradient(Gradient):
         # Normalize colors positions
         colors = list(self.colors)
         vector_length = abs(width * dx) + abs(height * dy)
-        positions = process_color_stops(vector_length, self.stop_positions)
+        positions, hints = process_color_stops(
+            vector_length, self.stop_positions, self.color_hints, style)
         if not self.repeating:
             # Add explicit colors at boundaries if needed, because PDF doesn’t
             # extend color stops that are not displayed
             if positions[0] == positions[1]:
                 positions.insert(0, positions[0] - 1)
                 colors.insert(0, colors[0])
+                hints.insert(0, 1)
             if positions[-2] == positions[-1]:
                 positions.append(positions[-1] + 1)
                 colors.append(colors[-1])
+                hints.append(1)
         first, last, positions = normalize_stop_positions(positions)
 
         if self.repeating:
@@ -623,7 +630,7 @@ class LinearGradient(Gradient):
             # See https://drafts.csswg.org/css-images-3/#repeating-gradients
             if first == last:
                 color = gradient_average_color(colors, positions)
-                return 1, 'solid', None, [], [color]
+                return 1, 'solid', None, [], [color], []
 
             # Define defined gradient length and steps between positions
             stop_length = last - first
@@ -635,13 +642,16 @@ class LinearGradient(Gradient):
             # Create cycles used to add colors
             next_steps = cycle((0, *position_steps))
             next_colors = cycle(colors)
+            next_hints = cycle(hints)
             previous_steps = cycle((0, *position_steps[::-1]))
             previous_colors = cycle(colors[::-1])
+            previous_hints = cycle(hints[::-1])
 
             # Add colors after last step
             while last < vector_length:
                 step = next(next_steps)
                 colors.append(next(next_colors))
+                hints.append(next(next_hints))
                 positions.append(positions[-1] + step)
                 last += step * stop_length
 
@@ -649,6 +659,7 @@ class LinearGradient(Gradient):
             while first > 0:
                 step = next(previous_steps)
                 colors.insert(0, next(previous_colors))
+                hints.insert(0, next(previous_hints))
                 positions.insert(0, positions[0] - step)
                 first -= step * stop_length
 
@@ -659,12 +670,12 @@ class LinearGradient(Gradient):
             start_x + dx * first, start_y + dy * first,
             start_x + dx * last, start_y + dy * last)
 
-        return 1, 'linear', points, positions, colors
+        return 1, 'linear', points, positions, colors, hints
 
 
 class RadialGradient(Gradient):
-    def __init__(self, color_stops, shape, size, center, repeating):
-        Gradient.__init__(self, color_stops, repeating)
+    def __init__(self, color_stops, shape, size, center, repeating, color_hints):
+        super().__init__(color_stops, repeating, color_hints)
         # Center of the ending shape. (origin_x, pos_x, origin_y, pos_y)
         self.center = center
         # Type of ending shape: 'circle' or 'ellipse'
@@ -676,15 +687,15 @@ class RadialGradient(Gradient):
         #   size: (radius_x, radius_y)
         self.size_type, self.size = size
 
-    def layout(self, width, height):
+    def layout(self, width, height, style):
         # Only one color, render the gradient as a solid color
         if len(self.colors) == 1:
-            return 1, 'solid', None, [], [self.colors[0]]
+            return 1, 'solid', None, [], [self.colors[0]], []
 
         # Define the center of the gradient
         origin_x, center_x, origin_y, center_y = self.center
-        center_x = percentage(center_x, width)
-        center_y = percentage(center_y, height)
+        center_x = percentage(center_x, style, width)
+        center_y = percentage(center_y, style, height)
         if origin_x == 'right':
             center_x = width - center_x
         if origin_y == 'bottom':
@@ -692,21 +703,24 @@ class RadialGradient(Gradient):
 
         # Resolve sizes and vertical scale
         size_x, size_y = self._handle_degenerate(
-            *self._resolve_size(width, height, center_x, center_y))
+            *self._resolve_size(width, height, center_x, center_y, style))
         scale_y = size_y / size_x
 
         # Normalize colors positions
         colors = list(self.colors)
-        positions = process_color_stops(size_x, self.stop_positions)
+        positions, hints = process_color_stops(
+            size_x, self.stop_positions, self.color_hints, style)
         if not self.repeating:
             # Add explicit colors at boundaries if needed, because PDF doesn’t
             # extend color stops that are not displayed
             if positions[0] > 0 and positions[0] == positions[1]:
                 positions.insert(0, 0)
                 colors.insert(0, colors[0])
+                hints.insert(0, 1)
             if positions[-2] == positions[-1]:
                 positions.append(positions[-1] + 1)
                 colors.append(colors[-1])
+                hints.append(1)
         if positions[0] < 0:
             # PDF doesn’t like negative radiuses, shift into the positive realm
             if self.repeating:
@@ -718,7 +732,7 @@ class RadialGradient(Gradient):
                 # Only keep colors with position >= 0, interpolate if needed
                 if positions[-1] <= 0:
                     # All stops are negative, fill with the last color
-                    return 1, 'solid', None, [], [self.colors[-1]]
+                    return 1, 'solid', None, [], [self.colors[-1]], []
                 for i, position in enumerate(positions):
                     if position == 0:
                         # Keep colors and positions from this rank
@@ -733,8 +747,8 @@ class RadialGradient(Gradient):
                         intermediate_color = gradient_average_color(
                             [previous_color, previous_color, color, color],
                             [previous_position, 0, 0, position])
-                        colors = [intermediate_color] + colors[i:]
-                        positions = [0] + positions[i:]
+                        colors = [intermediate_color, *colors[i:]]
+                        positions = [0, *positions[i:]]
                         break
         first, last, positions = normalize_stop_positions(positions)
 
@@ -742,7 +756,7 @@ class RadialGradient(Gradient):
         # See https://drafts.csswg.org/css-images-3/#repeating-gradients
         if first == last and self.repeating:
             color = gradient_average_color(colors, positions)
-            return 1, 'solid', None, [], [color]
+            return 1, 'solid', None, [], [color], []
 
         # Define the coordinates of the gradient circles
         points = (
@@ -753,7 +767,7 @@ class RadialGradient(Gradient):
             points, positions, colors = self._repeat(
                 width, height, scale_y, points, positions, colors)
 
-        return scale_y, 'radial', points, positions, colors
+        return scale_y, 'radial', points, positions, colors, hints
 
     def _repeat(self, width, height, scale_y, points, positions, colors):
         # Keep original lists and values, they’re useful
@@ -775,7 +789,7 @@ class RadialGradient(Gradient):
             colors *= repeat
             positions = [
                 i + position for i in range(repeat) for position in positions]
-            points = points[:5] + (points[5] + gradient_length * repeat_after,)
+            points = (*points[:5], points[5] + gradient_length * repeat_after)
 
         if points[2] == 0:
             # Inner circle has 0 radius, no need to repeat inside, return
@@ -785,7 +799,7 @@ class RadialGradient(Gradient):
         repeat_before = points[2] / gradient_length
 
         # Set the inner circle size to 0
-        points = points[:2] + (0,) + points[3:]
+        points = (*points[:2], 0, *points[3:])
 
         # Find how many times the whole gradient can be repeated
         full_repeat = int(repeat_before)
@@ -830,19 +844,19 @@ class RadialGradient(Gradient):
                 average_positions = [position, ratio, ratio, next_position]
                 zero_color = gradient_average_color(
                     average_colors, average_positions)
-                colors = [zero_color] + original_colors[-(i - 1):] + colors
+                colors = [zero_color, *original_colors[-(i - 1):], *colors]
                 new_positions = [
                     position - 1 - full_repeat for position
                     in original_positions[-(i - 1):]]
                 positions = (ratio - 1 - full_repeat, *new_positions, *positions)
                 return points, positions, colors
 
-    def _resolve_size(self, width, height, center_x, center_y):
+    def _resolve_size(self, width, height, center_x, center_y, style):
         """Resolve circle size of the radial gradient."""
         if self.size_type == 'explicit':
             size_x, size_y = self.size
-            size_x = percentage(size_x, width)
-            size_y = percentage(size_y, height)
+            size_x = percentage(size_x, style, width)
+            size_y = percentage(size_y, style, height)
             return size_x, size_y
         left = abs(center_x)
         right = abs(width - center_x)