Sankore 1107 Crashes fixed Undo command left

src/api/UBWidgetUniboardAPI.cpp

@@ -250,7 +250,7 @@ void UBWidgetUniboardAPI::eraseLineTo(const qreal x, const qreal y, const qreal
 void UBWidgetUniboardAPI::clear()
 {
     if (mScene)
-            mScene->clearItemsAndAnnotations();
+            mScene->clearContent(UBGraphicsScene::clearItemsAndAnnotations);
 }
 
 

src/board/UBBoardController.cpp

@@ -683,7 +683,7 @@ void UBBoardController::clearScene()
     if (mActiveScene)
     {
         freezeW3CWidgets(true);
-        mActiveScene->clearItemsAndAnnotations();
+        mActiveScene->clearContent(UBGraphicsScene::clearItemsAndAnnotations);
         updateActionStates();
     }
 }
@@ -694,7 +694,7 @@ void UBBoardController::clearSceneItems()
     if (mActiveScene)
     {
         freezeW3CWidgets(true);
-        mActiveScene->clearItems();
+        mActiveScene->clearContent(UBGraphicsScene::clearItems);
         updateActionStates();
     }
 }
@@ -704,7 +704,7 @@ void UBBoardController::clearSceneAnnotation()
 {
     if (mActiveScene)
     {
-        mActiveScene->clearAnnotations();
+        mActiveScene->clearContent(UBGraphicsScene::clearAnnotations);
         updateActionStates();
     }
 }
@@ -713,7 +713,7 @@ void UBBoardController::clearSceneBackground()
 {
     if (mActiveScene)
     {
-        mActiveScene->clearBackground();
+        mActiveScene->clearContent(UBGraphicsScene::clearBackground);
         updateActionStates();
     }
 }

src/desktop/UBDesktopAnnotationController.cpp

@@ -274,7 +274,7 @@ void UBDesktopAnnotationController::eraseDesktopAnnotations()
 {
     if (mTransparentDrawingScene)
     {
-        mTransparentDrawingScene->clearAnnotations();
+        mTransparentDrawingScene->clearContent(UBGraphicsScene::clearAnnotations);
     }
 }
 

src/domain/UBGraphicsGroupContainerItem.cpp

@@ -78,7 +78,10 @@ void UBGraphicsGroupContainerItem::addToGroup(QGraphicsItem *item)
     QTransform newItemTransform(itemTransform);
     item->setPos(mapFromItem(item, 0, 0));
 
-    item->scene()->removeItem(item);
+    if (item->scene()) {
+        item->scene()->removeItem(item);
+    }
+
     if (corescene())
         corescene()->removeItemFromDeletion(item);
     item->setParentItem(this);

src/domain/UBGraphicsItemDelegate.cpp

@@ -387,9 +387,22 @@ void UBGraphicsItemDelegate::remove(bool canUndo)
     UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene());
     if (scene)
     {
-        foreach(DelegateButton* button, mButtons)
+//        bool shownOnDisplay = mDelegated->data(UBGraphicsItemData::ItemLayerType).toInt() != UBItemLayerType::Control;
-            scene->removeItem(button);
+//        showHide(shownOnDisplay);
+//        updateFrame();
+//        updateButtons();
+
+        if (mFrame && !mFrame->scene() && mDelegated->scene())
+        {
+            mDelegated->scene()->addItem(mFrame);
+        }
+        mFrame->setAntiScale(mAntiScaleRatio);
+        mFrame->positionHandles();
+        updateButtons(true);
 
+        foreach(DelegateButton* button, mButtons) {
+            scene->removeItem(button);
+        }
         scene->removeItem(mFrame);
 
         /* this is performed because when removing delegated from scene while it contains flash content, segfault happens because of QGraphicsScene::removeItem() */

src/domain/UBGraphicsItemDelegate.h

@@ -244,6 +244,7 @@ class UBGraphicsItemDelegate : public QObject
         UBGraphicsToolBarItem* getToolBarItem() const { return mToolBarItem; }
 
         qreal antiScaleRatio() const { return mAntiScaleRatio; }
+        virtual void update() {positionHandles();}
 
     signals:
         void showOnDisplayChanged(bool shown);

src/domain/UBGraphicsScene.cpp

@@ -1064,106 +1064,72 @@ UBItem* UBGraphicsScene::deepCopy() const
     return sceneDeepCopy();
 }
 
-void UBGraphicsScene::clearItemsAndAnnotations()
+void UBGraphicsScene::clearContent(clearCase pCase)
 {
-    deselectAllItems();
-
-    QSet<QGraphicsItem*> emptyList;
-    QSet<QGraphicsItem*> removedItems;
-
-    QList<QGraphicsItem*> sceneItems = items();
-    foreach(QGraphicsItem* item, sceneItems)
-    {
-        if(!mTools.contains(item) && !isBackgroundObject(item))
-        {
-            removeItem(item);
-            removedItems << item;
-        }
-    }
-
-    // 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();
-}
-
-void UBGraphicsScene::clearItems()
-{
-    deselectAllItems();
-
-    QSet<QGraphicsItem*> emptyList;
     QSet<QGraphicsItem*> removedItems;
 
-    QList<QGraphicsItem*> sceneItems = items();
+    switch (pCase) {
-    foreach(QGraphicsItem* item, sceneItems)
+    case clearBackground :
-    {
+        removeItem(mBackgroundObject);
-        bool isGroup = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(item) != NULL;
+        removedItems << mBackgroundObject;
-        bool isPolygon = qgraphicsitem_cast<UBGraphicsPolygonItem*>(item) != NULL;
+        break;
-        bool isStrokesGroup = qgraphicsitem_cast<UBGraphicsStrokesGroup*>(item) != NULL;
+
-
+    case clearItemsAndAnnotations :
-        if(!isGroup && !isPolygon && !isStrokesGroup && !mTools.contains(item) && !isBackgroundObject(item))
+    case clearItems :
-        {
+    case clearAnnotations :
-            removeItem(item);
+        foreach(QGraphicsItem* item, items()) {
-            removedItems << item;
+
-        }
+            bool isGroup = item->type() == UBGraphicsGroupContainerItem::Type;
-    }
+            bool isStrokesGroup = item->type() == UBGraphicsStrokesGroup::Type;
-
+
-    // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
+            UBGraphicsGroupContainerItem *itemGroup = item->parentItem()
-    update(sceneRect());
+                                                      ? qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(item->parentItem())
-
+                                                      : 0;
-
+            UBGraphicsItemDelegate *curDelegate = UBGraphicsItem::Delegate(item);
-    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
+            if (!curDelegate) {
-        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
+                continue;
-        UBApplication::undoStack->push(uc);
+            }
-    }
 
-    setDocumentUpdated();
+            bool shouldDelete = false;
-}
+            switch (static_cast<int>(pCase)) {
+            case clearAnnotations :
+                shouldDelete = isStrokesGroup;
+                break;
+            case clearItems :
+                shouldDelete = !isGroup && !isBackgroundObject(item) && !isStrokesGroup;
+                break;
+            case clearItemsAndAnnotations:
+                shouldDelete = !isGroup && !isBackgroundObject(item);
+                break;
+            }
 
-void UBGraphicsScene::clearAnnotations()
+            if(shouldDelete) {
-{
+                if (itemGroup) {
-    QSet<QGraphicsItem*> emptyList;
+                    itemGroup->removeFromGroup(item);
-    QSet<QGraphicsItem*> removedItems;
+                    if (itemGroup->childItems().count() == 1) {
+                        itemGroup->destroy();
+                    }
+                    itemGroup->Delegate()->update();
+                }
 
-    QList<QGraphicsItem*> sceneItems = items();
+                curDelegate->remove(false);
-    foreach(QGraphicsItem* item, sceneItems)
+                removedItems << item;
-    {
+            }
-        UBGraphicsStrokesGroup* pi = qgraphicsitem_cast<UBGraphicsStrokesGroup*>(item);
-        if (pi)
-        {
-            removeItem(item);
-            removedItems << item;
         }
+        break;
     }
 
     // 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);
+        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, QSet<QGraphicsItem*>());
         UBApplication::undoStack->push(uc);
     }
 
-    setDocumentUpdated();
+    if (pCase == clearBackground) {
-}
-
-void UBGraphicsScene::clearBackground()
-{
-    if(mBackgroundObject){
-        removeItem(mBackgroundObject);
-
-        if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-            UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, mBackgroundObject, NULL);
-            UBApplication::undoStack->push(uc);
-        }
         mBackgroundObject = 0;
     }
-    update(sceneRect());
 
     setDocumentUpdated();
 }
@@ -1357,8 +1323,8 @@ UBGraphicsW3CWidgetItem* UBGraphicsScene::addOEmbed(const QUrl& pContentUrl, con
 UBGraphicsGroupContainerItem *UBGraphicsScene::createGroup(QList<QGraphicsItem *> items)
 {
     UBGraphicsGroupContainerItem *groupItem = new UBGraphicsGroupContainerItem();
-    addItem(groupItem);
 
+    addItem(groupItem);
     foreach (QGraphicsItem *item, items) {
         if (item->type() == UBGraphicsGroupContainerItem::Type) {
             QList<QGraphicsItem*> childItems = item->childItems();

src/domain/UBGraphicsScene.h

@@ -101,6 +101,13 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
 
     public:
 
+    enum clearCase {
+        clearItemsAndAnnotations = 0
+        , clearAnnotations
+        , clearItems
+        , clearBackground
+    };
+
     //        tmp stub for divide addings scene objects from undo mechanism implementation
     void setURStackEnable(bool set = true) {enableUndoRedoStack = set;}
     bool isURStackIsEnabled(){ return enableUndoRedoStack;}
@@ -114,10 +121,7 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
 
         UBGraphicsScene* sceneDeepCopy() const;
 
-        void clearItemsAndAnnotations();
+        void clearContent(clearCase pCase = clearItemsAndAnnotations);
-        void clearItems();
-        void clearAnnotations();
-        void clearBackground();
 
         bool inputDevicePress(const QPointF& scenePos, const qreal& pressure = 1.0);
         bool inputDeviceMove(const QPointF& scenePos, const qreal& pressure = 1.0);

src/domain/UBGraphicsTextItemDelegate.cpp

@@ -263,6 +263,11 @@ void UBGraphicsTextItemDelegate::setEditable(bool editable)
         mDelegated->setData(UBGraphicsItemData::ItemEditable, QVariant(false));
     }
 }
+void UBGraphicsTextItemDelegate::remove(bool canUndo)
+{
+    UBGraphicsItemDelegate::remove(canUndo);
+}
+
 bool UBGraphicsTextItemDelegate::isEditable()
 {
     return mDelegated->data(UBGraphicsItemData::ItemEditable).toBool();

src/domain/UBGraphicsTextItemDelegate.h

@@ -46,6 +46,7 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
     public slots:
         void contentsChanged();
         virtual void setEditable(bool);
+        virtual void remove(bool canUndo);
 
     protected:
         virtual void buildButtons();

src/domain/UBItem.cpp

@@ -17,6 +17,15 @@
 
 #include "core/memcheck.h"
 
+#include "domain/UBGraphicsPixmapItem.h"
+#include "domain/UBGraphicsTextItem.h"
+#include "domain/UBGraphicsSvgItem.h"
+#include "domain/UBGraphicsMediaItem.h"
+#include "domain/UBGraphicsStrokesGroup.h"
+#include "domain/UBGraphicsGroupContainerItem.h"
+#include "domain/UBGraphicsWidgetItem.h"
+#include "tools/UBGraphicsCurtainItem.h"
+
 UBItem::UBItem()
     : mUuid(QUuid())
     , mRenderingQuality(UBItem::RenderingQualityNormal)
@@ -44,3 +53,37 @@ bool UBGraphicsItem::isRotatable(QGraphicsItem *item)
 {
     return item->data(UBGraphicsItemData::ItemRotatable).toBool();
 }
+
+UBGraphicsItemDelegate *UBGraphicsItem::Delegate(QGraphicsItem *pItem)
+{
+    UBGraphicsItemDelegate *result = 0;
+
+    switch (static_cast<int>(pItem->type())) {
+    case UBGraphicsPixmapItem::Type :
+        result = (static_cast<UBGraphicsPixmapItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsTextItem::Type :
+        result = (static_cast<UBGraphicsTextItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsSvgItem::Type :
+        result = (static_cast<UBGraphicsSvgItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsMediaItem::Type:
+        result = (static_cast<UBGraphicsMediaItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsStrokesGroup::Type :
+        result = (static_cast<UBGraphicsStrokesGroup*>(pItem))->Delegate();
+        break;
+    case UBGraphicsGroupContainerItem::Type :
+        result = (static_cast<UBGraphicsGroupContainerItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsWidgetItem::Type :
+        result = (static_cast<UBGraphicsWidgetItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsCurtainItem::Type :
+        result = (static_cast<UBGraphicsCurtainItem*>(pItem))->Delegate();
+        break;
+    }
+
+    return result;
+}

src/domain/UBItem.h

@@ -108,6 +108,7 @@ public:
     static bool isRotatable(QGraphicsItem *item);
     static bool isFlippable(QGraphicsItem *item);
 
+    static UBGraphicsItemDelegate *Delegate(QGraphicsItem *pItem);
     virtual UBGraphicsItemDelegate *Delegate() const  = 0;
 
     virtual void remove() = 0;

src/gui/UBKeyboardPalette.cpp

@@ -60,7 +60,10 @@ UBKeyboardPalette::UBKeyboardPalette(QWidget *parent)
     createCtrlButtons();
 
     nCurrentLocale = UBSettings::settings()->KeyboardLocale->get().toInt();
-    setInput(locales[nCurrentLocale]);
+	if (nCurrentLocale < 0 || nCurrentLocale >= nLocalesCount)
+		nCurrentLocale = 0;
+	if (locales!=NULL)
+	    setInput(locales[nCurrentLocale]);
 
     setContentsMargins( 22, 22, 22, 22 );