/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "UrlSearchSnippet.h"

#include "Utilities.h"

#include "ChromeRenderer.h"

#include "ChromeWidget.h"

#include "ViewController.h"

#include "WebChromeSnippet.h"

#include "webpagecontroller.h"

namespace GVA {

// Methods for class UrlEditorWidget

UrlEditorWidget::UrlEditorWidget(QGraphicsItem * parent)

: QGraphicsTextItem(parent)

{

    // Disable wrapping, force text to be stored and displayed

    // as a single line.

    QTextOption textOption = document()->defaultTextOption();

    textOption.setWrapMode(QTextOption::NoWrap);

    document()->setDefaultTextOption(textOption);

    // Enable cursor keys.

    setTextInteractionFlags(Qt::TextEditorInteraction);

    // This is needed to initialize m_textLine.

    setText("");

}

UrlEditorWidget::~UrlEditorWidget()

{

}

void UrlEditorWidget::setText(const QString & text)

{

    setPlainText(text);

    m_textLine = document()->begin().layout()->lineForTextPosition(0);

}

qreal UrlEditorWidget::cursorX()

{

    return m_textLine.cursorToX(textCursor().position());

}

void UrlEditorWidget::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)

{

    // Paint without ugly selection ants (the dashed line that surrounds

    // the selected text).

    QStyleOptionGraphicsItem newOption = *option;

    newOption.state &= (!QStyle::State_Selected | !QStyle::State_HasFocus);

    painter->save();

    QGraphicsTextItem::paint(painter, &newOption, widget);

    painter->restore();

}

void UrlEditorWidget::keyPressEvent(QKeyEvent * event)

{

    // Signal horizontal cursor movement so UrlSearchSnippet can

    // implement horizontal scrolling.

    qreal oldX = cursorX();

    QGraphicsTextItem::keyPressEvent(event);

    qreal newX = cursorX();

    if (newX != oldX) {

        emit cursorXChanged(newX);

    }

}

// Methods for class UrlSearchSnippet

UrlSearchSnippet::UrlSearchSnippet(ChromeSnippet * snippet, ChromeWidget * chrome, QGraphicsItem * parent)

: NativeChromeItem(snippet, parent)

, m_chrome(chrome)

, m_percent(0)

, m_pendingClearCalls(0)

, m_viewPortWidth(0.0)

, m_viewPortHeight(0.0)

{

    setFlags(QGraphicsItem::ItemIsMovable);

    // Extract style information from element CSS.

    // For border-related properties, we constrain all values (top, left, etc.)

    // to be the same.  These can be set using the css shorthand (e.g. padding:10px),

    // but the computed css style will be for the four primitive values (padding-top,

    // padding-left) etc, which will all be equal.  Hence we just use one of the

    // computed primitive values (top) to represent the common value.

    QWebElement we = m_snippet->element();

    NativeChromeItem::CSSToQColor(

            we.styleProperty("color", QWebElement::ComputedStyle),

            m_textColor);

    NativeChromeItem::CSSToQColor(

            we.styleProperty("background-color", QWebElement::ComputedStyle),

            m_backgroundColor);

    NativeChromeItem::CSSToQColor(

            we.styleProperty("border-top-color", QWebElement::ComputedStyle),

            m_borderColor);

    QString cssPadding = we.styleProperty("padding-top", QWebElement::ComputedStyle);

    m_padding = cssPadding.remove("px").toInt();

    QString cssBorder = we.styleProperty("border-top-width", QWebElement::ComputedStyle);

    m_border = cssBorder.remove("px").toInt();

    // The viewport clips the editor when text overflows

    m_viewPort = new QGraphicsWidget(this);

    m_viewPort->setFlags(QGraphicsItem::ItemClipsChildrenToShape);

    // The actual text editor item

    m_editor = new UrlEditorWidget(m_viewPort);

    m_editor->setDefaultTextColor(m_textColor);

    m_editor->installEventFilter(this);

    // Monitor editor cursor position changes for horizontal scrolling.

    safe_connect(m_editor, SIGNAL(cursorXChanged(qreal)),

            this, SLOT(makeVisible(qreal)));

    // Monitor resize events.

    safe_connect(m_chrome->renderer(), SIGNAL(chromeResized()),

            this, SLOT(resize()));

    // Update state as soon as chrome completes loading.

    safe_connect(m_chrome, SIGNAL(chromeComplete()),

            this, SLOT(setStarted()));

    // Monitor page loading.

    WebPageController * pageController = WebPageController::getSingleton();

    safe_connect(pageController, SIGNAL(pageUrlChanged(const QString)),

            this, SLOT(setUrlText(const QString &)));

    safe_connect(pageController, SIGNAL(pageLoadStarted()),

            this, SLOT(setStarted()));

    safe_connect(pageController, SIGNAL(pageLoadProgress(const int)),

            this, SLOT(setProgress(int)));

    safe_connect(pageController, SIGNAL(pageLoadFinished(bool)),

            this, SLOT(setFinished(bool)));

    // Monitor view changes.

    ViewController * viewController = chrome->viewController();

    safe_connect(viewController, SIGNAL(currentViewChanged()),

            this, SLOT(viewChanged()));

}

UrlSearchSnippet::~UrlSearchSnippet()

{

}

bool UrlSearchSnippet::eventFilter(QObject * object, QEvent * event)

{

    // Filter editor key events.

    if (object != m_editor) {

        return false;

    }

    if (event->type() != QEvent::KeyPress) {

        return false;

    }

    QKeyEvent * keyEvent = static_cast<QKeyEvent*>(event);

    switch (keyEvent->key()) {

    case Qt::Key_Select:

    case Qt::Key_Return:

    case Qt::Key_Enter:

        // Signal that a carriage return-like key-press happened.

        emit activated();

        return true;

    case Qt::Key_Down:

    case Qt::Key_Up:

        // Swallow arrow up/down keys, editor has just one line.

        return true;

    default:

        return false;

    }

}

void UrlSearchSnippet::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)

{

    // Make sure any required horizontal scrolling happens

    // before rendering UrlEditorWidget.

    makeVisible(m_editor->cursorX());

    NativeChromeItem::paint(painter, option,widget);

    painter->save();

    painter->setRenderHint(QPainter::Antialiasing);

    painter->setBrush(m_backgroundColor);

    // First, do progress bar.

    QRectF g = boundingRect();

    g.setWidth(g.width() * m_percent / 100.0);

    painter->fillRect(g, QColor::fromRgb(0, 200, 200, 50));

    // Next, background matte.

    if (m_border > 0) {

        QPen pen;

        pen.setWidth(m_border);

        pen.setBrush(m_borderColor);

        painter->setPen(pen);

    }

    QPainterPath background;

    background.addRect(boundingRect());

    background.addRoundedRect(

            m_padding,

            m_padding,

            m_viewPortWidth,

            m_viewPortHeight,

            4,

            4);

    painter->drawPath(background);

    painter->restore();

}

void UrlSearchSnippet::resizeEvent(QGraphicsSceneResizeEvent * event)

{

    QSizeF size = event->newSize();

    m_viewPort->resize(size);

    m_viewPortWidth  = size.width()  - m_padding * 2;

    m_viewPortHeight = size.height() - m_padding * 2;

    m_viewPort->setGeometry(

            m_padding,

            (size.height() - m_editor->boundingRect().height()) / 2,

            m_viewPortWidth,

            m_viewPortHeight);

    m_editor->setTextWidth(m_viewPortWidth);

}

void UrlSearchSnippet::resize()

{

    QWebElement we = m_snippet->element();

    QRectF g = we.geometry();

    qreal newWidth  = g.width();

    qreal newHeight = g.height();

    QGraphicsWidget::resize(newWidth, newHeight);

}

void UrlSearchSnippet::setUrlText(const QString & text)

{

    m_editor->setText(text);

    m_editor->setPos(0, m_editor->pos().y());

    makeVisible(m_editor->cursorX());

}

void UrlSearchSnippet::setStarted()

{

    // Strictly speaking we should set progress to 0.

    // But set it higher to give immediate visual feedback

    // that something is happening.

    int progress = 0;

    WebPageController * pageController = WebPageController::getSingleton();

    if (pageController->isPageLoading()) {

        progress = 5;

    }

    setProgress(progress);

}

void UrlSearchSnippet::setProgress(int percent)

{

    m_percent = percent;

    update();

}

// Wait a half-second before actually clearing the progress bar.

//

// We have to be careful of the following two use cases:

//

// 1. Another page starts loading between the call to setFinished()

//    and the scheduled call to clearProgress().

//

//    We don't want to clear the progress bar if another page is

//    loading.  WebPageController::isPageLoading() can tell us

//    if that is the case.

//

// 2. Another page finishes loading between the call to setFinished()

//    and the scheduled call to clearProgress().  The sequence here is:

//

//      setFinished(ok) // for URL #1

//      setFinished(ok) // for URL #2

//      clearProgress() // for URL #1

//      clearProgress() // for URL #2

//

//    We don't want to clear the progress bar in the first call to

//    clearProgress() because we want the progress bar to retain its

//    appearance for the full timeout period.  We manage this by

//    tracking the number of pending calls to clearProgress() and

//    only clearing the progress bar when that number becomes 0.

void UrlSearchSnippet::setFinished(bool ok)

{

    if (ok) {

        setProgress(99);

    }

    ++m_pendingClearCalls;

    QTimer::singleShot(500, this, SLOT(clearProgress()));

}

void UrlSearchSnippet::clearProgress()

{

    --m_pendingClearCalls;

    if (m_pendingClearCalls > 0) {

        return;

    }

    WebPageController * pageController = WebPageController::getSingleton();

    if (pageController->isPageLoading()) {

        return;

    }

    setProgress(0);

}

void UrlSearchSnippet::viewChanged()

{

    WebPageController * pageController = WebPageController::getSingleton();

    setUrlText(pageController->currentDocUrl());

    int progress = pageController->loadProgressValue();

    if (progress >= 100) {

        progress = 0;

    }

    setProgress(progress);

}

// We divide the viewport into 3 distinct regions:

//

//

//        [ left | middle | right ]

//

// [ editor, shifted left by editorShift pixels ]

//

// When a cursor is in the middle section of the viewport we

// leave the editor shift unchanged, to preserve stability.

//

// When a cursor is in the right section or beyond we shift

// the editor left until the cursor appears at the border

// between the middle and right sections.

//

// When a cursor is in the left section or beyond we shift

// the editor right until the cursor appears at the border

// between the left and middle sections.

//

// We never shift the editor right of the viewport.

void UrlSearchSnippet::makeVisible(qreal cursorX)

{

    qreal leftScrollBorder  = 0;

    qreal rightScrollBorder = m_viewPortWidth - 10;

    qreal editorShift = -1 * m_editor->pos().x();

    qreal localX = cursorX - editorShift;

    if (localX < leftScrollBorder) {

        // Before left section, scroll right.

        // In left section, scroll right.

        qreal shift = qMin(leftScrollBorder - localX, editorShift);

        m_editor->moveBy(shift, 0);

        return;

    }

    if (localX >= rightScrollBorder) {

        // In right section, scroll left.

        // After right section, scroll left.

        qreal shift = localX - rightScrollBorder;

        m_editor->moveBy(-shift, 0);

        return;

    }

    // In middle section, no scroll needed.

    return;

}

} // namespace GVA