ea 0.6.139 → 0.6.141

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

@@ -23,26 +23,60 @@ module Ea
         FRAME_INSET_LEFT = 35
         INSET_TOUCHING_ORIGIN = 30
         FRAME_INSET_TOP = 40
+        # Where the diagram frame's border line sits from the canvas edge.
+        FRAME_BORDER_INSET = 6
 
-        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
+          @width = whole(width)
+          @height = whole(height)
+          @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
+
+          return empty_framed(diagram, min_x, min_y) unless bc.max_x
+
           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
+
+        # No element to size on: the frame alone, wide enough for its
+        # name tab.
+        def self.empty_framed(diagram, min_x, min_y)
+          width = [INSET_TOUCHING_ORIGIN + BoundsCalculator::INSET_RIGHT,
+                   DiagramFrame.new(canvas: nil).min_width(diagram)].max
+          new(min_x: min_x, min_y: min_y, width: width,
+              height: BoundsCalculator::INSET_TOP + BoundsCalculator::INSET_BOTTOM,
+              insets: [BoundsCalculator.inset_left_for(min_x), FRAME_INSET_TOP])
         end
 
         # Second-pass canvas over the DRAWN extents captured by the
@@ -51,30 +85,56 @@ 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|
             pts << [b.x, b.y]
             pts << [b.x + b.width, b.y + b.height]
           end
-          extra = base.send(:subtitle_points)
+          extra = base.subtitle_points
           min_x = (pts + extra).map(&:first).min || 0
           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).
-          inset_left = [BoundsCalculator::INSET_LEFT - 5 + min_x,
-                        BoundsCalculator::INSET_LEFT].min
+          inset_left = BoundsCalculator.inset_left_for(min_x)
           new(min_x: min_x, min_y: min_y,
               width: (max_x - min_x) + inset_left +
                      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
+
+        # This canvas when every point of `shapes` ([min_x, min_y, max_x,
+        # max_y] in canvas coordinates) lies inside its frame border (the
+        # FRAME_BORDER_INSET line), otherwise a canvas grown so the shapes
+        # sit CONTENT_MARGIN inside the border on the overflowing sides.
+        def holding(shapes)
+          left, top, right, bottom = shapes
+          reach = CanvasAnchor::CONTENT_MARGIN
+          grow_left = left < FRAME_BORDER_INSET ? reach - left : 0
+          grow_top = top < FRAME_BORDER_INSET ? reach - top : 0
+          new_width = right > width - FRAME_BORDER_INSET ? right + reach : width
+          new_height = bottom > height - FRAME_BORDER_INSET ? bottom + reach : height
+          return self if [grow_left, grow_top].all?(&:zero?) &&
+                         new_width == width && new_height == height
+
+          Canvas.new(min_x: min_x - grow_left, min_y: min_y - grow_top,
+                     width: new_width + grow_left, height: new_height + grow_top,
+                     insets: [inset_left, inset_top])
         end
 
         def view_box
@@ -97,7 +157,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
@@ -111,6 +171,12 @@ module Ea
 
         private
 
+        # Measured extents arrive as Floats ("508.0"); EA writes whole
+        # pixels into the viewBox and background rect.
+        def whole(pixels)
+          pixels.is_a?(Float) && pixels == pixels.to_i ? pixels.to_i : pixels
+        end
+
         def format_cm(px)
           return "0cm" if px.nil? || px.zero?
 

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

@@ -0,0 +1,132 @@
+# 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.
+      #
+      # Drawn text also holds the right and bottom edges open (text
+      # right/bottom + TEXT_MARGIN, symmetric with the origin rule), so
+      # a name wider than its box is not clipped. Checked on the 188
+      # PLATEAU natives: widths/heights unchanged (185/188, 188/188);
+      # 8DAB169F moves 13 closer; no native contradicts it.
+      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, texts, label_reach) - origin_x,
+                     height: bottom_edge(shapes, texts, label_reach, bottom) - origin_y,
+                     insets: [0, 0])
+        end
+
+        def right_edge(shapes, texts, label_reach)
+          [shapes && shapes[2] + CONTENT_MARGIN,
+           texts && (texts[2] + TEXT_MARGIN).ceil,
+           label_reach && label_reach[0] + LABEL_BOX_MARGIN].compact.max
+        end
+
+        def bottom_edge(shapes, texts, label_reach, bottom)
+          [shapes[3] + bottom,
+           texts && (texts[3] + TEXT_MARGIN).ceil,
+           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/attributes.rb

@@ -6,6 +6,11 @@ module Ea
       module Compartment
         # Attribute compartment. Skipped when no attribute lines.
         module Attributes
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -11,6 +11,11 @@ module Ea
         # content and suppresses them when they would overflow the
         # stored box height (never truncates rows).
         module Constraints
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -8,6 +8,11 @@ module Ea
         # italic header + each literal name. Skipped when the
         # classifier has no literals or no content geometry.
         module EnumLiterals
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           # Caption and literal rows share the same baseline spacing.

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

@@ -7,6 +7,11 @@ module Ea
         # Header compartment: stereotype label + class name. Skips
         # rendering when the classifier produces no header lines.
         module Header
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -8,6 +8,11 @@ module Ea
         # compartment (attributes / operations / literals / tagged
         # values). Skipped when there is no content below.
         module HeaderDivider
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -12,6 +12,11 @@ module Ea
         # InstanceSpecification or has neither slots nor a
         # classifier.
         module InstanceSlots
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           ROW_OFFSET = 13
           SUBTITLE_OFFSET_FROM_BOTTOM = 15
 

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

@@ -8,6 +8,11 @@ module Ea
         # short horizontal line below each instance name to denote
         # that it is an instance (UML convention).
         module InstanceUnderline
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::SQUARE_MITER
+          end
+
           Y_OFFSET = 1
 
           module_function

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

@@ -10,6 +10,11 @@ module Ea
         # Real OCL constraints render trailing, after the content —
         # the two are distinct compartments.
         module Marker
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -15,6 +15,11 @@ module Ea
 
           module_function
 
+          # The text group keeps the pen the note outline was drawn with.
+          def pen(context)
+            context.previous_pen || Pen::INITIAL
+          end
+
           def render(context)
             return nil if context.model_element.is_a?(Ea::Model::Note) &&
                           context.model_element.legend
@@ -63,7 +68,7 @@ module Ea
           # [pitch, first-baseline offset] for the note font.
           def vertical_layout(context)
             size = context.size
-            height = context.logical_height
+            height = Ea::Fonts::Metrics.source_logical_height(context.logical_height)
             height ||= Ea::Fonts::Metrics.gdi_logical_height(size) if context.size_unit == "pt"
             ascent, descent = Ea::Fonts::Metrics.gdi_cell_metrics(context.family, height)
             return [size + 7, size + 9] unless ascent
@@ -117,8 +122,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 = pen(context)
+            "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/note_text.rb

@@ -10,6 +10,11 @@ module Ea
         # Lines are estimated by character width and split at word
         # boundaries to fit the element bounds.
         module NoteText
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           X_PADDING = 5
           HAND_DRAW_X_PADDING = 10
           Y_FIRST_OFFSET = 15

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

@@ -7,6 +7,11 @@ module Ea
         # Operation compartment: divider line + operation signatures.
         # Skipped when no operations or when geometry cannot fit them.
         module Operations
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -11,6 +11,11 @@ module Ea
         # text (Enumeration gets a list-style icon; other classifiers
         # get the "folded paper" silhouette).
         module PackageContents
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::SQUARE_BEVEL
+          end
+
           ROW_HEIGHT = 16
           ICON_X_OFFSET = 5
           TEXT_X_OFFSET = 23

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

@@ -13,6 +13,11 @@ module Ea
         # (379 diagrams, 378 exact): classifiers never render the
         # subtitle, and ShowForeign=0 diagrams render none.
         module PackageFromParent
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)
@@ -37,9 +42,22 @@ 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
+          # Heights above this (a 100pt caption is H143) are corrupt
+          # input; they keep the legacy offset instead of pushing the
+          # caption far off the element.
+          MAX_CAPTION_HEIGHT = 60
 
           LINE_PITCH = 13
           WRAP_PADDING = 15
@@ -47,7 +65,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 +90,18 @@ module Ea
           end
           module_function :subtitle
 
+          def offset_from_bottom(context)
+            height = Ea::Fonts::Metrics.source_logical_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)
+
+            return LEGACY_Y_OFFSET_FROM_BOTTOM unless height.nil? || height <= MAX_CAPTION_HEIGHT
+
+            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

@@ -9,6 +9,19 @@ module Ea
         module Shape
           module_function
 
+          # Notes and legends take the pen the previous drawing left; every
+          # other shape draws its own round/bevel pen.
+          def pen(context)
+            return Pen::ROUND_BEVEL unless pen_inheriting?(context)
+
+            context.previous_pen || Pen::INITIAL
+          end
+
+          def pen_inheriting?(context)
+            legend?(context) || context.model_element.is_a?(Ea::Model::Note)
+          end
+          private_class_method :pen_inheriting?
+
           def render(context)
             if legend?(context)
               Element::LegendRenderer.render(
@@ -16,7 +29,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 },
+                pen: context.previous_pen
               )
             elsif context.model_element.is_a?(Ea::Model::Note)
               Element::NoteShapeRenderer.render(
@@ -24,7 +38,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 +74,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.

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

@@ -13,6 +13,12 @@ module Ea
         # Rendered after the header so the icon sits inside the
         # element body below the stereotype label.
         module StereotypeIcon
+          # ShapeScript output sets no stroke pen, so the icon leaves the
+          # previous pen in force.
+          def self.pen(_context)
+            nil
+          end
+
           module_function
 
           def render(context)

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

@@ -7,6 +7,11 @@ module Ea
         # Tagged value compartment. Skipped when no tagged values
         # or when geometry cannot fit them.
         module TaggedValues
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           DEFAULT_TEXT_COLOR = "#000000"
 
           module_function

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

@@ -49,6 +49,10 @@ module Ea
           InstanceUnderline
         ].freeze
 
+        # One rendered compartment and the pen its first group leaves behind
+        # (nil when it sets none, leaving the previous pen in force).
+        Painted = Struct.new(:svg, :pen)
+
         module_function
 
         # Renders every applicable compartment for the context.
@@ -57,6 +61,15 @@ module Ea
         def render_all(context)
           ALL.map { |compartment| compartment.render(context) }
         end
+
+        # Like render_all, but each applicable compartment comes with the
+        # pen it leaves behind; compartments that do not apply are dropped.
+        def paint_all(context)
+          ALL.filter_map do |compartment|
+            svg = compartment.render(context)
+            Painted.new(svg, compartment.pen(context)) if svg
+          end
+        end
       end
     end
   end