Merge branch 'develop' of github.com:OpenEducationFoundation/OpenBoard into develop

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -42,6 +42,7 @@
 #include "domain/UBGraphicsStroke.h"
 #include "domain/UBGraphicsStrokesGroup.h"
 #include "domain/UBGraphicsGroupContainerItem.h"
+#include "domain/UBGraphicsGroupContainerItemDelegate.h"
 #include "domain/UBItem.h"
 
 #include "tools/UBGraphicsRuler.h"
@@ -924,7 +925,13 @@ void UBSvgSubsetAdaptor::UBSvgSubsetReader::readGroupRoot()
         }
         else if (mXmlReader.isStartElement()) {
             if (mXmlReader.name() == tGroup) {
+                QString ubLocked = mXmlReader.attributes().value(UBSettings::uniboardDocumentNamespaceUri, "locked").toString();
                 UBGraphicsGroupContainerItem *curGroup = readGroup();
+                if (!ubLocked.isEmpty())
+                {
+                    bool isLocked = ubLocked.contains(xmlTrue);
+                    curGroup->Delegate()->setLocked(isLocked);
+                }
                 if (curGroup) {
                     mScene->addGroup(curGroup);
                 }
@@ -1276,6 +1283,9 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
                 if (curElement.hasAttribute(aId)) {
                     mXmlWriter.writeStartElement(curElement.tagName());
                     mXmlWriter.writeAttribute(aId, curElement.attribute(aId));
+                    if(curElement.hasAttribute("locked")){
+                        mXmlWriter.writeAttribute(UBSettings::uniboardDocumentNamespaceUri,"locked",curElement.attribute("locked"));
+                    }
                     QDomElement curSubElement = curElement.firstChildElement();
                     while (!curSubElement.isNull()) {
                         if (curSubElement.hasAttribute(aId)) {
@@ -1320,6 +1330,13 @@ void UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistGroupToDom(QGraphicsItem *gro
     if (!uuid.isNull()) {
         QDomElement curGroupElement = groupDomDocument->createElement(tGroup);
         curGroupElement.setAttribute(aId, uuid);
+        UBGraphicsGroupContainerItem* group = dynamic_cast<UBGraphicsGroupContainerItem*>(groupItem);
+        if(group && group->Delegate()){
+            if(group->Delegate()->isLocked())
+                curGroupElement.setAttribute("locked", xmlTrue);
+            else
+                curGroupElement.setAttribute("locked", xmlFalse);
+        }
         curParent->appendChild(curGroupElement);
         foreach (QGraphicsItem *item, groupItem->childItems()) {
             QUuid tmpUuid = UBGraphicsScene::getPersonalUuid(item);

src/board/UBBoardController.cpp

@@ -1634,7 +1634,7 @@ void UBBoardController::adjustDisplayViews()
 
 int UBBoardController::autosaveTimeoutFromSettings()
 {
-    int value = UBSettings::settings()->timerInterval->get().toInt();
+    int value = UBSettings::settings()->autoSaveInterval->get().toInt();
     int minute = 60 * 1000;
 
     return value * minute;
@@ -1773,8 +1773,8 @@ void UBBoardController::autosaveTimeout()
 
 void UBBoardController::appMainModeChanged(UBApplicationController::MainMode md)
 {
-    int timerInterval = autosaveTimeoutFromSettings();
+    int autoSaveInterval = autosaveTimeoutFromSettings();
-    if (!timerInterval) {
+    if (!autoSaveInterval) {
         return;
     }
 
@@ -1784,7 +1784,7 @@ void UBBoardController::appMainModeChanged(UBApplicationController::MainMode md)
     }
 
     if (md == UBApplicationController::Board) {
-        mAutosaveTimer->start(timerInterval);
+        mAutosaveTimer->start(autoSaveInterval);
     } else if (mAutosaveTimer->isActive()) {
         mAutosaveTimer->stop();
     }

src/board/UBBoardPaletteManager.cpp

@@ -243,7 +243,7 @@ void UBBoardPaletteManager::setupPalettes()
 
     mStylusPalette->stackUnder(mZoomPalette);
 
-    mTipPalette = new UBStartupHintsPalette(mContainer);
+    //mTipPalette = new UBStartupHintsPalette(mContainer);
     QList<QAction*> backgroundsActions;
 
     backgroundsActions << UBApplication::mainWindow->actionPlainLightBackground;

src/core/UBSettings.cpp

@@ -353,7 +353,7 @@ void UBSettings::init()
 
     boardShowToolsPalette = new UBSetting(this, "Board", "ShowToolsPalette", "false");
     magnifierDrawingMode = new UBSetting(this, "Board", "MagnifierDrawingMode", "0");
-    timerInterval = new UBSetting(this, "Board", "Timer interval", "5");
+    autoSaveInterval = new UBSetting(this, "Board", "AutoSaveIntervalInMinutes", "3");
 
     svgViewBoxMargin = new UBSetting(this, "SVG", "ViewBoxMargin", "50");
 

src/core/UBSettings.h

@@ -373,7 +373,7 @@ class UBSettings : public QObject
         UBSetting* libIconSize;
 
         UBSetting* magnifierDrawingMode;
-        UBSetting* timerInterval;
+        UBSetting* autoSaveInterval;
 
     public slots:
 

src/domain/UBGraphicsGroupContainerItem.cpp

@@ -79,9 +79,14 @@ void UBGraphicsGroupContainerItem::addToGroup(QGraphicsItem *item)
         if (UBGraphicsItem::isRotatable(this) && !UBGraphicsItem::isRotatable(item)) {
             Delegate()->setUBFlag(GF_REVOLVABLE, false);
         }
-    } else {
+        if (!UBGraphicsItem::isLocked(this) && UBGraphicsItem::isLocked(item)) {
+            Delegate()->setLocked(true);
+        }
+    } 
+    else {
         Delegate()->setUBFlag(GF_FLIPPABLE_ALL_AXIS, UBGraphicsItem::isFlippable(item));
         Delegate()->setUBFlag(GF_REVOLVABLE, UBGraphicsItem::isRotatable(item));
+        Delegate()->setLocked(UBGraphicsItem::isLocked(item));
     }
 
     // COMBINE
@@ -322,6 +327,7 @@ void UBGraphicsGroupContainerItem::pRemoveFromGroup(QGraphicsItem *item)
         if (!UBGraphicsItem::isFlippable(item) || !UBGraphicsItem::isRotatable(item)) {
             bool flippableNow = true;
             bool rotatableNow = true;
+            bool lockedNow = false;
 
             foreach (QGraphicsItem *item, childItems()) {
                 if (!UBGraphicsItem::isFlippable(item)) {
@@ -330,12 +336,17 @@ void UBGraphicsGroupContainerItem::pRemoveFromGroup(QGraphicsItem *item)
                 if (!UBGraphicsItem::isRotatable(item)) {
                     rotatableNow = false;
                 }
-                if (!rotatableNow && !flippableNow) {
+                if(UBGraphicsItem::isLocked(item))
+                    lockedNow = true;
+
+                if (!rotatableNow && !flippableNow && lockedNow) {
                     break;
                 }
+
             }
             Delegate()->setUBFlag(GF_FLIPPABLE_ALL_AXIS, flippableNow);
             Delegate()->setUBFlag(GF_REVOLVABLE, rotatableNow);
+            Delegate()->setLocked(lockedNow);
         }
     }
 

src/domain/UBGraphicsItemDelegate.cpp

@@ -715,6 +715,15 @@ void UBGraphicsItemDelegate::showMenu()
     mMenu->exec(cv->mapToGlobal(pinPos.bottomRight()));
 }
 
+void UBGraphicsItemDelegate::setLocked(bool pLocked)
+{
+    Q_ASSERT(mDelegated);
+
+    if (mDelegated) {
+        mDelegated->setData(UBGraphicsItemData::ItemLocked, QVariant(pLocked));
+    }
+}
+
 void UBGraphicsItemDelegate::updateFrame()
 {
     if (mFrame && !mFrame->scene() && mDelegated->scene())

src/domain/UBGraphicsItemDelegate.h

@@ -279,6 +279,7 @@ class UBGraphicsItemDelegate : public QObject
         void setMimeData(QMimeData* mimeData);
         void setDragPixmap(const QPixmap &pix) {mDragPixmap = pix;}
 
+        void setLocked(bool pLocked);
         void setButtonsVisible(bool visible);
 
         UBGraphicsToolBarItem* getToolBarItem() const { return mToolBarItem; }

src/domain/UBGraphicsItemZLevelUndoCommand.cpp

@@ -59,7 +59,7 @@ void UBGraphicsItemZLevelUndoCommand::undo(){
     if(mDest == UBZLayerController::down || mDest == UBZLayerController::bottom){
         // Move up
         QList<QGraphicsItem*>::iterator downIt = mItems.end();
-        for(downIt; downIt >= mItems.begin(); downIt--){
+        for(; downIt >= mItems.begin(); downIt--){
             for(int i=0; i<zDiff; i++)
                 mpScene->changeZLevelTo(*downIt, UBZLayerController::up);
         }

src/domain/UBGraphicsTextItemDelegate.cpp

@@ -45,13 +45,64 @@
 const int UBGraphicsTextItemDelegate::sMinPixelSize = 8;
 const int UBGraphicsTextItemDelegate::sMinPointSize = 8;
 
+
+AlignTextButton::AlignTextButton(const QString &fileName, QGraphicsItem *pDelegated, QGraphicsItem *parent, Qt::WindowFrameSection section)
+    : DelegateButton(fileName, pDelegated, parent, section)
+    , lft(new QSvgRenderer(QString(":/images/plus.svg")))
+    , cntr(new QSvgRenderer(QString(":/images/pause.svg")))
+    , rght(new QSvgRenderer(QString(":/images/minus.svg")))
+    , mxd(new QSvgRenderer(QString(":/images/reload.svg")))
+{
+    setKind(k_left);
+}
+
+AlignTextButton::~AlignTextButton()
+{
+    if (lft) delete lft;
+    if (cntr) delete cntr;
+    if (rght) delete rght;
+    if (mxd) delete mxd;
+}
+
+void AlignTextButton::setKind(int pKind)
+{
+    if (mHideMixed && pKind == k_mixed) {
+        qDebug() << "Mixed button is hidden, can't process it";
+        return;
+    }
+    mKind = pKind;
+    QSvgRenderer *rndrer = rndFromKind(pKind);
+    Q_ASSERT(rndrer);
+    setSharedRenderer(rndrer);
+}
+
+void AlignTextButton::setNextKind()
+{
+    int mxKind = MAX_KIND;
+    if (mHideMixed) {
+        mxKind--;
+    }
+    setKind(mKind == mxKind ? 0 : ++mKind);
+}
+
+int AlignTextButton::nextKind() const
+{
+    int mxKind = MAX_KIND;
+    if (mHideMixed) {
+        mxKind--;
+    }
+    int result = mKind;
+    return mKind == mxKind ? 0 : ++result;
+}
+
 UBGraphicsTextItemDelegate::UBGraphicsTextItemDelegate(UBGraphicsTextItem* pDelegated, QObject *)
     : UBGraphicsItemDelegate(pDelegated,0, GF_COMMON | GF_REVOLVABLE | GF_TOOLBAR_USED)
+    , mFontButton(0)
+    , mColorButton(0)
+    , mDecreaseSizeButton(0)
+    , mIncreaseSizeButton(0)
+    , mAlignButton(0)
     , mLastFontPixelSize(-1)
-    , mAlignLeftButton(0)
-    , mAlignCenterButton(0)
-    , mAlignRightButton(0)
-    , mAlighMixed(0)
     , delta(5)
 {
     delegated()->setData(UBGraphicsItemData::ItemEditable, QVariant(true));
@@ -70,6 +121,9 @@ UBGraphicsTextItemDelegate::UBGraphicsTextItemDelegate(UBGraphicsTextItem* pDele
     delegated()->adjustSize();
     delegated()->contentsChanged();
 
+    connect(delegated()->document(), SIGNAL(cursorPositionChanged(QTextCursor)), this, SLOT(onCursorPositionChanged(QTextCursor)));
+    connect(delegated()->document(), SIGNAL(modificationChanged(bool)), this, SLOT(onModificationChanged(bool)));
+
     // NOOP
 }
 
@@ -107,24 +161,35 @@ void UBGraphicsTextItemDelegate::buildButtons()
 {
     UBGraphicsItemDelegate::buildButtons();
 
+    if (!mFontButton) {
         mFontButton = new DelegateButton(":/images/font.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+        connect(mFontButton, SIGNAL(clicked(bool)), this, SLOT(pickFont()));
+    }
+    if (!mColorButton) {
         mColorButton = new DelegateButton(":/images/color.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+        connect(mColorButton, SIGNAL(clicked(bool)), this, SLOT(pickColor()));
+    }
+
+    if (!mDecreaseSizeButton) {
         mDecreaseSizeButton = new DelegateButton(":/images/minus.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+        connect(mDecreaseSizeButton, SIGNAL(clicked(bool)), this, SLOT(decreaseSize()));
+    }
+
+    if (!mIncreaseSizeButton) {
         mIncreaseSizeButton = new DelegateButton(":/images/plus.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+        connect(mIncreaseSizeButton, SIGNAL(clicked(bool)), this, SLOT(increaseSize()));
+    }
 
-    //Alignment buttons family
+    //    Alignment button
-    mAlignLeftButton = new DelegateButton(":/images/plus.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+    if (!mAlignButton) {
-    mAlignCenterButton = new DelegateButton(":/images/pause.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+        mAlignButton = new AlignTextButton(":/images/plus.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
-    mAlignRightButton  = new DelegateButton(":/images/minus.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+        connect(mAlignButton, SIGNAL(clicked()), this, SLOT(alignButtonProcess()));
-    mAlighMixed = new DelegateButton(":/images/reload.svg", mDelegated, mToolBarItem, Qt::TitleBarArea);
+    }
 
-    connect(mFontButton, SIGNAL(clicked(bool)), this, SLOT(pickFont()));
-    connect(mColorButton, SIGNAL(clicked(bool)), this, SLOT(pickColor()));
-    connect(mDecreaseSizeButton, SIGNAL(clicked(bool)), this, SLOT(decreaseSize()));
-    connect(mIncreaseSizeButton, SIGNAL(clicked(bool)), this, SLOT(increaseSize()));
 
     QList<QGraphicsItem*> itemsOnToolBar;
-    itemsOnToolBar << mFontButton << mColorButton << mDecreaseSizeButton << mIncreaseSizeButton << mFontButton;
+    itemsOnToolBar << mFontButton << mColorButton << mDecreaseSizeButton << mIncreaseSizeButton;
+    itemsOnToolBar << mAlignButton;
     mToolBarItem->setItemsOnToolBar(itemsOnToolBar);
     mToolBarItem->setShifting(true);
     mToolBarItem->setVisibleOnBoard(true);
@@ -259,6 +324,58 @@ void UBGraphicsTextItemDelegate::increaseSize()
    ChangeTextSize(delta, changeSize);
 }
 
+void UBGraphicsTextItemDelegate::alignButtonProcess()
+{
+    qDebug() << "alignButtonProcess() clicked";
+    QObject *sndr = sender();
+
+    if (sndr == mAlignButton) {
+        qDebug() << "Align button";
+        AlignTextButton *asAlText = static_cast<AlignTextButton*>(mAlignButton);
+        if (asAlText->nextKind() == AlignTextButton::k_mixed) {
+            restoreTextCursorFormats();
+        }
+        asAlText->setNextKind();
+
+        QTextCursor cur = delegated()->textCursor();
+        QTextBlockFormat fmt = cur.blockFormat();
+        switch (asAlText->kind()) {
+        case AlignTextButton::k_left:
+            fmt.setAlignment(Qt::AlignLeft);
+            break;
+        case AlignTextButton::k_center:
+            fmt.setAlignment(Qt::AlignCenter);
+            break;
+        case AlignTextButton::k_right:
+            fmt.setAlignment(Qt::AlignRight);
+            break;
+        case AlignTextButton::k_mixed:
+            break;
+        }
+
+        delegated()->setTextCursor(cur);
+        cur.setBlockFormat(fmt);
+    }
+
+    qDebug() << "sender process" << sndr;
+}
+
+void UBGraphicsTextItemDelegate::onCursorPositionChanged(const QTextCursor &cursor)
+{
+    qDebug() << "cursor position changed";
+    qDebug() << "-----------------------";
+    qDebug() << "we have a selection!" << cursor.selectionStart();
+    qDebug() << "-----------------------";
+    updateAlighButtonState();
+}
+
+void UBGraphicsTextItemDelegate::onModificationChanged(bool ch)
+{
+    Q_UNUSED(ch);
+    qDebug() << "modification changed";
+    updateAlighButtonState();
+}
+
 UBGraphicsTextItem* UBGraphicsTextItemDelegate::delegated()
 {
     return static_cast<UBGraphicsTextItem*>(mDelegated);
@@ -344,6 +461,47 @@ void UBGraphicsTextItemDelegate::positionHandles()
     }
 }
 
+bool UBGraphicsTextItemDelegate::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    mSelectionData.mButtonIsPressed = true;
+    qDebug() << "Reporting selection  of the cursor (mouse press)" << delegated()->textCursor().selection().isEmpty();
+    qDebug() << QString("Anchor: %1\nposition: %2 (mouse press)").arg(delegated()->textCursor().anchor()).arg(delegated()->textCursor().position());
+
+    if (!UBGraphicsItemDelegate::mousePressEvent(event)) {
+        return false;
+    }
+
+    return true;
+}
+
+bool UBGraphicsTextItemDelegate::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (mSelectionData.mButtonIsPressed) {
+        qDebug() << "Reporting selection of the cursor (mouse move)" << delegated()->textCursor().selection().isEmpty();
+        qDebug() << QString("Anchor: %1\nposition: %2 (mouse mouse move)").arg(delegated()->textCursor().anchor()).arg(delegated()->textCursor().position());
+    }
+
+    if (!UBGraphicsItemDelegate::mouseMoveEvent(event)) {
+        return false;
+    }
+
+    return true;
+}
+
+bool UBGraphicsTextItemDelegate::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    mSelectionData.mButtonIsPressed = false;
+    qDebug() << "Reporting selection of the cursor (mouse release)" << delegated()->textCursor().selection().isEmpty();
+    qDebug() << QString("Anchor: %1\nposition: %2 (mouse mouse release)").arg(delegated()->textCursor().anchor()).arg(delegated()->textCursor().position());
+    updateAlighButtonState();
+
+    if (!UBGraphicsItemDelegate::mouseReleaseEvent(event)) {
+        return false;
+    }
+
+    return true;
+}
+
 void UBGraphicsTextItemDelegate::ChangeTextSize(qreal factor, textChangeMode changeMode)
 {
     if (scaleSize == changeMode)
@@ -445,6 +603,77 @@ void UBGraphicsTextItemDelegate::ChangeTextSize(qreal factor, textChangeMode cha
     delegated()->setTextCursor(cursor);
 }
 
+void UBGraphicsTextItemDelegate::updateAlighButtonState()
+{
+    if (!mAlignButton) {
+        return;
+    }
+
+    AlignTextButton *asAlBtn = static_cast<AlignTextButton*>(mAlignButton);
+
+    if (!oneBlockSelection()) {
+        asAlBtn->setMixedButtonVisible(true);
+        asAlBtn->setKind(AlignTextButton::k_mixed);
+        saveTextCursorFormats();
+        return;
+    }
+
+    asAlBtn->setMixedButtonVisible(false);
+    switch (static_cast<int>(delegated()->textCursor().blockFormat().alignment())) {
+    case Qt::AlignCenter :
+        asAlBtn->setKind(AlignTextButton::k_center);
+        break;
+    case Qt::AlignRight :
+        asAlBtn->setKind(AlignTextButton::k_right);
+        break;
+    default:
+        asAlBtn->setKind(AlignTextButton::k_left);
+        break;
+    }
+}
+
+bool UBGraphicsTextItemDelegate::oneBlockSelection()
+{
+    const QTextCursor cursor = delegated()->textCursor();
+    int pos = cursor.position();
+    int anchor = cursor.anchor();
+
+    // no selection
+    if (pos == anchor) {
+        return true;
+    }
+
+    //selecton within one text block
+    QTextBlock blck = cursor.block();
+    if (blck.contains(pos) && blck.contains(anchor)) {
+        return true;
+    }
+
+    //otherwise
+    return false;
+}
+
+void UBGraphicsTextItemDelegate::saveTextCursorFormats()
+{
+    mSelectionData.anchor = delegated()->textCursor().anchor();
+    mSelectionData.position = delegated()->textCursor().position();
+    mSelectionData.html = delegated()->document()->toHtml();
+}
+
+void UBGraphicsTextItemDelegate::restoreTextCursorFormats()
+{
+    delegated()->document()->setHtml(mSelectionData.html);
+
+    int min = qMin(mSelectionData.position, mSelectionData.anchor);
+    int max = qMax(mSelectionData.position, mSelectionData.anchor);
+    int steps = max - min;
+
+    QTextCursor tcrsr = delegated()->textCursor();
+    tcrsr.setPosition(mSelectionData.position);
+    tcrsr.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor, steps);
+    delegated()->setTextCursor(tcrsr);
+}
+
 void UBGraphicsTextItemDelegate::scaleTextSize(qreal multiplyer)
 {
     ChangeTextSize(multiplyer, scaleSize);

src/domain/UBGraphicsTextItemDelegate.h

@@ -37,6 +37,64 @@
 
 class UBGraphicsTextItem;
 
+class AlignTextButton : public DelegateButton
+{
+    Q_OBJECT
+
+public:
+    static const int MAX_KIND = 3;
+    enum kind_t{
+        k_left = 0
+        , k_center
+        , k_right
+        , k_mixed
+    };
+
+    AlignTextButton(const QString & fileName, QGraphicsItem* pDelegated, QGraphicsItem * parent = 0, Qt::WindowFrameSection section = Qt::TopLeftSection);
+    virtual ~AlignTextButton();
+
+    void setKind(int pKind);
+    int kind() {return mKind;}
+
+    void setNextKind();
+    int nextKind() const;
+
+    void setMixedButtonVisible(bool v = true) {mHideMixed = !v;}
+    bool isMixedButtonVisible() {return !mHideMixed;}
+
+private:
+
+    QSvgRenderer *rndFromKind(int pknd)
+    {
+        switch (pknd) {
+        case k_left:
+            return lft;
+            break;
+        case k_center:
+            return cntr;
+            break;
+        case k_right:
+            return rght;
+            break;
+        case k_mixed:
+            return mxd;
+            break;
+        }
+
+        return 0;
+    }
+
+    QSvgRenderer *curRnd() {return rndFromKind(mKind);}
+
+    QPointer<QSvgRenderer> lft;
+    QPointer<QSvgRenderer> cntr;
+    QPointer<QSvgRenderer> rght;
+    QPointer<QSvgRenderer> mxd;
+
+    int mKind;
+    bool mHideMixed;
+};
+
 class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
 {
     Q_OBJECT
@@ -67,8 +125,11 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
 
         virtual void positionHandles();
 
-    private:
+        virtual bool mousePressEvent(QGraphicsSceneMouseEvent *event);
+        virtual bool mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+        virtual bool mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
 
+    private:
         UBGraphicsTextItem* delegated();
 
         DelegateButton* mFontButton;
@@ -76,10 +137,7 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
         DelegateButton* mDecreaseSizeButton;
         DelegateButton* mIncreaseSizeButton;
 
-        DelegateButton* mAlignLeftButton;
+        DelegateButton* mAlignButton;
-        DelegateButton* mAlignCenterButton;
-        DelegateButton* mAlignRightButton;
-        DelegateButton* mAlighMixed;
 
         int mLastFontPixelSize;
 
@@ -89,9 +147,26 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
     private:
         void customize(QFontDialog &fontDialog);
         void ChangeTextSize(qreal factor, textChangeMode changeMode);
+        void updateAlighButtonState();
+        bool oneBlockSelection();
+        void saveTextCursorFormats();
+        void restoreTextCursorFormats();
+
 
         QFont createDefaultFont();
         QAction *mEditableAction;
+        struct selectionData_t {
+            selectionData_t()
+                : mButtonIsPressed(false)
+            {}
+            bool mButtonIsPressed;
+            int position;
+            int anchor;
+            QString html;
+            QTextDocumentFragment selection;
+            QList<QTextBlockFormat> fmts;
+
+        } mSelectionData;
 
     private slots:
 
@@ -101,9 +176,12 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
         void decreaseSize();
         void increaseSize();
 
+        void alignButtonProcess();
+        void onCursorPositionChanged(const QTextCursor& cursor);
+        void onModificationChanged(bool ch);
+
 private:
       const int delta;
-
 };
 
 #endif /* UBGRAPHICSTEXTITEMDELEGATE_H_ */

src/domain/UBGraphicsWidgetItem.cpp

@@ -565,12 +565,9 @@ void UBGraphicsWidgetItem::injectInlineJavaScript()
 void UBGraphicsWidgetItem::paint( QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
 
-    if (scene() && scene()->renderingContext() != UBGraphicsScene::Screen) {
+
-        painter->drawPixmap(0, 0, snapshot());
-    }
-    else {
     QGraphicsWebView::paint(painter, option, widget);
-    }
+
 
     if (!mInitialLoadDone) {
         QString message;

src/domain/UBItem.cpp

@@ -85,6 +85,11 @@ bool UBGraphicsItem::isRotatable(QGraphicsItem *item)
     return item->data(UBGraphicsItemData::ItemRotatable).toBool();
 }
 
+bool UBGraphicsItem::isLocked(QGraphicsItem *item)
+{
+    return item->data(UBGraphicsItemData::ItemLocked).toBool();
+}
+
 QUuid UBGraphicsItem::getOwnUuid(QGraphicsItem *item)
 {
     QString idCandidate = item->data(UBGraphicsItemData::ItemUuid).toString();

src/domain/UBItem.h

@@ -116,6 +116,7 @@ public:
     static void assignZValue(QGraphicsItem*, qreal value);
     static bool isRotatable(QGraphicsItem *item);
     static bool isFlippable(QGraphicsItem *item);
+    static bool isLocked(QGraphicsItem *item);
     static QUuid getOwnUuid(QGraphicsItem *item);
 
     static UBGraphicsItemDelegate *Delegate(QGraphicsItem *pItem);

src/gui/UBDocumentTreeWidget.cpp

@@ -261,7 +261,7 @@ void UBDocumentTreeWidget::dropEvent(QDropEvent *event)
                 UBDocumentProxyTreeItem* pi = dynamic_cast<UBDocumentProxyTreeItem*>(ti);
                 if (pi)
                 {
-                    if (mSelectedProxyTi->proxy()->metaData(UBSettings::documentUpdatedAt).toString() >= pi->proxy()->metaData(UBSettings::documentUpdatedAt).toString())
+                    if (mSelectedProxyTi->proxy()->metaData(UBSettings::documentDate).toString() >= pi->proxy()->metaData(UBSettings::documentDate).toString())
                     {
                         break;
                     }
@@ -380,7 +380,7 @@ void UBDocumentTreeWidget::documentUpdated(UBDocumentProxy *pDocument)
                 UBDocumentProxyTreeItem* pi = dynamic_cast<UBDocumentProxyTreeItem*>(ti);
                 if (pi)
                 {
-                    if (pDocument->metaData(UBSettings::documentUpdatedAt).toString() >= pi->proxy()->metaData(UBSettings::documentUpdatedAt).toString())
+                    if (pDocument->metaData(UBSettings::documentDate).toString() >= pi->proxy()->metaData(UBSettings::documentDate).toString())
                     {
                         bool selected = treeItem->isSelected();
                         parent->removeChild(treeItem);
@@ -416,7 +416,7 @@ UBDocumentProxyTreeItem::UBDocumentProxyTreeItem(QTreeWidgetItem * parent, UBDoc
         UBDocumentProxyTreeItem* pi = dynamic_cast<UBDocumentProxyTreeItem*>(ti);
         if (pi)
         {
-            if (proxy->metaData(UBSettings::documentUpdatedAt).toString() >= pi->proxy()->metaData(UBSettings::documentUpdatedAt).toString())
+            if (proxy->metaData(UBSettings::documentDate).toString() >= pi->proxy()->metaData(UBSettings::documentDate).toString())
             {
                 break;
             }