/**

 * Copyright (C) 2006, 2007 Apple Inc. All rights 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 "RenderTextControl.h"

#include "CharacterNames.h"

#include "Document.h"

#include "Editor.h"

#include "EditorClient.h"

#include "Event.h"

#include "EventNames.h"

#include "Frame.h"

#include "HTMLBRElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HTMLTextAreaElement.h"

#include "HTMLTextFieldInnerElement.h"

#include "HitTestResult.h"

#include "LocalizedStrings.h"

#include "MouseEvent.h"

#include "PlatformScrollBar.h"

#include "RenderTheme.h"

#include "SearchPopupMenu.h"

#include "SelectionController.h"

#include "Settings.h"

#include "Text.h"

#include "TextIterator.h"

#include "TextStyle.h"

#include "htmlediting.h"

#include "visible_units.h"

#include <math.h>

#if PLATFORM(SYMBIAN)

#include "RenderView.h"

#include "WebCoreFrameBridge.h"

#endif

using namespace std;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

class RenderTextControlInnerBlock : public RenderBlock {

public:

    RenderTextControlInnerBlock(Node* node) : RenderBlock(node) { }

    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);

};

bool RenderTextControlInnerBlock::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int x, int y, int tx, int ty, HitTestAction hitTestAction)

{

    RenderTextControl* renderer = static_cast<RenderTextControl*>(node()->shadowAncestorNode()->renderer());

    return RenderBlock::nodeAtPoint(request, result, x, y, tx, ty, renderer->placeholderIsVisible() ? HitTestBlockBackground : hitTestAction);

}

RenderTextControl::RenderTextControl(Node* node, bool multiLine)

    : RenderBlock(node)

    , m_dirty(false)

    , m_multiLine(multiLine)

    , m_placeholderVisible(false)

    , m_userEdited(false)

    , m_searchPopup(0)

    , m_searchPopupIsVisible(false)

    , m_searchEventTimer(this, &RenderTextControl::searchEventTimerFired)

{

}

RenderTextControl::~RenderTextControl()

{

    if (m_searchPopup) {

        m_searchPopup->disconnectClient();

        m_searchPopup = 0;

    }

    if (m_multiLine && node())

        static_cast<HTMLTextAreaElement*>(node())->rendererWillBeDestroyed();

    // The children renderers have already been destroyed by destroyLeftoverChildren

    if (m_innerBlock)

        m_innerBlock->detach();

    else if (m_innerText)

        m_innerText->detach();

}

void RenderTextControl::setStyle(RenderStyle* style)

{

    RenderBlock::setStyle(style);

    if (m_innerBlock) {

        // We may have set the width and the height in the old style in layout(). Reset them now to avoid

        // getting a spurious layout hint.

        m_innerBlock->renderer()->style()->setHeight(Length());

        m_innerBlock->renderer()->style()->setWidth(Length());

        m_innerBlock->renderer()->setStyle(createInnerBlockStyle(style));

    }

    if (m_innerText) {

        RenderBlock* textBlockRenderer = static_cast<RenderBlock*>(m_innerText->renderer());

        RenderStyle* textBlockStyle = createInnerTextStyle(style);

        // We may have set the width and the height in the old style in layout(). Reset them now to avoid

        // getting a spurious layout hint.

        textBlockRenderer->style()->setHeight(Length());

        textBlockRenderer->style()->setWidth(Length());

        textBlockRenderer->setStyle(textBlockStyle);

        for (Node* n = m_innerText->firstChild(); n; n = n->traverseNextNode(m_innerText.get())) {

            if (n->renderer())

                n->renderer()->setStyle(textBlockStyle);

        }

    }

    if (m_resultsButton)

        m_resultsButton->renderer()->setStyle(createResultsButtonStyle(style));

    if (m_cancelButton)

        m_cancelButton->renderer()->setStyle(createCancelButtonStyle(style));

    setHasOverflowClip(false);

    setReplaced(isInline());

}

static Color disabledTextColor(const Color& textColor, const Color& backgroundColor)

{

    // The explcit check for black is an optimization for the 99% case (black on white).

    // This also means that black on black will turn into grey on black when disabled.

    if (textColor.rgb() == Color::black || differenceSquared(textColor, Color::white) > differenceSquared(backgroundColor, Color::white))

        return textColor.light();

    return textColor.dark();

}

RenderStyle* RenderTextControl::createInnerBlockStyle(RenderStyle* startStyle)

{

    RenderStyle* innerBlockStyle = new (renderArena()) RenderStyle();

    innerBlockStyle->inheritFrom(startStyle);

    innerBlockStyle->setDisplay(BLOCK);

    innerBlockStyle->setDirection(LTR);

    // We don't want the shadow dom to be editable, so we set this block to read-only in case the input itself is editable.

    innerBlockStyle->setUserModify(READ_ONLY);

    return innerBlockStyle;

}

RenderStyle* RenderTextControl::createInnerTextStyle(RenderStyle* startStyle)

{

    RenderStyle* textBlockStyle = new (renderArena()) RenderStyle();

    HTMLGenericFormElement* element = static_cast<HTMLGenericFormElement*>(node());

    textBlockStyle->inheritFrom(startStyle);

    // The inner block, if present, always has its direction set to LTR,

    // so we need to inherit the direction from the element.

    textBlockStyle->setDirection(style()->direction());

    textBlockStyle->setUserModify(element->isReadOnlyControl() || element->disabled() ? READ_ONLY : READ_WRITE_PLAINTEXT_ONLY);

    if (m_innerBlock)

        textBlockStyle->setDisplay(INLINE_BLOCK);

    else

        textBlockStyle->setDisplay(BLOCK);

    if (m_multiLine) {

        // Forward overflow properties.

        textBlockStyle->setOverflowX(startStyle->overflowX() == OVISIBLE ? OAUTO : startStyle->overflowX());

        textBlockStyle->setOverflowY(startStyle->overflowY() == OVISIBLE ? OAUTO : startStyle->overflowY());

        // Set word wrap property based on wrap attribute

        if (static_cast<HTMLTextAreaElement*>(element)->wrap() == HTMLTextAreaElement::ta_NoWrap) {

            textBlockStyle->setWhiteSpace(PRE);

            textBlockStyle->setWordWrap(NormalWordWrap);

        } else {

            textBlockStyle->setWhiteSpace(PRE_WRAP);

            textBlockStyle->setWordWrap(BreakWordWrap);

        }

    } else {

        textBlockStyle->setWhiteSpace(PRE);

        textBlockStyle->setWordWrap(NormalWordWrap);

        textBlockStyle->setOverflowX(OHIDDEN);

        textBlockStyle->setOverflowY(OHIDDEN);

        // Do not allow line-height to be smaller than our default.

        if (textBlockStyle->font().lineSpacing() > lineHeight(true, true))

            textBlockStyle->setLineHeight(Length(-100.0f, Percent));

    }

    if (!m_multiLine) {

        // We're adding one extra pixel of padding to match WinIE.

        textBlockStyle->setPaddingLeft(Length(1, Fixed));

        textBlockStyle->setPaddingRight(Length(1, Fixed));

    } else {

        // We're adding three extra pixels of padding to line textareas up with text fields.

        textBlockStyle->setPaddingLeft(Length(3, Fixed));

        textBlockStyle->setPaddingRight(Length(3, Fixed));

    }

    if (!element->isEnabled())

        textBlockStyle->setColor(disabledTextColor(startStyle->color(), startStyle->backgroundColor()));

    return textBlockStyle;

}

RenderStyle* RenderTextControl::createResultsButtonStyle(RenderStyle* startStyle)

{

    ASSERT(!m_multiLine);

    HTMLInputElement* input = static_cast<HTMLInputElement*>(node());

    RenderStyle* resultsBlockStyle;

    if (input->maxResults() < 0)

        resultsBlockStyle = getPseudoStyle(RenderStyle::SEARCH_DECORATION);

    else if (!input->maxResults())

        resultsBlockStyle = getPseudoStyle(RenderStyle::SEARCH_RESULTS_DECORATION);

    else

        resultsBlockStyle = getPseudoStyle(RenderStyle::SEARCH_RESULTS_BUTTON);

    if (!resultsBlockStyle)

        resultsBlockStyle = new (renderArena()) RenderStyle();

    if (startStyle)

        resultsBlockStyle->inheritFrom(startStyle);

    resultsBlockStyle->setDisplay(INLINE_BLOCK);

    return resultsBlockStyle;

}

RenderStyle* RenderTextControl::createCancelButtonStyle(RenderStyle* startStyle)

{

    RenderStyle* cancelBlockStyle;

    if (RenderStyle* pseudoStyle = getPseudoStyle(RenderStyle::SEARCH_CANCEL_BUTTON))

        // We may be sharing style with another search field, but we must not share the cancel button style.

        cancelBlockStyle = new (renderArena()) RenderStyle(*pseudoStyle);

    else

        cancelBlockStyle = new (renderArena()) RenderStyle();

    if (startStyle)

        cancelBlockStyle->inheritFrom(startStyle);

    cancelBlockStyle->setDisplay(INLINE_BLOCK);

    updateCancelButtonVisibility(cancelBlockStyle);

    return cancelBlockStyle;

}

void RenderTextControl::updatePlaceholder()

{

    bool oldPlaceholderVisible = m_placeholderVisible;

    String placeholder;

    if (!m_multiLine) {

        HTMLInputElement* input = static_cast<HTMLInputElement*>(node());

        if (input->value().isEmpty() && document()->focusedNode() != node())

            placeholder = input->getAttribute(placeholderAttr);

    }

    if (!placeholder.isEmpty() || m_placeholderVisible) {

        ExceptionCode ec = 0;

        m_innerText->setInnerText(placeholder, ec);

        m_placeholderVisible = !placeholder.isEmpty();

    }

    Color color;

    if (!placeholder.isEmpty())

        color = Color::darkGray;

    else if (node()->isEnabled())

        color = style()->color();

    else

        color = disabledTextColor(style()->color(), style()->backgroundColor());

    RenderObject* renderer = m_innerText->renderer();

    RenderStyle* innerStyle = renderer->style();

    if (innerStyle->color() != color) {

        innerStyle->setColor(color);

        renderer->repaint();

    }

    // temporary disable textSecurity if placeholder is visible

    if (style()->textSecurity() != TSNONE && oldPlaceholderVisible != m_placeholderVisible) {

        RenderStyle* newInnerStyle = new (renderArena()) RenderStyle(*innerStyle);

        newInnerStyle->setTextSecurity(m_placeholderVisible ? TSNONE : style()->textSecurity());

        renderer->setStyle(newInnerStyle);

        for (Node* n = m_innerText->firstChild(); n; n = n->traverseNextNode(m_innerText.get())) {

            if (n->renderer())

                n->renderer()->setStyle(newInnerStyle);

        }

    }

}

void RenderTextControl::createSubtreeIfNeeded()

{

    // When adding these elements, create the renderer & style first before adding to the DOM.

    // Otherwise, the render tree will create some anonymous blocks that will mess up our layout.

    bool isSearchField = !m_multiLine && static_cast<HTMLInputElement*>(node())->isSearchField();

    if (isSearchField && !m_innerBlock) {

        // Create the inner block element and give it a parent, renderer, and style

        m_innerBlock = new HTMLTextFieldInnerElement(document(), node());

        RenderBlock* innerBlockRenderer = new (renderArena()) RenderBlock(m_innerBlock.get());

        m_innerBlock->setRenderer(innerBlockRenderer);

        m_innerBlock->setAttached();

        m_innerBlock->setInDocument(true);

        innerBlockRenderer->setStyle(createInnerBlockStyle(style()));

        // Add inner block renderer to Render tree

        RenderBlock::addChild(innerBlockRenderer);

    }

    if (isSearchField && !m_resultsButton) {

        // Create the results block element and give it a parent, renderer, and style

        m_resultsButton = new HTMLSearchFieldResultsButtonElement(document());

        RenderBlock* resultsBlockRenderer = new (renderArena()) RenderBlock(m_resultsButton.get());

        m_resultsButton->setRenderer(resultsBlockRenderer);

        m_resultsButton->setAttached();

        m_resultsButton->setInDocument(true);

        RenderStyle* resultsBlockStyle = createResultsButtonStyle(m_innerBlock->renderer()->style());

        resultsBlockRenderer->setStyle(resultsBlockStyle);

        // Add results renderer to DOM & Render tree

        m_innerBlock->renderer()->addChild(resultsBlockRenderer);

        ExceptionCode ec = 0;

        m_innerBlock->appendChild(m_resultsButton, ec);

    }

    if (!m_innerText) {

        // Create the text block element and give it a parent, renderer, and style

        // For non-search fields, there is no intermediate m_innerBlock as the shadow node.

        // m_innerText will be the shadow node in that case.

        m_innerText = new HTMLTextFieldInnerTextElement(document(), m_innerBlock ? 0 : node());

        RenderTextControlInnerBlock* textBlockRenderer = new (renderArena()) RenderTextControlInnerBlock(m_innerText.get());

        m_innerText->setRenderer(textBlockRenderer);

        m_innerText->setAttached();

        m_innerText->setInDocument(true);

        RenderStyle* parentStyle = style();

        if (m_innerBlock)

            parentStyle = m_innerBlock->renderer()->style();

        RenderStyle* textBlockStyle = createInnerTextStyle(parentStyle);

        textBlockRenderer->setStyle(textBlockStyle);

        // Add text block renderer to Render tree

        if (m_innerBlock) {

            m_innerBlock->renderer()->addChild(textBlockRenderer);

            ExceptionCode ec = 0;

            // Add text block to the DOM

            m_innerBlock->appendChild(m_innerText, ec);

        } else

            RenderBlock::addChild(textBlockRenderer);

    }

    if (isSearchField && !m_cancelButton) {

        // Create the close block element and give it a parent, renderer, and style

        m_cancelButton = new HTMLSearchFieldCancelButtonElement(document());

        RenderBlock* closeBlockRenderer = new (renderArena()) RenderBlock(m_cancelButton.get());

        m_cancelButton->setRenderer(closeBlockRenderer);

        m_cancelButton->setAttached();

        m_cancelButton->setInDocument(true);

        RenderStyle* closeBlockStyle = createCancelButtonStyle(m_innerBlock->renderer()->style());

        closeBlockRenderer->setStyle(closeBlockStyle);

        // Add close block renderer to DOM & Render tree

        m_innerBlock->renderer()->addChild(closeBlockRenderer);

        ExceptionCode ec = 0;

        m_innerBlock->appendChild(m_cancelButton, ec);

    }

}

void RenderTextControl::updateFromElement()

{

    HTMLGenericFormElement* element = static_cast<HTMLGenericFormElement*>(node());

    createSubtreeIfNeeded();

    if (m_cancelButton)

        updateCancelButtonVisibility(m_cancelButton->renderer()->style());

    updatePlaceholder();

    m_innerText->renderer()->style()->setUserModify(element->isReadOnlyControl() || element->disabled() ? READ_ONLY : READ_WRITE_PLAINTEXT_ONLY);

    if ((!element->valueMatchesRenderer() || m_multiLine) && !m_placeholderVisible) {

        String value;

        if (m_multiLine)

            value = static_cast<HTMLTextAreaElement*>(element)->value();

        else

            value = static_cast<HTMLInputElement*>(element)->value();

        if (value.isNull())

            value = "";

        else

            value = value.replace('\\', backslashAsCurrencySymbol());

        if (value != text() || !m_innerText->hasChildNodes()) {

            ExceptionCode ec = 0;

#if PLATFORM(SYMBIAN)

        if (value.length() > 8192)

            value.truncate(8192);

#endif

            m_innerText->setInnerText(value, ec);

            if (value.endsWith("\n") || value.endsWith("\r"))

                m_innerText->appendChild(new HTMLBRElement(document()), ec);

            if (Frame* frame = document()->frame())

                frame->editor()->clearUndoRedoOperations();

            m_dirty = false;

            m_userEdited = false;

        }

        element->setValueMatchesRenderer();

    }

    if (m_searchPopupIsVisible)

        m_searchPopup->updateFromElement();

}

int RenderTextControl::selectionStart()

{

    Frame* frame = document()->frame();

    if (!frame)

        return 0;

    return indexForVisiblePosition(frame->selectionController()->start());

}

int RenderTextControl::selectionEnd()

{

    Frame* frame = document()->frame();

    if (!frame)

        return 0;

    return indexForVisiblePosition(frame->selectionController()->end());

}

void RenderTextControl::setSelectionStart(int start)

{

    setSelectionRange(start, max(start, selectionEnd()));

}

void RenderTextControl::setSelectionEnd(int end)

{

    setSelectionRange(min(end, selectionStart()), end);

}

void RenderTextControl::select()

{

    setSelectionRange(0, text().length());

}

void RenderTextControl::setSelectionRange(int start, int end)

{

    end = max(end, 0);

    start = min(max(start, 0), end);

    document()->updateLayout();

    if (style()->visibility() == HIDDEN || !m_innerText || !m_innerText->renderer() || !m_innerText->renderer()->height()) {

        if (m_multiLine)

            static_cast<HTMLTextAreaElement*>(node())->cacheSelection(start, end);

        else

            static_cast<HTMLInputElement*>(node())->cacheSelection(start, end);

        return;

    }

    VisiblePosition startPosition = visiblePositionForIndex(start);

    VisiblePosition endPosition;

    if (start == end)

        endPosition = startPosition;

    else

        endPosition = visiblePositionForIndex(end);

    ASSERT(startPosition.isNotNull() && endPosition.isNotNull());

    ASSERT(startPosition.deepEquivalent().node()->shadowAncestorNode() == node() && endPosition.deepEquivalent().node()->shadowAncestorNode() == node());

    Selection newSelection = Selection(startPosition, endPosition);

    if (Frame* frame = document()->frame())

        frame->selectionController()->setSelection(newSelection);

    // FIXME: Granularity is stored separately on the frame, but also in the selection controller.

    // The granularity in the selection controller should be used, and then this line of code would not be needed.

    if (Frame* frame = document()->frame())

        frame->setSelectionGranularity(CharacterGranularity);

}

Selection RenderTextControl::selection(int start, int end) const

{

    return Selection(VisiblePosition(m_innerText.get(), start, VP_DEFAULT_AFFINITY),

                     VisiblePosition(m_innerText.get(), end, VP_DEFAULT_AFFINITY));

}

VisiblePosition RenderTextControl::visiblePositionForIndex(int index)

{

    if (index <= 0)

        return VisiblePosition(m_innerText.get(), 0, DOWNSTREAM);

    ExceptionCode ec = 0;

    RefPtr<Range> range = new Range(document());

    range->selectNodeContents(m_innerText.get(), ec);

    CharacterIterator it(range.get());

    it.advance(index - 1);

    return VisiblePosition(it.range()->endContainer(ec), it.range()->endOffset(ec), UPSTREAM);

}

int RenderTextControl::indexForVisiblePosition(const VisiblePosition& pos)

{

    Position indexPosition = pos.deepEquivalent();

    if (!indexPosition.node() || indexPosition.node()->rootEditableElement() != m_innerText)

        return 0;

    ExceptionCode ec = 0;

    RefPtr<Range> range = new Range(document());

    range->setStart(m_innerText.get(), 0, ec);

    range->setEnd(indexPosition.node(), indexPosition.offset(), ec);

    return TextIterator::rangeLength(range.get());

}

void RenderTextControl::updateCancelButtonVisibility(RenderStyle* style)

{

    ASSERT(!m_multiLine);

    HTMLInputElement* input = static_cast<HTMLInputElement*>(node());

    if (input->value().isEmpty())

        style->setVisibility(HIDDEN);

    else

        style->setVisibility(VISIBLE);

}

void RenderTextControl::subtreeHasChanged()

{