mirror of
https://github.com/juce-framework/JUCE.git
synced 2026-01-10 23:44:24 +00:00
Move ShapedText to the detail namespace and expose it in the headers
This makes it accessible for the new TextEditor implementation in juce_gui_basics.
This commit is contained in:
attila
Attila Szarvas
parent
e31fb368b6
commit
1b595311d0
39 changed files with 891 additions and 607 deletions
474
modules/juce_graphics/detail/juce_JustifiedText.cpp
Normal file
474
modules/juce_graphics/detail/juce_JustifiedText.cpp
Normal file
|
|
@ -0,0 +1,474 @@
|
|||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE framework.
|
||||
Copyright (c) Raw Material Software Limited
|
||||
|
||||
JUCE is an open source framework subject to commercial or open source
|
||||
licensing.
|
||||
|
||||
By downloading, installing, or using the JUCE framework, or combining the
|
||||
JUCE framework with any other source code, object code, content or any other
|
||||
copyrightable work, you agree to the terms of the JUCE End User Licence
|
||||
Agreement, and all incorporated terms including the JUCE Privacy Policy and
|
||||
the JUCE Website Terms of Service, as applicable, which will bind you. If you
|
||||
do not agree to the terms of these agreements, we will not license the JUCE
|
||||
framework to you, and you must discontinue the installation or download
|
||||
process and cease use of the JUCE framework.
|
||||
|
||||
JUCE End User Licence Agreement: https://juce.com/legal/juce-8-licence/
|
||||
JUCE Privacy Policy: https://juce.com/juce-privacy-policy
|
||||
JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/
|
||||
|
||||
Or:
|
||||
|
||||
You may also use this code under the terms of the AGPLv3:
|
||||
https://www.gnu.org/licenses/agpl-3.0.en.html
|
||||
|
||||
THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
|
||||
WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
|
||||
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce::detail
|
||||
{
|
||||
|
||||
void drawJustifiedText (const JustifiedText& text, const Graphics& g, AffineTransform);
|
||||
|
||||
//==============================================================================
|
||||
static constexpr auto maxWidthTolerance = 0.005f;
|
||||
|
||||
static int64 getNumLeadingWhitespaces (Span<const ShapedGlyph> glyphs)
|
||||
{
|
||||
const auto it = std::find_if_not (glyphs.begin(),
|
||||
glyphs.end(),
|
||||
[&] (const auto& g) { return g.whitespace; });
|
||||
|
||||
return (int64) std::distance (glyphs.begin(), it);
|
||||
}
|
||||
|
||||
static int64 getNumTrailingWhitespaces (Span<const ShapedGlyph> glyphs)
|
||||
{
|
||||
if (glyphs.empty())
|
||||
return 0;
|
||||
|
||||
int64 trailingWhitespaces = 0;
|
||||
|
||||
for (auto it = glyphs.end(); --it >= glyphs.begin() && it->whitespace;)
|
||||
++trailingWhitespaces;
|
||||
|
||||
return trailingWhitespaces;
|
||||
}
|
||||
|
||||
struct NumWhitespaces
|
||||
{
|
||||
int64 total{}, leading{}, trailing{};
|
||||
};
|
||||
|
||||
static NumWhitespaces getNumWhitespaces (Span<const ShapedGlyph> glyphs)
|
||||
{
|
||||
const auto total = std::count_if (glyphs.begin(),
|
||||
glyphs.end(),
|
||||
[] (const auto& g) { return g.whitespace; });
|
||||
|
||||
return { total, getNumLeadingWhitespaces (glyphs), getNumTrailingWhitespaces (glyphs) };
|
||||
}
|
||||
|
||||
struct LineLength
|
||||
{
|
||||
float total{}, withoutTrailingWhitespaces{};
|
||||
};
|
||||
|
||||
static LineLength getMainAxisLineLength (Span<const ShapedGlyph> glyphs)
|
||||
{
|
||||
const auto total = std::accumulate (glyphs.begin(),
|
||||
glyphs.end(),
|
||||
0.0f,
|
||||
[] (auto acc, const auto& g) { return acc + g.advance.getX(); });
|
||||
|
||||
auto trailingWhitespacesLength = 0.0f;
|
||||
|
||||
if (glyphs.empty())
|
||||
return {};
|
||||
|
||||
for (auto it = glyphs.end(); --it >= glyphs.begin() && it->whitespace;)
|
||||
trailingWhitespacesLength += it->advance.getX();
|
||||
|
||||
return { total, total - trailingWhitespacesLength };
|
||||
}
|
||||
|
||||
static float getMainAxisLineLength (Span<const ShapedGlyph> glyphs, bool trailingWhitespacesShouldFit)
|
||||
{
|
||||
const auto lengths = getMainAxisLineLength (glyphs);
|
||||
|
||||
return trailingWhitespacesShouldFit ? lengths.total : lengths.withoutTrailingWhitespaces;
|
||||
}
|
||||
|
||||
struct MainAxisLineAlignment
|
||||
{
|
||||
float anchor{}, extraWhitespaceAdvance{};
|
||||
Range<int64> stretchableWhitespaces;
|
||||
};
|
||||
|
||||
static MainAxisLineAlignment getMainAxisLineAlignment (Justification justification,
|
||||
Span<const ShapedGlyph> glyphs,
|
||||
LineLength lineLength,
|
||||
float maxWidth,
|
||||
bool trailingWhitespacesShouldFit)
|
||||
{
|
||||
const auto effectiveLineLength = (trailingWhitespacesShouldFit ? lineLength.total
|
||||
: lineLength.withoutTrailingWhitespaces);
|
||||
|
||||
const auto tooLong = maxWidth + maxWidthTolerance < effectiveLineLength;
|
||||
|
||||
const auto mainAxisLineOffset = [&]
|
||||
{
|
||||
if (tooLong)
|
||||
{
|
||||
const auto approximateIsLeftToRight = [&]
|
||||
{
|
||||
if (glyphs.empty())
|
||||
return true;
|
||||
|
||||
return glyphs.front().cluster <= glyphs.back().cluster;
|
||||
}();
|
||||
|
||||
if (approximateIsLeftToRight)
|
||||
return 0.0f;
|
||||
|
||||
return maxWidth - effectiveLineLength;
|
||||
}
|
||||
|
||||
if (justification.testFlags (Justification::horizontallyCentred))
|
||||
{
|
||||
return (maxWidth - lineLength.withoutTrailingWhitespaces) / 2.0f;
|
||||
}
|
||||
|
||||
if (justification.testFlags (Justification::right))
|
||||
return maxWidth - effectiveLineLength;
|
||||
|
||||
return 0.0f;
|
||||
}();
|
||||
|
||||
const auto numWhitespaces = getNumWhitespaces (glyphs);
|
||||
|
||||
const auto stretchableWhitespaces = [&]() -> Range<int64>
|
||||
{
|
||||
if (! justification.testFlags (Justification::horizontallyJustified) || tooLong)
|
||||
return {};
|
||||
|
||||
return { numWhitespaces.leading, (int64) glyphs.size() - numWhitespaces.trailing };
|
||||
}();
|
||||
|
||||
const auto extraWhitespaceAdvance = [&]
|
||||
{
|
||||
if (! justification.testFlags (Justification::horizontallyJustified) || tooLong)
|
||||
return 0.0f;
|
||||
|
||||
const auto numWhitespacesBetweenWords = numWhitespaces.total
|
||||
- numWhitespaces.leading
|
||||
- numWhitespaces.trailing;
|
||||
|
||||
return numWhitespacesBetweenWords > 0 ? (maxWidth - effectiveLineLength) / (float) numWhitespacesBetweenWords
|
||||
: 0.0f;
|
||||
}();
|
||||
|
||||
return { mainAxisLineOffset, extraWhitespaceAdvance, stretchableWhitespaces };
|
||||
}
|
||||
|
||||
struct LineInfo
|
||||
{
|
||||
float lineHeight{}, maxAscent{};
|
||||
MainAxisLineAlignment mainAxisLineAlignment;
|
||||
};
|
||||
|
||||
static float getCrossAxisStartingAnchor (Justification justification,
|
||||
Span<const LineInfo> lineInfos,
|
||||
std::optional<float> height,
|
||||
float leadingInHeight)
|
||||
{
|
||||
if (lineInfos.empty())
|
||||
return 0.0f;
|
||||
|
||||
const auto minimumTop = lineInfos.front().maxAscent + lineInfos.front().lineHeight * leadingInHeight;
|
||||
|
||||
if (! height.has_value())
|
||||
return minimumTop;
|
||||
|
||||
const auto textHeight = std::accumulate (lineInfos.begin(),
|
||||
lineInfos.end(),
|
||||
0.0f,
|
||||
[] (auto acc, const auto info) { return acc + info.lineHeight; });
|
||||
|
||||
if (justification.testFlags (Justification::verticallyCentred))
|
||||
return (*height - textHeight) / 2.0f + lineInfos.front().maxAscent;
|
||||
|
||||
if (justification.testFlags (Justification::bottom))
|
||||
{
|
||||
const auto bottomLeading = 0.5f * lineInfos.back().lineHeight * leadingInHeight;
|
||||
return *height - textHeight - bottomLeading + lineInfos.front().maxAscent;
|
||||
}
|
||||
|
||||
return minimumTop;
|
||||
}
|
||||
|
||||
JustifiedText::JustifiedText (const SimpleShapedText& t, const ShapedTextOptions& options)
|
||||
: shapedText (t)
|
||||
{
|
||||
const auto leading = options.getLeading() - 1.0f;
|
||||
|
||||
std::vector<LineInfo> lineInfos;
|
||||
|
||||
for (const auto [range, lineNumber] : shapedText.getLineNumbers())
|
||||
{
|
||||
// This is guaranteed by the RangedValues implementation. You can't assign a value to an
|
||||
// empty range.
|
||||
jassert (! range.isEmpty());
|
||||
|
||||
const auto fonts = shapedText.getResolvedFonts().getIntersectionsWith (range);
|
||||
|
||||
const auto lineHeight = std::accumulate (fonts.begin(),
|
||||
fonts.end(),
|
||||
0.0f,
|
||||
[] (auto acc, const auto& rangedFont)
|
||||
{ return std::max (acc, rangedFont.value.getHeight()); });
|
||||
|
||||
const auto maxAscent = std::accumulate (fonts.begin(),
|
||||
fonts.end(),
|
||||
0.0f,
|
||||
[] (auto acc, const auto& rangedFont)
|
||||
{ return std::max (acc, rangedFont.value.getAscent()); });
|
||||
|
||||
const auto glyphs = shapedText.getGlyphs (range);
|
||||
const auto lineLength = getMainAxisLineLength (glyphs);
|
||||
|
||||
auto m = [&]
|
||||
{
|
||||
if (! options.getMaxWidth().has_value())
|
||||
return MainAxisLineAlignment{};
|
||||
|
||||
return getMainAxisLineAlignment (options.getJustification(),
|
||||
glyphs,
|
||||
lineLength,
|
||||
*options.getMaxWidth(),
|
||||
options.getTrailingWhitespacesShouldFit());
|
||||
}();
|
||||
|
||||
const auto containsHardBreak = shapedText.getCodepoint (range.getEnd() - 1) == 0xa
|
||||
|| shapedText.getCodepoint (range.getStart()) == 0xa;
|
||||
|
||||
if (containsHardBreak || lineNumber == shapedText.getLineNumbers().back().value)
|
||||
{
|
||||
m.extraWhitespaceAdvance = {};
|
||||
m.stretchableWhitespaces = {};
|
||||
}
|
||||
|
||||
lineInfos.push_back ({ lineHeight, maxAscent, std::move (m) });
|
||||
minimumRequiredWidthsForLine.push_back (options.getTrailingWhitespacesShouldFit() ? lineLength.total
|
||||
: lineLength.withoutTrailingWhitespaces);
|
||||
}
|
||||
|
||||
auto y = options.isBaselineAtZero() ? 0.0f
|
||||
: getCrossAxisStartingAnchor (options.getJustification(),
|
||||
lineInfos,
|
||||
options.getHeight(),
|
||||
leading);
|
||||
|
||||
for (const auto [lineIndex, lineInfo] : enumerate (lineInfos))
|
||||
{
|
||||
const auto range = shapedText.getLineNumbers().getItem ((size_t) lineIndex).range;
|
||||
|
||||
lineAnchors.set<detail::MergeEqualItems::no> (range,
|
||||
{ lineInfo.mainAxisLineAlignment.anchor, y });
|
||||
|
||||
whitespaceStretch.set (range, 0.0f);
|
||||
const auto stretchRange = lineInfo.mainAxisLineAlignment.stretchableWhitespaces + range.getStart();
|
||||
|
||||
whitespaceStretch.set (stretchRange,
|
||||
lineInfo.mainAxisLineAlignment.extraWhitespaceAdvance);
|
||||
|
||||
const auto maxDescent = lineInfo.lineHeight - lineInfo.maxAscent;
|
||||
const auto nextLineMaxAscent = lineIndex < (int) lineInfos.size() - 1 ? lineInfos[(size_t) lineIndex + 1].maxAscent : 0.0f;
|
||||
|
||||
y += (1.0f + leading) * (maxDescent + nextLineMaxAscent) + options.getAdditiveLineSpacing();
|
||||
}
|
||||
|
||||
rangesToDraw.set ({ 0, (int64) shapedText.getGlyphs().size() }, DrawType::normal);
|
||||
|
||||
//==============================================================================
|
||||
// Everything above this line should work well given none of the lines were too
|
||||
// long. When Options::getMaxNumLines() == 0 this is guaranteed by SimpleShapedText.
|
||||
// The remaining logic below is for supporting
|
||||
// GlyphArrangement::addFittedText() when the maximum number of lines is
|
||||
// constrained.
|
||||
if (lineAnchors.isEmpty())
|
||||
return;
|
||||
|
||||
const auto lastLineAlignment = lineAnchors.back();
|
||||
const auto lastLineGlyphRange = lastLineAlignment.range;
|
||||
const auto lastLineGlyphs = shapedText.getGlyphs (lastLineGlyphRange);
|
||||
const auto lastLineLengths = getMainAxisLineLength (lastLineGlyphs);
|
||||
|
||||
const auto effectiveLength = options.getTrailingWhitespacesShouldFit() ? lastLineLengths.total
|
||||
: lastLineLengths.withoutTrailingWhitespaces;
|
||||
|
||||
if (! options.getMaxWidth().has_value()
|
||||
|| effectiveLength <= *options.getMaxWidth() + maxWidthTolerance)
|
||||
return;
|
||||
|
||||
const auto cutoffAtFront = lastLineAlignment.value.getX() < 0.0f - maxWidthTolerance;
|
||||
|
||||
const auto getLastLineVisibleRange = [&] (float ellipsisLength)
|
||||
{
|
||||
const auto r = [&]() -> Range<int64>
|
||||
{
|
||||
if (cutoffAtFront)
|
||||
{
|
||||
auto length = lastLineLengths.total;
|
||||
|
||||
for (auto it = lastLineGlyphs.begin(); it < lastLineGlyphs.end(); ++it)
|
||||
{
|
||||
length -= it->advance.getX();
|
||||
|
||||
if (! options.getMaxWidth().has_value()
|
||||
|| *options.getMaxWidth() >= ellipsisLength + length)
|
||||
{
|
||||
return { (int64) std::distance (lastLineGlyphs.begin(), it) + 1,
|
||||
(int64) lastLineGlyphs.size() };
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
auto length = lastLineLengths.total;
|
||||
|
||||
for (auto it = lastLineGlyphs.end() - 1; it >= lastLineGlyphs.begin(); --it)
|
||||
{
|
||||
length -= it->advance.getX();
|
||||
|
||||
if (! options.getMaxWidth().has_value()
|
||||
|| *options.getMaxWidth() >= ellipsisLength + length)
|
||||
{
|
||||
return { 0, (int64) std::distance (lastLineGlyphs.begin(), it) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {};
|
||||
}();
|
||||
|
||||
return r.movedToStartAt (r.getStart() + lastLineGlyphRange.getStart());
|
||||
};
|
||||
|
||||
const auto lastLineVisibleRangeWithoutEllipsis = getLastLineVisibleRange (0.0f);
|
||||
|
||||
const auto eraseLastLineFromRangesToDraw = [&]
|
||||
{
|
||||
rangesToDraw.eraseFrom (lastLineGlyphRange.getStart());
|
||||
};
|
||||
|
||||
eraseLastLineFromRangesToDraw();
|
||||
rangesToDraw.set (lastLineVisibleRangeWithoutEllipsis, DrawType::normal);
|
||||
|
||||
if (options.getEllipsis().isEmpty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
// More logic supporting using ellipses
|
||||
const auto fontForEllipsis = [&]
|
||||
{
|
||||
const auto lastLineFonts = shapedText.getResolvedFonts().getIntersectionsWith (lastLineGlyphRange);
|
||||
|
||||
if (cutoffAtFront)
|
||||
return lastLineFonts.front().value;
|
||||
|
||||
return lastLineFonts.back().value;
|
||||
}();
|
||||
|
||||
ellipsis.emplace (&options.getEllipsis(), ShapedTextOptions {}.withFont (fontForEllipsis));
|
||||
|
||||
const auto lastLineVisibleRange = getLastLineVisibleRange (getMainAxisLineLength (ellipsis->getGlyphs(),
|
||||
options.getTrailingWhitespacesShouldFit()));
|
||||
|
||||
eraseLastLineFromRangesToDraw();
|
||||
rangesToDraw.set (lastLineVisibleRange, DrawType::normal);
|
||||
|
||||
if (cutoffAtFront)
|
||||
rangesToDraw.set (Range<int64>::withStartAndLength (lastLineVisibleRange.getStart() - 1, 1), DrawType::ellipsis);
|
||||
else
|
||||
rangesToDraw.set (Range<int64>::withStartAndLength (lastLineVisibleRange.getEnd(), 1), DrawType::ellipsis);
|
||||
|
||||
const auto lineWithEllipsisGlyphs = [&]
|
||||
{
|
||||
std::vector<ShapedGlyph> result;
|
||||
|
||||
const auto pushEllipsisGlyphs = [&]
|
||||
{
|
||||
const auto& range = ellipsis->getGlyphs();
|
||||
result.insert (result.begin(), range.begin(), range.end());
|
||||
};
|
||||
|
||||
if (cutoffAtFront)
|
||||
pushEllipsisGlyphs();
|
||||
|
||||
|
||||
const auto& range = shapedText.getGlyphs (lastLineVisibleRange);
|
||||
result.insert (result.end(), range.begin(), range.end());
|
||||
|
||||
if (! cutoffAtFront)
|
||||
pushEllipsisGlyphs();
|
||||
|
||||
return result;
|
||||
}();
|
||||
|
||||
const auto realign = [&]
|
||||
{
|
||||
if (! options.getMaxWidth().has_value())
|
||||
return MainAxisLineAlignment{};
|
||||
|
||||
return getMainAxisLineAlignment (options.getJustification(),
|
||||
lineWithEllipsisGlyphs,
|
||||
getMainAxisLineLength (lineWithEllipsisGlyphs),
|
||||
*options.getMaxWidth(),
|
||||
options.getTrailingWhitespacesShouldFit());
|
||||
}();
|
||||
|
||||
lastLineAlignment.value.setX (realign.anchor);
|
||||
whitespaceStretch.set (lastLineGlyphRange, 0.0f);
|
||||
whitespaceStretch.set (realign.stretchableWhitespaces + lastLineVisibleRange.getStart(),
|
||||
realign.extraWhitespaceAdvance);
|
||||
}
|
||||
|
||||
template <typename Callable>
|
||||
void JustifiedText::access (Callable&& callback) const
|
||||
{
|
||||
accessTogetherWith (std::forward<Callable> (callback));
|
||||
}
|
||||
|
||||
void drawJustifiedText (const JustifiedText& text, const Graphics& g, AffineTransform transform)
|
||||
{
|
||||
auto& context = g.getInternalContext();
|
||||
context.saveState();
|
||||
const ScopeGuard restoreGraphicsContext { [&context] { context.restoreState(); } };
|
||||
|
||||
text.access ([&] (auto glyphs, auto positions, auto font, auto, auto)
|
||||
{
|
||||
if (context.getFont() != font)
|
||||
context.setFont (font);
|
||||
|
||||
std::vector<uint16_t> glyphIds (glyphs.size());
|
||||
|
||||
std::transform (glyphs.begin(),
|
||||
glyphs.end(),
|
||||
glyphIds.begin(),
|
||||
[] (auto& glyph) { return (uint16_t) glyph.glyphId; });
|
||||
|
||||
context.drawGlyphs (glyphIds, positions, transform);
|
||||
});
|
||||
}
|
||||
|
||||
} // namespace juce::detail
|
||||
Loading…
Add table
Add a link
Reference in a new issue