Sankore 1107 Crashes fixed Undo command left

preferencesAboutTextFull
Ilia Ryabokon 12 years ago
parent 4406082dc8
commit 8b0e41ea91
  1. 2
      src/api/UBWidgetUniboardAPI.cpp
  2. 8
      src/board/UBBoardController.cpp
  3. 2
      src/desktop/UBDesktopAnnotationController.cpp
  4. 3
      src/domain/UBGraphicsGroupContainerItem.cpp
  5. 17
      src/domain/UBGraphicsItemDelegate.cpp
  6. 1
      src/domain/UBGraphicsItemDelegate.h
  7. 116
      src/domain/UBGraphicsScene.cpp
  8. 12
      src/domain/UBGraphicsScene.h
  9. 5
      src/domain/UBGraphicsTextItemDelegate.cpp
  10. 1
      src/domain/UBGraphicsTextItemDelegate.h
  11. 43
      src/domain/UBItem.cpp
  12. 1
      src/domain/UBItem.h
  13. 3
      src/gui/UBKeyboardPalette.cpp

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

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

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

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

@ -387,9 +387,22 @@ void UBGraphicsItemDelegate::remove(bool canUndo)
UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene()); UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene());
if (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); scene->removeItem(mFrame);
/* this is performed because when removing delegated from scene while it contains flash content, segfault happens because of QGraphicsScene::removeItem() */ /* this is performed because when removing delegated from scene while it contains flash content, segfault happens because of QGraphicsScene::removeItem() */

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

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

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

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

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

@ -17,6 +17,15 @@
#include "core/memcheck.h" #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() UBItem::UBItem()
: mUuid(QUuid()) : mUuid(QUuid())
, mRenderingQuality(UBItem::RenderingQualityNormal) , mRenderingQuality(UBItem::RenderingQualityNormal)
@ -44,3 +53,37 @@ bool UBGraphicsItem::isRotatable(QGraphicsItem *item)
{ {
return item->data(UBGraphicsItemData::ItemRotatable).toBool(); 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;
}

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

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

Loading…
Cancel
Save