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.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,8 +249,8 @@ bool UBGraphicsDelegateFrame::canResizeBottomRight(qreal width, qreal height, qr
 
 void UBGraphicsDelegateFrame::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (mDelegate->delegated()->data(UBGraphicsItemData::ItemLocked).toBool())
-        return;
+    if (None == mCurrentTool)
+        return; 
 
     QLineF move(mStartingPoint, event->scenePos());
     qreal moveX = move.length() * cos((move.angle() - mAngle) * PI / 180);
@@ -713,8 +713,8 @@ QGraphicsItem* UBGraphicsDelegateFrame::delegated()
 
 UBGraphicsDelegateFrame::FrameTool UBGraphicsDelegateFrame::toolFromPos(QPointF pos)
 {
-        if(mDelegate->isLocked())
-                return None;
+    if(mDelegate->isLocked())
+        return None;
     else if (bottomRightResizeGripRect().contains(pos))
         return ResizeBottomRight;
     else if (bottomResizeGripRect().contains(pos)){

src/domain/UBGraphicsItemDelegate.cpp

@@ -328,9 +328,11 @@ 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();
-        mFrame->show();
+
+        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,7 +129,10 @@ class DelegateMediaControl: public QGraphicsRectItem
         void updateTicker(qint64 time);
         void totalTimeChanged(qint64 newTotalTime);
 
-   protected:
+    signals:
+        void used();
+
+    protected:
         void seekToMousePos(QPointF mousePos);
 
         UBGraphicsMediaItem* mDelegate;

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,27 +44,47 @@ 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);
     else
@@ -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_ */
\ No newline at end of file

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 (group && group->getCurrentItem() == mDelegated && group->isSelected())
-                mToolBarItem->show();
+            if (mToolBarItem->parentItem() && !mToolBarItem->parentItem()->data(UBGraphicsItemData::ItemLocked).toBool())
+            {
+                if (group && group->getCurrentItem() == mDelegated && group->isSelected())
+                    mToolBarItem->show();
 
-            if (!group)
-                 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();
+}
\ No newline at end of file

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);