Merge branch 'dev' into 1.4-dev

resources/etc/OpenBoard.config

 [App]
 AngleTolerance=4
 EnableAutomaticSoftwareUpdates=false
-EnableSoftwareUpdates=true
 EnableStartupHints=true
 FavoriteToolURIs=openboardtool://openboard/mask, openboardtool://ruler, openboardtool://compass, openboardtool://protractor, openboardtool://triangle, openboardtool://magnifier, openboardtool://cache
 IsInSoftwareUpdateProcess=false

src/adaptors/UBExportPDF.cpp

@@ -32,6 +32,7 @@
 #include <QtCore>
 #include <QtSvg>
 #include <QPrinter>
+#include <QPdfWriter>
 
 #include "core/UBApplication.h"
 #include "core/UBSettings.h"
@@ -40,6 +41,7 @@
 
 #include "domain/UBGraphicsScene.h"
 #include "domain/UBGraphicsSvgItem.h"
+#include "domain/UBGraphicsPDFItem.h"
 
 #include "document/UBDocumentProxy.h"
 
@@ -66,56 +68,67 @@ void UBExportPDF::persist(UBDocumentProxy* pDocumentProxy)
 
 bool UBExportPDF::persistsDocument(UBDocumentProxy* pDocumentProxy, const QString& filename)
 {
-    QPrinter pdfPrinter;
+    QPdfWriter pdfWriter(filename);
 
     qDebug() << "exporting document to PDF" << filename;
 
-    pdfPrinter.setOutputFormat(QPrinter::PdfFormat);
-    pdfPrinter.setResolution(UBSettings::settings()->pdfResolution->get().toInt());
-    pdfPrinter.setOutputFileName(filename);
-    pdfPrinter.setFullPage(true);
+    pdfWriter.setResolution(UBSettings::settings()->pdfResolution->get().toInt());
+    pdfWriter.setPageMargins(QMarginsF());
+    pdfWriter.setTitle(pDocumentProxy->name());
+    pdfWriter.setCreator("OpenBoard PDF export");
 
     //need to calculate screen resolution
     QDesktopWidget* desktop = UBApplication::desktop();
     int dpiCommon = (desktop->physicalDpiX() + desktop->physicalDpiY()) / 2;
     float scaleFactor = 72.0f / dpiCommon;
-    
+
     QPainter pdfPainter;
     bool painterNeedsBegin = true;
 
     int existingPageCount = pDocumentProxy->pageCount();
 
-    for(int pageIndex = 0 ; pageIndex < existingPageCount; pageIndex++)
-    {
+    for(int pageIndex = 0 ; pageIndex < existingPageCount; pageIndex++) {
+
         UBGraphicsScene* scene = UBPersistenceManager::persistenceManager()->loadDocumentScene(pDocumentProxy, pageIndex);
         UBApplication::showMessage(tr("Exporting page %1 of %2").arg(pageIndex + 1).arg(existingPageCount));
+
         // set background to white, no crossing for PDF output
         bool isDark = scene->isDarkBackground();
         UBPageBackground pageBackground = scene->pageBackground();
         scene->setBackground(false, UBPageBackground::plain);
 
-        QSize pageSize = scene->nominalSize();
+        // pageSize is the output PDF page size; it is set to equal the scene's boundary size; if the contents
+        // of the scene overflow from the boundaries, they will be scaled down.
+        QSize pageSize = scene->sceneSize();
 
         // set high res rendering
         scene->setRenderingQuality(UBItem::RenderingQualityHigh);
         scene->setRenderingContext(UBGraphicsScene::NonScreen);
 
-        //setting page size to appropriate value
-        pdfPrinter.setPaperSize(QSizeF(pageSize.width()*scaleFactor, pageSize.height()*scaleFactor), QPrinter::Point);
-        if(painterNeedsBegin) painterNeedsBegin = !pdfPainter.begin(&pdfPrinter);
-        //render to PDF
-        scene->render(&pdfPainter, QRectF(), scene->normalizedSceneRect());
+        // Setting output page size
+        QPageSize outputPageSize = QPageSize(QSizeF(pageSize.width()*scaleFactor, pageSize.height()*scaleFactor), QPageSize::Point);
+        pdfWriter.setPageSize(outputPageSize);
 
-        if (pageIndex < existingPageCount - 1) pdfPrinter.newPage();
+        // Call begin only once
+        if(painterNeedsBegin)
+            painterNeedsBegin = !pdfPainter.begin(&pdfWriter);
 
-        //restore screen rendering quality
+        else if (pageIndex < existingPageCount)
+            pdfWriter.newPage();
+
+        // Render the scene
+        scene->render(&pdfPainter, QRectF(), scene->normalizedSceneRect());
+
+        // Restore screen rendering quality
         scene->setRenderingContext(UBGraphicsScene::Screen);
         scene->setRenderingQuality(UBItem::RenderingQualityNormal);
 
-        //restore background state
+        // Restore background state
         scene->setBackground(isDark, pageBackground);
     }
-    if(!painterNeedsBegin) pdfPainter.end();
+
+    if(!painterNeedsBegin)
+        pdfPainter.end();
 
     return true;
 }

src/board/UBBoardController.cpp

@@ -620,9 +620,6 @@ UBGraphicsItem *UBBoardController::duplicateItem(UBItem *item)
         itemSize = commonItem->boundingRect().size();
         commonItem->setSelected(false);
 
-        UBGraphicsStrokesGroup *stroke = dynamic_cast<UBGraphicsStrokesGroup*>(commonItem);
-        if (stroke)
-            itemPos = QPointF(shifting, shifting);
     }
 
     UBMimeType::Enum itemMimeType;
@@ -681,7 +678,7 @@ UBGraphicsItem *UBBoardController::duplicateItem(UBItem *item)
             {
                  QBuffer buffer(&pData);
                  buffer.open(QIODevice::WriteOnly);
-                 QString format = UBFileSystemUtils::extension(item->sourceUrl().toLocalFile());
+                 QString format = UBFileSystemUtils::extension(item->sourceUrl().toString(QUrl::DecodeReserved));
                  pixitem->pixmap().save(&buffer, format.toLatin1());
             }
         }break;

src/board/UBBoardPaletteManager.cpp

@@ -74,6 +74,7 @@
 
 #include "document/UBDocumentController.h"
 
+#include "core/UBPersistenceManager.h"
 #include "core/memcheck.h"
 
 UBBoardPaletteManager::UBBoardPaletteManager(QWidget* container, UBBoardController* pBoardController)
@@ -862,7 +863,11 @@ void UBBoardPaletteManager::addItemToCurrentPage()
     {
         UBGraphicsPixmapItem* item = UBApplication::boardController->activeScene()->addPixmap(mPixmap, NULL, mPos, mScaleFactor);
 
-        item->setSourceUrl(mItemUrl);
+        QString documentPath = UBApplication::boardController->selectedDocument()->persistencePath();
+        QString fileName = UBPersistenceManager::imageDirectory + "/" + item->uuid().toString() + ".png";
+        QString path = documentPath + "/" + fileName;
+
+        item->setSourceUrl(QUrl(path));
         item->setSelected(true);
 
         UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Selector);

src/core/UBApplication.cpp

@@ -511,13 +511,7 @@ void UBApplication::decorateActionMenu(QAction* action)
             menu->addSeparator();
             menu->addAction(mainWindow->actionPreferences);
             menu->addAction(mainWindow->actionMultiScreen);
-            // SANKORE-48: Hide the check update action if the setting
-            // EnableAutomaticSoftwareUpdates is false in Uniboard.config
-            if(UBSettings::settings()->appEnableAutomaticSoftwareUpdates->get().toBool())
-                menu->addAction(mainWindow->actionCheckUpdate);
-            else
-                mainWindow->actionCheckUpdate->setEnabled(false);
-
+            menu->addAction(mainWindow->actionCheckUpdate);
             menu->addSeparator();
 
             menu->addAction(mainWindow->actionPodcast);

src/core/UBApplicationController.cpp

@@ -479,7 +479,7 @@ void UBApplicationController::checkUpdate(const QUrl& url)
 {
     QUrl jsonUrl = url;
     if (url.isEmpty())
-        jsonUrl = UBSettings::settings()->appSoftwareUpdateURI->get().toUrl();
+        jsonUrl = UBSettings::settings()->appSoftwareUpdateURL->get().toUrl();
 
     qDebug() << "Checking for update at url: " << jsonUrl.toString();
 

src/core/UBPreferencesController.cpp

@@ -190,8 +190,6 @@ void UBPreferencesController::wire()
 
     // about tab
     connect(mPreferencesUI->checkSoftwareUpdateAtLaunchCheckBox, SIGNAL(clicked(bool)), settings->appEnableAutomaticSoftwareUpdates, SLOT(setBool(bool)));
-    // As we (hopefully temporarily) don't have a website to check updates at, this setting is hidden for now
-    mPreferencesUI->softwareUpdateGroupBox->setVisible(false);
 
     connect(mPreferencesUI->checkOpenSankoreAtStartup, SIGNAL(clicked(bool)), settings->appLookForOpenSankoreInstall, SLOT(setBool(bool)));
 }

src/core/UBSettings.cpp

@@ -227,8 +227,7 @@ void UBSettings::init()
     appToolBarPositionedAtTop = new UBSetting(this, "App", "ToolBarPositionedAtTop", true);
     appToolBarDisplayText = new UBSetting(this, "App", "ToolBarDisplayText", true);
     appEnableAutomaticSoftwareUpdates = new UBSetting(this, "App", "EnableAutomaticSoftwareUpdates", false);
-    appEnableSoftwareUpdates = new UBSetting(this, "App", "EnableSoftwareUpdates", true);
-    appSoftwareUpdateURI = new UBSetting(this, "App", "SoftwareUpdateURI", "http://www.openboard.ch/update.json");
+    appSoftwareUpdateURL = new UBSetting(this, "App", "SoftwareUpdateURL", "http://www.openboard.ch/update.json");
     appToolBarOrientationVertical = new UBSetting(this, "App", "ToolBarOrientationVertical", false);
     appPreferredLanguage = new UBSetting(this,"App","PreferredLanguage", "");
 
@@ -281,7 +280,7 @@ void UBSettings::init()
     pageSize = new UBSetting(this, "Board", "DefaultPageSize", documentSizes.value(DocumentSizeRatio::Ratio4_3));
 
 
-    boardCrossColorDarkBackground = new UBSetting(this, "Board", "CrossColorDarkBackground", "#C82C2C2C");
+    boardCrossColorDarkBackground = new UBSetting(this, "Board", "CrossColorDarkBackground", "#C8C0C0C0");
     boardCrossColorLightBackground = new UBSetting(this, "Board", "CrossColorLightBackground", "#A5E1FF");
 
     QStringList penLightBackgroundColors;

src/core/UBSettings.h

@@ -243,8 +243,7 @@ class UBSettings : public QObject
         UBSetting* appToolBarPositionedAtTop;
         UBSetting* appToolBarDisplayText;
         UBSetting* appEnableAutomaticSoftwareUpdates;
-        UBSetting* appEnableSoftwareUpdates;
-        UBSetting* appSoftwareUpdateURI;
+        UBSetting* appSoftwareUpdateURL;
         UBSetting* appToolBarOrientationVertical;
         UBSetting* appPreferredLanguage;
 

src/document/UBDocumentController.cpp

@@ -546,37 +546,66 @@ void UBDocumentController::duplicateSelectedItem()
 }
 
 /**
- * @brief When deleting multiple documents, find a new document and select it
+ * @brief Set the first document in the list as current document
  *
- * This method simply selects the first un-selected document
+ * If there are no documents, a new one is created.
  */
-void UBDocumentController::selectADocumentOnMultipleTrashing()
+void UBDocumentController::selectFirstDocumentInList()
 {
-    // Loop through all folders, and each document in those folders, until we find
-    // a document that is not in the current selection (which is being deleted)
+    // Loop through all folders until we find one that is not the trash and not empty,
+    // and select the first document in that folder
 
     for (int i(0); i < mDocumentUI->documentTreeWidget->topLevelItemCount(); ++i) {
         QTreeWidgetItem* item = mDocumentUI->documentTreeWidget->topLevelItem(i);
         UBDocumentGroupTreeItem* groupItem = dynamic_cast<UBDocumentGroupTreeItem*>(item);
 
-        if (!groupItem->isTrashFolder()) {
-            for (int j(0); j < groupItem->childCount(); ++j) {
-                if (!mCurrentSelection.contains( groupItem->child(j) )) {
-                    selectDocument(((UBDocumentProxyTreeItem*)groupItem->child(j))->proxy(), true);
-                    return;
-                }
-            }
+        if (!groupItem->isTrashFolder() && groupItem->childCount() > 0) {
+            selectDocument(((UBDocumentProxyTreeItem*)groupItem->child(0))->proxy(), true);
+            groupItem->child(0)->setSelected(true);
+            return;
         }
     }
 
-
-
     // No document found => create a new one
     UBDocumentGroupTreeItem* topFolder = dynamic_cast<UBDocumentGroupTreeItem*>(mDocumentUI->documentTreeWidget->topLevelItem(0));
 
     UBDocumentProxy* document = UBPersistenceManager::persistenceManager()->createDocument(topFolder->groupName());
     selectDocument(document, true);
+}
+
+/**
+ * @brief Find the current document, and select it in the list
+ *
+ * If selectNewCurrentDocument is true, the first document in the list is selected and set as
+ * current document.
+ */
+void UBDocumentController::selectATreeItemOnMultipleTrashing(bool selectNewCurrentDocument)
+{
+    mCurrentSelection.clear();
+
+    if (selectNewCurrentDocument) {
+        selectFirstDocumentInList();
+        return;
+    }
+
+    // Find the currently selected document, and select its corresponding tree item
+    // If it isn't found, then the first document in the list is selected and set as current document
+
+    for (int i(0); i < mDocumentUI->documentTreeWidget->topLevelItemCount(); i++) {
+        QTreeWidgetItem* item = mDocumentUI->documentTreeWidget->topLevelItem(i);
+        UBDocumentGroupTreeItem* groupItem = dynamic_cast<UBDocumentGroupTreeItem*>(item);
 
+        if (!groupItem->isTrashFolder()) {
+            for (int j(0); j < groupItem->childCount(); j++) {
+                if (((UBDocumentProxyTreeItem*)groupItem->child(j))->proxy() == mBoardController->selectedDocument()) {
+                    ((UBDocumentProxyTreeItem*)groupItem->child(j))->setSelected(true);
+                    return;
+                }
+            }
+        }
+    }
+
+    selectFirstDocumentInList();
 }
 
 void UBDocumentController::selectADocumentOnTrashingSelectedOne(UBDocumentGroupTreeItem* groupTi,UBDocumentProxyTreeItem *proxyTi)
@@ -807,9 +836,9 @@ void UBDocumentController::deleteTreeItem(QTreeWidgetItem * item, bool showConfi
 
             if (selectNewDocument) {
                 if (mTrashTi->childCount()==0)
-                    selectDocument(NULL);
+                    selectATreeItemOnMultipleTrashing(false);
                 else
-                    selectDocument(((UBDocumentProxyTreeItem*)mTrashTi->child(0))->proxy());
+                    selectDocument(((UBDocumentProxyTreeItem*)mTrashTi->child(0))->proxy(), false);
             }
 
             reloadThumbnails();
@@ -849,11 +878,18 @@ void UBDocumentController::deleteSelectedItem()
 
         QList<QTreeWidgetItem*> foldersToDelete;
 
+        bool currentDocumentDeleted = false;
+
         foreach (QTreeWidgetItem * item, mCurrentSelection) {
             LastSelectedElementType type = itemType(item);
-            if (type == Document)
+            if (type == Document) {
                 deleteTreeItem(item, false, false);
 
+                UBDocumentProxyTreeItem* proxyItem = dynamic_cast<UBDocumentProxyTreeItem*>(item);
+                if (proxyItem && proxyItem->proxy() && (proxyItem->proxy() == mBoardController->selectedDocument()))
+                    currentDocumentDeleted = true;
+            }
+
             else if (type == Folder)
                 // Delete folders later, to avoid deleting a document twice
                 foldersToDelete << item;
@@ -863,7 +899,7 @@ void UBDocumentController::deleteSelectedItem()
             deleteTreeItem(item, false, false);
         }
 
-        selectADocumentOnMultipleTrashing();
+        selectATreeItemOnMultipleTrashing(currentDocumentDeleted);
     }
 
     else if (mSelectionType == Document || mSelectionType == Folder) {

src/document/UBDocumentController.h

@@ -130,7 +130,8 @@ class UBDocumentController : public UBDocumentContainer
         QString mDefaultDocumentGroupName;
 
         void selectADocumentOnTrashingSelectedOne(UBDocumentGroupTreeItem* groupTi,UBDocumentProxyTreeItem *proxyTi);
-        void selectADocumentOnMultipleTrashing();
+        void selectFirstDocumentInList();
+        void selectATreeItemOnMultipleTrashing(bool selectNewCurrentDocument = false);
         void moveDocumentToTrash(UBDocumentGroupTreeItem* groupTi, UBDocumentProxyTreeItem *proxyTi, bool selectNewDocument);
         void moveFolderToTrash(UBDocumentGroupTreeItem* groupTi);
         void emptyTrash(bool showConfirmationDialog);

src/domain/UBGraphicsItemUndoCommand.cpp

@@ -98,7 +98,28 @@ void UBGraphicsItemUndoCommand::undo()
 
         UBApplication::boardController->freezeW3CWidget(item, true);
         item->setSelected(false);
+
+        QTransform t;
+        bool bApplyTransform = false;
+        UBGraphicsPolygonItem *polygonItem = qgraphicsitem_cast<UBGraphicsPolygonItem*>(item);
+        if (polygonItem){
+            if (polygonItem->strokesGroup()
+                    && polygonItem->strokesGroup()->parentItem()
+                    && UBGraphicsGroupContainerItem::Type == polygonItem->strokesGroup()->parentItem()->type())
+            {
+                bApplyTransform = true;
+                t = polygonItem->sceneTransform();
+            }
+            else if (polygonItem->strokesGroup())
+                polygonItem->resetTransform();
+
+            polygonItem->strokesGroup()->removeFromGroup(polygonItem);
+        }
         mScene->removeItem(item);
+
+        if (bApplyTransform)
+            polygonItem->setTransform(t);
+
     }
 
     QSetIterator<QGraphicsItem*> itRemoved(mRemovedItems);
@@ -207,7 +228,29 @@ void UBGraphicsItemUndoCommand::redo()
         {
             QGraphicsItem* item = itRemoved.next();
             item->setSelected(false);
+
+            QTransform t;
+            bool bApplyTransform = false;
+            UBGraphicsPolygonItem *polygonItem = qgraphicsitem_cast<UBGraphicsPolygonItem*>(item);
+
+            if (polygonItem){
+                if(polygonItem->strokesGroup()
+                        && polygonItem->strokesGroup()->parentItem()
+                        && UBGraphicsGroupContainerItem::Type == polygonItem->strokesGroup()->parentItem()->type())
+                {
+                    bApplyTransform = true;
+                    t = polygonItem->sceneTransform();
+                }
+                else if (polygonItem->strokesGroup())
+                    polygonItem->resetTransform();
+
+                polygonItem->strokesGroup()->removeFromGroup(polygonItem);
+            }
             mScene->removeItem(item);
+
+            if (bApplyTransform)
+                item->setTransform(t);
+
             UBApplication::boardController->freezeW3CWidget(item, true);
         }
 

src/domain/UBGraphicsMediaItem.cpp

@@ -130,7 +130,14 @@ UBGraphicsVideoItem::UBGraphicsVideoItem(const QUrl &pMediaFileUrl, QGraphicsIte
     mVideoItem->setData(UBGraphicsItemData::ItemLayerType, UBItemLayerType::Object);
     mVideoItem->setFlag(ItemStacksBehindParent, true);
 
-    mMediaObject->setVideoOutput(mVideoItem);
+    /* setVideoOutput has to be called only when the video item is visible on the screen,
+     * due to a Qt bug (QTBUG-32522). So instead of calling it here, it is called when the
+     * active scene has changed, or when the item is first created.
+     * If and when Qt fix this issue, this should be changed back.
+     * */
+    //mMediaObject->setVideoOutput(mVideoItem);
+    mHasVideoOutput = false;
+
     mMediaObject->setNotifyInterval(50);
 
     setMinimumSize(QSize(320, 240));
@@ -155,8 +162,10 @@ UBGraphicsVideoItem::UBGraphicsVideoItem(const QUrl &pMediaFileUrl, QGraphicsIte
 
 UBGraphicsMediaItem::~UBGraphicsMediaItem()
 {
-    if (mMediaObject)
+    if (mMediaObject) {
         mMediaObject->stop();
+        delete mMediaObject;
+    }
 }
 
 QVariant UBGraphicsMediaItem::itemChange(GraphicsItemChange change, const QVariant &value)
@@ -569,6 +578,22 @@ void UBGraphicsVideoItem::paint(QPainter *painter, const QStyleOptionGraphicsIte
 
 }
 
+QVariant UBGraphicsVideoItem::itemChange(GraphicsItemChange change, const QVariant &value) {
+    if (change == QGraphicsItem::ItemVisibleChange
+            && value.toBool()
+            && !mHasVideoOutput
+            && UBApplication::app()->boardController
+            && UBApplication::app()->boardController->activeScene() == scene())
+    {
+        //qDebug() << "Item change, setting video output";
+
+        mMediaObject->setVideoOutput(mVideoItem);
+        mHasVideoOutput = true;
+    }
+
+    return UBGraphicsMediaItem::itemChange(change, value);
+}
+
 void UBGraphicsVideoItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
     // Display the seek bar
@@ -610,9 +635,19 @@ void UBGraphicsVideoItem::mediaStateChanged(QMediaPlayer::State state)
 
 void UBGraphicsVideoItem::activeSceneChanged()
 {
+    //qDebug() << "Active scene changed";
+
     // Update the visibility of the placeholder, to prevent it being hidden when switching pages
     setPlaceholderVisible(!mErrorString.isEmpty());
 
+    // Call setVideoOutput, if the video is visible and if it hasn't been called already
+    if (!mHasVideoOutput && UBApplication::boardController->activeScene() == scene()) {
+        //qDebug() << "setting video output";
+        mMediaObject->setMedia(mMediaFileUrl);
+        mMediaObject->setVideoOutput(mVideoItem);
+        mHasVideoOutput = true;
+    }
+
     UBGraphicsMediaItem::activeSceneChanged();
 }
 

src/domain/UBGraphicsMediaItem.h

@@ -207,11 +207,14 @@ protected:
 
     QGraphicsVideoItem *mVideoItem;
 
+    virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
     virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
     virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
     virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
 
     void setPlaceholderVisible(bool visible);
+
+    bool mHasVideoOutput;
 };
 
 

src/domain/UBGraphicsScene.cpp

@@ -2336,15 +2336,19 @@ QList<QUrl> UBGraphicsScene::relativeDependencies() const
     while (itItems.hasNext())
     {
         QGraphicsItem* item = itItems.next();
-        UBGraphicsMediaItem *mediaItem = qgraphicsitem_cast<UBGraphicsMediaItem*> (item);
-
-        if (mediaItem){
-            QString completeFileName = QFileInfo(mediaItem->mediaFileUrl().toLocalFile()).fileName();
-            QString path;
-            if(mediaItem->getMediaType() == UBGraphicsMediaItem::mediaType_Video)
-                path = UBPersistenceManager::videoDirectory + "/";
-            else
-                path = UBPersistenceManager::audioDirectory + "/";
+
+        UBGraphicsVideoItem *videoItem = qgraphicsitem_cast<UBGraphicsVideoItem*> (item);
+        if (videoItem){
+            QString completeFileName = QFileInfo(videoItem->mediaFileUrl().toLocalFile()).fileName();
+            QString path = UBPersistenceManager::videoDirectory + "/";
+            relativePathes << QUrl(path + completeFileName);
+            continue;
+        }
+
+        UBGraphicsAudioItem *audioItem = qgraphicsitem_cast<UBGraphicsAudioItem*> (item);
+        if (audioItem){
+            QString completeFileName = QFileInfo(audioItem->mediaFileUrl().toLocalFile()).fileName();
+            QString path = UBPersistenceManager::audioDirectory + "/";
             relativePathes << QUrl(path + completeFileName);
             continue;
         }
@@ -2384,6 +2388,24 @@ QSize UBGraphicsScene::nominalSize()
     return mNominalSize;
 }
 
+/**
+ * @brief Return the scene's boundary size, including any background item
+ *
+ * If no background item is present, this returns nominalSize()
+ */
+QSize UBGraphicsScene::sceneSize()
+{
+    UBGraphicsPDFItem *pdfItem = qgraphicsitem_cast<UBGraphicsPDFItem*>(backgroundObject());
+
+    if (pdfItem) {
+        QRectF targetRect = pdfItem->sceneBoundingRect();
+        return targetRect.size().toSize();
+    }
+
+    else
+        return nominalSize();
+}
+
 void UBGraphicsScene::setNominalSize(const QSize& pSize)
 {
     if (nominalSize() != pSize)

src/domain/UBGraphicsScene.h

@@ -286,6 +286,8 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
 
         QSize nominalSize();
 
+        QSize sceneSize();
+
         void setNominalSize(const QSize& pSize);
 
         void setNominalSize(int pWidth, int pHeight);

src/domain/UBGraphicsStrokesGroup.cpp

@@ -148,12 +148,15 @@ void UBGraphicsStrokesGroup::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 UBItem* UBGraphicsStrokesGroup::deepCopy() const
 {
     QTransform groupTransform = transform();
+    QPointF groupPos = pos();
 
     UBGraphicsStrokesGroup* copy = new UBGraphicsStrokesGroup();
     copyItemParameters(copy);
     copy->resetTransform();
+    copy->setPos(0,0);
 
     const_cast<UBGraphicsStrokesGroup*>(this)->resetTransform();
+    const_cast<UBGraphicsStrokesGroup*>(this)->setPos(0,0);
 
     QList<QGraphicsItem*> chl = childItems();
 
@@ -175,7 +178,9 @@ UBItem* UBGraphicsStrokesGroup::deepCopy() const
         }
     }
     const_cast<UBGraphicsStrokesGroup*>(this)->setTransform(groupTransform);
+    const_cast<UBGraphicsStrokesGroup*>(this)->setPos(groupPos);
     copy->setTransform(groupTransform);
+    copy->setPos(groupPos);
 
     return copy;
 }

src/gui/UBDocumentTreeWidget.cpp

@@ -285,13 +285,16 @@ void UBDocumentTreeWidget::dropEvent(QDropEvent *event)
                                 QString source = scene->document()->persistencePath() + "/" + relativeFile.toString();
                                 QString target = targetDocProxy->persistencePath() + "/" + relativeFile.toString();
 
+                                QString sourceDecoded = scene->document()->persistencePath() + "/" + relativeFile.toString(QUrl::DecodeReserved);
+                                QString targetDecoded = targetDocProxy->persistencePath() + "/" + relativeFile.toString(QUrl::DecodeReserved);
+
                                 if(QFileInfo(source).isDir())
                                     UBFileSystemUtils::copyDir(source,target);
                                 else{
-                                    QFileInfo fi(target);
+                                    QFileInfo fi(targetDecoded);
                                     QDir d = fi.dir();
                                     d.mkpath(d.absolutePath());
-                                    QFile::copy(source, target);
+                                    QFile::copy(sourceDecoded, targetDecoded);
                                 }
                             }
 

src/tools/UBGraphicsCurtainItemDelegate.cpp

@@ -38,7 +38,7 @@
 #include "core/memcheck.h"
 
 UBGraphicsCurtainItemDelegate::UBGraphicsCurtainItemDelegate(UBGraphicsCurtainItem* pDelegated, QObject * parent)
-    : UBGraphicsItemDelegate(pDelegated, parent, GF_SCALABLE_ALL_AXIS | GF_MENU_SPECIFIED)
+    : UBGraphicsItemDelegate(pDelegated, parent, GF_MENU_SPECIFIED)
 {
     //NOOP
 }