| // Copyright 2019 Google LLC. |
| #include "modules/skparagraph/src/Run.h" |
| #include <unicode/brkiter.h> |
| #include "include/core/SkFontMetrics.h" |
| |
| namespace skia { |
| namespace textlayout { |
| |
| Run::Run(SkSpan<const char> text, |
| const SkShaper::RunHandler::RunInfo& info, |
| SkScalar lineHeight, |
| size_t index, |
| SkScalar offsetX) { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| fFont = info.fFont; |
| fHeightMultiplier = lineHeight; |
| fBidiLevel = info.fBidiLevel; |
| fAdvance = info.fAdvance; |
| fText = SkSpan<const char>(text.begin() + info.utf8Range.begin(), info.utf8Range.size()); |
| |
| fIndex = index; |
| fUtf8Range = info.utf8Range; |
| fOffset = SkVector::Make(offsetX, 0); |
| fGlyphs.push_back_n(info.glyphCount); |
| fPositions.push_back_n(info.glyphCount + 1); |
| fOffsets.push_back_n(info.glyphCount + 1, SkScalar(0)); |
| fClusterIndexes.push_back_n(info.glyphCount + 1); |
| info.fFont.getMetrics(&fFontMetrics); |
| fSpaced = false; |
| // To make edge cases easier: |
| fPositions[info.glyphCount] = fOffset + fAdvance; |
| fClusterIndexes[info.glyphCount] = info.utf8Range.end(); |
| } |
| |
| SkShaper::RunHandler::Buffer Run::newRunBuffer() { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| return {fGlyphs.data(), fPositions.data(), nullptr, fClusterIndexes.data(), fOffset}; |
| } |
| |
| SkScalar Run::calculateWidth(size_t start, size_t end, bool clip) const { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| SkASSERT(start <= end); |
| // clip |= end == size(); // Clip at the end of the run? |
| SkScalar offset = 0; |
| if (fSpaced && end > start) { |
| offset = fOffsets[clip ? end - 1 : end] - fOffsets[start]; |
| } |
| return fPositions[end].fX - fPositions[start].fX + offset; |
| } |
| |
| void Run::copyTo(SkTextBlobBuilder& builder, size_t pos, size_t size, SkVector offset) const { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| SkASSERT(pos + size <= this->size()); |
| const auto& blobBuffer = builder.allocRunPos(fFont, SkToInt(size)); |
| sk_careful_memcpy(blobBuffer.glyphs, fGlyphs.data() + pos, size * sizeof(SkGlyphID)); |
| |
| if (fSpaced || offset.fX != 0 || offset.fY != 0) { |
| for (size_t i = 0; i < size; ++i) { |
| auto point = fPositions[i + pos]; |
| if (fSpaced) { |
| point.fX += fOffsets[i + pos]; |
| } |
| blobBuffer.points()[i] = point + offset; |
| } |
| } else { |
| // Good for the first line |
| sk_careful_memcpy(blobBuffer.points(), fPositions.data() + pos, size * sizeof(SkPoint)); |
| } |
| } |
| |
| // TODO: Make the search more effective |
| std::tuple<bool, Cluster*, Cluster*> Run::findLimitingClusters(SkSpan<const char> text) { |
| if (text.empty()) { |
| Cluster* found = nullptr; |
| for (auto& cluster : fClusters) { |
| if (cluster.contains(text.begin())) { |
| found = &cluster; |
| break; |
| } |
| } |
| return std::make_tuple(found != nullptr, found, found); |
| } |
| |
| auto first = text.begin(); |
| auto last = text.end() - 1; |
| |
| Cluster* start = nullptr; |
| Cluster* end = nullptr; |
| for (auto& cluster : fClusters) { |
| if (cluster.contains(first)) start = &cluster; |
| if (cluster.contains(last)) end = &cluster; |
| } |
| if (!leftToRight()) { |
| std::swap(start, end); |
| } |
| |
| return std::make_tuple(start != nullptr && end != nullptr, start, end); |
| } |
| |
| void Run::iterateThroughClustersInTextOrder(const ClusterVisitor& visitor) { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| // Can't figure out how to do it with one code for both cases without 100 ifs |
| // Can't go through clusters because there are no cluster table yet |
| if (leftToRight()) { |
| size_t start = 0; |
| size_t cluster = this->clusterIndex(start); |
| for (size_t glyph = 1; glyph <= this->size(); ++glyph) { |
| auto nextCluster = this->clusterIndex(glyph); |
| if (nextCluster == cluster) { |
| continue; |
| } |
| |
| visitor(start, |
| glyph, |
| cluster, |
| nextCluster, |
| this->calculateWidth(start, glyph, glyph == size()), |
| this->calculateHeight()); |
| |
| start = glyph; |
| cluster = nextCluster; |
| } |
| } else { |
| size_t glyph = this->size(); |
| size_t cluster = this->fUtf8Range.begin(); |
| for (int32_t start = this->size() - 1; start >= 0; --start) { |
| size_t nextCluster = |
| start == 0 ? this->fUtf8Range.end() : this->clusterIndex(start - 1); |
| if (nextCluster == cluster) { |
| continue; |
| } |
| |
| visitor(start, |
| glyph, |
| cluster, |
| nextCluster, |
| this->calculateWidth(start, glyph, glyph == 0), |
| this->calculateHeight()); |
| |
| glyph = start; |
| cluster = nextCluster; |
| } |
| } |
| } |
| |
| SkScalar Run::addSpacesAtTheEnd(SkScalar space, Cluster* cluster) { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| if (cluster->endPos() == cluster->startPos()) { |
| return 0; |
| } |
| |
| fOffsets[cluster->endPos() - 1] += space; |
| // Increment the run width |
| fSpaced = true; |
| fAdvance.fX += space; |
| // Increment the cluster width |
| cluster->space(space, space); |
| |
| return space; |
| } |
| |
| SkScalar Run::addSpacesEvenly(SkScalar space, Cluster* cluster) { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| // Offset all the glyphs in the cluster |
| SkScalar shift = 0; |
| for (size_t i = cluster->startPos(); i < cluster->endPos(); ++i) { |
| fOffsets[i] += shift; |
| shift += space; |
| } |
| if (this->size() == cluster->endPos()) { |
| // To make calculations easier |
| fOffsets[cluster->endPos()] += shift; |
| } |
| // Increment the run width |
| fSpaced = true; |
| fAdvance.fX += shift; |
| // Increment the cluster width |
| cluster->space(shift, space); |
| |
| return shift; |
| } |
| |
| void Run::shift(const Cluster* cluster, SkScalar offset) { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| if (offset == 0) { |
| return; |
| } |
| |
| fSpaced = true; |
| for (size_t i = cluster->startPos(); i < cluster->endPos(); ++i) { |
| fOffsets[i] += offset; |
| } |
| if (this->size() == cluster->endPos()) { |
| // To make calculations easier |
| fOffsets[cluster->endPos()] += offset; |
| } |
| } |
| |
| void Cluster::setIsWhiteSpaces() { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| auto pos = fText.end(); |
| while (--pos >= fText.begin()) { |
| auto ch = *pos; |
| if (!u_isspace(ch) && u_charType(ch) != U_CONTROL_CHAR && |
| u_charType(ch) != U_NON_SPACING_MARK) { |
| return; |
| } |
| } |
| fWhiteSpaces = true; |
| } |
| |
| SkScalar Cluster::sizeToChar(const char* ch) const { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| if (ch < fText.begin() || ch >= fText.end()) { |
| return 0; |
| } |
| auto shift = ch - fText.begin(); |
| auto ratio = shift * 1.0 / fText.size(); |
| |
| return SkDoubleToScalar(fWidth * ratio); |
| } |
| |
| SkScalar Cluster::sizeFromChar(const char* ch) const { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| if (ch < fText.begin() || ch >= fText.end()) { |
| return 0; |
| } |
| auto shift = fText.end() - ch - 1; |
| auto ratio = shift * 1.0 / fText.size(); |
| |
| return SkDoubleToScalar(fWidth * ratio); |
| } |
| |
| size_t Cluster::roundPos(SkScalar s) const { |
| TRACE_EVENT0("skia", TRACE_FUNC); |
| auto ratio = (s * 1.0) / fWidth; |
| return sk_double_floor2int(ratio * size()); |
| } |
| |
| SkScalar Cluster::trimmedWidth(size_t pos) const { |
| // Find the width until the pos and return the min between trimmedWidth and the width(pos) |
| return SkTMin(this->run()->positionX(pos) - this->run()->positionX(fStart), fWidth - fSpacing); |
| } |
| |
| } // namespace textlayout |
| } // namespace skia |