ea 0.6.138 → 0.6.140

data/lib/ea/sources/xmi/stored_route.rb

@@ -9,6 +9,9 @@ module Ea
       # boxes). Returns nil where QEA would fall back to bare SX/SY deltas,
       # which the generic router keeps handling.
       class StoredRoute < Qea::DiagramBuilder
+        autoload :ReversedRoutes, "ea/sources/xmi/stored_route/reversed_routes"
+        include ReversedRoutes
+
         Link = Struct.new(:style, :path, :geometry)
         Connector = Struct.new(:connector_type)
 
@@ -26,9 +29,15 @@ module Ea
           finish(points, link, connector, source, target, bends, ports, offsets, edge)
         end
 
-        # Direct custom-line associations and aggregations retain ray origins as
-        # well as their computed boundary ports, just as the QEA builder does.
+        # Saved rays retain origins and computed boundary ports, matching QEA.
         def ray_metadata(model, link:, bounds:, offsets:, edge:)
+          if model.connector_type == "Generalization"
+            overlap = mode2_overlap_metadata(model, link, bounds, offsets, edge)
+            return overlap unless overlap.empty?
+
+            return generalization_ray_metadata(model, link, bounds, offsets, edge)
+          end
+
           return {} unless direct_association_ray?(model, bounds, offsets)
 
           source, target = bounds.values_at(:source, :target)
@@ -46,11 +55,10 @@ module Ea
         # UMLDI fallback. A single stored corner and an empty-path stored ray
         # carry mathematical origins that the generic facing-edge route loses.
         def association_route(model, link:, bounds:, offsets:, edge:)
-          overlap = umldi_association_metadata(model, link, bounds, offsets, edge)
-          return overlap unless overlap.empty?
-
-          partial = partial_port_metadata(model, link, bounds, offsets, edge)
-          return partial unless partial.empty?
+          ROUTE_STAGES.each do |stage|
+            found = method(stage).call(model, link, bounds, offsets, edge)
+            return found unless found.empty?
+          end
 
           return {} unless stored_association_candidate?(model, bounds)
 
@@ -64,6 +72,69 @@ module Ea
 
         private
 
+        ROUTE_STAGES = %i[umldi_association_metadata shared_overlap_metadata
+                          source_row_metadata auto_port_elbow_metadata reversed_tree_metadata
+                          reversed_corner_metadata reversed_lateral_tree_metadata partial_port_metadata].freeze
+
+        # Overlap rules need both end boxes and every end offset.
+        def ray_inputs?(bounds, offsets)
+          bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # A Mode 2 Generalization whose stored Path is a horizontal jog is EA's
+        # auto-route: QEA replaces the stored bends with one vertical ray, and
+        # the same QEA rule decides it here.
+        def mode2_overlap_metadata(model, link, bounds, offsets, edge)
+          return {} if link.path.to_s.empty? || !ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          initial = candidate.waypoints
+          mode2_overlap_ray(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} if candidate.waypoints.equal?(initial)
+
+          { waypoints: candidate.waypoints, source_anchor: candidate.source_anchor,
+            target_anchor: candidate.target_anchor, has_geometry_offsets: true }
+        end
+
+        # A stored (non-UMLDI) Association through the shared overlap row takes
+        # QEA's overlap origins and flush ports, decided by the same QEA rule.
+        def shared_overlap_metadata(model, link, bounds, offsets, edge)
+          return {} if model.style[:umldi_route] || !ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          geom = ray_geometry(offsets, edge)
+          association_stored_ray(candidate, link, bounds, geom, false) if association_ray_style?(model.style.to_h)
+          overlap_ray_origins(candidate, link, bounds, geom, false)
+          return {} unless candidate.style[:overlap_ray]
+
+          association_metadata(candidate)
+        end
+
+        # A Mode 2 Association with unequal end offsets and no (or a stale) Path
+        # rides the source row, as QEA's source_row_association_ray decides.
+        def source_row_metadata(model, link, bounds, offsets, edge)
+          return {} if model.style[:umldi_route] || !ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          source_row_association_ray(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} unless candidate.style[:overlap_ray]
+
+          association_metadata(candidate)
+        end
+
+        # A Mode 2 Association with uniform offsets, EDGE 4 and no Path keeps its
+        # physical ports and takes QEA's elbow, even when UMLDI saved a straight
+        # route (30D62231, 934F4502).
+        def auto_port_elbow_metadata(model, link, bounds, offsets, edge)
+          return {} unless ray_inputs?(bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          auto_port_elbow(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} unless candidate.style[:auto_port_elbow]
+
+          association_metadata(candidate)
+        end
+
         def umldi_association_metadata(model, link, bounds, offsets, edge)
           overlap = umldi_overlap_metadata(model, link, bounds, offsets, edge)
           return overlap unless overlap.empty?
@@ -96,7 +167,9 @@ module Ea
           return {} unless umldi_overlap_candidate?(model, bounds, offsets)
 
           candidate = association_model(model, bounds, offsets)
-          overlap_ray_origins(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          geom = ray_geometry(offsets, edge)
+          association_stored_ray(candidate, link, bounds, geom, false) if association_ray_style?(model.style.to_h)
+          overlap_ray_origins(candidate, link, bounds, geom, false)
           return {} unless candidate.style[:overlap_ray]
 
           { source_anchor: candidate.source_anchor, target_anchor: candidate.target_anchor,
@@ -159,6 +232,13 @@ module Ea
                                y: box.y + box.height / 2 + offset[1].to_i)
         end
 
+        # XMI has no QEA database from which to infer a wider element outline,
+        # so the saved connector width stands. A border-aware variant changed no
+        # connector in the PLATEAU census.
+        def association_outline_width(model, _link, _bounds)
+          model.style[:lwidth]
+        end
+
         def stored_ray_boxes(_link, bounds)
           bounds.values_at(:source, :target)
         end
@@ -169,6 +249,39 @@ module Ea
             bounds.values.all? && offsets.values.flatten.none?(&:nil?)
         end
 
+        # A direct Generalization clips its saved mathematical origins rather
+        # than treating boundary ports as the origins of the final drawn ray.
+        def generalization_ray_metadata(model, link, bounds, offsets, edge)
+          geom = ray_geometry(offsets, edge)
+          return {} unless generalization_ray_candidate?(model, link, bounds, offsets, geom)
+
+          source, target = bounds.values_at(:source, :target)
+          return {} unless stored_ray_gap?(source, target, model.style[:mode], edge)
+
+          points = ray_points(source, target, offsets, geom)
+          return {} if points.empty?
+
+          points.merge(style: generalization_ray_style(model, points, source, target))
+        end
+
+        def generalization_ray_candidate?(model, link, bounds, offsets, geom)
+          model.waypoints.size == 2 && stored_ray_style?(model.style, link) &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?) &&
+            (!geom[:sy].zero? || !geom[:ey].zero?)
+        end
+
+        def generalization_ray_style(model, points, source, target)
+          candidate = Ea::Model::DiagramConnector.new(
+            connector_type: model.connector_type, style: model.style.to_h.dup,
+            source_anchor: points[:source_anchor], target_anchor: points[:target_anchor]
+          )
+          return model.style.to_h unless centered_origin_ray?(candidate, source, target)
+
+          flags = { centered_origin_ray: true }
+          flags[:stored_origin_ray] = true if stored_origin_ray?(candidate, source, target)
+          model.style.to_h.merge(flags)
+        end
+
         def ray_geometry(offsets, edge)
           { sx: offsets[:source][0], sy: offsets[:source][1],
             ex: offsets[:target][0], ey: offsets[:target][1], edge: edge }

data/lib/ea/svg/ea_emitter/bottom_margin.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Space EA leaves below the lowest element of an unframed export.
+      #
+      # EMPIRICAL FIT (no stored selector was found; measured on the 187
+      # PLATEAU QEA diagrams whose native SVG is available, 172 match):
+      # below the lowest element the canvas keeps 21 + its font size in
+      # points (the objectstyle fontsz is in tenths of a point, 0 meaning
+      # the 7pt default): 31 for fontsz 100, 30 for 90, 28 for the
+      # default. A plain Note, and a Package that draws no "(from
+      # Parent)" subtitle, keep the bare 10 margin, as does a classifier
+      # of the diagram's own package. Misses: 2 outliers.
+      class BottomMargin
+        BARE = 10
+        LINE_ALLOWANCE = 21
+        HOME_TEXT_ALLOWANCE = 13
+        DEFAULT_POINTS = 7
+
+        def self.for(diagram, model_index)
+          lowest = lowest_elements(diagram)
+          return CanvasAnchor::BOTTOM_MARGIN if lowest.empty?
+
+          lowest.map { |element| of(element, diagram, model_index) }.max
+        end
+
+        def self.lowest_elements(diagram)
+          placed = (diagram.elements || []).select { |e| e.bounds || e.image_bounds }
+          bottom = placed.map { |e| edge(e) }.max
+          placed.select { |e| edge(e) == bottom }
+        end
+
+        def self.edge(element)
+          bounds = element.bounds || element.image_bounds
+          bounds.y + bounds.height
+        end
+
+        def self.of(element, diagram, model_index)
+          model = model_index && model_index[element.model_element_ref]
+          return home_text_margin(element) if home_text?(model, diagram)
+          return BARE if plain_note?(model) || bare_package?(model, diagram) ||
+                         home_classifier?(model, diagram)
+
+          LINE_ALLOWANCE + points(element)
+        end
+
+        # QEA keeps the raw objectstyle fontsz; XMI keeps only the GDI
+        # pixel height it was rendered at (tenths * 96 / 720, floored).
+        def self.points(element)
+          tenths = element.style && element.style[:fontsz].to_i
+          return tenths / 10 if tenths.to_i.positive?
+
+          pixels = element.font_logical_height.to_i.abs
+          pixels.positive? ? (pixels * 0.75).round : DEFAULT_POINTS
+        end
+
+        def self.plain_note?(model)
+          model.is_a?(Ea::Model::Note) && model.note_type != "Text"
+        end
+
+        # A classifier that lives in the diagram's own package draws no
+        # "(from Package)" row under its name (nor an owner-class
+        # qualifier), so EA keeps only the bare margin below it. Checked
+        # on the 7 PLATEAU diagrams whose lowest class is in the
+        # diagram's package (all natively 10) against the 84 that are
+        # foreign (all 28..31).
+        def self.home_classifier?(model, diagram)
+          model.is_a?(Ea::Model::Classifier) &&
+            !diagram.package_id.to_s.empty? &&
+            model.package_id == diagram.package_id &&
+            model.nested_parent_name.to_s.empty?
+        end
+
+        # A Text element of the diagram's own package keeps 13 + its
+        # font size in points (22 at 9pt) instead of the foreign 21 + size.
+        # EMPIRICAL FIT on a single sample (PLATEAU 2E98EA19, fontsz 90,
+        # natively 22); the 8 foreign Text cases (28..30) are unaffected.
+        def self.home_text?(model, diagram)
+          model.is_a?(Ea::Model::Note) && model.note_type == "Text" &&
+            !diagram.package_id.to_s.empty? &&
+            model.package_id == diagram.package_id
+        end
+
+        def self.home_text_margin(element)
+          HOME_TEXT_ALLOWANCE + points(element)
+        end
+
+        def self.bare_package?(model, diagram)
+          return false unless model.is_a?(Ea::Model::Package)
+
+          parent = model.parent_id
+          !(diagram.show_foreign && !parent.to_s.empty? &&
+            parent != diagram.package_id)
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/bounds_calculator.rb

@@ -38,7 +38,7 @@ module Ea
           @model_index = model_index
         end
 
-        attr_reader :effective_inset_left
+        attr_reader :effective_inset_left, :max_x, :max_y
 
         def compute
           points = element_points
@@ -48,6 +48,8 @@ module Ea
           ys = points.map(&:last)
           min_x = xs.min || 0
           min_y = ys.min || 0
+          @max_x = xs.max
+          @max_y = ys.max
           # Left inset scales from 30 up to the 35 cap with the
           # stored leftmost x: leftmost drawn x = 30 + min_x capped
           # at 35 (corpus: min_x 0 -> 30, 2 -> 32, 4 -> 34, >=5 -> 35).

data/lib/ea/svg/ea_emitter/canvas.rb

@@ -24,25 +24,45 @@ module Ea
         INSET_TOUCHING_ORIGIN = 30
         FRAME_INSET_TOP = 40
 
-        attr_reader :min_x, :min_y, :width, :height, :inset_left
+        attr_reader :min_x, :min_y, :width, :height, :inset_left, :inset_top
 
-        def initialize(min_x:, min_y:, width:, height:, inset_left: FRAME_INSET_LEFT)
+        # `insets` is [left, top]: where model (min_x, min_y) lands on
+        # the canvas.
+        def initialize(min_x:, min_y:, width:, height:,
+                       insets: [FRAME_INSET_LEFT, FRAME_INSET_TOP])
           @min_x = min_x
           @min_y = min_y
           @width = width
           @height = height
-          @inset_left = inset_left
+          @inset_left, @inset_top = insets
+        end
+
+        # Model-space origin of this canvas.
+        def origin_x
+          min_x - inset_left
+        end
+
+        def origin_y
+          min_y - inset_top
         end
 
         # Build a Canvas for a diagram by running the bound
         # calculator. Defaults model_index to nil (no canvas-aware
         # element bounds needed) for callers that only need a
         # frame-size estimate.
-        def self.from(diagram, model_index: nil)
+        def self.from(diagram, model_index: nil, content_anchor: false)
           bc = BoundsCalculator.new(diagram, model_index: model_index)
           min_x, min_y, width, height = bc.compute
+          if content_anchor
+            return CanvasAnchor.blank unless bc.max_x
+
+            return CanvasAnchor.stored(min_x, min_y, bc.max_x, bc.max_y,
+                                       bottom: BottomMargin.for(diagram, model_index))
+          end
+
           new(min_x: min_x, min_y: min_y, width: width, height: height,
-              inset_left: bc.effective_inset_left || FRAME_INSET_LEFT)
+              insets: [bc.effective_inset_left || FRAME_INSET_LEFT,
+                       FRAME_INSET_TOP])
         end
 
         # Second-pass canvas over the DRAWN extents captured by the
@@ -51,7 +71,8 @@ module Ea
         # canvas from drawn extents, so diagrams whose lowest/rightmost
         # element grew get a taller/wider canvas than the stored-rect
         # first pass provides.
-        def self.from_drawn(diagram, drawn_bounds, model_index: nil)
+        def self.from_drawn(diagram, drawn_bounds, model_index: nil,
+                            content_anchor: false)
           base = BoundsCalculator.new(diagram, model_index: model_index)
           pts = []
           drawn_bounds.each_value do |b|
@@ -63,7 +84,14 @@ module Ea
           min_y = (pts + extra).map(&:last).min || 0
           max_x = (pts + extra).map(&:first).max || 0
           max_y = (pts + extra).map(&:last).max || 0
-          return from(diagram, model_index: model_index) if pts.empty?
+          if pts.empty?
+            return from(diagram, model_index: model_index,
+                                 content_anchor: content_anchor)
+          end
+          if content_anchor
+            return CanvasAnchor.stored(min_x, min_y, max_x, max_y,
+                                       bottom: BottomMargin.for(diagram, model_index))
+          end
 
           # Same scaled rule as BoundsCalculator: drawn leftmost =
           # min(35, 30 + min_x).
@@ -74,7 +102,7 @@ module Ea
                      BoundsCalculator::INSET_RIGHT,
               height: (max_y - min_y) + BoundsCalculator::INSET_TOP +
                       BoundsCalculator::INSET_BOTTOM,
-              inset_left: inset_left)
+              insets: [inset_left, FRAME_INSET_TOP])
         end
 
         def view_box
@@ -97,7 +125,7 @@ module Ea
         end
 
         def translate_y(y)
-          y - min_y + FRAME_INSET_TOP
+          y - min_y + inset_top
         end
 
         # Compact coordinate formatter. Integers lose the decimal

data/lib/ea/svg/ea_emitter/canvas_anchor.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Canvas policy of an UNFRAMED export (EA's "Save Diagram Image"
+      # without the automatic frame: the PLATEAU native SVGs). Measured
+      # on the 220 native SVGs, where it reproduces the origin of 205 of
+      # 215 diagrams from the native content alone (the other 10 sit at
+      # the floor below):
+      #
+      #   origin = max(min(shape_min - 10, text_left_or_top - 5), -5)
+      #
+      # in model coordinates, per axis. Shapes are rect/path/polygon/
+      # ellipse points; a text box runs from its left edge and from
+      # baseline minus the rounded font height. The right margin is 10
+      # from the shapes.
+      #
+      # EMPIRICAL FITS (no saved selector was found in any QEA table):
+      # BOTTOM_MARGIN 31 is only the fallback; BottomMargin picks the
+      # margin from the lowest element. The right edge also reaches
+      # every connector end-label box (its position plus the stored
+      # CX width) + LABEL_BOX_MARGIN 5, exact on the 7 PLATEAU diagrams
+      # whose labels overhang the shapes (30D62231, 47E4600F,
+      # 4881CEEE, 70C77F92, 846DD800, 88AF6BD7, AC2191E3). Below, the
+      # same box (its top is the first baseline less the font height,
+      # its height the stored CY) + 5 holds the canvas open on 95246DCF.
+      module CanvasAnchor
+        CONTENT_MARGIN = 10
+        TEXT_MARGIN = 5
+        ORIGIN_FLOOR = -5
+        BOTTOM_MARGIN = 31
+        LABEL_BOX_MARGIN = 5
+        # EMPIRICAL FIT: the one PLATEAU diagram with nothing on it
+        # (29DD0967) exports a 210 x 110 white canvas.
+        BLANK_SIZE = [210, 110].freeze
+
+        module_function
+
+        # Where content starting at `content_min` lands on the canvas.
+        def inset(content_min)
+          content_min - floored(content_min - CONTENT_MARGIN)
+        end
+
+        # Canvas of a diagram that places no element.
+        def blank
+          Canvas.new(min_x: 0, min_y: 0, width: BLANK_SIZE[0],
+                     height: BLANK_SIZE[1], insets: [0, 0])
+        end
+
+        # Canvas for shapes spanning the given model-space extent (the
+        # stored element rects, before any drawn content is measured).
+        def stored(min_x, min_y, max_x, max_y, bottom: BOTTOM_MARGIN)
+          left = inset(min_x)
+          top = inset(min_y)
+          Canvas.new(min_x: min_x, min_y: min_y,
+                     width: (max_x - min_x) + left + CONTENT_MARGIN,
+                     height: (max_y - min_y) + top + bottom,
+                     insets: [left, top])
+        end
+
+        # Canvas for measured content, each box [min_x, min_y, max_x,
+        # max_y] in model coordinates (nil when absent). `label_reach` is
+        # the [right, bottom] edge of the connector end-label boxes.
+        def measured(shapes, texts, label_reach, bottom: BOTTOM_MARGIN)
+          origin_x = origin(shapes && shapes[0], texts && texts[0])
+          origin_y = origin(shapes && shapes[1], texts && texts[1])
+          Canvas.new(min_x: origin_x, min_y: origin_y,
+                     width: right_edge(shapes, label_reach) - origin_x,
+                     height: bottom_edge(shapes, label_reach, bottom) - origin_y,
+                     insets: [0, 0])
+        end
+
+        def right_edge(shapes, label_reach)
+          [shapes && shapes[2] + CONTENT_MARGIN,
+           label_reach && label_reach[0] + LABEL_BOX_MARGIN].compact.max
+        end
+
+        def bottom_edge(shapes, label_reach, bottom)
+          [shapes[3] + bottom,
+           label_reach && label_reach[1] + LABEL_BOX_MARGIN].compact.max
+        end
+
+        def origin(shape_min, text_min)
+          lead = [shape_min && shape_min - CONTENT_MARGIN,
+                  text_min && text_min - TEXT_MARGIN].compact.min
+          floored(lead)
+        end
+
+        # The floor encodes only "a shape at 0 draws at 5" (the corpus
+        # has no shape left of 0). Content starting further out keeps
+        # its full margin so nothing is drawn off the canvas.
+        def floored(lead)
+          lead >= ORIGIN_FLOOR - CONTENT_MARGIN ? [lead, ORIGIN_FLOOR].max : lead
+        end
+
+        # The canvas anchored on the content drawn into `layers` (the
+        # background excluded) and `label_reach`, or `canvas` itself
+        # when there is nothing to measure.
+        def reanchor(canvas, layers, label_reach, bottom: BOTTOM_MARGIN)
+          extent = ContentExtent.measure(layers)
+          return canvas unless extent.shapes
+
+          shift = [canvas.origin_x, canvas.origin_y]
+          measured(*[extent.shapes, extent.texts]
+                     .map { |box| model_box(box, shift) }, label_reach,
+                   bottom: bottom)
+        end
+
+        def model_box(box, shift)
+          return nil unless box
+
+          [box[0] + shift[0], box[1] + shift[1],
+           box[2] + shift[0], box[3] + shift[1]]
+        end
+
+        def same_canvas?(one, other)
+          [one.origin_x, one.origin_y, one.width, one.height] ==
+            [other.origin_x, other.origin_y, other.width, other.height]
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment/note_body.rb

@@ -117,8 +117,12 @@ module Ea
           end
           module_function :cjk_char?
 
+          # The text group keeps the pen the note outline was drawn with
+          # (EA never sets a note pen; 7C44AC09 square/miter, 7D960BD8
+          # square/bevel), so the next element inherits the right pen.
           def group_style(context)
-            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+            cap, join = context.previous_pen || Element::NoteShapeRenderer::INITIAL_PEN
+            "stroke-width:1;stroke-linecap:#{cap};stroke-linejoin:#{join}; " \
               "fill:#{context.theme.text_color};fill-opacity:1.00; " \
               "stroke:#000000; stroke-opacity:0.00"
           end

data/lib/ea/svg/ea_emitter/compartment/package_from_parent.rb

@@ -37,9 +37,18 @@ module Ea
 
           module_function :render
 
-          # EA draws the subtitle 15px BELOW the body bottom (outside
-          # the box) — verified against EA-published package SVGs.
-          Y_OFFSET_FROM_BOTTOM = 15
+          # EA draws the subtitle BELOW the body bottom (outside the
+          # box): GAP_BELOW_BODY plus the GDI text ascent of the caption
+          # font. Cambria 7pt (H10, ascent 10) gives the 15px seen in
+          # every Cambria native package SVG (14E9F5FD, 157826AA,
+          # 2A5E0832, 6481E2CC); Carlito 9pt (H13, ascent 12) gives the
+          # 17px of 37AC19B9. The 5px gap is fitted on the Cambria cases,
+          # the Carlito case is the held-out check. Fonts or units with
+          # no GDI cell data keep the legacy 15px.
+          # Only families with native evidence use the ascent offset.
+          ASCENT_FAMILIES = %w[cambria carlito].freeze
+          GAP_BELOW_BODY = 5
+          LEGACY_Y_OFFSET_FROM_BOTTOM = 15
 
           LINE_PITCH = 13
           WRAP_PADDING = 15
@@ -47,7 +56,7 @@ module Ea
           def subtitle(text, context)
             bounds = context.bounds
             fill = context.theme.attribute_text_color
-            y = bounds.y + bounds.height + Y_OFFSET_FROM_BOTTOM
+            y = bounds.y + bounds.height + offset_from_bottom(context)
             # EA word-wraps the subtitle to the package BODY width
             # (minus padding), centers each line by its integer
             # textLength inside the body, and floors x; successive
@@ -72,6 +81,16 @@ module Ea
           end
           module_function :subtitle
 
+          def offset_from_bottom(context)
+            height = context.logical_height
+            height ||= Ea::Fonts::Metrics.gdi_logical_height(context.size) if context.size_unit == "pt"
+            return LEGACY_Y_OFFSET_FROM_BOTTOM unless ASCENT_FAMILIES.include?(context.family.to_s.downcase)
+
+            ascent, = Ea::Fonts::Metrics.gdi_cell_metrics(context.family, height)
+            ascent ? GAP_BELOW_BODY + ascent : LEGACY_Y_OFFSET_FROM_BOTTOM
+          end
+          module_function :offset_from_bottom
+
           # EA carries the break space onto the broken line: line 1
           # is "(from ... Metadata - " with the trailing space, and
           # its textLength includes it (05DF5000: tl 146).

data/lib/ea/svg/ea_emitter/compartment/shape.rb

@@ -16,7 +16,8 @@ module Ea
                 legend: context.model_element.legend,
                 family: context.family,
                 item_font: { size: legend_item_size(context), unit: context.size_unit,
-                             logical_height: context.logical_height }
+                             logical_height: context.logical_height },
+                first_painted: context.first_painted
               )
             elsif context.model_element.is_a?(Ea::Model::Note)
               Element::NoteShapeRenderer.render(
@@ -24,7 +25,8 @@ module Ea
                 body: "", fill: context.fill, stroke: context.stroke,
                 stroke_width: context.stroke_width,
                 family: context.family, size: context.size,
-                text_fill: context.text_fill
+                text_fill: context.text_fill,
+                pen: context.previous_pen
               )
             elsif context.model_element.is_a?(Ea::Model::Package)
               label = package_label(context.model_element)
@@ -59,12 +61,22 @@ module Ea
             return unless element
             return element.font_size if element.font_size&.nonzero?
 
-            # Parsed source defaults inherit; unspecified callers keep 9pt.
-            inherited = element.font_size_inherited || element.style&.fetch(:fontsz, nil).to_s == "0"
-            context.size if inherited
+            context.size if inherits_context_size?(element)
           end
           private_class_method :legend_item_size
 
+          # Parsed source defaults inherit; unspecified callers keep 9pt.
+          # A parsed element (provenance recorded) that resolved no size
+          # also inherits: XMI legends carry no fontsz at all, and native
+          # EA draws their items at the context size (Cambria 7pt).
+          def inherits_context_size?(element)
+            return true if element.font_size_inherited
+            return true if element.style&.fetch(:fontsz, nil).to_s == "0"
+
+            !element.font_size_inherited.nil? && element.font_size.nil?
+          end
+          private_class_method :inherits_context_size?
+
           # A Text element with LegendOpts= renders as the legend
           # block rather than a folder silhouette. Dispatch on the
           # presence of the attached Legend payload.