Originally, #5999 was filed to report issues with the sleeve on Jaeger
not responding to biceps ease as expected. Increasing the biceps ease
would actually make the sleeve more narrow.
Turns out, this is a side-effect of the way the armhole depth is
calculated in v3. We used to take the biceps measurement (and ease) for
that, but now we rely on the waist to armpit measurements.
In brain, we used this new measurements along with the
armholeDepthFactor option to locate the bottom of the armhole.
This means that when we change the biceps ease, nothing will change in
the briam armhole, which means the total sleevecap length target remains
unchanges.
However, in Jaeger, increased biceps ease causes a taller sleevecap, and
since the total target sleevecap length (inherited from Brian) remains
unchanged, the pattern accomodates by making the sleeve more narrow so
that the taller sleevecap has the same sleevecap length. This is what
results in the counterintuitive behavior where increasing the biceps
ease makes the sleevecap more narrow.
This resolves that by taking the biceps ease into account when
calculating the bottom of the armhole in Brian. As a result, changing
the biceps ease will impact the armhole on Brian, which will in turn
influence the target sleevecap length that Bent drafts a 2-part sleeve
for, and now things work as aspected.
Given that Brian is such a foundational block, making changes to it is a
high-stakes game, but I feel this is a bug, so we need to fix it.
Fixes#5999
The discussion in #5976 is whether `Path.join()` should use a line
segment to close any gaps in the path caused by move operations, or by
differences in the end and start points of paths being joined.
The answer is yes, that is the intended behaviour, but people who read
_join_ might expect differently.
So I have made a few changes to clarify this:
- The new `Path.combine()` method combines multiple path instances into
a single instance without making any changes to the drawing operations
- Since `Path.combine()` is variadic, I have also updated `Path.join()`
to be variadic too, since that is more consistent.
- The old way of calling `Path.join(path, bool)` is deprecated and will
log a warning. Calling `Path.join()` this way will be removed in v4.
- Related to this change is how `Path.length()` should behave when there
are gaps in the path. Currently, it skips those. So I've added a
parameter that when set to `true` will include them.
- Added documentation for `Path.combine()`
- Updated documentation for `Path.join()`
- Updated documentation for `Path.length()`
