/*

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

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

*

* This program 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 Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not,

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include "GWebContentViewWidget.h"

#include "GWebContentView.h"

#include "browserpagefactory.h"

#include "webpagecontroller.h"

#include "Utilities.h"

#include "ChromeEffect.h"

#include <QGraphicsSceneResizeEvent>

#include <QGraphicsSceneContextMenuEvent>

#include <QWebFrame>

#include <QWebHitTestResult>

#include <QPoint>

#include <QStyleOptionGraphicsItem>

#include <QDebug>

#include <QGraphicsView>

#ifdef ENABLE_PERF_TRACE

#include "wrtperftracer.h"

#endif

namespace GVA {

const QString KViewPortWidthTag("width");

const QString KViewPortHeightTag("height");

const QString KViewPortInitialScaleTag("initial-scale");

const QString KViewPortMinScaleTag("minimum-scale");

const QString KViewPortMaxScaleTag("maximum-scale");

const QString KViewPortUserScalableTag("user-scalable");

const QString KViewPortDeviceWidthTag("device-width");

const QString KViewPortDeviceHeightTag("device-height");

const int KDefaultViewportWidth = 980;

const int KDefaultPortraitScaleWidth = 540;

const int KMinViewportWidth = 200;

const int KMaxViewportWidth = 10000;

const int KMinViewportHeight = 200;

const int KMaxViewportHeight = 10000;

const int KMaxPageZoom = 10;

const qreal KDefaultMinScale = 0.25;

const qreal KDefaultMaxScale = 10.00;

const QPoint KFocussPoint(5, 50);

const int checkerSize = 16;

const unsigned checkerColor1 = 0xff555555;

const unsigned checkerColor2 = 0xffaaaaaa;

GWebContentViewWidget::GWebContentViewWidget(QObject* parent, GWebContentView* view,QWebPage* pg) : QGraphicsWebView(0)

, m_webContentView(view)

, m_dirtyZoomFactor(1)

, m_frozenPixmap(0)

, m_frozenCount(0)

, m_wrtPage(0)

, m_bitmapZoom(false)

, m_isResize(false)

, m_currentinitialScale(0)

, m_previousViewPortwidth(size().toSize().width())

, m_bitmapImage(NULL)

, m_checkeredBoxPixmap(NULL)

{

   setParent(parent);

  if ( pg ) {

    setPage(pg);

  }

#ifdef ENABLE_PERF_TRACE

  WrtPerfTracer::tracer()->initPage(pg);

#endif //ENABLE_PERF_TRACE

  m_currentinitialScale = zoomFactor();

#ifndef NO_QSTM_GESTURE

  m_touchNavigation = new WebTouchNavigation(this);

#endif

  // Fixes missing radio button problem with certain themes

  QPalette pal = palette();

  pal.setColor(QPalette::ButtonText,Qt::black);

  setPalette(pal);

}

GWebContentViewWidget::~GWebContentViewWidget()

{

    delete m_bitmapImage;

    delete m_checkeredBoxPixmap;

    delete m_frozenPixmap;

}

void GWebContentViewWidget::updateViewport()

{

    if (page() && size() != page()->viewportSize()) {

        page()->setViewportSize(size().toSize());

    }

    setViewportSize();

}

void GWebContentViewWidget::setBlockElement(const QWebElement &pt)

{

  m_BlockElement = pt;

}

void GWebContentViewWidget::setCheckeredPixmap()

{

    delete m_checkeredBoxPixmap;

    m_checkeredBoxPixmap = NULL;

    m_checkeredBoxPixmap = new QPixmap(checkerSize, checkerSize);

    QPainter painter(m_checkeredBoxPixmap);

    painter.fillRect(0, 0, checkerSize, checkerSize, QColor(checkerColor1));

    painter.fillRect(0, checkerSize/2, checkerSize/2, checkerSize/2, QColor(checkerColor2));

    painter.fillRect(checkerSize/2, 0, checkerSize/2, checkerSize/2, QColor(checkerColor2));

}

void GWebContentViewWidget::createPageSnapShot()

{

    bitmapZoomCleanup();

    QRegion clipRegion;

    QWebFrame *frame = page()->mainFrame();

    m_bitmapImage = new QImage(size().width() ,size().height(),QImage::Format_RGB32);

    clipRegion = QRect(QPoint(0,0),size().toSize());

    QPainter painterImage(m_bitmapImage);

    painterImage.fillRect(0, 0, size().width(), size().height(), QColor(255, 255, 255));

    frame->render(&painterImage,clipRegion);

}

void GWebContentViewWidget::bitmapZoomCleanup()

{

    m_bitmapZoom = false;

    if (m_bitmapImage) {

        delete m_bitmapImage;

        m_bitmapImage = NULL;

    }

}

void GWebContentViewWidget::updateFrozenImage() {

    // Take a snapshot to be displayed while in frozen state.

    QStyleOptionGraphicsItem option;

    option.levelOfDetail = 1.0;

    option.exposedRect = QRectF(QPointF(0,0), size());

    // Discard existing pixmap.

    delete m_frozenPixmap;

    m_frozenPixmap = 0;

    // Paint the window into a new pixmap (m_frozenPixmap must be 0 here for this to work).

    QPixmap *frozenPixmap = new QPixmap(option.exposedRect.size().toSize());

    QPainter painter(frozenPixmap);

    paint(&painter, &option);

    painter.end();

    // Now point m_frozenPixmap at the new pixmap.

    m_frozenPixmap = frozenPixmap;

}

QImage GWebContentViewWidget::getPageSnapshot()

{

  QImage img(size().toSize(), QImage::Format_RGB32);

  if (!page()) return QImage();

  QPainter painter(&img);

  QWebFrame *frame = page()->mainFrame();

  painter.fillRect(QRectF(0, 0, size().width(), size().height()), QColor(255, 255, 255));

//    QTransform transform;

//    transform.scale(d->m_pageZoomFactor, d->m_pageZoomFactor);

//    painter.translate(-transform.map(frame->scrollPosition()));

  QRegion clipRegion(QRect(QPoint(0,0),size().toSize()));

//    QTransform invert = transform.inverted();

//    clipRegion = invert.map(clipRegion);

//    clipRegion.translate(frame->scrollPosition());

//    painter.scale(d->m_pageZoomFactor, d->m_pageZoomFactor);

//    d->m_webPage->mainFrame()->renderContents(&painter, clipRegion);

  frame->render(&painter, clipRegion);

  return img;

}

void GWebContentViewWidget::updateViewportSize(::QGraphicsSceneResizeEvent* e)

{

    //if there is change in mode (like landscape, potraite relayout the content)

    if (e->newSize().width() == e->oldSize().width())

        return;

    //if page is empty do not update 

    if (page()->currentFrame()->url().isEmpty())

        return;

    m_isResize = true;

    setViewportSize();

    m_isResize = false;

}

bool GWebContentViewWidget::event(QEvent * e) {

    if (e->type() == QEvent::Gesture) {

#ifndef NO_QSTM_GESTURE

          QStm_Gesture* gesture = getQStmGesture(e, WebGestureHelper::getAssignedGestureType());

          if (gesture) {

              m_touchNavigation->handleQStmGesture(gesture);

              return true;

          }

#endif

    }

    else if (e->type() == WebPageControllerUpdateViewPortEvent::staticType()) {

        updateViewport();

    }

    return QGraphicsWebView::event(e);

}

void GWebContentViewWidget::resizeEvent(QGraphicsSceneResizeEvent* e)

{

  // set the fixed text layout size for text wrapping

#if defined CWRTINTERNALWEBKIT

  if (page()) {

    p->m_webPage->settings()->setMaximumTextColumnWidth(e->newSize().width() - 6);

  }

#endif

  m_previousViewPortwidth = page()->viewportSize().width();

  const QSize &s = e->newSize().toSize();

  if (page() && s != page()->viewportSize()) {

    if (m_BlockElement.isNull()) {

      QPoint pos = QPoint(0,0);

      QWebFrame* frame = page()->frameAt(pos);

      frame = (frame) ? frame : page()->currentFrame();

      QWebHitTestResult htr = frame->hitTestContent(pos);

      m_BlockInFocus = htr.element();

      if (m_BlockInFocus.tagName() != "IMG")

        m_BlockInFocus = htr.enclosingBlockElement();

      QPoint position = m_BlockInFocus.geometry().topLeft() - page()->currentFrame()->scrollPosition();

      m_Ratiox = (qreal) position.x() / m_BlockInFocus.geometry().width();

      m_Ratioy = (qreal) position.y() / m_BlockInFocus.geometry().height();

    }

    page()->setViewportSize(s);

  }

  updateViewportSize(e);

  if(frozen()) {

    updateFrozenImage();

//    if(m_frozenPixmap && (m_frozenPixmap->size() != this->size())) {

//        QTimer::singleShot(50, this, SLOT(updateFrozenImage()));

//    }

  }

}

void GWebContentViewWidget::onLongPressEvent(QPoint pos) {

    QWebHitTestResult hitTest = page()->currentFrame()->hitTestContent(pos);

    //qDebug() << "GWebContentViewWidget::contextMenuEvent:"

    //        << "\n\t pos=" << hitTest.pos()

    //        << "\n\t linkUrl=" << hitTest.linkUrl()

    //        << "\n\t imageUrl=" << hitTest.imageUrl();

    ::WebViewEventContext *context =

            new ::WebViewEventContext(view()->type(), hitTest);

    if (m_webContentView && m_webContentView->currentPageIsSuperPage()) {

        // Let the superpage handle the event.

        m_webContentView->currentSuperPage()->onContextEvent(context);

    }

    else {

        // Send the event directly.

        emit contextEvent(context);

    }

}

void GWebContentViewWidget::contextMenuEvent(::QGraphicsSceneContextMenuEvent *event) {

    // Ignore.  The touch navigation code handles long presses.

    event->accept();

}

void GWebContentViewWidget::setZoomFactor(qreal zoom)

{

    this->setFocus();

    if (!m_userScalable)

        return;

    setPageZoomFactor(zoom);

}

void GWebContentViewWidget::setPageZoomFactor(qreal zoom)

{

//not zooming if it's bookmark or historyview or not a page

  if (!page() ||

	  	(m_webContentView->type() == "webView" && 

          m_webContentView->currentPageIsSuperPage()) )

      {

      return;      

      }

  //qDebug() << __func__ << "Zoom " << zoom << "Max : " << m_maximumScale << "Min: " << m_minimumScale;

  if (zoom < m_minimumScale)

      zoom = m_minimumScale;

  else if (zoom > m_maximumScale)

      zoom = m_maximumScale;

  QPoint pos = QPoint(0,0);

  if (!m_isResize) {

    QWebFrame* frame = page()->frameAt(pos);

    frame = (frame) ? frame : page()->currentFrame();

    QWebHitTestResult htr = frame->hitTestContent(pos);

    m_BlockInFocus = htr.element();

    if (m_BlockInFocus.tagName() != "IMG")

      m_BlockInFocus = htr.enclosingBlockElement();

    QPoint position = m_BlockInFocus.geometry().topLeft() - page()->currentFrame()->scrollPosition();

    m_Ratiox = (qreal) position.x() / m_BlockInFocus.geometry().width();

    m_Ratioy = (qreal) position.y() / m_BlockInFocus.geometry().height();

  }

  if ( m_dirtyZoomFactor != zoom ) {

      m_dirtyZoomFactor = zoom;

  }

  QGraphicsWebView::setZoomFactor( zoom );

  if (!m_BlockElement.isNull() && m_isResize) {

    QPoint imageFocusPoint;

    QPoint m_focusedBlockPt = QPoint(m_BlockElement.geometry().topLeft()) - page()->mainFrame()->scrollPosition();

    if (m_BlockElement.tagName() != "IMG" && (m_BlockElement.styleProperty(QString("background-image"),QWebElement::InlineStyle) == ""))

      page()->mainFrame()->scroll(m_focusedBlockPt.x() - KFocussPoint.x() , m_focusedBlockPt.y() - KFocussPoint.y());

    else {

      if ((page()->viewportSize().width() - m_BlockElement.geometry().width()) > 0)

        imageFocusPoint.setX((page()->viewportSize().width() - m_BlockElement.geometry().width())/2);

      else

        imageFocusPoint.setX(0);

      if ((page()->viewportSize().height() - m_BlockElement.geometry().height()) > 0)

        imageFocusPoint.setY((page()->viewportSize().height() - m_BlockElement.geometry().height())/2);

      else

        imageFocusPoint.setY(0);

      page()->mainFrame()->scroll(m_focusedBlockPt.x() - imageFocusPoint.x() ,

                    m_focusedBlockPt.y() - imageFocusPoint.y());

      }

      m_focusedBlockPt = QPoint(m_BlockElement.geometry().topLeft()) - page()->mainFrame()->scrollPosition();

      emit BlockFocusChanged(m_focusedBlockPt);

  } else {

    QPoint m_focusedBlockPt = QPoint(m_BlockInFocus.geometry().topLeft()) - page()->mainFrame()->scrollPosition();

    page()->currentFrame()->scroll(m_focusedBlockPt.x() - (m_Ratiox * m_BlockInFocus.geometry().width()),

                  m_focusedBlockPt.y() - (m_Ratioy * m_BlockInFocus.geometry().height()));

    m_BlockElement = QWebElement();

  }

    m_webContentView->changeZoomAction(zoom);

}

void GWebContentViewWidget::setDirtyZoomFactor(qreal zoom)

{

    if ( m_dirtyZoomFactor == zoom )

        return;

    m_dirtyZoomFactor = zoom;

    update();

}

void GWebContentViewWidget::onLoadStarted()

{

    m_inLoading = true;

    m_loadingTime.start();

}

void GWebContentViewWidget::onLoadFinished()

{

#ifdef NO_RESIZE_ON_LOAD

    m_inLoading = false;

    update();

#endif

}

#ifdef NO_RESIZE_ON_LOAD

void GWebContentViewWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* options, QWidget* widget)

{

    QRect clipRect;

    if (options && !options->exposedRect.isEmpty())

        clipRect = options->exposedRect.toRect();

    else

        {

            clipRect = geometry().toRect();

            clipRect.moveTo(0,0);

        }

#ifdef ENABLE_PERF_TRACE

    PERF_DEBUG() << "GWebContentViewWidget::paint: " << clipRect << "\n";

    unsigned int st = WrtPerfTracer::tracer()->startTimer();

#endif

    //painter->fillRect(clipRect, QColor(255, 255, 255));

    if (!m_inLoading || !(m_loadingTime.elapsed() < 750)) {

        QGraphicsWebView::paint(painter, options, widget);

    }

#ifdef ENABLE_PERF_TRACE

    PERF_DEBUG() << "GWebContentViewWidget::paint__end: " <<

        WrtPerfTracer::tracer()->elapsedTime(st) << "\n";

#endif

}

#else //NO_RESIZE_ON_LOAD

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

{

//    if (!m_active) return;

#ifdef ENABLE_PERF_TRACE

    PERF_DEBUG() << "GWebContentViewWidget::paint: " << option->exposedRect << "\n";

    unsigned int st = WrtPerfTracer::tracer()->startTimer();

#endif

    //qDebug() << "GWebContentViewWidget::paint";

    if (frozen() && m_frozenPixmap) {

        // Frozen, paint the snapshot.

        painter->drawPixmap(option->exposedRect.topLeft(), *m_frozenPixmap, option->exposedRect);

    }

    else {

        if (m_bitmapZoom) {

            // Frozen ----

            qreal czf = 1;

            qreal zoomF = zoomFactor();

            if ( m_bitmapZoomFactor != zoomF )

                czf = m_bitmapZoomFactor/zoomF;

            painter->save();

            if (czf < 1) {

                if (!m_checkeredBoxPixmap) {

                    setCheckeredPixmap();

                }

                QBrush brush(*m_checkeredBoxPixmap);

                painter->fillRect(0, 0, size().width(), size().height(), brush);

            }

            painter->drawImage(QRectF(0,0,size().width() * czf,size().height() * czf), *m_bitmapImage);

            painter->restore();

        }

        else if ( qAbs(zoomFactor() - m_dirtyZoomFactor) < 0.0001 )

        {

            // Do normal paint. ----

            // Cannot use normal QGraphicsWebView paint because have to fill background with white for the phone build

            // QGraphicsWebView::paintEvent( event);

            // Commented the following line out to try to improve scrolling performance.  hab - 3/25/10

            //painter->fillRect(0, 0, size().width(), size().height(), QColor(255, 255, 255));

            //painter->fillRect(clipRect, QColor(255, 255, 255));

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

        } else {

            // Do zooming paint. ----

            qreal czf = m_dirtyZoomFactor / zoomFactor();

            QWebFrame* frame = page()->mainFrame();

            painter->save();

            // Commented the following line out to try to improve scrolling performance.  hab - 3/25/10

            //painter->fillRect(0, 0, size().width(), size().height(), QColor(255, 255, 255));

            QTransform transform;

            transform.scale(czf, czf);

//            painter.translate(-transform.map(frame->scrollPosition()));

            QRegion clipRegion = QRect(QPoint(0,0), size().toSize());

            if (option && !option->exposedRect.isEmpty())

            {

                clipRegion.intersect( option->exposedRect.toRect());

            }

            QTransform invert = transform.inverted();

            clipRegion = invert.map(clipRegion);

//            clipRegion.translate(frame->scrollPosition());