#ifndef InlineIterator_h
#define InlineIterator_h
#include "BidiRun.h"
#include "RenderBlock.h"
#include "RenderText.h"
#include <wtf/StdLibExtras.h>
namespace WebCore {
class InlineIterator {
public:
InlineIterator()
: m_root(0)
, m_obj(0)
, m_pos(0)
, m_nextBreakablePosition(-1)
{
}
InlineIterator(RenderObject* root, RenderObject* o, unsigned p)
: m_root(root)
, m_obj(o)
, m_pos(p)
, m_nextBreakablePosition(-1)
{
}
void clear() { moveTo(0, 0); }
void moveToStartOf(RenderObject* object)
{
moveTo(object, 0);
}
void moveTo(RenderObject* object, unsigned offset, int nextBreak = -1)
{
m_obj = object;
m_pos = offset;
m_nextBreakablePosition = nextBreak;
}
RenderObject* object() const { return m_obj; }
unsigned offset() const { return m_pos; }
RenderObject* root() const { return m_root; }
void fastIncrementInTextNode();
void increment(InlineBidiResolver* = 0);
bool atEnd() const;
inline bool atTextParagraphSeparator()
{
return m_obj && m_obj->preservesNewline() && m_obj->isText() && toRenderText(m_obj)->textLength()
&& !toRenderText(m_obj)->isWordBreak() && toRenderText(m_obj)->characterAt(m_pos) == '\n';
}
inline bool atParagraphSeparator()
{
return (m_obj && m_obj->isBR()) || atTextParagraphSeparator();
}
UChar characterAt(unsigned) const;
UChar current() const;
UChar previousInSameNode() const;
ALWAYS_INLINE WTF::Unicode::Direction direction() const;
private:
RenderObject* m_root;
public:
RenderObject* m_obj;
unsigned m_pos;
int m_nextBreakablePosition;
};
inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
{
return it1.m_pos == it2.m_pos && it1.m_obj == it2.m_obj;
}
inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)
{
return it1.m_pos != it2.m_pos || it1.m_obj != it2.m_obj;
}
static inline WTF::Unicode::Direction embedCharFromDirection(TextDirection dir, EUnicodeBidi unicodeBidi)
{
using namespace WTF::Unicode;
if (unicodeBidi == Embed)
return dir == RTL ? RightToLeftEmbedding : LeftToRightEmbedding;
return dir == RTL ? RightToLeftOverride : LeftToRightOverride;
}
template <class Observer>
static inline void notifyObserverEnteredObject(Observer* observer, RenderObject* object)
{
if (!observer || !object || !object->isRenderInline())
return;
RenderStyle* style = object->style();
EUnicodeBidi unicodeBidi = style->unicodeBidi();
if (unicodeBidi == UBNormal) {
return;
}
if (isIsolated(unicodeBidi)) {
observer->commitExplicitEmbedding();
observer->enterIsolate();
return;
}
if (!observer->inIsolate())
observer->embed(embedCharFromDirection(style->direction(), unicodeBidi), FromStyleOrDOM);
}
template <class Observer>
static inline void notifyObserverWillExitObject(Observer* observer, RenderObject* object)
{
if (!observer || !object || !object->isRenderInline())
return;
EUnicodeBidi unicodeBidi = object->style()->unicodeBidi();
if (unicodeBidi == UBNormal)
return; if (isIsolated(unicodeBidi)) {
observer->exitIsolate();
return;
}
if (!observer->inIsolate())
observer->embed(WTF::Unicode::PopDirectionalFormat, FromStyleOrDOM);
}
static inline bool isIteratorTarget(RenderObject* object)
{
ASSERT(object); return object->isText() || object->isFloating() || object->isOutOfFlowPositioned() || object->isReplaced();
}
enum EmptyInlineBehavior {
SkipEmptyInlines,
IncludeEmptyInlines,
};
static bool isEmptyInline(RenderObject* object)
{
if (!object->isRenderInline())
return false;
for (RenderObject* curr = object->firstChild(); curr; curr = curr->nextSibling()) {
if (curr->isFloatingOrOutOfFlowPositioned())
continue;
if (curr->isText() && toRenderText(curr)->isAllCollapsibleWhitespace())
continue;
if (!isEmptyInline(curr))
return false;
}
return true;
}
template <class Observer>
static inline RenderObject* bidiNextShared(RenderObject* root, RenderObject* current, Observer* observer = 0, EmptyInlineBehavior emptyInlineBehavior = SkipEmptyInlines, bool* endOfInlinePtr = 0)
{
RenderObject* next = 0;
bool oldEndOfInline = endOfInlinePtr ? *endOfInlinePtr : false;
bool endOfInline = false;
while (current) {
next = 0;
if (!oldEndOfInline && !isIteratorTarget(current)) {
next = current->firstChild();
notifyObserverEnteredObject(observer, next);
}
if (!next) {
if (emptyInlineBehavior == IncludeEmptyInlines && !oldEndOfInline && current->isRenderInline()) {
next = current;
endOfInline = true;
break;
}
while (current && current != root) {
notifyObserverWillExitObject(observer, current);
next = current->nextSibling();
if (next) {
notifyObserverEnteredObject(observer, next);
break;
}
current = current->parent();
if (emptyInlineBehavior == IncludeEmptyInlines && current && current != root && current->isRenderInline()) {
next = current;
endOfInline = true;
break;
}
}
}
if (!next)
break;
if (isIteratorTarget(next)
|| ((emptyInlineBehavior == IncludeEmptyInlines || isEmptyInline(next)) && next->isRenderInline()))
break;
current = next;
}
if (endOfInlinePtr)
*endOfInlinePtr = endOfInline;
return next;
}
template <class Observer>
static inline RenderObject* bidiNextSkippingEmptyInlines(RenderObject* root, RenderObject* current, Observer* observer)
{
return bidiNextShared(root, current, observer, SkipEmptyInlines);
}
static inline RenderObject* bidiNextSkippingEmptyInlines(RenderObject* root, RenderObject* current)
{
InlineBidiResolver* observer = 0;
return bidiNextSkippingEmptyInlines(root, current, observer);
}
static inline RenderObject* bidiNextIncludingEmptyInlines(RenderObject* root, RenderObject* current, bool* endOfInlinePtr = 0)
{
InlineBidiResolver* observer = 0; return bidiNextShared(root, current, observer, IncludeEmptyInlines, endOfInlinePtr);
}
static inline RenderObject* bidiFirstSkippingEmptyInlines(RenderObject* root, InlineBidiResolver* resolver = 0)
{
RenderObject* o = root->firstChild();
if (!o)
return 0;
if (o->isRenderInline()) {
notifyObserverEnteredObject(resolver, o);
if (!isEmptyInline(o))
o = bidiNextSkippingEmptyInlines(root, o, resolver);
else {
if (resolver)
resolver->commitExplicitEmbedding();
return o;
}
}
if (o && !isIteratorTarget(o))
o = bidiNextSkippingEmptyInlines(root, o, resolver);
if (resolver)
resolver->commitExplicitEmbedding();
return o;
}
static inline RenderObject* bidiFirstIncludingEmptyInlines(RenderObject* root)
{
RenderObject* o = root->firstChild();
if (!o || o->isRenderInline() || isIteratorTarget(o))
return o;
return bidiNextIncludingEmptyInlines(root, o);
}
inline void InlineIterator::fastIncrementInTextNode()
{
ASSERT(m_obj);
ASSERT(m_obj->isText());
ASSERT(m_pos <= toRenderText(m_obj)->textLength());
m_pos++;
}
class InlineWalker {
public:
InlineWalker(RenderObject* root)
: m_root(root)
, m_current(0)
, m_atEndOfInline(false)
{
m_current = bidiFirstIncludingEmptyInlines(m_root);
}
RenderObject* root() { return m_root; }
RenderObject* current() { return m_current; }
bool atEndOfInline() { return m_atEndOfInline; }
bool atEnd() const { return !m_current; }
RenderObject* advance()
{
m_current = bidiNextIncludingEmptyInlines(m_root, m_current, &m_atEndOfInline);
return m_current;
}
private:
RenderObject* m_root;
RenderObject* m_current;
bool m_atEndOfInline;
};
inline void InlineIterator::increment(InlineBidiResolver* resolver)
{
if (!m_obj)
return;
if (m_obj->isText()) {
fastIncrementInTextNode();
if (m_pos < toRenderText(m_obj)->textLength())
return;
}
moveTo(bidiNextSkippingEmptyInlines(m_root, m_obj, resolver), 0);
}
inline bool InlineIterator::atEnd() const
{
return !m_obj;
}
inline UChar InlineIterator::characterAt(unsigned index) const
{
if (!m_obj || !m_obj->isText())
return 0;
return toRenderText(m_obj)->characterAt(index);
}
inline UChar InlineIterator::current() const
{
return characterAt(m_pos);
}
inline UChar InlineIterator::previousInSameNode() const
{
if (!m_pos)
return 0;
return characterAt(m_pos - 1);
}
ALWAYS_INLINE WTF::Unicode::Direction InlineIterator::direction() const
{
if (UChar c = current())
return WTF::Unicode::direction(c);
if (m_obj && m_obj->isListMarker())
return m_obj->style()->isLeftToRightDirection() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
return WTF::Unicode::OtherNeutral;
}
template<>
inline void InlineBidiResolver::increment()
{
m_current.increment(this);
}
static inline bool isIsolatedInline(RenderObject* object)
{
ASSERT(object);
return object->isRenderInline() && isIsolated(object->style()->unicodeBidi());
}
static inline RenderObject* containingIsolate(RenderObject* object, RenderObject* root)
{
ASSERT(object);
RenderObject* containingIsolateObject = 0;
while (object && object != root) {
if (containingIsolateObject && !isIsolatedInline(object))
break;
if (isIsolatedInline(object))
containingIsolateObject = object;
object = object->parent();
}
return containingIsolateObject;
}
static inline unsigned numberOfIsolateAncestors(const InlineIterator& iter)
{
RenderObject* object = iter.object();
if (!object)
return 0;
unsigned count = 0;
while (object && object != iter.root()) {
if (isIsolatedInline(object))
count++;
object = object->parent();
}
return count;
}
static inline void addPlaceholderRunForIsolatedInline(InlineBidiResolver& resolver, RenderObject* obj, unsigned pos)
{
ASSERT(obj);
BidiRun* isolatedRun = new (obj->renderArena()) BidiRun(pos, 0, obj, resolver.context(), resolver.dir());
resolver.runs().addRun(isolatedRun);
resolver.isolatedRuns().append(isolatedRun);
}
class IsolateTracker {
public:
explicit IsolateTracker(unsigned nestedIsolateCount)
: m_nestedIsolateCount(nestedIsolateCount)
, m_haveAddedFakeRunForRootIsolate(false)
{
}
void enterIsolate() { m_nestedIsolateCount++; }
void exitIsolate()
{
ASSERT(m_nestedIsolateCount >= 1);
m_nestedIsolateCount--;
if (!inIsolate())
m_haveAddedFakeRunForRootIsolate = false;
}
bool inIsolate() const { return m_nestedIsolateCount; }
void embed(WTF::Unicode::Direction, BidiEmbeddingSource) { }
void commitExplicitEmbedding() { }
void addFakeRunIfNecessary(RenderObject* obj, unsigned pos, InlineBidiResolver& resolver)
{
if (m_haveAddedFakeRunForRootIsolate || RenderBlock::shouldSkipCreatingRunsForObject(obj))
return;
m_haveAddedFakeRunForRootIsolate = true;
addPlaceholderRunForIsolatedInline(resolver, obj, pos);
MidpointState<InlineIterator>& midpointState = resolver.midpointState();
if (midpointState.betweenMidpoints && midpointState.midpoints[midpointState.currentMidpoint].object() == obj) {
midpointState.betweenMidpoints = false;
++midpointState.currentMidpoint;
}
}
private:
unsigned m_nestedIsolateCount;
bool m_haveAddedFakeRunForRootIsolate;
};
template <>
inline void InlineBidiResolver::appendRun()
{
if (!m_emptyRun && !m_eor.atEnd() && !m_reachedEndOfLine) {
IsolateTracker isolateTracker(numberOfIsolateAncestors(m_sor));
int start = m_sor.m_pos;
RenderObject* obj = m_sor.m_obj;
while (obj && obj != m_eor.m_obj && obj != endOfLine.m_obj) {
if (isolateTracker.inIsolate())
isolateTracker.addFakeRunIfNecessary(obj, start, *this);
else
RenderBlock::appendRunsForObject(m_runs, start, obj->length(), obj, *this);
start = 0;
obj = bidiNextSkippingEmptyInlines(m_sor.root(), obj, &isolateTracker);
}
if (obj) {
unsigned pos = obj == m_eor.m_obj ? m_eor.m_pos : UINT_MAX;
if (obj == endOfLine.m_obj && endOfLine.m_pos <= pos) {
m_reachedEndOfLine = true;
pos = endOfLine.m_pos;
}
int end = obj->length() ? pos + 1 : 0;
if (isolateTracker.inIsolate())
isolateTracker.addFakeRunIfNecessary(obj, start, *this);
else
RenderBlock::appendRunsForObject(m_runs, start, end, obj, *this);
}
m_eor.increment();
m_sor = m_eor;
}
m_direction = WTF::Unicode::OtherNeutral;
m_status.eor = WTF::Unicode::OtherNeutral;
}
}
#endif // InlineIterator_h