Merge branch 'Play_tool_implementation'

resources/forms/mainWindow.ui

@@ -1649,6 +1649,22 @@
     <string>Group items</string>
    </property>
   </action>
+  <action name="actionPlay">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="icon">
+    <iconset resource="../sankore.qrc">
+     <normaloff>:/images/stylusPalette/handPlay.png</normaloff>
+     <normalon>:/images/stylusPalette/handPlayOn.png</normalon>:/images/stylusPalette/handPlay.png</iconset>
+   </property>
+   <property name="text">
+    <string>Play</string>
+   </property>
+   <property name="toolTip">
+    <string>Interact with items</string>
+   </property>
+  </action>
  </widget>
  <resources>
   <include location="../sankore.qrc"/>

resources/sankore.qrc

@@ -125,6 +125,8 @@
         <file>images/toolbar/tools.png</file>
         <file>images/stylusPalette/arrow.png</file>
         <file>images/stylusPalette/arrowOn.png</file>
+        <file>images/stylusPalette/handPlay.png</file>
+        <file>images/stylusPalette/handPlayOn.png</file>
         <file>images/stylusPalette/eraser.png</file>
         <file>images/stylusPalette/eraserOn.png</file>
         <file>images/stylusPalette/hand.png</file>

src/api/UBWidgetUniboardAPI.cpp

@@ -123,6 +123,10 @@ void UBWidgetUniboardAPI::setTool(const QString& toolString)
     {
         UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Selector);
     }
+    else if (lower == "play")
+    {
+        UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Play);
+    }
     else if (lower == "line")
     {
         UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Line);

src/board/UBBoardPaletteManager.h

@@ -89,6 +89,8 @@ class UBBoardPaletteManager : public QObject
         void slot_changeMainMode(UBApplicationController::MainMode);
         void slot_changeDesktopMode(bool);
 
+        void toggleErasePalette(bool ckecked);
+
     private:
 
         void setupPalettes();
@@ -168,7 +170,6 @@ class UBBoardPaletteManager : public QObject
         void erasePaletteButtonPressed();
         void erasePaletteButtonReleased();
 
-        void toggleErasePalette(bool ckecked);
         void erasePaletteClosed();
 
         void togglePagePalette(bool ckecked);

src/board/UBBoardView.cpp

@@ -40,6 +40,7 @@
 #include "gui/UBTeacherGuideWidgetsTools.h"
 
 #include "board/UBBoardController.h"
+#include "board/UBBoardPaletteManager.h"
 
 #include "domain/UBGraphicsTextItem.h"
 #include "domain/UBGraphicsPixmapItem.h"
@@ -57,6 +58,7 @@
 #include "tools/UBGraphicsCompass.h"
 #include "tools/UBGraphicsCache.h"
 #include "tools/UBGraphicsTriangle.h"
+#include "tools/UBGraphicsProtractor.h"
 
 #include "core/memcheck.h"
 
@@ -67,16 +69,23 @@ UBBoardView::UBBoardView (UBBoardController* pController, QWidget* pParent)
 , mIsCreatingSceneGrabZone (false)
 , mOkOnWidget(false)
 , suspendedMousePressEvent(NULL)
+, mLongPressInterval(1000)
+, mIsDragInProgress(false)
 {
   init ();
 
   mFilterZIndex = false;
+
+  mLongPressTimer.setInterval(mLongPressInterval);
+  mLongPressTimer.setSingleShot(true);
 }
 
 UBBoardView::UBBoardView (UBBoardController* pController, int pStartLayer, int pEndLayer, QWidget* pParent)
 : QGraphicsView (pParent)
 , mController (pController)
 , suspendedMousePressEvent(NULL)
+, mLongPressInterval(1000)
+, mIsDragInProgress(false)
 {
   init ();
 
@@ -84,6 +93,9 @@ UBBoardView::UBBoardView (UBBoardController* pController, int pStartLayer, int p
   mEndLayer = pEndLayer;
 
   mFilterZIndex = true;  
+
+  mLongPressTimer.setInterval(mLongPressInterval);
+  mLongPressTimer.setSingleShot(true);
 }
 
 UBBoardView::~UBBoardView () {
@@ -375,8 +387,300 @@ void UBBoardView::tabletEvent (QTabletEvent * event)
 
 }
 
+bool UBBoardView::itemIsLocked(QGraphicsItem *item)
+{
+    if (!item)
+        return false;
+
+    if (item->data(UBGraphicsItemData::ItemLocked).toBool())
+        return true;
+
+    return itemIsLocked(item->parentItem());
+
+}
+
+bool UBBoardView::itemHaveParentWithType(QGraphicsItem *item, int type)
+{
+    if (!item)
+        return false;
+
+    if (type == item->type())
+        return true;
+    
+    return itemHaveParentWithType(item->parentItem(), type);
+
+}
+
+bool UBBoardView::itemShouldReceiveMousePressEvent(QGraphicsItem *item)
+{
+    if (!item) 
+        return true;
+
+    if (item == scene()->backgroundObject())
+        return true;
+
+    if (itemIsLocked(item))
+        return false;
+
+
+    UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController()->stylusTool();
+
+    if ((currentTool == UBStylusTool::Play) && UBGraphicsGroupContainerItem::Type == movingItem->type())
+        return movingItem = NULL;
+
+    switch(item->type())
+    {
+
+    case UBGraphicsMediaItem::Type:
+        return false;
+
+    case UBGraphicsPixmapItem::Type:
+    case UBGraphicsTextItem::Type:
+        if ((currentTool == UBStylusTool::Selector) && item->isSelected())
+            return true;
+        if ((currentTool == UBStylusTool::Selector) && item->parentItem() && item->parentItem()->isSelected())
+            return true;
+        if (currentTool != UBStylusTool::Selector)
+            return false;
+        break;
+
+    case UBGraphicsGroupContainerItem::Type:
+        return (currentTool == UBStylusTool::Selector);
+
+    case UBGraphicsW3CWidgetItem::Type:
+        if (currentTool == UBStylusTool::Selector && item->parentItem() && item->parentItem()->isSelected()) 
+            return true;
+        if (currentTool == UBStylusTool::Selector && item->isSelected()) 
+            return true;
+        if (currentTool == UBStylusTool::Play)
+            return true;
+        break;
+
+    default: 
+        return true;
+    }
+
+    return false;
+}
+
+bool UBBoardView::itemShouldReceiveSuspendedMousePressEvent(QGraphicsItem *item)
+{
+    if (!item) 
+        return false;
+
+    if (item == scene()->backgroundObject())
+        return false;
+
+    if (itemIsLocked(item))
+        return false;
+
+    UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController()->stylusTool();
+   
+    switch(item->type())
+    {
+    case UBGraphicsPixmapItem::Type:
+    case UBGraphicsTextItem::Type:
+    case UBGraphicsW3CWidgetItem::Type:
+        if (currentTool != UBStylusTool::Play && !item->isSelected() && item->parentItem())
+            return true;
+        if (currentTool != UBStylusTool::Play && !item->isSelected())
+            return true;
+        break;
+    
+    case UBGraphicsMediaItem::Type:
+        return true;
+
+    default:
+        return false;
+    }
+    return false;
+}
+
+bool UBBoardView::itemShouldBeMoved(QGraphicsItem *item)
+{
+    if (!item) 
+        return false;
+
+    if (item == scene()->backgroundObject())
+        return false;
+
+    if (!(mMouseButtonIsPressed || mTabletStylusIsPressed))
+        return false;
+        
+    if (movingItem->data(UBGraphicsItemData::ItemLocked).toBool())
+        return false;
+
+    UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController()->stylusTool();  
+   
+    if (movingItem->parentItem() && !movingItem->isSelected() && movingItem->parentItem()->isSelected())
+        return false;
+
+    switch(item->type())
+    {
+    case UBGraphicsGroupContainerItem::Type:
+        return true;
+
+    case UBGraphicsW3CWidgetItem::Type:
+        if(currentTool == UBStylusTool::Selector && item->isSelected()) 
+            return false;
+        if(currentTool == UBStylusTool::Play)
+            return false;
+
+    case UBGraphicsPixmapItem::Type:
+        if (item->isSelected())
+            return false;
+    case UBGraphicsMediaItem::Type:
+    case UBGraphicsStrokesGroup::Type: 
+        return true;
+    case UBGraphicsTextItem::Type:
+        return !item->isSelected();
+
+    default: 
+        false;
+    }
+
+    return false;
+}
+
+// determine item to interacts: item self or it's container.
+QGraphicsItem* UBBoardView::determineItemToMove(QGraphicsItem *item)
+{
+    if(item)
+    {
+        UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController()->stylusTool();  
+        if ((UBStylusTool::Play == currentTool) && (UBGraphicsW3CWidgetItem::Type == item->type()))
+                return item;
+
+        if(item->parentItem() && UBGraphicsGroupContainerItem::Type == item->parentItem()->type())
+        {
+            if (UBStylusTool::Play == currentTool && item->parentItem()->isSelected())
+                return item->parentItem();
+            
+            if (item->parentItem()->isSelected())
+                return item;
+                
+               
+            if (item->isSelected())
+                return NULL;
+
+            return item->parentItem();
+        }
+
+        if(item->parentItem() && UBGraphicsStrokesGroup::Type == item->parentItem()->type())    
+            return determineItemToMove(item->parentItem());    
+    }
+
+    return item;
+}
+
+void UBBoardView::handleItemMousePress(QMouseEvent *event)
+{
+    mLastPressedMousePos = mapToScene(event->pos());
+
+    if (itemShouldReceiveMousePressEvent(movingItem))
+        QGraphicsView::mousePressEvent (event);
+    else
+    if (itemShouldReceiveSuspendedMousePressEvent(movingItem))
+    {
+        if (suspendedMousePressEvent)
+            delete suspendedMousePressEvent;
+        suspendedMousePressEvent = new QMouseEvent(event->type(), event->pos(), event->button(), event->buttons(), event->modifiers());
+    }
+}
+
+void UBBoardView::handleItemMouseMove(QMouseEvent *event)
+{
+    if (movingItem)
+        movingItem = determineItemToMove(movingItem);
+
+    if (movingItem && itemShouldBeMoved(movingItem) && (mMouseButtonIsPressed || mTabletStylusIsPressed))       
+    {
+        QPointF scenePos = mapToScene(event->pos());
+        QPointF newPos = movingItem->pos() + scenePos - mLastPressedMousePos;
+        movingItem->setPos(newPos);
+        mLastPressedMousePos = scenePos;
+        mWidgetMoved = true;
+        event->accept();
+    }
+    else 
+    {
+        QPointF posBeforeMove;
+        QPointF posAfterMove;
+
+        if (movingItem)
+            posBeforeMove = movingItem->pos();
+
+        QGraphicsView::mouseMoveEvent (event);
+
+        if (movingItem)
+          posAfterMove = movingItem->pos();
+
+        mWidgetMoved = ((posAfterMove-posBeforeMove).manhattanLength() != 0);
+
+        // a cludge for terminate moving of w3c widgets.
+        if (mWidgetMoved && UBGraphicsW3CWidgetItem::Type == movingItem->type())
+            movingItem->setPos(posBeforeMove);
+
+    }
+}
+
+void UBBoardView::rubberItems()
+{
+    if (mUBRubberBand)
+        mRubberedItems = items(mUBRubberBand->geometry());
+}
+
+void UBBoardView::moveRubberedItems(QPointF movingVector)
+{
+    QRectF invalidateRect = scene()->itemsBoundingRect();
+
+    foreach (QGraphicsItem *item, mRubberedItems) 
+    {
+
+        if (item->type() == UBGraphicsW3CWidgetItem::Type
+              || item->type() == UBGraphicsPixmapItem::Type
+              || item->type() == UBGraphicsMediaItem::Type
+              || item->type() == UBGraphicsSvgItem::Type
+              || item->type() == UBGraphicsTextItem::Type
+              || item->type() == UBGraphicsStrokesGroup::Type
+              || item->type() == UBGraphicsGroupContainerItem::Type) 
+        {
+              item->setPos(item->pos()+movingVector);       
+        }    
+    }
+
+    scene()->invalidate(invalidateRect);
+}
+
+void UBBoardView::longPressEvent()
+{
+   UBDrawingController *drawingController = UBDrawingController::drawingController();
+   UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
+
+   
+   disconnect(&mLongPressTimer, SIGNAL(timeout()), this, SLOT(longPressEvent()));
+
+   if (UBStylusTool::Selector == currentTool)
+   {
+        drawingController->setStylusTool(UBStylusTool::Play);
+   }
+   else
+   if (currentTool == UBStylusTool::Play)
+   {
+        drawingController->setStylusTool(UBStylusTool::Selector);
+   }
+   else
+   if (UBStylusTool::Eraser == currentTool)
+   {
+       UBApplication::boardController->paletteManager()->toggleErasePalette(true);
+   }
+
+}
+
 void UBBoardView::mousePressEvent (QMouseEvent *event)
 {
+    mIsDragInProgress = false;
+
     if (isAbsurdPoint (event->pos ()))
     {
         event->accept ();
@@ -411,12 +715,13 @@ void UBBoardView::mousePressEvent (QMouseEvent *event)
             mPreviousPoint = event->posF ();
             event->accept ();
         }
-        else if (currentTool == UBStylusTool::Selector)
+        else if (currentTool == UBStylusTool::Selector || currentTool == UBStylusTool::Play)
         {
-//            QSet<QGraphicsItem*> existingTools = scene()->tools(); why do we need to get tools here?
-
             movingItem = scene()->itemAt(this->mapToScene(event->posF().toPoint()));
 
+            connect(&mLongPressTimer, SIGNAL(timeout()), this, SLOT(longPressEvent()));
+            mLongPressTimer.start();
+
             if (!movingItem) {
                 // Rubberband selection implementation
                 if (!mUBRubberBand) {
@@ -425,34 +730,12 @@ void UBBoardView::mousePressEvent (QMouseEvent *event)
                 mUBRubberBand->setGeometry (QRect (mMouseDownPos, QSize ()));
                 mUBRubberBand->show();
             }
-
-            if (!movingItem
-                || movingItem->isSelected()
-                || movingItem->type() == UBGraphicsDelegateFrame::Type
-                || movingItem->type() == DelegateButton::Type
-                || movingItem->type() == UBGraphicsCompass::Type
-                || movingItem->type() == UBGraphicsPDFItem::Type
-                || movingItem->type() == UBGraphicsPolygonItem::Type
-                || movingItem->type() == UBGraphicsCache::Type
-                || movingItem->type() == UBGraphicsTriangle::Type
-                || movingItem == this->scene()->backgroundObject()
-                || (movingItem->parentItem() && movingItem->parentItem()->type() == UBGraphicsGroupContainerItem::Type))
-            {
-                    movingItem = NULL;
-                    QGraphicsView::mousePressEvent (event);
-
-                }
             else
             {
-                mLastPressedMousePos = mapToScene(event->pos());
-                if (suspendedMousePressEvent)
-                {
-                    delete suspendedMousePressEvent;
-                }
-                suspendedMousePressEvent = new QMouseEvent(event->type(), event->pos(), event->button(), event->buttons(), event->modifiers()); // удалить
+                mUBRubberBand->hide();
             }
 
-
+            handleItemMousePress(event);
             event->accept();
         }
         else if (currentTool == UBStylusTool::Text)
@@ -509,6 +792,11 @@ void UBBoardView::mousePressEvent (QMouseEvent *event)
 
             if (scene () && !mTabletStylusIsPressed)
             {
+                if (currentTool == UBStylusTool::Eraser)
+                {
+                    connect(&mLongPressTimer, SIGNAL(timeout()), this, SLOT(longPressEvent()));
+                    mLongPressTimer.start();
+                }
                 scene ()->inputDevicePress (mapToScene (UBGeometryUtils::pointConstrainedInRect (event->pos (), rect ())));
             }
             event->accept ();
@@ -519,8 +807,16 @@ void UBBoardView::mousePressEvent (QMouseEvent *event)
 void
 UBBoardView::mouseMoveEvent (QMouseEvent *event)
 {
+  if(!mIsDragInProgress && ((mapToScene(event->pos()) - mLastPressedMousePos).manhattanLength() < QApplication::startDragDistance())) 
+  {
+      return;
+  }
+
+  mIsDragInProgress = true;
   UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
 
+  mLongPressTimer.stop();
+
   if (isAbsurdPoint (event->pos ()))
     {
       event->accept ();
@@ -536,14 +832,16 @@ UBBoardView::mouseMoveEvent (QMouseEvent *event)
       mPreviousPoint = eventPosition;
       event->accept ();
     }
-  else if (currentTool == UBStylusTool::Selector)
+  else if (currentTool == UBStylusTool::Selector || currentTool == UBStylusTool::Play)
   {
       if((event->pos() - mLastPressedMousePos).manhattanLength() < QApplication::startDragDistance()) {
           return;
       }
 
-      if (mUBRubberBand && mUBRubberBand->isVisible()) {
+      if (!movingItem && (mMouseButtonIsPressed || mTabletStylusIsPressed) && mUBRubberBand && mUBRubberBand->isVisible()) {
+
           QRect bandRect(mMouseDownPos, event->pos());
+
           bandRect = bandRect.normalized();
 
           mUBRubberBand->setGeometry(bandRect);
@@ -555,6 +853,8 @@ UBBoardView::mouseMoveEvent (QMouseEvent *event)
                   mJustSelectedItems.remove(item);
               }
           }
+
+          if (currentTool == UBStylusTool::Selector)
           foreach (QGraphicsItem *item, items(bandRect)) {
 
               if (item->type() == UBGraphicsW3CWidgetItem::Type
@@ -573,16 +873,7 @@ UBBoardView::mouseMoveEvent (QMouseEvent *event)
           }
       }
 
-        if (movingItem && (mMouseButtonIsPressed || mTabletStylusIsPressed))
-        {
-            QPointF scenePos = mapToScene(event->pos());
-            QPointF newPos = movingItem->pos() + scenePos - mLastPressedMousePos;
-            movingItem->setPos(newPos);
-            mLastPressedMousePos = scenePos;
-            mWidgetMoved = true;
-            event->accept();
-        }
-        else QGraphicsView::mouseMoveEvent (event);
+      handleItemMouseMove(event);
     }
   else if ((UBDrawingController::drawingController()->isDrawingTool())
     && !mMouseButtonIsPressed)
@@ -609,6 +900,9 @@ UBBoardView::mouseMoveEvent (QMouseEvent *event)
       }
       event->accept ();
     }
+
+    if((event->pos() - mLastPressedMousePos).manhattanLength() < QApplication::startDragDistance()) 
+        mWidgetMoved = true;
 }
 
 void
@@ -616,9 +910,7 @@ UBBoardView::mouseReleaseEvent (QMouseEvent *event)
 {
     UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
 
-    scene ()->setToolCursor (currentTool);
   setToolCursor (currentTool);
-
   // first propagate device release to the scene
   if (scene ())
     scene ()->inputDeviceRelease ();
@@ -630,13 +922,17 @@ UBBoardView::mouseReleaseEvent (QMouseEvent *event)
           mWidgetMoved = false;
           movingItem = NULL;
       }
-      else if (movingItem && suspendedMousePressEvent)
+      else 
+          if (movingItem)
+          {         
+              if (suspendedMousePressEvent && !movingItem->data(UBGraphicsItemData::ItemLocked).toBool())       
               {
                   QGraphicsView::mousePressEvent(suspendedMousePressEvent);     // suspendedMousePressEvent is deleted by old Qt event loop
                   movingItem = NULL;
                   delete suspendedMousePressEvent;
                   suspendedMousePressEvent = NULL;                       
               }
+          }
 
           if (mUBRubberBand && mUBRubberBand->isVisible()) {
               mUBRubberBand->hide();
@@ -644,6 +940,26 @@ UBBoardView::mouseReleaseEvent (QMouseEvent *event)
 
       QGraphicsView::mouseReleaseEvent (event);
     }
+  else if (currentTool == UBStylusTool::Play)
+  {
+      if (mWidgetMoved)
+      {
+          movingItem = NULL;
+          mWidgetMoved = false;
+      }
+      else
+      {
+          if (suspendedMousePressEvent && movingItem && !movingItem->data(UBGraphicsItemData::ItemLocked).toBool())       
+          {
+              QGraphicsView::mousePressEvent(suspendedMousePressEvent);     // suspendedMousePressEvent is deleted by old Qt event loop
+              movingItem = NULL;
+              delete suspendedMousePressEvent;
+              suspendedMousePressEvent = NULL;
+          }
+
+          QGraphicsView::mouseReleaseEvent (event);
+      }
+  }
   else if (currentTool == UBStylusTool::Text)
     {
       if (mRubberBand)
@@ -702,6 +1018,7 @@ UBBoardView::mouseReleaseEvent (QMouseEvent *event)
   mPendingStylusReleaseEvent = false;
   mTabletStylusIsPressed = false;
 
+  mLongPressTimer.stop();
 }
 
 void
@@ -1008,6 +1325,7 @@ UBBoardView::setToolCursor (int tool)
       break;
     case UBStylusTool::Eraser:
       controlViewport->setCursor (UBResources::resources ()->eraserCursor);
+      scene()->hideEraser();
       break;
     case UBStylusTool::Marker:
       controlViewport->setCursor (UBResources::resources ()->markerCursor);
@@ -1027,6 +1345,9 @@ UBBoardView::setToolCursor (int tool)
     case UBStylusTool::Selector:
       controlViewport->setCursor (UBResources::resources ()->arrowCursor);
       break;
+    case UBStylusTool::Play:
+      controlViewport->setCursor (UBResources::resources ()->drawLineRulerCursor);
+      break;
     case UBStylusTool::Line:
       controlViewport->setCursor (UBResources::resources ()->penCursor);
       break;

src/board/UBBoardView.h

@@ -42,6 +42,9 @@ class UBBoardView : public QGraphicsView
 
         void setToolCursor(int tool);
 
+        void rubberItems();
+        void moveRubberedItems(QPointF movingVector);
+
     signals:
 
         void resized(QResizeEvent* event);
@@ -51,6 +54,15 @@ class UBBoardView : public QGraphicsView
 
     protected:
 
+        bool itemIsLocked(QGraphicsItem *item);
+        bool itemShouldReceiveMousePressEvent(QGraphicsItem *item);
+        bool itemShouldReceiveSuspendedMousePressEvent(QGraphicsItem *item);
+        bool itemHaveParentWithType(QGraphicsItem *item, int type);
+        bool itemShouldBeMoved(QGraphicsItem *item);
+        QGraphicsItem* determineItemToMove(QGraphicsItem *item);
+        void handleItemMousePress(QMouseEvent *event);
+        void handleItemMouseMove(QMouseEvent *event);
+
         virtual bool event (QEvent * e);
 
         virtual void keyPressEvent(QKeyEvent *event);
@@ -124,9 +136,17 @@ class UBBoardView : public QGraphicsView
         QGraphicsItem *movingItem;
         QMouseEvent *suspendedMousePressEvent;
 
+        bool moveRubberBand;
         UBRubberBand *mUBRubberBand;
+        
+        QList<QGraphicsItem *> mRubberedItems;
         QSet<QGraphicsItem*> mJustSelectedItems;
 
+        int mLongPressInterval;
+        QTimer mLongPressTimer;
+
+        bool mIsDragInProgress;
+
     private slots:
 
         void settingChanged(QVariant newValue);
@@ -134,6 +154,7 @@ class UBBoardView : public QGraphicsView
 	public slots:
 
 		void virtualKeyboardActivated(bool b);
+        void longPressEvent();
 
 };
 

src/board/UBDrawingController.cpp

@@ -54,6 +54,7 @@ UBDrawingController::UBDrawingController(QObject * parent)
     connect(UBApplication::mainWindow->actionEraser, SIGNAL(triggered(bool)), this, SLOT(eraserToolSelected(bool)));
     connect(UBApplication::mainWindow->actionMarker, SIGNAL(triggered(bool)), this, SLOT(markerToolSelected(bool)));
     connect(UBApplication::mainWindow->actionSelector, SIGNAL(triggered(bool)), this, SLOT(selectorToolSelected(bool)));
+    connect(UBApplication::mainWindow->actionPlay, SIGNAL(triggered(bool)), this, SLOT(playToolSelected(bool)));
     connect(UBApplication::mainWindow->actionHand, SIGNAL(triggered(bool)), this, SLOT(handToolSelected(bool)));
     connect(UBApplication::mainWindow->actionZoomIn, SIGNAL(triggered(bool)), this, SLOT(zoomInToolSelected(bool)));
     connect(UBApplication::mainWindow->actionZoomOut, SIGNAL(triggered(bool)), this, SLOT(zoomOutToolSelected(bool)));
@@ -120,6 +121,8 @@ void UBDrawingController::setStylusTool(int tool)
             UBApplication::mainWindow->actionMarker->setChecked(true);
         else if (mStylusTool == UBStylusTool::Selector)
             UBApplication::mainWindow->actionSelector->setChecked(true);
+        else if (mStylusTool == UBStylusTool::Play)
+            UBApplication::mainWindow->actionPlay->setChecked(true);
         else if (mStylusTool == UBStylusTool::Hand)
             UBApplication::mainWindow->actionHand->setChecked(true);
         else if (mStylusTool == UBStylusTool::ZoomIn)
@@ -347,6 +350,12 @@ void UBDrawingController::selectorToolSelected(bool checked)
         setStylusTool(UBStylusTool::Selector);
 }
 
+void UBDrawingController::playToolSelected(bool checked)
+{
+    if (checked)
+        setStylusTool(UBStylusTool::Play);
+}
+
 void UBDrawingController::handToolSelected(bool checked)
 {
     if (checked)

src/board/UBDrawingController.h

@@ -88,6 +88,7 @@ class UBDrawingController : public QObject
         void eraserToolSelected(bool checked);
         void markerToolSelected(bool checked);
         void selectorToolSelected(bool checked);
+        void playToolSelected(bool checked);
         void handToolSelected(bool checked);
         void zoomInToolSelected(bool checked);
         void zoomOutToolSelected(bool checked);

src/core/UB.h

@@ -28,6 +28,7 @@ struct UBStylusTool
 		Eraser, 
  		Marker, 
 		Selector, 
+        Play,
 		Hand, 
 		ZoomIn, 
 		ZoomOut, 

src/domain/UBGraphicsDelegateFrame.cpp

@@ -249,7 +249,7 @@ bool UBGraphicsDelegateFrame::canResizeBottomRight(qreal width, qreal height, qr
 
 void UBGraphicsDelegateFrame::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (mDelegate->delegated()->data(UBGraphicsItemData::ItemLocked).toBool())
+    if (None == mCurrentTool)
         return; 
 
     QLineF move(mStartingPoint, event->scenePos());

src/domain/UBGraphicsItemDelegate.cpp

@@ -328,8 +328,10 @@ void UBGraphicsItemDelegate::positionHandles()
     if (mDelegated->isSelected()) {
         bool shownOnDisplay = mDelegated->data(UBGraphicsItemData::ItemLayerType).toInt() != UBItemLayerType::Control;
         showHide(shownOnDisplay);
-        lock(isLocked());
+        mDelegated->setData(UBGraphicsItemData::ItemLocked, QVariant(isLocked()));
         updateFrame();
+
+        if (UBStylusTool::Play != UBDrawingController::drawingController()->stylusTool())
             mFrame->show();
 
         updateButtons(true);
@@ -451,6 +453,7 @@ void UBGraphicsItemDelegate::lock(bool locked)
     }
 
     mDelegated->update();
+    positionHandles();
     mFrame->positionHandles();
 }
 
@@ -676,7 +679,7 @@ UBGraphicsToolBarItem::UBGraphicsToolBarItem(QGraphicsItem * parent) :
     rect.setWidth(parent->boundingRect().width());
     this->setRect(rect);
 
-    setBrush(QColor(UBSettings::paletteColor));             
+  //  setBrush(QColor(UBSettings::paletteColor));             
     setPen(Qt::NoPen);
     hide();
 
@@ -708,6 +711,17 @@ void UBGraphicsToolBarItem::paint(QPainter *painter, const QStyleOptionGraphicsI
     QPainterPath path;
     path.addRoundedRect(rect(), 10, 10);  
 
+    if (parentItem() && parentItem()->data(UBGraphicsItemData::ItemLocked).toBool())
+    {
+        QColor baseColor = UBSettings::paletteColor;
+        baseColor.setAlphaF(baseColor.alphaF() / 3);
+        setBrush(QBrush(baseColor));
+    }
+    else
+    {
+        setBrush(QBrush(UBSettings::paletteColor));
+    }
+
     painter->fillPath(path, brush());
 }
 
@@ -1215,6 +1229,7 @@ void DelegateMediaControl::mousePressEvent(QGraphicsSceneMouseEvent *event)
         seekToMousePos(event->pos());
         this->update();
         event->accept();
+        emit used();
     }
 }
 
@@ -1227,6 +1242,7 @@ void DelegateMediaControl::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
         seekToMousePos(event->pos());
         this->update();
         event->accept();
+        emit used();
     }
 }
 
@@ -1251,6 +1267,7 @@ void DelegateMediaControl::seekToMousePos(QPointF mousePos)
         //OSX is a bit lazy
         updateTicker(tickPos);
     }
+    emit used();
 }
 
 void DelegateMediaControl::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

src/domain/UBGraphicsItemDelegate.h

@@ -102,8 +102,10 @@ uint smallPoint : 1;
 
 };
 
-class DelegateMediaControl: public QGraphicsRectItem
+class DelegateMediaControl: public QObject, public QGraphicsRectItem
 {
+    Q_OBJECT
+
     public:
 
         DelegateMediaControl(UBGraphicsMediaItem* pDelegated, QGraphicsItem * parent = 0);
@@ -127,6 +129,9 @@ class DelegateMediaControl: public QGraphicsRectItem
         void updateTicker(qint64 time);
         void totalTimeChanged(qint64 newTotalTime);
 
+    signals:
+        void used();
+
     protected:
         void seekToMousePos(QPointF mousePos);
 

src/domain/UBGraphicsMediaItem.cpp

@@ -34,8 +34,8 @@ UBGraphicsMediaItem::UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsIte
         , mInitialPos(0)
         , mVideoWidget(NULL)
         , mAudioWidget(NULL)
+        , mLinkedImage(NULL)
 {
-    
     update();
 
     QString s = pMediaFileUrl.toLocalFile();
@@ -60,6 +60,7 @@ UBGraphicsMediaItem::UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsIte
             mVideoWidget->resize(320,240);
         }
         setWidget(mVideoWidget);
+        haveLinkedImage = true;
     }
     else    
     if (pMediaFileUrl.toLocalFile().contains("audios"))
@@ -71,6 +72,7 @@ UBGraphicsMediaItem::UBGraphicsMediaItem(const QUrl& pMediaFileUrl, QGraphicsIte
         mAudioWidget = new QWidget();
         mAudioWidget->resize(320,26);
         setWidget(mAudioWidget);
+        haveLinkedImage = false;
     }
 
     Phonon::createPath(mMediaObject, mAudioOutput);
@@ -226,7 +228,7 @@ void UBGraphicsMediaItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
     if (mDelegate)
     {
         mDelegate->mousePressEvent(event);
-        if (mDelegate && parentItem() && UBGraphicsGroupContainerItem::Type == parentItem()->type())
+        if (parentItem() && UBGraphicsGroupContainerItem::Type == parentItem()->type())
         {
             UBGraphicsGroupContainerItem *group = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(parentItem());
             if (group)
@@ -242,11 +244,6 @@ void UBGraphicsMediaItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             }       
 
         }
-        else
-        {
-            mDelegate->getToolBarItem()->show();
-        }
-
     }
 
     if (parentItem() && parentItem()->type() == UBGraphicsGroupContainerItem::Type)
@@ -271,9 +268,6 @@ void UBGraphicsMediaItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 
 void UBGraphicsMediaItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (data(UBGraphicsItemData::ItemLocked).toBool())
-        return;
-
     if(mShouldMove && (event->buttons() & Qt::LeftButton))
     {
         QPointF offset = event->scenePos() - mMousePressPos;

src/domain/UBGraphicsMediaItem.h

@@ -73,6 +73,8 @@ public:
         return mVideoWidget;
     }
 
+    bool hasLinkedImage(){return haveLinkedImage;}
+
     mediaType getMediaType() { return mMediaType; }
 
     virtual UBGraphicsScene* scene();
@@ -115,6 +117,8 @@ private:
     QPointF mMousePressPos;
     QPointF mMouseMovePos;
 
+    bool haveLinkedImage;
+    QGraphicsPixmapItem *mLinkedImage;
 };
 
 

src/domain/UBGraphicsMediaItemDelegate.cpp

@@ -33,6 +33,8 @@
 UBGraphicsMediaItemDelegate::UBGraphicsMediaItemDelegate(UBGraphicsMediaItem* pDelegated, Phonon::MediaObject* pMedia, QObject * parent)
     : UBGraphicsItemDelegate(pDelegated, parent, true, false)
     , mMedia(pMedia)
+    , mToolBarShowTimer(NULL)
+    , m_iToolBarShowingInterval(5000)
 {
     QPalette palette;
     palette.setBrush ( QPalette::Light, Qt::darkGray );
@@ -42,26 +44,46 @@ UBGraphicsMediaItemDelegate::UBGraphicsMediaItemDelegate(UBGraphicsMediaItem* pD
     connect(mMedia, SIGNAL(finished()), this, SLOT(updatePlayPauseState()));
     connect(mMedia, SIGNAL(tick(qint64)), this, SLOT(updateTicker(qint64)));
     connect(mMedia, SIGNAL(totalTimeChanged(qint64)), this, SLOT(totalTimeChanged(qint64)));
+
+    if (delegated()->hasLinkedImage())
+    {
+        mToolBarShowTimer = new QTimer();
+        connect(mToolBarShowTimer, SIGNAL(timeout()), this, SLOT(hideToolBar()));
+        mToolBarShowTimer->setInterval(m_iToolBarShowingInterval);
+    }
 }
 
 bool UBGraphicsMediaItemDelegate::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     Q_UNUSED(event);
     mToolBarItem->show();
+
+    if (mToolBarShowTimer)
+        mToolBarShowTimer->start();
+
     return UBGraphicsItemDelegate::mousePressEvent(event);
 }
 
+void UBGraphicsMediaItemDelegate::hideToolBar()
+{
+    mToolBarItem->hide();
+}
+
 void UBGraphicsMediaItemDelegate::buildButtons()
 {
     mPlayPauseButton = new DelegateButton(":/images/play.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
     connect(mPlayPauseButton, SIGNAL(clicked(bool)), this, SLOT(togglePlayPause()));
+    connect(mPlayPauseButton, SIGNAL(clicked(bool)), mToolBarShowTimer, SLOT(start()));
+    
 
     mStopButton = new DelegateButton(":/images/stop.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
     connect(mStopButton, SIGNAL(clicked(bool)), mMedia, SLOT(stop()));
+    connect(mStopButton, SIGNAL(clicked(bool)), mToolBarShowTimer, SLOT(start()));
 
     mMediaControl = new DelegateMediaControl(delegated(), mToolBarItem);
     mMediaControl->setFlag(QGraphicsItem::ItemIsSelectable, true);
     UBGraphicsItem::assignZValue(mMediaControl, delegated()->zValue());
+    connect(mMediaControl, SIGNAL(used()), mToolBarShowTimer, SLOT(start()));
     
     if (delegated()->isMuted())
         mMuteButton = new DelegateButton(":/images/soundOff.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
@@ -70,6 +92,7 @@ void UBGraphicsMediaItemDelegate::buildButtons()
 
     connect(mMuteButton, SIGNAL(clicked(bool)), delegated(), SLOT(toggleMute())); 
     connect(mMuteButton, SIGNAL(clicked(bool)), this, SLOT(toggleMute())); // for changing button image
+    connect(mMuteButton, SIGNAL(clicked(bool)), mToolBarShowTimer, SLOT(start()));
 
     mButtons << mPlayPauseButton << mStopButton << mMuteButton;
 
@@ -89,7 +112,8 @@ void UBGraphicsMediaItemDelegate::buildButtons()
 
 UBGraphicsMediaItemDelegate::~UBGraphicsMediaItemDelegate()
 {
-    //NOOP
+    if (mToolBarShowTimer)
+        delete mToolBarShowTimer;
 }
 
 void UBGraphicsMediaItemDelegate::positionHandles()

src/domain/UBGraphicsMediaItemDelegate.h

@@ -18,6 +18,7 @@
 
 #include <QtGui>
 #include <phonon/MediaObject>
+#include <QTimer>
 
 #include "core/UB.h"
 #include "UBGraphicsItemDelegate.h"
@@ -54,6 +55,8 @@ class UBGraphicsMediaItemDelegate :  public UBGraphicsItemDelegate
 
         void totalTimeChanged(qint64 newTotalTime);
 
+        void hideToolBar();
+
     protected:
         virtual void buildButtons();
 
@@ -65,6 +68,9 @@ class UBGraphicsMediaItemDelegate :  public UBGraphicsItemDelegate
         DelegateMediaControl *mMediaControl;
 
         Phonon::MediaObject* mMedia;
+
+        QTimer *mToolBarShowTimer;
+        int m_iToolBarShowingInterval;
 };
 
 #endif /* UBGRAPHICSMEDIAITEMDELEGATE_H_ */

src/domain/UBGraphicsProxyWidget.cpp

@@ -47,6 +47,10 @@ UBGraphicsProxyWidget::~UBGraphicsProxyWidget()
 
 QVariant UBGraphicsProxyWidget::itemChange(GraphicsItemChange change, const QVariant &value)
 {
+    if (change == QGraphicsItem::ItemCursorHasChanged &&  scene())
+    {
+        unsetCursor();
+    }
     if ((change == QGraphicsItem::ItemSelectedHasChanged)
               &&  scene())
     {
@@ -82,9 +86,10 @@ void UBGraphicsProxyWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)
     else
     {
         // QT Proxy Widget is a bit lazy, we force the selection ...
-        QGraphicsProxyWidget::mousePressEvent(event);
+
         setSelected(true);
     }
+    QGraphicsProxyWidget::mousePressEvent(event);
 }
 
 

src/domain/UBGraphicsScene.cpp

@@ -2366,14 +2366,10 @@ void UBGraphicsScene::createPointer()
 
 void UBGraphicsScene::setToolCursor(int tool)
 {
-    if (tool != (int)UBStylusTool::Selector
-            && tool != (int)UBStylusTool::Text)
+    if (tool == (int)UBStylusTool::Selector ||
+             tool == (int)UBStylusTool::Text || 
+                tool == (int)UBStylusTool::Play)
     {
         deselectAllItems();
     }
-
-    if (tool != (int)UBStylusTool::Eraser)
-    {
-        hideEraser();
-    }
 }

src/domain/UBGraphicsTextItemDelegate.cpp

@@ -303,11 +303,14 @@ void UBGraphicsTextItemDelegate::positionHandles()
             UBGraphicsGroupContainerItem *group = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(mDelegated->parentItem());
 
             mToolBarItem->hide();
+            if (mToolBarItem->parentItem() && !mToolBarItem->parentItem()->data(UBGraphicsItemData::ItemLocked).toBool())
+            {
                 if (group && group->getCurrentItem() == mDelegated && group->isSelected())
                     mToolBarItem->show();
 
                 if (!group)
                      mToolBarItem->show();
+            }
 
         }
     }

src/gui/UBRubberBand.cpp

@@ -23,10 +23,18 @@
 #include <QtGui/QMacStyle>
 #endif
 
+#include "core/UBApplication.h"
+#include "board/UBBoardController.h"
+#include "board/UBBoardView.h"
+
 #include "core/memcheck.h"
 
 UBRubberBand::UBRubberBand(Shape s, QWidget * p)
     : QRubberBand(s, p)
+    , mResizingMode(None)
+    , mMouseIsPressed(false)
+    , mLastPressedPoint(QPoint())
+    , mResizingBorderHeight(20)
 {
     customStyle = NULL;
 
@@ -41,6 +49,8 @@ UBRubberBand::UBRubberBand(Shape s, QWidget * p)
     if (customStyle)
         QRubberBand::setStyle(customStyle);
 
+    setAttribute(Qt::WA_TransparentForMouseEvents, false);
+    setMouseTracking(true);
 }
 
 UBRubberBand::~UBRubberBand()
@@ -48,3 +58,192 @@ UBRubberBand::~UBRubberBand()
     if (customStyle)
         delete customStyle;
 }
+
+UBRubberBand::enm_resizingMode UBRubberBand::determineResizingMode(QPoint pos)
+{
+    if (mMouseIsPressed)
+        return mResizingMode;
+    
+    QRect resizerTop    (mResizingBorderHeight               , 0                             , rect().width()-2*mResizingBorderHeight, mResizingBorderHeight                    );
+    QRect resizerBottom (mResizingBorderHeight               , rect().height() - mResizingBorderHeight, rect().width()-2*mResizingBorderHeight, mResizingBorderHeight                    );
+    QRect resizerLeft   (0                          , mResizingBorderHeight                  , mResizingBorderHeight                 , rect().height() - 2*mResizingBorderHeight);
+    QRect resizerRight  (rect().width()-mResizingBorderHeight, mResizingBorderHeight                  , mResizingBorderHeight                 , rect().height() - 2*mResizingBorderHeight);
+
+    QRect resizerTopLeft    (0                          , 0                             , mResizingBorderHeight, mResizingBorderHeight);
+    QRect resizerTopRight   (rect().width()-mResizingBorderHeight, 0                             , mResizingBorderHeight, mResizingBorderHeight);
+    QRect resizerBottomLeft (0                          , rect().height() - mResizingBorderHeight, mResizingBorderHeight, mResizingBorderHeight);
+    QRect resizerBottomRight(rect().width()-mResizingBorderHeight, rect().height() - mResizingBorderHeight, mResizingBorderHeight, mResizingBorderHeight);
+
+    enm_resizingMode resizingMode;
+    
+    QTransform cursorTransrofm;
+
+    if (resizerTop.contains(pos))
+    {
+        resizingMode = Top;
+        cursorTransrofm.rotate(90);
+    }
+    else
+    if (resizerBottom.contains(pos))
+    {
+        resizingMode = Bottom;
+        cursorTransrofm.rotate(90);
+    }
+    else
+    if (resizerLeft.contains(pos))
+    {
+        resizingMode = Left;
+    }
+    else
+    if (resizerRight.contains(pos))
+    {
+        resizingMode = Right;
+    }
+    else
+    if (resizerTopLeft.contains(pos))
+    {
+        resizingMode = TopLeft;
+        cursorTransrofm.rotate(45);
+    }
+    else
+    if (resizerTopRight.contains(pos))
+    {
+        resizingMode = TopRight;
+        cursorTransrofm.rotate(-45);
+    }
+    else
+    if (resizerBottomLeft.contains(pos))
+    {
+        resizingMode = BottomLeft;
+        cursorTransrofm.rotate(-45);
+    }
+    else
+    if (resizerBottomRight.contains(pos))
+    {
+        resizingMode = BottomRight;
+        cursorTransrofm.rotate(45);
+    }
+    else
+        resizingMode = None;
+    
+    if (None != resizingMode)
+    {
+        QPixmap pix(":/images/cursors/resize.png");
+        QCursor resizeCursor  = QCursor(pix.transformed(cursorTransrofm, Qt::SmoothTransformation), pix.width() / 2,  pix.height() / 2);
+        setCursor(resizeCursor);
+    }
+    else
+        unsetCursor();
+
+    return resizingMode;
+}
+
+void UBRubberBand::mousePressEvent(QMouseEvent *event)
+{
+    mResizingMode = determineResizingMode(event->pos());
+    mMouseIsPressed = true;
+
+    mLastPressedPoint = event->pos();
+    mLastMousePos = event->pos();
+
+    if (None == mResizingMode)
+    {
+        UBApplication::boardController->controlView()->rubberItems();
+        setCursor(QCursor(Qt::SizeAllCursor));
+    }
+}
+
+void UBRubberBand::mouseMoveEvent(QMouseEvent *event)
+{
+    determineResizingMode(event->pos());
+
+    if (mMouseIsPressed)
+    {
+        UBBoardView *view = UBApplication::boardController->controlView();
+        QRect currentGeometry = geometry();
+
+        QPoint pressPoint(event->pos());
+        QPoint pressPointGlobal(view->mapToGlobal(pressPoint));
+        QPoint prevPressPointGlobal(view->mapToGlobal(mLastPressedPoint));
+        QPoint movePointGlogal = (view->mapToGlobal(mLastMousePos));
+
+        QPoint topLeftResizeVector(pressPointGlobal - prevPressPointGlobal);
+        QPoint rightBottomResizeVector(pressPointGlobal - movePointGlogal);
+
+        bool bGeometryChange = true;
+
+        switch(mResizingMode)
+        {
+        case None:
+            {
+                QPointF itemsMoveVector(view->mapToScene(pressPointGlobal) - view->mapToScene(prevPressPointGlobal));
+
+                move(pos()+pressPointGlobal - prevPressPointGlobal);
+                view->moveRubberedItems(itemsMoveVector);
+
+                bGeometryChange = false;
+                break;
+            }
+
+        case Top:
+            {
+                currentGeometry.setY(currentGeometry.y()+topLeftResizeVector.y());
+            }break;
+
+        case Bottom:
+            {
+                currentGeometry.setHeight(currentGeometry.height()+rightBottomResizeVector.y());
+            }break;
+
+        case Left:
+            {
+                currentGeometry.setX(currentGeometry.x()+topLeftResizeVector.x());
+            }break;
+        case Right:
+            {
+                currentGeometry.setWidth(currentGeometry.width()+rightBottomResizeVector.x());
+            }break;
+
+        case TopLeft:
+            {
+                currentGeometry.setX(currentGeometry.x()+topLeftResizeVector.x());  
+                currentGeometry.setY(currentGeometry.y()+topLeftResizeVector.y());
+            }break;
+
+        case TopRight:
+            {
+                currentGeometry.setY(currentGeometry.y()+topLeftResizeVector.y());  
+                currentGeometry.setWidth(currentGeometry.width()+rightBottomResizeVector.x());                
+            }
+            break;
+
+        case BottomLeft:
+            {
+                currentGeometry.setX(currentGeometry.x()+topLeftResizeVector.x());
+                currentGeometry.setHeight(currentGeometry.height()+rightBottomResizeVector.y());  
+            }break;
+
+        case BottomRight:
+            {
+                currentGeometry.setWidth(currentGeometry.width()+rightBottomResizeVector.x());
+                currentGeometry.setHeight(currentGeometry.height()+rightBottomResizeVector.y());        
+            }break;
+        
+        }
+        if(bGeometryChange)
+        {   
+            setGeometry(currentGeometry);
+        }
+
+        mLastMousePos = event->pos();
+    }
+
+    QRubberBand::mouseMoveEvent(event);
+} 
+
+void UBRubberBand::mouseReleaseEvent(QMouseEvent *event)
+{
+    Q_UNUSED(event);
+    mMouseIsPressed = false;
+    unsetCursor();
+}

src/gui/UBRubberBand.h

@@ -26,8 +26,32 @@ class UBRubberBand : public QRubberBand
         UBRubberBand(Shape s, QWidget * p = 0);
         virtual ~UBRubberBand();
 
+    private:
+        enum enm_resizingMode
+        {
+            None,
+            Top,
+            TopLeft,
+            TopRight,
+            Bottom,
+            BottomLeft,
+            BottomRight,
+            Left,
+            Right
+        };
+
+        enm_resizingMode determineResizingMode(QPoint pos);
+        virtual void mousePressEvent(QMouseEvent *event);
+        virtual void mouseMoveEvent(QMouseEvent *event);
+        virtual void mouseReleaseEvent(QMouseEvent *event);
+
     private:
         QStyle* customStyle;
+        enm_resizingMode mResizingMode;
+        int mResizingBorderHeight;
+        bool mMouseIsPressed;
+        QPoint mLastPressedPoint;
+        QPoint mLastMousePos;
 };
 
 #endif /* UBRUBBERBAND_H_ */

src/gui/UBStylusPalette.cpp

@@ -39,6 +39,7 @@ UBStylusPalette::UBStylusPalette(QWidget *parent, Qt::Orientation orient)
     actions << UBApplication::mainWindow->actionEraser;
     actions << UBApplication::mainWindow->actionMarker;
     actions << UBApplication::mainWindow->actionSelector;
+    actions << UBApplication::mainWindow->actionPlay;
 
     actions << UBApplication::mainWindow->actionHand;
     actions << UBApplication::mainWindow->actionZoomIn;

src/tools/UBGraphicsCompass.cpp

@@ -170,7 +170,8 @@ QVariant UBGraphicsCompass::itemChange(GraphicsItemChange change, const QVariant
 
 void UBGraphicsCompass::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
-	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
+        UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
 		return;
 
     if (resizeButtonRect().contains(event->pos()))
@@ -205,7 +206,8 @@ void UBGraphicsCompass::mousePressEvent(QGraphicsSceneMouseEvent *event)
 
 void UBGraphicsCompass::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
+        UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
 		return;
 
     if (!mResizing && !mRotating && !mDrawing)
@@ -249,7 +251,8 @@ void UBGraphicsCompass::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 
 void UBGraphicsCompass::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
+        UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
 		return;
 
     if (mResizing)
@@ -289,7 +292,8 @@ void UBGraphicsCompass::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 
 void UBGraphicsCompass::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
-	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector && 
+        UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
 		return;
 
     mOuterCursor = cursor();
@@ -318,7 +322,8 @@ void UBGraphicsCompass::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 
 void UBGraphicsCompass::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
 {
-	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
+        UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
 		return;
 
     mShowButtons = false;
@@ -331,7 +336,8 @@ void UBGraphicsCompass::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
 
 void UBGraphicsCompass::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 {
-	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+	if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector &&
+        UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
 		return;
 
     mShowButtons = shape().contains(event->pos());

src/tools/UBGraphicsProtractor.cpp

@@ -250,13 +250,19 @@ void UBGraphicsProtractor::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
     if (scene())
         scene()->setModified(true);
 
+    if (!mShowButtons)
+    {
+        mShowButtons = true;
+        update();
+    }
+
     mCurrentTool = None;
 }
 
 
 void UBGraphicsProtractor::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
-    if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector)
+    if (UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Selector && UBDrawingController::drawingController ()->stylusTool() != UBStylusTool::Play)
         return;
 
     if (!mShowButtons)
@@ -292,12 +298,6 @@ void UBGraphicsProtractor::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 
     Tool currentTool = toolFromPos(event->pos());
 
-    if (!mShowButtons)
-    {
-        mShowButtons = true;
-        update();
-    }
-
     if (currentTool == Move)
         setCursor(Qt::SizeAllCursor);
     else

src/tools/UBGraphicsRuler.cpp

@@ -268,7 +268,7 @@ void UBGraphicsRuler::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 {
 	UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
 
-	if (currentTool == UBStylusTool::Selector)
+	if (currentTool == UBStylusTool::Selector || currentTool == UBStylusTool::Play)
 	{
 		mCloseSvgItem->setVisible(mShowButtons);
 		mResizeSvgItem->setVisible(mShowButtons);
@@ -376,7 +376,8 @@ void UBGraphicsRuler::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
 	UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
 
-	if (currentTool == UBStylusTool::Selector)
+	if (currentTool == UBStylusTool::Selector ||
+        currentTool == UBStylusTool::Play)
 	{
 		mCloseSvgItem->setParentItem(this);
 	    mResizeSvgItem->setParentItem(this);

src/tools/UBGraphicsTriangle.cpp

@@ -763,7 +763,9 @@ void UBGraphicsTriangle::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
     UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
 
-    if (currentTool == UBStylusTool::Selector)  {
+    if (currentTool == UBStylusTool::Selector ||
+        currentTool == UBStylusTool::Play)
+    {
         mCloseSvgItem->setParentItem(this);
 
         mShowButtons = true;
@@ -813,7 +815,8 @@ void UBGraphicsTriangle::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 {
     UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController ()->stylusTool ();
 
-    if (currentTool == UBStylusTool::Selector)
+    if (currentTool == UBStylusTool::Selector ||
+        currentTool == UBStylusTool::Play)
     {
         mCloseSvgItem->setVisible(mShowButtons);
         mVFlipSvgItem->setVisible(mShowButtons);