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

equal deleted inserted replaced

-:e48454f237ca
+:49c70dcc3f17
 #include "hgvgquadrenderer.h"
 #include "hgvgimage.h"
 #include "hgwidgetitem.h"
 #include "trace.h"
+//#include <hbstyleoptioncheckbox.h>
+//#include <hbcheckbox>
 #include <hbgridviewitem>
 #include <hbgridview>
 #include <hbiconitem>
 #include <qabstractitemmodel>
 #include "hglongpressvisualizer.h"
 mRenderer(0),
 mTapCount(0),
 mAnimateUsingScrollBar(false),
 mSelectionMode(HgWidget::NoSelection),
 mSelectionModel(0),
-mMarkImage(0),
+mMarkImageOn(0),
+mMarkImageOff(0),
 mSpringVelAtDragStart(0),
 mDragged(false),
 mFramesDragged(0),
 mHitItemView(NULL),
 mLongPressVisualizer(NULL),
 mLongPressTimer(NULL),
-mHitItemIndex(NULL),
+mHitItemIndex(-1),
-mItemSizePolicy(HgWidget::ItemSizeUserDefined),
+mItemSizePolicy(HgWidget::ItemSizeAutomatic),
-mOrientation(Qt::Vertical)
+mOrientation(Qt::Vertical),
+mDelayedScrollToIndex(),
+mIgnoreTap(false)
 {
 FUNC_LOG;
 grabGesture(Qt::PanGesture);
 grabGesture(Qt::TapGesture);
 {
 FUNC_LOG;
 qDeleteAll(mItems);
 mItems.clear();
-delete mMarkImage;
+delete mMarkImageOn;
+delete mMarkImageOff;
 delete mRenderer;
 }
 void HgContainer::setItemCount(int itemCount)
 {
 void HgContainer::dimensions(qreal &screenSize, qreal &worldSize)
 {
 const QRectF containerRect(rect());
-// TODO, fix logic
+if (scrollDirection()== Qt::Vertical) {
-if (containerRect.height() > containerRect.width()) {
 // assume we are in portrait mode, ofcource this might not be the case
 screenSize = containerRect.height()/(mRenderer->getImageSize().height() + mRenderer->getSpacing().height());
 worldSize = worldWidth();
 }
 else{
 }
 void HgContainer::setOrientation(Qt::Orientation orientation, bool animate)
 {
 FUNC_LOG;
 mOrientation = orientation;
-mRenderer->setOrientation(orientation, false);
+mRenderer->setOrientation(orientation);
+mRenderer->setScrollDirection(orientation, animate);
+if (!mSpring.isActive() && mSpring.pos().x() > worldWidth())
+boundSpring();
 }
 void HgContainer::scrollToPosition(qreal value, bool animate)
 {
 FUNC_LOG;
 void HgContainer::scrollTo(const QModelIndex &index)
 {
 FUNC_LOG;
-if (index.isValid() && mRenderer->getRowCount() > 0) {
+if (index.isValid() && mRenderer->getRowCount() > 0 ) {
-scrollToPosition(QPointF(index.row()/mRenderer->getRowCount(), 0), false);
+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;
+}
+// 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 = containerRect.height()/rowHeight;
+if ((int)containerRect.height()%rowHeight) {
+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 {
+// Scrolldirection is horizontal
+const int rowWidth = mRenderer->getImageSize().width() + mRenderer->getSpacing().width();
+itemsOnScreen = containerRect.width()/rowWidth;
+if ((int)containerRect.height()%rowWidth) {
+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);
+}
+}
+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 (mSelectionModel && mSelectionModel->isSelected(mSelectionModel->model()->index(index, 0))) {
+if (mSelectionMode != HgWidget::NoSelection) {
-return 1; // TODO: Assign flag to mark indicator
+// 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 0;
 }
 const HgImage *HgContainer::indicator(int flags) const
 {
 if (flags & 1) {
-return mMarkImage;
+return mMarkImageOn;
+}
+else if (flags & 2) {
+return mMarkImageOff;
 }
 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())
 {
-// spring works always in one dimension, that is, x coord.
 qreal pos = mSpring.pos().x();
 onScrollPositionChanged(pos);
 emit scrollPositionChanged(pos, true);
 }
-QRectF vp = painter->viewport();
+QPainter::RenderHints hints = painter->renderHints();
-QRectF rts = mapRectToScene(drawableRect());
+painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
-QRectF r;
-// transform rectangle to vg space &
-// rotate rendering according to orientation
-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
 qreal springVel = mSpring.velocity().x();
 // setup rendering and draw the current view
 mRenderer->setCameraDistance(getCameraDistance(springVel));
 mRenderer->setCameraRotationY(getCameraRotationY(springVel));
 mRenderer->draw(mSpring.startPos(), mSpring.pos(), mSpring.endPos(),
-springVel, painter);
+springVel, painter, sceneTransform(), rect());
+painter->setRenderHint(QPainter::SmoothPixmapTransform, false);
 }
 void HgContainer::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
 FUNC_LOG;
 HbWidget::resizeEvent(event);
+if (mDelayedScrollToIndex.isValid()) {
+scrollTo(mDelayedScrollToIndex);
+// set scrollto index to invalid value.
+mDelayedScrollToIndex = QModelIndex();
+}
 }
 // 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;
 QImage markImage(":/images/mark.svg");
 if (markImage.isNull()) {
 ERROR("Failed to load :/images/mark.svg");
 }
-mMarkImage = mQuadRenderer->createNativeImage();
+mMarkImageOn = mQuadRenderer->createNativeImage();
-HANDLE_ERROR_NULL(mMarkImage);
+HANDLE_ERROR_NULL(mMarkImageOn);
-if (mMarkImage) {
+if (mMarkImageOn) {
-mMarkImage->setImage(markImage);
+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).
+QGraphicsItem* checkBox = style()->createPrimitive(HbStyle::P_CheckBox_icon, this);
+HbIconItem* iconItem = static_cast<HbIconItem*>(checkBox);
+HbStyleOptionCheckBox checkBoxOption;
+checkBoxOption.state = QStyle::State_On;
+style()->updatePrimitive(iconItem, HbStyle::P_CheckBox_icon, &checkBoxOption);
+if (mMarkImageOn) {
+mMarkImageOn->setPixmap(iconItem->icon().pixmap());
+}
+checkBoxOption.state = QStyle::State_Off;
+style()->updatePrimitive(iconItem, HbStyle::P_CheckBox_icon, &checkBoxOption);
+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(started()), SIGNAL(scrollingStarted()));
+connect(&mSpring, SIGNAL(ended()), SLOT(onScrollingEnded()));
 connect(mRenderer, SIGNAL(renderingNeeded()), SLOT(redraw()));
 }
 qreal HgContainer::worldWidth() const
 qreal pos = mSpring.pos().x();
 qreal delta(0);
 qreal itemSide(0);
-if (mOrientation == mRenderer->getOrientation()) {
+if (mOrientation == mRenderer->getScrollDirection()) {
 delta = gesture->delta().y();
 }
 else {
 delta = gesture->delta().x();
 }
-if (mRenderer->getOrientation() == Qt::Vertical)
+if (mRenderer->getScrollDirection() == Qt::Vertical)
 itemSide = mRenderer->getImageSize().height()+mRenderer->getSpacing().height();
 else
 itemSide = mRenderer->getImageSize().width()+mRenderer->getSpacing().width();
 if (gesture->state() == Qt::GestureStarted) {
 FUNC_LOG;
 // If there is content, mSelectionModel must always exist - either default or client-provided
 if (!mSelectionModel) return false;
-mHitItem = getItemAt(pos, mHitItemIndex);
+int index = -1;
+mHitItem = getItemAt(pos, index);
 if (mHitItem)
 {
-int index = mHitItemIndex;
 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())
-selectItem();
+selectItem(index);
 emit longPressed(item->modelIndex(), pos);
 }
 else if (mSelectionMode == HgWidget::MultiSelection) {
 mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
 INFO("Select:" << item->modelIndex().row());
 update(); // It would be enough to update the item
 }
 else {
 INFO("Tap:" << item->modelIndex().row());
-if (mRenderer->coverflowModeEnabled())
+if (mRenderer->coverflowModeEnabled()) {  //coverflow and t-bone modes
-{
 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
+else {   //grid mode
-{
+if (!mIgnoreTap) {
 mSelectionModel->setCurrentIndex(item->modelIndex(), QItemSelectionModel::Current);
-selectItem();
+selectItem(index);
 emit activated(item->modelIndex());
+}
 }
 }
 }
 return true;
 }
 }
 bool HgContainer::getItemPoints(int index, QPolygonF& points)
 {
-QPolygonF poly;
+return mRenderer->getItemPoints(index, points);
-if (!mRenderer->getItemPoints(index, poly))
-return false;
-bool invertible;
-QTransform t = qtToVgTransform().inverted(&invertible);
-points = t.map(poly);
-return true;
 }
 QList<QModelIndex> HgContainer::getVisibleItemIndices() const
 {
 QList<HgQuad*> quads = mRenderer->getVisibleQuads();
 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();
 int itemsOnScreen = mRenderer->getVisibleQuads().count();
 (lastIndex >= firstItemOnScreen && lastIndex < lastItemOnScreen)) {
 update();
 }
 }
-void HgContainer::selectItem()
+void HgContainer::selectItem(int index)
 {
 // TODO: replace this with own selection implementation
-if (mHitItemIndex < 0 && mHitItemIndex >= mItems.count())
+/*    if (index < 0 && index >= mItems.count())
 return;
+mHitItemIndex = index;
 if (mHitItemView)
 {
 delete mHitItemView;
 mHitItemView = NULL;
 iconItem->setAspectRatioMode(Qt::IgnoreAspectRatio);
 iconItem->setIcon(icon);
 mHitItemView->resize(mRenderer->getImageSize().width(),
 mRenderer->getImageSize().height());
+*/
 }
 void HgContainer::updateSelectedItem()
 {
 if (!mHitItemView || mHitItemIndex == -1)
 QPolygonF points;
 if (!getItemPoints(mHitItemIndex, points))
 {
 // the item was not rendered, we must hide
 // our qt item
 mHitItemView->setVisible(false);
+return;
+}
+QRectF bounds = points.boundingRect();
+if (!(rect().contains(bounds) || rect().intersects(bounds)))
+{
+mHitItemView->setVisible(false);
+return;
 }
 QPolygonF img;
 img.append(QPointF(3,mHitItemView->boundingRect().height()-3));
 img.append(QPointF(mHitItemView->boundingRect().width()-3,mHitItemView->boundingRect().height()-3));
 img.append(QPointF(3,3));
 QTransform t;
 QTransform::quadToQuad(img, points, t);
-mHitItemView->setTransform(t);
+//t.translate(50,50);
+bool bOk;
+mHitItemView->setTransform(t * this->transform().inverted(&bOk));
 mHitItemView->setVisible(true);
 }
 void HgContainer::unselectItem()
 {
 return false;
 }
 HgWidgetItem* HgContainer::getItemAt(const QPointF& pos, int& index)
 {
-QPointF p = mapQtToVg(pos);
+HgQuad* quad = mRenderer->getQuadAt(pos);
-HgQuad* quad = mRenderer->getQuadAt(p);
 if (quad)
 {
 bool ok;
 index = quad->userData().toInt(&ok);
 if (mLongPressTimer && mLongPressVisualizer)
 {
 mLongPressTimer->stop();
 mLongPressVisualizer->stop();
 }
-}
-QTransform HgContainer::qtToVgTransform() const
-{
-QTransform t;
-if (mOrientation == Qt::Vertical)
-{
-t.translate(0, drawableRect().bottom());
-t.scale(1, -1);
-}
-else // horizontal
-{
-t.translate(drawableRect().bottom(), 0);
-t.scale(-1, 1);
-t.translate(0, drawableRect().right());
-t.rotate(-90, Qt::ZAxis);
-}
-return t;
-}
-QPointF HgContainer::mapQtToVg(const QPointF& p) const
-{
-QTransform t = qtToVgTransform();
-return t.map(p);
 }
 qreal HgContainer::getCameraDistance(qreal springVelocity)
 {
 Q_UNUSED(springVelocity)
 void HgContainer::onScrollPositionChanged(qreal pos)
 {
 Q_UNUSED(pos)
 }
+void HgContainer::onScrollingStarted()
+{
+// By default do nothing
+}
+void HgContainer::onScrollingEnded()
+{
+// By default do nothing
+}
 void HgContainer::handleCurrentChanged(const QModelIndex &current)
 {
 Q_UNUSED(current)
 // By default do nothing
-}
-QRectF HgContainer::drawableRect() const
-{
-return rect();
 }
 void HgContainer::setDefaultImage(QImage defaultImage)
 {
 HgQuadRenderer *renderer = mRenderer->getRenderer();
 return mUserItemSpacing;
 }
 Qt::Orientation HgContainer::scrollDirection() const
 {
-return mRenderer->getOrientation();
+return mRenderer->getScrollDirection();
 }
 qreal HgContainer::scrollPosition() const
 {
 return mSpring.pos().x();

changeset 2	49c70dcc3f17
parent 1	e48454f237ca
child 3	c863538fcbb6