--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/browsercore/appfw/Api/Views/HistoryView.cpp Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,480 @@
+/*
+* 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 "WrtPageManager.h"
+#include "FlowInterface.h"
+#include "HistoryView_p.h"
+#include "HistoryView.h"
+#include "HistoryViewEventContext.h"
+
+#include "qwebhistory.h"
+#include "qwebframe.h"
+#include "wrtbrowsercontainer.h"
+#include "webpagedata.h"
+#include "scriptobjects.h"
+
+#include <QDebug>
+
+namespace WRT {
+
+HistoryViewPrivate::HistoryViewPrivate(WrtPageManager * pageMgr,
+ QWidget* parent) :
+ m_flowInterface(0),
+ m_widgetParent(parent),
+ m_graphicsWidgetParent(0),
+ m_pageManager(pageMgr),
+ m_activePage(0),
+ m_historyIndex(0),
+ m_isActive(false)
+{
+ Q_ASSERT(m_pageManager);
+ init();
+}
+
+HistoryViewPrivate::HistoryViewPrivate(WrtPageManager * pageMgr,
+ QGraphicsWidget* parent) :
+ m_flowInterface(0),
+ m_widgetParent(0),
+ m_graphicsWidgetParent(parent),
+ m_pageManager(pageMgr),
+ m_activePage(0),
+ m_historyIndex(0),
+ m_isActive(false)
+{
+ Q_ASSERT(m_pageManager);
+ init();
+}
+
+HistoryViewPrivate::~HistoryViewPrivate()
+{
+ delete m_actionForward;
+ delete m_actionBack;
+ delete m_actionOK;
+ delete m_actionCancel;
+}
+
+void HistoryViewPrivate::init()
+{
+ // create the view's actions
+ m_actionForward = new QAction("Forward",m_widgetParent);
+ m_actionForward->setObjectName("Forward");
+ m_actionBack = new QAction("Back",m_widgetParent);
+ m_actionBack->setObjectName("Back");
+ m_actionOK = new QAction("OK",m_widgetParent);
+ m_actionOK->setObjectName("OK");
+ m_actionCancel = new QAction("Cancel",m_widgetParent);
+ m_actionCancel->setObjectName("Cancel");
+}
+
+/*!
+ * \class HistoryView
+ *
+ * \brief The base class for the HistoryViews
+ *
+ * This class provides the basic routines to enable history navigation.
+ * Derived classes (such as HistoryFlowView, and HistoryLiteView) supply
+ * the exact "FlowInterface" to be used, and rely on much of the base-class functionality
+ * for signal/slots, extracting history items from the current page, etc.
+ */
+
+/*!
+ Basic HistoryView constructor requires a PageManager to manage the pages
+ and a parent QWidget
+*/
+HistoryView::HistoryView(WrtPageManager * pageMgr,
+ QWidget* parent) :
+ d(new HistoryViewPrivate(pageMgr, parent))
+{
+}
+
+/*!
+ Basic HistoryView constructor requires a PageManager to manage the pages
+ and a parent QGraphicsWidget
+*/
+HistoryView::HistoryView(WrtPageManager * pageMgr,
+ QGraphicsWidget* parent) :
+ d(new HistoryViewPrivate(pageMgr, parent))
+{
+}
+
+
+HistoryView::~HistoryView()
+{
+ delete d;
+}
+
+/*!
+ Retrieve the WrtPageManager assigned to this view
+*/
+WrtPageManager* HistoryView::wrtPageManager()
+{
+ return d->m_pageManager;
+}
+
+/*!
+ Return the view's Forward QAction
+ For scrolling the history view forwards
+*/
+QAction * HistoryView::getActionForward()
+{
+ return d->m_actionForward;
+}
+
+/*!
+ Return the view's Back QAction
+ For scrolling the history view backwards
+*/
+QAction * HistoryView::getActionBack()
+{
+ return d->m_actionBack;
+}
+
+/*!
+ Return the view's OK QAction
+ For invoking the view's OK
+*/
+QAction * HistoryView::getActionOK()
+{
+ return d->m_actionOK;
+}
+
+/*!
+ Return the view's Cancel QAction
+ For invoking the view's Cancel
+*/
+QAction * HistoryView::getActionCancel()
+{
+ return d->m_actionCancel;
+}
+
+/*!
+ Return the widget handle of this view
+*/
+QGraphicsWidget* HistoryView::widget() const
+{
+ return d->m_flowInterface;
+}
+
+/*!
+ Return the title of this view for display
+*/
+QString HistoryView::title() const
+{
+ return QString("History");
+}
+
+/*!
+ Return whether this view is active or not
+*/
+bool HistoryView::isActive()
+{
+ return d->m_isActive;
+}
+
+
+/*!
+ Return the list of public QActions most relevant to the view's current context
+ (most approptiate for contextual menus, etc.
+*/
+QList<QAction*> HistoryView::getContext()
+{
+ // for now, all actions valid at all times
+ // but there may be some logic here to determine context
+ QList<QAction*> contextList;
+ contextList <<
+ d->m_actionForward <<
+ d->m_actionBack <<
+ d->m_actionOK <<
+ d->m_actionCancel;
+ return contextList;
+}
+
+
+
+/*!
+ activate the view's resources. Could be connected by client to view visibility
+*/
+void HistoryView::activate()
+{
+ Q_ASSERT(!d->m_isActive);
+
+ if(!d->m_flowInterface)
+ return;
+
+ d->m_flowInterface->init();
+ updateHistory(true);
+
+ // now forward visual flow lite's signals
+ connect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), SIGNAL(centerIndexChanged(int)));
+ connect(d->m_flowInterface, SIGNAL(ok(int)), this, SIGNAL(ok(int)));
+ connect(d->m_flowInterface, SIGNAL(cancel()), this, SIGNAL(cancel()));
+
+ // internally process the index change signal as well, and page load complete
+ connect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), this, SLOT(updateActions(int)));
+ connect(d->m_pageManager,SIGNAL(loadFinished(bool)),this,SLOT(updateHistory(bool)));
+
+ // auto-link relevant actions to slots
+ connect(d->m_actionForward, SIGNAL(triggered()), this, SLOT(forward()));
+ connect(d->m_actionBack, SIGNAL(triggered()), this, SLOT(back()));
+
+ widget()->installEventFilter(this);
+ connect(this, SIGNAL(contextEvent(QObject *)), jsObject(), SLOT(onContextEvent(QObject *)));
+
+ // show and set index
+ d->m_flowInterface->show();
+ d->m_historyIndex = 0;
+ d->m_isActive = true;
+
+ emit activated();
+}
+
+/*!
+ deactivate the view's resources. Could be connected by client to view visibility
+*/
+void HistoryView::deactivate()
+{
+ Q_ASSERT(d->m_isActive);
+
+ if(!d->m_flowInterface)
+ return;
+
+ // disconnect signals
+ disconnect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), this, SIGNAL(centerIndexChanged(int)));
+ disconnect(d->m_flowInterface, SIGNAL(ok(int)), this, SIGNAL(ok(int)));
+ disconnect(d->m_flowInterface, SIGNAL(cancel()), this, SIGNAL(cancel()));
+
+ // internally process the index change signal as well
+ disconnect(d->m_flowInterface, SIGNAL(centerIndexChanged(int)), this, SLOT(updateActions(int)));
+ disconnect(d->m_pageManager,SIGNAL(loadFinished(bool)),this,SLOT(updateHistory(bool)));
+
+ // auto-link relevant actions to slots
+ disconnect(d->m_actionForward, SIGNAL(triggered()), this, SLOT(forward()));
+ disconnect(d->m_actionBack, SIGNAL(triggered()), this, SLOT(back()));
+
+ widget()->removeEventFilter(this);
+ disconnect(this, SIGNAL(contextEvent(QObject *)), jsObject(), SLOT(onContextEvent(QObject *)));
+
+ // cleanup
+ d->m_flowInterface->deleteLater();
+ d->m_flowInterface = NULL;
+ d->m_isActive = false;
+
+ emit deactivated();
+}
+
+void HistoryView::updateHistory(bool status)
+{
+ if (!status) {
+ return;
+ }
+
+ if (!d->m_flowInterface) {
+ return;
+ }
+
+ // clear PictureFlow
+ d->m_flowInterface->clear();
+
+ d->m_activePage = d->m_pageManager->currentPage();
+
+ if (d->m_activePage->history()->count() < 0) {
+ return;
+ }
+
+ QWebHistoryItem item = d->m_activePage->history()->currentItem();
+ d->m_activePage->savePageDataToHistoryItem(d->m_activePage->mainFrame(), &item);
+
+ QList<QWebHistoryItem> items = d->m_activePage->history()->items();
+ for (int i = 0; i < d->m_activePage->history()->count(); i++) {
+ QWebHistoryItem item = items.at(i);
+ WebPageData data = item.userData().value<WebPageData>();
+ QImage img = data.m_thumbnail;
+ d->m_flowInterface->addSlide(img);
+ }
+
+ int currentItemIndex(d->m_activePage->history()->currentItemIndex());
+ d->m_flowInterface->setCenterIndex(currentItemIndex);
+ updateActions(currentItemIndex);
+}
+
+int HistoryView::currentIndex() {
+
+ return (d->m_activePage->history()->currentItemIndex());
+}
+
+/*!
+ set the history view's center index
+*/
+void HistoryView::setCenterIndex(int index)
+{
+ // first emit center index change
+ emit centerIndexChanged(index);
+
+ d->m_historyIndex = index - d->m_activePage->history()->currentItemIndex();
+
+ emit titleChanged(itemTitle(d->m_historyIndex));
+
+ //if(d->m_flowInterface)
+ //{
+ // qDebug() << "Setting center index " << index;
+ //d->m_flowInterface->setCurentIndex(index);
+ //}
+
+}
+
+/*!
+ scroll forward in the history view
+*/
+void HistoryView::forward()
+{
+ if(!d->m_flowInterface)
+ return;
+
+ d->m_flowInterface->showNext();
+}
+
+/*!
+ scroll back in the history view
+*/
+void HistoryView::back()
+{
+ if(!d->m_flowInterface)
+ return;
+
+ d->m_flowInterface->showPrevious();
+}
+
+void HistoryView::updateActions(int centerIndex)
+{
+ d->m_actionBack->setEnabled(centerIndex != 0);
+ d->m_actionForward->setEnabled(centerIndex < (d->m_activePage->history()->count() - 1));
+}
+
+QRect HistoryView::centralRect()
+{
+ if(!d->m_flowInterface)
+ return QRect();
+
+ return d->m_flowInterface->centralRect();
+}
+
+bool HistoryView::eventFilter(QObject *obj, QEvent *event)
+{
+ if (event->type() == QEvent::ContextMenu && obj == widget()) {
+ return handleWidgetContextMenuEvent(static_cast<QContextMenuEvent *>(event));
+ }
+
+ // standard event processing
+ return ControllableViewBase::eventFilter(obj, event);
+}
+
+bool HistoryView::handleWidgetContextMenuEvent(QContextMenuEvent *event)
+{
+// WRT::HistoryViewEventContext *context =
+// new WRT::HistoryViewEventContext(type(),
+// cmEvent->pos(),
+// d->m_flowInterface->centerIndex(),
+// itemTitle(d->m_flowInterface->centerIndex()));
+
+ // Create a javascript-accessible object with properties containing the required info.
+ QObject *context = new QObject();
+ context->setObjectName("historyContextEvent");
+ context->setProperty("viewType", type());
+ context->setProperty("itemIndex", d->m_flowInterface->centerIndex());
+ context->setProperty("itemTitle", itemTitle(d->m_flowInterface->centerIndex()));
+
+ // Create an object representing the position of the event. Make it a child of the context object
+ // so it can be accessed from javascript.
+ new ScriptPoint(context, event->pos(), "pos");
+
+ // Pass ownership to the javascript engine.
+ QWebFrame *chrome = chromeFrame();
+ if(chrome) {
+ chrome->addToJavaScriptWindowObject(context->objectName(), context, QScriptEngine::ScriptOwnership);
+ }
+
+ emit contextEvent(context);
+
+ return true;
+}
+
+QString HistoryView::itemTitle(int index) const
+{
+ QWebHistoryItem item = d->m_activePage->history()->itemAt(d->m_flowInterface->centerIndex());
+ QString title;
+ if (item.isValid()) {
+ title = item.title();
+ if (title.isNull() || title.isEmpty()) {
+ title = item.url().toString();
+ }
+ }
+ return title;
+}
+
+// -------------------------------------------
+
+HistoryViewJSObject::HistoryViewJSObject(HistoryView* view, QWebFrame* webFrame, const QString& objectName)
+ : ControllableViewJSObject(view, webFrame, objectName)
+{
+ connect(view,SIGNAL(ok(int)),this,SLOT(ok(int)));
+ connect(view,SIGNAL(cancel()),this,SLOT(cancel()));
+
+ connect(view,SIGNAL(activated()),this,SIGNAL(activated()));
+ connect(view,SIGNAL(deactivated()),this,SIGNAL(deactivated()));
+}
+
+HistoryViewJSObject::~HistoryViewJSObject()
+{
+ disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(ok(int)),this,SLOT(ok(int)));
+ disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(cancel()),this,SLOT(cancel()));
+
+ disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(activated()),this,SIGNAL(activated()));
+ disconnect(static_cast<HistoryView*>(m_contentView),SIGNAL(deactivated()),this,SIGNAL(deactivated()));
+}
+
+void HistoryViewJSObject::ok(int item)
+{
+ emit done(item);
+}
+
+void HistoryViewJSObject::cancel()
+{
+ emit done(historyView()->currentIndex());
+}
+
+void HistoryViewJSObject::onContextEvent(QObject *context){
+ emit contextEvent(context);
+}
+
+/*!
+ \fn void HistoryView::centerIndexChanged(int index);
+ emitted when the center index changed
+*/
+
+/*!
+ \fn void HistoryView::ok(int item);
+ emitted when the ok action has occured, contains history index at the time of close
+*/
+
+/*!
+ \fn void HistoryView::cancel();
+ emitted when the cancel action has occured
+*/
+
+} // namespace WRT