Merge branch 'master' of github.com:Sankore/Sankore-3.1

Sankore_3.1.pro

@@ -9,7 +9,7 @@ CONFIG += debug_and_release \
 VERSION_MAJ = 1
 VERSION_MIN = 40 
 VERSION_TYPE = b # a = alpha, b = beta, r = release, other => error
-VERSION_PATCH = 00
+VERSION_PATCH = 01
 
 VERSION = "$${VERSION_MAJ}.$${VERSION_MIN}.$${VERSION_TYPE}.$${VERSION_PATCH}"
 VERSION = $$replace(VERSION, "\\.r", "")

resources/library/sankoreInteractivities/ord-phrases.wgt/template/scripts/template2.js

@@ -208,7 +208,7 @@ function modeEdit()
     // if no sankore api, insert ok button
     if( !isSankore )
     {
-        $( "#mp_setup" ).empty().append( '<input type="button" value="OK">' );
+        $( "#mp_setup" ).empty().append( '<input type="button" value="View">' );
         $( "#mp_setup input:button" ).click( function(){
             modeView();
         });

resources/library/sankoreInteractivities/ord-words.wgt/template/scripts/template2.js

@@ -236,7 +236,7 @@ function modeEdit()
     // if no sankore api, insert ok button
     if( !isSankore )
     {
-        $( "#mp_setup" ).empty().append( '<input type="button" value="OK">' );
+        $( "#mp_setup" ).empty().append( '<input type="button" value="View">' );
         $( "#mp_setup input:button" ).click( function(){
             modeView();
         });
@@ -249,9 +249,11 @@ $(window).mouseout(function(){
     if(window.sankore){
         var str = "";
         $( "#mp_word .letter" ).each( function(){
-            str += $(this).text();
+            str += $(this).text() + "*";
         });
         
+        str = str.substr(0, str.length - 1);
+        
         sankore.setPreference("currentOrdWords", str);
         sankore.setPreference("rightOrdWords", word);
     }

src/adaptors/UBCFFSubsetAdaptor.cpp

@@ -999,6 +999,7 @@ void UBCFFSubsetAdaptor::UBCFFSubsetReader::repositionSvgItem(QGraphicsItem *ite
 bool UBCFFSubsetAdaptor::UBCFFSubsetReader::createNewScene()
 {
     mCurrentScene = UBPersistenceManager::persistenceManager()->createDocumentSceneAt(mProxy, mProxy->pageCount());
+    mCurrentScene->setURStackEnable(false);
     mCurrentSceneRect = mCurrentScene->normalizedSceneRect();
     mVBTransFactor = qMin(mCurrentSceneRect.width()  / mViewPort.width(),
                           mCurrentSceneRect.height() / mViewPort.height());
@@ -1035,7 +1036,6 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::persistScenes()
                 UBThumbnailAdaptor::persistScene(mProxy->persistencePath(), tmpScene, i);
                 delete tmpScene;
 
-
         mCurrentScene->setModified(false);
     }
 

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -29,6 +29,7 @@
 #include "domain/UBGraphicsTextItem.h"
 #include "domain/UBAbstractWidget.h"
 #include "domain/UBGraphicsStroke.h"
+#include "domain/UBItem.h"
 
 #include "tools/UBGraphicsRuler.h"
 #include "tools/UBGraphicsCompass.h"
@@ -106,7 +107,8 @@ QMatrix UBSvgSubsetAdaptor::fromSvgTransform(const QString& transform)
 static bool itemZIndexComp(const QGraphicsItem* item1,
                            const QGraphicsItem* item2)
 {
-    return item1->zValue() < item2->zValue();
+//    return item1->zValue() < item2->zValue();
+    return item1->data(UBGraphicsItemData::ItemOwnZValue).toReal() < item2->data(UBGraphicsItemData::ItemOwnZValue).toReal();
 }
 
 
@@ -1337,11 +1339,13 @@ UBGraphicsPolygonItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::polygonItemFromPol
 
     if (!ubZValue.isNull())
     {
-        polygonItem->setZValue(ubZValue.toString().toFloat());
+//        polygonItem->setZValue (ubZValue.toString().toFloat());
+        UBGraphicsItem::assignZValue(polygonItem, ubZValue.toString().toFloat());
     }
     else
     {
-        polygonItem->setZValue(mGroupZIndex);
+//        polygonItem->setZValue(mGroupZIndex);
+        UBGraphicsItem::assignZValue(polygonItem, mGroupZIndex);
     }
 
     QStringRef ubFillOnDarkBackground = mXmlReader.attributes().value(mNamespaceUri, "fill-on-dark-background");
@@ -1444,11 +1448,13 @@ UBGraphicsPolygonItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::polygonItemFromLin
 
     if (!ubZValue.isNull())
     {
-        polygonItem->setZValue(ubZValue.toString().toFloat());
+//        polygonItem->setZValue(ubZValue.toString().toFloat());
+        UBGraphicsItem::assignZValue(polygonItem, ubZValue.toString().toFloat());
     }
     else
     {
-        polygonItem->setZValue(mGroupZIndex);
+//        polygonItem->setZValue(mGroupZIndex);
+        UBGraphicsItem::assignZValue(polygonItem, mGroupZIndex);
     }
 
 
@@ -1587,7 +1593,8 @@ QList<UBGraphicsPolygonItem*> UBSvgSubsetAdaptor::UBSvgSubsetReader::polygonItem
         {
             UBGraphicsPolygonItem* polygonItem = new UBGraphicsPolygonItem(QLineF(points.at(i), points.at(i + 1)), lineWidth);
             polygonItem->setColor(brushColor);
-            polygonItem->setZValue(zValue);
+//            polygonItem->setZValue(zValue);
+            UBGraphicsItem::assignZValue(polygonItem, zValue);
             polygonItem->setColorOnDarkBackground(colorOnDarkBackground);
             polygonItem->setColorOnLightBackground(colorOnLightBackground);
 
@@ -1931,7 +1938,8 @@ void UBSvgSubsetAdaptor::UBSvgSubsetReader::graphicsItemFromSvg(QGraphicsItem* g
 
     if (!ubZValue.isNull())
     {
-        gItem->setZValue(ubZValue.toString().toFloat());
+//        gItem->setZValue(ubZValue.toString().toFloat());
+        UBGraphicsItem::assignZValue(gItem, ubZValue.toString().toFloat());
     }
 
     UBItem* ubItem = dynamic_cast<UBItem*>(gItem);
@@ -2484,7 +2492,8 @@ UBGraphicsRuler* UBSvgSubsetAdaptor::UBSvgSubsetReader::rulerFromSvg()
 
     graphicsItemFromSvg(ruler);
 
-    ruler->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetRuler);
+//    ruler->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetRuler);
+    UBGraphicsItem::assignZValue(ruler, UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetRuler);
     ruler->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     QStringRef svgWidth = mXmlReader.attributes().value("width");
@@ -2542,7 +2551,8 @@ UBGraphicsCompass* UBSvgSubsetAdaptor::UBSvgSubsetReader::compassFromSvg()
 
     graphicsItemFromSvg(compass);
 
-    compass->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetCompass);
+    //compass->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetCompass);
+    UBGraphicsItem::assignZValue(compass, UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetCompass);
     compass->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     QStringRef svgX = mXmlReader.attributes().value("x");
@@ -2606,7 +2616,8 @@ UBGraphicsProtractor* UBSvgSubsetAdaptor::UBSvgSubsetReader::protractorFromSvg()
 {
     UBGraphicsProtractor* protractor = new UBGraphicsProtractor();
 
-    protractor->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetProtractor);
+//    protractor->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetProtractor);
+    UBGraphicsItem::assignZValue(protractor, UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetProtractor);
     protractor->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     graphicsItemFromSvg(protractor);
@@ -2676,7 +2687,8 @@ UBGraphicsTriangle* UBSvgSubsetAdaptor::UBSvgSubsetReader::triangleFromSvg()
 {
     UBGraphicsTriangle* triangle = new UBGraphicsTriangle();
 
-    triangle->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetTriangle);
+//    triangle->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetTriangle);
+    UBGraphicsItem::assignZValue(triangle, UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetTriangle);
     triangle->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     graphicsItemFromSvg(triangle);
@@ -2695,7 +2707,6 @@ UBGraphicsTriangle* UBSvgSubsetAdaptor::UBSvgSubsetReader::triangleFromSvg()
         triangle->setRect(svgX.toString().toFloat(), svgY.toString().toFloat(), svgWidth.toString().toFloat(), svgHeight.toString().toFloat(), orientation);
     }
 
-
     triangle->setVisible(true);
     return triangle;
 }
@@ -2703,7 +2714,8 @@ UBGraphicsTriangle* UBSvgSubsetAdaptor::UBSvgSubsetReader::triangleFromSvg()
 UBGraphicsCache* UBSvgSubsetAdaptor::UBSvgSubsetReader::cacheFromSvg()
 {
     UBGraphicsCache* pCache = new UBGraphicsCache();
-    //pCache->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetCache);
+    pCache->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetCache);
+//    UBGraphicsItem::assignZValue(pCache, UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetCache);
     pCache->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     graphicsItemFromSvg(pCache);

src/board/UBBoardController.cpp

@@ -66,6 +66,7 @@
 #include "UBBoardPaletteManager.h"
 
 #include "core/memcheck.h"
+//#include <typeinfo>
 
 UBBoardController::UBBoardController(UBMainWindow* mainWindow)
     : QObject(mainWindow->centralWidget())
@@ -776,6 +777,12 @@ void UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QString
 {
     QString mimeType = pContentTypeHeader;
 
+    // In some cases "image/jpeg;charset=" is retourned by the drag-n-drop. That is
+    // why we will check if an ; exists and take the first part (the standard allows this kind of mimetype)
+    int position=mimeType.indexOf(";");
+    if(position != -1)
+        mimeType=mimeType.left(position);
+
     if (!pSuccess)
     {
         UBApplication::showMessage(tr("Downloading content %1 failed").arg(sourceUrl.toString()));
@@ -1132,7 +1139,7 @@ void UBBoardController::setActiveDocumentScene(UBDocumentProxy* pDocumentProxy,
         if(sceneChange)
             emit activeSceneWillChange();
 
-        UBApplication::undoStack->clear();
+        ClearUndoStack();
 
         mActiveScene = targetScene;
         mActiveDocument = pDocumentProxy;
@@ -1173,6 +1180,57 @@ void UBBoardController::setActiveDocumentScene(UBDocumentProxy* pDocumentProxy,
     }
 }
 
+void UBBoardController::ClearUndoStack()
+{
+    QSet<QGraphicsItem*> uniqueItems;
+    // go through all stack command
+    int count = UBApplication::undoStack->count();
+    for(int i = 0; i < UBApplication::undoStack->count(); i++)
+    {
+
+        UBAbstractUndoCommand *abstractCmd = (UBAbstractUndoCommand*)UBApplication::undoStack->command(i);
+        if(abstractCmd->getType() != UBAbstractUndoCommand::undotype_GRAPHICITEM)
+            continue;
+
+        UBGraphicsItemUndoCommand *cmd = (UBGraphicsItemUndoCommand*)UBApplication::undoStack->command(i);
+
+        // go through all added and removed objects, for create list of unique objects
+        QSetIterator<QGraphicsItem*> itAdded(cmd->GetAddedList());
+        while (itAdded.hasNext())
+        {
+            QGraphicsItem* item = itAdded.next();
+            if( !uniqueItems.contains(item) )
+                uniqueItems.insert(item);
+        }
+
+        QSetIterator<QGraphicsItem*> itRemoved(cmd->GetRemovedList());
+        while (itRemoved.hasNext())
+        {
+            QGraphicsItem* item = itRemoved.next();
+            if( !uniqueItems.contains(item) )
+                uniqueItems.insert(item);
+        }
+    }
+
+    // clear stack, and command list
+    UBApplication::undoStack->clear();
+    count = UBApplication::undoStack->count();
+
+    // go through all unique items, and check, ot on scene, or not.
+    // if not on scene, than item can be deleted
+
+    QSetIterator<QGraphicsItem*> itUniq(uniqueItems);
+    while (itUniq.hasNext())
+    {
+        QGraphicsItem* item = itUniq.next();
+        UBGraphicsScene *scene = (UBGraphicsScene*)item->scene();
+        if(!scene)
+        {
+            bool retCode = mActiveScene->deleteItem(item);
+        }
+    }
+
+}
 
 void UBBoardController::adjustDisplayViews()
 {
@@ -1842,7 +1900,8 @@ void UBBoardController::processMimeData(const QMimeData* pMimeData, const QPoint
 
                 if (gi)
                 {
-                    gi->setZValue(mActiveScene->getNextObjectZIndex());
+//                    gi->setZValue(mActiveScene->getNextObjectZIndex());
+                    UBGraphicsItem::assignZValue(gi, mActiveScene->getNextObjectZIndex());
                     mActiveScene->addItem(gi);
                     gi->setPos(gi->pos() + QPointF(50, 50));
                 }

src/board/UBBoardController.h

@@ -150,6 +150,9 @@ class UBBoardController : public QObject
         void notifyPageChanged();
         void displayMetaData(QMap<QString, QString> metadatas);
 
+        void ClearUndoStack();
+
+
     public slots:
         void setActiveDocumentScene(UBDocumentProxy* pDocumentProxy, int pSceneIndex = 0);
         void showDocumentsDialog();

src/core/UB.h

@@ -78,6 +78,7 @@ struct UBGraphicsItemData
         ItemLayerType
         , ItemLocked
         , ItemEditable//for text only
+        , ItemOwnZValue
     };
 };
 

src/core/UBApplicationController.cpp

@@ -460,6 +460,7 @@ void UBApplicationController::showTutorial()
         UBApplication::boardController->hide();
     }
 
+    // it's needed not to duplicate webbrowser search in web mode. If I've breaked smbd's code let Ivan know
     UBApplication::webController->show(UBWebController::Tutorial);
 
     mMainWindow->webToolBar->hide();
@@ -488,6 +489,7 @@ void UBApplicationController::showSankoreEditor()
         UBApplication::boardController->hide();
     }
 
+// it's needed not to duplicate webbrowser search in web mode. If I've breaked smbd's code let Ivan know
         UBApplication::webController->show(UBWebController::Paraschool);
 
     mMainWindow->webToolBar->hide();

src/domain/UBAbstractUndoCommand.cpp

@@ -0,0 +1,40 @@
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UBAbstractUndoCommand.h"
+
+UBAbstractUndoCommand::UBAbstractUndoCommand()
+{
+    // NOOP
+}
+
+UBAbstractUndoCommand::~UBAbstractUndoCommand()
+{
+    // NOOP
+}
+
+
+void UBAbstractUndoCommand::undo()
+{
+    // NOOP
+}
+
+void UBAbstractUndoCommand::redo()
+{
+    // NOOP
+}
+
+//void UBAbstractUndoCommand::UndoType getType(UndoType type);
+

src/domain/UBAbstractUndoCommand.h

@@ -0,0 +1,46 @@
+/*
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBABSTRACTUNDOCOMMAND_H_
+#define UBABSTRACTUNDOCOMMAND_H_
+
+#include <QtGui>
+
+class UBAbstractUndoCommand : public QUndoCommand
+{
+    public:
+
+        UBAbstractUndoCommand();
+        ~UBAbstractUndoCommand();
+
+        enum UndoType
+        {
+            undotype_UNKNOWN               = 0,
+            undotype_DOCUMENT              = 1,
+            undotype_GRAPHICITEMTRANSFORM  = 2,
+            undotype_GRAPHICITEM           = 3,
+            undotype_GRAPHICTEXTITEM       = 4,
+            undotype_PAGESIZE              = 5
+        };
+
+        virtual UndoType getType() { return undotype_UNKNOWN; }
+
+    protected:
+        virtual void undo();
+        virtual void redo();
+
+};
+
+#endif /* UBABSTRACTUNDOCOMMAND_H_ */

src/domain/UBDocumentUndoCommand.h

@@ -17,18 +17,20 @@
 #define UBDOCUMENTUNDOCOMMAND_H_
 
 #include <QtGui>
+#include "UBAbstractUndoCommand.h"
 
 class UBDocumentProxy;
 class UBGraphicsScene;
 
-
-class UBDocumentUndoCommand: public QUndoCommand
+class UBDocumentUndoCommand: public UBAbstractUndoCommand
 {
     public:
         UBDocumentUndoCommand(UBDocumentProxy* pDocument, const QList<UBGraphicsScene*>& pOldScenes,
                 const QList<UBGraphicsScene*>& pNewScenes, const int& pActiveSceneIndex);
         virtual ~UBDocumentUndoCommand();
 
+        virtual UndoType getType() { return undotype_DOCUMENT; };
+
     protected:
 
         virtual void undo();

src/domain/UBGraphicsAudioItem.cpp

@@ -95,7 +95,8 @@ UBItem* UBGraphicsAudioItem::deepCopy() const
     UBGraphicsAudioItem *copy = new UBGraphicsAudioItem(audioUrl, parentItem());
 
     copy->setPos(this->pos());
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
     copy->setTransform(this->transform());
     copy->setFlag(QGraphicsItem::ItemIsMovable, true);
     copy->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBGraphicsDelegateFrame.cpp

@@ -531,6 +531,9 @@ void UBGraphicsDelegateFrame::positionHandles()
     {
         setBrush(QBrush(UBSettings::paletteColor));
     }
+
+    //make frame interact like delegated item when selected. Maybe should be deleted if selection logic will change
+    setZValue(delegated()->zValue());
 }
 
 

src/domain/UBGraphicsItemDelegate.cpp

@@ -72,7 +72,8 @@ void UBGraphicsItemDelegate::init()
 {
     mFrame = new UBGraphicsDelegateFrame(this, QRectF(0, 0, 0, 0), mFrameWidth, mRespectRatio);
     mFrame->hide();
-    mFrame->setZValue(UBGraphicsScene::toolLayerStart + 1);
+//    mFrame->setZValue(UBGraphicsScene::toolLayerStart + 1);
+    UBGraphicsItem::assignZValue(mFrame, UBGraphicsScene::toolLayerStart + 1);
     mFrame->setFlag(QGraphicsItem::ItemIsSelectable, true);
 
     mDeleteButton = new DelegateButton(":/images/close.svg", mDelegated, mFrame);
@@ -92,7 +93,8 @@ void UBGraphicsItemDelegate::init()
     foreach(DelegateButton* button, mButtons)
     {
         button->hide();
-        button->setZValue(UBGraphicsScene::toolLayerStart + 2);
+//        button->setZValue(UBGraphicsScene::toolLayerStart + 2);
+        UBGraphicsItem::assignZValue(button, UBGraphicsScene::toolLayerStart + 2);
         button->setFlag(QGraphicsItem::ItemIsSelectable, true);
     }
 }
@@ -282,8 +284,8 @@ void UBGraphicsItemDelegate::positionHandles()
 
 void UBGraphicsItemDelegate::remove(bool canUndo)
 {
-    QGraphicsScene* scene = mDelegated->scene();
-
+//    QGraphicsScene* scene = mDelegated->scene();
+    UBGraphicsScene* scene = (UBGraphicsScene*)(mDelegated->scene());
     if (scene)
     {
         foreach(DelegateButton* button, mButtons)
@@ -321,12 +323,10 @@ void UBGraphicsItemDelegate::lock(bool locked)
     if (locked)
     {
         mDelegated->setData(UBGraphicsItemData::ItemLocked, QVariant(true));
-        qDebug() << "item's data is called for locked"  << mDelegated->data(UBGraphicsItemData::ItemLocked);
     }
     else
     {
         mDelegated->setData(UBGraphicsItemData::ItemLocked, QVariant(false));
-        qDebug() << "item's data is called for unlocked"  << mDelegated->data(UBGraphicsItemData::ItemLocked);
     }
 
     mDelegated->update();

src/domain/UBGraphicsItemTransformUndoCommand.cpp

@@ -15,6 +15,7 @@
 
 #include "UBGraphicsItemTransformUndoCommand.h"
 #include "UBResizableGraphicsItem.h"
+#include "domain/UBItem.h"
 
 #include "core/memcheck.h"
 
@@ -49,6 +50,7 @@ void UBGraphicsItemTransformUndoCommand::undo()
     mItem->setPos(mPreviousPosition);
     mItem->setTransform(mPreviousTransform);
     mItem->setZValue(mPreviousZValue);
+//    UBGraphicsItem::assignZValue(mItem, mPreviousZValue);
 
     UBResizableGraphicsItem* resizableItem = dynamic_cast<UBResizableGraphicsItem*>(mItem);
 
@@ -62,6 +64,8 @@ void UBGraphicsItemTransformUndoCommand::redo()
     mItem->setTransform(mCurrentTransform);
     mItem->setZValue(mCurrentZValue);
 
+//    UBGraphicsItem::assignZValue(mItem, /*mCurrentZValue*/mItem->data(UBGraphicsItemData::ItemOwnZValue).toReal());
+
     UBResizableGraphicsItem* resizableItem = dynamic_cast<UBResizableGraphicsItem*>(mItem);
 
     if (resizableItem)

src/domain/UBGraphicsItemTransformUndoCommand.h

@@ -19,9 +19,10 @@
 #include <QtGui>
 
 #include "UBResizableGraphicsItem.h"
+#include "UBAbstractUndoCommand.h"
 
 
-class UBGraphicsItemTransformUndoCommand : public QUndoCommand
+class UBGraphicsItemTransformUndoCommand : public UBAbstractUndoCommand
 {
     public:
         UBGraphicsItemTransformUndoCommand(QGraphicsItem* pItem,
@@ -31,6 +32,8 @@ class UBGraphicsItemTransformUndoCommand : public QUndoCommand
                                                 const QSizeF& prevSize = QSizeF());
         virtual ~UBGraphicsItemTransformUndoCommand();
 
+        virtual UndoType getType() { return undotype_GRAPHICITEMTRANSFORM; };
+
     protected:
         virtual void undo();
         virtual void redo();

src/domain/UBGraphicsItemUndoCommand.h

@@ -17,11 +17,13 @@
 #define UBGRAPHICSITEMUNDOCOMMAND_H_
 
 #include <QtGui>
+#include "UBAbstractUndoCommand.h"
+
 
 class UBGraphicsScene;
 
 
-class UBGraphicsItemUndoCommand : public QUndoCommand
+class UBGraphicsItemUndoCommand : public UBAbstractUndoCommand
 {
     public:
         UBGraphicsItemUndoCommand(UBGraphicsScene* pScene, const QSet<QGraphicsItem*>& pRemovedItems,
@@ -32,6 +34,11 @@ class UBGraphicsItemUndoCommand : public QUndoCommand
 
         virtual ~UBGraphicsItemUndoCommand();
 
+        QSet<QGraphicsItem*> GetAddedList() { return mAddedItems; };
+        QSet<QGraphicsItem*> GetRemovedList() { return mRemovedItems; };
+
+        virtual UndoType getType() { return undotype_GRAPHICITEM; };
+
     protected:
         virtual void undo();
         virtual void redo();

src/domain/UBGraphicsPDFItem.cpp

@@ -84,7 +84,8 @@ UBItem* UBGraphicsPDFItem::deepCopy() const
     UBGraphicsPDFItem *copy =  new UBGraphicsPDFItem(mRenderer, mPageNumber, parentItem());
 
     copy->setPos(this->pos());
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
     copy->setTransform(this->transform());
     copy->setFlag(QGraphicsItem::ItemIsMovable, true);
     copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
@@ -134,7 +135,8 @@ UBGraphicsPixmapItem* UBGraphicsPDFItem::toPixmapItem() const
     pixmapItem->setPixmap(pixmap);
 
     pixmapItem->setPos(this->pos());
-    pixmapItem->setZValue(this->zValue());
+//    pixmapItem->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(pixmapItem, this->zValue());
     pixmapItem->setTransform(this->transform());
     pixmapItem->setFlag(QGraphicsItem::ItemIsMovable, true);
     pixmapItem->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBGraphicsPixmapItem.cpp

@@ -98,7 +98,8 @@ UBItem* UBGraphicsPixmapItem::deepCopy() const
 
    copy->setPixmap(this->pixmap());
    copy->setPos(this->pos());
-   copy->setZValue(this->zValue());
+//   copy->setZValue(this->zValue());
+   UBGraphicsItem::assignZValue(copy, this->zValue());
    copy->setTransform(this->transform());
    copy->setFlag(QGraphicsItem::ItemIsMovable, true);
    copy->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBGraphicsPolygonItem.cpp

@@ -153,7 +153,9 @@ UBGraphicsPolygonItem* UBGraphicsPolygonItem::deepCopy(const QPolygonF& pol) con
     copy->setPen(this->pen());
     copy->mHasAlpha = this->mHasAlpha;
 
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
+
 
     copy->setColorOnDarkBackground(this->colorOnDarkBackground());
     copy->setColorOnLightBackground(this->colorOnLightBackground());

src/domain/UBGraphicsScene.cpp

@@ -75,6 +75,8 @@ qreal UBGraphicsScene::toolOffsetEraser = 200;
 qreal UBGraphicsScene::toolOffsetCurtain = 1000;
 qreal UBGraphicsScene::toolOffsetPointer = 1100;
 
+qreal UBGraphicsScene::toolOffsetCache = 1000;//Didier please define offset you want
+
 UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
     : UBCoreGraphicsScene(parent)
     , mEraser(0)
@@ -91,8 +93,10 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
     , mCurrentStroke(0)
     , mShouldUseOMP(true)
     , mItemCount(0)
+    , enableUndoRedoStack(true)
     , magniferControlViewWidget(0)
     , magniferDisplayViewWidget(0)
+
 {
 
 #ifdef __ppc__
@@ -137,6 +141,8 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
     }
 
     connect(this, SIGNAL(selectionChanged()), this, SLOT(selectionChangedProcessing()));
+
+
 }
 
 UBGraphicsScene::~UBGraphicsScene()
@@ -150,32 +156,28 @@ UBGraphicsScene::~UBGraphicsScene()
 
 void UBGraphicsScene::selectionChangedProcessing()
 {
-
-//    if (selectedItems().count())
-//        UBApplication::showMessage("ZValue is " + QString::number(selectedItems().first()->zValue(), 'f'));
+    if (selectedItems().count())
+        UBApplication::showMessage("ZValue is " + QString::number(selectedItems().first()->zValue(), 'f'));
 
 
     QList<QGraphicsItem *> allItemsList = items();
-    for( int i = 0; i < allItemsList.size(); i++ )
-    {
+    qreal maxZ = 0.;
+    for( int i = 0; i < allItemsList.size(); i++ ) {
         QGraphicsItem *nextItem = allItemsList.at(i);
         //Temporary stub. Due to ugly z-order implementation I need to do this (sankore 360)
         //z-order behavior should be reimplemented and this stub should be deleted
         if (nextItem == mBackgroundObject)
             continue;
         //Temporary stub end (sankore 360)
-//        qreal zValue = nextItem->zValue();
-        nextItem->setZValue(qreal(1));
-//        qDebug() << QString(" %1 ").arg(i) << QString(" %1 ").arg(zValue);
+        if (nextItem->zValue() > maxZ)
+            maxZ = nextItem->zValue();
+        nextItem->setZValue(nextItem->data(UBGraphicsItemData::ItemOwnZValue).toReal());
+//        nextItem->setZValue(qreal(1));
     }
-
     QList<QGraphicsItem *> selItemsList = selectedItems();
-    for( int i = 0; i < selItemsList.size(); i++ )
-    {
+    for( int i = 0; i < selItemsList.size(); i++ ) {
         QGraphicsItem *nextItem = selItemsList.at(i);
-//        qreal zValue = nextItem->zValue();
-        nextItem->setZValue(2);
-//        qDebug() << QString(" >>> %1 <<< ").arg(i) << QString(" >>> %1 <<< ").arg(zValue);
+        nextItem->setZValue(maxZ + 0.0001);
     }
 }
 
@@ -373,10 +375,13 @@ bool UBGraphicsScene::inputDeviceRelease()
    
     if (mRemovedItems.size() > 0 || mAddedItems.size() > 0)
     {
+
+        if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
             UBGraphicsItemUndoCommand* udcmd = new UBGraphicsItemUndoCommand(this, mRemovedItems, mAddedItems); //deleted by the undoStack
 
             if(UBApplication::undoStack)
                 UBApplication::undoStack->push(udcmd);
+        }
 
         mRemovedItems.clear();
         mAddedItems.clear();
@@ -407,23 +412,23 @@ void UBGraphicsScene::drawEraser(const QPointF &pPoint, bool isFirstDraw)
 
         if(isFirstDraw)
         {
+            qreal maxZ = 0.;
             QList<QGraphicsItem *> allItemsList = items();
             for( int i = 0; i < allItemsList.size(); i++ )
             {
                 QGraphicsItem *nextItem = allItemsList.at(i);
                 qreal zValue = nextItem->zValue();
-                nextItem->setZValue(qreal(1));
-                qDebug() << QString(" %1 ").arg(i) << QString(" %1 ").arg(zValue);
+                if (zValue > maxZ)
+                    maxZ = zValue;
+                nextItem->setZValue(nextItem->data(UBGraphicsItemData::ItemOwnZValue).toReal());
             }
 
-            mEraser->setZValue(2);
+            mEraser->setZValue(maxZ + 0.0001);
             mEraser->show();
         }
-
     }
 }
 
-
 void UBGraphicsScene::drawPointer(const QPointF &pPoint, bool isFirstDraw)
 {
     qreal pointerDiameter = UBSettings::pointerDiameter / UBApplication::boardController->currentZoom();
@@ -439,19 +444,20 @@ void UBGraphicsScene::drawPointer(const QPointF &pPoint, bool isFirstDraw)
 
         if(isFirstDraw)
         {
+            qreal maxZ = 0.;
             QList<QGraphicsItem *> allItemsList = items();
             for( int i = 0; i < allItemsList.size(); i++ )
             {
                 QGraphicsItem *nextItem = allItemsList.at(i);
                 qreal zValue = nextItem->zValue();
-                nextItem->setZValue(qreal(1));
-                qDebug() << QString(" %1 ").arg(i) << QString(" %1 ").arg(zValue);
+                if (zValue > maxZ)
+                    maxZ = zValue;
+                nextItem->setZValue(nextItem->data(UBGraphicsItemData::ItemOwnZValue).toReal());
             }
 
-            mPointer->setZValue(2);
+            mPointer->setZValue(maxZ + 0.0001);
             mPointer->show();
         }
-
     }
 }
 
@@ -824,8 +830,8 @@ void UBGraphicsScene::initPolygonItem(UBGraphicsPolygonItem* polygonItem)
 
     polygonItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Graphic));
 
-    polygonItem->setZValue(getNextDrawingZIndex());
-
+//    polygonItem->setZValue(getNextDrawingZIndex());
+    UBGraphicsItem::assignZValue(polygonItem, getNextDrawingZIndex());
 }
 
 
@@ -962,8 +968,11 @@ void UBGraphicsScene::clearItemsAndAnnotations()
     // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
     update(sceneRect());
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
         UBApplication::undoStack->push(uc);
+    }
+
     setDocumentUpdated();
 }
 
@@ -996,8 +1005,12 @@ void UBGraphicsScene::clearItems()
     // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
     update(sceneRect());
 
+
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
         UBApplication::undoStack->push(uc);
+    }
+
     setDocumentUpdated();
 }
 
@@ -1023,8 +1036,12 @@ void UBGraphicsScene::clearAnnotations()
     // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
     update(sceneRect());
 
+
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
         UBApplication::undoStack->push(uc);
+    }
+
     setDocumentUpdated();
 }
 
@@ -1035,7 +1052,8 @@ UBGraphicsPixmapItem* UBGraphicsScene::addPixmap(const QPixmap& pPixmap, const Q
 
     pixmapItem->setFlag(QGraphicsItem::ItemIsMovable, true);
     pixmapItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    pixmapItem->setZValue(getNextObjectZIndex());
+//    pixmapItem->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(pixmapItem, getNextObjectZIndex());
 
     pixmapItem->setPixmap(pPixmap);
 
@@ -1044,8 +1062,10 @@ UBGraphicsPixmapItem* UBGraphicsScene::addPixmap(const QPixmap& pPixmap, const Q
 
     addItem(pixmapItem);
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, pixmapItem);
         UBApplication::undoStack->push(uc);
+    }
 
     pixmapItem->scale(pScaleFactor, pScaleFactor);
 
@@ -1070,9 +1090,11 @@ UBGraphicsPixmapItem* UBGraphicsScene::addPixmap(const QPixmap& pPixmap, const Q
 
 void UBGraphicsScene::textUndoCommandAdded(UBGraphicsTextItem *textItem)
 {
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsTextItemUndoCommand* uc = new UBGraphicsTextItemUndoCommand(textItem);
         UBApplication::undoStack->push(uc);
     }
+}
 
 
 UBGraphicsVideoItem* UBGraphicsScene::addVideo(const QUrl& pVideoFileUrl, bool shouldPlayAsap, const QPointF& pPos)
@@ -1083,14 +1105,17 @@ UBGraphicsVideoItem* UBGraphicsScene::addVideo(const QUrl& pVideoFileUrl, bool s
 
     videoItem->setFlag(QGraphicsItem::ItemIsMovable, true);
     videoItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    videoItem->setZValue(getNextObjectZIndex());
+//    videoItem->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(videoItem, getNextObjectZIndex());
 
     addItem(videoItem);
 
     videoItem->show();
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, videoItem);
         UBApplication::undoStack->push(uc);
+    }
 
     videoItem->mediaObject()->play();
 
@@ -1113,14 +1138,17 @@ UBGraphicsAudioItem* UBGraphicsScene::addAudio(const QUrl& pAudioFileUrl, bool s
 
     audioItem->setFlag(QGraphicsItem::ItemIsMovable, true);
     audioItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    audioItem->setZValue(getNextObjectZIndex());
+//    audioItem->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(audioItem, getNextObjectZIndex());
 
     addItem(audioItem);
 
     audioItem->show();
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, audioItem);
         UBApplication::undoStack->push(uc);
+    }
 
     audioItem->mediaObject()->play();
 
@@ -1178,7 +1206,8 @@ UBGraphicsW3CWidgetItem* UBGraphicsScene::addW3CWidget(const QUrl& pWidgetUrl, c
 void UBGraphicsScene::addGraphicsWidget(UBGraphicsWidgetItem* graphicsWidget, const QPointF& pPos)
 {
     graphicsWidget->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    graphicsWidget->setZValue(getNextObjectZIndex());
+//    graphicsWidget->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(graphicsWidget, getNextObjectZIndex());
 
     addItem(graphicsWidget);
 
@@ -1194,8 +1223,10 @@ void UBGraphicsScene::addGraphicsWidget(UBGraphicsWidgetItem* graphicsWidget, co
 //        graphicsWidget->widgetWebView()->loadMainHtml();
 
         graphicsWidget->setSelected(true);
+        if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
             UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, graphicsWidget);
             UBApplication::undoStack->push(uc);
+        }
 
         setDocumentUpdated();
     }
@@ -1238,7 +1269,8 @@ UBGraphicsSvgItem* UBGraphicsScene::addSvg(const QUrl& pSvgFileUrl, const QPoint
 
     svgItem->setFlag(QGraphicsItem::ItemIsMovable, true);
     svgItem->setFlag(QGraphicsItem::ItemIsSelectable, true);
-    svgItem->setZValue(getNextObjectZIndex());
+//    svgItem->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(svgItem, getNextObjectZIndex());
 
     qreal sscale = 1 / UBApplication::boardController->systemScaleFactor();
     svgItem->scale(sscale, sscale);
@@ -1249,8 +1281,10 @@ UBGraphicsSvgItem* UBGraphicsScene::addSvg(const QUrl& pSvgFileUrl, const QPoint
 
     addItem(svgItem);
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, svgItem);
         UBApplication::undoStack->push(uc);
+    }
 
     setDocumentUpdated();
 
@@ -1271,7 +1305,8 @@ UBGraphicsTextItem* UBGraphicsScene::addTextWithFont(const QString& pString, con
 {
     UBGraphicsTextItem *textItem = new UBGraphicsTextItem();
     textItem->setPlainText(pString);
-    textItem->setZValue(getNextObjectZIndex());
+//    textItem->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(textItem, getNextObjectZIndex());
 
     QFont font = textItem->font();
 
@@ -1309,8 +1344,10 @@ UBGraphicsTextItem* UBGraphicsScene::addTextWithFont(const QString& pString, con
 
     textItem->show();
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, textItem);
         UBApplication::undoStack->push(uc);
+    }
 
     connect(textItem, SIGNAL(textUndoCommandAdded(UBGraphicsTextItem *)), this, SLOT(textUndoCommandAdded(UBGraphicsTextItem *)));
 
@@ -1326,18 +1363,20 @@ UBGraphicsTextItem *UBGraphicsScene::addTextHtml(const QString &pString, const Q
     UBGraphicsTextItem *textItem = new UBGraphicsTextItem();
     textItem->setPlainText("");
     textItem->setHtml(pString);
-    textItem->setZValue(getNextObjectZIndex());
+//    textItem->setZValue(getNextObjectZIndex());
+    UBGraphicsItem::assignZValue(textItem, getNextObjectZIndex());
 
     addItem(textItem);
     textItem->show();
 
+    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
         UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, 0, textItem);
         UBApplication::undoStack->push(uc);
+    }
 
     connect(textItem, SIGNAL(textUndoCommandAdded(UBGraphicsTextItem *)),
             this,     SLOT(textUndoCommandAdded(UBGraphicsTextItem *)));
 
-//    textItem->setSelected(true);
     textItem->setFocus();
 
     setDocumentUpdated();
@@ -1425,7 +1464,8 @@ QGraphicsItem* UBGraphicsScene::setAsBackgroundObject(QGraphicsItem* item, bool
         item->setAcceptedMouseButtons(Qt::NoButton);
         item->setData(UBGraphicsItemData::ItemLayerType, UBItemLayerType::FixedBackground);
 
-        item->setZValue(backgroundLayerStart);
+//        item->setZValue(backgroundLayerStart);
+        UBGraphicsItem::assignZValue(item, backgroundLayerStart);
 
         if (pAdaptTransformation)
         {
@@ -1529,7 +1569,9 @@ void UBGraphicsScene::addRuler(QPointF center)
     QRectF rect = ruler->rect();
     ruler->setRect(center.x() - rect.width()/2, center.y() - rect.height()/2, rect.width(), rect.height());
 
-    ruler->setZValue(toolLayerStart + toolOffsetRuler);
+//    ruler->setZValue(toolLayerStart + toolOffsetRuler);
+    UBGraphicsItem::assignZValue(ruler, toolLayerStart + toolOffsetRuler);
+
     ruler->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     addItem(ruler);
@@ -1546,7 +1588,9 @@ void UBGraphicsScene::addProtractor(QPointF center)
     UBGraphicsProtractor* protractor = new UBGraphicsProtractor(); // mem : owned and destroyed by the scene
     mTools << protractor;
 
-    protractor->setZValue(toolLayerStart + toolOffsetProtractor);
+//    protractor->setZValue(toolLayerStart + toolOffsetProtractor);
+    UBGraphicsItem::assignZValue(protractor, toolLayerStart + toolOffsetProtractor);
+
     protractor->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     addItem(protractor);
@@ -1565,7 +1609,9 @@ void UBGraphicsScene::addTriangle(QPointF center)
     UBGraphicsTriangle* triangle = new UBGraphicsTriangle(); // mem : owned and destroyed by the scene
     mTools << triangle;
 
-    triangle->setZValue(toolLayerStart + toolOffsetProtractor);
+//    triangle->setZValue(toolLayerStart + toolOffsetProtractor);
+    UBGraphicsItem::assignZValue(triangle, toolLayerStart + toolOffsetTriangle);
+
     triangle->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     addItem(triangle);
@@ -1696,7 +1742,9 @@ void UBGraphicsScene::addCompass(QPointF center)
     QRectF rect = compass->rect();
     compass->setRect(center.x() - rect.width() / 2, center.y() - rect.height() / 2, rect.width(), rect.height());
 
-    compass->setZValue(toolLayerStart + toolOffsetCompass);
+//    compass->setZValue(toolLayerStart + toolOffsetCompass);
+    UBGraphicsItem::assignZValue(compass, toolLayerStart + toolOffsetCompass);
+
     compass->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
 
     compass->setVisible(true);
@@ -1727,7 +1775,10 @@ void UBGraphicsScene::addMask()
         view = (QGraphicsView*)UBApplication::boardController->controlView();
 
     QPolygonF polygon = view->mapToScene(view->rect());
-    curtain->setZValue(toolLayerStart + toolOffsetCurtain);
+
+//    curtain->setZValue(toolLayerStart + toolOffsetCurtain);
+    UBGraphicsItem::assignZValue(curtain, toolLayerStart + toolOffsetCurtain);
+
     QRectF rect = polygon.boundingRect();
     qreal xScale = view->matrix().m11();
     qreal yScale = view->matrix().m22();

src/domain/UBGraphicsScene.h

@@ -55,6 +55,8 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
     Q_OBJECT
 
     public:
+    //        tmp stub for divide addings scene objects from undo mechanism implementation
+    void setURStackEnable(bool set = true) {enableUndoRedoStack = set;}
 
         UBGraphicsScene(UBDocumentProxy *parent);
         virtual ~UBGraphicsScene();
@@ -363,8 +365,13 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
         //int mMesure1Ms, mMesure2Ms;
 
         bool mHasCache;
+        //        tmp stub for divide addings scene objects from undo mechanism implementation
+        bool enableUndoRedoStack;
+
         UBMagnifier *magniferControlViewWidget;
         UBMagnifier *magniferDisplayViewWidget;
+
+
 };
 
 #endif /* UBGRAPHICSSCENE_H_ */

src/domain/UBGraphicsSvgItem.cpp

@@ -132,7 +132,8 @@ UBItem* UBGraphicsSvgItem::deepCopy() const
     UBGraphicsSvgItem* copy = new UBGraphicsSvgItem(this->fileData());
 
     copy->setPos(this->pos());
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
     copy->setTransform(this->transform());
     copy->setFlag(QGraphicsItem::ItemIsMovable, true);
     copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
@@ -186,7 +187,8 @@ UBGraphicsPixmapItem* UBGraphicsSvgItem::toPixmapItem() const
     pixmapItem->setPixmap(QPixmap::fromImage(image));
 
     pixmapItem->setPos(this->pos());
-    pixmapItem->setZValue(this->zValue());
+//    pixmapItem->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(pixmapItem, this->zValue());
     pixmapItem->setTransform(this->transform());
     pixmapItem->setFlag(QGraphicsItem::ItemIsMovable, true);
     pixmapItem->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBGraphicsTextItem.cpp

@@ -205,7 +205,8 @@ UBItem* UBGraphicsTextItem::deepCopy() const
 
     copy->setHtml(toHtml());
     copy->setPos(this->pos());
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
     copy->setTransform(this->transform());
     copy->setFlag(QGraphicsItem::ItemIsMovable, true);
     copy->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBGraphicsTextItemUndoCommand.h

@@ -17,16 +17,19 @@
 #define UBGRAPHICSTEXTITEMUNDOCOMMAND_H_
 
 #include <QtGui>
+#include "UBAbstractUndoCommand.h"
 
 #include "UBGraphicsTextItem.h"
 
 
-class UBGraphicsTextItemUndoCommand: public QUndoCommand
+class UBGraphicsTextItemUndoCommand : public UBAbstractUndoCommand
 {
     public:
         UBGraphicsTextItemUndoCommand(UBGraphicsTextItem *textItem);
         virtual ~UBGraphicsTextItemUndoCommand();
 
+        virtual UndoType getType() { return undotype_GRAPHICTEXTITEM; };
+
     protected:
         virtual void undo();
         virtual void redo();

src/domain/UBGraphicsVideoItem.cpp

@@ -68,7 +68,8 @@ UBItem* UBGraphicsVideoItem::deepCopy() const
     UBGraphicsVideoItem *copy = new UBGraphicsVideoItem(videoUrl, parentItem());
 
     copy->setPos(this->pos());
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
     copy->setTransform(this->transform());
     copy->setFlag(QGraphicsItem::ItemIsMovable, true);
     copy->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBGraphicsVideoItemDelegate.cpp

@@ -52,7 +52,8 @@ void UBGraphicsVideoItemDelegate::buildButtons()
     mMuteButton->hide();
 
     mVideoControl = new DelegateVideoControl(delegated(), mFrame);
-    mVideoControl->setZValue(UBGraphicsScene::toolLayerStart + 2);
+//    mVideoControl->setZValue(UBGraphicsScene::toolLayerStart + 2);
+    UBGraphicsItem::assignZValue(mVideoControl, UBGraphicsScene::toolLayerStart + 2);
     mVideoControl->setFlag(QGraphicsItem::ItemIsSelectable, true);
 
     connect(mPlayPauseButton, SIGNAL(clicked(bool)), this, SLOT(togglePlayPause()));

src/domain/UBGraphicsWidgetItem.cpp

@@ -366,7 +366,8 @@ UBItem* UBGraphicsW3CWidgetItem::deepCopy() const
     UBGraphicsW3CWidgetItem *copy = new UBGraphicsW3CWidgetItem(mWebKitWidget->widgetUrl(), parentItem());
 
     copy->setPos(this->pos());
-    copy->setZValue(this->zValue());
+//    copy->setZValue(this->zValue());
+    UBGraphicsItem::assignZValue(copy, this->zValue());
     copy->setTransform(this->transform());
     copy->setFlag(QGraphicsItem::ItemIsMovable, true);
     copy->setFlag(QGraphicsItem::ItemIsSelectable, true);

src/domain/UBItem.cpp

@@ -28,3 +28,9 @@ UBItem::~UBItem()
 {
     // NOOP
 }
+
+void UBGraphicsItem::assignZValue(QGraphicsItem *item, int value)
+{
+    item->setZValue(value);
+    item->setData(UBGraphicsItemData::ItemOwnZValue, value);
+}

src/domain/UBItem.h

@@ -100,6 +100,7 @@ protected:
 
 public:
 
+    static void assignZValue(QGraphicsItem*, int value);
     virtual UBGraphicsItemDelegate *Delegate() const  = 0;
 
     virtual void remove() = 0;

src/domain/UBPageSizeUndoCommand.h

@@ -17,16 +17,19 @@
 #define UBPageSizeUndoCommand_H_
 
 #include <QtGui>
+#include "UBAbstractUndoCommand.h"
 
 class UBGraphicsScene;
 
 
-class UBPageSizeUndoCommand : public QUndoCommand
+class UBPageSizeUndoCommand : public UBAbstractUndoCommand
 {
     public:
         UBPageSizeUndoCommand(UBGraphicsScene* pScene, const QSize& previousSize, const QSize& newSize);
         virtual ~UBPageSizeUndoCommand();
 
+        virtual UndoType getType() { return undotype_PAGESIZE; };
+
     protected:
         virtual void undo();
         virtual void redo();

src/domain/domain.pri

@@ -21,7 +21,8 @@ HEADERS      += src/domain/UBGraphicsScene.h \
                 src/domain/UBGraphicsStroke.h \
     src/domain/UBGraphicsMediaItem.h \
     src/domain/UBGraphicsAudioItem.h \
-    src/domain/UBGraphicsAudioItemDelegate.h
+    src/domain/UBGraphicsAudioItemDelegate.h \
+    src/domain/UBAbstractUndoCommand.h
                 
 HEADERS      += src/domain/UBGraphicsItemDelegate.h \
 				src/domain/UBGraphicsVideoItemDelegate.h \
@@ -52,7 +53,8 @@ SOURCES      += src/domain/UBGraphicsScene.cpp \
                 src/domain/UBGraphicsStroke.cpp \
     src/domain/UBGraphicsMediaItem.cpp \
     src/domain/UBGraphicsAudioItem.cpp \
-    src/domain/UBGraphicsAudioItemDelegate.cpp
+    src/domain/UBGraphicsAudioItemDelegate.cpp \
+    src/domain/UBAbstractUndoCommand.cpp
                 
 SOURCES      += src/domain/UBGraphicsItemDelegate.cpp \
 				src/domain/UBGraphicsVideoItemDelegate.cpp \

src/frameworks/UBCoreGraphicsScene.cpp

@@ -53,3 +53,16 @@ void UBCoreGraphicsScene::removeItem(QGraphicsItem* item, bool forceDelete)
         delete item;
     }
 }
+
+bool UBCoreGraphicsScene::deleteItem(QGraphicsItem* item)
+{
+    if(mItemsToDelete.contains(item))
+    {
+        mItemsToDelete.remove(item);
+        delete item;
+        return true;
+    }
+    else
+        return false;
+}
+

src/frameworks/UBCoreGraphicsScene.h

@@ -28,6 +28,9 @@ class UBCoreGraphicsScene : public QGraphicsScene
 
         virtual void removeItem(QGraphicsItem* item, bool forceDelete = false);
 
+        virtual bool deleteItem(QGraphicsItem* item);
+
+
     private:
         QSet<QGraphicsItem*> mItemsToDelete;
 };

src/gui/UBDocumentNavigator.cpp

@@ -159,6 +159,7 @@ void UBDocumentNavigator::updateSpecificThumbnail(int iPage)
                 mScene->removeItem(pItem);
                 mScene->addItem(pixmapItem);
                 mThumbnails.replace(iPage, pixmapItem);
+                delete pItem;
             }
         }
     }

src/gui/UBDocumentTreeWidget.cpp

@@ -25,6 +25,10 @@
 #include "core/UBDocumentManager.h"
 #include "document/UBDocumentController.h"
 
+#include "adaptors/UBThumbnailAdaptor.h"
+#include "adaptors/UBSvgSubsetAdaptor.h"
+#include "frameworks/UBFileSystemUtils.h"
+
 #include "core/memcheck.h"
 
 UBDocumentTreeWidget::UBDocumentTreeWidget(QWidget * parent)
@@ -290,6 +294,13 @@ void UBDocumentTreeWidget::dropEvent(QDropEvent *event)
                             }
 
                             UBPersistenceManager::persistenceManager()->insertDocumentSceneAt(targetDocProxy, sceneClone, targetDocProxy->pageCount());
+
+                            //due to incorrect generation of thumbnails of invisible scene I've used direct copying of thumbnail files
+                            //it's not universal and good way but it's faster
+                            QString from = sourceItem.documentProxy()->persistencePath() + UBFileSystemUtils::digitFileFormat("/page%1.thumbnail.jpg", sourceItem.sceneIndex() + 1);
+                            QString to  = targetDocProxy->persistencePath() + UBFileSystemUtils::digitFileFormat("/page%1.thumbnail.jpg", targetDocProxy->pageCount());
+                            QFile::remove(to);
+                            QFile::copy(from, to);
                           }
                     }
 

src/gui/UBDocumentTreeWidget.h

@@ -23,7 +23,7 @@ class UBDocumentProxyTreeItem;
 
 class UBDocumentTreeWidget : public QTreeWidget
 {
-    Q_OBJECT;
+    Q_OBJECT
 
     public:
         UBDocumentTreeWidget(QWidget *parent = 0);

src/gui/UBTeacherBarWidget.cpp

@@ -62,6 +62,7 @@ UBTeacherBarWidget::UBTeacherBarWidget(QWidget *parent, const char *name):UBDock
     mpTitleLabel->setAlignment(Qt::AlignRight);
     mpTitle = new QLineEdit(mpContainer);
     mpTitle->setObjectName("DockPaletteWidgetLineEdit");
+	connect(mpTitle, SIGNAL(textChanged(const QString&)), this, SLOT(onTitleTextChanged(const QString&)));
     mpTitleLayout = new QHBoxLayout();
     mpTitleLayout->addWidget(mpTitleLabel, 0);
     mpTitleLayout->addWidget(mpTitle, 1);
@@ -95,6 +96,7 @@ UBTeacherBarWidget::UBTeacherBarWidget(QWidget *parent, const char *name):UBDock
     mpEquipmentLabel->setAlignment(Qt::AlignRight);
     mpEquipment = new QLineEdit(mpContainer);
     mpEquipment->setObjectName("DockPaletteWidgetLineEdit");
+	connect(mpEquipment, SIGNAL(textChanged(const QString&)), this, SLOT(onEquipmentTextChanged(const QString&)));
     mpEquipmentLayout = new QHBoxLayout();
     mpEquipmentLayout->addWidget(mpEquipmentLabel, 0);
     mpEquipmentLayout->addWidget(mpEquipment, 1);
@@ -319,6 +321,16 @@ void UBTeacherBarWidget::loadContent()
     mpAction3->setStudentText(nextInfos.action3Student);
 }
 
+void UBTeacherBarWidget::onTitleTextChanged(const QString& text)
+{
+	mpTitle->setToolTip(text);
+}
+
+void UBTeacherBarWidget::onEquipmentTextChanged(const QString& text)
+{
+	mpEquipment->setToolTip(text);
+}
+
 UBTeacherStudentAction::UBTeacherStudentAction(int actionNumber, QWidget *parent, const char *name):QWidget(parent)
     , mpActionLabel(NULL)
     , mpTeacherLabel(NULL)