--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/browsercore/core/wrtbrowsercontainer.cpp	Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,518 @@
+/*
+* Copyright (c) 2009 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 "browserpagefactory.h"
+#include "webcontentview.h"
+#include "wrtpage.h"
+#include "wrtbrowsercontainer_p.h"
+#include "wrtbrowsercontainer.h"
+#include "webpagedata.h"
+#include "qwebhistory.h"
+#include "qwebframe.h"
+#include "SchemeHandlerBr.h"
+#include "webnetworkaccessmanager.h"
+#ifdef QT_MOBILITY_BEARER_MANAGEMENT
+#include "WebNetworkConnectionManager.h"
+#endif // QT_MOBILITY_BEARER_MANAGEMENT
+#include "webcookiejar.h"
+#include "webnavigation.h"
+#include "secureuicontroller.h"
+#include "LoadController.h"
+#include "WebDialogProvider.h"
+#include "bedrockprovisioning.h"
+#include <QPainter>
+#include <QAuthenticator>
+#include <QFile>
+#include <QMessageBox>
+
+namespace WRT
+{
+
+const int historyItemsCount = 20;
+
+WrtBrowserContainerPrivate::WrtBrowserContainerPrivate(QObject* parent,
+		WrtBrowserContainer* page/*never NULL*/) : m_schemeHandler(new SchemeHandler())
+,   m_pageFactory(0)
+,   m_widget(0)
+{
+    assert(page);
+    m_page = page;
+
+    m_secureController = new WRT::SecureUIController(parent);
+    m_loadController = new  WRT::LoadController();
+ 
+    // Turn off the scroll bars of main frame
+    m_page->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
+    m_page->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
+    
+}
+
+WrtBrowserContainerPrivate::~WrtBrowserContainerPrivate()
+{
+	m_page->setView(0);
+	if (m_page)
+		m_page->disconnect();
+	delete m_schemeHandler;
+  delete m_secureController;
+  delete m_loadController;
+}
+
+/*!
+ * Static function which creates Wrt page with parent Widget
+ * @param parent   : parent widget for the new page
+ * @return WrtBrowserContainer : Page handle to the newly created page
+ */
+WrtBrowserContainer* WrtBrowserContainer::createPageWithWidgetParent(
+		QObject* parent, WrtBrowserContainer* page)
+{
+    if (page)
+    {
+        page->setParent(parent);
+        return page;
+    }
+    else
+        return new WrtBrowserContainer(parent);
+}
+
+/*!
+ * \class WrtBrowserContainer
+ * \brief Description: This class is a handle to open page on which user can
+ * load an url , view history items, load an history item into the page etc.
+ * @see WrtPageManager
+ */
+
+/*!
+ * WrtBrowserContainer Constructor
+ * @param parent : Widget parent
+ */
+WrtBrowserContainer::WrtBrowserContainer(QObject* parent) :
+	WrtPage(parent), d(new WrtBrowserContainerPrivate(this, this))
+{
+	// Download related enable "forwardUnsupportedContent" to redirect unsupported content to download manager
+	setForwardUnsupportedContent(true);
+
+#ifndef NO_NETWORK_ACCESS_MANAGER	
+	setNetworkAccessManager(new WebNetworkAccessManager(this,this));
+#endif
+	
+#ifdef QT_MOBILITY_BEARER_MANAGEMENT
+	setNetworkConnectionManager(new WebNetworkConnectionManager(this));
+#endif // QT_MOBILITY_BEARER_MANAGEMENT
+	history()->setMaximumItemCount(historyItemsCount);
+
+	connect(this,
+			SIGNAL(saveFrameStateRequested(QWebFrame*, QWebHistoryItem*)),
+			this, SLOT(savePageDataToHistoryItem(QWebFrame*, QWebHistoryItem*)));
+
+    /* Connect secure related signals and slots */
+    connect(mainFrame(), SIGNAL(urlChanged(QUrl)), d->m_secureController, SLOT(setTopLevelScheme(const QUrl &)));
+    connect(this, SIGNAL(loadFinished(bool)), d->m_secureController, SLOT( endSecureCheck(bool) ) );
+    connect(d->m_secureController, SIGNAL(pageSecureState(int)), this, SLOT(pageSecureState(int)));
+    connect(networkAccessManager(), SIGNAL(sslErrors(QNetworkReply *, const QList<QSslError> &)), d->m_secureController, SLOT(onSslErrors(QNetworkReply *, const QList<QSslError> &)));
+
+    connect(this, SIGNAL(loadStarted()), d->m_loadController, SLOT(loadStarted()));
+    connect(this, SIGNAL(loadProgress(int)), d->m_loadController, SLOT(loadProgress(int)));
+    connect(this, SIGNAL(loadFinished(bool)), d->m_loadController, SLOT(loadFinished(bool)));
+    connect(mainFrame(), SIGNAL(urlChanged(QUrl)), d->m_loadController, SLOT(urlChanged(QUrl)));
+    
+	// All pages in the browser share the same pageGroup.
+	d->m_pageGroupName = "nokia_page_group";
+	setPageGroupName(d->m_pageGroupName);
+}
+
+/*!
+ * WrtBrowserContainer destructor
+ */
+WrtBrowserContainer::~WrtBrowserContainer()
+{
+	// gracefully but warn, disconnect anything connected to this page
+	if (!disconnect())
+		qWarning("WrtPage destructor blanket disconnect failed");
+
+    //setNetworkAccessManager(NULL);
+   delete d;
+}
+
+QGraphicsWidget* WrtBrowserContainer::webWidget() const
+{
+    return d->m_widget;
+}
+
+void WrtBrowserContainer::setWebWidget(QGraphicsWidget* view)
+{
+    if(d->m_widget) {
+        disconnect(static_cast<WebContentWidget*>(webWidget()), SIGNAL(pageZoomMetaDataChange(QWebFrame*, ZoomMetaData)), this, SLOT(pageZoomMetaDataChange(QWebFrame*, ZoomMetaData)));
+    }
+
+    d->m_widget = view;
+
+    if (view)
+    {
+        QGraphicsWebView* webView = static_cast<QGraphicsWebView*>(view);
+        if(webView)
+            webView->setPage(this);
+
+        /* Currently connecting it here. Need to revisit if the dialog is enabled in the
+         * context of multiple windows */
+        connect( d->m_secureController, SIGNAL( showMessageBox(WRT::MessageBoxProxy*)), static_cast<WebContentWidget*>(webWidget())->view(), SLOT( showMessageBox(WRT::MessageBoxProxy*)));
+
+        connect(static_cast<WebContentWidget*>(webWidget()), SIGNAL(pageZoomMetaDataChange(QWebFrame*, ZoomMetaData)), this, SLOT(pageZoomMetaDataChange(QWebFrame*, ZoomMetaData)));
+    }
+}
+ 
+/*!
+ * Handles pageSecureState state 
+ */
+void WrtBrowserContainer::pageSecureState(int state) {
+
+    emit secureStateChange(state);
+
+}
+
+/*!
+ * Returns schemeHandler
+ */
+SchemeHandler* WrtBrowserContainer::schemeHandler() const
+{
+   return d->m_schemeHandler;
+}
+
+/*!
+ * Gets the history count for this page, i.e gets the number of urls loaded
+ * onto this page
+ * @return  History count of this page
+ */
+int WrtBrowserContainer::getHistoryCount() const
+{
+	return history()->count();
+}
+
+/*!
+ * Triggers public Action
+ * @param WebAction : web action to be triggred
+ * @param checked  : true/false
+ * @see   WebAction
+ */
+/*void WrtBrowserContainer::triggerAction(QWebPage::WebAction action, bool checked)
+ {
+ triggerAction(action, checked);
+ }
+ */
+
+/*!
+ * clears cookies
+ */
+void WrtBrowserContainer::clearCookies()
+{
+	return ((CookieJar*) networkAccessManager()->cookieJar())->clear();
+}
+
+bool WrtBrowserContainer::clearNetworkCache()
+{
+   bool ok = false;
+    QAbstractNetworkCache* diskCache = networkAccessManager()->cache();
+    diskCache->clear();
+    if (!diskCache->cacheSize()) { 
+       // Unless there was failures clearing the cache cacheSize() should return 0 after a call to clear 
+       ok = true;
+   }
+   return ok;
+}
+
+/*!
+ * This function page thumbnail for this page as specified by X & Y co-ordinate scale factors
+ * @param  scaleX :  X Co-ordinate scale factor for the page thumbnail
+ * @param  scaleY :  y Co-ordinate scale factor for the page thumbnail
+ */
+QImage WrtBrowserContainer::pageThumbnail(qreal scaleX, qreal scaleY)
+{
+    qDebug() << "WrtBrowserContainer::pageThumbnail:" << webWidget()->size();
+    QSize size = webWidget()->size().toSize();
+    QImage image(size, QImage::Format_RGB32);
+
+    QPainter painter(&image);
+    QRect r(0, 0, size.width(), size.height());
+    QRegion clip(r);
+    painter.save();
+    painter.setBrush(Qt::white);
+    painter.drawRect(r);
+    painter.restore();
+    mainFrame()->render(&painter, clip);
+    return image;
+}
+
+/*!
+ * sets the page zoom factor as specified by zoom
+ * @param zoom : page zoom factor to be set
+ */
+void WrtBrowserContainer::setPageZoomFactor(qreal zoom)
+{
+   // FiX ME ... canvas zoom doesn't seem to support text-only zooming.
+   //static_cast<WebCanvasWidget*>(webWidget())->canvas()->setPageZoomFactor(zoom);
+
+	bool isZoomTextOnly = BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->value(
+			"ZoomTextOnly").toBool();
+
+	if (!isZoomTextOnly)
+	{
+		// mainFrame()->setZoomFactor(zoom);
+		static_cast<WebContentWidget*> (webWidget())->setZoomFactor(zoom);
+	}
+	else
+	{
+		//mainFrame()->setTextSizeMultiplier(zoom);
+		static_cast<WebContentWidget*> (webWidget())->setTextSizeMultiplier(
+				zoom);
+    }
+}
+
+/*!
+ * setpageDirtyZoomFactor
+ * @param zoom: page zoom factor to be set
+ */
+void WrtBrowserContainer::setPageDirtyZoomFactor(qreal zoom)
+{
+   // FIXME: dirty page zoom is not supported yet in single-buffer mode.
+   static_cast<WebContentWidget*> (webWidget())->setDirtyZoomFactor(zoom);
+}
+
+/*!
+ * setpageCenterZoomFactor
+ * @param zoom: center page zoom factor to be set
+ */
+// TODO: hold on this change until zoom/scrolling improvement 
+/*
+ void WrtBrowserContainer::setPageCenterZoomFactor(qreal zoom)
+ {
+ static_cast<WebCanvasWidget*>(webWidget())->canvas()->setPageCenterZoomFactor(zoom);
+ }
+ */
+/*!
+ * returns the current page zoom factor of this page
+ * @return current zoom factor
+ */
+qreal WrtBrowserContainer::pageZoomFactor() const
+{
+   return static_cast<WebContentWidget*> (webWidget())->zoomFactor();
+}
+
+/*!
+ * sets the Canvas ScaleFactor  for this page
+ * @param  scaleX :  X Co-ordinate scale factor
+ * @param  scaleY :  Y Co-ordinate scale factor
+ */
+void WrtBrowserContainer::setCanvasScaleFactor(qreal scaleX, qreal scaleY)
+{
+   QTransform transform;
+   transform.scale(scaleX, scaleY);
+   //     static_cast<ContentView*>(webWidget())->setTransform(transform);
+}
+
+/*!
+ * allows offlineStorage for url
+ * @param url : url for which offlinestorage has to be enabled
+ */
+bool WrtBrowserContainer::allowOfflineStorage(const QUrl& url)
+{
+   if (BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->value("SecurityLevel").toInt()
+         != SecurityHigh)
+      return true;
+
+	QStringList yesno;
+	yesno << "Yes" << "No";
+	return (WebDialogProvider::getButtonResponse(
+			0, /* webWidget(), Check, that widget is required */
+			QString(
+					"Offline Database: This host asking for storing data in offline database, allow?"),
+			yesno));
+}
+
+
+/*!
+ Pulic Slots:
+ void savePageDataToHistoryItem(QWebFrame*, QWebHistoryItem* item);
+ void slotAuthenticationRequired(QNetworkReply *, QAuthenticator *);
+ void slotProxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *);
+ */
+
+/*!
+ * Public slot, saves the page data (like thumbail, current position, zoom factor etc ) to WebHistoryItem
+ * @frame  main frame for which the data has to be stored
+ * @item   handle to QWebHistoryItem into which the page data has to be saved.
+ */
+
+void WrtBrowserContainer::savePageDataToHistoryItem(QWebFrame* frame,
+      QWebHistoryItem* item)
+{
+    if (frame != mainFrame() || !item->isValid() || !webWidget())
+    {
+        return;
+    }
+    if (restoreSession()) return;
+    	
+    WebPageData data(this);
+    //   WebPageData data = item->userData().value<WebPageData>();
+    data.m_zoomFactor = pageZoomFactor();
+    data.m_thumbnail = pageThumbnail(1.0, 1.0);//data.m_zoomFactor, data.m_zoomFactor);
+
+    QPoint pos(0, 0);
+    //    pos = static_cast<WebCanvasWidget*>(webWidget())->canvas()->canvasToDocument(pos);
+    pos = mainFrame()->scrollPosition();
+    data.m_contentsPos = pos;
+    QVariant variant;
+    variant.setValue(data);
+    item->setUserData(variant);
+    //ii++;
+}
+
+/*!
+ * Public slot  AuthenticationRequired
+ * Launches dialog for user name and password if Authentication is required for page load.
+ * @param reply     : network reply
+ * @param  athenticator : athenticator
+ */
+void WrtBrowserContainer::slotAuthenticationRequired(QNetworkReply* reply,
+      QAuthenticator* authenticator)
+{
+	QString username, password;
+	if (WebDialogProvider::getUsernamePassword(0/*webWidget()*/, username, password))
+	{
+		authenticator->setUser(username);
+		authenticator->setPassword(password);
+    }
+}
+
+/*!
+ * public slot for setting proxy when Authentication is Required
+ * @param networkProxy : network Proxy
+ * @param authenticator : authenticator
+ */
+void WrtBrowserContainer::slotProxyAuthenticationRequired(
+      const QNetworkProxy& networkProxy, QAuthenticator* authenticator)
+{
+	QString username, password;
+	if (WebDialogProvider::getUsernamePassword(0/*webWidget()*/, username, password))
+	{
+		authenticator->setUser(username);
+		authenticator->setPassword(password);
+    }
+}
+
+QWebPage* WrtBrowserContainer::createWindow(
+    QWebPage::WebWindowType webWindowType)
+{
+
+    /* When WrtPage is created, QWebSettings::JavascriptCanOpenWindows is initialized
+     * to popup setting value. Need not do any check here 
+     */
+    if (d->m_pageFactory)
+    {
+        // no need to signal in this case
+        return d->m_pageFactory->openPage();
+    }
+
+    WrtBrowserContainer* wrtPage = new WrtBrowserContainer();
+    emit createNewWindow(wrtPage);
+    return wrtPage;
+}
+
+void WrtBrowserContainer::setPageFactory(BrowserPageFactory* f)
+{
+    d->m_pageFactory = f;
+}
+
+void WrtBrowserContainer::setElementType(
+      wrtBrowserDefs::BrowserElementType& aElType)
+{
+    m_elementType = aElType;
+}
+wrtBrowserDefs::BrowserElementType WrtBrowserContainer::getElementType()
+{
+   return m_elementType;
+}
+
+QString WrtBrowserContainer::pageTitle(){
+
+    QString title = mainFrame()->title();
+    
+    // If mainFrame title is empty we may be restoring session
+    // Check history title
+    if (title.isEmpty()){ 
+    	title = history()->currentItem().title();
+    }
+    
+    /* If there is no title, provide the partial url */
+    if (title.isEmpty()) {
+        QUrl url  = mainFrame()->url(); 
+        // If mainframe url is empty, we may be restoring session
+        // check history url
+        if (url.isEmpty()) {
+        	url = history()->currentItem().url();
+        }
+        title = url.toString();
+        QString scheme=url.scheme();
+        title.remove(0, scheme.length() + 3); // remove "scheme://"
+        if (title.startsWith("www.", Qt::CaseInsensitive)) {
+            title.remove(0, 4);
+        }
+
+    }
+    return title;
+}
+
+int WrtBrowserContainer::secureState() {
+
+    return d->m_secureController->secureState();
+}
+bool WrtBrowserContainer::restoreSession() {
+	if (d->m_pageFactory)
+    return d->m_pageFactory->m_bRestoreSession;
+  else
+    return true;
+}
+
+bool WrtBrowserContainer::emptyWindow() {
+
+    bool result= false;
+    if (mainFrame()->title()  == "" && mainFrame()->url().toString() == "" )
+        result = true;
+
+    return result;
+}
+
+void WrtBrowserContainer::pageZoomMetaDataChange(QWebFrame* frame,  ZoomMetaData  zoomData ){
+
+    //qDebug() << __func__ << "Frame " << frame << "My Frame " << mainFrame();
+    if (frame == mainFrame()) {
+        setPageZoomMetaData(zoomData);
+    } 
+}
+
+ZoomMetaData WrtBrowserContainer::pageZoomMetaData() {
+    return d->m_zoomData ;
+
+}
+void WrtBrowserContainer::setPageZoomMetaData( ZoomMetaData  zoomData ){
+
+    d->m_zoomData = zoomData;
+}
+
+
+}
+
+