miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to 14.0-beta1

Browse Source
This commit is contained in:
dP
2024-02-04 02:18:17 +05:30
parent 79037e2c65
commit 33ef333b57
1325 changed files with 138461 additions and 70983 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gfx_layout.cpp
+146 -663
View File
@@ -8,17 +8,18 @@
/** @file gfx_layout.cpp Handling of laying out text. */
#include "stdafx.h"
#include "core/math_func.hpp"
#include "gfx_layout.h"
#include "string_func.h"
#include "strings_func.h"
#include "zoom_func.h"
#include "debug.h"
#include "table/control_codes.h"
#ifdef WITH_ICU_LX
#include <unicode/ustring.h>
#endif /* WITH_ICU_LX */
#include "gfx_layout_fallback.h"
#if defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)
#include "gfx_layout_icu.h"
#endif /* WITH_ICU_I18N && WITH_HARFBUZZ */
#ifdef WITH_UNISCRIBE
#include "os/windows/string_uniscribe.h"
@@ -49,553 +50,6 @@ Font::Font(FontSize size, TextColour colour) :
assert(size < FS_END);
}
#ifdef WITH_ICU_LX
/* Implementation details of LEFontInstance */
le_int32 Font::getUnitsPerEM() const
{
return this->fc->GetUnitsPerEM();
}
le_int32 Font::getAscent() const
{
return this->fc->GetAscender();
}
le_int32 Font::getDescent() const
{
return -this->fc->GetDescender();
}
le_int32 Font::getLeading() const
{
return this->fc->GetHeight();
}
float Font::getXPixelsPerEm() const
{
return (float)this->fc->GetHeight();
}
float Font::getYPixelsPerEm() const
{
return (float)this->fc->GetHeight();
}
float Font::getScaleFactorX() const
{
return 1.0f;
}
float Font::getScaleFactorY() const
{
return 1.0f;
}
const void *Font::getFontTable(LETag tableTag) const
{
size_t length;
return this->getFontTable(tableTag, length);
}
const void *Font::getFontTable(LETag tableTag, size_t &length) const
{
return this->fc->GetFontTable(tableTag, length);
}
LEGlyphID Font::mapCharToGlyph(LEUnicode32 ch) const
{
if (IsTextDirectionChar(ch)) return 0;
return this->fc->MapCharToGlyph(ch);
}
void Font::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
{
advance.fX = glyph == 0xFFFF ? 0 : this->fc->GetGlyphWidth(glyph);
advance.fY = 0;
}
le_bool Font::getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const
{
return false;
}
/**
* Wrapper for doing layouts with ICU.
*/
class ICUParagraphLayout : public ParagraphLayouter {
icu::ParagraphLayout *p; ///< The actual ICU paragraph layout.
public:
/** Visual run contains data about the bit of text with the same font. */
class ICUVisualRun : public ParagraphLayouter::VisualRun {
const icu::ParagraphLayout::VisualRun *vr; ///< The actual ICU vr.
public:
ICUVisualRun(const icu::ParagraphLayout::VisualRun *vr) : vr(vr) { }
const Font *GetFont() const override { return (const Font*)vr->getFont(); }
int GetGlyphCount() const override { return vr->getGlyphCount(); }
const GlyphID *GetGlyphs() const override { return vr->getGlyphs(); }
const float *GetPositions() const override { return vr->getPositions(); }
int GetLeading() const override { return vr->getLeading(); }
const int *GetGlyphToCharMap() const override { return vr->getGlyphToCharMap(); }
};
/** A single line worth of VisualRuns. */
class ICULine : public std::vector<ICUVisualRun>, public ParagraphLayouter::Line {
icu::ParagraphLayout::Line *l; ///< The actual ICU line.
public:
ICULine(icu::ParagraphLayout::Line *l) : l(l)
{
for (int i = 0; i < l->countRuns(); i++) {
this->emplace_back(l->getVisualRun(i));
}
}
~ICULine() override { delete l; }
int GetLeading() const override { return l->getLeading(); }
int GetWidth() const override { return l->getWidth(); }
int CountRuns() const override { return l->countRuns(); }
const ParagraphLayouter::VisualRun &GetVisualRun(int run) const override { return this->at(run); }
int GetInternalCharLength(WChar c) const override
{
/* ICU uses UTF-16 internally which means we need to account for surrogate pairs. */
return Utf8CharLen(c) < 4 ? 1 : 2;
}
};
ICUParagraphLayout(icu::ParagraphLayout *p) : p(p) { }
~ICUParagraphLayout() override { delete p; }
void Reflow() override { p->reflow(); }
std::unique_ptr<const Line> NextLine(int max_width) override
{
icu::ParagraphLayout::Line *l = p->nextLine(max_width);
return std::unique_ptr<const Line>(l == nullptr ? nullptr : new ICULine(l));
}
};
/**
* Helper class to construct a new #ICUParagraphLayout.
*/
class ICUParagraphLayoutFactory {
public:
/** Helper for GetLayouter, to get the right type. */
typedef UChar CharType;
/** Helper for GetLayouter, to get whether the layouter supports RTL. */
static const bool SUPPORTS_RTL = true;
static ParagraphLayouter *GetParagraphLayout(UChar *buff, UChar *buff_end, FontMap &fontMapping)
{
int32 length = buff_end - buff;
if (length == 0) {
/* ICU's ParagraphLayout cannot handle empty strings, so fake one. */
buff[0] = ' ';
length = 1;
fontMapping.back().first++;
}
/* Fill ICU's FontRuns with the right data. */
icu::FontRuns runs(fontMapping.size());
for (auto &pair : fontMapping) {
runs.add(pair.second, pair.first);
}
LEErrorCode status = LE_NO_ERROR;
/* ParagraphLayout does not copy "buff", so it must stay valid.
* "runs" is copied according to the ICU source, but the documentation does not specify anything, so this might break somewhen. */
icu::ParagraphLayout *p = new icu::ParagraphLayout(buff, length, &runs, nullptr, nullptr, nullptr, _current_text_dir == TD_RTL ? 1 : 0, false, status);
if (status != LE_NO_ERROR) {
delete p;
return nullptr;
}
return new ICUParagraphLayout(p);
}
static size_t AppendToBuffer(UChar *buff, const UChar *buffer_last, WChar c)
{
/* Transform from UTF-32 to internal ICU format of UTF-16. */
int32 length = 0;
UErrorCode err = U_ZERO_ERROR;
u_strFromUTF32(buff, buffer_last - buff, &length, (UChar32*)&c, 1, &err);
return length;
}
};
#endif /* WITH_ICU_LX */
/*** Paragraph layout ***/
/**
* Class handling the splitting of a paragraph of text into lines and
* visual runs.
*
* One constructs this class with the text that needs to be split into
* lines. Then nextLine is called with the maximum width until nullptr is
* returned. Each nextLine call creates VisualRuns which contain the
* length of text that are to be drawn with the same font. In other
* words, the result of this class is a list of sub strings with their
* font. The sub strings are then already fully laid out, and only
* need actual drawing.
*
* The positions in a visual run are sequential pairs of X,Y of the
* begin of each of the glyphs plus an extra pair to mark the end.
*
* @note This variant does not handle left-to-right properly. This
* is supported in the one ParagraphLayout coming from ICU.
*/
class FallbackParagraphLayout : public ParagraphLayouter {
public:
/** Visual run contains data about the bit of text with the same font. */
class FallbackVisualRun : public ParagraphLayouter::VisualRun {
Font *font; ///< The font used to layout these.
GlyphID *glyphs; ///< The glyphs we're drawing.
float *positions; ///< The positions of the glyphs.
int *glyph_to_char; ///< The char index of the glyphs.
int glyph_count; ///< The number of glyphs.
public:
FallbackVisualRun(Font *font, const WChar *chars, int glyph_count, int x);
FallbackVisualRun(FallbackVisualRun &&other) noexcept;
~FallbackVisualRun() override;
const Font *GetFont() const override;
int GetGlyphCount() const override;
const GlyphID *GetGlyphs() const override;
const float *GetPositions() const override;
int GetLeading() const override;
const int *GetGlyphToCharMap() const override;
};
/** A single line worth of VisualRuns. */
class FallbackLine : public std::vector<FallbackVisualRun>, public ParagraphLayouter::Line {
public:
int GetLeading() const override;
int GetWidth() const override;
int CountRuns() const override;
const ParagraphLayouter::VisualRun &GetVisualRun(int run) const override;
int GetInternalCharLength(WChar c) const override { return 1; }
};
const WChar *buffer_begin; ///< Begin of the buffer.
const WChar *buffer; ///< The current location in the buffer.
FontMap &runs; ///< The fonts we have to use for this paragraph.
FallbackParagraphLayout(WChar *buffer, int length, FontMap &runs);
void Reflow() override;
std::unique_ptr<const Line> NextLine(int max_width) override;
};
/**
* Helper class to construct a new #FallbackParagraphLayout.
*/
class FallbackParagraphLayoutFactory {
public:
/** Helper for GetLayouter, to get the right type. */
typedef WChar CharType;
/** Helper for GetLayouter, to get whether the layouter supports RTL. */
static const bool SUPPORTS_RTL = false;
/**
* Get the actual ParagraphLayout for the given buffer.
* @param buff The begin of the buffer.
* @param buff_end The location after the last element in the buffer.
* @param fontMapping THe mapping of the fonts.
* @return The ParagraphLayout instance.
*/
static ParagraphLayouter *GetParagraphLayout(WChar *buff, WChar *buff_end, FontMap &fontMapping)
{
return new FallbackParagraphLayout(buff, buff_end - buff, fontMapping);
}
/**
* Append a wide character to the internal buffer.
* @param buff The buffer to append to.
* @param buffer_last The end of the buffer.
* @param c The character to add.
* @return The number of buffer spaces that were used.
*/
static size_t AppendToBuffer(WChar *buff, const WChar *buffer_last, WChar c)
{
*buff = c;
return 1;
}
};
/**
* Create the visual run.
* @param font The font to use for this run.
* @param chars The characters to use for this run.
* @param char_count The number of characters in this run.
* @param x The initial x position for this run.
*/
FallbackParagraphLayout::FallbackVisualRun::FallbackVisualRun(Font *font, const WChar *chars, int char_count, int x) :
font(font), glyph_count(char_count)
{
const bool isbuiltin = font->fc->IsBuiltInFont();
this->glyphs = MallocT<GlyphID>(this->glyph_count);
this->glyph_to_char = MallocT<int>(this->glyph_count);
/* Positions contains the location of the begin of each of the glyphs, and the end of the last one. */
this->positions = MallocT<float>(this->glyph_count * 2 + 2);
this->positions[0] = x;
for (int i = 0; i < this->glyph_count; i++) {
this->glyphs[i] = font->fc->MapCharToGlyph(chars[i]);
if (isbuiltin) {
this->positions[2 * i + 1] = font->fc->GetAscender(); // Apply sprite font's ascender.
} else if (chars[i] >= SCC_SPRITE_START && chars[i] <= SCC_SPRITE_END) {
this->positions[2 * i + 1] = (font->fc->GetHeight() - ScaleSpriteTrad(FontCache::GetDefaultFontHeight(font->fc->GetSize()))) / 2; // Align sprite font to centre
} else {
this->positions[2 * i + 1] = 0; // No ascender adjustment.
}
this->positions[2 * i + 2] = this->positions[2 * i] + font->fc->GetGlyphWidth(this->glyphs[i]);
this->glyph_to_char[i] = i;
}
}
/** Move constructor for visual runs.*/
FallbackParagraphLayout::FallbackVisualRun::FallbackVisualRun(FallbackVisualRun &&other) noexcept : font(other.font), glyph_count(other.glyph_count)
{
this->positions = other.positions;
this->glyph_to_char = other.glyph_to_char;
this->glyphs = other.glyphs;
other.positions = nullptr;
other.glyph_to_char = nullptr;
other.glyphs = nullptr;
}
/** Free all data. */
FallbackParagraphLayout::FallbackVisualRun::~FallbackVisualRun()
{
free(this->positions);
free(this->glyph_to_char);
free(this->glyphs);
}
/**
* Get the font associated with this run.
* @return The font.
*/
const Font *FallbackParagraphLayout::FallbackVisualRun::GetFont() const
{
return this->font;
}
/**
* Get the number of glyphs in this run.
* @return The number of glyphs.
*/
int FallbackParagraphLayout::FallbackVisualRun::GetGlyphCount() const
{
return this->glyph_count;
}
/**
* Get the glyphs of this run.
* @return The glyphs.
*/
const GlyphID *FallbackParagraphLayout::FallbackVisualRun::GetGlyphs() const
{
return this->glyphs;
}
/**
* Get the positions of this run.
* @return The positions.
*/
const float *FallbackParagraphLayout::FallbackVisualRun::GetPositions() const
{
return this->positions;
}
/**
* Get the glyph-to-character map for this visual run.
* @return The glyph-to-character map.
*/
const int *FallbackParagraphLayout::FallbackVisualRun::GetGlyphToCharMap() const
{
return this->glyph_to_char;
}
/**
* Get the height of this font.
* @return The height of the font.
*/
int FallbackParagraphLayout::FallbackVisualRun::GetLeading() const
{
return this->GetFont()->fc->GetHeight();
}
/**
* Get the height of the line.
* @return The maximum height of the line.
*/
int FallbackParagraphLayout::FallbackLine::GetLeading() const
{
int leading = 0;
for (const auto &run : *this) {
leading = std::max(leading, run.GetLeading());
}
return leading;
}
/**
* Get the width of this line.
* @return The width of the line.
*/
int FallbackParagraphLayout::FallbackLine::GetWidth() const
{
if (this->size() == 0) return 0;
/*
* The last X position of a run contains is the end of that run.
* Since there is no left-to-right support, taking this value of
* the last run gives us the end of the line and thus the width.
*/
const auto &run = this->GetVisualRun(this->CountRuns() - 1);
return (int)run.GetPositions()[run.GetGlyphCount() * 2];
}
/**
* Get the number of runs in this line.
* @return The number of runs.
*/
int FallbackParagraphLayout::FallbackLine::CountRuns() const
{
return (uint)this->size();
}
/**
* Get a specific visual run.
* @return The visual run.
*/
const ParagraphLayouter::VisualRun &FallbackParagraphLayout::FallbackLine::GetVisualRun(int run) const
{
return this->at(run);
}
/**
* Create a new paragraph layouter.
* @param buffer The characters of the paragraph.
* @param length The length of the paragraph.
* @param runs The font mapping of this paragraph.
*/
FallbackParagraphLayout::FallbackParagraphLayout(WChar *buffer, int length, FontMap &runs) : buffer_begin(buffer), buffer(buffer), runs(runs)
{
assert(runs.End()[-1].first == length);
}
/**
* Reset the position to the start of the paragraph.
*/
void FallbackParagraphLayout::Reflow()
{
this->buffer = this->buffer_begin;
}
/**
* Construct a new line with a maximum width.
* @param max_width The maximum width of the string.
* @return A Line, or nullptr when at the end of the paragraph.
*/
std::unique_ptr<const ParagraphLayouter::Line> FallbackParagraphLayout::NextLine(int max_width)
{
/* Simple idea:
* - split a line at a newline character, or at a space where we can break a line.
* - split for a visual run whenever a new line happens, or the font changes.
*/
if (this->buffer == nullptr) return nullptr;
std::unique_ptr<FallbackLine> l(new FallbackLine());
if (*this->buffer == '\0') {
/* Only a newline. */
this->buffer = nullptr;
l->emplace_back(this->runs.front().second, this->buffer, 0, 0);
return l;
}
int offset = this->buffer - this->buffer_begin;
FontMap::iterator iter = this->runs.data();
while (iter->first <= offset) {
iter++;
assert(iter != this->runs.End());
}
const FontCache *fc = iter->second->fc;
const WChar *next_run = this->buffer_begin + iter->first;
const WChar *begin = this->buffer;
const WChar *last_space = nullptr;
const WChar *last_char;
int width = 0;
for (;;) {
WChar c = *this->buffer;
last_char = this->buffer;
if (c == '\0') {
this->buffer = nullptr;
break;
}
if (this->buffer == next_run) {
int w = l->GetWidth();
l->emplace_back(iter->second, begin, this->buffer - begin, w);
iter++;
assert(iter != this->runs.End());
next_run = this->buffer_begin + iter->first;
begin = this->buffer;
}
if (IsWhitespace(c)) last_space = this->buffer;
if (IsPrintable(c) && !IsTextDirectionChar(c)) {
int char_width = GetCharacterWidth(fc->GetSize(), c);
width += char_width;
if (width > max_width) {
/* The string is longer than maximum width so we need to decide
* what to do with it. */
if (width == char_width) {
/* The character is wider than allowed width; don't know
* what to do with this case... bail out! */
this->buffer = nullptr;
return l;
}
if (last_space == nullptr) {
/* No space has been found. Just terminate at our current
* location. This usually happens for languages that do not
* require spaces in strings, like Chinese, Japanese and
* Korean. For other languages terminating mid-word might
* not be the best, but terminating the whole string instead
* of continuing the word at the next line is worse. */
last_char = this->buffer;
} else {
/* A space is found; perfect place to terminate */
this->buffer = last_space + 1;
last_char = last_space;
}
break;
}
}
this->buffer++;
}
if (l->size() == 0 || last_char - begin > 0) {
int w = l->GetWidth();
l->emplace_back(iter->second, begin, last_char - begin, w);
}
return l;
}
/**
* Helper for getting a ParagraphLayouter of the given type.
*
@@ -606,12 +60,12 @@ std::unique_ptr<const ParagraphLayouter::Line> FallbackParagraphLayout::NextLine
* @tparam T The type of layouter we want.
*/
template <typename T>
static inline void GetLayouter(Layouter::LineCacheItem &line, const char *&str, FontState &state)
static inline void GetLayouter(Layouter::LineCacheItem &line, std::string_view str, FontState &state)
{
if (line.buffer != nullptr) free(line.buffer);
typename T::CharType *buff_begin = MallocT<typename T::CharType>(DRAW_STRING_BUFFER);
const typename T::CharType *buffer_last = buff_begin + DRAW_STRING_BUFFER;
typename T::CharType *buff_begin = MallocT<typename T::CharType>(str.size() + 1);
const typename T::CharType *buffer_last = buff_begin + str.size() + 1;
typename T::CharType *buff = buff_begin;
FontMap &fontMapping = line.runs;
Font *f = Layouter::GetFont(state.fontsize, state.cur_colour);
@@ -619,15 +73,18 @@ static inline void GetLayouter(Layouter::LineCacheItem &line, const char *&str,
line.buffer = buff_begin;
fontMapping.clear();
auto cur = str.begin();
/*
* Go through the whole string while adding Font instances to the font map
* whenever the font changes, and convert the wide characters into a format
* usable by ParagraphLayout.
*/
for (; buff < buffer_last;) {
WChar c = Utf8Consume(const_cast<const char **>(&str));
for (; buff < buffer_last && cur != str.end();) {
char32_t c = Utf8Consume(cur);
if (c == '\0' || c == '\n') {
break;
/* Caller should already have filtered out these characters. */
NOT_REACHED();
} else if (c >= SCC_BLUE && c <= SCC_BLACK) {
state.SetColour((TextColour)(c - SCC_BLUE));
} else if (c == SCC_PUSH_COLOUR) {
@@ -640,15 +97,15 @@ static inline void GetLayouter(Layouter::LineCacheItem &line, const char *&str,
/* Filter out non printable characters */
if (!IsPrintable(c)) continue;
/* Filter out text direction characters that shouldn't be drawn, and
* will not be handled in the fallback non ICU case because they are
* mostly needed for RTL languages which need more ICU support. */
* will not be handled in the fallback case because they are mostly
* needed for RTL languages which need more proper shaping support. */
if (!T::SUPPORTS_RTL && IsTextDirectionChar(c)) continue;
buff += T::AppendToBuffer(buff, buffer_last, c);
continue;
}
if (!fontMapping.Contains(buff - buff_begin)) {
fontMapping.Insert(buff - buff_begin, f);
if (fontMapping.count(buff - buff_begin) == 0) {
fontMapping[buff - buff_begin] = f;
}
f = Layouter::GetFont(state.fontsize, state.cur_colour);
}
@@ -656,8 +113,8 @@ static inline void GetLayouter(Layouter::LineCacheItem &line, const char *&str,
/* Better safe than sorry. */
*buff = '\0';
if (!fontMapping.Contains(buff - buff_begin)) {
fontMapping.Insert(buff - buff_begin, f);
if (fontMapping.count(buff - buff_begin) == 0) {
fontMapping[buff - buff_begin] = f;
}
line.layout = T::GetParagraphLayout(buff_begin, buff, fontMapping);
line.state_after = state;
@@ -670,69 +127,51 @@ static inline void GetLayouter(Layouter::LineCacheItem &line, const char *&str,
* @param colour The colour of the font.
* @param fontsize The size of font to use.
*/
Layouter::Layouter(const char *str, int maxw, TextColour colour, FontSize fontsize) : string(str)
Layouter::Layouter(std::string_view str, int maxw, TextColour colour, FontSize fontsize) : string(str)
{
FontState state(colour, fontsize);
WChar c = 0;
do {
/* Scan string for end of line */
const char *lineend = str;
for (;;) {
size_t len = Utf8Decode(&c, lineend);
if (c == '\0' || c == '\n') break;
lineend += len;
}
while (true) {
auto line_length = str.find_first_of('\n');
auto str_line = str.substr(0, line_length);
LineCacheItem& line = GetCachedParagraphLayout(str, lineend - str, state);
LineCacheItem &line = GetCachedParagraphLayout(str_line, state);
if (line.layout != nullptr) {
/* Line is in cache */
str = lineend + 1;
state = line.state_after;
line.layout->Reflow();
} else {
/* Line is new, layout it */
FontState old_state = state;
#if defined(WITH_ICU_LX) || defined(WITH_UNISCRIBE) || defined(WITH_COCOA)
const char *old_str = str;
#endif
#ifdef WITH_ICU_LX
GetLayouter<ICUParagraphLayoutFactory>(line, str, state);
#if defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)
if (line.layout == nullptr) {
static bool warned = false;
if (!warned) {
Debug(misc, 0, "ICU layouter bailed on the font. Falling back to the fallback layouter");
warned = true;
GetLayouter<ICUParagraphLayoutFactory>(line, str_line, state);
if (line.layout == nullptr) {
state = old_state;
}
state = old_state;
str = old_str;
}
#endif
#ifdef WITH_UNISCRIBE
if (line.layout == nullptr) {
GetLayouter<UniscribeParagraphLayoutFactory>(line, str, state);
GetLayouter<UniscribeParagraphLayoutFactory>(line, str_line, state);
if (line.layout == nullptr) {
state = old_state;
str = old_str;
}
}
#endif
#ifdef WITH_COCOA
if (line.layout == nullptr) {
GetLayouter<CoreTextParagraphLayoutFactory>(line, str, state);
GetLayouter<CoreTextParagraphLayoutFactory>(line, str_line, state);
if (line.layout == nullptr) {
state = old_state;
str = old_str;
}
}
#endif
if (line.layout == nullptr) {
GetLayouter<FallbackParagraphLayoutFactory>(line, str, state);
GetLayouter<FallbackParagraphLayoutFactory>(line, str_line, state);
}
}
@@ -742,7 +181,15 @@ Layouter::Layouter(const char *str, int maxw, TextColour colour, FontSize fontsi
if (l == nullptr) break;
this->push_back(std::move(l));
}
} while (c != '\0');
/* Break out if this was the last line. */
if (line_length == std::string_view::npos) {
break;
}
/* Go to the next line. */
str.remove_prefix(line_length + 1);
}
}
/**
@@ -760,88 +207,119 @@ Dimension Layouter::GetBounds()
}
/**
* Get the position of a character in the layout.
* @param ch Character to get the position of.
* @return Upper left corner of the character relative to the start of the string.
* @note Will only work right for single-line strings.
* Test whether a character is a non-printable formatting code
*/
Point Layouter::GetCharPosition(const char *ch) const
static bool IsConsumedFormattingCode(char32_t ch)
{
/* Find the code point index which corresponds to the char
* pointer into our UTF-8 source string. */
size_t index = 0;
const char *str = this->string;
while (str < ch) {
WChar c;
size_t len = Utf8Decode(&c, str);
if (c == '\0' || c == '\n') break;
str += len;
index += this->front()->GetInternalCharLength(c);
}
if (str == ch) {
/* Valid character. */
const auto &line = this->front();
/* Pointer to the end-of-string/line marker? Return total line width. */
if (*ch == '\0' || *ch == '\n') {
Point p = { line->GetWidth(), 0 };
return p;
}
/* Scan all runs until we've found our code point index. */
for (int run_index = 0; run_index < line->CountRuns(); run_index++) {
const ParagraphLayouter::VisualRun &run = line->GetVisualRun(run_index);
for (int i = 0; i < run.GetGlyphCount(); i++) {
/* Matching glyph? Return position. */
if ((size_t)run.GetGlyphToCharMap()[i] == index) {
Point p = { (int)run.GetPositions()[i * 2], (int)run.GetPositions()[i * 2 + 1] };
return p;
}
}
}
}
Point p = { 0, 0 };
return p;
if (ch >= SCC_BLUE && ch <= SCC_BLACK) return true;
if (ch == SCC_PUSH_COLOUR) return true;
if (ch == SCC_POP_COLOUR) return true;
if (ch >= SCC_FIRST_FONT && ch <= SCC_LAST_FONT) return true;
// All other characters defined in Unicode standard are assumed to be non-consumed.
return false;
}
/**
* Get the character that is at a position.
* @param x Position in the string.
* @return Pointer to the character at the position or nullptr if no character is at the position.
* Get the position of a character in the layout.
* @param ch Character to get the position of. Must be an iterator of the string passed to the constructor.
* @return Upper left corner of the character relative to the start of the string.
* @note Will only work right for single-line strings.
*/
const char *Layouter::GetCharAtPosition(int x) const
Point Layouter::GetCharPosition(std::string_view::const_iterator ch) const
{
const auto &line = this->front();
/* Pointer to the end-of-string marker? Return total line width. */
if (ch == this->string.end()) {
Point p = { line->GetWidth(), 0 };
return p;
}
/* Find the code point index which corresponds to the char
* pointer into our UTF-8 source string. */
size_t index = 0;
auto str = this->string.begin();
while (str < ch) {
char32_t c = Utf8Consume(str);
if (!IsConsumedFormattingCode(c)) index += line->GetInternalCharLength(c);
}
/* Initial position, returned if character not found. */
static const std::vector<Point> zero = { {0, 0} };
auto position = zero.begin();
/* We couldn't find the code point index. */
if (str != ch) return *position;
/* Valid character. */
/* Scan all runs until we've found our code point index. */
for (int run_index = 0; run_index < line->CountRuns(); run_index++) {
const ParagraphLayouter::VisualRun &run = line->GetVisualRun(run_index);
const auto &positions = run.GetPositions();
const auto &charmap = run.GetGlyphToCharMap();
/* Run starts after our character, use the last found position. */
if ((size_t)charmap.front() > index) return *position;
position = positions.begin();
for (auto it = charmap.begin(); it != charmap.end(); /* nothing */) {
/* Plain honest-to-$deity match. */
if ((size_t)*it == index) return *position;
++it;
if (it == charmap.end()) break;
/* We just passed our character, it's probably a ligature, use the last found position. */
if ((size_t)*it > index) return *position;
++position;
}
}
/* At the end of the run but still didn't find our character so probably a trailing ligature, use the last found position. */
return *position;
}
/**
* Get the character that is at a pixel position in the first line of the layouted text.
* @param x Position in the string.
* @param line_index Which line of the layout to search
* @return String offset of the position (bytes) or -1 if no character is at the position.
*/
ptrdiff_t Layouter::GetCharAtPosition(int x, size_t line_index) const
{
if (line_index >= this->size()) return -1;
const auto &line = this->at(line_index);
for (int run_index = 0; run_index < line->CountRuns(); run_index++) {
const ParagraphLayouter::VisualRun &run = line->GetVisualRun(run_index);
const auto &glyphs = run.GetGlyphs();
const auto &positions = run.GetPositions();
const auto &charmap = run.GetGlyphToCharMap();
for (int i = 0; i < run.GetGlyphCount(); i++) {
/* Not a valid glyph (empty). */
if (run.GetGlyphs()[i] == 0xFFFF) continue;
if (glyphs[i] == 0xFFFF) continue;
int begin_x = (int)run.GetPositions()[i * 2];
int end_x = (int)run.GetPositions()[i * 2 + 2];
int begin_x = positions[i].x;
int end_x = positions[i + 1].x;
if (IsInsideMM(x, begin_x, end_x)) {
/* Found our glyph, now convert to UTF-8 string index. */
size_t index = run.GetGlyphToCharMap()[i];
size_t index = charmap[i];
size_t cur_idx = 0;
for (const char *str = this->string; *str != '\0'; ) {
if (cur_idx == index) return str;
for (auto str = this->string.begin(); str != this->string.end();) {
if (cur_idx == index) return str - this->string.begin();
WChar c = Utf8Consume(&str);
cur_idx += line->GetInternalCharLength(c);
char32_t c = Utf8Consume(str);
if (!IsConsumedFormattingCode(c)) cur_idx += line->GetInternalCharLength(c);
}
}
}
}
return nullptr;
return -1;
}
/**
@@ -849,12 +327,21 @@ const char *Layouter::GetCharAtPosition(int x) const
*/
Font *Layouter::GetFont(FontSize size, TextColour colour)
{
FontColourMap::iterator it = fonts[size].Find(colour);
if (it != fonts[size].End()) return it->second;
FontColourMap::iterator it = fonts[size].find(colour);
if (it != fonts[size].end()) return it->second.get();
Font *f = new Font(size, colour);
fonts[size].emplace_back(colour, f);
return f;
fonts[size][colour] = std::make_unique<Font>(size, colour);
return fonts[size][colour].get();
}
/**
* Perform initialization of layout engine.
*/
void Layouter::Initialize()
{
#if defined(WITH_ICU_I18N) && defined(WITH_HARFBUZZ)
ICUParagraphLayoutFactory::InitializeLayouter();
#endif /* WITH_ICU_I18N && WITH_HARFBUZZ */
}
/**
@@ -863,9 +350,6 @@ Font *Layouter::GetFont(FontSize size, TextColour colour)
*/
void Layouter::ResetFontCache(FontSize size)
{
for (auto &pair : fonts[size]) {
delete pair.second;
}
fonts[size].clear();
/* We must reset the linecache since it references the just freed fonts */
@@ -883,18 +367,17 @@ void Layouter::ResetFontCache(FontSize size)
* Get reference to cache item.
* If the item does not exist yet, it is default constructed.
* @param str Source string of the line (including colour and font size codes).
* @param len Length of \a str in bytes (no termination).
* @param state State of the font at the beginning of the line.
* @return Reference to cache item.
*/
Layouter::LineCacheItem &Layouter::GetCachedParagraphLayout(const char *str, size_t len, const FontState &state)
Layouter::LineCacheItem &Layouter::GetCachedParagraphLayout(std::string_view str, const FontState &state)
{
if (linecache == nullptr) {
/* Create linecache on first access to avoid trouble with initialisation order of static variables. */
linecache = new LineCache();
}
if (auto match = linecache->find(LineCacheQuery{state, std::string_view{str, len}});
if (auto match = linecache->find(LineCacheQuery{state, str});
match != linecache->end()) {
return match->second;
}
@@ -902,7 +385,7 @@ Layouter::LineCacheItem &Layouter::GetCachedParagraphLayout(const char *str, siz
/* Create missing entry */
LineCacheKey key;
key.state_before = state;
key.str.assign(str, len);
key.str.assign(str);
return (*linecache)[key];
}