FCL/sf/mw/hgwidgets: comparison ganeswidgets/src/HgContainer.cpp

equal deleted inserted replaced

-:463f1934e292
+:c348b9772569
 */
 #include <QGesture>
 #include <QPainter>
 #include <QTimer>
-#include <hbgridviewitem>
+#include <HbMainWindow>
-#include <hbmainwindow>
 #include "hgcontainer.h"
 #include "hgmediawallrenderer.h"
 #include "hgquad.h"
 #include "hgvgquadrenderer.h"
 #include "hgvgimage.h"
 #include "hgwidgetitem.h"
 #include "trace.h"
-//#include <hbstyleoptioncheckbox.h>
+#include <HbCheckBox>
-//#include <hbcheckbox>
+#include <HbGridViewItem>
-#include <hbgridviewitem>
+#include <HbGridView>
-#include <hbgridview>
+#include <HbIconItem>
-#include <hbiconitem>
+#include <QAbstractItemModel>
-#include <qabstractitemmodel>
+#include <HbTapGesture>
 #include "hglongpressvisualizer.h"
 static const qreal KSpringKScrolling(50.0);
 static const qreal KSpringKScrollBar(10.0);
 static const qreal KSpringDampingScrolling(20.0);
 mLongPressTimer(NULL),
 mHitItemIndex(-1),
 mItemSizePolicy(HgWidget::ItemSizeAutomatic),
 mOrientation(Qt::Vertical),
 mDelayedScrollToIndex(),
-mIgnoreTap(false)
+mIgnoreGestureAction(false)
 {
 FUNC_LOG;
+setFlag(QGraphicsItem::ItemHasNoContents, false);
 grabGesture(Qt::PanGesture);
 grabGesture(Qt::TapGesture);
-grabGesture(Qt::TapAndHoldGesture);
 }
 HgContainer::~HgContainer()
 {
 FUNC_LOG;
 /*!
 Changes the selection model of the container.
 Ownership is not transferred.
 Widget is redrawn to make new selection visible.
 */
-void HgContainer::setSelectionModel(QItemSelectionModel *selectionModel)
+void HgContainer::setSelectionModel(QItemSelectionModel *selectionModel, const QModelIndex &defaultItem)
 {
 FUNC_LOG;
 HANDLE_ERROR_NULL(selectionModel); // Parameter is always a valid QItemSelectionModel
-if (mSelectionModel != selectionModel) {
+if (mSelectionModel == selectionModel) return;
-if (mSelectionModel) { // mSelectionModel is 0 when called first time
-mSelectionModel->disconnect(SIGNAL(currentChanged(QModelIndex,QModelIndex)), this);
+bool defaultCurrentSet(false);
-if (mSelectionModel->currentIndex().isValid() &&
+if (!selectionModel->currentIndex().isValid()) { // If there is valid current item, do not change it
-!(selectionModel->currentIndex().isValid())) {
+if (!mSelectionModel && defaultItem.isValid()) { // mSelectionModel is 0 when called first time
-selectionModel->setCurrentIndex(mSelectionModel->currentIndex(),
+selectionModel->setCurrentIndex(defaultItem, QItemSelectionModel::Current);
-QItemSelectionModel::Current);
+defaultCurrentSet = true;
 }
-}
+else if (mSelectionModel && mSelectionModel->currentIndex().isValid()) {
-mSelectionModel = selectionModel;
+selectionModel->setCurrentIndex(mSelectionModel->currentIndex(),
-connect(mSelectionModel, SIGNAL(currentChanged(QModelIndex,QModelIndex)),
+QItemSelectionModel::Current);
-SLOT(updateByCurrentIndex(QModelIndex)));
+}
+}
+mSelectionModel = selectionModel;
+if (mSelectionModel->currentIndex().isValid() && !defaultCurrentSet) {
+scrollTo(mSelectionModel->currentIndex());
+}
+else {
 update();
 }
 }
 /*!
 }
 void HgContainer::setOrientation(Qt::Orientation orientation, bool animate)
 {
 FUNC_LOG;
 mOrientation = orientation;
 mRenderer->setOrientation(orientation);
 mRenderer->setScrollDirection(orientation, animate);
-if (!mSpring.isActive() && mSpring.pos().x() > worldWidth())
+if (mSpring.isActive()) {
-boundSpring();
+// Need to stop scrolling.
+mSpring.cancel();
+}
 }
 void HgContainer::scrollToPosition(qreal value, bool animate)
 {
 FUNC_LOG;
 }
 void HgContainer::scrollTo(const QModelIndex &index)
 {
 FUNC_LOG;
+INFO("Scrolling to" << index);
 if (index.isValid() && mRenderer->getRowCount() > 0 ) {
 QRectF containerRect(rect());
 if (containerRect.isNull()) {
 // Container hasn't been resized yet. We need to know the container
 // size before we can calculate if index we are scrolling to is valid.
 // Store scrollTo index and scrolling is performed when container is resized.
 mDelayedScrollToIndex = index;
-}
+return;
+}
 // Container has some size. We can try to calculate if scrollto index is valid.
 // ScrollTo index will be the top item in grid and left item on coverflow.
 if (!mRenderer->coverflowModeEnabled()) {
 // Grid case
 int itemsOnScreen = 0;
 if (scrollDirection()== Qt::Vertical) {
 const int rowHeight = mRenderer->getImageSize().height() + mRenderer->getSpacing().height();
 itemsOnScreen++;
 }
 itemsOnScreen *= rowCount();
 if (itemsOnScreen + index.row() > mItems.count()) {
 int newItem = mItems.count()-itemsOnScreen;
 if (mItems.count()%rowCount())
 newItem += rowCount() - (mItems.count()%rowCount());
 if (newItem < 0)
 newItem = 0;
 scrollToPosition(QPointF(newItem/mRenderer->getRowCount(),0), false);
 } else {
 scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);
 }
 } else {
 }
 itemsOnScreen *= rowCount();
 if (itemsOnScreen + index.row() > mItems.count()) {
 int newItem = mItems.count()-itemsOnScreen;
 if (mItems.count()%rowCount())
 newItem += rowCount() - (mItems.count()%rowCount());
 if (newItem < 0) newItem = 0;
 scrollToPosition(QPointF(newItem/mRenderer->getRowCount(),0), false);
 } else {
 scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);
 }
 }
 updateBySpringPosition();
 } else {
 // Coverflow case. TODO, this will need some finetuning.
 scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);
 updateBySpringPosition();
 }
 }
 }
 void HgContainer::itemDataChanged(const QModelIndex &firstIndex, const QModelIndex &lastIndex)
 {
 int HgContainer::flags(int index) const
 {
 if (index >= 0 && index < itemCount()) {
 if (mSelectionMode != HgWidget::NoSelection) {
-// TODO, fix these returns values when we can use the checkbox indicators.
 if (mSelectionModel && mSelectionModel->isSelected(mSelectionModel->model()->index(index, 0))) {
 return 1; // TODO: Assign flag to mark indicator
 } else
-return 0;
+return 2;
 }
 }
 return 0;
 }
 void HgContainer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
 Q_UNUSED(option)
 Q_UNUSED(widget)
 // update spring position at paint if needed,
 // this is hack for scrollbar, since dragging it
 // causes also paint events in here
 if (mSpring.updatePositionIfNeeded())
 {
 qreal pos = mSpring.pos().x();
 onScrollPositionChanged(pos);
 emit scrollPositionChanged(pos, true);
 }
 QPainter::RenderHints hints = painter->renderHints();
 painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 // interpolate spring velocity towards zero, this is done
 // so that spring velocity for rendering doesn't drop directly to
 // zero when dragging starts
 qreal springVel = mSpring.velocity().x();
 mRenderer->setCameraDistance(getCameraDistance(springVel));
 mRenderer->setCameraRotationY(getCameraRotationY(springVel));
 mRenderer->draw(mSpring.startPos(), mSpring.pos(), mSpring.endPos(),
 springVel, painter, sceneTransform(), rect());
-painter->setRenderHint(QPainter::SmoothPixmapTransform, false);
+painter->setRenderHint(QPainter::SmoothPixmapTransform, (hints.testFlag(QPainter::SmoothPixmapTransform)) );
 }
 void HgContainer::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
 FUNC_LOG;
 // this needs to be implemented for gesture framework to work
 void HgContainer::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
 Q_UNUSED(event);
-if (mSpring.isActive() && !mRenderer->coverflowModeEnabled()) {
-// We could do some small animation when scrolling is stopped.
-mSpring.cancel();
-update();
-mIgnoreTap = true;
-} else {
-mIgnoreTap = false;
-}
 }
 void HgContainer::gestureEvent(QGestureEvent *event)
 {
 FUNC_LOG;
+if (mItems.count() == 0) {
+// we have no items so no need to handle the gesture.
+event->ignore();
+return;
+}
 bool eventHandled(false);
 // Event may contain more than one gesture type
-if (QGesture *gesture = event->gesture(Qt::TapAndHoldGesture)) {
+HbTapGesture *tap = 0;
-QTapAndHoldGesture *tapAndHold = static_cast<QTapAndHoldGesture *>(gesture);
+if (QGesture *gesture = event->gesture(Qt::TapGesture)) {
-if (handleLongTap(tapAndHold->state(),
+tap = static_cast<HbTapGesture *>(event->gesture(Qt::TapGesture));
-mapFromScene(event->mapToGraphicsScene(tapAndHold->position())))) {
+if (tap->tapStyleHint() == HbTapGesture::TapAndHold) {
-}
+eventHandled = handleLongTap(tap->state(),
-}
+mapFromScene(event->mapToGraphicsScene(tap->hotSpot())));
-else if (QGesture *gesture = event->gesture(Qt::TapGesture)) {
-// Tap and hold is not working yet in HW, tap gesture is delivered instead
+} else {
-QTapGesture *tap = static_cast<QTapGesture *>(gesture);
+eventHandled = handleTap(tap->state(),
-eventHandled = handleTap(tap->state(),
+mapFromScene(event->mapToGraphicsScene(tap->hotSpot())));
-mapFromScene(event->mapToGraphicsScene(tap->position())));
+}
 }
-else if (QGesture *pan = event->gesture(Qt::PanGesture)) {
+if (QGesture *pan = event->gesture(Qt::PanGesture)) {
 eventHandled = handlePanning(static_cast<QPanGesture*>(pan));
-}
+} else if( mIgnoreGestureAction && tap && tap->state() == Qt::GestureCanceled ) {
+// user has tapped or long pressed in grid while scrolling so we need to
-if (eventHandled) {
+// stop the 3d effect.
-event->accept();
+mSpring.resetVelocity();
-event->accept(Qt::TapAndHoldGesture);
+update();
-event->accept(Qt::TapGesture);
+mIgnoreGestureAction = false;
-event->accept(Qt::PanGesture);
+}
-}
-else {
+eventHandled ? event->accept() : event->ignore();
-event->ignore();
-event->ignore(Qt::TapAndHoldGesture);
-event->ignore(Qt::TapGesture);
-event->ignore(Qt::PanGesture);
-}
 }
 void HgContainer::init(Qt::Orientation scrollDirection)
 {
 FUNC_LOG;
 mRenderer = createRenderer(scrollDirection);
 mOrientation = scrollDirection;
 mQuadRenderer = mRenderer->getRenderer();
-QImage markImage(":/images/mark.svg");
+// Fetch icons for marking mode (on and off states).
-if (markImage.isNull()) {
-ERROR("Failed to load :/images/mark.svg");
-}
 mMarkImageOn = mQuadRenderer->createNativeImage();
-HANDLE_ERROR_NULL(mMarkImageOn);
-if (mMarkImageOn) {
-mMarkImageOn->setImage(markImage);
-}
-/*    mMarkImageOn = mQuadRenderer->createNativeImage();
 HANDLE_ERROR_NULL(mMarkImageOn);
 mMarkImageOff = mQuadRenderer->createNativeImage();
 HANDLE_ERROR_NULL(mMarkImageOff);
-// Fetch icons for marking mode (on and off states).
+// Since there is no way to create the icons directly currently
-QGraphicsItem* checkBox = style()->createPrimitive(HbStyle::P_CheckBox_icon, this);
+// lets create HbCheckBox and ask primitives from it.
-HbIconItem* iconItem = static_cast<HbIconItem*>(checkBox);
+HbCheckBox* checkBox = new HbCheckBox();
-HbStyleOptionCheckBox checkBoxOption;
+checkBox->setCheckState(Qt::Checked);
-checkBoxOption.state = QStyle::State_On;
+QGraphicsItem *icon = checkBox->HbWidget::primitive("icon");
-style()->updatePrimitive(iconItem, HbStyle::P_CheckBox_icon, &checkBoxOption);
+HbIconItem *iconItem = 0;
+if (icon) {
-if (mMarkImageOn) {
+iconItem = static_cast<HbIconItem*>(icon);
-mMarkImageOn->setPixmap(iconItem->icon().pixmap());
+if (mMarkImageOn) {
-}
+mMarkImageOn->setPixmap(iconItem->icon().pixmap());
+}
-checkBoxOption.state = QStyle::State_Off;
+}
-style()->updatePrimitive(iconItem, HbStyle::P_CheckBox_icon, &checkBoxOption);
+checkBox->setCheckState(Qt::Unchecked);
-if (mMarkImageOff) {
+icon = checkBox->HbWidget::primitive("icon");
-mMarkImageOff->setPixmap(iconItem->icon().pixmap());
+if (icon) {
-}
+iconItem = static_cast<HbIconItem*>(icon);
+if (mMarkImageOff) {
+mMarkImageOff->setPixmap(iconItem->icon().pixmap());
+}
+}
 delete checkBox;
-*/
 connect(&mSpring, SIGNAL(updated()), SLOT(updateBySpringPosition()));
 connect(&mSpring, SIGNAL(started()), SIGNAL(scrollingStarted()));
 connect(&mSpring, SIGNAL(started()), SLOT(onScrollingStarted()));
 connect(&mSpring, SIGNAL(ended()), SIGNAL(scrollingEnded()));
 connect(&mSpring, SIGNAL(ended()), SLOT(onScrollingEnded()));
 if (mDragged)
 {
 emit scrollingStarted();
 qreal newPosition = mDrag.update(delta, pos, itemSide);
-if (qAbs(newPosition - mSpring.pos().x()) > 0.01f)
+if (qAbs(newPosition - mSpring.pos().x()) > 0.01f) {
-{
 mSpring.gotoPos(QPointF(newPosition, 0));
-emit scrollPositionChanged(newPosition,true);
+if (mRenderer->coverflowModeEnabled()) {
-update();
+emit scrollPositionChanged(newPosition,true);
+update();
+} else {
+updateBySpringPosition();
+}
 }
 }
 }
 else if (mDragged && gesture->state() == Qt::GestureFinished) {
 mDrag.update(delta, pos, itemSide);
 }
 else {
 boundSpring();
 }
 }
+else if(!mDragged && gesture->state() == Qt::GestureFinished) {
+if (!mRenderer->coverflowModeEnabled()) {
+mSpring.resetVelocity();
+update();
+}
+}
 else if (gesture->state() == Qt::GestureCanceled) {
 boundSpring();
 }
 return true;
 }
 bool HgContainer::handleTap(Qt::GestureState state, const QPointF &pos)
 {
 FUNC_LOG;
-if (state == Qt::GestureStarted) {
+bool handleGesture = false;
-if (hasItemAt(pos)) {
-mTapDuration.start();
+if (hasItemAt(pos)) {
-startLongPressWatcher(pos);
+switch (state)
-return true;
+{
-}
+case Qt::GestureStarted:
-return false;
+{
-}
+if (mRenderer->coverflowModeEnabled() || !mSpring.isActive()) {
-else if (state == Qt::GestureCanceled)
+mIgnoreGestureAction = false;
-{
+startLongPressWatcher(pos);
-stopLongPressWatcher();
+} else if(mSpring.isActive()) {
+mSpring.cancel();
-if (hasItemAt(pos)) {
+mIgnoreGestureAction = true;
-return true;
+}
-}
+break;
-return false;
+}
-}
+case Qt::GestureFinished:
-else if (state == Qt::GestureFinished) {
+handleGesture = handleItemAction(pos, NormalTap);
-stopLongPressWatcher();
+case Qt::GestureUpdated:
-return handleItemAction(pos, mTapDuration.elapsed() > KLongTapDuration ? LongTap : NormalTap);
+case Qt::GestureCanceled:
-}
+default:
+stopLongPressWatcher();
-return false;
+break;
+}
+handleGesture = true;
+} else {
+mIgnoreGestureAction = true;
+}
+return handleGesture;
 }
 bool HgContainer::handleLongTap(Qt::GestureState state, const QPointF &pos)
 {
 FUNC_LOG;
+bool handleGesture = false;
 if (hasItemAt(pos)) {
-mAnimateUsingScrollBar = false;
-initSpringForScrolling();
+switch (state)
+{
-if (state == Qt::GestureFinished) {
+case Qt::GestureUpdated:
-handleItemAction(pos, LongTap);
+handleItemAction(pos,LongTap);
-}
+case Qt::GestureStarted:
-return true;
+case Qt::GestureCanceled:
-}
+case Qt::GestureFinished:
+default:
-return false;
+stopLongPressWatcher();
+break;
+}
+handleGesture = true;
+} else {
+mIgnoreGestureAction = true;
+}
+return handleGesture;
 }
 /*!
 Handle tap, lang tap and double tap action.
 Finds out the item in the tap position and sends out suitable signal,
 HgWidgetItem* item = itemByIndex(index);
 if (item && action != DoubleTap) {
 if (action == LongTap) {
 INFO("Long tap:" << item->modelIndex().row());
-mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
+if (!mRenderer->coverflowModeEnabled()) {
-if (!mRenderer->coverflowModeEnabled())
 selectItem(index);
+} else {
-emit longPressed(item->modelIndex(), pos);
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
+}
+if (!mIgnoreGestureAction) {
+emit longPressed(item->modelIndex(), pos);
+} else {
+mSpring.resetVelocity();
+update();
+mIgnoreGestureAction = false;
+}
 }
 else if (mSelectionMode == HgWidget::MultiSelection) {
 mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 INFO("Select:" << item->modelIndex().row());
 mSelectionModel->select(item->modelIndex(), QItemSelectionModel::Toggle);
 {
 mSpring.animateToPos(QPointF(index, 0));
 }
 }
 else {   //grid mode
-if (!mIgnoreTap) {
+if (!mIgnoreGestureAction) {
-mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
+// Current should be topleft item.
+//                        mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 selectItem(index);
 emit activated(item->modelIndex());
+} else {
+mSpring.resetVelocity();
+update();
+mIgnoreGestureAction = false;
 }
 }
 }
 }
 QList<HgQuad*> quads = mRenderer->getVisibleQuads();
 QList<QModelIndex> result;
 for (int i = 0; i < quads.count(); i++) {
 bool ok;
 int index = quads.at(i)->userData().toInt(&ok);
-result.append(itemByIndex(index)->modelIndex());
+HgWidgetItem *item = itemByIndex(index);
+if (item)
+result.append(item->modelIndex());
 }
 qSort(result);
 return result;
 }
 void HgContainer::itemDataChanged(const int &firstIndex, const int &lastIndex)
 {
 FUNC_LOG;
 int firstItemOnScreen = 0, lastItemOnScreen = 0;
 firstItemOnScreen = mSpring.pos().x();
 firstItemOnScreen *= rowCount();
 int itemsOnScreen = mRenderer->getVisibleQuads().count();
 lastItemOnScreen = firstItemOnScreen+itemsOnScreen;
-if ((firstIndex >= firstItemOnScreen && firstIndex < lastItemOnScreen) ||
+if ( itemsOnScreen == 0 || (firstIndex >= firstItemOnScreen && firstIndex < lastItemOnScreen) ||
 (lastIndex >= firstItemOnScreen && lastIndex < lastItemOnScreen)) {
 update();
 }
 }
 void HgContainer::selectItem(int index)
 {
+Q_UNUSED(index)
 // TODO: replace this with own selection implementation
 /*    if (index < 0 && index >= mItems.count())
 return;
 mHitItemIndex = index;
 int frame = 100.0f * qreal(elapsed - 80) / qreal(KLongTapDuration - 80);
 mLongPressVisualizer->setFrame(frame);
 }
 }
-void HgContainer::updateByCurrentIndex(const QModelIndex &current)
-{
-handleCurrentChanged(current);
-}
 bool HgContainer::hasItemAt(const QPointF& pos)
 {
 int dummy;
 HgWidgetItem *item = getItemAt(pos, dummy);
 if (item) {
 void HgContainer::onScrollingEnded()
 {
 // By default do nothing
 }
-void HgContainer::handleCurrentChanged(const QModelIndex &current)
-{
-Q_UNUSED(current)
-// By default do nothing
-}
 void HgContainer::setDefaultImage(QImage defaultImage)
 {
 HgQuadRenderer *renderer = mRenderer->getRenderer();
 if (renderer) {
 QImage scaled = defaultImage.scaled(mRenderer->getImageSize().toSize());
 qreal HgContainer::scrollPosition() const
 {
 return mSpring.pos().x();
 }
+// EOF

branch	GCC_SURGE
changeset 10	c348b9772569
parent 9	dde80bf4a8c7
child 13	8bf920201dea