ea 0.6.95 → 0.6.97

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87aea8f508b2ef7e8f98038519122caff0f87c967f3e59132838885124d0db84
-  data.tar.gz: 381aa0a30e5c9c3c60f0885f4fd2ca737d909f8fc620e36725e787db909898ab
+  metadata.gz: c2ca3f0fd4381aec39af89849d601c85defa496b697f1fe625558c8a210aef64
+  data.tar.gz: adbc3773a202f06ad7327ace0fbea64daacea45a4719afb28959332673dafdcd
 SHA512:
-  metadata.gz: adba2730ddbc449a79ce0063273cb6f75c4fc88d219899e12e13bc4226d2d88d5ef438c062384d908296e62938d1b937c56b926043e89dc55b4d43a1d53c63c8
-  data.tar.gz: b677683c53a71f27f68c2c80f7b150517288751bdbf586d78ad0fbe986b014931b57659235587e4ba61b8753656de72f6949363291fd6f1ab2d6e1a0a70aa5d1
+  metadata.gz: 99b878a17d58444e251964011cf2af59d46459223e657b8ffbf1a4602dc572af56e594bedd05c321cec0502d91e654cdd013d5b408277027d1c4f41c65885d3f
+  data.tar.gz: 73ef9107ec26ea7b60f7c9e5d00b7fa09b4d08b10842345c589a75dfd13a62b553287b95b0ad1b71e0c45fc032ab30ff1299fecb03e2a3abac69027a69180e97

data/config/themes/119.yml

@@ -10,6 +10,9 @@ font:
   weight_normal: 400
   weight_bold: 700
 
+label_font:
+  family: Cambria
+
 # Element-level font (distinct from diagram-level frame font).
 # EA renders classifier compartments at this size regardless of
 # the diagram-level font.size.

data/config/themes/39.yml

@@ -0,0 +1,8 @@
+id: "39"
+name: EA theme 39 connector labels
+font:
+  unit: px
+label_font:
+  family: Cambria
+  size: 7
+  unit: pt

data/lib/ea/fonts/cambria_7_regular_widths.json

@@ -0,0 +1,77 @@
+{
+  " ": 2,
+  "(": 4,
+  ")": 4,
+  "*": 4,
+  "+": 6,
+  "-": 3,
+  ".": 2,
+  "0": 6,
+  "1": 6,
+  "2": 6,
+  "3": 6,
+  "4": 6,
+  "5": 6,
+  "6": 6,
+  "8": 6,
+  "9": 6,
+  ":": 3,
+  "<": 6,
+  "=": 6,
+  ">": 6,
+  "A": 6,
+  "B": 6,
+  "C": 6,
+  "D": 7,
+  "E": 6,
+  "F": 5,
+  "G": 6,
+  "H": 7,
+  "I": 3,
+  "K": 6,
+  "L": 5,
+  "M": 8,
+  "N": 7,
+  "O": 7,
+  "P": 6,
+  "Q": 7,
+  "R": 6,
+  "S": 5,
+  "T": 6,
+  "U": 6,
+  "V": 6,
+  "W": 9,
+  "X": 6,
+  "Y": 6,
+  "Z": 5,
+  "[": 4,
+  "]": 4,
+  "a": 5,
+  "b": 5,
+  "c": 4,
+  "d": 6,
+  "e": 5,
+  "f": 3,
+  "g": 5,
+  "h": 6,
+  "i": 3,
+  "j": 3,
+  "k": 5,
+  "l": 3,
+  "m": 8,
+  "n": 6,
+  "o": 5,
+  "p": 6,
+  "q": 5,
+  "r": 4,
+  "s": 4,
+  "t": 3,
+  "u": 6,
+  "v": 5,
+  "w": 8,
+  "x": 5,
+  "y": 5,
+  "z": 5,
+  "{": 4,
+  "}": 4
+}

data/lib/ea/fonts/metrics.rb

@@ -29,9 +29,18 @@ module Ea
         "calibri" => "Carlito",
         "carlito" => "Carlito",
         "arial" => "Arial",
-        "arial narrow" => "Arial Narrow"
+        "arial narrow" => "Arial Narrow",
+        "cambria" => "Cambria"
       }.freeze
 
+      # Cambria measurements are in SVG units at 7pt, not em advances.
+      # Unmeasured characters and other sizes/styles must use the fallback.
+      CAMBRIA_7_REGULAR_WIDTHS = JSON.parse(File.read(
+                                              File.expand_path("cambria_7_regular_widths.json", __dir__)
+                                            )).freeze
+      CAMBRIA_7_GUILLEMET_PAIR_WIDTH = 10
+      private_constant :CAMBRIA_7_REGULAR_WIDTHS, :CAMBRIA_7_GUILLEMET_PAIR_WIDTH
+
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
 
@@ -64,6 +73,12 @@ module Ea
         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)
+      end
+
+      def advance_text_length(text, size_pt, family, weight, style)
         resolved = resolve_family(family)
         if GDI_HEIGHT_FAMILIES.include?(resolved)
           height = (size_pt.to_f * 10 / 7).round
@@ -86,6 +101,26 @@ module Ea
          cjk_count * CJK_ADVANCE * size_pt.to_f).round(3)
       end
 
+      private_class_method :advance_text_length
+
+      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 cambria_ascii_length(text) unless text.start_with?("«") && text.end_with?("»")
+
+        inner_width = cambria_ascii_length(text[1...-1])
+        inner_width + CAMBRIA_7_GUILLEMET_PAIR_WIDTH if inner_width
+      end
+      private_class_method :cambria_text_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)
+      end
+      private_class_method :cambria_ascii_length
+
       # Families whose EA driver quantizes per-glyph advances
       # (fitted from published textLengths).
       GDI_HEIGHT_FAMILIES = %w[Carlito].freeze

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

@@ -8,6 +8,187 @@ module Ea
         module Routing
           private
 
+          # Stored SY/EY use mathematical Y; ray origins use screen Y.
+          # Computed-jog origins are already normalized to their derived ports.
+          def correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
+            return model if context
+            return model unless stored_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
+
+            set_stored_ray_origins(model, source, target, geom)
+          end
+
+          def stored_ray_boxes(link_row, diagram_row)
+            connector = database.find_connector(link_row.connectorid)
+            [source_placement_for(connector, diagram_row),
+             target_placement_for(connector, diagram_row)].map { |placement| bounds_from_rect(placement) }
+          end
+
+          def set_stored_ray_origins(model, source, target, geom)
+            model.source_anchor = stored_ray_origin(source, geom[:sx], geom[:sy])
+            model.target_anchor = stored_ray_origin(target, geom[:ex], geom[:ey])
+            model
+          end
+
+          def stored_ray_candidate?(model, link_row, geom)
+            %w[Generalization Aggregation].include?(model.connector_type) &&
+              model.waypoints.size == 2 && stored_ray_style?(model.style, link_row) &&
+              stored_ray_geometry?(model, geom) && !normalized_port_anchors?(model)
+          end
+
+          def stored_ray_style?(style, link_row)
+            %w[1 3].include?(style[:mode]) && !style[:tree] &&
+              (style[:mode] == "1" || link_row.path.to_s.empty?)
+          end
+
+          def stored_ray_geometry?(model, geom)
+            model.has_geometry_offsets && model.source_port && model.target_port &&
+              (!geom[:sy].to_i.zero? || !geom[:ey].to_i.zero?)
+          end
+
+          def normalized_port_anchors?(model)
+            same_port_anchor?(model.source_anchor, model.source_port) &&
+              same_port_anchor?(model.target_anchor, model.target_port)
+          end
+
+          def same_port_anchor?(anchor, port)
+            anchor.x == port.x && anchor.y == port.y
+          end
+
+          def stored_ray_gap?(source, target, mode, edge)
+            return horizontal_ray_gap?(source, target) || vertical_ray_gap?(source, target) if mode == "1"
+
+            if edge == 1
+              target.y + target.height < source.y
+            elsif edge == 4
+              target.x + target.width < source.x
+            end
+          end
+
+          def horizontal_ray_gap?(source, target)
+            source.x + source.width < target.x || target.x + target.width < source.x
+          end
+
+          def vertical_ray_gap?(source, target)
+            source.y + source.height < target.y || target.y + target.height < source.y
+          end
+
+          def stored_ray_origin(bounds, x_offset, y_offset)
+            Ea::Model::Point.new(x: bounds.x + bounds.width / 2 + x_offset.to_i,
+                                 y: bounds.y + bounds.height / 2 - y_offset.to_i)
+          end
+
+          # Square routing keeps the stored orthogonal trunk, even when a
+          # shorter facing-edge route exists between the same boxes.
+          def stored_square_route(link_row, connector, source, target)
+            return nil unless stored_square_style?(link_row, connector)
+
+            corners = stored_square_corners(link_row)
+            square_corner_route(corners, source, target) if corners
+          end
+
+          def stored_square_style?(link_row, connector)
+            style = DiagramStyleParser.parse(link_row.style)
+            %w[Association Aggregation Generalization].include?(connector.connector_type) &&
+              style[:mode] == "3" && style[:tree] == "OS" && style[:lwidth] == "2"
+          end
+
+          def stored_square_corners(link_row)
+            return nil unless link_row.path.to_s.match?(/\A(?:-?\d+:-?\d+;)*-?\d+:-?\d+;?\z/)
+
+            corners = intermediate_waypoints(link_row)
+            corners if corners.each_cons(2).all? { |a, b| a[0] == b[0] || a[1] == b[1] }
+          end
+
+          def square_corner_route(corners, source, target)
+            first = square_corner_dock(corners.first, source)
+            last = square_corner_dock(corners.last, target)
+            return nil unless first && last
+
+            points = corners.dup
+            points.unshift(first) unless points.first == first
+            points.push(last) unless points.last == last
+            points if points.size >= 3
+          end
+
+          def square_corner_dock(corner, bounds)
+            x, y = corner
+            projected = [x.clamp(bounds.x, bounds.x + bounds.width),
+                         y.clamp(bounds.y, bounds.y + bounds.height)]
+            return nil if projected[0] != x && projected[1] != y
+
+            projected if rectangle_edge?(projected, bounds)
+          end
+
+          def rectangle_edge?(point, bounds)
+            [bounds.x, bounds.x + bounds.width].include?(point[0]) ||
+              [bounds.y, bounds.y + bounds.height].include?(point[1])
+          end
+
+          # A valid lateral corner joins one vertical leg and one horizontal
+          # leg. Keep it even when the boxes also admit a shorter direct route.
+          def stored_lateral_route(link_row, connector, source, target)
+            return nil unless %w[Aggregation Association].include?(connector.connector_type)
+
+            style = DiagramStyleParser.parse(link_row.style)
+            return nil unless stored_lateral_style?(style)
+
+            corner = stored_lateral_corner(link_row)
+            return nil unless corner
+
+            if style[:tree] == "LH"
+              horizontal_corner_route(corner, source, target)
+            else
+              vertical_corner_route(corner, source, target)
+            end
+          end
+
+          def stored_lateral_corner(link_row)
+            return nil unless link_row.path.to_s.match?(/\A-?\d+:-?\d+;?\z/)
+
+            intermediate_waypoints(link_row).first
+          end
+
+          def stored_lateral_style?(style)
+            style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) && %w[LH LV].include?(style[:tree])
+          end
+
+          def horizontal_corner?(corner, source, target)
+            within_horizontal_span?(corner, source) && within_height?(corner[1], target) &&
+              !within_height?(corner[1], source) && !within_horizontal_span?(corner, target)
+          end
+
+          def horizontal_corner_route(corner, source, target)
+            return nil unless horizontal_corner?(corner, source, target)
+
+            x, y = corner
+
+            source_y = y < source.y ? source.y : source.y + source.height
+            target_x = x < target.x ? target.x : target.x + target.width
+            [[x, source_y], corner, [target_x, y]]
+          end
+
+          def vertical_corner?(corner, source, target)
+            within_height?(corner[1], source) && within_horizontal_span?(corner, target) &&
+              !within_horizontal_span?(corner, source) && !within_height?(corner[1], target)
+          end
+
+          def vertical_corner_route(corner, source, target)
+            return nil unless vertical_corner?(corner, source, target)
+
+            x, y = corner
+
+            source_x = x < source.x ? source.x : source.x + source.width
+            target_y = y < target.y ? target.y : target.y + target.height
+            [[source_x, y], corner, [x, target_y]]
+          end
+
+          def within_height?(height, bounds)
+            height.between?(bounds.y, bounds.y + bounds.height)
+          end
+
           # A lateral tree leaves the side edge before turning upward.
           # Keep that dock only when its first leg actually points outward.
           def lateral_source_exit?(points, link_row, bounds)

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

@@ -385,7 +385,7 @@ module Ea
           geom = parse_geometry_fields(link_row.geometry)
           context = ContextDiagramSupport.package_context(diagram_row) ||
                     ContextDiagramSupport.element_regenerate?(diagram_row)
-          collapse_computed_jog(Ea::Model::DiagramConnector.new(
+          model = collapse_computed_jog(Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic("dc", diagram_row.diagram_id,
                                        link_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
@@ -410,6 +410,7 @@ module Ea
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
           ), link_row, diagram_row, geom)
+          correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
         end
 
         # Ray origin for one connector end: the element's center
@@ -648,7 +649,9 @@ module Ea
           # EDGE=2 routes are excluded; they are already exact.
           src = bounds_from_rect(source_placement)
           tgt = bounds_from_rect(target_placement)
-          tree_route = horizontal_tree_route(points, link_row, connector, src, tgt)
+          tree_route = stored_square_route(link_row, connector, src, tgt) ||
+                       stored_lateral_route(link_row, connector, src, tgt) ||
+                       horizontal_tree_route(points, link_row, connector, src, tgt)
           if tree_route
             points = tree_route
           elsif %w[Association Aggregation].include?(connector.connector_type) &&

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

@@ -106,7 +106,7 @@ module Ea
         def outline_connector?(connector, bounds)
           return true if %w[Generalization Aggregation].include?(connector.connector_type)
 
-          return false unless stored_association?(connector)
+          return false unless stored_association?(connector) || offset_free_association?(connector)
 
           # Diagonal Association rounding and tree docks keep their existing rules.
           pairs = clipped_pairs(bounds, [connector.source_anchor, connector.target_anchor])
@@ -122,6 +122,20 @@ module Ea
         end
         private_class_method :stored_association?
 
+        def offset_free_association?(connector)
+          style = connector.style.to_h
+          connector.connector_type == "Association" && style[:mode] == "3" && !style[:tree] &&
+            %i[direct regenerated].none? { |key| style.key?(key) } && offset_free_anchors?(connector)
+        end
+        private_class_method :offset_free_association?
+
+        def offset_free_anchors?(connector)
+          !connector.has_geometry_offsets &&
+            [connector.source_port, connector.target_port].all?(&:nil?) &&
+            [connector.source_anchor, connector.target_anchor].all?
+        end
+        private_class_method :offset_free_anchors?
+
         def clipped_pairs(bounds, anchors)
           source, target = bounds
           source_anchor, target_anchor = anchors

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -75,11 +75,8 @@ module Ea
               text_pos, mult_pos = tree_positions(end_kind, anchor, role,
                                                   text_pos, mult_pos)
             elsif mult_box && stored_offsets_zero?(mult_box)
-              # A stored mult box with OX=0:OY=0 means "EA default":
-              # the multiplicity sits 12px right of and 15px below the
-              # endpoint anchor, regardless of line direction
-              # (87-sample corpus fit: dy = +15 constant, dx = +12
-              # dominant with a +3 minority).
+              # Start at the legacy default; measured directional seats
+              # below replace it for default Cambria labels.
               mult_pos = [anchor[0] + 12, anchor[1] + 15]
             end
             # The end's stored stereotype renders verbatim («Type» on
@@ -89,8 +86,13 @@ module Ea
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
             if direction && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = role_seat(direction, anchor, text_box, role) || text_pos
-              mult_pos = mult_seat(direction, anchor, mult_box) || mult_pos
+              text_pos = source_property_seat(connector, direction, anchor, text_box, role) ||
+                         plain_upward_seat(connector, direction, anchor, text_box, role) ||
+                         role_seat(direction, anchor, text_box, role) || text_pos
+              mult_pos = directional_multiplicity(connector, direction, anchor, mult_box, mult) ||
+                         mult_seat(direction, anchor, mult_box) || mult_pos
+            elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
+              mult_pos = target_multiplicity_seat(heading, anchor, mult_box) || mult_pos
             end
 
             build_texts(role:, mult:, standalone:,
@@ -147,19 +149,22 @@ module Ea
           # right: the multiplicity 6px above it on an upward leg and
           # 15px below it on a rightward one, the role 7px above it on
           # a rightward one. Other sizes, headings, the target end,
-          # custom presentation keep their offsets; zero multiplicity boxes keep their default seat.
+          # custom presentation keep their offsets. Zero multiplicity boxes
+          # follow the direction for Cambria and keep the default otherwise.
           def leg_direction(end_kind, heading)
             return nil unless source_seat?(end_kind, heading)
 
             dx, dy = heading
             return :up if dx.zero? && dy.negative?
             return :right if dy.zero? && dx.positive?
+            return :left if dy.zero? && dx.negative?
+            return :down if dx.zero? && dy.positive?
 
             nil
           end
 
           # Role text on a rightward leg is left-aligned at the corner,
-          # 7px above it. Upward legs keep the plain role offset.
+          # 7px above it.
           def role_seat(direction, anchor, box, role)
             return nil unless direction == :right
             return nil if box.nil? || role_empty?(role)
@@ -169,8 +174,101 @@ module Ea
             [x + SEAT_X_INSET, y - 7]
           end
 
+          # Property-role clusters use a direction-specific right edge;
+          # alignment controls the stereotype line within that cluster.
+          def source_property_seat(connector, direction, anchor, box, role)
+            return nil unless %i[up left down].include?(direction) && property_role_box?(box, direction)
+            return nil unless source_property_font?(connector, direction)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            inset, baseline = property_role_offsets(direction)
+            [x - inset - width, y + baseline]
+          end
+
+          def plain_upward_seat(connector, direction, anchor, box, role)
+            return nil unless direction == :up && cambria_box?(box)
+            return nil unless [0, 1].include?(box["alignment"])
+            return nil unless connector_source_dest_stereotype(connector, :source).empty?
+            return nil unless plain_role_route?(connector.style.to_h)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            [x - SEAT_X_INSET - width, y - 6]
+          end
+
+          def plain_role_route?(style)
+            %w[1 3].include?(style[:mode]) && %w[0 2].include?(style[:lwidth]) &&
+              [nil, "V"].include?(style[:tree])
+          end
+
+          def property_role_box?(box, direction)
+            alignments = direction == :down ? [1] : [0, 1]
+            box && alignments.include?(box["alignment"]) && default_presentation?(box)
+          end
+
+          def property_role_offsets(direction)
+            case direction
+            when :up then [60, -6]
+            when :left then [60, -7]
+            else [65, 15]
+            end
+          end
+
+          def source_property_font?(connector, direction)
+            font_family.to_s.casecmp("Cambria").zero? &&
+              property_label?(connector, :source) &&
+              source_property_route?(connector.style.to_h, direction)
+          end
+
+          def source_property_route?(style, direction)
+            case direction
+            when :left then left_property_route?(style)
+            when :down then downward_property_route?(style)
+            else style[:lwidth] == "2" && style[:tree] != "OS"
+            end
+          end
+
+          def left_property_route?(style)
+            style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
+              [nil, "H", "LV"].include?(style[:tree])
+          end
+
+          def downward_property_route?(style)
+            %w[1 3].include?(style[:mode]) && style[:lwidth] == "2" && !style[:tree]
+          end
+
+          def directional_multiplicity(connector, direction, anchor, box, mult)
+            return nil unless cambria_box?(box)
+
+            x, y = seat_corner(anchor, box)
+            return [x + 8, y + 15] if direction == :down
+            return nil unless direction == :left && source_property_font?(connector, direction)
+
+            width = Ea::Fonts::Metrics.text_length(mult, font_size, family: font_family)
+            [x - width - 3, y + 15] if width
+          end
+
+          def target_multiplicity_seat(heading, anchor, box)
+            return nil unless seat_font?
+            return nil unless heading && heading[0].zero? && heading[1].negative?
+            return nil unless cambria_box?(box) && stored_offsets_zero?(box)
+
+            [anchor[0] + 8, anchor[1] - 7]
+          end
+
+          def cambria_box?(box)
+            box && default_presentation?(box) && font_family.to_s.casecmp("Cambria").zero?
+          end
+
           def mult_seat(direction, anchor, box)
-            return nil if box.nil? || stored_offsets_zero?(box)
+            return nil unless %i[up right].include?(direction)
+            return nil if box.nil?
+            return nil if stored_offsets_zero?(box) && !cambria_box?(box)
             return nil unless default_presentation?(box)
 
             x, y = seat_corner(anchor, box)

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

@@ -91,12 +91,13 @@ module Ea
           end_renderer.texts(text_box: src_tb, mult_box: src_mb,
                              anchor: source_pt, connector: connector,
                              end_kind: :source, tree: tree && tree[:source],
-                             heading: stored_src && leg_heading(points),
+                             heading: stored_src && source_heading(connector, points),
                              stored_labels: stored_labels).each { |t| texts << t }
           end_renderer.texts(text_box: tgt_tb,
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
                              end_kind: :target, tree: tree && tree[:target],
+                             heading: stored_tgt && leg_heading(points.reverse),
                              stored_labels: stored_labels).each { |t| texts << t }
           texts
         end
@@ -112,6 +113,72 @@ module Ea
           { source: true, target: true }
         end
 
+        # A diagonal clipped leg keeps the seat of its unambiguous exit face.
+        # Unknown faces retain the stored-upward fallback.
+        def source_heading(connector, points)
+          heading = leg_heading(points)
+          return heading unless points.size == 2 && heading.none?(&:zero?)
+
+          box = source_dock_bounds(connector)
+          face = box && dock_face_heading(points.first, box)
+          return face if face && face.zip(heading).any? { |axis, delta| (axis * delta).positive? }
+
+          stored_upward_heading(connector, heading)
+        end
+
+        def stored_upward_heading(connector, heading)
+          return heading unless heading[1].negative?
+
+          stored = waypoint_pairs(connector)
+          return heading unless stored.size == 2
+
+          original = leg_heading(stored)
+          original[0].zero? && original[1].negative? ? original : heading
+        end
+
+        def source_dock_bounds(connector)
+          return nil unless model_index && drawn_bounds
+
+          relationship = model_index[connector.relationship_ref]
+          return nil unless relationship
+
+          source, target = ConnectorRedock.end_refs(relationship)
+          return nil if source == target
+          return nil unless drawn_bounds[target]
+
+          drawn_bounds[source]
+        end
+
+        def dock_face_heading(point, box)
+          return nil unless box.width.positive? && box.height.positive?
+
+          vertical_dock_heading(point, box) || horizontal_dock_heading(point, box)
+        end
+
+        def vertical_dock_heading(point, box)
+          x, y = point
+          left = box.x
+          return nil unless x > left && x < left + box.width
+
+          top = box.y
+          return [0, -1] if [top, top - 1].include?(y)
+
+          bottom = top + box.height
+          [0, 1] if [bottom, bottom + 1].include?(y)
+        end
+
+        def horizontal_dock_heading(point, box)
+          x, y = point
+          top = box.y
+          return nil unless y > top && y < top + box.height
+
+          left = box.x
+          return [-1, 0] if [left, left - 1].include?(x)
+
+          right = left + box.width
+          [1, 0] if [right, right + 1].include?(x)
+        end
+
         def leg_heading(points)
           [points[1][0] - points[0][0], points[1][1] - points[0][1]]
         end
@@ -159,7 +226,7 @@ module Ea
             theme: theme,
             font_family: label_font_family,
             font_size: label_font_size,
-            font_unit: theme.font_size_unit
+            font_unit: theme.label_font_size_unit
           )
         end
 
@@ -169,7 +236,7 @@ module Ea
             model_index: model_index,
             font_family: label_font_family,
             font_size: label_font_size,
-            font_unit: theme.font_size_unit
+            font_unit: theme.label_font_size_unit
           )
         end
 
@@ -195,11 +262,11 @@ module Ea
         end
 
         def label_font_family
-          theme.font_family || DEFAULT_FAMILY
+          theme.label_font_family || DEFAULT_FAMILY
         end
 
         def label_font_size
-          theme.font_size || DEFAULT_SIZE
+          theme.label_font_size || DEFAULT_SIZE
         end
       end
     end

data/lib/ea/theme/definition.rb

@@ -65,6 +65,8 @@ module Ea
                                     text_y_offset: 12, line_height: 13).freeze
 
       def initialize(id:, name: nil, font_family: nil, font_size: nil,
+                     label_font_family: nil, label_font_size: nil,
+                     label_font_size_unit: nil,
                      font_size_unit: "pt", text_weight_normal: 400,
                      text_weight_bold: 700,
                      element_font_size: 9, element_font_unit: "pt",
@@ -81,6 +83,9 @@ module Ea
         @id = id.to_s
         @name = name
         @font_family = font_family
+        @label_font_family = label_font_family
+        @label_font_size = label_font_size
+        @label_font_size_unit = label_font_size_unit
         @font_size = font_size
         @font_size_unit = font_size_unit
         @text_weight_normal = text_weight_normal
@@ -119,7 +124,22 @@ module Ea
         fills[classifier.class.name]
       end
 
+      def label_font_family
+        @label_font_family || font_family
+      end
+
+      def label_font_size
+        @label_font_size || font_size
+      end
+
+      def label_font_size_unit
+        @label_font_size_unit || font_size_unit
+      end
+
       def with(**overrides)
+        clear_label_override(overrides, :font_family, :label_font_family)
+        clear_label_override(overrides, :font_size, :label_font_size)
+        clear_label_override(overrides, :font_size_unit, :label_font_size_unit)
         Definition.new(**to_h.merge(overrides))
       end
 
@@ -151,6 +171,9 @@ module Ea
           id: id, name: name,
           font_family: font_family, font_size: font_size,
           font_size_unit: font_size_unit,
+          label_font_family: @label_font_family,
+          label_font_size: @label_font_size,
+          label_font_size_unit: @label_font_size_unit,
           text_weight_normal: text_weight_normal,
           text_weight_bold: text_weight_bold,
           element_font_size: element_font_size,
@@ -171,6 +194,12 @@ module Ea
           package: package, note: note, fills: fills
         }
       end
+
+      private
+
+      def clear_label_override(overrides, global_key, label_key)
+        overrides[label_key] = nil if overrides.key?(global_key) && !overrides.key?(label_key)
+      end
     end
   end
 end

data/lib/ea/theme/loader.rb

@@ -10,6 +10,7 @@ module Ea
     #   name: EA White Theme
     #   font: { family: Carlito, size: 7, unit: pt, weight_normal: 400, ... }
     #   element_font: { size: 9, unit: pt }
+    #   label_font: { family: Cambria, size: 7, unit: pt }
     #   colors: { text: "#000000", attribute_text: "#66413F", ... }
     #   strokes: { element_border: 2, connector_line: 2, ... }
     #   text_metrics: { width_factor: 0.65 }
@@ -38,6 +39,7 @@ module Ea
         def from_hash(data)
           font = data["font"] || {}
           elem_font = data["element_font"] || {}
+          label_font = data["label_font"] || {}
           colors = data["colors"] || {}
           strokes = data["strokes"] || {}
           text_metrics = data["text_metrics"] || {}
@@ -53,6 +55,9 @@ module Ea
             id: data["id"],
             name: data["name"],
             font_family: font["family"],
+            label_font_family: label_font["family"],
+            label_font_size: label_font["size"],
+            label_font_size_unit: label_font["unit"],
             font_size: font["size"],
             font_size_unit: font["unit"] || "pt",
             text_weight_normal: font["weight_normal"] || 400,

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.95"
+  VERSION = "0.6.97"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.95
+  version: 0.6.97
 platform: ruby
 authors:
 - Ribose Inc.
@@ -501,6 +501,7 @@ files:
 - config/qea_schema.yml
 - config/stereotype_colors.yml
 - config/themes/119.yml
+- config/themes/39.yml
 - config/themes/default.yml
 - docs/ea_to_uml_type_mapping.md
 - docs/xmi_qea_conversion_capabilities.md
@@ -615,6 +616,7 @@ files:
 - lib/ea/export/xsd/generator.rb
 - lib/ea/export/xsd/namespace_registry.rb
 - lib/ea/fonts.rb
+- lib/ea/fonts/cambria_7_regular_widths.json
 - lib/ea/fonts/carlito_metrics.json
 - lib/ea/fonts/metrics.rb
 - lib/ea/guid_format.rb