mpl-richtext 0.1.4__tar.gz → 0.1.7__tar.gz

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpl-richtext
-Version: 0.1.4
+Version: 0.1.7
 Summary: Rich text rendering for Matplotlib with multi-color and multi-style support
 Home-page: https://github.com/ra8in/mpl-richtext
 Author: Rabin Katel
@@ -27,6 +27,8 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: uharfbuzz>=0.30.0
+Requires-Dist: fonttools>=4.34.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/mpl_richtext/core.py

@@ -2,8 +2,49 @@ import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
 from matplotlib.text import Text
 from matplotlib.lines import Line2D
+from matplotlib.lines import Line2D
+import matplotlib.font_manager as fm
+from matplotlib.font_manager import FontProperties, findfont
 from typing import List, Optional, Tuple, Union, Dict, Any
 
+from .shaping import ShapedText, HarfbuzzShaper, HAS_HARFBUZZ
+
+def _needs_complex_shaping(text: str) -> bool:
+    """
+    Check if text contains characters from complex scripts that need HarfBuzz shaping.
+    Currently checks for Devanagari (used for Nepali, Hindi, Sanskrit, etc.)
+    """
+    for char in text:
+        code = ord(char)
+        # Devanagari: U+0900 to U+097F
+        # Devanagari Extended: U+A8E0 to U+A8FF  
+        # Vedic Extensions: U+1CD0 to U+1CFF
+        if (0x0900 <= code <= 0x097F or 
+            0xA8E0 <= code <= 0xA8FF or
+            0x1CD0 <= code <= 0x1CFF):
+            return True
+    return False
+
+def _resolve_font_path(kwargs: Dict[str, Any]) -> Optional[str]:
+    """Helper to resolve font file path from text kwargs."""
+    fp = kwargs.get('fontproperties')
+    if fp:
+        return findfont(fp)
+        
+    font = kwargs.get('fontfamily') or kwargs.get('family')
+    if not font:
+        # Fallback to default
+        font = plt.rcParams['font.family'][0]
+    
+    if isinstance(font, list):
+        font = font[0]
+        
+    try:
+        fp = FontProperties(family=font)
+        return findfont(fp)
+    except Exception:
+        return None
+
 def richtext(
     x: float,
     y: float,
@@ -14,6 +55,7 @@ def richtext(
 ) -> List[Text]:
     """
     Display text with different colors and properties for each string, supporting word wrapping and alignment.
+    Supports complex scripts (e.g. Nepali) via manual shaping if uharfbuzz is installed.
 
     Parameters
     ----------
@@ -272,6 +314,46 @@ def _get_text_width(text: str, ax: Axes, renderer, **text_kwargs) -> float:
     kwargs = text_kwargs.copy()
     kwargs.pop('underline', None)
     
+    # Try shaping if available
+    if HAS_HARFBUZZ:
+        font = kwargs.get('fontfamily') or kwargs.get('family') or plt.rcParams['font.family'][0]
+        # Resolve font path
+        try:
+            # Handle fontfamily being None or list
+            if not font:
+                 font = plt.rcParams['font.family'][0]
+            if isinstance(font, list):
+                font = font[0]
+                
+            fp = FontProperties(family=font)
+            path = findfont(fp)
+            
+            # Simple caching could go here
+            if path:
+                fontsize = kwargs.get('fontsize') or kwargs.get('size') or plt.rcParams['font.size']
+                shaper = HarfbuzzShaper(path)
+                width_points = shaper.get_text_width(text, fontsize)
+                
+                # Convert points -> pixels -> data
+                # 1. Points to Pixels
+                pixels = renderer.points_to_pixels(width_points)
+                
+                # 2. Pixels to Data
+                # We can measure the width of a 0-width line vs 'pixels'-width line?
+                # Or use proper transform math.
+                # bbox width in pixels = 'pixels'.
+                # We want width in data.
+                
+                # Create a bbox in display coords
+                from matplotlib.transforms import Bbox
+                bbox_display = Bbox.from_bounds(0, 0, pixels, 0)
+                
+                # Transform to data coords
+                bbox_data = bbox_display.transformed(ax.transData.inverted())
+                return bbox_data.width
+        except Exception:
+            pass # Fallback to native
+
     t = ax.text(0, 0, text, **kwargs)
     bbox = t.get_window_extent(renderer=renderer)
     bbox_data = bbox.transformed(ax.transData.inverted())
@@ -280,12 +362,95 @@ def _get_text_width(text: str, ax: Axes, renderer, **text_kwargs) -> float:
     return w
 
 
+def _get_text_metrics(text: str, ax: Axes, renderer, **text_kwargs) -> tuple:
+    """
+    Get text metrics: (width, ascent) in data units.
+    - width: horizontal extent
+    - ascent: distance from baseline to top of text
+    """
+    kwargs = text_kwargs.copy()
+    kwargs.pop('underline', None)
+    
+    # Try shaping if available
+    # Only use HarfBuzz measurement if the text actually needs complex shaping.
+    # Otherwise, trust Matplotlib's native measurement which handles font fallback (e.g. lists of fonts) better.
+    if HAS_HARFBUZZ and _needs_complex_shaping(text):
+        path = _resolve_font_path(kwargs)
+        try:
+            if path:
+                fontsize = kwargs.get('fontsize') or kwargs.get('size') or plt.rcParams['font.size']
+                shaper = HarfbuzzShaper(path)
+                
+                # Get width and ascent in points
+                width_points = shaper.get_text_width(text, fontsize)
+                ascent_points = shaper.get_ascent(fontsize)
+                
+                # Convert to pixels then to data units
+                from matplotlib.transforms import Bbox
+                
+                width_px = renderer.points_to_pixels(width_points)
+                ascent_px = renderer.points_to_pixels(ascent_points)
+                
+                # Width: horizontal conversion
+                bbox_w = Bbox.from_bounds(0, 0, width_px, 0)
+                width_data = bbox_w.transformed(ax.transData.inverted()).width
+                
+                # Ascent: vertical conversion
+                bbox_a = Bbox.from_bounds(0, 0, 0, ascent_px)
+                ascent_data = bbox_a.transformed(ax.transData.inverted()).height
+                
+                return (width_data, ascent_data)
+        except Exception:
+            pass  # Fallback to native
+    
+    # Native measurement
+    t = ax.text(0, 0, text, **kwargs)
+    bbox = t.get_window_extent(renderer=renderer)
+    bbox_data = bbox.transformed(ax.transData.inverted())
+    
+    width_data = bbox_data.width
+    # For native text, ascent ≈ height (simplified; baseline is at bottom of bbox)
+    ascent_data = bbox_data.height
+    
+    t.remove()
+    return (width_data, ascent_data)
+
+
 def _get_text_height(text: str, ax: Axes, renderer, **text_kwargs) -> float:
     """Measure the height of a text string."""
     # Remove custom properties that ax.text doesn't understand
     kwargs = text_kwargs.copy()
     kwargs.pop('underline', None)
 
+    # Try shaping-based height for Devanagari fonts
+    # This avoids measuring with Latin chars that the font might not have
+    if HAS_HARFBUZZ:
+        path = _resolve_font_path(kwargs)
+        try:
+            # Check if this is a known Devanagari font (simplified check via path for now? 
+            # Or assume if resolving worked and contained Devanagari chars earlier...
+            # Actually valid logic: if we are here and path resolves, we trust it?
+            # But the original code restricted it to known fonts.
+            # Let's keep it generally open if path is found, OR check font name.
+            
+            if path:
+                # Optional: check for Devanagari-likeness if needed, but path resolution implies intent.
+                # However, for height specifically we only wanted this for specific fonts to avoid 'Hg'.
+                # Let's be permissive if path is found since we use shaper now.
+                
+                fontsize = kwargs.get('fontsize') or kwargs.get('size') or plt.rcParams['font.size']
+                shaper = HarfbuzzShaper(path)
+                height_points = shaper.get_font_height(fontsize)
+                
+                # Convert points -> pixels -> data
+                pixels = renderer.points_to_pixels(height_points)
+                from matplotlib.transforms import Bbox
+                bbox_display = Bbox.from_bounds(0, 0, 0, pixels)
+                bbox_data = bbox_display.transformed(ax.transData.inverted())
+                return bbox_data.height
+        except Exception:
+            pass  # Fallback to native
+
     # Use a representative character for height if text is empty or space
     # But we need the height of THIS specific font configuration.
     measure_text = text if text.strip() else "Hg"
@@ -302,24 +467,25 @@ def _build_lines_wrapped(
     ax: Axes, 
     renderer, 
     box_width: float
-) -> List[List[Tuple[str, Dict[str, Any], float]]]:
+) -> List[List[Tuple[str, Dict[str, Any], float, float]]]:
     """
     Group words into lines based on box_width.
+    Returns: List of lines, where each line is List of (word, props, width, ascent).
     """
-    lines: List[List[Tuple[str, Dict[str, Any], float]]] = []
-    current_line: List[Tuple[str, Dict[str, Any], float]] = []
+    lines: List[List[Tuple[str, Dict[str, Any], float, float]]] = []
+    current_line: List[Tuple[str, Dict[str, Any], float, float]] = []
     current_line_width = 0.0
 
     for word, props in words:
-        w = _get_text_width(word, ax, renderer, **props)
+        w, asc = _get_text_metrics(word, ax, renderer, **props)
         
         if current_line_width + w > box_width and current_line:
             # Wrap to new line
             lines.append(current_line)
-            current_line = [(word, props, w)]
+            current_line = [(word, props, w, asc)]
             current_line_width = w
         else:
-            current_line.append((word, props, w))
+            current_line.append((word, props, w, asc))
             current_line_width += w
             
     if current_line:
@@ -333,19 +499,20 @@ def _build_line_seamless(
     properties: List[Dict[str, Any]],
     ax: Axes,
     renderer
-) -> List[Tuple[str, Dict[str, Any], float]]:
+) -> List[Tuple[str, Dict[str, Any], float, float]]:
     """
     Build a single line from strings without splitting by spaces.
+    Returns: List of (string, props, width, ascent).
     """
-    line: List[Tuple[str, Dict[str, Any], float]] = []
+    line: List[Tuple[str, Dict[str, Any], float, float]] = []
     for string, props in zip(strings, properties):
-        w = _get_text_width(string, ax, renderer, **props)
-        line.append((string, props, w))
+        w, asc = _get_text_metrics(string, ax, renderer, **props)
+        line.append((string, props, w, asc))
     return line
 
 
 def _draw_lines(
-    lines: List[List[Tuple[str, Dict[str, Any], float]]],
+    lines: List[List[Tuple[str, Dict[str, Any], float, float]]],
     x: float,
     y: float,
     ax: Axes,
@@ -357,24 +524,26 @@ def _draw_lines(
     zorder: int
 ) -> List[Text]:
     """
-    Draw the lines of text onto the axes.
+    Draw the lines of text onto the axes using baseline alignment.
+    Each line item is (word, props, width, ascent).
     """
     text_objects: List[Text] = []
     
-    # Calculate height for each line
-    line_heights = []
+    # Calculate metrics for each line
+    line_metrics = []
     for line in lines:
-        # Find max height in this line
-        max_h = 0.0
-        for word, props, _ in line:
+        # Find max ascent and max total height in this line
+        max_ascent = max(item[3] for item in line) if line else 0.0
+        max_height = 0.0
+        for word, props, w, asc in line:
             h = _get_text_height(word, ax, renderer, **props)
-            if h > max_h:
-                max_h = h
-        line_heights.append(max_h * linespacing)
+            if h > max_height:
+                max_height = h
+        line_metrics.append((max_ascent, max_height * linespacing))
         
-    total_block_height = sum(line_heights)
+    total_block_height = sum(m[1] for m in line_metrics)
     
-    # Calculate top Y position based on vertical alignment
+    # Calculate top Y position based on vertical alignment of the block
     if va == 'center':
         top_y = y + (total_block_height / 2)
     elif va == 'top':
@@ -387,10 +556,11 @@ def _draw_lines(
     current_y = top_y
     
     for i, line in enumerate(lines):
-        line_height = line_heights[i]
+        max_ascent, line_height = line_metrics[i]
         
-        # Position line center
-        line_center_y = current_y - (line_height / 2)
+        # Calculate baseline position
+        # Baseline is at: top of line - max_ascent
+        baseline_y = current_y - max_ascent
         
         # Calculate line width for horizontal alignment
         line_width = sum(item[2] for item in line)
@@ -399,25 +569,42 @@ def _draw_lines(
             line_start_x = x - (line_width / 2)
         elif ha == 'right':
             line_start_x = x - line_width
-        else: # left
+        else:  # left
             line_start_x = x
             
         current_x = line_start_x
         
-        for word, props, w in line:
+        for word, props, w, asc in line:
             text_kwargs = props.copy()
             
             # Extract underline property
             underline = text_kwargs.pop('underline', False)
             
+            # Use baseline alignment for all text
             text_kwargs.update({
-                'va': 'center', 
+                'va': 'baseline', 
                 'ha': 'left',
                 'transform': transform,
                 'zorder': zorder
             })
             
-            t = ax.text(current_x, line_center_y, word, **text_kwargs)
+            # Determine if we should use ShapedText
+            used_shaper = False
+            t = None
+            
+            if HAS_HARFBUZZ and _needs_complex_shaping(word):
+                try:
+                    path = _resolve_font_path(text_kwargs)
+                    if path:
+                        t = ShapedText(current_x, baseline_y, word, font_path=path, **text_kwargs)
+                        ax.add_artist(t)
+                        used_shaper = True
+                except Exception as e:
+                    pass
+            
+            if not used_shaper:
+                t = ax.text(current_x, baseline_y, word, **text_kwargs)
+                
             text_objects.append(t)
             
             # Draw underline if requested
@@ -433,11 +620,34 @@ def _draw_lines(
                 # Let's put the underline at line_center_y - (h/2) - padding?
                 
                 # Let's use the bbox of the text object to find the bottom
-                bbox = t.get_window_extent(renderer=renderer)
-                bbox_data = bbox.transformed(ax.transData.inverted())
+                # bbox = t.get_window_extent(renderer=renderer)
+                # bbox_data = bbox.transformed(ax.transData.inverted())
                 
                 # y0 is the bottom of the text bbox
-                y_bottom = bbox_data.y0
+                # y_bottom = bbox_data.y0
+                
+                # Since ShapedText might behave differently with bbox, and we already know 'w'.
+                # And we aligned 'va=center'.
+                # Let's use the line_center_y and offset down.
+                # Text Height approximation:
+                fontsize = text_kwargs.get('fontsize', 12)
+                # data_height approximation? 
+                # This is risky if aspect ratio is not 1.
+                # Fallback to bbox logic, assuming draw has happened?
+                # ShapedText needs to be drawn to have a valid bbox?
+                # In Matplotlib, get_window_extent() triggers a draw if needed? 
+                # Or we can just trust the metrics.
+                
+                # For consistency with previous code, let's try getting bbox.
+                try:
+                    bbox = t.get_window_extent(renderer=renderer)
+                    bbox_data = bbox.transformed(ax.transData.inverted())
+                    y_bottom = bbox_data.y0
+                except Exception:
+                    # Fallback if renderer issue
+                    y_bottom = line_center_y - 5 # arbitrary?
+                
+                # Draw line from current_x to current_x + w
                 
                 # Draw line from current_x to current_x + w
                 # Use the same color as the text

mpl_richtext-0.1.7/mpl_richtext/shaping.py

@@ -0,0 +1,291 @@
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import matplotlib.font_manager as fm
+from matplotlib.path import Path
+from matplotlib.transforms import Affine2D
+from typing import List, Tuple, Optional, Any
+import warnings
+
+try:
+    import uharfbuzz as hb
+    from fontTools.ttLib import TTFont
+    from fontTools.pens.basePen import BasePen
+    HAS_HARFBUZZ = True
+except ImportError:
+    HAS_HARFBUZZ = False
+
+class MatplotlibPathPen(BasePen):
+    def __init__(self, glyphSet):
+        super().__init__(glyphSet)
+        self.verts = []
+        self.codes = []
+
+    def _moveTo(self, p):
+        self.verts.append(p)
+        self.codes.append(Path.MOVETO)
+
+    def _lineTo(self, p):
+        self.verts.append(p)
+        self.codes.append(Path.LINETO)
+
+    def _curveToOne(self, p1, p2, p3):
+        self.verts.extend([p1, p2, p3])
+        self.codes.extend([Path.CURVE4, Path.CURVE4, Path.CURVE4])
+
+    def _qCurveToOne(self, p1, p2):
+        self.verts.extend([p1, p2])
+        self.codes.extend([Path.CURVE3, Path.CURVE3])
+
+    def _closePath(self):
+        self.verts.append((0, 0))
+        self.codes.append(Path.CLOSEPOLY)
+
+class HarfbuzzShaper:
+    def __init__(self, font_path: str):
+        if not HAS_HARFBUZZ:
+            raise ImportError("uharfbuzz and fonttools are required for manual shaping.")
+            
+        self.font_path = font_path
+        
+        # Load for HarfBuzz
+        with open(font_path, 'rb') as f:
+            self.font_data = f.read()
+        self.face = hb.Face(self.font_data)
+        self.font = hb.Font(self.face)
+        self.upem = self.face.upem
+        self.font.scale = (self.upem, self.upem)
+        
+        # Load for Path Extraction
+        self.ttfont = TTFont(font_path)
+        self.glyph_set = self.ttfont.getGlyphSet()
+        self.glyph_order = self.ttfont.getGlyphOrder()
+
+    def shape(self, text: str) -> Tuple[List[Any], List[Any]]:
+        buf = hb.Buffer()
+        buf.add_str(text)
+        buf.guess_segment_properties()
+        hb.shape(self.font, buf)
+        return buf.glyph_infos, buf.glyph_positions
+
+    def get_text_width(self, text: str, fontsize: float) -> float:
+        infos, positions = self.shape(text)
+        total_advance_units = sum(pos.x_advance for pos in positions)
+        return total_advance_units * (fontsize / self.upem)
+
+    def get_font_height(self, fontsize: float) -> float:
+        # Get ascender/descender from fontTools hhea table
+        hhea = self.ttfont.get('hhea')
+        if hhea:
+            ascender = hhea.ascent
+            descender = hhea.descent  # Usually negative
+            return (ascender - descender) * (fontsize / self.upem)
+        else:
+            # Fallback: approximate based on upem 
+            return fontsize * 1.2  # Rough approximation
+
+    def get_ascent(self, fontsize: float) -> float:
+        """Get ascent (baseline to top) in scaled units."""
+        hhea = self.ttfont.get('hhea')
+        if hhea:
+            return hhea.ascent * (fontsize / self.upem)
+        else:
+            return fontsize * 0.8  # Rough approximation
+
+    def get_shaped_paths(self, text: str) -> List[Tuple[Path, float, float, float]]:
+        """
+        Returns list of (Path, x_pos, y_pos, scale_factor)
+        Path is in Font Units.
+        Pos is in Font Units.
+        """
+        infos, positions = self.shape(text)
+        
+        results = []
+        current_x = 0
+        current_y = 0
+        
+        for info, pos in zip(infos, positions):
+            gid = info.codepoint
+            try:
+                glyph_name = self.glyph_order[gid]
+            except IndexError:
+                continue
+                
+            pen = MatplotlibPathPen(self.glyph_set)
+            self.glyph_set[glyph_name].draw(pen)
+            
+            if pen.verts:
+                path = Path(pen.verts, pen.codes)
+                
+                # We return position relative to start of string
+                # x = cursor + off_x
+                # y = cursor + off_y
+                x = current_x + pos.x_offset
+                y = current_y + pos.y_offset
+                
+                results.append((path, x, y))
+                
+            current_x += pos.x_advance
+            current_y += pos.y_advance
+            
+        return results
+
+from matplotlib.text import Text
+from matplotlib.transforms import Affine2D
+
+class ShapedText(Text):
+    """
+    A Text artist that uses manual HarfBuzz shaping.
+    """
+    def __init__(self, x, y, text, font_path, **kwargs):
+        super().__init__(x, y, text, **kwargs)
+        self.shaper = HarfbuzzShaper(font_path)
+        
+    def draw(self, renderer):
+        if renderer is not None:
+             self._renderer = renderer
+        if not self.get_visible():
+            return
+            
+        # 1. Basic Text Setup (properties)
+        gc = renderer.new_gc()
+        gc.set_foreground(self.get_color())
+        gc.set_alpha(self.get_alpha())
+        # gc.set_url(self.get_url())
+        
+        # 2. Get shaping results
+        # Path is in Font Units (e.g. 1000 or 2048 UPEM)
+        paths_and_pos = self.shaper.get_shaped_paths(self.get_text())
+        
+        # 3. Calculate Transform
+        # Text transform: (Data X, Data Y) -> (Screen X, Screen Y)
+        # We need to map: FontUnit -> ScreenUnit
+        
+        # Current Font Size in points
+        fontsize_points = self.get_fontsize()
+        # Pixels per point
+        dpi = self.figure.dpi
+        pixels_per_point = dpi / 72.0
+        
+        # Scale factor: FontUnit -> Pixels
+        # 1 FontUnit = (1/UPEM) * (fontsize_points) * (pixels_per_point) pixels
+        upem = self.shaper.upem
+        scale = (1.0 / upem) * fontsize_points * pixels_per_point
+        
+        # Position transform
+        # The (x,y) of the Text object is processed by self.get_transform()
+        # This gives us the Screen Pixel coordinate of the text anchor.
+        text_pos_screen = self.get_transform().transform([self.get_position()]) # [[x, y]]
+        screen_x, screen_y = text_pos_screen[0]
+        
+        # We also need to handle Horizontal/Vertical Alignment (ha/va)
+        # To do this, we need total width/height of the shaped text.
+        total_width_font_units = self.shaper.get_text_width(self.get_text(), self.shaper.upem) # pass upem to get unscaled width
+        total_width_pixels = total_width_font_units * scale
+        
+        # Height is approximately fontsize_pixels? Or bounding box?
+        # For simplicity, approximate with fontsize for alignment??
+        # Usually MPL uses bbox. We can calculate bbox from paths if needed.
+        # Let's stick to basic alignment for now or assume baseline alignment (y=0).
+        
+        offset_x = 0
+        if self.get_horizontalalignment() == 'center':
+            offset_x = -total_width_pixels / 2
+        elif self.get_horizontalalignment() == 'right':
+            offset_x = -total_width_pixels
+            
+        # Vertical alignment
+        # Matplotlib centers based on the bounding box of the text.
+        # We need to calculate the bounding box of the shaped glyphs in Font Units.
+        # Paths are (path, x, y).
+        
+        offset_y = 0
+        va = self.get_verticalalignment()
+        
+        if va != 'baseline':
+            # Calculate bounds
+            min_y = float('inf')
+            max_y = float('-inf')
+            has_paths = False
+            
+            for path, gx, gy in paths_and_pos:
+                if not path.vertices.size:
+                    continue
+                # Get extents of this path (in font units, relative to its origin 0,0)
+                ext = path.get_extents()
+                # Shift by glyph position
+                # path.vertices are relative to glyph origin.
+                # (gx, gy) is glyph origin relative to string origin.
+                # So absolute y = vert_y + gy
+                # extents are (xmin, ymin, xmax, ymax)
+                
+                # Careful: Bbox object behavior
+                glyph_ymin = ext.ymin + gy
+                glyph_ymax = ext.ymax + gy
+                
+                if glyph_ymin < min_y: min_y = glyph_ymin
+                if glyph_ymax > max_y: max_y = glyph_ymax
+                has_paths = True
+            
+            if not has_paths:
+                # Fallback to font metrics if no glyphs (e.g. space) or bbox failure
+                # height ~ ascender - descender?
+                # Center ~ (ascender + descender) / 2
+                asc = self.shaper.face.ascender
+                desc = self.shaper.face.descender
+                min_y = desc
+                max_y = asc
+            
+            # Now determine offset (in Font Units)
+            # We want to shift so that the reference point (e.g. center) is at 0.
+            # Then our base transform places 0 at screen_y.
+            
+            if va == 'center':
+                center_y = (min_y + max_y) / 2
+                offset_y = -center_y * scale
+            elif va == 'top':
+                offset_y = -max_y * scale
+            elif va == 'bottom':
+                offset_y = -min_y * scale
+            # baseline: offset_y = 0 (already set)
+            
+        # Actual Layout Transform:
+        # 1. Scale path by `scale`
+        # 2. Translate by (glyph_x * scale, glyph_y * scale) to assemble string
+        # 3. Translate by (offset_x, offset_y) for alignment
+        # 4. Translate by (screen_x, screen_y) to place on screen
+        # 5. Rotate? self.get_rotation().
+        
+        # Matrix:
+        # Scale(scale) * Translate(pos_x, pos_y) ...
+        
+        rotation = self.get_rotation()
+        # Rotation usually happens around the anchor point (screen_x, screen_y).
+        
+        # Base transform for the whole text block (anchor at 0,0)
+        # Font -> Screen (Calculated)
+        base_transform = Affine2D().scale(scale)
+        
+        # Alignment translation
+        align_transform = Affine2D().translate(offset_x, offset_y)
+        
+        # Rotation & Translation to Screen Position
+        placement_transform = Affine2D().rotate_deg(rotation).translate(screen_x, screen_y)
+        
+        # Loop and draw
+        for path, gx, gy in paths_and_pos:
+            # Transform for this specific glyph
+            # Move glyph to its place in the string (scaled)
+            # Actually since we scale the whole coordinate system, gx/gy are in FontUnits.
+            # So: Translate(gx, gy) -> Scale(scale) ...
+            
+            glyph_trans = Affine2D().translate(gx, gy) + base_transform + align_transform + placement_transform
+            
+            from matplotlib.colors import to_rgba
+            rgba_color = to_rgba(self.get_color(), alpha=self.get_alpha())
+            renderer.draw_path(gc, path, glyph_trans, rgbFace=rgba_color)
+            
+        gc.restore()
+
+
+

mpl_richtext-0.1.7/mpl_richtext/version.py

@@ -0,0 +1 @@
+__version__ = '0.1.7'

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/mpl_richtext.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpl-richtext
-Version: 0.1.4
+Version: 0.1.7
 Summary: Rich text rendering for Matplotlib with multi-color and multi-style support
 Home-page: https://github.com/ra8in/mpl-richtext
 Author: Rabin Katel
@@ -27,6 +27,8 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: uharfbuzz>=0.30.0
+Requires-Dist: fonttools>=4.34.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/mpl_richtext.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ examples/basic_usage.py
 examples/mpl_richtext_examples.png
 mpl_richtext/__init__.py
 mpl_richtext/core.py
+mpl_richtext/shaping.py
 mpl_richtext/version.py
 mpl_richtext.egg-info/PKG-INFO
 mpl_richtext.egg-info/SOURCES.txt

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/mpl_richtext.egg-info/requires.txt

@@ -1,4 +1,6 @@
 matplotlib>=3.5.0
+uharfbuzz>=0.30.0
+fonttools>=4.34.0
 
 [dev]
 pytest>=7.0

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/pyproject.toml

@@ -37,6 +37,8 @@ classifiers = [
 ]
 dependencies = [
     "matplotlib>=3.5.0",
+    "uharfbuzz>=0.30.0",
+    "fonttools>=4.34.0",
 ]
 
 [project.optional-dependencies]

{mpl_richtext-0.1.4 → mpl_richtext-0.1.7}/setup.py

@@ -44,6 +44,8 @@ setup(
     python_requires=">=3.8",
     install_requires=[
         "matplotlib>=3.5.0",
+        "uharfbuzz>=0.30.0",
+        "fonttools>=4.34.0",
     ],
     extras_require={
         "dev": [

mpl_richtext-0.1.4/mpl_richtext/version.py

@@ -1 +0,0 @@
-__version__ = '0.1.4'