/*

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

* All rights reserved.

*

*

*

*

*/

#include "GWebContentView.h"

#include "GWebContentViewWidget.h"

#include "GWebContentViewJSObject.h"

#include "ChromeWidget.h"

#include "WebViewEventContext.h"

#include "browserpagefactory.h"

#include "wrtbrowsercontainer.h"

#include "webpagecontroller.h"

#ifndef NO_QSTM_GESTURE

#include "qstmgestureevent.h"

#endif

#include <QGraphicsWebView>

#include <QWebHistory>

#include <QWebPage>

#include <QWebFrame>

#include <QTimeLine>

#include <QDebug>

namespace GVA {

  // ----------------------------------------------------------

  const qreal KZoomInStep = 1.05;

  const qreal KZoomOutStep = 0.95238;

  GWebContentView::GWebContentView(ChromeWidget *chrome, QObject * parent, const QString &objectName)

    : ControllableViewBase(parent),

      m_networkMgr(0),

      m_chrome(chrome),

      m_timeLine(0),

      m_zoomIn(false),

      m_backEnabled(false),

      m_forwardEnabled(false),

      m_currentSuperPage(m_superPages.begin()),

      m_currentPageIsSuperPage(false),

  {

      setObjectName(objectName);

      m_widget = new GWebContentViewWidget(parent, this, page);

#ifndef __gva_no_chrome__

#endif

      m_networkMgr = webWidget()->page()->networkAccessManager();

      webWidget()->page()->currentFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);

      webWidget()->page()->currentFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);

#ifdef NO_QSTM_GESTURE

      m_touchNavigation->setChromeWidget(m_chrome);

#endif

      WRT::WrtBrowserContainer * wrtPage = static_cast<WRT::WrtBrowserContainer *>(page);

          wrtPage->setWebWidget(webWidget());

          pageCreated(wrtPage);

      }

      connectAll();

  }

  GWebContentView::~GWebContentView() {

      disconnect(m_jsObject);

      disconnect(webWidget());

      delete m_touchNavigation;

      delete m_widget;

          delete page;

      }

  }

void GWebContentView::bitmapZoomStop()

{

    if (m_timer) {

        m_timer->stop();

        disconnect(m_timer,SIGNAL(timeout()));

        delete m_timer;

    }

    qreal zoomFactor = m_value * webWidget()->zoomFactor();

    ((zoomFactor+0.001) >= webWidget()->maximumScale() )? webWidget()->setZoomFactor(webWidget()->maximumScale()):webWidget()->setZoomFactor(zoomFactor);

    webWidget()->bitmapZoomCleanup();

}

void GWebContentView::zoomP()

{

    if ((m_value * webWidget()->zoomFactor()) >  webWidget()->maximumScale()) {

        if (m_timer && m_timer->isActive())

            bitmapZoomStop();

    }else {

        if (m_timer->isSingleShot()) {

            m_timer->setSingleShot(false);

            m_timer->start(1);

        }

        webWidget()->setBitmapZoom(m_value * webWidget()->zoomFactor());

        m_value *= KZoomInStep;

    }

}

void GWebContentView::zoomN()

{

    if ((m_value * webWidget()->zoomFactor()) <  webWidget()->minimumScale()){

        if (m_timer && m_timer->isActive())

    }else {

        if (m_timer->isSingleShot()) {

            m_timer->setSingleShot(false);

            m_timer->start(1);

        }

        webWidget()->setBitmapZoom(m_value * webWidget()->zoomFactor());

        m_value *= KZoomOutStep;

    }

}

{

    Q_UNUSED(deltaPercent)

    if (webWidget() && webWidget()->isUserScalable()) {

        if (m_timer && m_timer->isActive()) {

            if (!m_timer->isSingleShot())

                m_value /= KZoomInStep;

            bitmapZoomStop();

        }else if (!m_timer)

            m_timer = new QTimer(this);

        m_value = KZoomInStep;

        if ((m_value * webWidget()->zoomFactor()) <  webWidget()->maximumScale()) {

            webWidget()->createPageSnapShot();

            connect(m_timer,SIGNAL(timeout()),this,SLOT(zoomP()));

            zoomP();

            m_timer->setSingleShot(true);

            m_timer->start(500);

        }else {

            delete m_timer;

            m_timer = NULL;

            webWidget()->setZoomFactor(m_value * webWidget()->zoomFactor());

        }

}

{

    Q_UNUSED(deltaPercent)

    if (webWidget() && webWidget()->isUserScalable()) {

        if (m_timer && m_timer->isActive()) {

            if (!m_timer->isSingleShot())

                m_value /= KZoomOutStep;

            bitmapZoomStop();

            return;

        }else if (!m_timer)

            m_timer = new QTimer(this);

        m_value = KZoomOutStep;

        if ((m_value * webWidget()->zoomFactor()) >  webWidget()->minimumScale()) {

            webWidget()->createPageSnapShot();

            connect(m_timer,SIGNAL(timeout()),this,SLOT(zoomN()));

            zoomN();

            m_timer->setSingleShot(true);

            m_timer->start(500);

        }else {

            delete m_timer;

            m_timer = NULL;

            webWidget()->setZoomFactor(m_value * webWidget()->zoomFactor());

        }

    }

}

  void GWebContentView::connectAll() {

    //qDebug() << "GWebContentView::connectAll: " << widget();

#ifndef __gva_no_chrome__

    safe_connect(widget(), SIGNAL(contextEvent(::WebViewEventContext *)),

                 m_jsObject, SLOT(onContextEvent(::WebViewEventContext *)));

    QObject::connect(webWidget(), SIGNAL(titleChanged(const QString &)), m_jsObject, SIGNAL(titleChanged(const QString &)));

    QObject::connect(webWidget(), SIGNAL(loadStarted()), m_jsObject, SIGNAL(loadStarted()));

    QObject::connect(webWidget(), SIGNAL(loadProgress(int)), m_jsObject, SIGNAL(loadProgress(int)));

#endif

    QObject::connect(webWidget(), SIGNAL(loadStarted()), this, SLOT(onLoadStarted()));

    QObject::connect(webWidget(), SIGNAL(loadFinished(bool)), this, SLOT(onLoadFinished(bool)));

    QObject::connect(webWidget(), SIGNAL(urlChanged(const QUrl&)), this, SLOT(onUrlChanged(const QUrl&)));

#ifndef __gva_no_chrome__

    QObject::connect(this, SIGNAL(urlChanged(const QString&)), m_jsObject, SIGNAL(urlChanged(const QString&)));

    QObject::connect(this, SIGNAL(backEnabled(bool)), m_jsObject, SIGNAL(backEnabled(bool)));

    QObject::connect(this, SIGNAL(forwardEnabled(bool)), m_jsObject, SIGNAL(forwardEnabled(bool)));

    QObject::connect(this, SIGNAL(loadFinished(bool)), m_jsObject, SIGNAL(loadFinished(bool)));

    QObject::connect(this, SIGNAL(secureConnection(bool)), m_jsObject, SIGNAL(secureConnection(bool)));

    connect(m_touchNavigation, SIGNAL(startingPanGesture(int)), m_jsObject, SIGNAL(startingPanGesture(int)));

#endif

    connect(WebPageController::getSingleton(), SIGNAL(pageCreated(WRT::WrtBrowserContainer*)),

            this, SLOT(pageCreated(WRT::WrtBrowserContainer*)));

    connect(WebPageController::getSingleton(), SIGNAL(pageChanged(WRT::WrtBrowserContainer*, WRT::WrtBrowserContainer*)),

  }

  QVariant GWebContentView::getContentWindowObject() {

    try {

        return webWidget()->page()->mainFrame()->evaluateJavaScript("window");

    }

    catch(...) {

        qDebug() << "GWebContentView::getContentWindowObject: caught expection";

        return QVariant();

    }

  }

  QGraphicsWidget* GWebContentView::widget() const {

    return static_cast<QGraphicsWidget*>(m_widget);

  }

  GWebContentViewWidget *GWebContentView::webWidget() const {

    return m_widget;

  }

  QString GWebContentView::title() const {

    return webWidget()->title();

  }

  QUrl GWebContentView::url() {

    return webWidget()->url();

  }

  QWebPage* GWebContentView::wrtPage() {

    return m_widget->wrtPage();

  }

      /* Disable zoomOut action initially as we are the the minimum scale */

      /* Revisit this to determine whether we can use the change signal to

       * set the zoomOut button image initially as well

       */

  }

  void GWebContentView::triggerAction(const QString & action)

  {

    QWebPage::WebAction webAction;

      webAction = QWebPage::Stop;

    else if (action=="Back")

      webAction = QWebPage::Back;

      webAction = QWebPage::Reload;

    else if (action=="Forward")

      webAction = QWebPage::Forward;

    else

      return;

    webWidget()->triggerPageAction(webAction);

  }

  void GWebContentView::deactivateZoomActions()

  {

  }

  void GWebContentView::changeZoomAction(qreal zoom){

        deactivateZoomActions();

    }

    else {

      if (zoom <= webWidget()->minimumScale() ) {

      }

      else {

      }

      if (zoom >= webWidget()->maximumScale()  ){

      }

      else {

      }

    }

  }

  void GWebContentView::setZoomFactor(qreal factor){

        webWidget()->setZoomFactor(factor);

  }

  qreal GWebContentView::getZoomFactor() const {

    return webWidgetConst() ? webWidgetConst()->zoomFactor() : 0.0;

  }

  }

  void GWebContentView::deactivate() {

      ControllableViewBase::deactivate();

  }

//  static void appendAction(QWebPage* page, QList<QAction*> &list, enum QWebPage::WebAction webAction, const QString &name) {

//      QAction *action = page->action(webAction);

//          action->setObjectName(name);

//          list.append(action);

//      }

//  }

  /*!

    Return the list of public QActions most relevant to the view's current context.

    @return  List of public actions

  */

  QList<QAction *> GWebContentView::getContext()

  {

      // Get some of the actions from the page (there are many more available) and build a list

      // list of them.

      QList<QAction*> actions;

      /* Add zoomIn and zoomOut actions created earlier*/

      return actions;

  }

  QAction * GWebContentView::getAction(const QString & action)

  {