| /* |
| * 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. |
| */ |
| |
| #include <stdint.h> |
| #include <unicode/uchar.h> |
| #include <unicode/utf16.h> |
| #include <algorithm> |
| |
| #include <minikin/Emoji.h> |
| #include <minikin/GraphemeBreak.h> |
| #include "MinikinInternal.h" |
| #include "utils/WindowsUtils.h" |
| |
| namespace minikin { |
| |
| int32_t tailoredGraphemeClusterBreak(uint32_t c) { |
| // Characters defined as Control that we want to treat them as Extend. |
| // These are curated manually. |
| if (c == 0x00AD // SHY |
| || c == 0x061C // ALM |
| || c == 0x180E // MONGOLIAN VOWEL SEPARATOR |
| || c == 0x200B // ZWSP |
| || c == 0x200E // LRM |
| || c == 0x200F // RLM |
| || (0x202A <= c && c <= 0x202E) // LRE, RLE, PDF, LRO, RLO |
| || ((c | 0xF) == |
| 0x206F) // WJ, invisible math operators, LRI, RLI, FSI, PDI, |
| // and the deprecated invisible format controls |
| || c == 0xFEFF // BOM |
| || ((c | 0x7F) == |
| 0xE007F)) // recently undeprecated tag characters in Plane 14 |
| return U_GCB_EXTEND; |
| // THAI CHARACTER SARA AM is treated as a normal letter by most other |
| // implementations: they allow a grapheme break before it. |
| else if (c == 0x0E33) |
| return U_GCB_OTHER; |
| else |
| return u_getIntPropertyValue(c, UCHAR_GRAPHEME_CLUSTER_BREAK); |
| } |
| |
| // Returns true for all characters whose IndicSyllabicCategory is Pure_Killer. |
| // From http://www.unicode.org/Public/9.0.0/ucd/IndicSyllabicCategory.txt |
| bool isPureKiller(uint32_t c) { |
| return (c == 0x0E3A || c == 0x0E4E || c == 0x0F84 || c == 0x103A || |
| c == 0x1714 || c == 0x1734 || c == 0x17D1 || c == 0x1BAA || |
| c == 0x1BF2 || c == 0x1BF3 || c == 0xA806 || c == 0xA953 || |
| c == 0xABED || c == 0x11134 || c == 0x112EA || c == 0x1172B); |
| } |
| |
| bool GraphemeBreak::isGraphemeBreak(const float* advances, |
| const uint16_t* buf, |
| size_t start, |
| size_t count, |
| const size_t offset) { |
| // This implementation closely follows Unicode Standard Annex #29 on |
| // Unicode Text Segmentation (http://www.unicode.org/reports/tr29/), |
| // implementing a tailored version of extended grapheme clusters. |
| // The GB rules refer to section 3.1.1, Grapheme Cluster Boundary Rules. |
| |
| // Rule GB1, sot ÷; Rule GB2, ÷ eot |
| if (offset <= start || offset >= start + count) { |
| return true; |
| } |
| if (U16_IS_TRAIL(buf[offset])) { |
| // Don't break a surrogate pair, but a lonely trailing surrogate pair is a |
| // break |
| return !U16_IS_LEAD(buf[offset - 1]); |
| } |
| uint32_t c1 = 0; |
| uint32_t c2 = 0; |
| size_t offset_back = offset; |
| size_t offset_forward = offset; |
| U16_PREV(buf, start, offset_back, c1); |
| U16_NEXT(buf, offset_forward, start + count, c2); |
| int32_t p1 = tailoredGraphemeClusterBreak(c1); |
| int32_t p2 = tailoredGraphemeClusterBreak(c2); |
| // Rule GB3, CR x LF |
| if (p1 == U_GCB_CR && p2 == U_GCB_LF) { |
| return false; |
| } |
| // Rule GB4, (Control | CR | LF) ÷ |
| if (p1 == U_GCB_CONTROL || p1 == U_GCB_CR || p1 == U_GCB_LF) { |
| return true; |
| } |
| // Rule GB5, ÷ (Control | CR | LF) |
| if (p2 == U_GCB_CONTROL || p2 == U_GCB_CR || p2 == U_GCB_LF) { |
| return true; |
| } |
| // Rule GB6, L x ( L | V | LV | LVT ) |
| if (p1 == U_GCB_L && |
| (p2 == U_GCB_L || p2 == U_GCB_V || p2 == U_GCB_LV || p2 == U_GCB_LVT)) { |
| return false; |
| } |
| // Rule GB7, ( LV | V ) x ( V | T ) |
| if ((p1 == U_GCB_LV || p1 == U_GCB_V) && (p2 == U_GCB_V || p2 == U_GCB_T)) { |
| return false; |
| } |
| // Rule GB8, ( LVT | T ) x T |
| if ((p1 == U_GCB_LVT || p1 == U_GCB_T) && p2 == U_GCB_T) { |
| return false; |
| } |
| // Rule GB9, x (Extend | ZWJ); Rule GB9a, x SpacingMark; Rule GB9b, Prepend x |
| if (p2 == U_GCB_EXTEND || p2 == U_GCB_ZWJ || p2 == U_GCB_SPACING_MARK || |
| p1 == U_GCB_PREPEND) { |
| return false; |
| } |
| |
| // This is used to decide font-dependent grapheme clusters. If we don't have |
| // the advance information, we become conservative in grapheme breaking and |
| // assume that it has no advance. |
| const bool c2_has_advance = |
| (advances != nullptr && advances[offset - start] != 0.0); |
| |
| // All the following rules are font-dependent, in the way that if we know c2 |
| // has an advance, we definitely know that it cannot form a grapheme with the |
| // character(s) before it. So we make the decision in favor a grapheme break |
| // early. |
| if (c2_has_advance) { |
| return true; |
| } |
| |
| // Note: For Rule GB10 and GB11 below, we do not use the Unicode line breaking |
| // properties for determining emoji-ness and carry our own data, because our |
| // data could be more fresh than what ICU provides. |
| // |
| // Tailored version of Rule GB10, (E_Base | EBG) Extend* × E_Modifier. |
| // The rule itself says do not break between emoji base and emoji modifiers, |
| // skipping all Extend characters. Variation selectors are considered Extend, |
| // so they are handled fine. |
| // |
| // We tailor this by requiring that an actual ligature is formed. If the font |
| // doesn't form a ligature, we allow a break before the modifier. |
| if (isEmojiModifier(c2)) { |
| uint32_t c0 = c1; |
| size_t offset_backback = offset_back; |
| int32_t p0 = p1; |
| if (p0 == U_GCB_EXTEND && offset_backback > start) { |
| // skip over emoji variation selector |
| U16_PREV(buf, start, offset_backback, c0); |
| } |
| if (isEmojiBase(c0)) { |
| return false; |
| } |
| } |
| |
| // Tailored version of Rule GB11, ZWJ × (Glue_After_Zwj | EBG) |
| // We try to make emoji sequences with ZWJ a single grapheme cluster, but only |
| // if they actually merge to one cluster. So we are more relaxed than the UAX |
| // #29 rules in accepting any emoji character after the ZWJ, but are tighter |
| // in that we only treat it as one cluster if a ligature is actually formed |
| // and we also require the character before the ZWJ to also be an emoji. |
| if (p1 == U_GCB_ZWJ && isEmoji(c2) && offset_back > start) { |
| // look at character before ZWJ to see that both can participate in an |
| // emoji zwj sequence |
| uint32_t c0 = 0; |
| size_t offset_backback = offset_back; |
| U16_PREV(buf, start, offset_backback, c0); |
| if (c0 == 0xFE0F && offset_backback > start) { |
| // skip over emoji variation selector |
| U16_PREV(buf, start, offset_backback, c0); |
| } |
| if (isEmoji(c0)) { |
| return false; |
| } |
| } |
| |
| // Tailored version of Rule GB12 and Rule GB13 that look at even-odd cases. |
| // sot (RI RI)* RI x RI |
| // [^RI] (RI RI)* RI x RI |
| // |
| // If we have font information, we have already broken the cluster if and only |
| // if the second character had no advance, which means a ligature was formed. |
| // If we don't, we look back like UAX #29 recommends, but only up to 1000 code |
| // units. |
| if (p1 == U_GCB_REGIONAL_INDICATOR && p2 == U_GCB_REGIONAL_INDICATOR) { |
| if (advances != nullptr) { |
| // We have advances information. But if we are here, we already know c2 |
| // has no advance. So we should definitely disallow a break. |
| return false; |
| } else { |
| // Look at up to 1000 code units. |
| const size_t lookback_barrier = |
| std::max((ssize_t)start, (ssize_t)offset_back - 1000); |
| size_t offset_backback = offset_back; |
| while (offset_backback > lookback_barrier) { |
| uint32_t c0 = 0; |
| U16_PREV(buf, lookback_barrier, offset_backback, c0); |
| if (tailoredGraphemeClusterBreak(c0) != U_GCB_REGIONAL_INDICATOR) { |
| offset_backback += U16_LENGTH(c0); |
| break; |
| } |
| } |
| // The number 4 comes from the number of code units in a whole flag. |
| return (offset - offset_backback) % 4 == 0; |
| } |
| } |
| // Cluster Indic syllables together (tailoring of UAX #29). |
| // Immediately after each virama (that is not just a pure killer) followed by |
| // a letter, we disallow grapheme breaks (if we are here, we don't know about |
| // advances, or we already know that c2 has no advance). |
| if (u_getIntPropertyValue(c1, UCHAR_CANONICAL_COMBINING_CLASS) == 9 // virama |
| && !isPureKiller(c1) && |
| u_getIntPropertyValue(c2, UCHAR_GENERAL_CATEGORY) == U_OTHER_LETTER) { |
| return false; |
| } |
| // Rule GB999, Any ÷ Any |
| return true; |
| } |
| |
| size_t GraphemeBreak::getTextRunCursor(const float* advances, |
| const uint16_t* buf, |
| size_t start, |
| size_t count, |
| size_t offset, |
| MoveOpt opt) { |
| switch (opt) { |
| case AFTER: |
| if (offset < start + count) { |
| offset++; |
| } |
| // fall through |
| case AT_OR_AFTER: |
| while (!isGraphemeBreak(advances, buf, start, count, offset)) { |
| offset++; |
| } |
| break; |
| case BEFORE: |
| if (offset > start) { |
| offset--; |
| } |
| // fall through |
| case AT_OR_BEFORE: |
| while (!isGraphemeBreak(advances, buf, start, count, offset)) { |
| offset--; |
| } |
| break; |
| case AT: |
| if (!isGraphemeBreak(advances, buf, start, count, offset)) { |
| offset = (size_t)-1; |
| } |
| break; |
| } |
| return offset; |
| } |
| |
| } // namespace minikin |
