| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "StaticLayout" |
| |
| #include "ScopedIcuLocale.h" |
| #include "unicode/locid.h" |
| #include "unicode/brkiter.h" |
| #include "utils/misc.h" |
| #include "utils/Log.h" |
| #include "ScopedPrimitiveArray.h" |
| #include "JNIHelp.h" |
| #include "core_jni_helpers.h" |
| #include <cstdint> |
| #include <vector> |
| #include <list> |
| #include <algorithm> |
| |
| #include "SkPaint.h" |
| #include "SkTypeface.h" |
| #include "MinikinSkia.h" |
| #include "MinikinUtils.h" |
| #include "Paint.h" |
| |
| namespace android { |
| |
| struct JLineBreaksID { |
| jfieldID breaks; |
| jfieldID widths; |
| jfieldID flags; |
| }; |
| |
| static jclass gLineBreaks_class; |
| static JLineBreaksID gLineBreaks_fieldID; |
| |
| class Builder { |
| public: |
| ~Builder() { |
| utext_close(&mUText); |
| delete mBreakIterator; |
| } |
| |
| void setLocale(const icu::Locale& locale) { |
| delete mBreakIterator; |
| UErrorCode status = U_ZERO_ERROR; |
| mBreakIterator = icu::BreakIterator::createLineInstance(locale, status); |
| // TODO: check status |
| } |
| |
| void resize(size_t size) { |
| mTextBuf.resize(size); |
| mWidthBuf.resize(size); |
| } |
| |
| size_t size() const { |
| return mTextBuf.size(); |
| } |
| |
| uint16_t* buffer() { |
| return mTextBuf.data(); |
| } |
| |
| float* widths() { |
| return mWidthBuf.data(); |
| } |
| |
| // set text to current contents of buffer |
| void setText() { |
| UErrorCode status = U_ZERO_ERROR; |
| utext_openUChars(&mUText, mTextBuf.data(), mTextBuf.size(), &status); |
| mBreakIterator->setText(&mUText, status); |
| } |
| |
| void finish() { |
| if (mTextBuf.size() > MAX_TEXT_BUF_RETAIN) { |
| mTextBuf.clear(); |
| mTextBuf.shrink_to_fit(); |
| mWidthBuf.clear(); |
| mWidthBuf.shrink_to_fit(); |
| } |
| } |
| |
| icu::BreakIterator* breakIterator() const { |
| return mBreakIterator; |
| } |
| |
| float measureStyleRun(Paint* paint, TypefaceImpl* typeface, size_t start, size_t end, |
| bool isRtl); |
| |
| void addReplacement(size_t start, size_t end, float width); |
| |
| private: |
| const size_t MAX_TEXT_BUF_RETAIN = 32678; |
| icu::BreakIterator* mBreakIterator = nullptr; |
| UText mUText = UTEXT_INITIALIZER; |
| std::vector<uint16_t>mTextBuf; |
| std::vector<float>mWidthBuf; |
| }; |
| |
| static const int CHAR_SPACE = 0x20; |
| static const int CHAR_TAB = 0x09; |
| static const int CHAR_NEWLINE = 0x0a; |
| static const int CHAR_ZWSP = 0x200b; |
| |
| class TabStops { |
| public: |
| // specified stops must be a sorted array (allowed to be null) |
| TabStops(JNIEnv* env, jintArray stops, jint defaultTabWidth) : |
| mStops(env), mTabWidth(defaultTabWidth) { |
| if (stops != nullptr) { |
| mStops.reset(stops); |
| mNumStops = mStops.size(); |
| } else { |
| mNumStops = 0; |
| } |
| } |
| float width(float widthSoFar) const { |
| const jint* mStopsArray = mStops.get(); |
| for (int i = 0; i < mNumStops; i++) { |
| if (mStopsArray[i] > widthSoFar) { |
| return mStopsArray[i]; |
| } |
| } |
| // find the next tabstop after widthSoFar |
| return static_cast<int>((widthSoFar + mTabWidth) / mTabWidth) * mTabWidth; |
| } |
| private: |
| ScopedIntArrayRO mStops; |
| const int mTabWidth; |
| int mNumStops; |
| |
| // disable copying and assignment |
| TabStops(const TabStops&); |
| void operator=(const TabStops&); |
| }; |
| |
| enum PrimitiveType { |
| kPrimitiveType_Box, |
| kPrimitiveType_Glue, |
| kPrimitiveType_Penalty, |
| kPrimitiveType_Variable, |
| kPrimitiveType_Wordbreak |
| }; |
| |
| static const float PENALTY_INFINITY = 1e7; // forced non-break, negative infinity is forced break |
| |
| struct Primitive { |
| PrimitiveType type; |
| int location; |
| // 'Box' has width |
| // 'Glue' has width |
| // 'Penalty' has width and penalty |
| // 'Variable' has tabStop |
| // 'Wordbreak' has penalty |
| union { |
| struct { |
| float width; |
| float penalty; |
| }; |
| const TabStops* tabStop; |
| }; |
| }; |
| |
| class LineWidth { |
| public: |
| LineWidth(float firstWidth, int firstWidthLineCount, float restWidth) : |
| mFirstWidth(firstWidth), mFirstWidthLineCount(firstWidthLineCount), |
| mRestWidth(restWidth) {} |
| float getLineWidth(int line) const { |
| return (line < mFirstWidthLineCount) ? mFirstWidth : mRestWidth; |
| } |
| private: |
| const float mFirstWidth; |
| const int mFirstWidthLineCount; |
| const float mRestWidth; |
| }; |
| |
| class LineBreaker { |
| public: |
| LineBreaker(const std::vector<Primitive>& primitives, |
| const LineWidth& lineWidth) : |
| mPrimitives(primitives), mLineWidth(lineWidth) {} |
| virtual ~LineBreaker() {} |
| virtual void computeBreaks(std::vector<int>* breaks, std::vector<float>* widths, |
| std::vector<unsigned char>* flags) const = 0; |
| protected: |
| const std::vector<Primitive>& mPrimitives; |
| const LineWidth& mLineWidth; |
| }; |
| |
| class OptimizingLineBreaker : public LineBreaker { |
| public: |
| OptimizingLineBreaker(const std::vector<Primitive>& primitives, const LineWidth& lineWidth) : |
| LineBreaker(primitives, lineWidth) {} |
| void computeBreaks(std::vector<int>* breaks, std::vector<float>* widths, |
| std::vector<unsigned char>* flags) const { |
| int numBreaks = mPrimitives.size(); |
| Node* opt = new Node[numBreaks]; |
| opt[0].prev = -1; |
| opt[0].prevCount = 0; |
| opt[0].width = 0; |
| opt[0].demerits = 0; |
| opt[0].flags = false; |
| opt[numBreaks - 1].prev = -1; |
| opt[numBreaks - 1].prevCount = 0; |
| |
| std::list<int> active; |
| active.push_back(0); |
| int lastBreak = 0; |
| for (int i = 0; i < numBreaks; i++) { |
| const Primitive& p = mPrimitives[i]; |
| if (p.type == kPrimitiveType_Penalty) { |
| const bool finalBreak = (i + 1 == numBreaks); |
| bool breakFound = false; |
| Node bestBreak; |
| for (std::list<int>::iterator it = active.begin(); it != active.end(); /* incrementing done in loop */) { |
| const int pos = *it; |
| bool flags; |
| float width, printedWidth; |
| const int lines = opt[pos].prevCount; |
| const float maxWidth = mLineWidth.getLineWidth(lines); |
| // we have to compute metrics every time -- |
| // we can't really precompute this stuff and just deal with breaks |
| // because of the way tab characters work, this makes it computationally |
| // harder, but this way, we can still optimize while treating tab characters |
| // correctly |
| computeMetrics(pos, i, &width, &printedWidth, &flags); |
| if (printedWidth <= maxWidth) { |
| float demerits = computeDemerits(maxWidth, printedWidth, |
| finalBreak, p.penalty) + opt[pos].demerits; |
| if (!breakFound || demerits < bestBreak.demerits) { |
| bestBreak.prev = pos; |
| bestBreak.prevCount = opt[pos].prevCount + 1; |
| bestBreak.demerits = demerits; |
| bestBreak.width = printedWidth; |
| bestBreak.flags = flags; |
| breakFound = true; |
| } |
| ++it; |
| } else { |
| active.erase(it++); // safe to delete like this |
| } |
| } |
| if (p.penalty == -PENALTY_INFINITY) { |
| active.clear(); |
| } |
| if (breakFound) { |
| opt[i] = bestBreak; |
| active.push_back(i); |
| lastBreak = i; |
| } |
| if (active.empty()) { |
| // we can't give up! |
| float width, printedWidth; |
| bool flags; |
| const int lines = opt[lastBreak].prevCount; |
| const float maxWidth = mLineWidth.getLineWidth(lines); |
| const int breakIndex = desperateBreak(lastBreak, numBreaks, maxWidth, &width, &printedWidth, &flags); |
| |
| opt[breakIndex].prev = lastBreak; |
| opt[breakIndex].prevCount = lines + 1; |
| opt[breakIndex].demerits = 0; // doesn't matter, it's the only one |
| opt[breakIndex].width = width; |
| opt[breakIndex].flags = flags; |
| |
| active.push_back(breakIndex); |
| lastBreak = breakIndex; |
| i = breakIndex; // incremented by i++ |
| } |
| } |
| } |
| |
| int idx = numBreaks - 1; |
| int count = opt[idx].prevCount; |
| breaks->resize(count); |
| widths->resize(count); |
| flags->resize(count); |
| while (opt[idx].prev != -1) { |
| --count; |
| |
| (*breaks)[count] = mPrimitives[idx].location; |
| (*widths)[count] = opt[idx].width; |
| (*flags)[count] = opt[idx].flags; |
| |
| idx = opt[idx].prev; |
| } |
| delete[] opt; |
| } |
| private: |
| inline void computeMetrics(int start, int end, float* width, float* printedWidth, bool* flags) const { |
| bool f = false; |
| float w = 0, pw = 0; |
| for (int i = start; i < end; i++) { |
| const Primitive& p = mPrimitives[i]; |
| if (p.type == kPrimitiveType_Box || p.type == kPrimitiveType_Glue) { |
| w += p.width; |
| if (p.type == kPrimitiveType_Box) { |
| pw = w; |
| } |
| } else if (p.type == kPrimitiveType_Variable) { |
| w = p.tabStop->width(w); |
| f = true; |
| } |
| } |
| *width = w; |
| *printedWidth = pw; |
| *flags = f; |
| } |
| |
| inline float computeDemerits(float maxWidth, float width, bool finalBreak, float penalty) const { |
| float deviation = finalBreak ? 0 : maxWidth - width; |
| return (deviation * deviation) + penalty; |
| } |
| |
| // returns end pos (chosen break), -1 if fail |
| inline int desperateBreak(int start, int limit, float maxWidth, float* width, float* printedWidth, bool* flags) const { |
| float w = 0, pw = 0; |
| bool breakFound = false; |
| int breakIndex = 0, firstTabIndex = INT_MAX; |
| for (int i = start; i < limit; i++) { |
| const Primitive& p = mPrimitives[i]; |
| |
| if (p.type == kPrimitiveType_Box || p.type == kPrimitiveType_Glue) { |
| w += p.width; |
| if (p.type == kPrimitiveType_Box) { |
| pw = w; |
| } |
| } else if (p.type == kPrimitiveType_Variable) { |
| w = p.tabStop->width(w); |
| firstTabIndex = std::min(firstTabIndex, i); |
| } |
| |
| if (pw > maxWidth) { |
| if (breakFound) { |
| break; |
| } else { |
| // no choice, keep going |
| } |
| } |
| |
| // must make progress |
| if (i > start && (p.type == kPrimitiveType_Penalty || p.type == kPrimitiveType_Wordbreak)) { |
| breakFound = true; |
| breakIndex = i; |
| } |
| } |
| |
| if (breakFound) { |
| *width = w; |
| *printedWidth = pw; |
| *flags = (start <= firstTabIndex && firstTabIndex < breakIndex); |
| return breakIndex; |
| } else { |
| return -1; |
| } |
| } |
| |
| struct Node { |
| int prev; // set to sentinel value (-1) for initial node |
| int prevCount; // number of breaks so far |
| float demerits; |
| float width; |
| bool flags; |
| }; |
| }; |
| |
| class GreedyLineBreaker : public LineBreaker { |
| public: |
| GreedyLineBreaker(const std::vector<Primitive>& primitives, const LineWidth& lineWidth) : |
| LineBreaker(primitives, lineWidth) {} |
| void computeBreaks(std::vector<int>* breaks, std::vector<float>* widths, |
| std::vector<unsigned char>* flags) const { |
| int lineNum = 0; |
| float width = 0, printedWidth = 0; |
| bool breakFound = false, goodBreakFound = false; |
| int breakIndex = 0, goodBreakIndex = 0; |
| float breakWidth = 0, goodBreakWidth = 0; |
| int firstTabIndex = INT_MAX; |
| |
| float maxWidth = mLineWidth.getLineWidth(lineNum); |
| |
| const int numPrimitives = mPrimitives.size(); |
| // greedily fit as many characters as possible on each line |
| // loop over all primitives, and choose the best break point |
| // (if possible, a break point without splitting a word) |
| // after going over the maximum length |
| for (int i = 0; i < numPrimitives; i++) { |
| const Primitive& p = mPrimitives[i]; |
| |
| // update the current line width |
| if (p.type == kPrimitiveType_Box || p.type == kPrimitiveType_Glue) { |
| width += p.width; |
| if (p.type == kPrimitiveType_Box) { |
| printedWidth = width; |
| } |
| } else if (p.type == kPrimitiveType_Variable) { |
| width = p.tabStop->width(width); |
| // keep track of first tab character in the region we are examining |
| // so we can determine whether or not a line contains a tab |
| firstTabIndex = std::min(firstTabIndex, i); |
| } |
| |
| // find the best break point for the characters examined so far |
| if (printedWidth > maxWidth) { |
| if (breakFound || goodBreakFound) { |
| if (goodBreakFound) { |
| // a true line break opportunity existed in the characters examined so far, |
| // so there is no need to split a word |
| i = goodBreakIndex; // no +1 because of i++ |
| lineNum++; |
| maxWidth = mLineWidth.getLineWidth(lineNum); |
| breaks->push_back(mPrimitives[goodBreakIndex].location); |
| widths->push_back(goodBreakWidth); |
| flags->push_back(firstTabIndex < goodBreakIndex); |
| firstTabIndex = INT_MAX; |
| } else { |
| // must split a word because there is no other option |
| i = breakIndex; // no +1 because of i++ |
| lineNum++; |
| maxWidth = mLineWidth.getLineWidth(lineNum); |
| breaks->push_back(mPrimitives[breakIndex].location); |
| widths->push_back(breakWidth); |
| flags->push_back(firstTabIndex < breakIndex); |
| firstTabIndex = INT_MAX; |
| } |
| printedWidth = width = 0; |
| goodBreakFound = breakFound = false; |
| goodBreakWidth = breakWidth = 0; |
| continue; |
| } else { |
| // no choice, keep going... must make progress by putting at least one |
| // character on a line, even if part of that character is cut off -- |
| // there is no other option |
| } |
| } |
| |
| // update possible break points |
| if (p.type == kPrimitiveType_Penalty && p.penalty < PENALTY_INFINITY) { |
| // this does not handle penalties with width |
| |
| // handle forced line break |
| if (p.penalty == -PENALTY_INFINITY) { |
| lineNum++; |
| maxWidth = mLineWidth.getLineWidth(lineNum); |
| breaks->push_back(p.location); |
| widths->push_back(printedWidth); |
| flags->push_back(firstTabIndex < i); |
| firstTabIndex = INT_MAX; |
| printedWidth = width = 0; |
| goodBreakFound = breakFound = false; |
| goodBreakWidth = breakWidth = 0; |
| continue; |
| } |
| if (i > breakIndex && (printedWidth <= maxWidth || breakFound == false)) { |
| breakFound = true; |
| breakIndex = i; |
| breakWidth = printedWidth; |
| } |
| if (i > goodBreakIndex && printedWidth <= maxWidth) { |
| goodBreakFound = true; |
| goodBreakIndex = i; |
| goodBreakWidth = printedWidth; |
| } |
| } else if (p.type == kPrimitiveType_Wordbreak) { |
| // only do this if necessary -- we don't want to break words |
| // when possible, but sometimes it is unavoidable |
| if (i > breakIndex && (printedWidth <= maxWidth || breakFound == false)) { |
| breakFound = true; |
| breakIndex = i; |
| breakWidth = printedWidth; |
| } |
| } |
| } |
| |
| if (breakFound || goodBreakFound) { |
| // output last break if there are more characters to output |
| if (goodBreakFound) { |
| breaks->push_back(mPrimitives[goodBreakIndex].location); |
| widths->push_back(goodBreakWidth); |
| flags->push_back(firstTabIndex < goodBreakIndex); |
| } else { |
| breaks->push_back(mPrimitives[breakIndex].location); |
| widths->push_back(breakWidth); |
| flags->push_back(firstTabIndex < breakIndex); |
| } |
| } |
| } |
| }; |
| |
| static jint recycleCopy(JNIEnv* env, jobject recycle, jintArray recycleBreaks, |
| jfloatArray recycleWidths, jbooleanArray recycleFlags, |
| jint recycleLength, const std::vector<jint>& breaks, |
| const std::vector<jfloat>& widths, const std::vector<jboolean>& flags) { |
| int bufferLength = breaks.size(); |
| if (recycleLength < bufferLength) { |
| // have to reallocate buffers |
| recycleBreaks = env->NewIntArray(bufferLength); |
| recycleWidths = env->NewFloatArray(bufferLength); |
| recycleFlags = env->NewBooleanArray(bufferLength); |
| |
| env->SetObjectField(recycle, gLineBreaks_fieldID.breaks, recycleBreaks); |
| env->SetObjectField(recycle, gLineBreaks_fieldID.widths, recycleWidths); |
| env->SetObjectField(recycle, gLineBreaks_fieldID.flags, recycleFlags); |
| } |
| // copy data |
| env->SetIntArrayRegion(recycleBreaks, 0, breaks.size(), &breaks.front()); |
| env->SetFloatArrayRegion(recycleWidths, 0, widths.size(), &widths.front()); |
| env->SetBooleanArrayRegion(recycleFlags, 0, flags.size(), &flags.front()); |
| |
| return bufferLength; |
| } |
| |
| void computePrimitives(const jchar* textArr, const jfloat* widthsArr, jint length, const std::vector<int>& breaks, |
| const TabStops& tabStopCalculator, std::vector<Primitive>* primitives) { |
| int breaksSize = breaks.size(); |
| int breakIndex = 0; |
| Primitive p; |
| for (int i = 0; i < length; i++) { |
| p.location = i; |
| jchar c = textArr[i]; |
| if (c == CHAR_SPACE || c == CHAR_ZWSP) { |
| p.type = kPrimitiveType_Glue; |
| p.width = widthsArr[i]; |
| primitives->push_back(p); |
| } else if (c == CHAR_TAB) { |
| p.type = kPrimitiveType_Variable; |
| p.tabStop = &tabStopCalculator; // shared between all variable primitives |
| primitives->push_back(p); |
| } else if (c != CHAR_NEWLINE) { |
| while (breakIndex < breaksSize && breaks[breakIndex] < i) breakIndex++; |
| p.width = 0; |
| if (breakIndex < breaksSize && breaks[breakIndex] == i) { |
| p.type = kPrimitiveType_Penalty; |
| p.penalty = 0; |
| } else { |
| p.type = kPrimitiveType_Wordbreak; |
| } |
| if (widthsArr[i] != 0) { |
| primitives->push_back(p); |
| } |
| |
| p.type = kPrimitiveType_Box; |
| p.width = widthsArr[i]; |
| primitives->push_back(p); |
| } |
| } |
| // final break at end of everything |
| p.location = length; |
| p.type = kPrimitiveType_Penalty; |
| p.width = 0; |
| p.penalty = -PENALTY_INFINITY; |
| primitives->push_back(p); |
| } |
| |
| // sets the text on the builder |
| static void nSetText(JNIEnv* env, jclass, jlong nativePtr, jcharArray text, int length) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| b->resize(length); |
| env->GetCharArrayRegion(text, 0, length, b->buffer()); |
| b->setText(); |
| } |
| |
| static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr, |
| jint length, |
| jfloat firstWidth, jint firstWidthLineLimit, jfloat restWidth, |
| jintArray variableTabStops, jint defaultTabStop, jboolean optimize, |
| jobject recycle, jintArray recycleBreaks, |
| jfloatArray recycleWidths, jbooleanArray recycleFlags, |
| jint recycleLength) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| |
| std::vector<int> breaks; |
| |
| icu::BreakIterator* breakIterator = b->breakIterator(); |
| int loc = breakIterator->first(); |
| while ((loc = breakIterator->next()) != icu::BreakIterator::DONE) { |
| breaks.push_back(loc); |
| } |
| |
| // TODO: all these allocations can be moved into the builder |
| std::vector<Primitive> primitives; |
| TabStops tabStops(env, variableTabStops, defaultTabStop); |
| computePrimitives(b->buffer(), b->widths(), length, breaks, tabStops, &primitives); |
| |
| LineWidth lineWidth(firstWidth, firstWidthLineLimit, restWidth); |
| std::vector<int> computedBreaks; |
| std::vector<float> computedWidths; |
| std::vector<unsigned char> computedFlags; |
| |
| if (optimize) { |
| OptimizingLineBreaker breaker(primitives, lineWidth); |
| breaker.computeBreaks(&computedBreaks, &computedWidths, &computedFlags); |
| } else { |
| GreedyLineBreaker breaker(primitives, lineWidth); |
| breaker.computeBreaks(&computedBreaks, &computedWidths, &computedFlags); |
| } |
| b->finish(); |
| |
| return recycleCopy(env, recycle, recycleBreaks, recycleWidths, recycleFlags, recycleLength, |
| computedBreaks, computedWidths, computedFlags); |
| } |
| |
| static jlong nNewBuilder(JNIEnv*, jclass) { |
| return reinterpret_cast<jlong>(new Builder); |
| } |
| |
| static void nFreeBuilder(JNIEnv*, jclass, jlong nativePtr) { |
| delete reinterpret_cast<Builder*>(nativePtr); |
| } |
| |
| static void nFinishBuilder(JNIEnv*, jclass, jlong nativePtr) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| b->finish(); |
| } |
| |
| static void nSetLocale(JNIEnv* env, jclass, jlong nativePtr, jstring javaLocaleName) { |
| ScopedIcuLocale icuLocale(env, javaLocaleName); |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| |
| if (icuLocale.valid()) { |
| b->setLocale(icuLocale.locale()); |
| } |
| } |
| |
| float Builder::measureStyleRun(Paint* paint, TypefaceImpl* typeface, size_t start, size_t end, |
| bool isRtl) { |
| Layout layout; |
| int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; |
| // TODO: should we provide more context? |
| MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, mTextBuf.data() + start, 0, |
| end - start, end - start); |
| layout.getAdvances(mWidthBuf.data() + start); |
| return layout.getAdvance(); |
| } |
| |
| void Builder::addReplacement(size_t start, size_t end, float width) { |
| mWidthBuf[start] = width; |
| std::fill(&mWidthBuf[start + 1], &mWidthBuf[end], 0.0f); |
| } |
| |
| // Basically similar to Paint.getTextRunAdvances but with C++ interface |
| static jfloat nAddStyleRun(JNIEnv* env, jclass, jlong nativePtr, |
| jlong nativePaint, jlong nativeTypeface, jint start, jint end, jboolean isRtl) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| Paint* paint = reinterpret_cast<Paint*>(nativePaint); |
| TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(nativeTypeface); |
| return b->measureStyleRun(paint, typeface, start, end, isRtl); |
| } |
| |
| // Accept width measurements for the run, passed in from Java |
| static void nAddMeasuredRun(JNIEnv* env, jclass, jlong nativePtr, |
| jint start, jint end, jfloatArray widths) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| env->GetFloatArrayRegion(widths, start, end - start, b->widths() + start); |
| } |
| |
| static void nAddReplacementRun(JNIEnv* env, jclass, jlong nativePtr, |
| jint start, jint end, jfloat width) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| b->addReplacement(start, end, width); |
| } |
| |
| static void nGetWidths(JNIEnv* env, jclass, jlong nativePtr, jfloatArray widths) { |
| Builder* b = reinterpret_cast<Builder*>(nativePtr); |
| env->SetFloatArrayRegion(widths, 0, b->size(), b->widths()); |
| } |
| |
| static JNINativeMethod gMethods[] = { |
| // TODO performance: many of these are candidates for fast jni, awaiting guidance |
| {"nNewBuilder", "()J", (void*) nNewBuilder}, |
| {"nFreeBuilder", "(J)V", (void*) nFreeBuilder}, |
| {"nFinishBuilder", "(J)V", (void*) nFinishBuilder}, |
| {"nSetLocale", "(JLjava/lang/String;)V", (void*) nSetLocale}, |
| {"nSetText", "(J[CI)V", (void*) nSetText}, |
| {"nAddStyleRun", "(JJJIIZ)F", (void*) nAddStyleRun}, |
| {"nAddMeasuredRun", "(JII[F)V", (void*) nAddMeasuredRun}, |
| {"nAddReplacementRun", "(JIIF)V", (void*) nAddReplacementRun}, |
| {"nGetWidths", "(J[F)V", (void*) nGetWidths}, |
| {"nComputeLineBreaks", "(JIFIF[IIZLandroid/text/StaticLayout$LineBreaks;[I[F[ZI)I", |
| (void*) nComputeLineBreaks} |
| }; |
| |
| int register_android_text_StaticLayout(JNIEnv* env) |
| { |
| gLineBreaks_class = MakeGlobalRefOrDie(env, |
| FindClassOrDie(env, "android/text/StaticLayout$LineBreaks")); |
| |
| gLineBreaks_fieldID.breaks = GetFieldIDOrDie(env, gLineBreaks_class, "breaks", "[I"); |
| gLineBreaks_fieldID.widths = GetFieldIDOrDie(env, gLineBreaks_class, "widths", "[F"); |
| gLineBreaks_fieldID.flags = GetFieldIDOrDie(env, gLineBreaks_class, "flags", "[Z"); |
| |
| return RegisterMethodsOrDie(env, "android/text/StaticLayout", gMethods, NELEM(gMethods)); |
| } |
| |
| } |