/**

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

#include "InlineTextBox.h"

#include "Range.h"

#include "RenderArena.h"

#include "RenderBlock.h"

#include "RenderLayer.h"

#include "Text.h"

#include "TextBreakIterator.h"

#include "TextStyle.h"

#include "break_lines.h"

#include <wtf/AlwaysInline.h>

using namespace std;

using namespace WTF;

using namespace Unicode;

namespace WebCore {

#if PLATFORM(SYMBIAN)

const double KSecureTimerTimeout = 0.8f;

#endif

static inline bool charactersAreAllASCII(const StringImpl* text)

{

    const UChar* chars = text->characters();

    unsigned length = text->length();

    UChar ored = 0;

    for (unsigned i = 0; i < length; ++i)

        ored |= chars[i];

    return !(ored & 0xFF80);

}

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

     : RenderObject(node)

     , m_text(str)

     , m_firstTextBox(0)

     , m_lastTextBox(0)

     , m_minWidth(-1)

     , m_maxWidth(-1)

     , m_selectionState(SelectionNone)

     , m_hasTab(false)

     , m_linesDirty(false)

     , m_containsReversedText(false)

     , m_isAllASCII(charactersAreAllASCII(m_text.get()))

#if PLATFORM(SYMBIAN)     

     , m_securityTimer(this, &RenderText::securityTimerFired)

#endif

{

    ASSERT(m_text);

    setRenderText();

    m_text = m_text->replace('\\', backslashAsCurrencySymbol());

}

#ifndef NDEBUG

RenderText::~RenderText()

{

    ASSERT(!m_firstTextBox);

    ASSERT(!m_lastTextBox);

}

#endif

void RenderText::setStyle(RenderStyle* newStyle)

{

    RenderStyle* oldStyle = style();

    if (oldStyle == newStyle)

        return;

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

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

    RenderObject::setStyle(newStyle);

    if (oldTransform != newStyle->textTransform() || oldSecurity != newStyle->textSecurity()

#if ENABLE(SVG)

        || isSVGText() /* All SVG text has to be transformed */

#endif

       ) {

        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()->setNextLineBox(0);

    box->setPreviousLineBox(0);

    for (InlineRunBox* curr = box; curr; curr = curr->nextLineBox())

        curr->setExtracted();

    checkConsistency();

}

void RenderText::attachTextBox(InlineTextBox* box)

{

    checkConsistency();

    if (m_lastTextBox) {

        m_lastTextBox->setNextLineBox(box);

        box->setPreviousLineBox(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()->setPreviousLineBox(box->prevTextBox());

    if (box->prevTextBox())

        box->prevTextBox()->setNextLineBox(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 = element();

    return e ? static_cast<Text*>(e)->string() : 0;

}

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

{

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

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

}

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

{

    int x, y;

    absolutePositionForContent(x, y);

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

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

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

        else {

            unsigned realEnd = min(box->end() + 1, end); // box->end() points at the last char, not after it

            IntRect r = box->selectionRect(x, y, 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(y + box->yPos());

                }

                rects.append(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->m_len;

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

        s = s->nextTextBox();

        off = s->m_start + s->m_len;

    }

    // we are now in the correct text run

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

    return s;

}

VisiblePosition RenderText::positionForCoordinates(int x, int y)

{

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

        return VisiblePosition(element(), 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() && y <  firstTextBox()->root()->bottomOverflow() && 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(x);

        return VisiblePosition(element(), offset + firstTextBox()->m_start, DOWNSTREAM);

    }

    if (lastTextBox() && y >= lastTextBox()->root()->topOverflow() && 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(x);

        return VisiblePosition(element(), offset + lastTextBox()->m_start, DOWNSTREAM);

    }

    InlineTextBox* lastBoxAbove = 0;

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

        if (y >= box->root()->topOverflow()) {

            int bottom = box->root()->nextRootBox() ? box->root()->nextRootBox()->topOverflow() : box->root()->bottomOverflow();

            if (y < bottom) {

                offset = box->offsetForPosition(x);

                if (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 VisiblePosition(element(), offset + box->m_start, DOWNSTREAM);

                if (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 VisiblePosition(element(), offset + box->m_start, offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);

                if (!box->prevOnLine() && 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 VisiblePosition(element(), offset + box->m_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 VisiblePosition(element(), offset + box->m_start, VP_UPSTREAM_IF_POSSIBLE);

            }

            lastBoxAbove = box;

        }

    }

    return VisiblePosition(element(), lastBoxAbove ? lastBoxAbove->m_start + lastBoxAbove->m_len : 0, DOWNSTREAM);

}

static RenderObject* lastRendererOnPrevLine(InlineBox* box)

{

    if (!box)

        return 0;

    RootInlineBox* root = box->root();

    if (!root)

        return 0;

    if (root->endsWithBreak())

        return 0;

    RootInlineBox* prevRoot = root->prevRootBox();

    if (!prevRoot)

        return 0;

    InlineBox* lastChild = prevRoot->lastChild();

    if (!lastChild)

        return 0;

    return lastChild->object();

}

static inline bool atLineWrap(InlineTextBox* box, int offset)

{

    return box->nextTextBox() && !box->nextOnLine() && offset == box->m_start + box->m_len;

}

IntRect RenderText::caretRect(int offset, EAffinity affinity, int* extraWidthToEndOfLine)

{

    if (!firstTextBox() || !textLength())

        return IntRect();

    // Find the text box for the given offset

    InlineTextBox* box = 0;

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

        if (box->containsCaretOffset(offset)) {

            // Check if downstream affinity would make us move to the next line.

            if (atLineWrap(box, offset) && affinity == DOWNSTREAM) {

                // Use the next text box

                box = box->nextTextBox();

                offset = box->m_start;

            } else {

                InlineTextBox* prevBox = box->prevTextBox();

                if (offset == box->m_start && affinity == UPSTREAM && prevBox && !box->prevOnLine()) {

                    if (prevBox) {

                        box = prevBox;

                        offset = box->m_start + box->m_len;

                    } else {

                        RenderObject *object = lastRendererOnPrevLine(box);

                        if (object)

                            return object->caretRect(0, affinity);

                    }

                }

            }

            break;

        }

    }

    if (!box)

        return IntRect();

    int height = box->root()->bottomOverflow() - box->root()->topOverflow();

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

    int left = box->positionForOffset(offset);

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

    // 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);

    int absx, absy;

    absolutePositionForContent(absx, absy);

    left += absx;

    top += absy;

    RenderBlock* cb = containingBlock();

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

        int availableWidth = cb->lineWidth(top);

        if (!box->m_reversed)

            left = min(left, absx + rootLeft + availableWidth - 1);

        else

            left = max(left, absx + rootLeft);

    }

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

}

ALWAYS_INLINE int RenderText::widthFromCache(const Font& f, int start, int len, int xPos) const

{

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

        // FIXME: This code should be simplfied; it's only run when m_text is known to be all 0000-007F,

        // but is uses the general purpose Unicode direction function.

        int monospaceCharacterWidth = f.spaceWidth();

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

        int w = 0;

        char previousChar = ' '; // FIXME: Preserves historical behavior, but seems wrong for start > 0.

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

            char c = (*m_text)[i];

            Direction dir = direction(c);

            if (dir != NonSpacingMark && dir != BoundaryNeutral) {

                if (c == '\t' && tabWidth)

                    w += tabWidth - ((xPos + w) % tabWidth);

                else

                    w += monospaceCharacterWidth;

                if (isspace(c) && !isspace(previousChar))

                    w += f.wordSpacing();

            }

            previousChar = c;

        }

        return w;

    }

    return f.width(TextRun(text()->characters() + start, len), TextStyle(allowTabs(), xPos));

}

void RenderText::trimmedPrefWidths(int leadWidth,

                                   int& beginMinW, bool& beginWS,

                                   int& endMinW, bool& endWS,

                                   bool& hasBreakableChar, bool& hasBreak,

                                   int& beginMaxW, int& endMaxW,

                                   int& minW, int& maxW, bool& stripFrontSpaces)

{

    bool collapseWhiteSpace = style()->collapseWhiteSpace();

    if (!collapseWhiteSpace)

        stripFrontSpaces = false;

    if (m_hasTab || prefWidthsDirty())

        calcPrefWidths(leadWidth);

    int len = textLength();

    if (!len || (stripFrontSpaces && m_text->containsOnlyWhitespace())) {

        maxW = 0;

        hasBreak = false;

        return;

    }

    minW = m_minWidth;

    maxW = m_maxWidth;

    beginWS = !stripFrontSpaces && m_hasBeginWS;

    endWS = m_hasEndWS;

    beginMinW = m_beginMinWidth;

    endMinW = m_endMinWidth;

    hasBreakableChar = m_hasBreakableChar;

    hasBreak = m_hasBreak;

    if (stripFrontSpaces && ((*m_text)[0] == ' ' || ((*m_text)[0] == '\n' && !style()->preserveNewline()) || (*m_text)[0] == '\t')) {

        const Font& f = style()->font(); // FIXME: This ignores first-line.

        const UChar space = ' ';

        int spaceWidth = f.width(TextRun(&space, 1));

        maxW -= spaceWidth + f.wordSpacing();

    }

    stripFrontSpaces = collapseWhiteSpace && m_hasEndWS;

    if (!style()->autoWrap() || minW > maxW)

        minW = maxW;

    // Compute our max widths by scanning the string for newlines.

    if (hasBreak) {

        const Font& f = style()->font(); // FIXME: This ignores first-line.

        bool firstLine = true;

        beginMaxW = maxW;

        endMaxW = maxW;

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

            int linelen = 0;

            while (i + linelen < len && (*m_text)[i + linelen] != '\n')

                linelen++;

            if (linelen) {

                endMaxW = widthFromCache(f, i, linelen, leadWidth + endMaxW);

                if (firstLine) {

                    firstLine = false;

                    leadWidth = 0;

                    beginMaxW = endMaxW;

                }

                i += linelen;

            } else if (firstLine) {

                beginMaxW = 0;

                firstLine = false;

                leadWidth = 0;

            }

            if (i == len - 1)

                // A <pre> run that ends with a newline, as in, e.g.,

                // <pre>Some text\n\n<span>More text</pre>

                endMaxW = 0;

        }

    }

}

static inline bool isSpaceAccordingToStyle(UChar c, RenderStyle* style)

{

    return c == ' ' || (c == noBreakSpace && style->nbspMode() == SPACE);

}

int RenderText::minPrefWidth() const

{

    if (prefWidthsDirty())

        const_cast<RenderText*>(this)->calcPrefWidths(0);

    return m_minWidth;

}

int RenderText::maxPrefWidth() const

{

    if (prefWidthsDirty())

        const_cast<RenderText*>(this)->calcPrefWidths(0);

    return m_maxWidth;

}