| /* |
| * Copyright (C) 2000 Lars Knoll (knoll@kde.org) |
| * Copyright (C) 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. |
| * |
| */ |
| |
| #include "config.h" |
| #include "bidi.h" |
| |
| #include "CharacterNames.h" |
| #include "Document.h" |
| #include "Element.h" |
| #include "FrameView.h" |
| #include "InlineTextBox.h" |
| #include "Logging.h" |
| #include "RenderArena.h" |
| #include "RenderLayer.h" |
| #include "RenderListMarker.h" |
| #include "RenderView.h" |
| #include "break_lines.h" |
| #include <wtf/AlwaysInline.h> |
| #include <wtf/Vector.h> |
| |
| using namespace std; |
| using namespace WTF; |
| using namespace Unicode; |
| |
| namespace WebCore { |
| |
| // We don't let our line box tree for a single line get any deeper than this. |
| const unsigned cMaxLineDepth = 200; |
| |
| class BidiIterator { |
| public: |
| BidiIterator() |
| : block(0) |
| , obj(0) |
| , pos(0) |
| { |
| } |
| |
| BidiIterator(RenderBlock* b, RenderObject* o, unsigned p) |
| : block(b) |
| , obj(o) |
| , pos(p) |
| { |
| } |
| |
| void increment(BidiResolver<BidiIterator, BidiRun>& state); |
| bool atEnd() const; |
| |
| UChar current() const; |
| WTF::Unicode::Direction direction() const; |
| |
| RenderBlock* block; |
| RenderObject* obj; |
| unsigned int pos; |
| }; |
| |
| // Used to track a list of chained bidi runs. |
| static BidiRun* sFirstBidiRun; |
| static BidiRun* sLastBidiRun; |
| static BidiRun* sLogicallyLastBidiRun; |
| static int sBidiRunCount; |
| |
| // Midpoint globals. The goal is not to do any allocation when dealing with |
| // these midpoints, so we just keep an array around and never clear it. We track |
| // the number of items and position using the two other variables. |
| static Vector<BidiIterator>* smidpoints; |
| static unsigned sNumMidpoints; |
| static unsigned sCurrMidpoint; |
| static bool betweenMidpoints; |
| |
| static bool isLineEmpty = true; |
| static bool previousLineBrokeCleanly = true; |
| static int numSpaces; |
| |
| static int getBPMWidth(int childValue, Length cssUnit) |
| { |
| if (!cssUnit.isIntrinsicOrAuto()) |
| return (cssUnit.isFixed() ? cssUnit.value() : childValue); |
| return 0; |
| } |
| |
| static int getBorderPaddingMargin(RenderObject* child, bool endOfInline) |
| { |
| RenderStyle* cstyle = child->style(); |
| int result = 0; |
| bool leftSide = (cstyle->direction() == LTR) ? !endOfInline : endOfInline; |
| result += getBPMWidth((leftSide ? child->marginLeft() : child->marginRight()), |
| (leftSide ? cstyle->marginLeft() : |
| cstyle->marginRight())); |
| result += getBPMWidth((leftSide ? child->paddingLeft() : child->paddingRight()), |
| (leftSide ? cstyle->paddingLeft() : |
| cstyle->paddingRight())); |
| result += leftSide ? child->borderLeft() : child->borderRight(); |
| return result; |
| } |
| |
| static int inlineWidth(RenderObject* child, bool start = true, bool end = true) |
| { |
| unsigned lineDepth = 1; |
| int extraWidth = 0; |
| RenderObject* parent = child->parent(); |
| while (parent->isInline() && !parent->isInlineBlockOrInlineTable() && lineDepth++ < cMaxLineDepth) { |
| if (start && parent->firstChild() == child) |
| extraWidth += getBorderPaddingMargin(parent, false); |
| if (end && parent->lastChild() == child) |
| extraWidth += getBorderPaddingMargin(parent, true); |
| child = parent; |
| parent = child->parent(); |
| } |
| return extraWidth; |
| } |
| |
| #ifndef NDEBUG |
| WTFLogChannel LogWebCoreBidiRunLeaks = { 0x00000000, "", WTFLogChannelOn }; |
| |
| struct BidiRunCounter { |
| static int count; |
| ~BidiRunCounter() |
| { |
| if (count) |
| LOG(WebCoreBidiRunLeaks, "LEAK: %d BidiRun\n", count); |
| } |
| }; |
| int BidiRunCounter::count = 0; |
| static BidiRunCounter bidiRunCounter; |
| |
| static bool inBidiRunDestroy; |
| #endif |
| |
| void BidiRun::destroy(RenderArena* renderArena) |
| { |
| #ifndef NDEBUG |
| inBidiRunDestroy = true; |
| #endif |
| delete this; |
| #ifndef NDEBUG |
| inBidiRunDestroy = false; |
| #endif |
| |
| // Recover the size left there for us by operator delete and free the memory. |
| renderArena->free(*(size_t *)this, this); |
| } |
| |
| void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw() |
| { |
| #ifndef NDEBUG |
| ++BidiRunCounter::count; |
| #endif |
| return renderArena->allocate(sz); |
| } |
| |
| void BidiRun::operator delete(void* ptr, size_t sz) |
| { |
| #ifndef NDEBUG |
| --BidiRunCounter::count; |
| #endif |
| ASSERT(inBidiRunDestroy); |
| |
| // Stash size where destroy() can find it. |
| *(size_t*)ptr = sz; |
| } |
| |
| template <> |
| void BidiState::deleteRuns() |
| { |
| emptyRun = true; |
| if (!m_firstRun) |
| return; |
| |
| BidiRun* curr = m_firstRun; |
| while (curr) { |
| BidiRun* s = curr->next(); |
| curr->destroy(curr->obj->renderArena()); |
| curr = s; |
| } |
| |
| m_firstRun = 0; |
| m_lastRun = 0; |
| m_runCount = 0; |
| } |
| |
| // --------------------------------------------------------------------- |
| |
| inline bool operator==(const BidiIterator& it1, const BidiIterator& it2) |
| { |
| return it1.pos == it2.pos && it1.obj == it2.obj; |
| } |
| |
| inline bool operator!=(const BidiIterator& it1, const BidiIterator& it2) |
| { |
| return it1.pos != it2.pos || it1.obj != it2.obj; |
| } |
| |
| static inline RenderObject* bidiNext(RenderBlock* block, RenderObject* current, BidiState& bidi, |
| bool skipInlines = true, bool* endOfInline = 0) |
| { |
| RenderObject* next = 0; |
| bool oldEndOfInline = endOfInline ? *endOfInline : false; |
| if (endOfInline) |
| *endOfInline = false; |
| |
| while (current) { |
| next = 0; |
| if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned()) { |
| next = current->firstChild(); |
| if (next && bidi.adjustEmbedding() && next->isInlineFlow()) { |
| EUnicodeBidi ub = next->style()->unicodeBidi(); |
| if (ub != UBNormal) { |
| TextDirection dir = next->style()->direction(); |
| Direction d = (ub == Embed |
| ? (dir == RTL ? RightToLeftEmbedding : LeftToRightEmbedding) |
| : (dir == RTL ? RightToLeftOverride : LeftToRightOverride)); |
| bidi.embed(d); |
| } |
| } |
| } |
| |
| if (!next) { |
| if (!skipInlines && !oldEndOfInline && current->isInlineFlow()) { |
| next = current; |
| if (endOfInline) |
| *endOfInline = true; |
| break; |
| } |
| |
| while (current && current != block) { |
| if (bidi.adjustEmbedding() && current->isInlineFlow() && current->style()->unicodeBidi() != UBNormal) |
| bidi.embed(PopDirectionalFormat); |
| |
| next = current->nextSibling(); |
| if (next) { |
| if (bidi.adjustEmbedding() && next->isInlineFlow()) { |
| EUnicodeBidi ub = next->style()->unicodeBidi(); |
| if (ub != UBNormal) { |
| TextDirection dir = next->style()->direction(); |
| Direction d = (ub == Embed |
| ? (dir == RTL ? RightToLeftEmbedding: LeftToRightEmbedding) |
| : (dir == RTL ? RightToLeftOverride : LeftToRightOverride)); |
| bidi.embed(d); |
| } |
| } |
| break; |
| } |
| |
| current = current->parent(); |
| if (!skipInlines && current && current != block && current->isInlineFlow()) { |
| next = current; |
| if (endOfInline) |
| *endOfInline = true; |
| break; |
| } |
| } |
| } |
| |
| if (!next) |
| break; |
| |
| if (next->isText() || next->isBR() || next->isFloating() || next->isReplaced() || next->isPositioned() |
| || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines. |
| && next->isInlineFlow())) |
| break; |
| current = next; |
| } |
| return next; |
| } |
| |
| static RenderObject* bidiFirst(RenderBlock* block, BidiState& bidi, bool skipInlines = true ) |
| { |
| if (!block->firstChild()) |
| return 0; |
| |
| RenderObject* o = block->firstChild(); |
| if (o->isInlineFlow()) { |
| if (bidi.adjustEmbedding()) { |
| EUnicodeBidi ub = o->style()->unicodeBidi(); |
| if (ub != UBNormal) { |
| TextDirection dir = o->style()->direction(); |
| Direction d = (ub == Embed |
| ? (dir == RTL ? RightToLeftEmbedding : LeftToRightEmbedding) |
| : (dir == RTL ? RightToLeftOverride : LeftToRightOverride)); |
| bidi.embed(d); |
| } |
| } |
| if (skipInlines && o->firstChild()) |
| o = bidiNext(block, o, bidi, skipInlines); |
| else |
| return o; // Never skip empty inlines. |
| } |
| |
| if (o && !o->isText() && !o->isBR() && !o->isReplaced() && !o->isFloating() && !o->isPositioned()) |
| o = bidiNext(block, o, bidi, skipInlines); |
| return o; |
| } |
| |
| inline void BidiIterator::increment(BidiState& bidi) |
| { |
| if (!obj) |
| return; |
| if (obj->isText()) { |
| pos++; |
| if (pos >= static_cast<RenderText *>(obj)->textLength()) { |
| obj = bidiNext(block, obj, bidi); |
| pos = 0; |
| } |
| } else { |
| obj = bidiNext(block, obj, bidi); |
| pos = 0; |
| } |
| } |
| |
| inline bool BidiIterator::atEnd() const |
| { |
| return !obj; |
| } |
| |
| UChar BidiIterator::current() const |
| { |
| if (!obj || !obj->isText()) |
| return 0; |
| |
| RenderText* text = static_cast<RenderText*>(obj); |
| if (!text->characters()) |
| return 0; |
| |
| return text->characters()[pos]; |
| } |
| |
| ALWAYS_INLINE Direction BidiIterator::direction() const |
| { |
| if (!obj) |
| return OtherNeutral; |
| if (obj->isListMarker()) |
| return obj->style()->direction() == LTR ? LeftToRight : RightToLeft; |
| if (!obj->isText()) |
| return OtherNeutral; |
| RenderText* renderTxt = static_cast<RenderText*>(obj); |
| if (pos >= renderTxt->textLength()) |
| return OtherNeutral; |
| return Unicode::direction(renderTxt->characters()[pos]); |
| } |
| |
| // ------------------------------------------------------------------------------------------------- |
| |
| template <> |
| inline void BidiState::addRun(BidiRun* bidiRun) |
| { |
| if (!m_firstRun) |
| m_firstRun = bidiRun; |
| else |
| m_lastRun->m_next = bidiRun; |
| m_lastRun = bidiRun; |
| m_runCount++; |
| |
| sLogicallyLastBidiRun = bidiRun; |
| |
| // Compute the number of spaces in this run, |
| if (bidiRun->obj && bidiRun->obj->isText()) { |
| RenderText* text = static_cast<RenderText*>(bidiRun->obj); |
| if (text->characters()) { |
| for (int i = bidiRun->m_start; i < bidiRun->m_stop; i++) { |
| UChar c = text->characters()[i]; |
| if (c == ' ' || c == '\n' || c == '\t') |
| numSpaces++; |
| } |
| } |
| } |
| } |
| |
| static void chopMidpointsAt(RenderObject* obj, unsigned pos) |
| { |
| if (!sNumMidpoints) |
| return; |
| BidiIterator* midpoints = smidpoints->data(); |
| for (unsigned i = 0; i < sNumMidpoints; i++) { |
| const BidiIterator& point = midpoints[i]; |
| if (point.obj == obj && point.pos == pos) { |
| sNumMidpoints = i; |
| break; |
| } |
| } |
| } |
| |
| static void checkMidpoints(BidiIterator& lBreak, BidiState& bidi) |
| { |
| // Check to see if our last midpoint is a start point beyond the line break. If so, |
| // shave it off the list, and shave off a trailing space if the previous end point doesn't |
| // preserve whitespace. |
| if (lBreak.obj && sNumMidpoints && sNumMidpoints%2 == 0) { |
| BidiIterator* midpoints = smidpoints->data(); |
| BidiIterator& endpoint = midpoints[sNumMidpoints-2]; |
| const BidiIterator& startpoint = midpoints[sNumMidpoints-1]; |
| BidiIterator currpoint = endpoint; |
| while (!currpoint.atEnd() && currpoint != startpoint && currpoint != lBreak) |
| currpoint.increment(bidi); |
| if (currpoint == lBreak) { |
| // We hit the line break before the start point. Shave off the start point. |
| sNumMidpoints--; |
| if (endpoint.obj->style()->collapseWhiteSpace()) { |
| if (endpoint.obj->isText()) { |
| // Don't shave a character off the endpoint if it was from a soft hyphen. |
| RenderText* textObj = static_cast<RenderText*>(endpoint.obj); |
| if (endpoint.pos + 1 < textObj->textLength()) { |
| if (textObj->characters()[endpoint.pos+1] == softHyphen) |
| return; |
| } else if (startpoint.obj->isText()) { |
| RenderText *startText = static_cast<RenderText*>(startpoint.obj); |
| if (startText->textLength() && startText->characters()[0] == softHyphen) |
| return; |
| } |
| } |
| endpoint.pos--; |
| } |
| } |
| } |
| } |
| |
| static void addMidpoint(const BidiIterator& midpoint) |
| { |
| if (!smidpoints) |
| return; |
| |
| if (smidpoints->size() <= sNumMidpoints) |
| smidpoints->grow(sNumMidpoints + 10); |
| |
| BidiIterator* midpoints = smidpoints->data(); |
| midpoints[sNumMidpoints++] = midpoint; |
| } |
| |
| static void appendRunsForObject(int start, int end, RenderObject* obj, BidiState& bidi) |
| { |
| if (start > end || obj->isFloating() || |
| (obj->isPositioned() && !obj->hasStaticX() && !obj->hasStaticY() && !obj->container()->isInlineFlow())) |
| return; |
| |
| bool haveNextMidpoint = (smidpoints && sCurrMidpoint < sNumMidpoints); |
| BidiIterator nextMidpoint; |
| if (haveNextMidpoint) |
| nextMidpoint = smidpoints->at(sCurrMidpoint); |
| if (betweenMidpoints) { |
| if (!(haveNextMidpoint && nextMidpoint.obj == obj)) |
| return; |
| // This is a new start point. Stop ignoring objects and |
| // adjust our start. |
| betweenMidpoints = false; |
| start = nextMidpoint.pos; |
| sCurrMidpoint++; |
| if (start < end) |
| return appendRunsForObject(start, end, obj, bidi); |
| } |
| else { |
| if (!smidpoints || !haveNextMidpoint || (obj != nextMidpoint.obj)) { |
| bidi.addRun(new (obj->renderArena()) BidiRun(start, end, obj, bidi.context(), bidi.dir())); |
| return; |
| } |
| |
| // An end midpoint has been encountered within our object. We |
| // need to go ahead and append a run with our endpoint. |
| if (int(nextMidpoint.pos+1) <= end) { |
| betweenMidpoints = true; |
| sCurrMidpoint++; |
| if (nextMidpoint.pos != UINT_MAX) { // UINT_MAX means stop at the object and don't include any of it. |
| if (int(nextMidpoint.pos+1) > start) |
| bidi.addRun(new (obj->renderArena()) |
| BidiRun(start, nextMidpoint.pos+1, obj, bidi.context(), bidi.dir())); |
| return appendRunsForObject(nextMidpoint.pos+1, end, obj, bidi); |
| } |
| } |
| else |
| bidi.addRun(new (obj->renderArena()) BidiRun(start, end, obj, bidi.context(), bidi.dir())); |
| } |
| } |
| |
| template <> |
| void BidiState::appendRun() |
| { |
| if (emptyRun || eor.atEnd()) |
| return; |
| bool b = m_adjustEmbedding; |
| m_adjustEmbedding = false; |
| |
| int start = sor.pos; |
| RenderObject *obj = sor.obj; |
| while (obj && obj != eor.obj && obj != endOfLine.obj) { |
| appendRunsForObject(start, obj->length(), obj, *this); |
| start = 0; |
| obj = bidiNext(sor.block, obj, *this); |
| } |
| if (obj) { |
| unsigned pos = obj == eor.obj ? eor.pos : UINT_MAX; |
| if (obj == endOfLine.obj && endOfLine.pos <= pos) { |
| reachedEndOfLine = true; |
| pos = endOfLine.pos; |
| } |
| // It's OK to add runs for zero-length RenderObjects, just don't make the run larger than it should be |
| int end = obj->length() ? pos+1 : 0; |
| appendRunsForObject(start, end, obj, *this); |
| } |
| |
| eor.increment(*this); |
| sor = eor; |
| m_direction = OtherNeutral; |
| m_status.eor = OtherNeutral; |
| m_adjustEmbedding = b; |
| } |
| |
| InlineFlowBox* RenderBlock::createLineBoxes(RenderObject* obj) |
| { |
| // See if we have an unconstructed line box for this object that is also |
| // the last item on the line. |
| unsigned lineDepth = 1; |
| InlineFlowBox* childBox = 0; |
| InlineFlowBox* parentBox = 0; |
| InlineFlowBox* result = 0; |
| do { |
| ASSERT(obj->isInlineFlow() || obj == this); |
| RenderFlow* flow = static_cast<RenderFlow*>(obj); |
| |
| // Get the last box we made for this render object. |
| parentBox = flow->lastLineBox(); |
| |
| // If this box is constructed then it is from a previous line, and we need |
| // to make a new box for our line. If this box is unconstructed but it has |
| // something following it on the line, then we know we have to make a new box |
| // as well. In this situation our inline has actually been split in two on |
| // the same line (this can happen with very fancy language mixtures). |
| bool constructedNewBox = false; |
| if (!parentBox || parentBox->isConstructed() || parentBox->nextOnLine()) { |
| // We need to make a new box for this render object. Once |
| // made, we need to place it at the end of the current line. |
| InlineBox* newBox = obj->createInlineBox(false, obj == this); |
| ASSERT(newBox->isInlineFlowBox()); |
| parentBox = static_cast<InlineFlowBox*>(newBox); |
| parentBox->setFirstLineStyleBit(m_firstLine); |
| constructedNewBox = true; |
| } |
| |
| if (!result) |
| result = parentBox; |
| |
| // If we have hit the block itself, then |box| represents the root |
| // inline box for the line, and it doesn't have to be appended to any parent |
| // inline. |
| if (childBox) |
| parentBox->addToLine(childBox); |
| |
| if (!constructedNewBox || obj == this) |
| break; |
| |
| childBox = parentBox; |
| |
| // If we've exceeded our line depth, then jump straight to the root and skip all the remaining |
| // intermediate inline flows. |
| obj = (++lineDepth >= cMaxLineDepth) ? this : obj->parent(); |
| |
| } while (true); |
| |
| return result; |
| } |
| |
| RootInlineBox* RenderBlock::constructLine(const BidiIterator& start, const BidiIterator& end) |
| { |
| if (!sFirstBidiRun) |
| return 0; // We had no runs. Don't make a root inline box at all. The line is empty. |
| |
| InlineFlowBox* parentBox = 0; |
| for (BidiRun* r = sFirstBidiRun; r; r = r->next()) { |
| // Create a box for our object. |
| bool isOnlyRun = (sBidiRunCount == 1); |
| if (sBidiRunCount == 2 && !r->obj->isListMarker()) |
| isOnlyRun = ((style()->direction() == RTL) ? sLastBidiRun : sFirstBidiRun)->obj->isListMarker(); |
| r->box = r->obj->createInlineBox(r->obj->isPositioned(), false, isOnlyRun); |
| if (r->box) { |
| // If we have no parent box yet, or if the run is not simply a sibling, |
| // then we need to construct inline boxes as necessary to properly enclose the |
| // run's inline box. |
| if (!parentBox || parentBox->object() != r->obj->parent()) |
| // Create new inline boxes all the way back to the appropriate insertion point. |
| parentBox = createLineBoxes(r->obj->parent()); |
| |
| // Append the inline box to this line. |
| parentBox->addToLine(r->box); |
| |
| if (r->box->isInlineTextBox()) { |
| InlineTextBox *text = static_cast<InlineTextBox*>(r->box); |
| text->setStart(r->m_start); |
| text->setLen(r->m_stop - r->m_start); |
| bool visuallyOrdered = r->obj->style()->visuallyOrdered(); |
| text->m_reversed = r->reversed(visuallyOrdered); |
| text->m_dirOverride = r->dirOverride(visuallyOrdered); |
| } |
| } |
| } |
| |
| // We should have a root inline box. It should be unconstructed and |
| // be the last continuation of our line list. |
| ASSERT(lastLineBox() && !lastLineBox()->isConstructed()); |
| |
| // Set bits on our inline flow boxes that indicate which sides should |
| // paint borders/margins/padding. This knowledge will ultimately be used when |
| // we determine the horizontal positions and widths of all the inline boxes on |
| // the line. |
| RenderObject* endObject = 0; |
| bool lastLine = !end.obj; |
| if (end.obj && end.pos == 0) |
| endObject = end.obj; |
| lastLineBox()->determineSpacingForFlowBoxes(lastLine, endObject); |
| |
| // Now mark the line boxes as being constructed. |
| lastLineBox()->setConstructed(); |
| |
| // Return the last line. |
| return lastRootBox(); |
| } |
| |
| void RenderBlock::computeHorizontalPositionsForLine(RootInlineBox* lineBox, bool reachedEnd) |
| { |
| // First determine our total width. |
| int availableWidth = lineWidth(m_height); |
| int totWidth = lineBox->getFlowSpacingWidth(); |
| BidiRun* r = 0; |
| bool needsWordSpacing = false; |
| for (r = sFirstBidiRun; r; r = r->next()) { |
| if (!r->box || r->obj->isPositioned() || r->box->isLineBreak()) |
| continue; // Positioned objects are only participating to figure out their |
| // correct static x position. They have no effect on the width. |
| // Similarly, line break boxes have no effect on the width. |
| if (r->obj->isText()) { |
| RenderText* rt = static_cast<RenderText*>(r->obj); |
| int textWidth = rt->width(r->m_start, r->m_stop - r->m_start, totWidth, m_firstLine); |
| int rtLength = rt->textLength(); |
| if (rtLength != 0) { |
| if (!r->compact && !r->m_start && needsWordSpacing && isSpaceOrNewline(rt->characters()[r->m_start])) |
| totWidth += rt->style(m_firstLine)->font().wordSpacing(); |
| needsWordSpacing = !isSpaceOrNewline(rt->characters()[r->m_stop - 1]) && r->m_stop == rtLength; |
| } |
| r->box->setWidth(textWidth); |
| } else if (!r->obj->isInlineFlow()) { |
| r->obj->calcWidth(); |
| r->box->setWidth(r->obj->width()); |
| if (!r->compact) |
| totWidth += r->obj->marginLeft() + r->obj->marginRight(); |
| } |
| |
| // Compacts don't contribute to the width of the line, since they are placed in the margin. |
| if (!r->compact) |
| totWidth += r->box->width(); |
| } |
| |
| if (totWidth > availableWidth && sLogicallyLastBidiRun->obj->style(m_firstLine)->autoWrap() && |
| sLogicallyLastBidiRun->obj->style(m_firstLine)->breakOnlyAfterWhiteSpace() && |
| !sLogicallyLastBidiRun->compact) { |
| sLogicallyLastBidiRun->box->setWidth(sLogicallyLastBidiRun->box->width() - totWidth + availableWidth); |
| totWidth = availableWidth; |
| } |
| |
| // Armed with the total width of the line (without justification), |
| // we now examine our text-align property in order to determine where to position the |
| // objects horizontally. The total width of the line can be increased if we end up |
| // justifying text. |
| int x = leftOffset(m_height); |
| switch(style()->textAlign()) { |
| case LEFT: |
| case WEBKIT_LEFT: |
| // The direction of the block should determine what happens with wide lines. In |
| // particular with RTL blocks, wide lines should still spill out to the left. |
| if (style()->direction() == RTL && totWidth > availableWidth) |
| x -= (totWidth - availableWidth); |
| numSpaces = 0; |
| break; |
| case JUSTIFY: |
| if (numSpaces != 0 && !reachedEnd && !lineBox->endsWithBreak()) |
| break; |
| // fall through |
| case TAAUTO: |
| numSpaces = 0; |
| // for right to left fall through to right aligned |
| if (style()->direction() == LTR) |
| break; |
| case RIGHT: |
| case WEBKIT_RIGHT: |
| // Wide lines spill out of the block based off direction. |
| // So even if text-align is right, if direction is LTR, wide lines should overflow out of the right |
| // side of the block. |
| if (style()->direction() == RTL || totWidth < availableWidth) |
| x += availableWidth - totWidth; |
| numSpaces = 0; |
| break; |
| case CENTER: |
| case WEBKIT_CENTER: |
| int xd = (availableWidth - totWidth)/2; |
| x += xd > 0 ? xd : 0; |
| numSpaces = 0; |
| break; |
| } |
| |
| if (numSpaces > 0) { |
| for (r = sFirstBidiRun; r; r = r->next()) { |
| if (!r->box) continue; |
| |
| int spaceAdd = 0; |
| if (numSpaces > 0 && r->obj->isText() && !r->compact) { |
| // get the number of spaces in the run |
| int spaces = 0; |
| for (int i = r->m_start; i < r->m_stop; i++) { |
| UChar c = static_cast<RenderText*>(r->obj)->characters()[i]; |
| if (c == ' ' || c == '\n' || c == '\t') |
| spaces++; |
| } |
| |
| ASSERT(spaces <= numSpaces); |
| |
| // Only justify text if whitespace is collapsed. |
| if (r->obj->style()->collapseWhiteSpace()) { |
| spaceAdd = (availableWidth - totWidth)*spaces/numSpaces; |
| static_cast<InlineTextBox*>(r->box)->setSpaceAdd(spaceAdd); |
| totWidth += spaceAdd; |
| } |
| numSpaces -= spaces; |
| } |
| } |
| } |
| |
| // The widths of all runs are now known. We can now place every inline box (and |
| // compute accurate widths for the inline flow boxes). |
| int leftPosition = x; |
| int rightPosition = x; |
| needsWordSpacing = false; |
| lineBox->placeBoxesHorizontally(x, leftPosition, rightPosition, needsWordSpacing); |
| lineBox->setHorizontalOverflowPositions(leftPosition, rightPosition); |
| } |
| |
| void RenderBlock::computeVerticalPositionsForLine(RootInlineBox* lineBox) |
| { |
| lineBox->verticallyAlignBoxes(m_height); |
| lineBox->setBlockHeight(m_height); |
| |
| // See if the line spilled out. If so set overflow height accordingly. |
| int bottomOfLine = lineBox->bottomOverflow(); |
| if (bottomOfLine > m_height && bottomOfLine > m_overflowHeight) |
| m_overflowHeight = bottomOfLine; |
| |
| // Now make sure we place replaced render objects correctly. |
| for (BidiRun* r = sFirstBidiRun; r; r = r->next()) { |
| if (!r->box) |
| continue; // Skip runs with no line boxes. |
| |
| // Align positioned boxes with the top of the line box. This is |
| // a reasonable approximation of an appropriate y position. |
| if (r->obj->isPositioned()) |
| r->box->setYPos(m_height); |
| |
| // Position is used to properly position both replaced elements and |
| // to update the static normal flow x/y of positioned elements. |
| r->obj->position(r->box); |
| } |
| } |
| |
| // collects one line of the paragraph and transforms it to visual order |
| void RenderBlock::bidiReorderLine(const BidiIterator& start, const BidiIterator& end, BidiState& bidi) |
| { |
| if (start == end) { |
| if (start.current() == '\n') |
| m_height += lineHeight(m_firstLine, true); |
| return; |
| } |
| |
| numSpaces = 0; |
| |
| bidi.createBidiRunsForLine(start, end, style()->visuallyOrdered(), previousLineBrokeCleanly); |
| |
| sFirstBidiRun = bidi.firstRun(); |
| sLastBidiRun = bidi.lastRun(); |
| sBidiRunCount = bidi.runCount(); |
| } |
| |
| static void buildCompactRuns(RenderObject* compactObj, BidiState& bidi) |
| { |
| ASSERT(compactObj->isRenderBlock()); |
| ASSERT(!bidi.firstRun()); |
| |
| // Format the compact like it is its own single line. We build up all the runs for |
| // the little compact and then reorder them for bidi. |
| RenderBlock* compactBlock = static_cast<RenderBlock*>(compactObj); |
| bidi.setAdjustEmbedding(true); |
| BidiIterator start(compactBlock, bidiFirst(compactBlock, bidi), 0); |
| bidi.setAdjustEmbedding(false); |
| BidiIterator end = start; |
| |
| betweenMidpoints = false; |
| isLineEmpty = true; |
| previousLineBrokeCleanly = true; |
| |
| end = compactBlock->findNextLineBreak(start, bidi); |
| if (!isLineEmpty) |
| compactBlock->bidiReorderLine(start, end, bidi); |
| |
| for (BidiRun* run = bidi.firstRun(); run; run = run->next()) |
| run->compact = true; |
| |
| sNumMidpoints = 0; |
| sCurrMidpoint = 0; |
| betweenMidpoints = false; |
| } |
| |
| void RenderBlock::layoutInlineChildren(bool relayoutChildren, int& repaintTop, int& repaintBottom) |
| { |
| BidiState bidi; |
| |
| bool useRepaintBounds = false; |
| |
| invalidateVerticalPosition(); |
| |
| m_overflowHeight = 0; |
| |
| m_height = borderTop() + paddingTop(); |
| int toAdd = borderBottom() + paddingBottom() + horizontalScrollbarHeight(); |
| |
| // Figure out if we should clear out our line boxes. |
| // FIXME: Handle resize eventually! |
| // FIXME: Do something better when floats are present. |
| bool fullLayout = !firstLineBox() || !firstChild() || selfNeedsLayout() || relayoutChildren || containsFloats(); |
| if (fullLayout) |
| deleteLineBoxes(); |
| |
| // Text truncation only kicks in if your overflow isn't visible and your text-overflow-mode isn't |
| // clip. |
| // FIXME: CSS3 says that descendants that are clipped must also know how to truncate. This is insanely |
| // difficult to figure out (especially in the middle of doing layout), and is really an esoteric pile of nonsense |
| // anyway, so we won't worry about following the draft here. |
| bool hasTextOverflow = style()->textOverflow() && hasOverflowClip(); |
| |
| // Walk all the lines and delete our ellipsis line boxes if they exist. |
| if (hasTextOverflow) |
| deleteEllipsisLineBoxes(); |
| |
| if (firstChild()) { |
| // layout replaced elements |
| bool endOfInline = false; |
| RenderObject* o = bidiFirst(this, bidi, false); |
| bool hasFloat = false; |
| while (o) { |
| o->invalidateVerticalPosition(); |
| if (o->isReplaced() || o->isFloating() || o->isPositioned()) { |
| if (relayoutChildren || o->style()->width().isPercent() || o->style()->height().isPercent()) |
| o->setChildNeedsLayout(true, false); |
| |
| // If relayoutChildren is set and we have percentage padding, we also need to invalidate the child's pref widths. |
| if (relayoutChildren && (o->style()->paddingLeft().isPercent() || o->style()->paddingRight().isPercent())) |
| o->setPrefWidthsDirty(true, false); |
| |
| if (o->isPositioned()) |
| o->containingBlock()->insertPositionedObject(o); |
| else { |
| if (o->isFloating()) |
| hasFloat = true; |
| else if (fullLayout || o->needsLayout()) // Replaced elements |
| o->dirtyLineBoxes(fullLayout); |
| o->layoutIfNeeded(); |
| } |
| } |
| else if (o->isText() || (o->isInlineFlow() && !endOfInline)) { |
| if (fullLayout || o->selfNeedsLayout()) |
| o->dirtyLineBoxes(fullLayout); |
| o->setNeedsLayout(false); |
| } |
| o = bidiNext(this, o, bidi, false, &endOfInline); |
| } |
| |
| if (hasFloat) |
| fullLayout = true; // FIXME: Will need to find a way to optimize floats some day. |
| |
| if (fullLayout && !selfNeedsLayout()) { |
| setNeedsLayout(true, false); // Mark ourselves as needing a full layout. This way we'll repaint like |
| // we're supposed to. |
| if (!document()->view()->needsFullRepaint() && m_layer) { |
| // Because we waited until we were already inside layout to discover |
| // that the block really needed a full layout, we missed our chance to repaint the layer |
| // before layout started. Luckily the layer has cached the repaint rect for its original |
| // position and size, and so we can use that to make a repaint happen now. |
| RenderView* c = view(); |
| if (c && !c->printing()) |
| c->repaintViewRectangle(m_layer->repaintRect()); |
| } |
| } |
| |
| BidiContext *startEmbed; |
| if (style()->direction() == LTR |
| #if ENABLE(SVG) |
| || (style()->unicodeBidi() == UBNormal && isSVGText()) |
| #endif |
| ) { |
| startEmbed = new BidiContext(0, LeftToRight, style()->unicodeBidi() == Override); |
| } else { |
| startEmbed = new BidiContext(1, RightToLeft, style()->unicodeBidi() == Override); |
| } |
| |
| bidi.setLastStrongDir(startEmbed->dir()); |
| bidi.setLastDir(startEmbed->dir()); |
| bidi.setEorDir(startEmbed->dir()); |
| bidi.setContext(startEmbed); |
| |
| if (!smidpoints) |
| smidpoints = new Vector<BidiIterator>(); |
| |
| sNumMidpoints = 0; |
| sCurrMidpoint = 0; |
| |
| // We want to skip ahead to the first dirty line |
| BidiIterator start; |
| RootInlineBox* startLine = determineStartPosition(fullLayout, start, bidi); |
| |
| // We also find the first clean line and extract these lines. We will add them back |
| // if we determine that we're able to synchronize after handling all our dirty lines. |
| BidiIterator cleanLineStart; |
| BidiStatus cleanLineBidiStatus; |
| int endLineYPos = 0; |
| RootInlineBox* endLine = (fullLayout || !startLine) ? |
| 0 : determineEndPosition(startLine, cleanLineStart, cleanLineBidiStatus, endLineYPos); |
| |
| if (startLine) { |
| useRepaintBounds = true; |
| repaintTop = m_height; |
| repaintBottom = m_height; |
| RenderArena* arena = renderArena(); |
| RootInlineBox* box = startLine; |
| while (box) { |
| repaintTop = min(repaintTop, box->topOverflow()); |
| repaintBottom = max(repaintBottom, box->bottomOverflow()); |
| RootInlineBox* next = box->nextRootBox(); |
| box->deleteLine(arena); |
| box = next; |
| } |
| startLine = 0; |
| } |
| |
| BidiIterator end = start; |
| |
| bool endLineMatched = false; |
| while (!end.atEnd()) { |
| start = end; |
| if (endLine && (endLineMatched = matchedEndLine(start, bidi.status(), cleanLineStart, cleanLineBidiStatus, endLine, endLineYPos, repaintBottom, repaintTop))) |
| break; |
| |
| betweenMidpoints = false; |
| isLineEmpty = true; |
| if (m_firstLine && firstChild() && firstChild()->isCompact() && firstChild()->isRenderBlock()) { |
| buildCompactRuns(firstChild(), bidi); |
| start.obj = firstChild()->nextSibling(); |
| end = start; |
| } |
| end = findNextLineBreak(start, bidi); |
| if (start.atEnd()) { |
| bidi.deleteRuns(); |
| break; |
| } |
| if (!isLineEmpty) { |
| bidiReorderLine(start, end, bidi); |
| |
| // Now that the runs have been ordered, we create the line boxes. |
| // At the same time we figure out where border/padding/margin should be applied for |
| // inline flow boxes. |
| |
| RootInlineBox* lineBox = 0; |
| if (sBidiRunCount) { |
| lineBox = constructLine(start, end); |
| if (lineBox) { |
| lineBox->setEndsWithBreak(previousLineBrokeCleanly); |
| |
| // Now we position all of our text runs horizontally. |
| computeHorizontalPositionsForLine(lineBox, end.atEnd()); |
| |
| // Now position our text runs vertically. |
| computeVerticalPositionsForLine(lineBox); |
| |
| #if ENABLE(SVG) |
| // Special SVG text layout code |
| lineBox->computePerCharacterLayoutInformation(); |
| #endif |
| |
| #if PLATFORM(MAC) |
| // Highlight acts as an overflow inflation. |
| if (style()->highlight() != nullAtom) |
| lineBox->addHighlightOverflow(); |
| #endif |
| } |
| } |
| |
| bidi.deleteRuns(); |
| |
| if (end == start) { |
| bidi.setAdjustEmbedding(true); |
| end.increment(bidi); |
| bidi.setAdjustEmbedding(false); |
| } |
| |
| if (lineBox) { |
| lineBox->setLineBreakInfo(end.obj, end.pos, bidi.status()); |
| if (useRepaintBounds) { |
| repaintTop = min(repaintTop, lineBox->topOverflow()); |
| repaintBottom = max(repaintBottom, lineBox->bottomOverflow()); |
| } |
| } |
| |
| m_firstLine = false; |
| newLine(); |
| } |
| |
| sNumMidpoints = 0; |
| sCurrMidpoint = 0; |
| } |
| |
| if (endLine) { |
| if (endLineMatched) { |
| // Attach all the remaining lines, and then adjust their y-positions as needed. |
| for (RootInlineBox* line = endLine; line; line = line->nextRootBox()) |
| line->attachLine(); |
| |
| // Now apply the offset to each line if needed. |
| int delta = m_height - endLineYPos; |
| if (delta) { |
| for (RootInlineBox* line = endLine; line; line = line->nextRootBox()) { |
| repaintTop = min(repaintTop, line->topOverflow() + (delta < 0 ? delta : 0)); |
| repaintBottom = max(repaintBottom, line->bottomOverflow() + (delta > 0 ? delta : 0)); |
| line->adjustPosition(0, delta); |
| } |
| } |
| m_height = lastRootBox()->blockHeight(); |
| } else { |
| // Delete all the remaining lines. |
| InlineRunBox* line = endLine; |
| RenderArena* arena = renderArena(); |
| while (line) { |
| repaintTop = min(repaintTop, line->topOverflow()); |
| repaintBottom = max(repaintBottom, line->bottomOverflow()); |
| InlineRunBox* next = line->nextLineBox(); |
| line->deleteLine(arena); |
| line = next; |
| } |
| } |
| } |
| } |
| |
| sNumMidpoints = 0; |
| sCurrMidpoint = 0; |
| |
| // in case we have a float on the last line, it might not be positioned up to now. |
| // This has to be done before adding in the bottom border/padding, or the float will |
| // include the padding incorrectly. -dwh |
| positionNewFloats(); |
| |
| // Now add in the bottom border/padding. |
| m_height += toAdd; |
| |
| // Always make sure this is at least our height. |
| m_overflowHeight = max(m_height, m_overflowHeight); |
| |
| // See if any lines spill out of the block. If so, we need to update our overflow width. |
| checkLinesForOverflow(); |
| |
| if (!firstLineBox() && hasLineIfEmpty()) |
| m_height += lineHeight(true, true); |
| |
| // See if we have any lines that spill out of our block. If we do, then we will possibly need to |
| // truncate text. |
| if (hasTextOverflow) |
| checkLinesForTextOverflow(); |
| } |
| |
| RootInlineBox* RenderBlock::determineStartPosition(bool fullLayout, BidiIterator& start, BidiState& bidi) |
| { |
| RootInlineBox* curr = 0; |
| RootInlineBox* last = 0; |
| RenderObject* startObj = 0; |
| int pos = 0; |
| |
| if (fullLayout) { |
| // Nuke all our lines. |
| if (firstRootBox()) { |
| RenderArena* arena = renderArena(); |
| curr = firstRootBox(); |
| while (curr) { |
| RootInlineBox* next = curr->nextRootBox(); |
| curr->deleteLine(arena); |
| curr = next; |
| } |
| ASSERT(!firstLineBox() && !lastLineBox()); |
| } |
| } else { |
| for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) { } |
| if (curr) { |
| // We have a dirty line. |
| if (RootInlineBox* prevRootBox = curr->prevRootBox()) { |
| // We have a previous line. |
| if (!prevRootBox->endsWithBreak() || prevRootBox->lineBreakObj()->isText() && prevRootBox->lineBreakPos() >= static_cast<RenderText*>(prevRootBox->lineBreakObj())->textLength()) |
| // The previous line didn't break cleanly or broke at a newline |
| // that has been deleted, so treat it as dirty too. |
| curr = prevRootBox; |
| } |
| } else { |
| // No dirty lines were found. |
| // If the last line didn't break cleanly, treat it as dirty. |
| if (lastRootBox() && !lastRootBox()->endsWithBreak()) |
| curr = lastRootBox(); |
| } |
| |
| // If we have no dirty lines, then last is just the last root box. |
| last = curr ? curr->prevRootBox() : lastRootBox(); |
| } |
| |
| m_firstLine = !last; |
| previousLineBrokeCleanly = !last || last->endsWithBreak(); |
| if (last) { |
| m_height = last->blockHeight(); |
| startObj = last->lineBreakObj(); |
| pos = last->lineBreakPos(); |
| bidi.setStatus(last->lineBreakBidiStatus()); |
| } else { |
| bidi.setAdjustEmbedding(true); |
| startObj = bidiFirst(this, bidi, 0); |
| bidi.setAdjustEmbedding(false); |
| } |
| |
| start = BidiIterator(this, startObj, pos); |
| |
| return curr; |
| } |
| |
| RootInlineBox* RenderBlock::determineEndPosition(RootInlineBox* startLine, BidiIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus, int& yPos) |
| { |
| RootInlineBox* last = 0; |
| if (!startLine) |
| last = 0; |
| else { |
| for (RootInlineBox* curr = startLine->nextRootBox(); curr; curr = curr->nextRootBox()) { |
| if (curr->isDirty()) |
| last = 0; |
| else if (!last) |
| last = curr; |
| } |
| } |
| |
| if (!last) |
| return 0; |
| |
| RootInlineBox* prev = last->prevRootBox(); |
| cleanLineStart = BidiIterator(this, prev->lineBreakObj(), prev->lineBreakPos()); |
| cleanLineBidiStatus = prev->lineBreakBidiStatus(); |
| yPos = prev->blockHeight(); |
| |
| for (RootInlineBox* line = last; line; line = line->nextRootBox()) |
| line->extractLine(); // Disconnect all line boxes from their render objects while preserving |
| // their connections to one another. |
| |
| return last; |
| } |
| |
| bool RenderBlock::matchedEndLine(const BidiIterator& start, const BidiStatus& status, |
| const BidiIterator& endLineStart, const BidiStatus& endLineStatus, |
| RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop) |
| { |
| if (start == endLineStart) |
| return status == endLineStatus; |
| else { |
| // The first clean line doesn't match, but we can check a handful of following lines to try |
| // to match back up. |
| static int numLines = 8; // The # of lines we're willing to match against. |
| RootInlineBox* line = endLine; |
| for (int i = 0; i < numLines && line; i++, line = line->nextRootBox()) { |
| if (line->lineBreakObj() == start.obj && line->lineBreakPos() == start.pos) { |
| // We have a match. |
| if (line->lineBreakBidiStatus() != status) |
| return false; // ...but the bidi state doesn't match. |
| RootInlineBox* result = line->nextRootBox(); |
| |
| // Set our yPos to be the block height of endLine. |
| if (result) |
| endYPos = line->blockHeight(); |
| |
| // Now delete the lines that we failed to sync. |
| RootInlineBox* boxToDelete = endLine; |
| RenderArena* arena = renderArena(); |
| while (boxToDelete && boxToDelete != result) { |
| repaintTop = min(repaintTop, boxToDelete->topOverflow()); |
| repaintBottom = max(repaintBottom, boxToDelete->bottomOverflow()); |
| RootInlineBox* next = boxToDelete->nextRootBox(); |
| boxToDelete->deleteLine(arena); |
| boxToDelete = next; |
| } |
| |
| endLine = result; |
| return result; |
| } |
| } |
| } |
| return false; |
| } |
| |
| static inline bool skipNonBreakingSpace(BidiIterator &it) |
| { |
| if (it.obj->style()->nbspMode() != SPACE || it.current() != noBreakSpace) |
| return false; |
| |
| // FIXME: This is bad. It makes nbsp inconsistent with space and won't work correctly |
| // with m_minWidth/m_maxWidth. |
| // Do not skip a non-breaking space if it is the first character |
| // on a line after a clean line break (or on the first line, since previousLineBrokeCleanly starts off |
| // |true|). |
| if (isLineEmpty && previousLineBrokeCleanly) |
| return false; |
| |
| return true; |
| } |
| |
| static inline bool shouldCollapseWhiteSpace(const RenderStyle* style) |
| { |
| return style->collapseWhiteSpace() || (style->whiteSpace() == PRE_WRAP && (!isLineEmpty || !previousLineBrokeCleanly)); |
| } |
| |
| static inline bool shouldPreserveNewline(RenderObject* object) |
| { |
| #if ENABLE(SVG) |
| if (object->isSVGText()) |
| return false; |
| #endif |
| |
| return object->style()->preserveNewline(); |
| } |
| |
| static bool inlineFlowRequiresLineBox(RenderObject* flow) |
| { |
| // FIXME: Right now, we only allow line boxes for inlines that are truly empty. |
| // We need to fix this, though, because at the very least, inlines with only text |
| // children that is all whitespace should should also have line boxes. |
| if (!flow->isInlineFlow() || flow->firstChild()) |
| return false; |
| |
| bool hasPaddingOrMargin = !(flow->paddingLeft() == 0 && flow->paddingRight() == 0 |
| && flow->paddingTop() == 0 && flow->paddingBottom() == 0 |
| && flow->marginLeft() == 0 && flow->marginRight() == 0 |
| && flow->marginTop() == 0 && flow->marginBottom() == 0); |
| if (flow->hasBoxDecorations() || hasPaddingOrMargin) |
| return true; |
| |
| return false; |
| } |
| |
| static inline bool requiresLineBox(BidiIterator& it) |
| { |
| if (it.obj->isFloatingOrPositioned()) |
| return false; |
| |
| if (it.obj->isInlineFlow() && !inlineFlowRequiresLineBox(it.obj)) |
| return false; |
| |
| if (!shouldCollapseWhiteSpace(it.obj->style()) || it.obj->isBR()) |
| return true; |
| |
| UChar current = it.current(); |
| return current != ' ' && current != '\t' && current != softHyphen && (current != '\n' || shouldPreserveNewline(it.obj)) && !skipNonBreakingSpace(it); |
| } |
| |
| bool RenderBlock::generatesLineBoxesForInlineChild(RenderObject* inlineObj) |
| { |
| ASSERT(inlineObj->parent() == this); |
| |
| BidiIterator it(this, inlineObj, 0); |
| BidiState state; |
| while (!it.atEnd() && !requiresLineBox(it)) |
| it.increment(state); |
| |
| return !it.atEnd(); |
| } |
| |
| int RenderBlock::skipWhitespace(BidiIterator &it, BidiState &bidi) |
| { |
| // FIXME: The entire concept of the skipWhitespace function is flawed, since we really need to be building |
| // line boxes even for containers that may ultimately collapse away. Otherwise we'll never get positioned |
| // elements quite right. In other words, we need to build this function's work into the normal line |
| // object iteration process. |
| int w = lineWidth(m_height); |
| bidi.setAdjustEmbedding(true); |
| |
| while (!it.atEnd() && !requiresLineBox(it)) { |
| if (it.obj->isFloatingOrPositioned()) { |
| RenderObject *o = it.obj; |
| // add to special objects... |
| if (o->isFloating()) { |
| insertFloatingObject(o); |
| positionNewFloats(); |
| w = lineWidth(m_height); |
| } |
| else if (o->isPositioned()) { |
| // FIXME: The math here is actually not really right. It's a best-guess approximation that |
| // will work for the common cases |
| RenderObject* c = o->container(); |
| if (c->isInlineFlow()) { |
| // A relative positioned inline encloses us. In this case, we also have to determine our |
| // position as though we were an inline. Set |staticX| and |staticY| on the relative positioned |
| // inline so that we can obtain the value later. |
| c->setStaticX(style()->direction() == LTR ? |
| leftOffset(m_height) : rightOffset(m_height)); |
| c->setStaticY(m_height); |
| } |
| |
| if (o->hasStaticX()) { |
| bool wasInline = o->style()->isOriginalDisplayInlineType(); |
| if (wasInline) |
| o->setStaticX(style()->direction() == LTR ? |
| leftOffset(m_height) : |
| width() - rightOffset(m_height)); |
| else |
| o->setStaticX(style()->direction() == LTR ? |
| borderLeft() + paddingLeft() : |
| borderRight() + paddingRight()); |
| } |
| if (o->hasStaticY()) |
| o->setStaticY(m_height); |
| } |
| } |
| it.increment(bidi); |
| } |
| |
| bidi.setAdjustEmbedding(false); |
| return w; |
| } |
| |
| // This is currently just used for list markers and inline flows that have line boxes. Neither should |
| // have an effect on whitespace at the start of the line. |
| static bool shouldSkipWhitespaceAfterStartObject(RenderBlock* block, RenderObject* o, BidiState &bidi) |
| { |
| RenderObject* next = bidiNext(block, o, bidi); |
| if (next && !next->isBR() && next->isText() && static_cast<RenderText*>(next)->textLength() > 0) { |
| RenderText* nextText = static_cast<RenderText*>(next); |
| UChar nextChar = nextText->characters()[0]; |
| if (nextText->style()->isCollapsibleWhiteSpace(nextChar)) { |
| BidiIterator endMid(0, o, 0); |
| addMidpoint(endMid); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| BidiIterator RenderBlock::findNextLineBreak(BidiIterator &start, BidiState &bidi) |
| { |
| // eliminate spaces at beginning of line |
| int width = skipWhitespace(start, bidi); |
| int w = 0; |
| int tmpW = 0; |
| |
| if (start.atEnd()) |
| return start; |
| |
| // This variable is used only if whitespace isn't set to PRE, and it tells us whether |
| // or not we are currently ignoring whitespace. |
| bool ignoringSpaces = false; |
| BidiIterator ignoreStart; |
| |
| // This variable tracks whether the very last character we saw was a space. We use |
| // this to detect when we encounter a second space so we know we have to terminate |
| // a run. |
| bool currentCharacterIsSpace = false; |
| bool currentCharacterIsWS = false; |
| RenderObject* trailingSpaceObject = 0; |
| |
| BidiIterator lBreak = start; |
| |
| RenderObject *o = start.obj; |
| RenderObject *last = o; |
| RenderObject *previous = o; |
| int pos = start.pos; |
| bool atStart = true; |
| |
| bool prevLineBrokeCleanly = previousLineBrokeCleanly; |
| previousLineBrokeCleanly = false; |
| |
| bool autoWrapWasEverTrueOnLine = false; |
| |
| // Firefox and Opera will allow a table cell to grow to fit an image inside it under |
| // very specific cirucumstances (in order to match common WinIE renderings). |
| // Not supporting the quirk has caused us to mis-render some real sites. (See Bugzilla 10517.) |
| bool allowImagesToBreak = !style()->htmlHacks() || !isTableCell() || !style()->width().isIntrinsicOrAuto(); |
| |
| EWhiteSpace currWS = style()->whiteSpace(); |
| EWhiteSpace lastWS = currWS; |
| while (o) { |
| currWS = o->isReplaced() ? o->parent()->style()->whiteSpace() : o->style()->whiteSpace(); |
| lastWS = last->isReplaced() ? last->parent()->style()->whiteSpace() : last->style()->whiteSpace(); |
| |
| bool autoWrap = RenderStyle::autoWrap(currWS); |
| autoWrapWasEverTrueOnLine = autoWrapWasEverTrueOnLine || autoWrap; |
| |
| #if ENABLE(SVG) |
| bool preserveNewline = o->isSVGText() ? false : RenderStyle::preserveNewline(currWS); |
| #else |
| bool preserveNewline = RenderStyle::preserveNewline(currWS); |
| #endif |
| |
| bool collapseWhiteSpace = RenderStyle::collapseWhiteSpace(currWS); |
| |
| if (o->isBR()) { |
| if (w + tmpW <= width) { |
| lBreak.obj = o; |
| lBreak.pos = 0; |
| lBreak.increment(bidi); |
| |
| // A <br> always breaks a line, so don't let the line be collapsed |
| // away. Also, the space at the end of a line with a <br> does not |
| // get collapsed away. It only does this if the previous line broke |
| // cleanly. Otherwise the <br> has no effect on whether the line is |
| // empty or not. |
| if (prevLineBrokeCleanly) |
| isLineEmpty = false; |
| trailingSpaceObject = 0; |
| previousLineBrokeCleanly = true; |
| |
| if (!isLineEmpty) { |
| // only check the clear status for non-empty lines. |
| EClear clear = o->style()->clear(); |
| if (clear != CNONE) |
| m_clearStatus = (EClear) (m_clearStatus | clear); |
| } |
| } |
| goto end; |
| } |
| |
| if (o->isFloatingOrPositioned()) { |
| // add to special objects... |
| if (o->isFloating()) { |
| insertFloatingObject(o); |
| // check if it fits in the current line. |
| // If it does, position it now, otherwise, position |
| // it after moving to next line (in newLine() func) |
| if (o->width() + o->marginLeft() + o->marginRight() + w + tmpW <= width) { |
| positionNewFloats(); |
| width = lineWidth(m_height); |
| } |
| } else if (o->isPositioned()) { |
| // If our original display wasn't an inline type, then we can |
| // go ahead and determine our static x position now. |
| bool isInlineType = o->style()->isOriginalDisplayInlineType(); |
| bool needToSetStaticX = o->hasStaticX(); |
| if (o->hasStaticX() && !isInlineType) { |
| o->setStaticX(o->parent()->style()->direction() == LTR ? |
| borderLeft() + paddingLeft() : |
| borderRight() + paddingRight()); |
| needToSetStaticX = false; |
| } |
| |
| // If our original display was an INLINE type, then we can go ahead |
| // and determine our static y position now. |
| bool needToSetStaticY = o->hasStaticY(); |
| if (o->hasStaticY() && isInlineType) { |
| o->setStaticY(m_height); |
| needToSetStaticY = false; |
| } |
| |
| bool needToCreateLineBox = needToSetStaticX || needToSetStaticY; |
| RenderObject* c = o->container(); |
| if (c->isInlineFlow() && (!needToSetStaticX || !needToSetStaticY)) |
| needToCreateLineBox = true; |
| |
| // If we're ignoring spaces, we have to stop and include this object and |
| // then start ignoring spaces again. |
| if (needToCreateLineBox) { |
| trailingSpaceObject = 0; |
| ignoreStart.obj = o; |
| ignoreStart.pos = 0; |
| if (ignoringSpaces) { |
| addMidpoint(ignoreStart); // Stop ignoring spaces. |
| addMidpoint(ignoreStart); // Start ignoring again. |
| } |
| |
| } |
| } |
| } else if (o->isInlineFlow()) { |
| // Right now, we should only encounter empty inlines here. |
| ASSERT(!o->firstChild()); |
| |
| // Now that some inline flows have line boxes, if we are already ignoring spaces, we need |
| // to make sure that we stop to include this object and then start ignoring spaces again. |
| // If this object is at the start of the line, we need to behave like list markers and |
| // start ignoring spaces. |
| if (inlineFlowRequiresLineBox(o)) { |
| if (ignoringSpaces) { |
| trailingSpaceObject = 0; |
| addMidpoint(BidiIterator(0, o, 0)); // Stop ignoring spaces. |
| addMidpoint(BidiIterator(0, o, 0)); // Start ignoring again. |
| } else if (style()->collapseWhiteSpace() && start.obj == o |
| && shouldSkipWhitespaceAfterStartObject(start.block, o, bidi)) { |
| // Like with list markers, we start ignoring spaces to make sure that any |
| // additional spaces we see will be discarded. |
| currentCharacterIsSpace = true; |
| currentCharacterIsWS = true; |
| ignoringSpaces = true; |
| } |
| } |
| |
| if (static_cast<RenderFlow*>(o)->isWordBreak()) { |
| w += tmpW; |
| tmpW = 0; |
| lBreak.obj = o; |
| lBreak.pos = 0; |
| } |
| tmpW += o->marginLeft() + o->borderLeft() + o->paddingLeft() + |
| o->marginRight() + o->borderRight() + o->paddingRight(); |
| } else if (o->isReplaced()) { |
| // Break on replaced elements if either has normal white-space. |
| if ((autoWrap || RenderStyle::autoWrap(lastWS)) && (!o->isImage() || allowImagesToBreak)) { |
| w += tmpW; |
| tmpW = 0; |
| lBreak.obj = o; |
| lBreak.pos = 0; |
| } |
| |
| if (ignoringSpaces) { |
| BidiIterator startMid( 0, o, 0 ); |
| addMidpoint(startMid); |
| } |
| isLineEmpty = false; |
| ignoringSpaces = false; |
| currentCharacterIsSpace = false; |
| currentCharacterIsWS = false; |
| trailingSpaceObject = 0; |
| |
| // Optimize for a common case. If we can't find whitespace after the list |
| // item, then this is all moot. -dwh |
| if (o->isListMarker() && !static_cast<RenderListMarker*>(o)->isInside()) { |
| if (style()->collapseWhiteSpace() && shouldSkipWhitespaceAfterStartObject(start.block, o, bidi)) { |
| // Like with inline flows, we start ignoring spaces to make sure that any |
| // additional spaces we see will be discarded. |
| currentCharacterIsSpace = true; |
| currentCharacterIsWS = true; |
| ignoringSpaces = true; |
| } |
| } else |
| tmpW += o->width() + o->marginLeft() + o->marginRight() + inlineWidth(o); |
| } else if (o->isText()) { |
| RenderText* t = static_cast<RenderText*>(o); |
| int strlen = t->textLength(); |
| int len = strlen - pos; |
| const UChar* str = t->characters(); |
| |
| const Font& f = t->style(m_firstLine)->font(); |
| |
| int lastSpace = pos; |
| int wordSpacing = o->style()->wordSpacing(); |
| int lastSpaceWordSpacing = 0; |
| |
| bool appliedStartWidth = pos > 0; // If the span originated on a previous line, |
| // then assume the start width has been applied. |
| int wrapW = tmpW + inlineWidth(o, !appliedStartWidth, true); |
| int charWidth = 0; |
| int nextBreakable = -1; |
| bool breakNBSP = autoWrap && o->style()->nbspMode() == SPACE; |
| // Auto-wrapping text should wrap in the middle of a word only if it could not wrap before the word, |
| // which is only possible if the word is the first thing on the line, that is, if |w| is zero. |
| bool breakWords = o->style()->breakWords() && ((autoWrap && !w) || currWS == PRE); |
| bool midWordBreak = false; |
| bool breakAll = o->style()->wordBreak() == BreakAllWordBreak && autoWrap; |
| |
| while (len) { |
| bool previousCharacterIsSpace = currentCharacterIsSpace; |
| bool previousCharacterIsWS = currentCharacterIsWS; |
| UChar c = str[pos]; |
| currentCharacterIsSpace = c == ' ' || c == '\t' || (!preserveNewline && (c == '\n')); |
| |
| if (!collapseWhiteSpace || !currentCharacterIsSpace) |
| isLineEmpty = false; |
| |
| // Check for soft hyphens. Go ahead and ignore them. |
| if (c == softHyphen) { |
| if (!ignoringSpaces) { |
| // Ignore soft hyphens |
| BidiIterator endMid; |
| if (pos > 0) |
| endMid = BidiIterator(0, o, pos - 1); |
| else |
| endMid = BidiIterator(0, previous, previous->isText() ? static_cast<RenderText*>(previous)->textLength() - 1 : 0); |
| // Two consecutive soft hyphens. Avoid overlapping midpoints. |
| if (sNumMidpoints && smidpoints->at(sNumMidpoints - 1).obj == endMid.obj && smidpoints->at(sNumMidpoints - 1).pos > endMid.pos) |
| sNumMidpoints--; |
| else |
| addMidpoint(endMid); |
| |
| // Add the width up to but not including the hyphen. |
| tmpW += t->width(lastSpace, pos - lastSpace, f, w + tmpW) + lastSpaceWordSpacing; |
| |
| // For wrapping text only, include the hyphen. We need to ensure it will fit |
| // on the line if it shows when we break. |
| if (autoWrap) |
| tmpW += t->width(pos, 1, f, w + tmpW); |
| |
| BidiIterator startMid(0, o, pos + 1); |
| addMidpoint(startMid); |
| } |
| |
| pos++; |
| len--; |
| lastSpaceWordSpacing = 0; |
| lastSpace = pos; // Cheesy hack to prevent adding in widths of the run twice. |
| continue; |
| } |
| |
| bool applyWordSpacing = false; |
| |
| currentCharacterIsWS = currentCharacterIsSpace || (breakNBSP && c == noBreakSpace); |
| |
| if ((breakAll || breakWords) && !midWordBreak) { |
| wrapW += charWidth; |
| charWidth = t->width(pos, 1, f, w + wrapW); |
| midWordBreak = w + wrapW + charWidth > width; |
| } |
| |
| bool betweenWords = c == '\n' || (currWS != PRE && !atStart && isBreakable(str, pos, strlen, nextBreakable, breakNBSP)); |
| |
| if (betweenWords || midWordBreak) { |
| bool stoppedIgnoringSpaces = false; |
| if (ignoringSpaces) { |
| if (!currentCharacterIsSpace) { |
| // Stop ignoring spaces and begin at this |
| // new point. |
| ignoringSpaces = false; |
| lastSpaceWordSpacing = 0; |
| lastSpace = pos; // e.g., "Foo goo", don't add in any of the ignored spaces. |
| BidiIterator startMid(0, o, pos); |
| addMidpoint(startMid); |
| stoppedIgnoringSpaces = true; |
| } else { |
| // Just keep ignoring these spaces. |
| pos++; |
| len--; |
| continue; |
| } |
| } |
| |
| int additionalTmpW = t->width(lastSpace, pos - lastSpace, f, w+tmpW) + lastSpaceWordSpacing; |
| tmpW += additionalTmpW; |
| if (!appliedStartWidth) { |
| tmpW += inlineWidth(o, true, false); |
| appliedStartWidth = true; |
| } |
| |
| applyWordSpacing = wordSpacing && currentCharacterIsSpace && !previousCharacterIsSpace; |
| |
| if (autoWrap && w + tmpW > width && !w) { |
| int fb = nearestFloatBottom(m_height); |
| int newLineWidth = lineWidth(fb); |
| // See if |tmpW| will fit on the new line. As long as it does not, |
| // keep adjusting our float bottom until we find some room. |
| int lastFloatBottom = m_height; |
| while (lastFloatBottom < fb && tmpW > newLineWidth) { |
| lastFloatBottom = fb; |
| fb = nearestFloatBottom(fb); |
| newLineWidth = lineWidth(fb); |
| } |
| |
| if (!w && m_height < fb && width < newLineWidth) { |
| m_height = fb; |
| width = newLineWidth; |
| } |
| } |
| |
| if (autoWrap || breakWords) { |
| // If we break only after white-space, consider the current character |
| // as candidate width for this line. |
| bool lineWasTooWide = false; |
| if (w + tmpW <= width && currentCharacterIsWS && o->style()->breakOnlyAfterWhiteSpace() && !midWordBreak) { |
| int charWidth = t->width(pos, 1, f, w + tmpW) + (applyWordSpacing ? wordSpacing : 0); |
| // Check if line is too big even without the extra space |
| // at the end of the line. If it is not, do nothing. |
| // If the line needs the extra whitespace to be too long, |
| // then move the line break to the space and skip all |
| // additional whitespace. |
| if (w + tmpW + charWidth > width) { |
| lineWasTooWide = true; |
| lBreak.obj = o; |
| lBreak.pos = pos; |
| if (pos > 0) { |
| // Separate the trailing space into its own box, which we will |
| // resize to fit on the line in computeHorizontalPositionsForLine(). |
| BidiIterator midpoint(0, o, pos); |
| addMidpoint(BidiIterator(0, o, pos-1)); // Stop |
| addMidpoint(BidiIterator(0, o, pos)); // Start |
| } |
| skipWhitespace(lBreak, bidi); |
| } |
| } |
| if (lineWasTooWide || w + tmpW > width) { |
| if (lBreak.obj && shouldPreserveNewline(lBreak.obj) && lBreak.obj->isText() && static_cast<RenderText*>(lBreak.obj)->characters()[lBreak.pos] == '\n') { |
| if (!stoppedIgnoringSpaces && pos > 0) { |
| // We need to stop right before the newline and then start up again. |
| BidiIterator midpoint(0, o, pos); |
| addMidpoint(BidiIterator(0, o, pos-1)); // Stop |
| addMidpoint(BidiIterator(0, o, pos)); // Start |
| } |
| lBreak.increment(bidi); |
| previousLineBrokeCleanly = true; |
| } |
| goto end; // Didn't fit. Jump to the end. |
| } else { |
| if (!betweenWords || (midWordBreak && !autoWrap)) |
| tmpW -= additionalTmpW; |
| if (pos > 0 && str[pos-1] == softHyphen) |
| // Subtract the width of the soft hyphen out since we fit on a line. |
| tmpW -= t->width(pos-1, 1, f, w+tmpW); |
| } |
| } |
| |
| if (c == '\n' && preserveNewline) { |
| if (!stoppedIgnoringSpaces && pos > 0) { |
| // We need to stop right before the newline and then start up again. |
| BidiIterator midpoint(0, o, pos); |
| addMidpoint(BidiIterator(0, o, pos-1)); // Stop |
| addMidpoint(BidiIterator(0, o, pos)); // Start |
| } |
| lBreak.obj = o; |
| lBreak.pos = pos; |
| lBreak.increment(bidi); |
| previousLineBrokeCleanly = true; |
| return lBreak; |
| } |
| |
| if (autoWrap && betweenWords) { |
| w += tmpW; |
| wrapW = 0; |
| tmpW = 0; |
| lBreak.obj = o; |
| lBreak.pos = pos; |
| // Auto-wrapping text should not wrap in the middle of a word once it has had an |
| // opportunity to break after a word. |
| breakWords = false; |
| } |
| |
| if (midWordBreak) { |
| // Remember this as a breakable position in case |
| // adding the end width forces a break. |
| lBreak.obj = o; |
| lBreak.pos = pos; |
| midWordBreak &= (breakWords || breakAll); |
| } |
| |
| if (betweenWords) { |
| lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0; |
| lastSpace = pos; |
| } |
| |
| if (!ignoringSpaces && o->style()->collapseWhiteSpace()) { |
| // If we encounter a newline, or if we encounter a |
| // second space, we need to go ahead and break up this |
| // run and enter a mode where we start collapsing spaces. |
| if (currentCharacterIsSpace && previousCharacterIsSpace) { |
| ignoringSpaces = true; |
| |
| // We just entered a mode where we are ignoring |
| // spaces. Create a midpoint to terminate the run |
| // before the second space. |
| addMidpoint(ignoreStart); |
| } |
| } |
| } else if (ignoringSpaces) { |
| // Stop ignoring spaces and begin at this |
| // new point. |
| ignoringSpaces = false; |
| lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0; |
| lastSpace = pos; // e.g., "Foo goo", don't add in any of the ignored spaces. |
| BidiIterator startMid(0, o, pos); |
| addMidpoint(startMid); |
| } |
| |
| if (currentCharacterIsSpace && !previousCharacterIsSpace) { |
| ignoreStart.obj = o; |
| ignoreStart.pos = pos; |
| } |
| |
| if (!currentCharacterIsWS && previousCharacterIsWS) { |
| if (autoWrap && o->style()->breakOnlyAfterWhiteSpace()) { |
| lBreak.obj = o; |
| lBreak.pos = pos; |
| } |
| } |
| |
| if (collapseWhiteSpace && currentCharacterIsSpace && !ignoringSpaces) |
| trailingSpaceObject = o; |
| else if (!o->style()->collapseWhiteSpace() || !currentCharacterIsSpace) |
| trailingSpaceObject = 0; |
| |
| pos++; |
| len--; |
| atStart = false; |
| } |
| |
| // IMPORTANT: pos is > length here! |
| if (!ignoringSpaces) |
| tmpW += t->width(lastSpace, pos - lastSpace, f, w+tmpW) + lastSpaceWordSpacing; |
| tmpW += inlineWidth(o, !appliedStartWidth, true); |
| } else |
| ASSERT_NOT_REACHED(); |
| |
| RenderObject* next = bidiNext(start.block, o, bidi); |
| bool checkForBreak = autoWrap; |
| if (w && w + tmpW > width && lBreak.obj && currWS == NOWRAP) |
| checkForBreak = true; |
| else if (next && o->isText() && next->isText() && !next->isBR()) { |
| if (autoWrap || (next->style()->autoWrap())) { |
| if (currentCharacterIsSpace) |
| checkForBreak = true; |
| else { |
| checkForBreak = false; |
| RenderText* nextText = static_cast<RenderText*>(next); |
| if (nextText->textLength() != 0) { |
| UChar c = nextText->characters()[0]; |
| if (c == ' ' || c == '\t' || (c == '\n' && !shouldPreserveNewline(next))) |
| // If the next item on the line is text, and if we did not end with |
| // a space, then the next text run continues our word (and so it needs to |
| // keep adding to |tmpW|. Just update and continue. |
| checkForBreak = true; |
| } |
| bool willFitOnLine = (w + tmpW <= width); |
| bool canPlaceOnLine = willFitOnLine || !autoWrapWasEverTrueOnLine; |
| if (canPlaceOnLine && checkForBreak) { |
| w += tmpW; |
| tmpW = 0; |
| lBreak.obj = next; |
| lBreak.pos = 0; |
| } |
| } |
| } |
| } |
| |
| if (checkForBreak && (w + tmpW > width)) { |
| // if we have floats, try to get below them. |
| if (currentCharacterIsSpace && !ignoringSpaces && o->style()->collapseWhiteSpace()) |
| trailingSpaceObject = 0; |
| |
| int fb = nearestFloatBottom(m_height); |
| int newLineWidth = lineWidth(fb); |
| // See if |tmpW| will fit on the new line. As long as it does not, |
| // keep adjusting our float bottom until we find some room. |
| int lastFloatBottom = m_height; |
| while (lastFloatBottom < fb && tmpW > newLineWidth) { |
| lastFloatBottom = fb; |
| fb = nearestFloatBottom(fb); |
| newLineWidth = lineWidth(fb); |
| } |
| if (!w && m_height < fb && width < newLineWidth) { |
| m_height = fb; |
| width = newLineWidth; |
| } |
| |
| // |width| may have been adjusted because we got shoved down past a float (thus |
| // giving us more room), so we need to retest, and only jump to |
| // the end label if we still don't fit on the line. -dwh |
| if (w + tmpW > width) |
| goto end; |
| } |
| |
| last = o; |
| if (!o->isFloating() && (!o->isPositioned() || o->hasStaticX() || o->hasStaticY() || !o->container()->isInlineFlow())) |
| previous = o; |
| o = next; |
| |
| if (!last->isFloatingOrPositioned() && last->isReplaced() && autoWrap && (!last->isImage() || allowImagesToBreak) && |
| (!last->isListMarker() || static_cast<RenderListMarker*>(last)->isInside())) { |
| w += tmpW; |
| tmpW = 0; |
| lBreak.obj = o; |
| lBreak.pos = 0; |
| } |
| |
| // Clear out our character space bool, since inline <pre>s don't collapse whitespace |
| // with adjacent inline normal/nowrap spans. |
| if (!collapseWhiteSpace) |
| currentCharacterIsSpace = false; |
| |
| pos = 0; |
| atStart = false; |
| } |
| |
| |
| if (w + tmpW <= width || lastWS == NOWRAP) { |
| lBreak.obj = 0; |
| lBreak.pos = 0; |
| } |
| |
| end: |
| |
| if (lBreak == start && !lBreak.obj->isBR()) { |
| // we just add as much as possible |
| if (style()->whiteSpace() == PRE) { |
| // FIXME: Don't really understand this case. |
| if (pos != 0) { |
| lBreak.obj = o; |
| lBreak.pos = pos - 1; |
| } else { |
| lBreak.obj = last; |
| lBreak.pos = last->isText() ? last->length() : 0; |
| } |
| } else if (lBreak.obj) { |
| if (last != o && !last->isListMarker()) { |
| // better to break between object boundaries than in the middle of a word (except for list markers) |
| lBreak.obj = o; |
| lBreak.pos = 0; |
| } else { |
| // Don't ever break in the middle of a word if we can help it. |
| // There's no room at all. We just have to be on this line, |
| // even though we'll spill out. |
| lBreak.obj = o; |
| lBreak.pos = pos; |
| } |
| } |
| } |
| |
| // make sure we consume at least one char/object. |
| if (lBreak == start) |
| lBreak.increment(bidi); |
| |
| // Sanity check our midpoints. |
| checkMidpoints(lBreak, bidi); |
| |
| if (trailingSpaceObject) { |
| // This object is either going to be part of the last midpoint, or it is going |
| // to be the actual endpoint. In both cases we just decrease our pos by 1 level to |
| // exclude the space, allowing it to - in effect - collapse into the newline. |
| if (sNumMidpoints%2==1) { |
| BidiIterator* midpoints = smidpoints->data(); |
| midpoints[sNumMidpoints-1].pos--; |
| } |
| //else if (lBreak.pos > 0) |
| // lBreak.pos--; |
| else if (lBreak.obj == 0 && trailingSpaceObject->isText()) { |
| // Add a new end midpoint that stops right at the very end. |
| RenderText* text = static_cast<RenderText *>(trailingSpaceObject); |
| unsigned length = text->textLength(); |
| unsigned pos = length >= 2 ? length - 2 : UINT_MAX; |
| BidiIterator endMid(0, trailingSpaceObject, pos); |
| addMidpoint(endMid); |
| } |
| } |
| |
| // We might have made lBreak an iterator that points past the end |
| // of the object. Do this adjustment to make it point to the start |
| // of the next object instead to avoid confusing the rest of the |
| // code. |
| if (lBreak.pos > 0) { |
| lBreak.pos--; |
| lBreak.increment(bidi); |
| } |
| |
| if (lBreak.obj && lBreak.pos >= 2 && lBreak.obj->isText()) { |
| // For soft hyphens on line breaks, we have to chop out the midpoints that made us |
| // ignore the hyphen so that it will render at the end of the line. |
| UChar c = static_cast<RenderText*>(lBreak.obj)->characters()[lBreak.pos-1]; |
| if (c == softHyphen) |
| chopMidpointsAt(lBreak.obj, lBreak.pos-2); |
| } |
| |
| return lBreak; |
| } |
| |
| void RenderBlock::checkLinesForOverflow() |
| { |
| m_overflowWidth = m_width; |
| for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) { |
| m_overflowLeft = min(curr->leftOverflow(), m_overflowLeft); |
| m_overflowTop = min(curr->topOverflow(), m_overflowTop); |
| m_overflowWidth = max(curr->rightOverflow(), m_overflowWidth); |
| m_overflowHeight = max(curr->bottomOverflow(), m_overflowHeight); |
| } |
| } |
| |
| void RenderBlock::deleteEllipsisLineBoxes() |
| { |
| for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) |
| curr->clearTruncation(); |
| } |
| |
| void RenderBlock::checkLinesForTextOverflow() |
| { |
| // Determine the width of the ellipsis using the current font. |
| // FIXME: CSS3 says this is configurable, also need to use 0x002E (FULL STOP) if horizontal ellipsis is "not renderable" |
| TextRun ellipsisRun(&horizontalEllipsis, 1); |
| static AtomicString ellipsisStr(&horizontalEllipsis, 1); |
| const Font& firstLineFont = firstLineStyle()->font(); |
| const Font& font = style()->font(); |
| int firstLineEllipsisWidth = firstLineFont.width(ellipsisRun); |
| int ellipsisWidth = (font == firstLineFont) ? firstLineEllipsisWidth : font.width(ellipsisRun); |
| |
| // For LTR text truncation, we want to get the right edge of our padding box, and then we want to see |
| // if the right edge of a line box exceeds that. For RTL, we use the left edge of the padding box and |
| // check the left edge of the line box to see if it is less |
| // Include the scrollbar for overflow blocks, which means we want to use "contentWidth()" |
| bool ltr = style()->direction() == LTR; |
| for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) { |
| int blockEdge = ltr ? rightOffset(curr->yPos()) : leftOffset(curr->yPos()); |
| int lineBoxEdge = ltr ? curr->xPos() + curr->width() : curr->xPos(); |
| if ((ltr && lineBoxEdge > blockEdge) || (!ltr && lineBoxEdge < blockEdge)) { |
| // This line spills out of our box in the appropriate direction. Now we need to see if the line |
| // can be truncated. In order for truncation to be possible, the line must have sufficient space to |
| // accommodate our truncation string, and no replaced elements (images, tables) can overlap the ellipsis |
| // space. |
| int width = curr == firstRootBox() ? firstLineEllipsisWidth : ellipsisWidth; |
| if (curr->canAccommodateEllipsis(ltr, blockEdge, lineBoxEdge, width)) |
| curr->placeEllipsis(ellipsisStr, ltr, blockEdge, width); |
| } |
| } |
| } |
| |
| } |
