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

equal deleted inserted replaced

-:89c329efa980
+:e48454f237ca
 mDragged(false),
 mFramesDragged(0),
 mHitItemView(NULL),
 mLongPressVisualizer(NULL),
 mLongPressTimer(NULL),
-mHitItemIndex(NULL)
+mHitItemIndex(NULL),
-{
+mItemSizePolicy(HgWidget::ItemSizeUserDefined),
-FUNC_LOG;
+mOrientation(Qt::Vertical)
+{
+FUNC_LOG;
 grabGesture(Qt::PanGesture);
 grabGesture(Qt::TapGesture);
 grabGesture(Qt::TapAndHoldGesture);
 }
 HgContainer::~HgContainer()
 {
 FUNC_LOG;
-for (QList<HgWidgetItem*>::iterator i = mItems.begin(); i != mItems.end(); ++i) {
+qDeleteAll(mItems);
-delete (*i);
-}
 mItems.clear();
 delete mMarkImage;
 delete mRenderer;
 }
 void HgContainer::setItemCount(int itemCount)
 {
 FUNC_LOG;
+qDeleteAll(mItems);
 mItems.clear();
 for (int i=0; i<itemCount; i++) {
 HgWidgetItem* item = new HgWidgetItem(mQuadRenderer);
 mItems.append(item);
 }
 Qt::Orientation HgContainer::orientation() const
 {
 FUNC_LOG;
-return mRenderer->getOrientation();
+return mOrientation;
 }
 void HgContainer::setOrientation(Qt::Orientation orientation, bool animate)
 {
 FUNC_LOG;
-mRenderer->setOrientation(orientation, animate);
+mOrientation = orientation;
+mRenderer->setOrientation(orientation, false);
 }
 void HgContainer::scrollToPosition(qreal value, bool animate)
 {
 FUNC_LOG;
 void HgContainer::scrollTo(const QModelIndex &index)
 {
 FUNC_LOG;
-if (index.isValid()) {
+if (index.isValid() && mRenderer->getRowCount() > 0) {
-scrollToPosition(QPointF(index.row(), index.column()), false);
+scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);
 }
 }
 void HgContainer::itemDataChanged(const QModelIndex &firstIndex, const QModelIndex &lastIndex)
 {
 }
 void HgContainer::addItems(int start, int end)
 {
 FUNC_LOG;
+HANDLE_ERROR_NULL(mSelectionModel);
 int first = qBound(0, start, mItems.count()-1);
 int last = qBound(0, end, mItems.count()-1);
 for (int i = 0; i <= end-start; i++) {
 HgWidgetItem* item = new HgWidgetItem(mQuadRenderer);
 mItems.insert(start, item);
 }
+scrollTo(mSelectionModel->currentIndex());
 }
 void HgContainer::removeItems(int start, int end)
 {
 FUNC_LOG;
+HANDLE_ERROR_NULL(mSelectionModel);
 int first = qBound(0, start, mItems.count()-1);
 int last = qBound(0, end, mItems.count()-1);
 for (int i = last; i >= first; i--) {
 delete mItems.at(i);
 mItems.removeAt(i);
 }
+scrollTo(mSelectionModel->currentIndex());
 }
 void HgContainer::moveItems(int start, int end, int destination)
 {
 FUNC_LOG;
+HANDLE_ERROR_NULL(mSelectionModel);
 int first = qBound(0, start, mItems.count()-1);
 int last = qBound(0, end, mItems.count()-1);
 int target = qBound(0, destination, mItems.count()-1);
 for (int i = 0; i <= last-first; i++) {
 mItems.move(last-i, target);
 }
 }
 // else do nothing
+scrollTo(mSelectionModel->currentIndex());
 }
 int HgContainer::imageCount() const
 {
 return mItems.count();
 return 0;
 }
 void HgContainer::updateBySpringPosition()
 {
-update();
 // spring works always in one dimension, that is, x coord.
 qreal pos = mSpring.pos().x();
 onScrollPositionChanged(pos);
 emit scrollPositionChanged(pos, mAnimateUsingScrollBar);
+update();
 }
 void HgContainer::redraw()
 {
 update();
 void HgContainer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
 Q_UNUSED(option)
 Q_UNUSED(widget)
 if (mSpring.updatePositionIfNeeded())
 {
 // spring works always in one dimension, that is, x coord.
 qreal pos = mSpring.pos().x();
 onScrollPositionChanged(pos);
-emit scrollPositionChanged(pos, mAnimateUsingScrollBar);
+emit scrollPositionChanged(pos, true);
 }
 QRectF vp = painter->viewport();
-QRectF rts = mapRectToScene(rect());
+QRectF rts = mapRectToScene(drawableRect());
 QRectF r;
 // transform rectangle to vg space &
 // rotate rendering according to orientation
-if (mainWindow()->orientation() == Qt::Horizontal) {
+if (mOrientation == Qt::Horizontal) {
 r = QRectF(vp.width()-(rts.height()+rts.top()), rts.left(), rts.height(), rts.width());
+mRenderer->setRect(r);
 mRenderer->setCameraRotationZ(-90);
 }
 else {
 r = QRectF(rts.left(), vp.height()-(rts.height()+rts.top()), rts.width(), rts.height());
 mRenderer->setCameraRotationZ(0);
+mRenderer->setRect(r);
+if (!mSpring.isActive() && mSpring.pos().x() > worldWidth())
+boundSpring();
 }
 // interpolate spring velocity towards zero, this is done
 // so that spring velocity for rendering doesn't drop directly to
 // zero when dragging starts
 }
 // setup rendering and draw the current view
 mRenderer->setCameraDistance(getCameraDistance(springVel));
 mRenderer->setCameraRotationY(getCameraRotationY(springVel));
-mRenderer->setRect(r);
 mRenderer->draw(mSpring.startPos(), mSpring.pos(), mSpring.endPos(),
 springVel, painter);
 }
 void HgContainer::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
 FUNC_LOG;
 void HgContainer::gestureEvent(QGestureEvent *event)
 {
 FUNC_LOG;
+bool eventHandled(false);
 // Event may contain more than one gesture type
 if (QGesture *gesture = event->gesture(Qt::TapAndHoldGesture)) {
 QTapAndHoldGesture *tapAndHold = static_cast<QTapAndHoldGesture *>(gesture);
-handleLongTap(tapAndHold->state(),
+if (handleLongTap(tapAndHold->state(),
-mapFromScene(event->mapToGraphicsScene(tapAndHold->position())));
+mapFromScene(event->mapToGraphicsScene(tapAndHold->position())))) {
+}
 }
 else if (QGesture *gesture = event->gesture(Qt::TapGesture)) {
 // Tap and hold is not working yet in HW, tap gesture is delivered instead
 QTapGesture *tap = static_cast<QTapGesture *>(gesture);
-handleTap(tap->state(),
+eventHandled = handleTap(tap->state(),
 mapFromScene(event->mapToGraphicsScene(tap->position())));
 }
 else if (QGesture *pan = event->gesture(Qt::PanGesture)) {
-handlePanning(static_cast<QPanGesture*>(pan));
+eventHandled = handlePanning(static_cast<QPanGesture*>(pan));
+}
+if (eventHandled) {
+event->accept();
+event->accept(Qt::TapAndHoldGesture);
+event->accept(Qt::TapGesture);
+event->accept(Qt::PanGesture);
+}
+else {
+event->ignore();
+event->ignore(Qt::TapAndHoldGesture);
+event->ignore(Qt::TapGesture);
+event->ignore(Qt::PanGesture);
 }
 }
 void HgContainer::init(Qt::Orientation scrollDirection)
 {
 FUNC_LOG;
-mRenderer = createRenderer();
+mRenderer = createRenderer(scrollDirection);
-if (mRenderer->coverflowModeEnabled())
+mOrientation = scrollDirection;
-mRenderer->setOrientation(Qt::Horizontal, false);
-else
-mRenderer->setOrientation(scrollDirection, false);
 mQuadRenderer = mRenderer->getRenderer();
 QImage markImage(":/images/mark.svg");
 if (markImage.isNull()) {
 ERROR("Failed to load :/images/mark.svg");
 mMarkImage = mQuadRenderer->createNativeImage();
 HANDLE_ERROR_NULL(mMarkImage);
 if (mMarkImage) {
 mMarkImage->setImage(markImage);
 }
 connect(&mSpring, SIGNAL(updated()), SLOT(updateBySpringPosition()));
-connect(&mSpring, SIGNAL(ended()), SLOT(onScrollingEnded()));
 connect(&mSpring, SIGNAL(ended()), SIGNAL(scrollingEnded()));
 connect(&mSpring, SIGNAL(started()), SIGNAL(scrollingStarted()));
 connect(mRenderer, SIGNAL(renderingNeeded()), SLOT(redraw()));
 }
 mSpring.animateToPos(QPointF(x, 0));
 }
-void HgContainer::handlePanning(QPanGesture *gesture)
+bool HgContainer::handlePanning(QPanGesture *gesture)
 {
 mAnimateUsingScrollBar = false;
 initSpringForScrolling();
 qreal pos = mSpring.pos().x();
 qreal delta(0);
 qreal itemSide(0);
-if (mRenderer->getOrientation() == mainWindow()->orientation()) {
+if (mOrientation == mRenderer->getOrientation()) {
 delta = gesture->delta().y();
 }
 else {
 delta = gesture->delta().x();
 }
 qreal newPosition = mDrag.update(delta, pos, itemSide);
 if (qAbs(newPosition - mSpring.pos().x()) > 0.01f)
 {
 mSpring.gotoPos(QPointF(newPosition, 0));
+emit scrollPositionChanged(newPosition,true);
 update();
 }
 }
 }
 else if (mDragged && gesture->state() == Qt::GestureFinished) {
 }
 }
 else if (gesture->state() == Qt::GestureCanceled) {
 boundSpring();
 }
-}
+return true;
+}
-void HgContainer::handleTap(Qt::GestureState state, const QPointF &pos)
+bool HgContainer::handleTap(Qt::GestureState state, const QPointF &pos)
 {
 FUNC_LOG;
 if (state == Qt::GestureStarted) {
-mTapDuration.start();
+if (hasItemAt(pos)) {
+mTapDuration.start();
 startLongPressWatcher(pos);
+return true;
+}
+return false;
 }
 else if (state == Qt::GestureCanceled)
 {
 stopLongPressWatcher();
+if (hasItemAt(pos)) {
+return true;
+}
+return false;
 }
 else if (state == Qt::GestureFinished) {
 stopLongPressWatcher();
-handleItemAction(pos, mTapDuration.elapsed() > KLongTapDuration ? LongTap : NormalTap);
+return handleItemAction(pos, mTapDuration.elapsed() > KLongTapDuration ? LongTap : NormalTap);
 }
-}
+return false;
-void HgContainer::handleLongTap(Qt::GestureState state, const QPointF &pos)
+}
-{
-FUNC_LOG;
+bool HgContainer::handleLongTap(Qt::GestureState state, const QPointF &pos)
+{
-mAnimateUsingScrollBar = false;
+FUNC_LOG;
-initSpringForScrolling();
+if (hasItemAt(pos)) {
-if (state == Qt::GestureFinished) {
+mAnimateUsingScrollBar = false;
-handleItemAction(pos, LongTap);
+initSpringForScrolling();
-}
+if (state == Qt::GestureFinished) {
+handleItemAction(pos, LongTap);
+}
+return true;
+}
+return false;
 }
 /*!
 Handle tap, lang tap and double tap action.
 Finds out the item in the tap position and sends out suitable signal,
 Sets the item as the current item and in multiselection mode toggles the
 item selection status.
 */
-void HgContainer::handleItemAction(const QPointF &pos, ItemActionType action)
+bool HgContainer::handleItemAction(const QPointF &pos, ItemActionType action)
 {
 FUNC_LOG;
 // If there is content, mSelectionModel must always exist - either default or client-provided
-if (!mSelectionModel) return;
+if (!mSelectionModel) return false;
 mHitItem = getItemAt(pos, mHitItemIndex);
 if (mHitItem)
 {
 int index = mHitItemIndex;
 HgWidgetItem* item = itemByIndex(index);
 if (item && action != DoubleTap) {
-mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 if (action == LongTap) {
 INFO("Long tap:" << item->modelIndex().row());
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 if (!mRenderer->coverflowModeEnabled())
 selectItem();
 emit longPressed(item->modelIndex(), pos);
 }
 else if (mSelectionMode == HgWidget::MultiSelection) {
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 INFO("Select:" << item->modelIndex().row());
 mSelectionModel->select(item->modelIndex(), QItemSelectionModel::Toggle);
 update(); // It would be enough to update the item
 }
 else if (mSelectionMode == HgWidget::SingleSelection) {
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 INFO("Select:" << item->modelIndex().row());
 mSelectionModel->select(item->modelIndex(), QItemSelectionModel::ClearAndSelect);
 update(); // It would be enough to update the item
 }
 else if (mSelectionMode == HgWidget::ContiguousSelection) {
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 QModelIndex newSelected = item->modelIndex();
 QModelIndexList oldSelection = mSelectionModel->selectedIndexes();
 INFO("Select:" << newSelected.row());
 if (oldSelection.count() > 0 && !mSelectionModel->isSelected(newSelected)) {
 if (newSelected.row() < oldSelection.front().row()) {
 if (mRenderer->coverflowModeEnabled())
 {
 if (qAbs(qreal(index) - mSpring.pos().x()) < 0.01f)
 {
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 emit activated(item->modelIndex());
 }
 else
 {
 mSpring.animateToPos(QPointF(index, 0));
 }
 }
 else
 {
+mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 selectItem();
 emit activated(item->modelIndex());
 }
 }
 }
+return true;
 }
 else {
 INFO("No quad at pos:" << pos);
 unselectItem();
+return false;
 }
 }
 bool HgContainer::getItemPoints(int index, QPolygonF& points)
 {
 void HgContainer::itemDataChanged(const int &firstIndex, const int &lastIndex)
 {
 FUNC_LOG;
+// if screen is frequently updated no need to update now.
+if (mSpring.isActive() || mDragged ) return;
 // TODO FIX THIS FUNCTION!!!!!!!!!!!!!!!!!!!!!!
 int firstItemOnScreen = 0, lastItemOnScreen = 0;
 firstItemOnScreen = mSpring.pos().x();
 firstItemOnScreen *= rowCount();
-// This code doesnt take into count if there is some empty space at the
+int itemsOnScreen = mRenderer->getVisibleQuads().count();
-// beginning or at the end of the widget
-int itemsOnScreen = 0;
-if (mRenderer->getOrientation() == Qt::Vertical) {
-itemsOnScreen = this->rect().height()/mRenderer->getImageSize().height();
-itemsOnScreen += rowCount();
-}
-else {
-// Doesnt work here. Use some magic for now.
-itemsOnScreen = this->rect().width()/mRenderer->getImageSize().width();
-itemsOnScreen += 4;
-}
-itemsOnScreen *= rowCount();
 lastItemOnScreen = firstItemOnScreen+itemsOnScreen;
-if ((firstIndex >= firstItemOnScreen && firstIndex <= lastItemOnScreen) ||
+if ((firstIndex >= firstItemOnScreen && firstIndex < lastItemOnScreen) ||
-(lastIndex >= firstItemOnScreen && lastIndex <= lastItemOnScreen)) {
+(lastIndex >= firstItemOnScreen && lastIndex < lastItemOnScreen)) {
-update( this->rect() );
+update();
 }
 }
 void HgContainer::selectItem()
 {
 // TODO: replace this with own selection implementation
+if (mHitItemIndex < 0 && mHitItemIndex >= mItems.count())
+return;
 if (mHitItemView)
 {
 delete mHitItemView;
 mHitItemView = NULL;
 }
 mHitItemView = new HbGridViewItem(this);
 mHitItemView->setVisible(false);
+mHitItemView->setPos(QPointF(0,0));
-QModelIndex modelIndex = mItems[mHitItemIndex]->modelIndex();
+mHitItemView->setPressed(true, false);
-const QAbstractItemModel* model = modelIndex.model();
-mHitItemView->resize(mRenderer->getImageSize().width() + 10,
+const QImage& image = mItems[mHitItemIndex]->image()->getQImage();
-mRenderer->getImageSize().height() + 10);
+if (image.isNull())
+{
-QVariant iconVariant = model->data(modelIndex, Qt::DecorationRole);
+mHitItemView->setVisible(false);
-mHitItemPixmap = iconVariant.value<QPixmap>();
+return;
-HbIcon icon(mHitItemPixmap);
+}
+QPixmap pixmap = QPixmap::fromImage(image);
+HbIcon icon(pixmap.scaled(mRenderer->getImageSize().toSize(), Qt::IgnoreAspectRatio));
 QGraphicsItem* item = mHitItemView->style()->createPrimitive(HbStyle::P_GridViewItem_icon, mHitItemView);
 HbIconItem *iconItem = static_cast<HbIconItem*>(item);
+iconItem->setAlignment(Qt::AlignCenter);
+iconItem->setAspectRatioMode(Qt::IgnoreAspectRatio);
 iconItem->setIcon(icon);
-iconItem->setAlignment(Qt::AlignCenter);
-iconItem->setAspectRatioMode(Qt::KeepAspectRatio);
+mHitItemView->resize(mRenderer->getImageSize().width(),
+mRenderer->getImageSize().height());
-mHitItemView->setModelIndex(modelIndex);
-mHitItemView->setPos(QPointF(-10,-10));
-mHitItemView->setPressed(true, false);
-mHitItemView->updatePrimitives();
 }
 void HgContainer::updateSelectedItem()
 {
 if (!mHitItemView || mHitItemIndex == -1)
 // the item was not rendered, we must hide
 // our qt item
 mHitItemView->setVisible(false);
 }
-if (mHitItemPixmap.isNull())
-{
-mHitItemView->setVisible(false);
-return;
-}
 QPolygonF img;
-img.append(QPointF(0,mHitItemPixmap.height()));
+img.append(QPointF(3,mHitItemView->boundingRect().height()-3));
-img.append(QPointF(mHitItemPixmap.width(),mHitItemPixmap.height()));
+img.append(QPointF(mHitItemView->boundingRect().width()-3,mHitItemView->boundingRect().height()-3));
-img.append(QPointF(mHitItemPixmap.width(),0));
+img.append(QPointF(mHitItemView->boundingRect().width()-3,3));
-img.append(QPointF(0,0));
+img.append(QPointF(3,3));
 QTransform t;
 QTransform::quadToQuad(img, points, t);
 mHitItemView->setTransform(t);
 void HgContainer::unselectItem()
 {
 mHitItemIndex = -1;
 if (mHitItemView)
 {
-mHitItemView->setPressed(false, false);
 mHitItemView->setVisible(false);
 }
 }
 void HgContainer::updateLongPressVisualizer()
 {
 int elapsed = mLongTapDuration.elapsed();
 if (elapsed > 80)
 {
 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) {
+return item->modelIndex().isValid();
+}
+return false;
 }
 HgWidgetItem* HgContainer::getItemAt(const QPointF& pos, int& index)
 {
 QPointF p = mapQtToVg(pos);
 }
 QTransform HgContainer::qtToVgTransform() const
 {
 QTransform t;
-if (mainWindow()->orientation() == Qt::Vertical)
+if (mOrientation == Qt::Vertical)
 {
-t.translate(0, rect().height());
+t.translate(0, drawableRect().bottom());
 t.scale(1, -1);
 }
 else // horizontal
 {
-t.translate(rect().height(), 0);
+t.translate(drawableRect().bottom(), 0);
 t.scale(-1, 1);
-t.translate(0, rect().width());
+t.translate(0, drawableRect().right());
 t.rotate(-90, Qt::ZAxis);
 }
 return t;
 }
 {
 Q_UNUSED(current)
 // By default do nothing
 }
-void HgContainer::onScrollingEnded()
+QRectF HgContainer::drawableRect() const
 {
-/*    int index;
+return rect();
-HgWidgetItem* item = getItemAt(rect().center(), index);
+}
-if (item && item->modelIndex() != mSelectionModel->currentIndex()) {
-mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
+void HgContainer::setDefaultImage(QImage defaultImage)
-}*/
+{
-}
+HgQuadRenderer *renderer = mRenderer->getRenderer();
+if (renderer) {
+QImage scaled = defaultImage.scaled(mRenderer->getImageSize().toSize());
+renderer->setDefaultImage(scaled);
+}
+}
+void HgContainer::setItemSizePolicy(HgWidget::ItemSizePolicy policy)
+{
+if (policy != mItemSizePolicy)
+{
+mItemSizePolicy = policy;
+updateItemSizeAndSpacing();
+}
+}
+HgWidget::ItemSizePolicy HgContainer::itemSizePolicy() const
+{
+return mItemSizePolicy;
+}
+void HgContainer::setItemSize(const QSizeF& size)
+{
+mUserItemSize = size;
+updateItemSizeAndSpacing();
+}
+QSizeF HgContainer::itemSize() const
+{
+return mRenderer->getImageSize();
+}
+void HgContainer::setItemSpacing(const QSizeF& spacing)
+{
+mUserItemSpacing = spacing;
+updateItemSizeAndSpacing();
+}
+QSizeF HgContainer::itemSpacing() const
+{
+return mRenderer->getSpacing();
+}
+void HgContainer::updateItemSizeAndSpacing()
+{
+if (mItemSizePolicy == HgWidget::ItemSizeUserDefined)
+{
+mRenderer->setImageSize(mUserItemSize);
+mRenderer->setSpacing(mUserItemSpacing);
+}
+}
+QSizeF HgContainer::getAutoItemSize() const
+{
+return mUserItemSize;
+}
+QSizeF HgContainer::getAutoItemSpacing() const
+{
+return mUserItemSpacing;
+}
+Qt::Orientation HgContainer::scrollDirection() const
+{
+return mRenderer->getOrientation();
+}
+qreal HgContainer::scrollPosition() const
+{
+return mSpring.pos().x();
+}

changeset 1	e48454f237ca
parent 0	89c329efa980
child 2	49c70dcc3f17