ea 0.6.106 → 0.6.108

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 944b29164fec6d17c5e89224547ae993a7ef4dfbee74ac1c15208eba6f88f0d5
-  data.tar.gz: e0d40f4203d9ef1bf8a1d6f0cf72349b7e3e052ed2c3c920f96f1ca655ff2741
+  metadata.gz: e5457390e5e190fab6345e9bb50a0bb773b1223e7e0617de9b8121efb6eb0cf7
+  data.tar.gz: b56bf3ce3bb1b5b8f1339f509b1ba99080f72eb480c0d85db5826c7251f91caa
 SHA512:
-  metadata.gz: 4087c56867c690c67f9c99011a3e8bd4c043fdcb4bb25880a6d7020d7bab5c6e9bed6adc5b25475e37d9dfe64034d6ce7a52fea44d163fb7a41df37998ce1186
-  data.tar.gz: 4ae9f0ff3fc328d2f4ceeec2a9e8b0acb51fc72326c9806b00471449dfc656d3b60029f002b4bd5e59269c32807144ed1a660dafb29bc9b4916731e5ba57e761
+  metadata.gz: 769abf22c7038cab232e7ca4965dd44d6e11c1940d1de7cbc9f5821478109d5113d430805af6278caa34fa827167f92834400631992305f402ea38483d2e98d9
+  data.tar.gz: 19a7d924227c5783ac2e348ab6b682943746112bc3809fd32d2c1edef3c92fabdf2e74ac1de1f910c996b355825ab083cb25d20d7910ac68851801d4d5c5b401

data/config/themes/119.yml

@@ -17,14 +17,15 @@ label_font:
 # EA renders classifier compartments at this size regardless of
 # the diagram-level font.size.
 element_font:
+  family: Cambria
   size: 9
   unit: pt
 
 # Colors (decoded from EA's BGR integer encoding).
-# AttrColor=4145510→#66413F, ElemLineColor=8684698→#9A8484.
+# ElemLineColor=8684698→#9A8484. Attribute rows inherit `text`: EA's
+# exported SVGs draw them black, and QEA stores no attribute color.
 colors:
   text: "#000000"
-  attribute_text: "#66413F"
   method_text: "#335C5D"
   border: "#9A8484"
   fill: "#FFFFFF"

data/lib/ea/fonts/cambria_7_styled_widths.json

@@ -0,0 +1,293 @@
+{
+  "bold": {
+    " ": 2,
+    "!": 3,
+    "\"": 4,
+    "#": 6,
+    "$": 5,
+    "%": 10,
+    "&": 7,
+    "'": 3,
+    "(": 4,
+    ")": 4,
+    "*": 5,
+    "+": 6,
+    ",": 2,
+    "-": 3,
+    ".": 2,
+    "/": 5,
+    "0": 6,
+    "1": 6,
+    "2": 6,
+    "3": 6,
+    "4": 6,
+    "5": 6,
+    "6": 6,
+    "7": 6,
+    "8": 6,
+    "9": 6,
+    ":": 3,
+    ";": 3,
+    "<": 6,
+    "=": 6,
+    ">": 6,
+    "?": 5,
+    "@": 9,
+    "A": 7,
+    "B": 7,
+    "C": 6,
+    "D": 7,
+    "E": 6,
+    "F": 6,
+    "G": 6,
+    "H": 7,
+    "I": 4,
+    "J": 3,
+    "K": 7,
+    "L": 6,
+    "M": 8,
+    "N": 7,
+    "O": 7,
+    "P": 6,
+    "Q": 7,
+    "R": 7,
+    "S": 5,
+    "T": 6,
+    "U": 7,
+    "V": 6,
+    "W": 10,
+    "X": 6,
+    "Y": 6,
+    "Z": 6,
+    "[": 4,
+    "\\": 5,
+    "]": 4,
+    "^": 6,
+    "_": 4,
+    "`": 3,
+    "a": 5,
+    "b": 6,
+    "c": 5,
+    "d": 6,
+    "e": 5,
+    "f": 3,
+    "g": 5,
+    "h": 6,
+    "i": 3,
+    "j": 3,
+    "k": 6,
+    "l": 3,
+    "m": 9,
+    "n": 6,
+    "o": 6,
+    "p": 6,
+    "q": 6,
+    "r": 5,
+    "s": 5,
+    "t": 4,
+    "u": 6,
+    "v": 5,
+    "w": 8,
+    "x": 5,
+    "y": 5,
+    "z": 5,
+    "{": 4,
+    "|": 3,
+    "}": 4,
+    "~": 6
+  },
+  "italic": {
+    " ": 2,
+    "!": 3,
+    "\"": 4,
+    "#": 6,
+    "$": 5,
+    "%": 9,
+    "&": 7,
+    "'": 2,
+    "(": 4,
+    ")": 4,
+    "*": 4,
+    "+": 5,
+    ",": 2,
+    "-": 3,
+    ".": 2,
+    "/": 5,
+    "0": 5,
+    "1": 5,
+    "2": 5,
+    "3": 5,
+    "4": 5,
+    "5": 5,
+    "6": 5,
+    "7": 5,
+    "8": 5,
+    "9": 5,
+    ":": 3,
+    ";": 3,
+    "<": 5,
+    "=": 5,
+    ">": 5,
+    "?": 4,
+    "@": 9,
+    "A": 6,
+    "B": 6,
+    "C": 5,
+    "D": 6,
+    "E": 6,
+    "F": 5,
+    "G": 6,
+    "H": 7,
+    "I": 3,
+    "J": 3,
+    "K": 6,
+    "L": 5,
+    "M": 8,
+    "N": 7,
+    "O": 6,
+    "P": 6,
+    "Q": 6,
+    "R": 6,
+    "S": 5,
+    "T": 6,
+    "U": 6,
+    "V": 6,
+    "W": 9,
+    "X": 5,
+    "Y": 5,
+    "Z": 5,
+    "[": 3,
+    "\\": 5,
+    "]": 3,
+    "^": 5,
+    "_": 4,
+    "`": 3,
+    "a": 5,
+    "b": 5,
+    "c": 4,
+    "d": 5,
+    "e": 5,
+    "f": 3,
+    "g": 5,
+    "h": 5,
+    "i": 3,
+    "j": 3,
+    "k": 5,
+    "l": 3,
+    "m": 8,
+    "n": 5,
+    "o": 5,
+    "p": 5,
+    "q": 5,
+    "r": 4,
+    "s": 4,
+    "t": 3,
+    "u": 5,
+    "v": 5,
+    "w": 7,
+    "x": 4,
+    "y": 5,
+    "z": 4,
+    "{": 4,
+    "|": 3,
+    "}": 4,
+    "~": 5
+  },
+  "bold_italic": {
+    " ": 2,
+    "!": 3,
+    "\"": 4,
+    "#": 6,
+    "$": 5,
+    "%": 10,
+    "&": 7,
+    "'": 2,
+    "(": 4,
+    ")": 4,
+    "*": 4,
+    "+": 6,
+    ",": 2,
+    "-": 3,
+    ".": 2,
+    "/": 5,
+    "0": 6,
+    "1": 6,
+    "2": 6,
+    "3": 6,
+    "4": 6,
+    "5": 6,
+    "6": 6,
+    "7": 6,
+    "8": 6,
+    "9": 6,
+    ":": 3,
+    ";": 3,
+    "<": 6,
+    "=": 6,
+    ">": 6,
+    "?": 4,
+    "@": 9,
+    "A": 6,
+    "B": 6,
+    "C": 6,
+    "D": 7,
+    "E": 6,
+    "F": 5,
+    "G": 6,
+    "H": 7,
+    "I": 3,
+    "J": 3,
+    "K": 7,
+    "L": 5,
+    "M": 8,
+    "N": 7,
+    "O": 7,
+    "P": 6,
+    "Q": 7,
+    "R": 6,
+    "S": 5,
+    "T": 6,
+    "U": 7,
+    "V": 6,
+    "W": 9,
+    "X": 6,
+    "Y": 6,
+    "Z": 5,
+    "[": 4,
+    "\\": 5,
+    "]": 4,
+    "^": 6,
+    "_": 4,
+    "`": 3,
+    "a": 6,
+    "b": 6,
+    "c": 5,
+    "d": 6,
+    "e": 5,
+    "f": 3,
+    "g": 6,
+    "h": 6,
+    "i": 3,
+    "j": 3,
+    "k": 5,
+    "l": 3,
+    "m": 9,
+    "n": 6,
+    "o": 5,
+    "p": 6,
+    "q": 6,
+    "r": 5,
+    "s": 4,
+    "t": 4,
+    "u": 6,
+    "v": 5,
+    "w": 8,
+    "x": 5,
+    "y": 5,
+    "z": 5,
+    "{": 4,
+    "|": 3,
+    "}": 4,
+    "~": 6
+  }
+}

data/lib/ea/fonts/metrics.rb

@@ -38,8 +38,15 @@ module Ea
       CAMBRIA_7_REGULAR_WIDTHS = JSON.parse(File.read(
                                               File.expand_path("cambria_7_regular_widths.json", __dir__)
                                             )).freeze
+      # Styled ASCII advances come from Cambria's native TTF metrics,
+      # quantized at the same 10px logical height as EA's 7pt font.
+      # Bold uses monochrome hinted advances from the native TTF.
+      CAMBRIA_7_STYLED_WIDTHS = JSON.parse(File.read(
+                                             File.expand_path("cambria_7_styled_widths.json", __dir__)
+                                           )).freeze
       CAMBRIA_7_GUILLEMET_PAIR_WIDTH = 10
-      private_constant :CAMBRIA_7_REGULAR_WIDTHS, :CAMBRIA_7_GUILLEMET_PAIR_WIDTH
+      private_constant :CAMBRIA_7_REGULAR_WIDTHS, :CAMBRIA_7_STYLED_WIDTHS,
+                       :CAMBRIA_7_GUILLEMET_PAIR_WIDTH
 
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
@@ -60,6 +67,32 @@ module Ea
 
       module_function
 
+      # EA's Cambria 7pt compartment rows use a 12px cell; Carlito
+      # uses 13px. Keep unmeasured sizes and pixel fonts on their
+      # configured spacing.
+      def compartment_line_height(size, family:, unit: "pt", offset: 6, logical_height: nil)
+        return size + offset - 1 if compact_compartment_font?(size, family: family, unit: unit)
+
+        # Source sizes 90 and 100 both export as 9pt but retain
+        # distinct 12px and 13px logical heights. Apply that same
+        # source-height delta to the existing compartment spacing.
+        adjustment = if logical_height && unit == "pt" &&
+                        GDI_HEIGHT_FAMILIES.include?(resolve_family(family))
+                       logical_height - gdi_logical_height(size)
+                     else
+                       0
+                     end
+        size + offset + adjustment
+      end
+
+      def gdi_logical_height(size)
+        (size.to_f * 10 / 7).round
+      end
+
+      def compact_compartment_font?(size, family:, unit: "pt")
+        family.to_s.casecmp("Cambria").zero? && size == 7 && unit == "pt"
+      end
+
       # Width of `text` in EA's exported SVG units for the given pt
       # size, or nil when the family is not metric-compatible.
       #
@@ -69,19 +102,19 @@ module Ea
       # textLength is the SUM of those per-glyph integers - corpus
       # fitted to 97-100% exact on 10k Carlito texts (bold 7pt
       # 1666/1671). The legacy sum-then-round model matched only 27%.
-      def text_length(text, size_pt, family: nil, weight: nil, style: nil)
+      def text_length(text, size_pt, family: nil, weight: nil, style: nil, logical_height: nil)
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
         return cambria_text_length(text, size_pt, weight, style) if resolve_family(family) == "Cambria"
 
-        advance_text_length(text, size_pt, family, weight, style)
+        advance_text_length(text, size_pt, family, weight, style, logical_height)
       end
 
-      def advance_text_length(text, size_pt, family, weight, style)
+      def advance_text_length(text, size_pt, family, weight, style, logical_height)
         resolved = resolve_family(family)
         if GDI_HEIGHT_FAMILIES.include?(resolved)
-          height = (size_pt.to_f * 10 / 7).round
+          height = logical_height || gdi_logical_height(size_pt)
           table = table_for(family, weight, style)
           latin = 0
           cjk_count = 0
@@ -105,8 +138,11 @@ module Ea
 
       def cambria_text_length(text, size_pt, weight, style)
         return nil unless size_pt.to_f.to_r == 7
-        return nil unless ["", "0", "400", "normal"].include?(weight.to_s)
-        return nil unless ["", "normal"].include?(style.to_s)
+        return nil unless ["", "0", "400", "normal", "700", "bold"].include?(weight.to_s)
+        return nil unless ["", "normal", "italic"].include?(style.to_s)
+
+        key = STYLE_KEYS.fetch([bold?(weight), italic?(style)])
+        return cambria_styled_length(text, key) unless key == :regular
 
         return cambria_ascii_length(text) unless text.start_with?("«") && text.end_with?("»")
 
@@ -115,6 +151,13 @@ module Ea
       end
       private_class_method :cambria_text_length
 
+      def cambria_styled_length(text, key)
+        table = CAMBRIA_7_STYLED_WIDTHS.fetch(key.to_s)
+        widths = text.each_char.map { |char| table[char] }
+        widths.sum unless widths.empty? || widths.include?(nil)
+      end
+      private_class_method :cambria_styled_length
+
       def cambria_ascii_length(text)
         widths = text.each_char.map { |char| CAMBRIA_7_REGULAR_WIDTHS[char] }
         widths.sum unless widths.empty? || widths.include?(nil)

data/lib/ea/model/diagram_element.rb

@@ -22,6 +22,8 @@ module Ea
       attribute :line_width, :integer
       attribute :font_family, :string
       attribute :font_size, :integer
+      attribute :font_logical_height, :integer # original GDI pixel height before point normalization
+      attribute :font_size_unit, :string # source font size unit, before theme fallback
       attribute :font_bold, :boolean
       attribute :font_italic, :boolean
       attribute :font_underline, :boolean
@@ -53,6 +55,8 @@ module Ea
         map "lineWidth", to: :line_width
         map "fontFamily", to: :font_family
         map "fontSize", to: :font_size
+        map "fontSizeUnit", to: :font_size_unit
+        map "fontLogicalHeight", to: :font_logical_height
         map "fontBold", to: :font_bold, render_default: true
         map "fontItalic", to: :font_italic, render_default: true
         map "fontUnderline", to: :font_underline, render_default: true

data/lib/ea/sources/qea/diagram_builder/auto_routing.rb

@@ -8,12 +8,118 @@ module Ea
         module AutoRouting
           private
 
-          # Nonuniform horizontal offsets seat the route at the source row.
+          # An empty flush LV tree uses the target's center x and source's
+          # center y for its corner, the transposed LH construction. Keep
+          # authored corners and other connector styles on their existing path.
+          def derived_vertical_lateral_route(style, link_row, connector, source, target)
+            return nil unless style[:mode] == "3" && style[:lwidth] == "0" &&
+                              connector.connector_type == "Association" && link_row.path.to_s.empty?
+
+            corner = [target.x + target.width / 2, source.y + source.height / 2]
+            vertical_corner_route(corner, source, target)
+          end
+
+          # Without an authored Path, a direct Association can still store
+          # aligned mathematical origins rather than screen-space ports.
+          def stored_association_path?(model, link_row, source, target, geom)
+            return true unless model.connector_type == "Association" && link_row.path.to_s.empty?
+            return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
+
+            origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
+                       stored_ray_origin(target, geom[:ex], geom[:ey])]
+            origins.first.y == origins.last.y && horizontal_ray_gap?(source, target) &&
+              origins.zip([source, target]).all? { |origin, box| inside_box?(origin, grown_bounds(box, 1)) }
+          end
+
+          # A Mode 2 Association with equal SX/EX (vertical EDGE 1/3) or
+          # equal SY/EY (horizontal EDGE 2/4) and no custom Path docks as a
+          # straight line through the middle of the boxes' overlap, moved
+          # by the shared stored offset. Stored SY counts upward.
+          def overlap_ray_origins(model, link_row, diagram_row, geom, context)
+            return model if context
+            return model unless overlap_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            origins = overlap_origins(source, target, geom)
+            return model unless origins && overlap_correction?(source, target, geom)
+
+            model.source_anchor, model.target_anchor = origins.map do |ox, oy|
+              Ea::Model::Point.new(x: ox, y: oy)
+            end
+            if model.waypoints.size == 3
+              model.waypoints = port_waypoints(model, [model.source_anchor, model.target_anchor])
+            end
+            model.style[:overlap_ray] = true
+            model
+          end
+
+          # Aligned, zero-offset EDGE 2 routes already have their legacy docks.
+          def overlap_correction?(source, target, geom)
+            geom[:edge] != 2 || !geom[:sy].zero? ||
+              source.y * 2 + source.height != target.y * 2 + target.height
+          end
+
+          # Both ray origins share the overlap coordinate on the axis the
+          # offsets move and sit at each box's centre on the other axis.
+          def overlap_origins(source, target, geom)
+            along, across, offset = overlap_axes(geom)
+            coordinate = overlap_ray_coordinate(*box_span(source, along), *box_span(target, along), offset)
+            return nil unless coordinate && disjoint_span?(*box_span(source, across), *box_span(target, across))
+
+            [source, target].map do |box|
+              start, size = box_span(box, across)
+              centre = start + size / 2.0
+              [2, 4].include?(geom[:edge]) ? [centre, coordinate] : [coordinate, centre]
+            end
+          end
+
+          # [axis the offsets move, axis the boxes face, stored offset]
+          def overlap_axes(geom)
+            return [%i[y height], %i[x width], -geom[:sy]] if [2, 4].include?(geom[:edge])
+
+            [%i[x width], %i[y height], geom[:sx]]
+          end
+
+          def box_span(box, keys)
+            keys.map { |key| box.public_send(key) }
+          end
+
+          def overlap_ray_candidate?(model, link_row, geom)
+            model.connector_type == "Association" && model.style[:mode] == "2" &&
+              [2, 3].include?(model.waypoints.size) && link_row.path.to_s.empty? && !model.style[:tree] &&
+              model.has_geometry_offsets && uniform_overlap_offsets?(geom)
+          end
+
+          def uniform_overlap_offsets?(geom)
+            return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
+
+            if [2, 4].include?(geom[:edge])
+              geom[:sy] == geom[:ey]
+            else
+              [1, 3].include?(geom[:edge]) && geom[:sx] == geom[:ex]
+            end
+          end
+
+          # Floor of the overlap midpoint plus the shared offset; nil
+          # when the boxes do not overlap on this axis.
+          def overlap_ray_coordinate(start_a, size_a, start_b, size_b, offset)
+            low = [start_a, start_b].max
+            high = [start_a + size_a, start_b + size_b].min
+            return nil if low > high
+
+            coordinate = ((low + high) / 2.0 + offset).floor
+            coordinate if coordinate.between?(low, high)
+          end
+
+          # Nonuniform horizontal offsets move the shared overlap row by SY.
           # Uniform offsets retain the shared-overlap routing contract.
           def source_row_association_ray(model, link_row, diagram_row, geom, context)
-            return model if context || !source_row_association?(model, link_row, geom)
+            return model if context || !source_row_association?(model, geom)
 
-            origins = source_row_origins(*stored_ray_boxes(link_row, diagram_row), geom)
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless source_row_path?(link_row, source, target)
+
+            origins = source_row_origins(source, target, geom)
             return model unless origins
 
             model.source_anchor, model.target_anchor = origins
@@ -72,16 +178,12 @@ module Ea
           def source_row_origins(source, target, geom)
             return nil unless source_row_faces_target?(source, target, geom[:edge])
 
-            row = source_row_y(source, geom)
-            return nil unless [source, target].all? { |box| within_height?(row, box) }
+            row = overlap_ray_coordinate(source.y, source.height, target.y, target.height, -geom[:sy])
+            return nil unless row && [source, target].all? { |box| within_height?(row, box) }
 
             [source, target].map { |box| Ea::Model::Point.new(x: box.x + box.width / 2.0, y: row) }
           end
 
-          def source_row_y(source, geom)
-            (source.y + source.height / 2.0 - geom[:sy]).floor
-          end
-
           def source_row_faces_target?(source, target, edge)
             if edge == 2
               source.x + source.width < target.x
@@ -90,13 +192,24 @@ module Ea
             end
           end
 
-          def source_row_association?(model, link_row, geom)
+          def source_row_association?(model, geom)
             model.connector_type == "Association" && model.has_geometry_offsets &&
               model.source_anchor && model.target_anchor &&
-              link_row.path.to_s.empty? && source_row_style?(model.style.to_h) &&
+              source_row_style?(model.style.to_h) &&
               source_row_offsets?(geom)
           end
 
+          def source_row_path?(link_row, source, target)
+            link_row.path.to_s.empty? || stale_horizontal_jog?(link_row, source, target)
+          end
+
+          # A horizontal saved jog outside both boxes is stale auto-routing.
+          # A corner that still lies beside either box remains authored.
+          def stale_horizontal_jog?(link_row, source, target)
+            corners = intermediate_waypoints(link_row)
+            horizontal_jog?(corners) && [source, target].none? { |box| within_height?(corners.first[1], box) }
+          end
+
           def source_row_style?(style)
             style[:mode] == "2" && style[:lwidth] == "2" && !style[:tree]
           end

data/lib/ea/sources/qea/diagram_builder/font_settings.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      class DiagramBuilder
+        # Resolves saved classifier and placement fonts and EA's point sizes.
+        module FontSettings
+          private
+
+          # Placement defaults inherit the classifier's saved font before the
+          # diagram theme. A zero fontsz is EA's use-default marker.
+          def effective_font_style(obj_row, style)
+            object = database.find_object(obj_row.ea_object_id)
+            defaults = DiagramStyleParser.parse(object&.styleex)
+            {
+              font: presence(style[:font]) || defaults[:font],
+              fontsz: font_size_from(style) ? style[:fontsz] : defaults[:fontsz]
+            }
+          end
+
+          def presence(value)
+            value.nil? || value.to_s.empty? ? nil : value
+          end
+
+          # EA stores the element font size in tenths of a point and
+          # renders it through GDI's double rounding: pixel height =
+          # floor(tenths * 96 / 720), then point size =
+          # floor(pixels * 72 / 96). A zero fontsz inherits the default.
+          USE_DEFAULT_FONTSZ = [0].freeze
+          GDI_DPI = 96
+
+          def font_logical_height_from(style_hash)
+            raw = style_hash[:fontsz]
+            return nil if raw.nil? || raw.to_s.empty?
+
+            return nil if USE_DEFAULT_FONTSZ.include?(raw.to_i)
+
+            (raw.to_f * GDI_DPI / 720).floor
+          end
+
+          def font_size_from(style_hash)
+            pixels = font_logical_height_from(style_hash)
+            (pixels * 72.0 / GDI_DPI).floor if pixels
+          end
+        end
+      end
+    end
+  end
+end