| /* |
| * 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 |
