--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ginebra2/ContentViews/GWebContentView.cpp Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,740 @@
+/*
+* 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 "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>
+
+
+#define safe_connect(src, srcSig, target, targetSlot) \
+ { int res = connect(src, srcSig, target, targetSlot); assert(res); }
+
+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),
+ m_timer(NULL)
+ {
+ setObjectName(objectName);
+ qDebug() << "GWebContentView::GWebContentView: this=" << this;
+ QWebPage* page = BrowserPageFactory::openBrowserPage();
+
+ setZoomActions();
+ m_widget = new GWebContentViewWidget(parent, this, page);
+#ifndef __gva_no_chrome__
+ m_jsObject = new GWebContentViewJSObject(this, m_chrome->page()->mainFrame(), objectName);
+#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 = new GWebTouchNavigation(page, m_widget);
+ m_touchNavigation->setChromeWidget(m_chrome);
+ connect(m_touchNavigation, SIGNAL(mouseEvent(QEvent::Type)) , this, SIGNAL(contentViewMouseEvent(QEvent::Type)));
+#endif
+ WRT::WrtBrowserContainer * wrtPage = static_cast<WRT::WrtBrowserContainer *>(page);
+ if(wrtPage) {
+ wrtPage->setWebWidget(webWidget());
+ pageCreated(wrtPage);
+ }
+
+ connectAll();
+ }
+
+ GWebContentView::~GWebContentView() {
+ disconnect(m_jsObject);
+ disconnect(webWidget());
+ delete m_touchNavigation;
+ delete m_actionZoomIn;
+ delete m_actionZoomOut;
+ delete m_widget;
+ foreach(GWebPage *page, m_superPages) {
+ delete page;
+ }
+ }
+
+void GWebContentView::bitmapZoomStop()
+{
+ if (m_timer) {
+ m_timer->stop();
+ disconnect(m_timer,SIGNAL(timeout()));
+ delete m_timer;
+ m_timer = NULL;
+ }
+ 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())
+ bitmapZoomStop();
+ }else {
+ if (m_timer->isSingleShot()) {
+ m_timer->setSingleShot(false);
+ m_timer->start(1);
+ }
+ webWidget()->setBitmapZoom(m_value * webWidget()->zoomFactor());
+ m_value *= KZoomOutStep;
+ }
+}
+
+void GWebContentView::zoomIn(qreal deltaPercent)
+{
+ Q_UNUSED(deltaPercent)
+ if (webWidget() && webWidget()->isUserScalable()) {
+ if (m_timer && m_timer->isActive()) {
+ if (!m_timer->isSingleShot())
+ m_value /= KZoomInStep;
+ bitmapZoomStop();
+ return;
+ }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());
+ }
+ }
+}
+
+void GWebContentView::zoomOut(qreal deltaPercent)
+{
+ 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*)),
+ this, SLOT(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();
+ }
+
+ void GWebContentView::setZoomActions(){
+
+ // Create zoomIn and zoomOut actions */
+ m_actionZoomIn = new QAction("zoomIn", this);
+ m_actionZoomIn->setObjectName("zoomIn");
+
+ m_actionZoomOut = new QAction("zoomOut", this);
+ m_actionZoomOut->setObjectName("zoomOut");
+ /* 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
+ */
+ m_actionZoomOut->setEnabled(false);
+
+ connect(m_actionZoomIn, SIGNAL(triggered()), this, SLOT(zoomIn()));
+ connect(m_actionZoomOut, SIGNAL(triggered()), this, SLOT(zoomOut()));
+ }
+
+ void GWebContentView::triggerAction(const QString & action)
+ {
+ qDebug() << "GWebContentView::triggerAction: " << action;
+ QWebPage::WebAction webAction;
+ if(action=="Stop")
+ webAction = QWebPage::Stop;
+ else if (action=="Back")
+ webAction = QWebPage::Back;
+ else if(action=="Reload")
+ webAction = QWebPage::Reload;
+ else if (action=="Forward")
+ webAction = QWebPage::Forward;
+ else
+ return;
+ webWidget()->triggerPageAction(webAction);
+ }
+
+ void GWebContentView::deactivateZoomActions()
+ {
+ m_actionZoomOut->setEnabled(false);
+ m_actionZoomIn->setEnabled(false);
+ }
+
+ void GWebContentView::changeZoomAction(qreal zoom){
+ if(!webWidget()) return;
+ if(!(webWidget()->isUserScalable() ) ){
+ deactivateZoomActions();
+ }
+ else {
+ if (zoom <= webWidget()->minimumScale() ) {
+ m_actionZoomOut->setEnabled(false);
+ }
+ else {
+ m_actionZoomOut->setEnabled(true);
+ }
+
+ if (zoom >= webWidget()->maximumScale() ){
+ m_actionZoomIn->setEnabled(false);
+ }
+ else {
+ m_actionZoomIn->setEnabled(true);
+ }
+ }
+ }
+
+ void GWebContentView::setZoomFactor(qreal factor){
+ if(webWidget())
+ webWidget()->setZoomFactor(factor);
+ }
+
+ qreal GWebContentView::getZoomFactor() const {
+ return webWidgetConst() ? webWidgetConst()->zoomFactor() : 0.0;
+ }
+
+ void GWebContentView::activate() {
+ qDebug() << "GWebContentView::activate";
+ ControllableViewBase::activate();
+ }
+
+ void GWebContentView::deactivate() {
+ qDebug() << "GWebContentView::deactivate";
+ ControllableViewBase::deactivate();
+ }
+
+// static void appendAction(QWebPage* page, QList<QAction*> &list, enum QWebPage::WebAction webAction, const QString &name) {
+// QAction *action = page->action(webAction);
+// if(action) {
+// 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*/
+ if(m_actionZoomIn) actions.append(m_actionZoomIn);
+ if(m_actionZoomOut) actions.append(m_actionZoomOut);
+
+ return actions;
+ }
+
+
+ QAction * GWebContentView::getAction(const QString & action)
+ {
+ if(action == "zoomIn")
+ return m_actionZoomIn;
+ if(action == "zoomOut")
+ return m_actionZoomOut;
+ QWebPage::WebAction webAction;
+ if(action == "Back")
+ webAction = QWebPage::Back;
+ else if(action == "Forward")
+ webAction = QWebPage::Forward;
+ else if(action == "Stop")
+ webAction = QWebPage::Stop;
+ else if(action == "Reload")
+ webAction = QWebPage::Reload;
+ else return 0;
+ return webWidget()->pageAction(webAction);
+ }
+
+ void GWebContentView::scrollViewBy(int dx, int dy)
+ {
+ wrtPage()->mainFrame()->scroll(dx, dy);
+ }
+
+ void GWebContentView::scrollViewTo(int x, int y)
+ {
+ wrtPage()->mainFrame()->setScrollPosition(QPoint(x, y));
+ }
+
+
+ void GWebContentView::showMessageBox(WRT::MessageBoxProxy* proxy)
+ {
+ /*
+ QMessageBox msgBox(this);
+ msgBox.setText(proxy->m_text);
+ msgBox.setInformativeText(proxy->m_informativeText);
+ msgBox.setDetailedText(proxy->m_detailedText);
+ msgBox.setStandardButtons(proxy->m_buttons);
+ msgBox.setDefaultButton(proxy->m_defaultButton);
+ msgBox.setIcon(proxy->m_icon);
+ int ret = msgBox.exec();
+ */
+ QString displayText = proxy->m_text + QLatin1String("\n") + QLatin1String("\n")+ proxy->m_detailedText + QLatin1String("\n") + QLatin1String("\n") + proxy->m_informativeText;
+ int ret = QMessageBox::warning(0/* TODO: find appropriate widget if required or just remove this widget()*/,
+ proxy->m_text, displayText, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
+ proxy->onMessageBoxResponse(ret);
+ }
+
+ void GWebContentView::loadUrlToCurrentPage(const QString & url)
+ {
+ WRT::WrtBrowserContainer * activePage = WebPageController::getSingleton()->currentPage();
+
+ if(activePage) {
+ activePage->mainFrame()->load(url);
+ }
+ }
+
+ QWebPage *GWebContentView::currentPage() {
+ WRT::WrtBrowserContainer * activePage = WebPageController::getSingleton()->currentPage();
+ return activePage;
+ }
+
+ int GWebContentView::contentWidth()
+ {
+ return currentPage()->mainFrame()->contentsSize().width();
+ }
+
+ int GWebContentView::contentHeight()
+ {
+ return currentPage()->mainFrame()->contentsSize().height();
+ }
+
+ void GWebContentView::stop()
+ {
+ webWidget()->stop();
+ }
+
+ void GWebContentView::back()
+ {
+ qDebug() << "GWebContentView::back";
+ webWidget()->back();
+ }
+
+ void GWebContentView::forward()
+ {
+ webWidget()->forward();
+ }
+
+ void GWebContentView::reload()
+ {
+ webWidget()->reload();
+ }
+
+ int GWebContentView::scrollX()
+ {
+ return currentPage()->mainFrame()->scrollPosition().x();
+ }
+
+ int GWebContentView::scrollY()
+ {
+ return currentPage()->mainFrame()->scrollPosition().y();
+ }
+
+ void GWebContentView::zoom(bool in)
+ {
+ m_zoomIn = in;
+ if(!m_timeLine) {
+ m_timeLine = new QTimeLine();
+ connect(m_timeLine, SIGNAL(valueChanged(qreal)),
+ this, SLOT(updateZoom(qreal)));
+ }
+ else {
+ m_timeLine->stop();
+ }
+ m_timeLine->start();
+ }
+
+ void GWebContentView::toggleZoom(){
+ zoom(!m_zoomIn);
+ }
+ void GWebContentView::stopZoom() {
+ m_timeLine->stop();
+ }
+
+ void GWebContentView::updateZoom(qreal delta){
+ Q_UNUSED(delta)
+ if(m_zoomIn)
+ zoomBy(0.1);
+ else
+ zoomBy(-0.1);
+ }
+
+ void GWebContentView::onUrlChanged(const QUrl& url)
+ {
+ emit urlChanged(url.toString());
+ //NB: Brief hack
+ if(url.scheme()=="https")
+ emit secureConnection(true);
+ else
+ emit secureConnection(false);
+ }
+
+ GWebPage *GWebContentView::createSuperPage(const QString &name) {
+ qDebug() << "GWebContentView::createSuperPage: " << name;
+ GWebPage *page = 0;
+ PageMap::iterator it = m_superPages.find(name);
+ if(it == m_superPages.end()) {
+ // Doesn't exist. Create a new one.
+ page = new GSuperWebPage(0, chrome());
+ page->setParent(jsObject());
+ page->setObjectName(name);
+
+ // Add it to the superpage list.
+ m_superPages[name] = page;
+ if(m_superPages.count() == 1) {
+ // This is the only superpage, make it current.
+ m_currentSuperPage = m_superPages.find(name);
+ }
+
+ //NB: Here's how to set default webview backgound color
+ page->page()->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
+ page->page()->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
+ QPalette viewPalette = widget()->palette();
+ viewPalette.setBrush(QPalette::Base, Qt::white);
+ //viewPalette.setColor(QPalette::Window, Qt::transparent);
+ page->page()->setPalette(viewPalette);
+ //m_view->setPalette(viewPalette);
+ }
+ else {
+ qDebug() << "GWebContentView::createPage: page already exists: " << name;
+ }
+ return page;
+ }
+
+ void GWebContentView::destroySuperPage(const QString &name) {
+ qDebug() << "GWebContentView::destroySuperPage: " << name;
+ if(!m_superPages.contains(name)) return;
+
+ GWebPage *page = m_superPages.take(name);
+ if(page) {
+ delete page;
+ }
+ }
+
+ void GWebContentView::setCurrentSuperPage(const QString &name) {
+ PageMap::iterator it = m_superPages.find(name);
+ if(it != m_superPages.end()) {
+ m_currentSuperPage = it;
+ }
+ else {
+ qDebug() << "GWebContentView::setCurrentSuperPage: not found: " << name;
+ }
+ }
+
+ bool GWebContentView::isSuperPage(const QString &name){
+ PageMap::iterator it = m_superPages.find(name);
+ if(it != m_superPages.end()) {
+ return true;
+ }
+ qDebug() << "GWebContentView::superPage: not found: " << name;
+ return false;
+ }
+
+
+ GWebPage * GWebContentView::superPage(const QString &name) {
+ PageMap::iterator it = m_superPages.find(name);
+ if(it != m_superPages.end()) {
+ return it.value();
+ }
+ qDebug() << "GWebContentView::superPage: not found: " << name;
+ return 0;
+ }
+
+ void GWebContentView::showSuperPage(const QString &name) {
+ setCurrentSuperPage(name);
+ qDebug() << "GWebContentView::showSuperPage: " << currentSuperPage();
+ m_currentPageIsSuperPage = true;
+ webWidget()->setPage(currentSuperPage()->page());
+ m_touchNavigation->setPage(webWidget()->page());
+ webWidget()->page()->setPreferredContentsSize(webWidget()->size().toSize());
+ }
+
+ void GWebContentView::showNormalPage() {
+ if(webWidget()) {
+ webWidget()->showNormalPage();
+ webWidget()->setViewportSize();
+ m_touchNavigation->setPage(currentPage());
+ m_currentPageIsSuperPage =false;
+ }
+ }
+
+ QObjectList GWebContentView::getSuperPages() {
+ QObjectList *result = new QObjectList;
+ foreach(GVA::GWebPage *page, m_superPages) {
+ result->append(page);
+ }
+ // TO DO: Need to add result to JS engine so it can be cleaned up.
+ return *result;
+ }
+
+ bool GWebContentView::currentPageIsSuperPage() const {
+ //qDebug() << "GWebContentView::currentPageIsSuperPage: " << webWidget()->page();
+ return m_currentPageIsSuperPage;
+ }
+
+ void GWebContentView::onLoadStarted()
+ {
+ //qDebug() << "GWebContentView::onLoadStarted: " << QTime::currentTime();
+#if defined(__gva_no_chrome__) || defined(NO_RESIZE_ON_LOAD)
+ m_widget->onLoadStarted();
+#endif
+ emit loadStarted();
+ }
+
+ void GWebContentView::onLoadFinished(bool ok)
+ {
+ //qDebug() << "GWebContentView::onLoadFinished: " << QTime::currentTime();
+ emit loadFinished(ok);
+ //NB: page manager functions really
+ if(!m_backEnabled && currentPage()->history()->canGoBack()){
+ m_backEnabled = true;
+ emit backEnabled(true);
+ }
+ else if (m_backEnabled && !currentPage()->history()->canGoBack()){
+ m_backEnabled = false;
+ emit backEnabled(false);
+ }
+ if(!m_forwardEnabled && currentPage()->history()->canGoForward()){
+ m_forwardEnabled = true;
+ emit forwardEnabled(true);
+ }
+ else if (m_forwardEnabled && !currentPage()->history()->canGoForward()){
+ m_forwardEnabled = false;
+ emit forwardEnabled(false);
+ }
+
+ // Set focus to the Web View so that text boxes have the focus (BR-994)
+ m_widget->setFocus();
+
+#if defined(__gva_no_chrome__) || defined(NO_RESIZE_ON_LOAD)
+ m_widget->onLoadFinished();
+#endif
+ }
+
+ void GWebContentView::dump() {
+ qDebug() << "-------------";
+ qDebug() << "GWebContentView::dump: " << this;
+ qDebug() << "\tcurrent page=: " << currentPage() << " title=" << currentPage()->mainFrame()->title();
+ qDebug() << "\tcurrent superpage=: " << currentSuperPage();
+ qDebug() << "\tsuperpage count=: " << m_superPages.count();
+ foreach(GVA::GWebPage *page, m_superPages) {
+ page->dump();
+ }
+ qDebug() << "GWebContentView::dump: finished";
+ qDebug() << "-------------";
+ }
+
+// ControllableView* GWebContentView::createNew(QWidget *parent)
+// {
+// QWebPage* page = BrowserPageFactory::openBrowserPage();
+// return new GWebContentView(page, parent);
+// }
+
+
+ void GWebContentView::pageCreated(WRT::WrtBrowserContainer* newPage) {
+
+ qDebug() << "GWebContentView::pageCreated";
+ /* save the page snapshot before changing the current page to the new page*/
+ WRT::WrtBrowserContainer * currPage = WebPageController::getSingleton()->currentPage();
+ if(currPage) {
+ QWebHistoryItem item = currPage->history()->currentItem();
+ currPage->savePageDataToHistoryItem(currPage->mainFrame(), &item);
+ }
+
+ // When new windows are created from window view, as the content is empty, we should disable
+ // zoom actions. Set the user-scalable to false and also init the other zoom params
+ // so that even if we change to windows view again without loading a page we are safe.
+ // In the code-driven window usecase, this will be overwritten when the page is loaded and setViewportSize is invoked
+ newPage->setPageZoomMetaData(webWidget()->defaultZoomData());
+
+ /* Set the new page as the current page */
+ WebPageController::getSingleton()->setCurrentPage(newPage);
+
+ /* Set the web widget- this one is responsible for webnavigation etc */
+ newPage->setWebWidget(webWidget());
+
+ //connect new page main frame's initialLayoutCompleted with WebContentWidget' setViewportSize SLOT
+ connect(newPage->mainFrame(), SIGNAL(initialLayoutCompleted()), webWidget(), SLOT(setViewportSize()));
+ }
+
+ void GWebContentView::updateWebPage(WRT::WrtBrowserContainer* pg)
+ {
+ GWebContentViewWidget* w = webWidget();
+ w->setPage(pg);
+ if(pg)
+ {
+ pg->setWebWidget(w);
+
+ // Change navigation also to the current page
+ m_touchNavigation->setPage(pg);
+
+ }
+ }
+
+ void GWebContentView::pageChanged(WRT::WrtBrowserContainer* oldPage, WRT::WrtBrowserContainer* newPage) {
+ qDebug() << "GWebContentView::pageChanged";
+ Q_UNUSED(oldPage)
+ updateWebPage(newPage);
+
+ // Set new page zoom info
+ changeContentViewZoomInfo(newPage);
+ }
+
+ void GWebContentView::changeContentViewZoomInfo(WRT::WrtBrowserContainer* newPage){
+ // Copy the new page zoom info into cv
+ webWidget()->setPageZoomMetaData(newPage->pageZoomMetaData());
+
+ if (webWidget()->isUserScalable()) {
+ webWidget()->setZoomFactor(newPage->mainFrame()->zoomFactor());
+ }
+ else {
+ // Need to call setPageZoomFactor instead of setZoomFactor because setZoomFactor
+ // will not do anything if user-scalable is false. But we need to
+ // ensure that the correct zoom factor is applied as there is a possibility
+ // that we might have been on another page earlier
+ webWidget()->setPageZoomFactor(newPage->mainFrame()->zoomFactor());
+ }
+ }
+
+
+
+} // end of namespace GVA
+
+