int nextBreakablePosition(LazyLineBreakIterator& lazyBreakIterator, int pos, bool treatNoBreakSpaceAsBreak) { const UChar* str = lazyBreakIterator.string(); int len = lazyBreakIterator.length(); int nextBreak = -1; UChar lastCh = pos > 0 ? str[pos - 1] : 0; for (int i = pos; i < len; i++) { UChar ch = str[i]; if (isBreakableSpace(ch, treatNoBreakSpaceAsBreak) || shouldBreakAfter(lastCh, ch)) return i; if (needsLineBreakIterator(ch) || needsLineBreakIterator(lastCh)) { if (nextBreak < i && i) { TextBreakIterator* breakIterator = lazyBreakIterator.get(); if (breakIterator) nextBreak = textBreakFollowing(breakIterator, i - 1); } // These characters are not kinsoku characters according to Unicode 6.0, // However, they are in JLreq (http://www.w3.org/TR/jlreq/). We need // special treatment here. if (i == nextBreak && !isBreakableSpace(lastCh, treatNoBreakSpaceAsBreak) && !Font::isUnbreakableCharactersPair(lastCh, ch)) return i; } lastCh = ch; } return len; }
int nextBreakablePosition(LazyLineBreakIterator& lazyBreakIterator, int pos, bool treatNoBreakSpaceAsBreak) { const UChar* str = lazyBreakIterator.string(); int len = lazyBreakIterator.length(); int nextBreak = -1; UChar lastLastCh = pos > 1 ? str[pos - 2] : 0; UChar lastCh = pos > 0 ? str[pos - 1] : 0; for (int i = pos; i < len; i++) { UChar ch = str[i]; if (isBreakableSpace(ch, treatNoBreakSpaceAsBreak) || shouldBreakAfter(lastLastCh, lastCh, ch)) return i; if (needsLineBreakIterator(ch) || needsLineBreakIterator(lastCh)) { if (nextBreak < i && i) { TextBreakIterator* breakIterator = lazyBreakIterator.get(); if (breakIterator) nextBreak = textBreakFollowing(breakIterator, i - 1); } if (i == nextBreak && !isBreakableSpace(lastCh, treatNoBreakSpaceAsBreak)) return i; } lastLastCh = lastCh; lastCh = ch; } return len; }
int nextBreakablePosition(const UChar* str, int pos, int len, bool treatNoBreakSpaceAsBreak) { #if !PLATFORM(MAC) || !defined(BUILDING_ON_TIGER) TextBreakIterator* breakIterator = 0; #endif int nextBreak = -1; UChar lastCh = pos > 0 ? str[pos - 1] : 0; for (int i = pos; i < len; i++) { UChar ch = str[i]; if (isBreakableSpace(ch, treatNoBreakSpaceAsBreak) || shouldBreakAfter(lastCh)) return i; if (needsLineBreakIterator(ch) || needsLineBreakIterator(lastCh)) { if (nextBreak < i && i) { #if !PLATFORM(MAC) || !defined(BUILDING_ON_TIGER) if (!breakIterator) breakIterator = lineBreakIterator(str, len); if (breakIterator) nextBreak = textBreakFollowing(breakIterator, i - 1); #else static TextBreakLocatorRef breakLocator = lineBreakLocator(); if (breakLocator) { UniCharArrayOffset nextUCBreak; if (UCFindTextBreak(breakLocator, kUCTextBreakLineMask, 0, str, len, i, &nextUCBreak) == 0) nextBreak = nextUCBreak; } #endif } if (i == nextBreak && !isBreakableSpace(lastCh, treatNoBreakSpaceAsBreak)) return i; } lastCh = ch; } return len; }
static inline int nextBreakablePosition(LazyLineBreakIterator& lazyBreakIterator, const CharacterType* str, unsigned length, int pos) { int len = static_cast<int>(length); int nextBreak = -1; CharacterType lastLastCh = pos > 1 ? str[pos - 2] : static_cast<CharacterType>(lazyBreakIterator.secondToLastCharacter()); CharacterType lastCh = pos > 0 ? str[pos - 1] : static_cast<CharacterType>(lazyBreakIterator.lastCharacter()); unsigned priorContextLength = lazyBreakIterator.priorContextLength(); for (int i = pos; i < len; i++) { CharacterType ch = str[i]; if (isBreakableSpace(ch) || shouldBreakAfter(lastLastCh, lastCh, ch)) return i; if (needsLineBreakIterator(ch) || needsLineBreakIterator(lastCh)) { if (nextBreak < i) { // Don't break if positioned at start of primary context and there is no prior context. if (i || priorContextLength) { TextBreakIterator* breakIterator = lazyBreakIterator.get(priorContextLength); if (breakIterator) { nextBreak = breakIterator->following(i - 1 + priorContextLength); if (nextBreak >= 0) { nextBreak -= priorContextLength; } } } } if (i == nextBreak && !isBreakableSpace(lastCh)) return i; } lastLastCh = lastCh; lastCh = ch; } return len; }