Sankore groups elements are now interactable

src/board/UBBoardView.cpp

@@ -50,6 +50,7 @@
 #include "domain/UBGraphicsVideoItem.h"
 #include "domain/UBGraphicsAudioItem.h"
 #include "domain/UBGraphicsSvgItem.h"
+#include "domain/ubgraphicsgroupcontaineritem.h"
 
 #include "document/UBDocumentProxy.h"
 
@@ -435,7 +436,7 @@ void UBBoardView::mousePressEvent (QMouseEvent *event)
                 || movingItem->type() == UBGraphicsCache::Type
                 || movingItem->type() == UBGraphicsTriangle::Type
                 || movingItem == this->scene()->backgroundObject()
-                || movingItem->group())
+                || (movingItem->parentItem() && movingItem->parentItem()->type() == UBGraphicsGroupContainerItem::Type))
 
                 {
                     movingItem = NULL;

src/domain/UBGraphicsItemDelegate.cpp

@@ -40,6 +40,7 @@
 #include "domain/UBGraphicsTextItem.h"
 #include "domain/UBGraphicsAudioItem.h"
 #include "domain/UBGraphicsVideoItem.h"
+#include "domain/ubgraphicsgroupcontaineritem.h"
 
 #include "web/UBWebController.h"
 
@@ -217,10 +218,9 @@ bool UBGraphicsItemDelegate::mousePressEvent(QGraphicsSceneMouseEvent *event)
 
     startUndoStep();
 
-    if (!mDelegated->isSelected())
+    if (!delegated()->isSelected())
     {
-        mDelegated->setSelected(true);
+        delegated()->setSelected(true);
-        positionHandles();
         return true;
     }
     else
@@ -262,7 +262,7 @@ bool UBGraphicsItemDelegate::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 bool UBGraphicsItemDelegate::weelEvent(QGraphicsSceneWheelEvent *event)
 {
     Q_UNUSED(event);
-    if( mDelegated->isSelected() )
+    if( delegated()->isSelected() )
     {
 //        event->accept();
         return true;
@@ -310,6 +310,18 @@ void UBGraphicsItemDelegate::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
 //    }
 }
 
+QGraphicsItem *UBGraphicsItemDelegate::delegated()
+{
+    QGraphicsItem *curDelegate = 0;
+    if (mDelegated->parentItem() && mDelegated->parentItem()->type() == UBGraphicsGroupContainerItem::Type) {
+        curDelegate = mDelegated->parentItem(); // considering delegated item as an item's group which contains everything
+    } else {
+        curDelegate = mDelegated;
+    }
+
+    return curDelegate;
+}
+
 void UBGraphicsItemDelegate::positionHandles()
 {
     if (mDelegated->isSelected()) {
@@ -363,7 +375,7 @@ void UBGraphicsItemDelegate::setZOrderButtonsVisible(bool visible)
 void UBGraphicsItemDelegate::remove(bool canUndo)
 {
 //    QGraphicsScene* scene = mDelegated->scene();
-    UBGraphicsScene* scene = (UBGraphicsScene*)(mDelegated->scene());
+    UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene());
     if (scene)
     {
         foreach(DelegateButton* button, mButtons)

src/domain/UBGraphicsItemDelegate.h

@@ -121,10 +121,7 @@ class UBGraphicsItemDelegate : public QObject
 
         void printMessage(const QString &mess) {qDebug() << mess;}
 
-        QGraphicsItem* delegated()
+        QGraphicsItem* delegated();
-        {
-            return mDelegated;
-        }
 
         void setCanDuplicate(bool allow){ mCanDuplicate = allow; }
 

src/domain/UBGraphicsScene.cpp

@@ -383,9 +383,9 @@ void UBGraphicsScene::processGroupItems()
 
     foreach (QGraphicsItem *item, selectedItems()) {
         item->setSelected(false);
-        item->setFlag(QGraphicsItem::ItemIsSelectable, false);
+        item->setFlag(QGraphicsItem::ItemIsSelectable, true);
         item->setFlag( QGraphicsItem::ItemIsMovable, false);
-        item->setFlag(QGraphicsItem::ItemIsFocusable);
+        item->setFlag(QGraphicsItem::ItemIsFocusable, true);
         groupItem->addToGroup(item);
     }
 

src/domain/UBGraphicsWidgetItem.cpp

@@ -93,7 +93,6 @@ void UBGraphicsWidgetItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
 }
 void UBGraphicsWidgetItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 {
-    qDebug() << "hover move catched";
     UBGraphicsProxyWidget::hoverMoveEvent(event);
 }
 

src/domain/ubgraphicsgroupcontaineritem.cpp

@@ -9,7 +9,7 @@
 #include "core/memcheck.h"
 
 UBGraphicsGroupContainerItem::UBGraphicsGroupContainerItem(QGraphicsItem *parent)
-    : QGraphicsItemGroup(parent)
+    : QGraphicsItem(parent)
 {
     setData(UBGraphicsItemData::ItemLayerType, UBItemLayerType::Object);
 
@@ -23,8 +23,123 @@ UBGraphicsGroupContainerItem::UBGraphicsGroupContainerItem(QGraphicsItem *parent
     UBGraphicsGroupContainerItem::setAcceptHoverEvents(true);
 
     setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); //Necessary to set if we want z value to be assigned correctly
+
+}
+
+void UBGraphicsGroupContainerItem::addToGroup(QGraphicsItem *item)
+{
+    if (!item) {
+        qWarning("UBGraphicsGroupContainerItem::addToGroup: cannot add null item");
+        return;
+    }
+    if (item == this) {
+        qWarning("UBGraphicsGroupContainerItem::addToGroup: cannot add a group to itself");
+        return;
+    }
+
+    // COMBINE
+    bool ok;
+    QTransform itemTransform = item->itemTransform(this, &ok);
+
+    if (!ok) {
+        qWarning("UBGraphicsGroupContainerItem::addToGroup: could not find a valid transformation from item to group coordinates");
+        return;
+    }
+
+    QTransform newItemTransform(itemTransform);
+    item->setPos(mapFromItem(item, 0, 0));
+    item->setParentItem(this);
+
+    // removing position from translation component of the new transform
+    if (!item->pos().isNull())
+        newItemTransform *= QTransform::fromTranslate(-item->x(), -item->y());
+
+    // removing additional transformations properties applied with itemTransform()
+    QPointF origin = item->transformOriginPoint();
+    QMatrix4x4 m;
+    QList<QGraphicsTransform*> transformList = item->transformations();
+    for (int i = 0; i < transformList.size(); ++i)
+        transformList.at(i)->applyTo(&m);
+    newItemTransform *= m.toTransform().inverted();
+    newItemTransform.translate(origin.x(), origin.y());
+    newItemTransform.rotate(-item->rotation());
+    newItemTransform.scale(1/item->scale(), 1/item->scale());
+    newItemTransform.translate(-origin.x(), -origin.y());
+
+    // ### Expensive, we could maybe use dirtySceneTransform bit for optimization
+
+    item->setTransform(newItemTransform);
+//    item->d_func()->setIsMemberOfGroup(true);
+    prepareGeometryChange();
+    itemsBoundingRect |= itemTransform.mapRect(item->boundingRect() | item->childrenBoundingRect());
+    update();
+}
+void UBGraphicsGroupContainerItem::removeFromGroup(QGraphicsItem *item)
+{
+    if (!item) {
+        qWarning("QGraphicsItemGroup::removeFromGroup: cannot remove null item");
+        return;
     }
 
+    QGraphicsItem *newParent = parentItem();
+
+    // COMBINE
+    bool ok;
+    QTransform itemTransform;
+    if (newParent)
+        itemTransform = item->itemTransform(newParent, &ok);
+    else
+        itemTransform = item->sceneTransform();
+
+    QPointF oldPos = item->mapToItem(newParent, 0, 0);
+    item->setParentItem(newParent);
+    item->setPos(oldPos);
+
+    // removing position from translation component of the new transform
+    if (!item->pos().isNull())
+        itemTransform *= QTransform::fromTranslate(-item->x(), -item->y());
+
+    // removing additional transformations properties applied
+    // with itemTransform() or sceneTransform()
+    QPointF origin = item->transformOriginPoint();
+    QMatrix4x4 m;
+    QList<QGraphicsTransform*> transformList = item->transformations();
+    for (int i = 0; i < transformList.size(); ++i)
+        transformList.at(i)->applyTo(&m);
+    itemTransform *= m.toTransform().inverted();
+    itemTransform.translate(origin.x(), origin.y());
+    itemTransform.rotate(-item->rotation());
+    itemTransform.scale(1 / item->scale(), 1 / item->scale());
+    itemTransform.translate(-origin.x(), -origin.y());
+
+    // ### Expensive, we could maybe use dirtySceneTransform bit for optimization
+
+    item->setTransform(itemTransform);
+//    item->d_func()->setIsMemberOfGroup(item->group() != 0);
+
+    // ### Quite expensive. But removeFromGroup() isn't called very often.
+    prepareGeometryChange();
+    itemsBoundingRect = childrenBoundingRect();
+}
+
+QRectF UBGraphicsGroupContainerItem::boundingRect() const
+{
+    return itemsBoundingRect;
+}
+void UBGraphicsGroupContainerItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+                               QWidget *widget)
+{
+    Q_UNUSED(widget);
+    if (option->state & QStyle::State_Selected) {
+        painter->setBrush(Qt::NoBrush);
+        QPen tmpPen;
+        qreal tmpPenWidth = 1.0;
+        tmpPen.setWidth(tmpPenWidth);
+        tmpPen.setColor(Qt::lightGray);
+        painter->setPen(tmpPen);
+        painter->drawRect(itemsBoundingRect.adjusted(tmpPenWidth / 2, tmpPenWidth / 2, -tmpPenWidth / 2, -tmpPenWidth / 2));
+    }
+}
 
 UBGraphicsScene *UBGraphicsGroupContainerItem::scene()
 {
@@ -60,23 +175,18 @@ void UBGraphicsGroupContainerItem::destroy() {
     foreach (QGraphicsItem *item, childItems()) {
         removeFromGroup(item);
         item->setFlag(QGraphicsItem::ItemIsSelectable, true);
+        item->setFlag(QGraphicsItem::ItemIsFocusable, true);
     }
 
     mDelegate->remove(true);
 }
 
-void UBGraphicsGroupContainerItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
-{
-    qDebug() << "hover move group";
-    QGraphicsItemGroup::hoverMoveEvent(event);
-}
-
 void UBGraphicsGroupContainerItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     if (mDelegate->mousePressEvent(event)) {
         //NOOP
     } else {
-        QGraphicsItemGroup::mousePressEvent(event);
+        QGraphicsItem::mousePressEvent(event);
         setSelected(true);
     }
 }
@@ -86,18 +196,18 @@ void UBGraphicsGroupContainerItem::mouseMoveEvent(QGraphicsSceneMouseEvent *even
     if (mDelegate->mouseMoveEvent(event)) {
         // NOOP;
     } else {
-        QGraphicsItemGroup::mouseMoveEvent(event);
+        QGraphicsItem::mouseMoveEvent(event);
     }
 }
 
 void UBGraphicsGroupContainerItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     mDelegate->mouseReleaseEvent(event);
-    QGraphicsItemGroup::mouseReleaseEvent(event);
+    QGraphicsItem::mouseReleaseEvent(event);
 }
 
 QVariant UBGraphicsGroupContainerItem::itemChange(GraphicsItemChange change, const QVariant &value)
 {
     QVariant newValue = mDelegate->itemChange(change, value);
-    return QGraphicsItemGroup::itemChange(change, newValue);
+    return QGraphicsItem::itemChange(change, newValue);
 }

src/domain/ubgraphicsgroupcontaineritem.h

@@ -5,11 +5,17 @@
 
 #include "domain/UBItem.h"
 
-class UBGraphicsGroupContainerItem : public QGraphicsItemGroup, public UBItem, public UBGraphicsItem
+class UBGraphicsGroupContainerItem : public QGraphicsItem, public UBItem, public UBGraphicsItem
 {
 
 public:
     UBGraphicsGroupContainerItem (QGraphicsItem *parent = 0);
+
+    void addToGroup(QGraphicsItem *item);
+    void removeFromGroup(QGraphicsItem *item);
+    QRectF boundingRect() const;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+
     virtual UBGraphicsItemDelegate* Delegate() const { return mDelegate;}
 
     virtual UBGraphicsScene* scene();
@@ -26,7 +32,6 @@ public:
 
 
 protected:
-    virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
     virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
     virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
     virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
@@ -34,6 +39,7 @@ protected:
     virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
 
 private:
+    QRectF itemsBoundingRect;
 
 };