/* | |
* Copyright (C) 2000 Lars Knoll (knoll@kde.org) | |
* Copyright (C) 2003, 2004, 2006, 2007, 2008 Apple Inc. All right reserved. | |
* | |
* This library is free software; you can redistribute it and/or | |
* modify it under the terms of the GNU Library General Public | |
* License as published by the Free Software Foundation; either | |
* version 2 of the License, or (at your option) any later version. | |
* | |
* This library is distributed in the hope that it will be useful, | |
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
* Library General Public License for more details. | |
* | |
* You should have received a copy of the GNU Library General Public License | |
* along with this library; see the file COPYING.LIB. If not, write to | |
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
* Boston, MA 02110-1301, USA. | |
* | |
*/ | |
#ifndef BidiResolver_h | |
#define BidiResolver_h | |
#include "BidiContext.h" | |
#include <wtf/Noncopyable.h> | |
#include <wtf/PassRefPtr.h> | |
#include <wtf/Vector.h> | |
namespace WebCore { | |
template <class Iterator> struct MidpointState { | |
MidpointState() | |
{ | |
reset(); | |
} | |
void reset() | |
{ | |
numMidpoints = 0; | |
currentMidpoint = 0; | |
betweenMidpoints = false; | |
} | |
// The goal is to reuse the line state across multiple | |
// lines so we just keep an array around for midpoints and never clear it across multiple | |
// lines. We track the number of items and position using the two other variables. | |
Vector<Iterator> midpoints; | |
unsigned numMidpoints; | |
unsigned currentMidpoint; | |
bool betweenMidpoints; | |
}; | |
// The BidiStatus at a given position (typically the end of a line) can | |
// be cached and then used to restart bidi resolution at that position. | |
struct BidiStatus { | |
BidiStatus() | |
: eor(WTF::Unicode::OtherNeutral) | |
, lastStrong(WTF::Unicode::OtherNeutral) | |
, last(WTF::Unicode::OtherNeutral) | |
{ | |
} | |
BidiStatus(WTF::Unicode::Direction eorDir, WTF::Unicode::Direction lastStrongDir, WTF::Unicode::Direction lastDir, PassRefPtr<BidiContext> bidiContext) | |
: eor(eorDir) | |
, lastStrong(lastStrongDir) | |
, last(lastDir) | |
, context(bidiContext) | |
{ | |
} | |
WTF::Unicode::Direction eor; | |
WTF::Unicode::Direction lastStrong; | |
WTF::Unicode::Direction last; | |
RefPtr<BidiContext> context; | |
}; | |
inline bool operator==(const BidiStatus& status1, const BidiStatus& status2) | |
{ | |
return status1.eor == status2.eor && status1.last == status2.last && status1.lastStrong == status2.lastStrong && *(status1.context) == *(status2.context); | |
} | |
inline bool operator!=(const BidiStatus& status1, const BidiStatus& status2) | |
{ | |
return !(status1 == status2); | |
} | |
struct BidiCharacterRun { | |
BidiCharacterRun(int start, int stop, BidiContext* context, WTF::Unicode::Direction dir) | |
: m_start(start) | |
, m_stop(stop) | |
, m_override(context->override()) | |
, m_next(0) | |
{ | |
if (dir == WTF::Unicode::OtherNeutral) | |
dir = context->dir(); | |
m_level = context->level(); | |
// add level of run (cases I1 & I2) | |
if (m_level % 2) { | |
if (dir == WTF::Unicode::LeftToRight || dir == WTF::Unicode::ArabicNumber || dir == WTF::Unicode::EuropeanNumber) | |
m_level++; | |
} else { | |
if (dir == WTF::Unicode::RightToLeft) | |
m_level++; | |
else if (dir == WTF::Unicode::ArabicNumber || dir == WTF::Unicode::EuropeanNumber) | |
m_level += 2; | |
} | |
} | |
void destroy() { delete this; } | |
int start() const { return m_start; } | |
int stop() const { return m_stop; } | |
unsigned char level() const { return m_level; } | |
bool reversed(bool visuallyOrdered) { return m_level % 2 && !visuallyOrdered; } | |
bool dirOverride(bool visuallyOrdered) { return m_override || visuallyOrdered; } | |
BidiCharacterRun* next() const { return m_next; } | |
unsigned char m_level; | |
int m_start; | |
int m_stop; | |
bool m_override; | |
BidiCharacterRun* m_next; | |
}; | |
template <class Iterator, class Run> class BidiResolver : public Noncopyable { | |
public : | |
BidiResolver() | |
: m_direction(WTF::Unicode::OtherNeutral) | |
, reachedEndOfLine(false) | |
, emptyRun(true) | |
, m_firstRun(0) | |
, m_lastRun(0) | |
, m_logicallyLastRun(0) | |
, m_runCount(0) | |
{ | |
} | |
const Iterator& position() const { return current; } | |
void setPosition(const Iterator& position) { current = position; } | |
void increment() { current.increment(); } | |
BidiContext* context() const { return m_status.context.get(); } | |
void setContext(PassRefPtr<BidiContext> c) { m_status.context = c; } | |
void setLastDir(WTF::Unicode::Direction lastDir) { m_status.last = lastDir; } | |
void setLastStrongDir(WTF::Unicode::Direction lastStrongDir) { m_status.lastStrong = lastStrongDir; } | |
void setEorDir(WTF::Unicode::Direction eorDir) { m_status.eor = eorDir; } | |
WTF::Unicode::Direction dir() const { return m_direction; } | |
void setDir(WTF::Unicode::Direction d) { m_direction = d; } | |
const BidiStatus& status() const { return m_status; } | |
void setStatus(const BidiStatus s) { m_status = s; } | |
MidpointState<Iterator>& midpointState() { return m_midpointState; } | |
void embed(WTF::Unicode::Direction); | |
void commitExplicitEmbedding(); | |
void createBidiRunsForLine(const Iterator& end, bool visualOrder = false, bool hardLineBreak = false); | |
Run* firstRun() const { return m_firstRun; } | |
Run* lastRun() const { return m_lastRun; } | |
Run* logicallyLastRun() const { return m_logicallyLastRun; } | |
unsigned runCount() const { return m_runCount; } | |
void addRun(Run*); | |
void prependRun(Run*); | |
void moveRunToEnd(Run*); | |
void moveRunToBeginning(Run*); | |
void deleteRuns(); | |
protected: | |
void appendRun(); | |
void reverseRuns(unsigned start, unsigned end); | |
Iterator current; | |
Iterator sor; | |
Iterator eor; | |
Iterator last; | |
BidiStatus m_status; | |
WTF::Unicode::Direction m_direction; | |
Iterator endOfLine; | |
bool reachedEndOfLine; | |
Iterator lastBeforeET; | |
bool emptyRun; | |
Run* m_firstRun; | |
Run* m_lastRun; | |
Run* m_logicallyLastRun; | |
unsigned m_runCount; | |
MidpointState<Iterator> m_midpointState; | |
private: | |
void raiseExplicitEmbeddingLevel(WTF::Unicode::Direction from, WTF::Unicode::Direction to); | |
void lowerExplicitEmbeddingLevel(WTF::Unicode::Direction from); | |
Vector<WTF::Unicode::Direction, 8> m_currentExplicitEmbeddingSequence; | |
}; | |
template <class Iterator, class Run> | |
inline void BidiResolver<Iterator, Run>::addRun(Run* run) | |
{ | |
if (!m_firstRun) | |
m_firstRun = run; | |
else | |
m_lastRun->m_next = run; | |
m_lastRun = run; | |
m_runCount++; | |
} | |
template <class Iterator, class Run> | |
inline void BidiResolver<Iterator, Run>::prependRun(Run* run) | |
{ | |
ASSERT(!run->m_next); | |
if (!m_lastRun) | |
m_lastRun = run; | |
else | |
run->m_next = m_firstRun; | |
m_firstRun = run; | |
m_runCount++; | |
} | |
template <class Iterator, class Run> | |
inline void BidiResolver<Iterator, Run>::moveRunToEnd(Run* run) | |
{ | |
ASSERT(m_firstRun); | |
ASSERT(m_lastRun); | |
ASSERT(run->m_next); | |
Run* current = 0; | |
Run* next = m_firstRun; | |
while (next != run) { | |
current = next; | |
next = current->next(); | |
} | |
if (!current) | |
m_firstRun = run->next(); | |
else | |
current->m_next = run->m_next; | |
run->m_next = 0; | |
m_lastRun->m_next = run; | |
m_lastRun = run; | |
} | |
template <class Iterator, class Run> | |
inline void BidiResolver<Iterator, Run>::moveRunToBeginning(Run* run) | |
{ | |
ASSERT(m_firstRun); | |
ASSERT(m_lastRun); | |
ASSERT(run != m_firstRun); | |
Run* current = m_firstRun; | |
Run* next = current->next(); | |
while (next != run) { | |
current = next; | |
next = current->next(); | |
} | |
current->m_next = run->m_next; | |
if (run == m_lastRun) | |
m_lastRun = current; | |
run->m_next = m_firstRun; | |
m_firstRun = run; | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::appendRun() | |
{ | |
if (!emptyRun && !eor.atEnd()) { | |
unsigned startOffset = sor.offset(); | |
unsigned endOffset = eor.offset(); | |
if (!endOfLine.atEnd() && endOffset >= endOfLine.offset()) { | |
reachedEndOfLine = true; | |
endOffset = endOfLine.offset(); | |
} | |
if (endOffset >= startOffset) | |
addRun(new Run(startOffset, endOffset + 1, context(), m_direction)); | |
eor.increment(); | |
sor = eor; | |
} | |
m_direction = WTF::Unicode::OtherNeutral; | |
m_status.eor = WTF::Unicode::OtherNeutral; | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::embed(WTF::Unicode::Direction d) | |
{ | |
using namespace WTF::Unicode; | |
ASSERT(d == PopDirectionalFormat || d == LeftToRightEmbedding || d == LeftToRightOverride || d == RightToLeftEmbedding || d == RightToLeftOverride); | |
m_currentExplicitEmbeddingSequence.append(d); | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::lowerExplicitEmbeddingLevel(WTF::Unicode::Direction from) | |
{ | |
using namespace WTF::Unicode; | |
if (!emptyRun && eor != last) { | |
ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); | |
// bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last | |
ASSERT(m_status.last == EuropeanNumberSeparator | |
|| m_status.last == EuropeanNumberTerminator | |
|| m_status.last == CommonNumberSeparator | |
|| m_status.last == BoundaryNeutral | |
|| m_status.last == BlockSeparator | |
|| m_status.last == SegmentSeparator | |
|| m_status.last == WhiteSpaceNeutral | |
|| m_status.last == OtherNeutral); | |
if (m_direction == OtherNeutral) | |
m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; | |
if (from == LeftToRight) { | |
// bidi.sor ... bidi.eor ... bidi.last L | |
if (m_status.eor == EuropeanNumber) { | |
if (m_status.lastStrong != LeftToRight) { | |
m_direction = EuropeanNumber; | |
appendRun(); | |
} | |
} else if (m_status.eor == ArabicNumber) { | |
m_direction = ArabicNumber; | |
appendRun(); | |
} else if (m_status.lastStrong != LeftToRight) { | |
appendRun(); | |
m_direction = LeftToRight; | |
} | |
} else if (m_status.eor == EuropeanNumber || m_status.eor == ArabicNumber || m_status.lastStrong == LeftToRight) { | |
appendRun(); | |
m_direction = RightToLeft; | |
} | |
eor = last; | |
} | |
appendRun(); | |
emptyRun = true; | |
// sor for the new run is determined by the higher level (rule X10) | |
setLastDir(from); | |
setLastStrongDir(from); | |
eor = Iterator(); | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::raiseExplicitEmbeddingLevel(WTF::Unicode::Direction from, WTF::Unicode::Direction to) | |
{ | |
using namespace WTF::Unicode; | |
if (!emptyRun && eor != last) { | |
ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); | |
// bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last | |
ASSERT(m_status.last == EuropeanNumberSeparator | |
|| m_status.last == EuropeanNumberTerminator | |
|| m_status.last == CommonNumberSeparator | |
|| m_status.last == BoundaryNeutral | |
|| m_status.last == BlockSeparator | |
|| m_status.last == SegmentSeparator | |
|| m_status.last == WhiteSpaceNeutral | |
|| m_status.last == OtherNeutral); | |
if (m_direction == OtherNeutral) | |
m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; | |
if (to == LeftToRight) { | |
// bidi.sor ... bidi.eor ... bidi.last L | |
if (m_status.eor == EuropeanNumber) { | |
if (m_status.lastStrong != LeftToRight) { | |
m_direction = EuropeanNumber; | |
appendRun(); | |
} | |
} else if (m_status.eor == ArabicNumber) { | |
m_direction = ArabicNumber; | |
appendRun(); | |
} else if (m_status.lastStrong != LeftToRight && from == LeftToRight) { | |
appendRun(); | |
m_direction = LeftToRight; | |
} | |
} else if (m_status.eor == ArabicNumber | |
|| (m_status.eor == EuropeanNumber && (m_status.lastStrong != LeftToRight || from == RightToLeft)) | |
|| (m_status.eor != EuropeanNumber && m_status.lastStrong == LeftToRight && from == RightToLeft)) { | |
appendRun(); | |
m_direction = RightToLeft; | |
} | |
eor = last; | |
} | |
appendRun(); | |
emptyRun = true; | |
setLastDir(to); | |
setLastStrongDir(to); | |
eor = Iterator(); | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::commitExplicitEmbedding() | |
{ | |
using namespace WTF::Unicode; | |
unsigned char fromLevel = context()->level(); | |
RefPtr<BidiContext> toContext = context(); | |
for (size_t i = 0; i < m_currentExplicitEmbeddingSequence.size(); ++i) { | |
Direction embedding = m_currentExplicitEmbeddingSequence[i]; | |
if (embedding == PopDirectionalFormat) { | |
if (BidiContext* parentContext = toContext->parent()) | |
toContext = parentContext; | |
} else { | |
Direction direction = (embedding == RightToLeftEmbedding || embedding == RightToLeftOverride) ? RightToLeft : LeftToRight; | |
bool override = embedding == LeftToRightOverride || embedding == RightToLeftOverride; | |
unsigned char level = toContext->level(); | |
if (direction == RightToLeft) { | |
// Go to the least greater odd integer | |
level += 1; | |
level |= 1; | |
} else { | |
// Go to the least greater even integer | |
level += 2; | |
level &= ~1; | |
} | |
if (level < 61) | |
toContext = BidiContext::create(level, direction, override, toContext.get()); | |
} | |
} | |
unsigned char toLevel = toContext->level(); | |
if (toLevel > fromLevel) | |
raiseExplicitEmbeddingLevel(fromLevel % 2 ? RightToLeft : LeftToRight, toLevel % 2 ? RightToLeft : LeftToRight); | |
else if (toLevel < fromLevel) | |
lowerExplicitEmbeddingLevel(fromLevel % 2 ? RightToLeft : LeftToRight); | |
setContext(toContext); | |
m_currentExplicitEmbeddingSequence.clear(); | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::deleteRuns() | |
{ | |
emptyRun = true; | |
if (!m_firstRun) | |
return; | |
Run* curr = m_firstRun; | |
while (curr) { | |
Run* s = curr->next(); | |
curr->destroy(); | |
curr = s; | |
} | |
m_firstRun = 0; | |
m_lastRun = 0; | |
m_runCount = 0; | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::reverseRuns(unsigned start, unsigned end) | |
{ | |
if (start >= end) | |
return; | |
ASSERT(end < m_runCount); | |
// Get the item before the start of the runs to reverse and put it in | |
// |beforeStart|. |curr| should point to the first run to reverse. | |
Run* curr = m_firstRun; | |
Run* beforeStart = 0; | |
unsigned i = 0; | |
while (i < start) { | |
i++; | |
beforeStart = curr; | |
curr = curr->next(); | |
} | |
Run* startRun = curr; | |
while (i < end) { | |
i++; | |
curr = curr->next(); | |
} | |
Run* endRun = curr; | |
Run* afterEnd = curr->next(); | |
i = start; | |
curr = startRun; | |
Run* newNext = afterEnd; | |
while (i <= end) { | |
// Do the reversal. | |
Run* next = curr->next(); | |
curr->m_next = newNext; | |
newNext = curr; | |
curr = next; | |
i++; | |
} | |
// Now hook up beforeStart and afterEnd to the startRun and endRun. | |
if (beforeStart) | |
beforeStart->m_next = endRun; | |
else | |
m_firstRun = endRun; | |
startRun->m_next = afterEnd; | |
if (!afterEnd) | |
m_lastRun = startRun; | |
} | |
template <class Iterator, class Run> | |
void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& end, bool visualOrder, bool hardLineBreak) | |
{ | |
using namespace WTF::Unicode; | |
ASSERT(m_direction == OtherNeutral); | |
emptyRun = true; | |
eor = Iterator(); | |
last = current; | |
bool pastEnd = false; | |
BidiResolver<Iterator, Run> stateAtEnd; | |
while (true) { | |
Direction dirCurrent; | |
if (pastEnd && (hardLineBreak || current.atEnd())) { | |
BidiContext* c = context(); | |
while (c->parent()) | |
c = c->parent(); | |
dirCurrent = c->dir(); | |
if (hardLineBreak) { | |
// A deviation from the Unicode Bidi Algorithm in order to match | |
// Mac OS X text and WinIE: a hard line break resets bidi state. | |
stateAtEnd.setContext(c); | |
stateAtEnd.setEorDir(dirCurrent); | |
stateAtEnd.setLastDir(dirCurrent); | |
stateAtEnd.setLastStrongDir(dirCurrent); | |
} | |
} else { | |
dirCurrent = current.direction(); | |
if (context()->override() | |
&& dirCurrent != RightToLeftEmbedding | |
&& dirCurrent != LeftToRightEmbedding | |
&& dirCurrent != RightToLeftOverride | |
&& dirCurrent != LeftToRightOverride | |
&& dirCurrent != PopDirectionalFormat) | |
dirCurrent = context()->dir(); | |
else if (dirCurrent == NonSpacingMark) | |
dirCurrent = m_status.last; | |
} | |
ASSERT(m_status.eor != OtherNeutral || eor.atEnd()); | |
switch (dirCurrent) { | |
// embedding and overrides (X1-X9 in the Bidi specs) | |
case RightToLeftEmbedding: | |
case LeftToRightEmbedding: | |
case RightToLeftOverride: | |
case LeftToRightOverride: | |
case PopDirectionalFormat: | |
embed(dirCurrent); | |
commitExplicitEmbedding(); | |
break; | |
// strong types | |
case LeftToRight: | |
switch(m_status.last) { | |
case RightToLeft: | |
case RightToLeftArabic: | |
case EuropeanNumber: | |
case ArabicNumber: | |
if (m_status.last != EuropeanNumber || m_status.lastStrong != LeftToRight) | |
appendRun(); | |
break; | |
case LeftToRight: | |
break; | |
case EuropeanNumberSeparator: | |
case EuropeanNumberTerminator: | |
case CommonNumberSeparator: | |
case BoundaryNeutral: | |
case BlockSeparator: | |
case SegmentSeparator: | |
case WhiteSpaceNeutral: | |
case OtherNeutral: | |
if (m_status.eor == EuropeanNumber) { | |
if (m_status.lastStrong != LeftToRight) { | |
// the numbers need to be on a higher embedding level, so let's close that run | |
m_direction = EuropeanNumber; | |
appendRun(); | |
if (context()->dir() != LeftToRight) { | |
// the neutrals take the embedding direction, which is R | |
eor = last; | |
m_direction = RightToLeft; | |
appendRun(); | |
} | |
} | |
} else if (m_status.eor == ArabicNumber) { | |
// Arabic numbers are always on a higher embedding level, so let's close that run | |
m_direction = ArabicNumber; | |
appendRun(); | |
if (context()->dir() != LeftToRight) { | |
// the neutrals take the embedding direction, which is R | |
eor = last; | |
m_direction = RightToLeft; | |
appendRun(); | |
} | |
} else if (m_status.lastStrong != LeftToRight) { | |
//last stuff takes embedding dir | |
if (context()->dir() == RightToLeft) { | |
eor = last; | |
m_direction = RightToLeft; | |
} | |
appendRun(); | |
} | |
default: | |
break; | |
} | |
eor = current; | |
m_status.eor = LeftToRight; | |
m_status.lastStrong = LeftToRight; | |
m_direction = LeftToRight; | |
break; | |
case RightToLeftArabic: | |
case RightToLeft: | |
switch (m_status.last) { | |
case LeftToRight: | |
case EuropeanNumber: | |
case ArabicNumber: | |
appendRun(); | |
case RightToLeft: | |
case RightToLeftArabic: | |
break; | |
case EuropeanNumberSeparator: | |
case EuropeanNumberTerminator: | |
case CommonNumberSeparator: | |
case BoundaryNeutral: | |
case BlockSeparator: | |
case SegmentSeparator: | |
case WhiteSpaceNeutral: | |
case OtherNeutral: | |
if (m_status.eor == EuropeanNumber) { | |
if (m_status.lastStrong == LeftToRight && context()->dir() == LeftToRight) | |
eor = last; | |
appendRun(); | |
} else if (m_status.eor == ArabicNumber) | |
appendRun(); | |
else if (m_status.lastStrong == LeftToRight) { | |
if (context()->dir() == LeftToRight) | |
eor = last; | |
appendRun(); | |
} | |
default: | |
break; | |
} | |
eor = current; | |
m_status.eor = RightToLeft; | |
m_status.lastStrong = dirCurrent; | |
m_direction = RightToLeft; | |
break; | |
// weak types: | |
case EuropeanNumber: | |
if (m_status.lastStrong != RightToLeftArabic) { | |
// if last strong was AL change EN to AN | |
switch (m_status.last) { | |
case EuropeanNumber: | |
case LeftToRight: | |
break; | |
case RightToLeft: | |
case RightToLeftArabic: | |
case ArabicNumber: | |
eor = last; | |
appendRun(); | |
m_direction = EuropeanNumber; | |
break; | |
case EuropeanNumberSeparator: | |
case CommonNumberSeparator: | |
if (m_status.eor == EuropeanNumber) | |
break; | |
case EuropeanNumberTerminator: | |
case BoundaryNeutral: | |
case BlockSeparator: | |
case SegmentSeparator: | |
case WhiteSpaceNeutral: | |
case OtherNeutral: | |
if (m_status.eor == EuropeanNumber) { | |
if (m_status.lastStrong == RightToLeft) { | |
// ENs on both sides behave like Rs, so the neutrals should be R. | |
// Terminate the EN run. | |
appendRun(); | |
// Make an R run. | |
eor = m_status.last == EuropeanNumberTerminator ? lastBeforeET : last; | |
m_direction = RightToLeft; | |
appendRun(); | |
// Begin a new EN run. | |
m_direction = EuropeanNumber; | |
} | |
} else if (m_status.eor == ArabicNumber) { | |
// Terminate the AN run. | |
appendRun(); | |
if (m_status.lastStrong == RightToLeft || context()->dir() == RightToLeft) { | |
// Make an R run. | |
eor = m_status.last == EuropeanNumberTerminator ? lastBeforeET : last; | |
m_direction = RightToLeft; | |
appendRun(); | |
// Begin a new EN run. | |
m_direction = EuropeanNumber; | |
} | |
} else if (m_status.lastStrong == RightToLeft) { | |
// Extend the R run to include the neutrals. | |
eor = m_status.last == EuropeanNumberTerminator ? lastBeforeET : last; | |
m_direction = RightToLeft; | |
appendRun(); | |
// Begin a new EN run. | |
m_direction = EuropeanNumber; | |
} | |
default: | |
break; | |
} | |
eor = current; | |
m_status.eor = EuropeanNumber; | |
if (m_direction == OtherNeutral) | |
m_direction = LeftToRight; | |
break; | |
} | |
case ArabicNumber: | |
dirCurrent = ArabicNumber; | |
switch (m_status.last) { | |
case LeftToRight: | |
if (context()->dir() == LeftToRight) | |
appendRun(); | |
break; | |
case ArabicNumber: | |
break; | |
case RightToLeft: | |
case RightToLeftArabic: | |
case EuropeanNumber: | |
eor = last; | |
appendRun(); | |
break; | |
case CommonNumberSeparator: | |
if (m_status.eor == ArabicNumber) | |
break; | |
case EuropeanNumberSeparator: | |
case EuropeanNumberTerminator: | |
case BoundaryNeutral: | |
case BlockSeparator: | |
case SegmentSeparator: | |
case WhiteSpaceNeutral: | |
case OtherNeutral: | |
if (m_status.eor == ArabicNumber | |
|| (m_status.eor == EuropeanNumber && (m_status.lastStrong == RightToLeft || context()->dir() == RightToLeft)) | |
|| (m_status.eor != EuropeanNumber && m_status.lastStrong == LeftToRight && context()->dir() == RightToLeft)) { | |
// Terminate the run before the neutrals. | |
appendRun(); | |
// Begin an R run for the neutrals. | |
m_direction = RightToLeft; | |
} else if (m_direction == OtherNeutral) | |
m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft; | |
eor = last; | |
appendRun(); | |
default: | |
break; | |
} | |
eor = current; | |
m_status.eor = ArabicNumber; | |
if (m_direction == OtherNeutral) | |
m_direction = ArabicNumber; | |
break; | |
case EuropeanNumberSeparator: | |
case CommonNumberSeparator: | |
break; | |
case EuropeanNumberTerminator: | |
if (m_status.last == EuropeanNumber) { | |
dirCurrent = EuropeanNumber; | |
eor = current; | |
m_status.eor = dirCurrent; | |
} else if (m_status.last != EuropeanNumberTerminator) | |
lastBeforeET = emptyRun ? eor : last; | |
break; | |
// boundary neutrals should be ignored | |
case BoundaryNeutral: | |
if (eor == last) | |
eor = current; | |
break; | |
// neutrals | |
case BlockSeparator: | |
// ### what do we do with newline and paragraph seperators that come to here? | |
break; | |
case SegmentSeparator: | |
// ### implement rule L1 | |
break; | |
case WhiteSpaceNeutral: | |
break; | |
case OtherNeutral: | |
break; | |
default: | |
break; | |
} | |
if (pastEnd && eor == current) { | |
if (!reachedEndOfLine) { | |
eor = endOfLine; | |
switch (m_status.eor) { | |
case LeftToRight: | |
case RightToLeft: | |
case ArabicNumber: | |
m_direction = m_status.eor; | |
break; | |
case EuropeanNumber: | |
m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : EuropeanNumber; | |
break; | |
default: | |
ASSERT(false); | |
} | |
appendRun(); | |
} | |
current = end; | |
m_status = stateAtEnd.m_status; | |
sor = stateAtEnd.sor; | |
eor = stateAtEnd.eor; | |
last = stateAtEnd.last; | |
reachedEndOfLine = stateAtEnd.reachedEndOfLine; | |
lastBeforeET = stateAtEnd.lastBeforeET; | |
emptyRun = stateAtEnd.emptyRun; | |
m_direction = OtherNeutral; | |
break; | |
} | |
// set m_status.last as needed. | |
switch (dirCurrent) { | |
case EuropeanNumberTerminator: | |
if (m_status.last != EuropeanNumber) | |
m_status.last = EuropeanNumberTerminator; | |
break; | |
case EuropeanNumberSeparator: | |
case CommonNumberSeparator: | |
case SegmentSeparator: | |
case WhiteSpaceNeutral: | |
case OtherNeutral: | |
switch(m_status.last) { | |
case LeftToRight: | |
case RightToLeft: | |
case RightToLeftArabic: | |
case EuropeanNumber: | |
case ArabicNumber: | |
m_status.last = dirCurrent; | |
break; | |
default: | |
m_status.last = OtherNeutral; | |
} | |
break; | |
case NonSpacingMark: | |
case BoundaryNeutral: | |
case RightToLeftEmbedding: | |
case LeftToRightEmbedding: | |
case RightToLeftOverride: | |
case LeftToRightOverride: | |
case PopDirectionalFormat: | |
// ignore these | |
break; | |
case EuropeanNumber: | |
// fall through | |
default: | |
m_status.last = dirCurrent; | |
} | |
last = current; | |
if (emptyRun && !(dirCurrent == RightToLeftEmbedding | |
|| dirCurrent == LeftToRightEmbedding | |
|| dirCurrent == RightToLeftOverride | |
|| dirCurrent == LeftToRightOverride | |
|| dirCurrent == PopDirectionalFormat)) { | |
sor = current; | |
emptyRun = false; | |
} | |
increment(); | |
if (!m_currentExplicitEmbeddingSequence.isEmpty()) { | |
commitExplicitEmbedding(); | |
if (pastEnd) { | |
current = end; | |
m_status = stateAtEnd.m_status; | |
sor = stateAtEnd.sor; | |
eor = stateAtEnd.eor; | |
last = stateAtEnd.last; | |
reachedEndOfLine = stateAtEnd.reachedEndOfLine; | |
lastBeforeET = stateAtEnd.lastBeforeET; | |
emptyRun = stateAtEnd.emptyRun; | |
m_direction = OtherNeutral; | |
break; | |
} | |
} | |
if (emptyRun && (dirCurrent == RightToLeftEmbedding | |
|| dirCurrent == LeftToRightEmbedding | |
|| dirCurrent == RightToLeftOverride | |
|| dirCurrent == LeftToRightOverride | |
|| dirCurrent == PopDirectionalFormat)) { | |
// exclude the embedding char itself from the new run so that ATSUI will never see it | |
eor = Iterator(); | |
last = current; | |
sor = current; | |
} | |
if (!pastEnd && (current == end || current.atEnd())) { | |
if (emptyRun) | |
break; | |
stateAtEnd.m_status = m_status; | |
stateAtEnd.sor = sor; | |
stateAtEnd.eor = eor; | |
stateAtEnd.last = last; | |
stateAtEnd.reachedEndOfLine = reachedEndOfLine; | |
stateAtEnd.lastBeforeET = lastBeforeET; | |
stateAtEnd.emptyRun = emptyRun; | |
endOfLine = last; | |
pastEnd = true; | |
} | |
} | |
m_logicallyLastRun = m_lastRun; | |
// reorder line according to run structure... | |
// do not reverse for visually ordered web sites | |
if (!visualOrder) { | |
// first find highest and lowest levels | |
unsigned char levelLow = 128; | |
unsigned char levelHigh = 0; | |
Run* r = firstRun(); | |
while (r) { | |
if (r->m_level > levelHigh) | |
levelHigh = r->m_level; | |
if (r->m_level < levelLow) | |
levelLow = r->m_level; | |
r = r->next(); | |
} | |
// implements reordering of the line (L2 according to Bidi spec): | |
// L2. From the highest level found in the text to the lowest odd level on each line, | |
// reverse any contiguous sequence of characters that are at that level or higher. | |
// reversing is only done up to the lowest odd level | |
if (!(levelLow % 2)) | |
levelLow++; | |
unsigned count = runCount() - 1; | |
while (levelHigh >= levelLow) { | |
unsigned i = 0; | |
Run* currRun = firstRun(); | |
while (i < count) { | |
while (i < count && currRun && currRun->m_level < levelHigh) { | |
i++; | |
currRun = currRun->next(); | |
} | |
unsigned start = i; | |
while (i <= count && currRun && currRun->m_level >= levelHigh) { | |
i++; | |
currRun = currRun->next(); | |
} | |
unsigned end = i - 1; | |
reverseRuns(start, end); | |
} | |
levelHigh--; | |
} | |
} | |
endOfLine = Iterator(); | |
} | |
} // namespace WebCore | |
#endif // BidiResolver_h |