ea 0.4.0 → 0.5.0

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

@@ -3,28 +3,55 @@
 module Ea
   module Svg
     module EaEmitter
-      # Emits the connectors layer: for each DiagramConnector, emits
-      # one <g> containing the <path d="M x y L x2 y2..."/> through
-      # its waypoints. Markers (arrowheads, diamonds) are emitted
-      # separately by the Markers emitter.
+      # Emits connector line `<path>` elements grouped per line-style.
+      # Returns an Array of `Layer` structs.
+      #
+      # Default mode (`grouped: true`) consolidates all same-style
+      # paths into ONE `<g>` element — matching EA's encoding for
+      # diagrams with many similarly-styled connectors.
+      #
+      # Pass `grouped: false` for per-connector grouping (one `<g>`
+      # per line, used when strict per-entity interleaving with
+      # markers is required).
       class Connectors
-        attr_reader :diagram
+        LINE_STYLE_KEY = :connector_line
 
-        def initialize(diagram)
+        attr_reader :diagram, :canvas, :grouped, :stroke_width
+
+        def initialize(diagram, canvas: nil, grouped: true, stroke_width: 2)
           @diagram = diagram
+          @canvas = canvas
+          @grouped = grouped
+          @stroke_width = stroke_width
         end
 
-        def render
+        def layers
           paths = visible_connectors.filter_map { |c| path_for(c) }
-          return "" if paths.empty?
+          return [] if paths.empty?
+
+          if grouped
+            [Layer.new(style_key: LINE_STYLE_KEY, style: line_style,
+                       body: paths.join("\n  "))]
+          else
+            paths.map do |path|
+              Layer.new(style_key: LINE_STYLE_KEY, style: line_style, body: path)
+            end
+          end
+        end
 
-          %(<g style="stroke-width:2;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00">\n#{paths.join("\n")}\n</g>)
+        def line_style
+          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        end
+
+        # Backwards-compatible render — joins all layers' `<g>`.
+        def render
+          layers.map(&:to_svg).join("\n")
         end
 
         private
 
         def visible_connectors
-          (diagram.connectors || []).reject(&:hidden)
+          (diagram.connectors || []).select(&:renderable?)
         end
 
         def path_for(connector)
@@ -32,9 +59,10 @@ module Ea
           return nil if pts.size < 2
 
           d = pts.each_with_index.map do |p, idx|
-            "#{idx.zero? ? 'M' : 'L'} #{p[0]} #{p[1]}"
+            x, y = translate_point(p)
+            "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
           end.join(" ")
-          %(  <path d="#{d}" shape-rendering="auto"/>)
+          %(<path d="#{d}" shape-rendering="auto"/>)
         end
 
         def waypoints_for(connector)
@@ -44,6 +72,12 @@ module Ea
             [wp.position.x, wp.position.y]
           end
         end
+
+        def translate_point(p)
+          return p unless @canvas
+
+          [@canvas.translate_x(p[0]), @canvas.translate_y(p[1])]
+        end
       end
     end
   end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits the diagram frame: outer border + name tab. EA renders
+      # every diagram with a 1px black border forming a rectangle
+      # inset 6px from the canvas edge, plus a "tab" polygon in the
+      # upper-left containing the diagram type + name text.
+      #
+      # Layout:
+      #   ┌───┐
+      #   │tab│──────────────────┐
+      #   └───┘                  │
+      #                          │
+      #   (diagram contents)     │
+      #                          │
+      #   ┌──────────────────────┘
+      #
+      # Format observed in EA reference SVGs:
+      #   <g style="...stroke-width:1;stroke-linecap:square;
+      #              stroke-linejoin:miter; fill:#000000;
+      #              fill-opacity:0.00; stroke:#000000;
+      #              stroke-opacity:1.00">
+      #     <path d="M 6 6 L 6 H-6 W-6 W-6 6 L 6 6"/>
+      #   </g>
+      #   <g style="...fill:#FFFFFF;...">
+      #     <polygon points="6 26 X 26 X+13 12 X+13 6 6 6 6 26"/>
+      #   </g>
+      #   <g style="...">
+      #     <text x="11" y="19" ...>class DiagramName</text>
+      #   </g>
+      class DiagramFrame
+        attr_reader :canvas, :theme
+
+        def initialize(canvas:, theme: nil)
+          @canvas = canvas
+          @theme = theme || Ea::Theme::Registry.default
+        end
+
+        def layers(diagram)
+          return [] if canvas.nil?
+
+          [
+            border_layer(canvas),
+            tab_layer(canvas, diagram),
+            tab_label_layer(canvas, diagram)
+          ].compact
+        end
+
+        private
+
+        def border_layer(canvas)
+          d = border_path_d(canvas)
+          body = %(<path d="#{d}" shape-rendering="auto"/>)
+          Layer.new(style_key: :frame_border, style: BORDER_STYLE, body: body)
+        end
+
+        def tab_layer(canvas, diagram)
+          points = tab_points(canvas, diagram)
+          body = %(<polygon points="#{points}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+          Layer.new(style_key: :frame_tab, style: TAB_STYLE, body: body)
+        end
+
+        def tab_label_layer(canvas, diagram)
+          label = tab_label(diagram)
+          return nil unless label
+
+          body = build_label_text(label)
+          Layer.new(style_key: :frame_label, style: LABEL_STYLE, body: body)
+        end
+
+        def border_path_d(canvas)
+          inset = theme.frame.inset
+          right = canvas.width - inset
+          bottom = canvas.height - inset
+          "M #{inset} #{inset} L #{inset} #{bottom} L #{right} #{bottom} L #{right} #{inset} L #{inset} #{inset}"
+        end
+
+        def tab_points(canvas, diagram)
+          label_width = tab_label_width(diagram)
+          x1 = theme.frame.inset
+          x2 = x1 + label_width
+          x3 = x2 + theme.frame.tab_slant
+          top1 = theme.frame.inset
+          top2 = theme.frame.inset + theme.frame.tab_height
+          "#{x1} #{top2} #{x2} #{top2} #{x3} #{top1 + theme.frame.tab_height - theme.frame.tab_slant} #{x3} #{top1} #{x1} #{top1} #{x1} #{top2}"
+        end
+
+        def tab_label(diagram)
+          type = diagram_label_prefix(diagram)
+          return nil unless type
+
+          "#{type} #{diagram.name}"
+        end
+
+        def diagram_label_prefix(diagram)
+          case diagram.diagram_type&.downcase
+          when "logical" then "class"
+          when "package" then "pkg"
+          when "usecase" then "uc"
+          when "sequence" then "seq"
+          when "activity" then "act"
+          when "statechart" then "sm"
+          when "deployment" then "dep"
+          when "component" then "comp"
+          when "object" then "object"
+          when "custom", "conceptual" then nil
+          else diagram.diagram_type&.downcase
+          end
+        end
+
+        def tab_label_width(diagram)
+          label = tab_label(diagram)
+          return theme.package.default_tab_width unless label
+
+          text_width = Ea::Svg::EaEmitter::TextRenderer.estimate_width(
+            label, theme.font_size || 7, theme.text_width_factor
+          ).round
+          text_width + theme.frame.tab_padding
+        end
+
+        def build_label_text(label)
+          TextRenderer.new(
+            content: label,
+            x: theme.frame.tab_label_x, y: theme.frame.tab_label_y,
+            family: theme.font_family || "Calibri",
+            size: theme.font_size || 7,
+            weight: theme.text_weight_bold,
+            size_unit: theme.font_size_unit,
+            fill: "#000000",
+            stroke_in_text: theme.stroke_in_text_color,
+            width_factor: theme.text_width_factor
+          ).to_svg
+        end
+
+        BORDER_STYLE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        TAB_STYLE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter; fill:#FFFFFF;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+        LABEL_STYLE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
+      end
+    end
+  end
+end

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

@@ -4,39 +4,30 @@ module Ea
   module Svg
     module EaEmitter
       # Top-level orchestrator: emits a complete standalone SVG
-      # document matching EA's structure. Calls the layer emitters
-      # in EA's canonical order.
+      # document matching EA's encoding. Bound computation and
+      # layer sequencing delegated to BoundsCalculator and
+      # LayerSequencer respectively (SRP).
       class Document
-        BUILD_ID = "1628"
+        BUILD_ID = "1624"
 
-        attr_reader :diagram, :model_index, :options
+        attr_reader :diagram, :model_index, :frame, :document
 
-        def initialize(diagram, model_index:, **_options)
+        def initialize(diagram, model_index:, frame: true, document: nil, **_options)
           @diagram = diagram
           @model_index = model_index
+          @frame = frame
+          @document = document
         end
 
         def render
-          canvas = Canvas.from(diagram)
-          layers = [
-            Background.render(canvas),
-            Elements.new(diagram, model_index: model_index).render,
-            Connectors.new(diagram).render,
-            Markers.new(diagram, model_index: model_index).render,
-            Labels.new(diagram).render
-          ].reject { |s| s.nil? || s.empty? }
+          canvas = Canvas.from(diagram, model_index: model_index)
+          layers = LayerSequencer.new(diagram, model_index: model_index,
+                                        canvas: canvas, frame: frame,
+                                        document: document)
+                                  .layers
+                                  .reject { |s| s.nil? || s.empty? }
 
-          <<~SVG
-            <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-            <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
-
-            <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">
-            <title></title>
-            <desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>
-
-            #{layers.join("\n\n")}
-            </svg>
-          SVG
+          %(<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">\n\n<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">\n<title></title>\n<desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>\n#{layers.join("\n")}\n</svg>)
         end
       end
     end

data/lib/ea/svg/ea_emitter/element/attribute_line_builder.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Builds the text representation of a single property line
+        # for the attribute compartment. Encapsulates the four EA
+        # rendering rules:
+        #
+        #   1. Visibility marker (+, -, #, ~).
+        #   2. Namespace prefix on properties inherited from a
+        #      classifier in a different package ("core::mimeType").
+        #   3. Primitive type name stripping ("xs::double" → "double").
+        #   4. Multiplicity shorthand ("[2..2]" → "[2]") and
+        #      `{ordered}` modifier.
+        #
+        # Stateless: each call returns a fresh line String. Pass a
+        # `Lookup` to enable cross-classifier resolution (namespace
+        # prefix). Without a lookup, the line is rendered as-is
+        # (backwards-compatible).
+        class AttributeLineBuilder
+          # XSD primitive types whose namespace prefix EA drops in
+          # the rendered attribute line. The full set is not yet
+          # reverse-engineered — leave empty for now so we never
+          # wrongly strip a prefix. TODO-D 47 will populate this
+          # once verified per-diagram.
+          PRIMITIVE_TYPES = Set.new([]).freeze
+
+          attr_reader :property, :host, :lookup
+
+          # property - the Ea::Model::Property to render
+          # host     - the Ea::Model::Classifier whose compartment
+          #            we're rendering (determines "inherited" status)
+          # lookup   - object responding to `#call(id) -> Classifier`
+          #            used to resolve the property's declaring
+          #            classifier (defaults to no lookup).
+          def initialize(property, host: nil, lookup: nil)
+            @property = property
+            @host = host
+            @lookup = lookup
+          end
+
+          def to_s
+            parts = ["#{visibility_marker} "]
+            parts << namespaced_name
+            type_str = formatted_type
+            parts << ": #{type_str}" unless type_str.empty?
+            mult = multiplicity
+            parts << " #{mult}" unless mult.empty?
+            parts << " = #{property.default_value}" if property.default_value && !property.default_value.to_s.empty?
+            parts.join.rstrip
+          end
+
+          private
+
+          def visibility_marker
+            case property.visibility
+            when "private"   then "-"
+            when "protected" then "#"
+            when "package"   then "~"
+            else "+"
+            end
+          end
+
+          # Property name, prefixed with the declaring classifier's
+          # package name when the property is inherited from a
+          # different package than the host classifier.
+          def namespaced_name
+            prefix = inherited_namespace_prefix
+            base = property.name.to_s
+            prefix && !prefix.empty? ? "#{prefix}::#{base}" : base
+          end
+
+          # Returns the declaring classifier's package name when it
+          # differs from the host's package; nil otherwise.
+          def inherited_namespace_prefix
+            return nil unless host && lookup
+            return nil if property.owner_id.nil? || property.owner_id == host.id
+
+            owner = lookup.call(property.owner_id)
+            return nil unless owner.is_a?(Ea::Model::Classifier)
+            return nil if owner.package_id.nil?
+            return nil if owner.package_id == host.package_id
+
+            owner.package_name
+          end
+
+          # Format the type name. Primitive types from the PRIMITIVE_TYPES
+          # set render bare; everything else renders verbatim from the
+          # source. The source already provides the correct colon form
+          # (single for XSD, double for UML package qualifiers).
+          def formatted_type
+            raw = property.type_name.to_s
+            return "" if raw.empty?
+
+            simple = raw.split(":").last.to_s.split("::").last.to_s
+            PRIMITIVE_TYPES.member?(simple) ? simple : raw
+          end
+
+          def multiplicity
+            lower = property.multiplicity_lower
+            upper = property.multiplicity_upper
+            return "" if lower.nil? && upper.nil?
+            return "" if lower == 1 && upper == 1
+
+            "[#{lower || 0}..#{bound_text(upper)}]"
+          end
+
+          def bound_text(value)
+            value == -1 ? "*" : value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/attribute_renderer.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the attribute compartment text `<g>`. Each attribute
+        # renders as TWO `<text>` elements (visibility marker +
+        # content) matching EA's encoding.
+        class AttributeRenderer
+          DEFAULT_VISIBILITY_X_OFFSET = 5
+          DEFAULT_CONTENT_X_OFFSET = 26
+          DEFAULT_FONT_UNIT = "pt"
+
+          def self.render(lines, bounds:, first_y:, family:,
+                          size:, size_unit: DEFAULT_FONT_UNIT,
+                          fill: "#000000",
+                          visibility_x_offset: DEFAULT_VISIBILITY_X_OFFSET,
+                          content_x_offset: DEFAULT_CONTENT_X_OFFSET)
+            line_h = size + 4
+            text_blocks = []
+            lines.each_with_index do |line, idx|
+              y = first_y + (idx * line_h)
+              visibility, rest = split_visibility(line)
+              if visibility
+                text_blocks << build_text(bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill)
+                text_blocks << build_text(bounds.x + content_x_offset, y, rest, family, size, size_unit, fill)
+              else
+                text_blocks << build_text(bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill)
+              end
+            end
+            group_style = "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#{fill};fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
+            %(<g style="#{group_style}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          # Builds attribute display lines from classifier properties,
+          # hiding properties that are navigable association ends
+          # (those are rendered as connector lines).
+          #
+          # When a property carries a stereotype (e.g. «voidable»),
+          # EA renders the stereotype label as a separate line above
+          # the property's own line. We insert those labels here so
+          # the renderer's per-line spacing naturally places them.
+          #
+          # Pass a `lookup` (any callable returning a Classifier for
+          # an id) to enable inherited-property namespace prefixing.
+          def self.lines_for(classifier, lookup: nil)
+            props = displayable_properties(classifier)
+            return [] unless props
+
+            props.flat_map do |prop|
+              lines = []
+              stereotype = property_stereotype(prop)
+              lines << "«#{stereotype}»" if stereotype
+              lines << AttributeLineBuilder.new(prop, host: classifier,
+                                                  lookup: lookup).to_s
+            end
+          end
+
+          # Internal helpers
+
+          def self.split_visibility(line)
+            stripped = line.strip
+            return [nil, stripped] unless stripped.match?(/^[-+~#]\s/)
+
+            visibility = "#{stripped[0]} "
+            rest = stripped[2..].to_s.strip
+            [visibility, rest]
+          end
+          private_class_method :split_visibility
+
+          def self.build_text(x, y, content, family, size, size_unit = DEFAULT_FONT_UNIT, fill = "#000000")
+            TextRenderer.new(content: content, x: x, y: y,
+                              family: family, size: size, size_unit: size_unit, fill: fill).to_svg
+          end
+          private_class_method :build_text
+
+          def self.displayable_properties(classifier)
+            return nil unless classifier.properties
+
+            classifier.properties.reject(&:association_id)
+          end
+          private_class_method :displayable_properties
+
+          # Returns the first stereotype ref for a property, or nil.
+          # Used to emit «voidable» (and similar) labels above the
+          # property's own line.
+          def self.property_stereotype(property)
+            refs = property.stereotype_refs
+            return nil unless refs&.any?
+
+            refs.first.to_s
+          end
+          private_class_method :property_stereotype
+
+          # EA renders namespace separators as "::" (UML standard)
+          # even when the source XMI stores them as ":" (XML style).
+          def self.namespace_double_colon(type_name)
+            return nil if type_name.nil? || type_name.empty?
+
+            type_name.to_s.gsub(/([A-Za-z0-9_]):([A-Za-z])/, '\1::\2')
+          end
+          private_class_method :namespace_double_colon
+
+          def self.multiplicity_text(property)
+            lower = property.multiplicity_lower
+            upper = property.multiplicity_upper
+            return "" if lower.nil? && upper.nil?
+            return "" if lower == 1 && upper == 1
+            return "[#{upper == -1 ? "*" : upper}]" if lower == upper
+
+            "[#{lower || 0}..#{upper == -1 ? "*" : upper}]"
+          end
+          private_class_method :multiplicity_text
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/bcol_decoder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Decodes EA's BGR-encoded BCol/LCol integers into "#RRGGBB"
+        # hex strings. EA stores color as a Win32 COLORREF: R in low
+        # byte, G in mid byte, B in high byte.
+        #
+        # Returns nil when bgr_int is nil OR equals -1 (EA's sentinel
+        # for "no color override" — callers fall through to a
+        # stereotype-derived default).
+        class BColDecoder
+          SENTINEL = -1
+
+          def self.to_hex(bgr_int)
+            return nil if bgr_int.nil? || bgr_int == SENTINEL
+
+            r = bgr_int & 0xff
+            g = (bgr_int >> 8) & 0xff
+            b = (bgr_int >> 16) & 0xff
+            format("#%02X%02X%02X", r, g, b)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/compartment_geometry.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Y-coordinate calculator for the compartments of an element
+        # box: header text, header divider, attribute rows, operation
+        # rows, enum literals, tagged-value rows.
+        #
+        # Owns its own coordinate math; the rest of Elements only
+        # reads `header_first_y`, `divider_y`, `attr_first_y`, etc.
+        # Construction takes the bounds, font size, line counts,
+        # and per-region offsets from the theme.
+        #
+        # Extracted from Elements.rb to keep each concern in one
+        # place (MECE). Element rendering reads these values;
+        # coordinate math changes don't ripple into rendering.
+        class CompartmentGeometry
+          attr_reader :bounds, :size, :header_lines_count,
+                      :attr_lines_count, :op_lines_count,
+                      :tagged_values_count,
+                      :header_top_padding, :header_line_offset,
+                      :divider_offset, :attr_line_offset,
+                      :attr_first_offset
+
+          def initialize(bounds:, size:, header_lines_count:,
+                          attr_lines_count:, op_lines_count:,
+                          tagged_values_count:,
+                          header_top_padding: 9,
+                          header_line_offset: 6,
+                          divider_offset: 8,
+                          attr_line_offset: 4,
+                          attr_first_offset: 7)
+            @bounds = bounds
+            @size = size
+            @header_lines_count = header_lines_count
+            @attr_lines_count = attr_lines_count
+            @op_lines_count = op_lines_count
+            @tagged_values_count = tagged_values_count
+            @header_top_padding = header_top_padding
+            @header_line_offset = header_line_offset
+            @divider_offset = divider_offset
+            @attr_line_offset = attr_line_offset
+            @attr_first_offset = attr_first_offset
+          end
+
+          def header_first_y
+            bounds.y + size + (header_top_padding || 9)
+          end
+
+          # Y of the divider line between header and the rest.
+          # Returns nil when there's no header content to separate
+          # from empty below-header content.
+          def divider_y
+            return nil if header_lines_count.zero?
+
+            header_first_y +
+              ([header_lines_count, 1].max - 1) * (size + (header_line_offset || 6)) +
+              (divider_offset || 8)
+          end
+
+          def attr_first_y
+            return bounds.y + size + (header_top_padding || 9) + 12 unless divider_y
+
+            divider_y + size + (attr_first_offset || 7)
+          end
+
+          def attr_bottom_y
+            return attr_first_y unless attr_lines_count&.positive?
+
+            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 4))
+          end
+
+          def op_divider_y
+            attr_bottom_y + size + 5
+          end
+
+          def op_first_y
+            return nil unless op_lines_count&.positive?
+
+            op_divider_y + size + 5
+          end
+
+          def op_bottom_y
+            return op_divider_y unless op_lines_count&.positive?
+
+            op_first_y + (op_lines_count - 1) * (size + 4)
+          end
+
+          def enum_divider_y
+            op_bottom_y + size + 5
+          end
+
+          def enum_literal_first_y
+            enum_divider_y + size + 5
+          end
+
+          # Tagged values appear after attributes (or after ops if
+          # present). EA does not emit a separate divider — the
+          # italic "tags" header marks the compartment.
+          def tagged_value_first_y
+            return nil unless tagged_values_count&.positive?
+
+            base = attr_bottom_y
+            base = op_bottom_y if op_lines_count&.positive?
+            base + size + 5
+          end
+        end
+      end
+    end
+  end
+end