/**

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

 *           (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/) 

 * Copyright (C) 2010 Google 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 "RenderTextControlSingleLine.h"

#include "CSSStyleSelector.h"

#include "Event.h"

#include "EventNames.h"

#include "Frame.h"

#include "FrameView.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HitTestResult.h"

#include "InputElement.h"

#include "LocalizedStrings.h"

#include "MouseEvent.h"

#include "PlatformKeyboardEvent.h"

#include "RenderLayer.h"

#include "RenderScrollbar.h"

#include "RenderTheme.h"

#include "SearchPopupMenu.h"

#include "SelectionController.h"

#include "Settings.h"

#include "SimpleFontData.h"

#include "TextControlInnerElements.h"

using namespace std;

namespace WebCore {

using namespace HTMLNames;

RenderTextControlSingleLine::RenderTextControlSingleLine(Node* node, bool placeholderVisible)

    : RenderTextControl(node, placeholderVisible)

    , m_searchPopupIsVisible(false)

    , m_shouldDrawCapsLockIndicator(false)

    , m_searchEventTimer(this, &RenderTextControlSingleLine::searchEventTimerFired)

    , m_searchPopup(0)

{

}

RenderTextControlSingleLine::~RenderTextControlSingleLine()

{

    if (m_searchPopup) {

        m_searchPopup->disconnectClient();

        m_searchPopup = 0;

    }

    if (m_innerBlock)

        m_innerBlock->detach();

    if (m_innerSpinButton)

        m_innerSpinButton->detach();

    if (m_outerSpinButton)

        m_outerSpinButton->detach();

}

RenderStyle* RenderTextControlSingleLine::textBaseStyle() const

{

    return m_innerBlock ? m_innerBlock->renderer()->style() : style();

}

void RenderTextControlSingleLine::addSearchResult()

{

    ASSERT(node()->isHTMLElement());

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

    if (input->maxResults() <= 0)

        return;

    String value = input->value();

    if (value.isEmpty())

        return;

    Settings* settings = document()->settings();

    if (!settings || settings->privateBrowsingEnabled())

        return;

    int size = static_cast<int>(m_recentSearches.size());

    for (int i = size - 1; i >= 0; --i) {

        if (m_recentSearches[i] == value)

            m_recentSearches.remove(i);

    }

    m_recentSearches.insert(0, value);

    while (static_cast<int>(m_recentSearches.size()) > input->maxResults())

        m_recentSearches.removeLast();

    const AtomicString& name = autosaveName();

    if (!m_searchPopup)

        m_searchPopup = SearchPopupMenu::create(this);

    m_searchPopup->saveRecentSearches(name, m_recentSearches);

}

void RenderTextControlSingleLine::stopSearchEventTimer()

{

    ASSERT(node()->isHTMLElement());

    m_searchEventTimer.stop();

}

void RenderTextControlSingleLine::showPopup()

{

    ASSERT(node()->isHTMLElement());

    if (m_searchPopupIsVisible)

        return;

    if (!m_searchPopup)

        m_searchPopup = SearchPopupMenu::create(this);

    if (!m_searchPopup->enabled())

        return;

    m_searchPopupIsVisible = true;

    const AtomicString& name = autosaveName();

    m_searchPopup->loadRecentSearches(name, m_recentSearches);

    // Trim the recent searches list if the maximum size has changed since we last saved.

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

    if (static_cast<int>(m_recentSearches.size()) > input->maxResults()) {

        do {

            m_recentSearches.removeLast();

        } while (static_cast<int>(m_recentSearches.size()) > input->maxResults());

        m_searchPopup->saveRecentSearches(name, m_recentSearches);

    }

    m_searchPopup->show(absoluteBoundingBoxRect(true), document()->view(), -1);

}

void RenderTextControlSingleLine::hidePopup()

{

    ASSERT(node()->isHTMLElement());

    if (m_searchPopup)

        m_searchPopup->hide();

}

void RenderTextControlSingleLine::subtreeHasChanged()

{

    bool wasChanged = wasChangedSinceLastChangeEvent();

    RenderTextControl::subtreeHasChanged();

    InputElement* input = inputElement();

    // We don't need to call sanitizeUserInputValue() function here because

    // InputElement::handleBeforeTextInsertedEvent() has already called

    // sanitizeUserInputValue().

    // sanitizeValue() is needed because IME input doesn't dispatch BeforeTextInsertedEvent.

    input->setValueFromRenderer(input->sanitizeValue(text()));

    if (m_cancelButton)

        updateCancelButtonVisibility();

    // If the incremental attribute is set, then dispatch the search event

    if (input->searchEventsShouldBeDispatched())

        startSearchEventTimer();

    if (!wasChanged && node()->focused()) {

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

            frame->textFieldDidBeginEditing(static_cast<Element*>(node()));

    }

    if (node()->focused()) {

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

            frame->textDidChangeInTextField(static_cast<Element*>(node()));

    }

}

void RenderTextControlSingleLine::paint(PaintInfo& paintInfo, int tx, int ty)

{

    RenderTextControl::paint(paintInfo, tx, ty);

    if (paintInfo.phase == PaintPhaseBlockBackground && m_shouldDrawCapsLockIndicator) {

        IntRect contentsRect = contentBoxRect();

        // Center vertically like the text.

        contentsRect.setY((height() - contentsRect.height()) / 2);

        // Convert the rect into the coords used for painting the content

        contentsRect.move(tx + x(), ty + y());

        theme()->paintCapsLockIndicator(this, paintInfo, contentsRect);

    }

}

void RenderTextControlSingleLine::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)

{

    paintBoxDecorationsWithSize(paintInfo, tx, ty, width() - decorationWidthRight(), height());

}

void RenderTextControlSingleLine::addFocusRingRects(Vector<IntRect>& rects, int tx, int ty)

{

    int w = width() - decorationWidthRight();

    if (w && height())

        rects.append(IntRect(tx, ty, w, height()));

}

void RenderTextControlSingleLine::layout()

{

    int oldHeight = height();

    calcHeight();

    int oldWidth = width();

    calcWidth();

    bool relayoutChildren = oldHeight != height() || oldWidth != width();

    RenderBox* innerTextRenderer = innerTextElement()->renderBox();

    RenderBox* innerBlockRenderer = m_innerBlock ? m_innerBlock->renderBox() : 0;

    // Set the text block height

    int desiredHeight = textBlockHeight();

    int currentHeight = innerTextRenderer->height();

    if (currentHeight > height()) {

        if (desiredHeight != currentHeight)

            relayoutChildren = true;

        innerTextRenderer->style()->setHeight(Length(desiredHeight, Fixed));

        if (m_innerBlock)

            innerBlockRenderer->style()->setHeight(Length(desiredHeight, Fixed));

    }

    // Set the text block width

    int desiredWidth = textBlockWidth();

    if (desiredWidth != innerTextRenderer->width())

        relayoutChildren = true;

    innerTextRenderer->style()->setWidth(Length(desiredWidth, Fixed));

    if (m_innerBlock) {

        int innerBlockWidth = width() - borderAndPaddingWidth();

        if (innerBlockWidth != innerBlockRenderer->width())

            relayoutChildren = true;

        innerBlockRenderer->style()->setWidth(Length(innerBlockWidth, Fixed));

    }

    RenderBlock::layoutBlock(relayoutChildren);

    // Center the child block vertically

    RenderBox* childBlock = innerBlockRenderer ? innerBlockRenderer : innerTextRenderer;

    currentHeight = childBlock->height();

    if (currentHeight < height())

        childBlock->setY((height() - currentHeight) / 2);

    // Ignores the paddings for the inner spin button.

    if (RenderBox* spinBox = m_innerSpinButton ? m_innerSpinButton->renderBox() : 0) {

        spinBox->setLocation(spinBox->x() + paddingRight(), borderTop());

        spinBox->setHeight(height() - borderTop() - borderBottom());

    }

    // Center the spin button vertically, and move it to the right by

    // padding + border of the text fields.

    if (RenderBox* spinBox = m_outerSpinButton ? m_outerSpinButton->renderBox() : 0) {

        int diff = height() - spinBox->height();

        // If the diff is odd, the top area over the spin button takes the

        // remaining one pixel. It's good for Mac NSStepper because it has

        // shadow at the bottom.

        int y = (diff / 2) + (diff % 2);

        int x = width() - borderRight() - paddingRight() - spinBox->width();

        spinBox->setLocation(x, y);

    }

}

bool RenderTextControlSingleLine::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, int xPos, int yPos, int tx, int ty, HitTestAction hitTestAction)

{

    // If we're within the text control, we want to act as if we've hit the inner text block element, in case the point

    // was on the control but not on the inner element (see Radar 4617841).

    // In a search field, we want to act as if we've hit the results block if we're to the left of the inner text block,

    // and act as if we've hit the close block if we're to the right of the inner text block.

    if (!RenderTextControl::nodeAtPoint(request, result, xPos, yPos, tx, ty, hitTestAction))

        return false;

    // If we hit a node inside the inner text element, say that we hit that element,

    // and if we hit our node (e.g. we're over the border or padding), also say that we hit the

    // inner text element so that it gains focus.

    if (result.innerNode()->isDescendantOf(innerTextElement()) || result.innerNode() == node())

        hitInnerTextElement(result, xPos, yPos, tx, ty);

    // If we found a spin button, we're done.

    if (m_innerSpinButton && result.innerNode() == m_innerSpinButton)

        return true;

    if (m_outerSpinButton && result.innerNode() == m_outerSpinButton)

        return true;

    // If we're not a search field, or we already found the speech, results or cancel buttons, we're done.

    if (!m_innerBlock || result.innerNode() == m_resultsButton || result.innerNode() == m_cancelButton)

        return true;

#if ENABLE(INPUT_SPEECH)

    if (m_innerBlock && m_speechButton && result.innerNode() == m_speechButton)

        return true;

#endif

    Node* innerNode = 0;

    RenderBox* innerBlockRenderer = m_innerBlock->renderBox();

    RenderBox* innerTextRenderer = innerTextElement()->renderBox();

    IntPoint localPoint = result.localPoint();

    localPoint.move(-innerBlockRenderer->x(), -innerBlockRenderer->y());

    int textLeft = tx + x() + innerBlockRenderer->x() + innerTextRenderer->x();

    if (m_resultsButton && m_resultsButton->renderer() && xPos < textLeft)

        innerNode = m_resultsButton.get();

#if ENABLE(INPUT_SPEECH)

    if (!innerNode && m_speechButton && m_speechButton->renderer()) {

        int buttonLeft = textLeft + innerTextRenderer->width();

        if (m_cancelButton) {

            RenderBox* cancelRenderer = m_cancelButton->renderBox();

            cancelRenderer->calcWidth();

            buttonLeft += cancelRenderer->width() + cancelRenderer->marginLeft() + cancelRenderer->marginRight();

        }

        if (xPos > buttonLeft)

            innerNode = m_speechButton.get();

    }

#endif

    if (!innerNode) {

        int textRight = textLeft + innerTextRenderer->width();

        if (m_cancelButton && m_cancelButton->renderer() && xPos > textRight)

            innerNode = m_cancelButton.get();

    }

    if (innerNode) {

        result.setInnerNode(innerNode);

        localPoint.move(-innerNode->renderBox()->x(), -innerNode->renderBox()->y());

    }

    result.setLocalPoint(localPoint);

    return true;

}

void RenderTextControlSingleLine::forwardEvent(Event* event)

{

    RenderBox* innerTextRenderer = innerTextElement()->renderBox();

    if (event->type() == eventNames().blurEvent) {

        if (innerTextRenderer) {

            if (RenderLayer* innerLayer = innerTextRenderer->layer())

                innerLayer->scrollToOffset(style()->direction() == RTL ? innerLayer->scrollWidth() : 0, 0);

        }

        capsLockStateMayHaveChanged();

    } else if (event->type() == eventNames().focusEvent)

        capsLockStateMayHaveChanged();

    if (!event->isMouseEvent()) {

        RenderTextControl::forwardEvent(event);

        return;

    }

    FloatPoint localPoint = innerTextRenderer->absoluteToLocal(static_cast<MouseEvent*>(event)->absoluteLocation(), false, true);

    int textRight = innerTextRenderer->borderBoxRect().right();

#if ENABLE(INPUT_SPEECH)

    if (RenderBox* speechBox = m_speechButton ? m_speechButton->renderBox() : 0) {

        if (localPoint.x() >= speechBox->x() && localPoint.x() < speechBox->x() + speechBox->width()) {

            m_speechButton->defaultEventHandler(event);

            return;

        }

    }

#endif

    if (m_resultsButton && localPoint.x() < innerTextRenderer->borderBoxRect().x())

        m_resultsButton->defaultEventHandler(event);

    else if (m_cancelButton && localPoint.x() > textRight)

        m_cancelButton->defaultEventHandler(event);

    else if (m_innerSpinButton && localPoint.x() > textRight && localPoint.x() < textRight + m_innerSpinButton->renderBox()->width())

        m_innerSpinButton->defaultEventHandler(event);

    else if (m_outerSpinButton && localPoint.x() > textRight)

        m_outerSpinButton->defaultEventHandler(event);

    else

        RenderTextControl::forwardEvent(event);

}

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

{

    RenderTextControl::styleDidChange(diff, oldStyle);

    if (RenderObject* innerBlockRenderer = m_innerBlock ? m_innerBlock->renderer() : 0) {

        // 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.

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

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

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

    }

    if (RenderObject* resultsRenderer = m_resultsButton ? m_resultsButton->renderer() : 0)

        resultsRenderer->setStyle(createResultsButtonStyle(style()));

    if (RenderObject* cancelRenderer = m_cancelButton ? m_cancelButton->renderer() : 0)

        cancelRenderer->setStyle(createCancelButtonStyle(style()));

    if (RenderObject* spinRenderer = m_outerSpinButton ? m_outerSpinButton->renderer() : 0)

        spinRenderer->setStyle(createOuterSpinButtonStyle());

#if ENABLE(INPUT_SPEECH)

    if (RenderObject* speechRenderer = m_speechButton ? m_speechButton->renderer() : 0)

        speechRenderer->setStyle(createSpeechButtonStyle(style()));

#endif

    setHasOverflowClip(false);

}

void RenderTextControlSingleLine::capsLockStateMayHaveChanged()

{

    if (!node() || !document())

        return;

    // Only draw the caps lock indicator if these things are true:

    // 1) The field is a password field

    // 2) The frame is active

    // 3) The element is focused

    // 4) The caps lock is on

    bool shouldDrawCapsLockIndicator = false;

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

        shouldDrawCapsLockIndicator = inputElement()->isPasswordField()

                                      && frame->selection()->isFocusedAndActive()

                                      && document()->focusedNode() == node()

                                      && PlatformKeyboardEvent::currentCapsLockState();

    if (shouldDrawCapsLockIndicator != m_shouldDrawCapsLockIndicator) {

        m_shouldDrawCapsLockIndicator = shouldDrawCapsLockIndicator;

        repaint();

    }

}

bool RenderTextControlSingleLine::hasControlClip() const

{

    bool clip = m_cancelButton;

#if ENABLE(INPUT_SPEECH)

    if (m_speechButton)

        clip = true;

#endif

    return clip;

}

IntRect RenderTextControlSingleLine::controlClipRect(int tx, int ty) const

{

    // This should only get called for search & speech inputs.

    ASSERT(hasControlClip());

    IntRect clipRect = IntRect(m_innerBlock->renderBox()->frameRect());

    clipRect.move(tx, ty);

    return clipRect;

}

int RenderTextControlSingleLine::textBlockWidth() const

{

    int width = RenderTextControl::textBlockWidth();

    if (RenderBox* resultsRenderer = m_resultsButton ? m_resultsButton->renderBox() : 0) {

        resultsRenderer->calcWidth();

        width -= resultsRenderer->width() + resultsRenderer->marginLeft() + resultsRenderer->marginRight();

    }

    if (RenderBox* cancelRenderer = m_cancelButton ? m_cancelButton->renderBox() : 0) {

        cancelRenderer->calcWidth();

        width -= cancelRenderer->width() + cancelRenderer->marginLeft() + cancelRenderer->marginRight();

    }

    if (RenderBox* spinRenderer = m_innerSpinButton ? m_innerSpinButton->renderBox() : 0) {

        spinRenderer->calcWidth();

        width -= spinRenderer->width() + spinRenderer->marginLeft() + spinRenderer->marginRight();

    }

#if ENABLE(INPUT_SPEECH)

    if (RenderBox* speechRenderer = m_speechButton ? m_speechButton->renderBox() : 0) {

        speechRenderer->calcWidth();

        width -= speechRenderer->width() + speechRenderer->marginLeft() + speechRenderer->marginRight();

    }

#endif

    return width - decorationWidthRight();

}

int RenderTextControlSingleLine::decorationWidthRight() const

{

    int width = 0;

    if (RenderBox* spinRenderer = m_outerSpinButton ? m_outerSpinButton->renderBox() : 0) {

        spinRenderer->calcWidth();

        width += spinRenderer->width() + spinRenderer->marginLeft() + spinRenderer->marginRight();

    }

    if (width > 0)

        width += paddingRight() + borderRight();

    return width;

}

float RenderTextControlSingleLine::getAvgCharWidth(AtomicString family)

{

    // Since Lucida Grande is the default font, we want this to match the width

    // of MS Shell Dlg, the default font for textareas in Firefox, Safari Win and

    // IE for some encodings (in IE, the default font is encoding specific).

    // 901 is the avgCharWidth value in the OS/2 table for MS Shell Dlg.

    if (family == AtomicString("Lucida Grande"))

        return scaleEmToUnits(901);

    return RenderTextControl::getAvgCharWidth(family);

}

int RenderTextControlSingleLine::preferredContentWidth(float charWidth) const

{

    int factor = inputElement()->size();

    if (factor <= 0)

        factor = 20;

    int result = static_cast<int>(ceilf(charWidth * factor));

    float maxCharWidth = 0.f;

    AtomicString family = style()->font().family().family();