/*

 * (C) 1999 Lars Knoll (knoll@kde.org)

 * (C) 2000 Dirk Mueller (mueller@kde.org)

 * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.

 * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)

 * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)

 *

 * 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 "RenderText.h"

#include "AXObjectCache.h"

#include "CharacterNames.h"

#include "EllipsisBox.h"

#include "FloatQuad.h"

#include "FontTranscoder.h"

#include "FrameView.h"

#include "InlineTextBox.h"

#include "Range.h"

#include "RenderArena.h"

#include "RenderBlock.h"

#include "RenderLayer.h"

#include "RenderView.h"

#include "StringBuffer.h"

#include "Text.h"

#include "TextBreakIterator.h"

#include "TextResourceDecoder.h"

#include "VisiblePosition.h"

#include "break_lines.h"

#include <wtf/AlwaysInline.h>

using namespace std;

using namespace WTF;

using namespace Unicode;

namespace WebCore {

static void makeCapitalized(String* string, UChar previous)

{

    if (string->isNull())

        return;

    unsigned length = string->length();

    const UChar* characters = string->characters();

    StringBuffer stringWithPrevious(length + 1);

    stringWithPrevious[0] = previous == noBreakSpace ? ' ' : previous;

    for (unsigned i = 1; i < length + 1; i++) {

        // Replace &nbsp with a real space since ICU no longer treats &nbsp as a word separator.

        if (characters[i - 1] == noBreakSpace)

            stringWithPrevious[i] = ' ';

        else

            stringWithPrevious[i] = characters[i - 1];

    }

    TextBreakIterator* boundary = wordBreakIterator(stringWithPrevious.characters(), length + 1);

    if (!boundary)

        return;

    StringBuffer data(length);

    int32_t endOfWord;

    int32_t startOfWord = textBreakFirst(boundary);

    for (endOfWord = textBreakNext(boundary); endOfWord != TextBreakDone; startOfWord = endOfWord, endOfWord = textBreakNext(boundary)) {

        if (startOfWord != 0) // Ignore first char of previous string

            data[startOfWord - 1] = characters[startOfWord - 1] == noBreakSpace ? noBreakSpace : toTitleCase(stringWithPrevious[startOfWord]);

        for (int i = startOfWord + 1; i < endOfWord; i++)

            data[i - 1] = characters[i - 1];

    }

    *string = String::adopt(data);

}

RenderText::RenderText(Node* node, PassRefPtr<StringImpl> str)

     : RenderObject(node)

     , m_minWidth(-1)

     , m_text(str)

     , m_firstTextBox(0)

     , m_lastTextBox(0)

     , m_maxWidth(-1)

     , m_beginMinWidth(0)

     , m_endMinWidth(0)

     , m_hasTab(false)

     , m_linesDirty(false)

     , m_containsReversedText(false)

     , m_isAllASCII(m_text.containsOnlyASCII())

     , m_knownToHaveNoOverflowAndNoFallbackFonts(false)

     , m_needsTranscoding(false)

{

    ASSERT(m_text);

    setIsText();

    // FIXME: It would be better to call this only if !m_text->containsOnlyWhitespace().

    // But that might slow things down, and maybe should only be done if visuallyNonEmpty

    // is still false. Not making any change for now, but should consider in the future.

    view()->frameView()->setIsVisuallyNonEmpty();

}

#ifndef NDEBUG

RenderText::~RenderText()

{

    ASSERT(!m_firstTextBox);

    ASSERT(!m_lastTextBox);

}

#endif

const char* RenderText::renderName() const

{

    return "RenderText";

}

bool RenderText::isTextFragment() const

{

    return false;

}

bool RenderText::isWordBreak() const

{

    return false;

}

void RenderText::updateNeedsTranscoding()

{

    const AtomicString& fontFamily = style()->font().family().family();

    const TextEncoding* encoding = document()->decoder() ? &document()->decoder()->encoding() : 0;

    m_needsTranscoding = fontTranscoder().needsTranscoding(fontFamily, encoding);

}

void RenderText::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)

{

    // There is no need to ever schedule repaints from a style change of a text run, since

    // we already did this for the parent of the text run.

    // We do have to schedule layouts, though, since a style change can force us to

    // need to relayout.

    if (diff == StyleDifferenceLayout) {

        setNeedsLayoutAndPrefWidthsRecalc();

        m_knownToHaveNoOverflowAndNoFallbackFonts = false;

    }

    bool needsResetText = false;

    if (!oldStyle) {

        updateNeedsTranscoding();

        needsResetText = m_needsTranscoding;

    } else if (oldStyle->font().needsTranscoding() != style()->font().needsTranscoding() || (style()->font().needsTranscoding() && oldStyle->font().family().family() != style()->font().family().family())) {

        updateNeedsTranscoding();

        needsResetText = true;

    }

    ETextTransform oldTransform = oldStyle ? oldStyle->textTransform() : TTNONE;

    ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;

    if (needsResetText || oldTransform != style()->textTransform() || oldSecurity != style()->textSecurity()) {

        if (RefPtr<StringImpl> textToTransform = originalText())

            setText(textToTransform.release(), true);

    }

}

void RenderText::destroy()

{

    if (!documentBeingDestroyed()) {

        if (firstTextBox()) {

            if (isBR()) {

                RootInlineBox* next = firstTextBox()->root()->nextRootBox();

                if (next)

                    next->markDirty();

            }

            for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())

                box->remove();

        } else if (parent())

            parent()->dirtyLinesFromChangedChild(this);

    }

    deleteTextBoxes();

    RenderObject::destroy();

}

void RenderText::extractTextBox(InlineTextBox* box)

{

    checkConsistency();

    m_lastTextBox = box->prevTextBox();

    if (box == m_firstTextBox)

        m_firstTextBox = 0;

    if (box->prevTextBox())

        box->prevTextBox()->setNextTextBox(0);

    box->setPreviousTextBox(0);

    for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox())

        curr->setExtracted();

    checkConsistency();

}

void RenderText::attachTextBox(InlineTextBox* box)

{

    checkConsistency();

    if (m_lastTextBox) {

        m_lastTextBox->setNextTextBox(box);

        box->setPreviousTextBox(m_lastTextBox);

    } else

        m_firstTextBox = box;

    InlineTextBox* last = box;

    for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox()) {

        curr->setExtracted(false);

        last = curr;

    }

    m_lastTextBox = last;

    checkConsistency();

}

void RenderText::removeTextBox(InlineTextBox* box)

{

    checkConsistency();

    if (box == m_firstTextBox)

        m_firstTextBox = box->nextTextBox();

    if (box == m_lastTextBox)

        m_lastTextBox = box->prevTextBox();

    if (box->nextTextBox())

        box->nextTextBox()->setPreviousTextBox(box->prevTextBox());

    if (box->prevTextBox())

        box->prevTextBox()->setNextTextBox(box->nextTextBox());

    checkConsistency();

}

void RenderText::deleteTextBoxes()

{

    if (firstTextBox()) {

        RenderArena* arena = renderArena();

        InlineTextBox* next;

        for (InlineTextBox* curr = firstTextBox(); curr; curr = next) {

            next = curr->nextTextBox();

            curr->destroy(arena);

        }

        m_firstTextBox = m_lastTextBox = 0;

    }

}

PassRefPtr<StringImpl> RenderText::originalText() const

{

    Node* e = node();

    return (e && e->isTextNode()) ? static_cast<Text*>(e)->dataImpl() : 0;

}

void RenderText::absoluteRects(Vector<IntRect>& rects, int tx, int ty)

{

    for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())

        rects.append(IntRect(tx + box->x(), ty + box->y(), box->width(), box->height()));

}

void RenderText::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, unsigned end, bool useSelectionHeight)

{

    // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX

    // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this 

    // function to take ints causes various internal mismatches. But selectionRect takes ints, and 

    // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but 

    // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.

    ASSERT(end == UINT_MAX || end <= INT_MAX);

    ASSERT(start <= INT_MAX);

    start = min(start, static_cast<unsigned>(INT_MAX));

    end = min(end, static_cast<unsigned>(INT_MAX));

    for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {

        // Note: box->end() returns the index of the last character, not the index past it

        if (start <= box->start() && box->end() < end) {

            IntRect r = IntRect(box->x(), box->y(), box->width(), box->height());

            if (useSelectionHeight) {

                IntRect selectionRect = box->selectionRect(0, 0, start, end);

                r.setHeight(selectionRect.height());

                r.setY(selectionRect.y());

            }

            FloatPoint origin = localToAbsolute(r.location());

            r.setX(origin.x());

            r.setY(origin.y());

            rects.append(r);

        } else {

            unsigned realEnd = min(box->end() + 1, end);

            IntRect r = box->selectionRect(0, 0, start, realEnd);

            if (!r.isEmpty()) {

                if (!useSelectionHeight) {

                    // change the height and y position because selectionRect uses selection-specific values

                    r.setHeight(box->height());

                    r.setY(box->y());

                }

                FloatPoint origin = localToAbsolute(r.location());

                localToAbsolute(origin);

                r.setX(origin.x());

                r.setY(origin.y());

                rects.append(r);

            }

        }

    }

}

void RenderText::absoluteQuads(Vector<FloatQuad>& quads)

{

    for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())

        quads.append(localToAbsoluteQuad(FloatRect(box->calculateBoundaries())));

}

void RenderText::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start, unsigned end, bool useSelectionHeight)

{

    // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX

    // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this 

    // function to take ints causes various internal mismatches. But selectionRect takes ints, and 

    // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but 

    // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.

    ASSERT(end == UINT_MAX || end <= INT_MAX);

    ASSERT(start <= INT_MAX);

    start = min(start, static_cast<unsigned>(INT_MAX));

    end = min(end, static_cast<unsigned>(INT_MAX));

    for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {

        // Note: box->end() returns the index of the last character, not the index past it

        if (start <= box->start() && box->end() < end) {

            IntRect r(box->calculateBoundaries());

            if (useSelectionHeight) {

                IntRect selectionRect = box->selectionRect(0, 0, start, end);

                r.setHeight(selectionRect.height());

                r.setY(selectionRect.y());

            }

            quads.append(localToAbsoluteQuad(FloatRect(r)));

        } else {

            unsigned realEnd = min(box->end() + 1, end);

            IntRect r = box->selectionRect(0, 0, start, realEnd);

            if (r.height()) {

                if (!useSelectionHeight) {

                    // change the height and y position because selectionRect uses selection-specific values

                    r.setHeight(box->height());

                    r.setY(box->y());

                }

                quads.append(localToAbsoluteQuad(FloatRect(r)));

            }

        }

    }

}

InlineTextBox* RenderText::findNextInlineTextBox(int offset, int& pos) const

{

    // The text runs point to parts of the RenderText's m_text

    // (they don't include '\n')

    // Find the text run that includes the character at offset

    // and return pos, which is the position of the char in the run.

    if (!m_firstTextBox)

        return 0;

    InlineTextBox* s = m_firstTextBox;

    int off = s->len();

    while (offset > off && s->nextTextBox()) {

        s = s->nextTextBox();

        off = s->start() + s->len();

    }

    // we are now in the correct text run

    pos = (offset > off ? s->len() : s->len() - (off - offset) );

    return s;

}

VisiblePosition RenderText::positionForPoint(const IntPoint& point)

{

    if (!firstTextBox() || textLength() == 0)

        return createVisiblePosition(0, DOWNSTREAM);

    // Get the offset for the position, since this will take rtl text into account.

    int offset;

    // FIXME: We should be able to roll these special cases into the general cases in the loop below.

    if (firstTextBox() && point.y() <  firstTextBox()->root()->lineBottom() && point.x() < firstTextBox()->m_x) {

        // at the y coordinate of the first line or above

        // and the x coordinate is to the left of the first text box left edge

        offset = firstTextBox()->offsetForPosition(point.x());

        return createVisiblePosition(offset + firstTextBox()->start(), DOWNSTREAM);

    }

    if (lastTextBox() && point.y() >= lastTextBox()->root()->lineTop() && point.x() >= lastTextBox()->m_x + lastTextBox()->m_width) {

        // at the y coordinate of the last line or below

        // and the x coordinate is to the right of the last text box right edge

        offset = lastTextBox()->offsetForPosition(point.x());

        return createVisiblePosition(offset + lastTextBox()->start(), VP_UPSTREAM_IF_POSSIBLE);

    }

    InlineTextBox* lastBoxAbove = 0;

    for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {

        if (point.y() >= box->root()->lineTop()) {

            int bottom = box->root()->nextRootBox() ? box->root()->nextRootBox()->lineTop() : box->root()->lineBottom();

            if (point.y() < bottom) {

                offset = box->offsetForPosition(point.x());

                if (point.x() == box->m_x)

                    // the x coordinate is equal to the left edge of this box

                    // the affinity must be downstream so the position doesn't jump back to the previous line

                    return createVisiblePosition(offset + box->start(), DOWNSTREAM);

                if (point.x() < box->m_x + box->m_width)

                    // and the x coordinate is to the left of the right edge of this box

                    // check to see if position goes in this box

                    return createVisiblePosition(offset + box->start(), offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);

                if (!box->prevOnLine() && point.x() < box->m_x)

                    // box is first on line

                    // and the x coordinate is to the left of the first text box left edge

                    return createVisiblePosition(offset + box->start(), DOWNSTREAM);

                if (!box->nextOnLine())

                    // box is last on line

                    // and the x coordinate is to the right of the last text box right edge

                    // generate VisiblePosition, use UPSTREAM affinity if possible

                    return createVisiblePosition(offset + box->start(), offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);

            }

            lastBoxAbove = box;

        }

    }

    return createVisiblePosition(lastBoxAbove ? lastBoxAbove->start() + lastBoxAbove->len() : 0, DOWNSTREAM);

}

IntRect RenderText::localCaretRect(InlineBox* inlineBox, int caretOffset, int* extraWidthToEndOfLine)

{

    if (!inlineBox)

        return IntRect();

    ASSERT(inlineBox->isInlineTextBox());

    if (!inlineBox->isInlineTextBox())

        return IntRect();

    InlineTextBox* box = static_cast<InlineTextBox*>(inlineBox);

    int height = box->root()->lineBottom() - box->root()->lineTop();

    int top = box->root()->lineTop();

    int left = box->positionForOffset(caretOffset);

    // Distribute the caret's width to either side of the offset.

    int caretWidthLeftOfOffset = caretWidth / 2;

    left -= caretWidthLeftOfOffset;

    int caretWidthRightOfOffset = caretWidth - caretWidthLeftOfOffset;

    int rootLeft = box->root()->x();

    int rootRight = rootLeft + box->root()->width();

    // FIXME: should we use the width of the root inline box or the

    // width of the containing block for this?

    if (extraWidthToEndOfLine)

        *extraWidthToEndOfLine = (box->root()->width() + rootLeft) - (left + 1);

    RenderBlock* cb = containingBlock();

    RenderStyle* cbStyle = cb->style();

    int leftEdge;

    int rightEdge;

    if (style()->autoWrap()) {

        leftEdge = cb->x();

        rightEdge = cb->frameRect().right();

    } else {

        leftEdge = min(cb->x(), rootLeft);

        rightEdge = max(cb->frameRect().right(), rootRight);

    }

    bool rightAligned = false;

    switch (cbStyle->textAlign()) {

    case TAAUTO:

    case JUSTIFY:

        rightAligned = cbStyle->direction() == RTL;

        break;

    case RIGHT:

    case WEBKIT_RIGHT:

        rightAligned = true;

        break;

    case LEFT:

    case WEBKIT_LEFT:

    case CENTER:

    case WEBKIT_CENTER:

        break;

    }

    if (rightAligned) {

        left = max(left, leftEdge);

        left = min(left, rootRight - caretWidth);

    } else {

        left = min(left, rightEdge - caretWidthRightOfOffset);

        left = max(left, rootLeft);

    }

    return IntRect(left, top, caretWidth, height);

}

ALWAYS_INLINE int RenderText::widthFromCache(const Font& f, int start, int len, int xPos, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const

{

    if (f.isFixedPitch() && !f.isSmallCaps() && m_isAllASCII) {

        int monospaceCharacterWidth = f.spaceWidth();

        int tabWidth = allowTabs() ? monospaceCharacterWidth * 8 : 0;

        int w = 0;

        bool isSpace;

        bool previousCharWasSpace = true; // FIXME: Preserves historical behavior, but seems wrong for start > 0.

        ASSERT(m_text);

        StringImpl& text = *m_text.impl();

        for (int i = start; i < start + len; i++) {

            char c = text[i];

            if (c <= ' ') {

                if (c == ' ' || c == '\n') {

                    w += monospaceCharacterWidth;

                    isSpace = true;

                } else if (c == '\t') {

                    w += tabWidth ? tabWidth - ((xPos + w) % tabWidth) : monospaceCharacterWidth;

                    isSpace = true;

                } else

                    isSpace = false;

            } else {

                w += monospaceCharacterWidth;

                isSpace = false;

            }

            if (isSpace && !previousCharWasSpace)