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

buildDebianPackage

@@ -107,7 +107,11 @@ buildWithStandardQt(){
         STANDARD_QT_USED=true
         QMAKE_PATH=$STANDARD_QT
         LRELEASES=`which lrelease`
-        QT_PATH="/usr/lib/`arch`-linux-gnu"
+        if [ "`arch`" == "i686" ]; then
+            QT_PATH="/usr/lib/i386-linux-gnu"
+        else
+            QT_PATH="/usr/lib/`arch`-linux-gnu"
+        fi
         PLUGINS_PATH="$QT_PATH/qt4/plugins"
     fi
   fi
@@ -189,6 +193,9 @@ cp -R resources/linux/qtlinux/* $PRODUCT_PATH/
 notifyProgress "QT" "Coping plugins and library ..."
 cp -R $PLUGINS_PATH $PRODUCT_PATH/
 
+# copying customization
+cp -R resources/customizations $PRODUCT_PATH/
+
 if [ $STANDARD_QT_USED == false ]; then 
 #copying custom qt library
   mkdir -p $QT_LIBRARY_DEST_PATH

resources/style.qss

@@ -70,11 +70,10 @@ QLabel#UBTGMediaDropMeLabel
 	padding: 2px;
 }
 
+QTextEdit,
+QLineEdit,
 QComboBox#DockPaletteWidgetComboBox QAbstractItemView
 {
-	background-color: white;
-	color: black;
- 
 	selection-background-color: lightgreen;
 	selection-color: black;
 }

src/adaptors/UBCFFSubsetAdaptor.cpp

@@ -869,8 +869,18 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgAudio(const QDomElement &ele
 
     QUuid uuid = QUuid::createUuid();
 
-    concreteUrl = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()
+    QString destFile;
-        ->addAudioFileToDocument(mCurrentScene->document(), concreteUrl.toLocalFile(), uuid));
+    bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(
+            mCurrentScene->document(), 
+            concreteUrl.toLocalFile(), 
+            UBPersistenceManager::audioDirectory,
+            uuid,
+            destFile);
+    if (!b)
+    {
+        return false;
+    }
+    concreteUrl = QUrl::fromLocalFile(destFile);
     
     UBGraphicsMediaItem *audioItem = mCurrentScene->addAudio(concreteUrl, false);
     QTransform transform;
@@ -912,8 +922,19 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgVideo(const QDomElement &ele
 
     QUuid uuid = QUuid::createUuid();
 
-    concreteUrl = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()
+
-        ->addVideoFileToDocument(mCurrentScene->document(), concreteUrl.toLocalFile(), uuid));
+    QString destFile;
+    bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(
+            mCurrentScene->document(), 
+            concreteUrl.toLocalFile(), 
+            UBPersistenceManager::videoDirectory,
+            uuid,
+            destFile);
+    if (!b)
+    {
+        return false;
+    }
+    concreteUrl = QUrl::fromLocalFile(destFile);
 
     UBGraphicsMediaItem *videoItem = mCurrentScene->addVideo(concreteUrl, false);
     QTransform transform;

src/adaptors/UBImportAdaptor.cpp

@@ -22,8 +22,9 @@
 
 #include "core/memcheck.h"
 
-UBImportAdaptor::UBImportAdaptor(QObject *parent)
+UBImportAdaptor::UBImportAdaptor(bool _documentBased, QObject *parent)
-    :QObject(parent)
+    :QObject(parent),
+    documentBased(_documentBased)
 {
     // NOOP
 }
@@ -33,6 +34,20 @@ UBImportAdaptor::~UBImportAdaptor()
     // NOOP
 }
 
+UBPageBasedImportAdaptor::UBPageBasedImportAdaptor(QObject *parent)
+    :UBImportAdaptor(false, parent)
+{
+    // NOOP
+}
+
+UBDocumentBasedImportAdaptor::UBDocumentBasedImportAdaptor(QObject *parent)
+    :UBImportAdaptor(true, parent)
+{
+    // NOOP
+}
+
+
+/*
 UBDocumentProxy* UBImportAdaptor::importFile(const QFile& pFile, const QString& pGroup)
 {
     QString documentName = QFileInfo(pFile.fileName()).completeBaseName();
@@ -53,3 +68,4 @@ UBDocumentProxy* UBImportAdaptor::importFile(const QFile& pFile, const QString&
 
     return newDocument;
 }
+*/

src/adaptors/UBImportAdaptor.h

@@ -18,6 +18,8 @@
 
 #include <QtGui>
 
+class UBGraphicsItem;
+class UBGraphicsScene;
 class UBDocumentProxy;
 
 class UBImportAdaptor : public QObject
@@ -25,15 +27,39 @@ class UBImportAdaptor : public QObject
     Q_OBJECT;
 
     protected:
-        UBImportAdaptor(QObject *parent = 0);
+        UBImportAdaptor(bool _documentBased, QObject *parent = 0);
         virtual ~UBImportAdaptor();
 
     public:
 
         virtual QStringList supportedExtentions() = 0;
         virtual QString importFileFilter() = 0;
-        virtual UBDocumentProxy* importFile(const QFile& pFile, const QString& pGroup);
+
-        virtual bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile) = 0;
+        bool isDocumentBased(){return documentBased;}
+    private:
+        bool documentBased;
+        
+};
+
+class UBPageBasedImportAdaptor : public UBImportAdaptor
+{
+protected:
+        UBPageBasedImportAdaptor(QObject *parent = 0);
+
+public:
+        virtual QList<UBGraphicsItem*> import(const QUuid& uuid, const QString& filePath) = 0;
+        virtual void placeImportedItemToScene(UBGraphicsScene* scene, UBGraphicsItem* item) = 0;
+        virtual const QString& folderToCopy() = 0;
 };
 
+class UBDocumentBasedImportAdaptor : public UBImportAdaptor
+{
+protected:
+        UBDocumentBasedImportAdaptor(QObject *parent = 0);
+public:
+    virtual UBDocumentProxy* importFile(const QFile& pFile, const QString& pGroup) = 0;
+    virtual bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile) = 0;
+};
+
+
 #endif /* UBIMPORTADAPTOR_H_ */

src/adaptors/UBImportCFF.cpp

@@ -14,6 +14,7 @@
  */
 
 #include <QDir>
+#include <QList>
 
 #include "core/UBApplication.h"
 #include "core/UBPersistenceManager.h"
@@ -38,7 +39,7 @@ THIRD_PARTY_WARNINGS_ENABLE
 #include "core/memcheck.h"
 
 UBImportCFF::UBImportCFF(QObject *parent)
-    : UBImportAdaptor(parent)
+    : UBDocumentBasedImportAdaptor(parent)
 {
     // NOOP
 }
@@ -77,7 +78,6 @@ QString UBImportCFF::importFileFilter()
     return filter;
 }
 
-
 bool UBImportCFF::addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile)
 {
     QFileInfo fi(pFile);
@@ -220,6 +220,7 @@ QString UBImportCFF::expandFileToDir(const QFile& pZipFile, const QString& pDir)
     return documentRootFolder;
 }
 
+
 UBDocumentProxy* UBImportCFF::importFile(const QFile& pFile, const QString& pGroup)
 {
     Q_UNUSED(pGroup); // group is defined in the imported file
@@ -277,4 +278,3 @@ UBDocumentProxy* UBImportCFF::importFile(const QFile& pFile, const QString& pGro
         return newDocument;
     }
 }
-

src/adaptors/UBImportCFF.h

@@ -21,7 +21,7 @@
 
 class UBDocumentProxy;
 
-class UBImportCFF : public UBImportAdaptor
+class UBImportCFF : public UBDocumentBasedImportAdaptor
 {
     Q_OBJECT;
 
@@ -33,13 +33,10 @@ class UBImportCFF : public UBImportAdaptor
         virtual QString importFileFilter();
 
         virtual bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile);
-
-        //base class method override
         virtual UBDocumentProxy* importFile(const QFile& pFile, const QString& pGroup);
 
     private:
-
+        QString expandFileToDir(const QFile& pZipFile, const QString& pDir);
-        virtual QString expandFileToDir(const QFile& pZipFile, const QString& pDir);
 };
 
 #endif // UBIMPORTCFF_H

src/adaptors/UBImportDocument.cpp

@@ -33,7 +33,7 @@ THIRD_PARTY_WARNINGS_ENABLE
 #include "core/memcheck.h"
 
 UBImportDocument::UBImportDocument(QObject *parent)
-    :UBImportAdaptor(parent)
+    :UBDocumentBasedImportAdaptor(parent)
 {
     // NOOP
 }
@@ -173,7 +173,6 @@ QString UBImportDocument::expandFileToDir(const QFile& pZipFile, const QString&
     return documentRootFolder;
 }
 
-
 UBDocumentProxy* UBImportDocument::importFile(const QFile& pFile, const QString& pGroup)
 {
     Q_UNUSED(pGroup); // group is defined in the imported file
@@ -197,7 +196,6 @@ UBDocumentProxy* UBImportDocument::importFile(const QFile& pFile, const QString&
 	}
 }
 
-
 bool UBImportDocument::addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile)
 {
     QFileInfo fi(pFile);
@@ -215,3 +213,5 @@ bool UBImportDocument::addFileToDocument(UBDocumentProxy* pDocument, const QFile
 
     return true;
 }
+
+

src/adaptors/UBImportDocument.h

@@ -21,7 +21,7 @@
 
 class UBDocumentProxy;
 
-class UBImportDocument : public UBImportAdaptor
+class UBImportDocument : public UBDocumentBasedImportAdaptor
 {
     Q_OBJECT;
 
@@ -37,7 +37,7 @@ class UBImportDocument : public UBImportAdaptor
         virtual bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile);
 
     private:
-        virtual QString expandFileToDir(const QFile& pZipFile, const QString& pDir);
+        QString expandFileToDir(const QFile& pZipFile, const QString& pDir);
 };
 
 #endif /* UBIMPORTDOCUMENT_H_ */

src/adaptors/UBImportImage.cpp

@@ -21,14 +21,14 @@
 #include "core/UBPersistenceManager.h"
 #include "core/UBDocumentManager.h"
 
-#include "domain/UBGraphicsPDFItem.h"
+#include "domain/UBGraphicsPixmapItem.h"
 
 #include "pdf/PDFRenderer.h"
 
 #include "core/memcheck.h"
 
 UBImportImage::UBImportImage(QObject *parent)
-    : UBImportAdaptor(parent)
+    : UBPageBasedImportAdaptor(parent)
 {
     // NOOP
 }
@@ -74,18 +74,33 @@ QString UBImportImage::importFileFilter()
     return filter;
 }
 
-
+QList<UBGraphicsItem*> UBImportImage::import(const QUuid& uuid, const QString& filePath)
-bool UBImportImage::addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile)
+{
+    QList<UBGraphicsItem*> result;
+
+    QPixmap pix(filePath);
+    if (pix.isNull())
+        return result;
+
+    UBGraphicsPixmapItem* pixmapItem = new UBGraphicsPixmapItem();
+    pixmapItem->setPixmap(pix);
+    result << pixmapItem;
+    return result;
+}
+
+void UBImportImage::placeImportedItemToScene(UBGraphicsScene* scene, UBGraphicsItem* item)
+{
+    UBGraphicsPixmapItem* pixmapItem = (UBGraphicsPixmapItem*)item;
+    
+     UBGraphicsPixmapItem* sceneItem = scene->addPixmap(pixmapItem->pixmap(), NULL, QPointF(0, 0));
+     scene->setAsBackgroundObject(sceneItem, true);
+
+     // Only stored pixmap, should be deleted now
+     delete pixmapItem;
+}
+
+const QString& UBImportImage::folderToCopy()
 {
-    int res = UBDocumentManager::documentManager()->addImageAsPageToDocument(QStringList(QFileInfo(pFile).absoluteFilePath()), pDocument);
+    static QString f("");
-    if (res == 0)
+    return f;
-    {
-        UBApplication::showMessage(tr("Image import failed."));
-        return false;
-    }
-    else
-    {
-        UBApplication::showMessage(tr("Image import successful."));
-        return true;
-    }
 }

src/adaptors/UBImportImage.h

@@ -21,7 +21,7 @@
 
 class UBDocumentProxy;
 
-class UBImportImage : public UBImportAdaptor
+class UBImportImage : public UBPageBasedImportAdaptor
 {
     Q_OBJECT;
 
@@ -32,7 +32,9 @@ class UBImportImage : public UBImportAdaptor
         virtual QStringList supportedExtentions();
         virtual QString importFileFilter();
 
-        virtual bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile);
+        virtual QList<UBGraphicsItem*> import(const QUuid& uuid, const QString& filePath);
+        virtual void placeImportedItemToScene(UBGraphicsScene* scene, UBGraphicsItem* item);
+        virtual const QString& folderToCopy();
 };
 
 #endif /* UBIMPORTIMAGE_H_ */

src/adaptors/UBImportPDF.cpp

@@ -27,7 +27,7 @@
 #include "core/memcheck.h"
 
 UBImportPDF::UBImportPDF(QObject *parent)
-    : UBImportAdaptor(parent)
+    : UBPageBasedImportAdaptor(parent)
 {
     QDesktopWidget* desktop = UBApplication::desktop();
 	this->dpi = (desktop->physicalDpiX() + desktop->physicalDpiY()) / 2;
@@ -52,63 +52,42 @@ QString UBImportPDF::importFileFilter()
 }
 
 
-bool UBImportPDF::addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile)
+QList<UBGraphicsItem*> UBImportPDF::import(const QUuid& uuid, const QString& filePath)
 {
-    QString documentName = QFileInfo(pFile.fileName()).completeBaseName();
+    QList<UBGraphicsItem*> result;
 
-    QUuid uuid = QUuid::createUuid();
+    PDFRenderer *pdfRenderer = PDFRenderer::rendererForUuid(uuid, filePath, true); // renderer is automatically deleted when not used anymore
-
-    QString filepath = UBPersistenceManager::persistenceManager()->addPdfFileToDocument(pDocument, pFile.fileName(), uuid);
-
-    PDFRenderer *pdfRenderer = PDFRenderer::rendererForUuid(uuid, pDocument->persistencePath() + "/" + filepath, true); // renderer is automatically deleted when not used anymore
 
     if (!pdfRenderer->isValid())
     {
         UBApplication::showMessage(tr("PDF import failed."));
-        return false;
+        return result;
     }
 	pdfRenderer->setDPI(this->dpi);
 
-    int documentPageCount = pDocument->pageCount();
-
-    if (documentPageCount == 1 && UBPersistenceManager::persistenceManager()->loadDocumentScene(pDocument, 0)->isEmpty())
-    {
-        documentPageCount = 0;
-    }
-
     int pdfPageCount = pdfRenderer->pageCount();
 
     for(int pdfPageNumber = 1; pdfPageNumber <= pdfPageCount; pdfPageNumber++)
     {
-        int pageIndex = documentPageCount + pdfPageNumber;
         UBApplication::showMessage(tr("Importing page %1 of %2").arg(pdfPageNumber).arg(pdfPageCount), true);
 
-        UBGraphicsScene* scene = 0;
+        result << new UBGraphicsPDFItem(pdfRenderer, pdfPageNumber); // deleted by the scene
-
+    }
-        if (pageIndex == 0)
+    return result;
-        {
+}
-            scene = UBPersistenceManager::persistenceManager()->loadDocumentScene(pDocument, pageIndex);
-        }
-        else
-        {
-            scene = UBPersistenceManager::persistenceManager()->createDocumentSceneAt(pDocument, pageIndex);
-        }
-
-        scene->setBackground(false, false);
-        UBGraphicsPDFItem *pdfItem = new UBGraphicsPDFItem(pdfRenderer, pdfPageNumber); // deleted by the scene
-        scene->addItem(pdfItem);
-
-        pdfItem->setPos(-pdfItem->boundingRect().width() / 2, -pdfItem->boundingRect().height() / 2);
-
-        scene->setAsBackgroundObject(pdfItem, false, false);
 
-        scene->setNominalSize(pdfItem->boundingRect().width(), pdfItem->boundingRect().height());
+void UBImportPDF::placeImportedItemToScene(UBGraphicsScene* scene, UBGraphicsItem* item)
+{
+    UBGraphicsPDFItem *pdfItem = (UBGraphicsPDFItem*)item;
 
+    pdfItem->setPos(-pdfItem->boundingRect().width() / 2, -pdfItem->boundingRect().height() / 2);
 
-        UBPersistenceManager::persistenceManager()->persistDocumentScene(pDocument, scene, pageIndex);
+    scene->setAsBackgroundObject(pdfItem, false, false);
-    }
 
-    UBApplication::showMessage(tr("PDF import successful."));
+    scene->setNominalSize(pdfItem->boundingRect().width(), pdfItem->boundingRect().height());
+}
 
-    return true;
+const QString& UBImportPDF::folderToCopy()
+{
+    return UBPersistenceManager::objectDirectory;
 }

src/adaptors/UBImportPDF.h

@@ -21,7 +21,7 @@
 
 class UBDocumentProxy;
 
-class UBImportPDF : public UBImportAdaptor
+class UBImportPDF : public UBPageBasedImportAdaptor
 {
     Q_OBJECT;
 
@@ -32,7 +32,9 @@ class UBImportPDF : public UBImportAdaptor
         virtual QStringList supportedExtentions();
         virtual QString importFileFilter();
 
-        virtual bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile);
+        virtual QList<UBGraphicsItem*> import(const QUuid& uuid, const QString& filePath);
+        virtual void placeImportedItemToScene(UBGraphicsScene* scene, UBGraphicsItem* item);
+        virtual const QString& folderToCopy();
 
 	private:
 		int dpi;

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -1194,6 +1194,7 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
             UBGraphicsStrokesGroup* strokesGroupItem = qgraphicsitem_cast<UBGraphicsStrokesGroup*>(item);
             if(strokesGroupItem && strokesGroupItem->isVisible()){
             	mXmlWriter.writeStartElement("g");
+                mXmlWriter.writeAttribute(UBSettings::uniboardDocumentNamespaceUri, "uuid", UBStringUtils::toCanonicalUuid(strokesGroupItem->uuid()));
             	QMatrix matrix = item->sceneMatrix();
 				if (!matrix.isIdentity()){
 					mXmlWriter.writeAttribute("transform", toSvgTransform(matrix));
@@ -2769,6 +2770,12 @@ UBGraphicsTextItem* UBSvgSubsetAdaptor::UBSvgSubsetReader::textItemFromSvg()
                     }
                 }
 
+                QTextCursor curCursor = textItem->textCursor();
+                QTextCharFormat format;
+
+                format.setFont(font);
+                curCursor.mergeCharFormat(format);
+                textItem->setTextCursor(curCursor);
                 textItem->setFont(font);
 
                 QStringRef fill = mXmlReader.attributes().value("color");

src/adaptors/UBThumbnailAdaptor.cpp

@@ -117,9 +117,6 @@ void UBThumbnailAdaptor::load(UBDocumentProxy* proxy, QList<const QPixmap*>& lis
 
 void UBThumbnailAdaptor::persistScene(UBDocumentProxy* proxy, UBGraphicsScene* pScene, int pageIndex, bool overrideModified)
 {
-
-    qDebug() << "Persist scene on path " << proxy->persistencePath() << ", index " << pageIndex;
-
     QString fileName = proxy->persistencePath() + UBFileSystemUtils::digitFileFormat("/page%1.thumbnail.jpg", pageIndex);
 
     QFile thumbFile(fileName);

src/api/UBWidgetUniboardAPI.cpp

@@ -476,7 +476,7 @@ void UBWidgetUniboardAPI::enableDropOnWidget(bool enable)
     }
 }
 
-void UBWidgetUniboardAPI::ProcessDropEvent(QDropEvent *event)
+void UBWidgetUniboardAPI::ProcessDropEvent(QGraphicsSceneDragDropEvent *event)
 {
     const QMimeData *pMimeData = event->mimeData();
 
@@ -485,11 +485,12 @@ void UBWidgetUniboardAPI::ProcessDropEvent(QDropEvent *event)
     bool downloaded = false;
 
     QGraphicsView *tmpView = mGraphicsWidget->scene()->views().at(0);
-    QPoint dropPoint(mGraphicsWidget->mapFromScene(tmpView->mapToScene(event->pos())).toPoint());
+    QPoint dropPoint(mGraphicsWidget->mapFromScene(tmpView->mapToScene(event->pos().toPoint())).toPoint());
-    Qt::DropActions dropActions = event->dropAction();
+    Qt::DropActions dropActions = event->possibleActions();
-    Qt::MouseButtons dropMouseButtons = event->mouseButtons();
+    Qt::MouseButtons dropMouseButtons = event->buttons();
-    Qt::KeyboardModifiers dropModifiers = event->keyboardModifiers();
+    Qt::KeyboardModifiers dropModifiers = event->modifiers();
-    QMimeData dropMimeData;
+    QMimeData *dropMimeData = new QMimeData;
+    qDebug() << event->possibleActions();
 
 
     if (pMimeData->hasHtml()) { //Dropping element from web browser
@@ -510,7 +511,7 @@ void UBWidgetUniboardAPI::ProcessDropEvent(QDropEvent *event)
             desc.name = QFileInfo(url).fileName();
             desc.totalSize = 0; // The total size will be retrieved during the download
 
-            desc.dropPoint = event->pos(); //Passing pure event point. No modifications
+            desc.dropPoint = event->pos().toPoint(); //Passing pure event point. No modifications
             desc.dropActions = dropActions;
             desc.dropMouseButtons = dropMouseButtons;
             desc.dropModifiers = dropModifiers;
@@ -542,12 +543,9 @@ void UBWidgetUniboardAPI::ProcessDropEvent(QDropEvent *event)
     }
     qDebug() << destFileName;
     QString mimeText = createMimeText(downloaded, contentType, destFileName);
-    dropMimeData.setData(tMimeText, mimeText.toAscii());
+    dropMimeData->setData(tMimeText, mimeText.toAscii());
 
-    QDropEvent readyEvent(dropPoint, dropActions, &dropMimeData, dropMouseButtons, dropModifiers);
+    event->setMimeData(dropMimeData);
-    //sending event to destination either it had been downloaded or not
-    QApplication::sendEvent(mGraphicsWidget,&readyEvent);
-    readyEvent.acceptProposedAction();
 }
 
 void UBWidgetUniboardAPI::onDownloadFinished(bool pSuccess, sDownloadFileDesc desc, QByteArray pData)

src/api/UBWidgetUniboardAPI.h

@@ -16,7 +16,7 @@
 #define UBWIDGETAPI_H
 
 #include <QtCore>
-#include <QDropEvent>
+#include <QGraphicsSceneDragDropEvent>
 
 #include "UBW3CWidgetAPI.h"
 #include "core/UBDownloadManager.h"
@@ -246,7 +246,7 @@ class UBWidgetUniboardAPI : public QObject
          * When an object is dropped on a widget, this one send us the informations to download it locally.
          * this method download the object on the widget directory and return the path of the downloaded object
          */
-        void ProcessDropEvent(QDropEvent *);
+        void ProcessDropEvent(QGraphicsSceneDragDropEvent *);
         bool isDropableData(const QMimeData *pMimeData) const;
 
 private slots:

src/board/UBBoardController.cpp

@@ -628,6 +628,7 @@ void UBBoardController::deleteScene(int nIndex)
     {
         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
         persistCurrentScene();
+        showMessage(tr("Delete page %1 from document").arg(nIndex), true);
 
         QList<int> scIndexes;
         scIndexes << nIndex;
@@ -638,6 +639,7 @@ void UBBoardController::deleteScene(int nIndex)
         if (nIndex >= pageCount())
             nIndex = pageCount()-1;
         setActiveDocumentScene(nIndex);
+        showMessage(tr("Page %1 deleted").arg(nIndex));
         QApplication::restoreOverrideCursor();
     }
 }
@@ -1074,8 +1076,20 @@ UBItem *UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QStri
         {
             QUuid uuid = QUuid::createUuid();
 
-            QUrl url = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()
+            QString destFile;
-                ->addVideoFileToDocument(selectedDocument(), sourceUrl, pData, uuid));
+            bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(selectedDocument(), 
+                "", 
+                UBPersistenceManager::videoDirectory,
+                uuid,
+                destFile,
+                &pData);
+            if (!b)
+            {
+                showMessage(tr("Add file operation failed: file copying error"));
+                return NULL;
+            }
+
+            QUrl url = QUrl::fromLocalFile(destFile);
 
             mediaVideoItem = mActiveScene->addMedia(url, false, pPos);
 
@@ -1105,8 +1119,20 @@ UBItem *UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QStri
         {
             QUuid uuid = QUuid::createUuid();
 
-            QUrl url = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()
+            QString destFile;
-                ->addAudioFileToDocument(selectedDocument(), sourceUrl, pData, uuid));
+            bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(selectedDocument(), 
+                "", 
+                UBPersistenceManager::audioDirectory,
+                uuid,
+                destFile,
+                &pData);
+            if (!b)
+            {
+                showMessage(tr("Add file operation failed: file copying error"));
+                return NULL;
+            }
+
+            QUrl url = QUrl::fromLocalFile(destFile);
 
             audioMediaItem = mActiveScene->addMedia(url, false, pPos);
 
@@ -1186,15 +1212,18 @@ UBItem *UBBoardController::downloadFinished(bool pSuccess, QUrl sourceUrl, QStri
         qDebug() << "sourceurl : " + sourceUrl.toString();
         int result = 0;
         if(!sourceUrl.isEmpty()){
-            QFile sourceFile(sourceUrl.toLocalFile());
+            QStringList fileNames;
-            result = UBDocumentManager::documentManager()->addFileToDocument(selectedDocument(), sourceFile);
+            fileNames << sourceUrl.toLocalFile();
+            result = UBDocumentManager::documentManager()->addFilesToDocument(selectedDocument(), fileNames);
         }
         else if(pData.size()){
             QTemporaryFile pdfFile("XXXXXX.pdf");
             if (pdfFile.open())
             {
                 pdfFile.write(pData);
-                result = UBDocumentManager::documentManager()->addFileToDocument(selectedDocument(), pdfFile);
+                QStringList fileNames;
+                fileNames << pdfFile.fileName();
+                result = UBDocumentManager::documentManager()->addFilesToDocument(selectedDocument(), fileNames);
                 pdfFile.close();
             }
         }
@@ -1904,7 +1933,18 @@ UBGraphicsMediaItem* UBBoardController::addVideo(const QUrl& pSourceUrl, bool st
     QUuid uuid = QUuid::createUuid();
     QUrl concreteUrl = pSourceUrl;
 
-    concreteUrl = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()->addVideoFileToDocument(selectedDocument(), pSourceUrl.toLocalFile(), uuid));
+    QString destFile;
+    bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(selectedDocument(), 
+                pSourceUrl.toLocalFile(), 
+                UBPersistenceManager::videoDirectory,
+                uuid,
+                destFile);
+    if (!b)
+    {
+        showMessage(tr("Add file operation failed: file copying error"));
+        return NULL;
+    }
+    concreteUrl = QUrl::fromLocalFile(destFile);
 
     UBGraphicsMediaItem* vi = mActiveScene->addMedia(concreteUrl, startPlay, pos);
     selectedDocument()->setMetaData(UBSettings::documentUpdatedAt, UBStringUtils::toUtcIsoDateTime(QDateTime::currentDateTime()));
@@ -1923,7 +1963,18 @@ UBGraphicsMediaItem* UBBoardController::addAudio(const QUrl& pSourceUrl, bool st
     QUuid uuid = QUuid::createUuid();
     QUrl concreteUrl = pSourceUrl;
 
-    concreteUrl = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()->addAudioFileToDocument(selectedDocument(), pSourceUrl.toLocalFile(), uuid));
+    QString destFile;
+    bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(selectedDocument(), 
+                pSourceUrl.toLocalFile(), 
+                UBPersistenceManager::audioDirectory,
+                uuid,
+                destFile);
+    if (!b)
+    {
+        showMessage(tr("Add file operation failed: file copying error"));
+        return NULL;
+    }
+    concreteUrl = QUrl::fromLocalFile(destFile);
 
     UBGraphicsMediaItem* ai = mActiveScene->addMedia(concreteUrl, startPlay, pos);
     selectedDocument()->setMetaData(UBSettings::documentUpdatedAt, UBStringUtils::toUtcIsoDateTime(QDateTime::currentDateTime()));
@@ -1942,9 +1993,11 @@ UBGraphicsWidgetItem *UBBoardController::addW3cWidget(const QUrl &pUrl, const QP
     UBGraphicsWidgetItem* w3cWidgetItem = 0;
 
     QUuid uuid = QUuid::createUuid();
-    QUrl newUrl = pUrl;
 
-    newUrl = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()->addGraphicsWidgteToDocument(selectedDocument(), pUrl.toLocalFile(), uuid));
+    QString destPath;
+    if (!UBPersistenceManager::persistenceManager()->addGraphicsWidgteToDocument(selectedDocument(), pUrl.toLocalFile(), uuid, destPath))
+        return NULL;
+    QUrl newUrl = QUrl::fromLocalFile(destPath);
 
     w3cWidgetItem = mActiveScene->addW3CWidget(newUrl, pos);
 

src/board/UBBoardView.cpp

@@ -989,7 +989,8 @@ UBBoardView::mouseReleaseEvent (QMouseEvent *event)
           {
              if (QGraphicsSvgItem::Type !=  movingItem->type() &&
                 UBGraphicsDelegateFrame::Type !=  movingItem->type() &&
-                UBToolWidget::Type != movingItem->type())
+                UBToolWidget::Type != movingItem->type() &&
+                QGraphicsWidget::Type != movingItem->type())
              {
                  bReleaseIsNeed = false;
                  if (movingItem->isSelected() && mMultipleSelectionIsEnabled)
@@ -1202,56 +1203,22 @@ UBBoardView::drawItems (QPainter *painter, int numItems,
 }
 
 
-void UBBoardView::dragMoveEvent (QDragMoveEvent *event)
+void UBBoardView::dragMoveEvent(QDragMoveEvent *event)
 {
-    QGraphicsItem* graphicsItemAtPos = itemAt(event->pos().x(),event->pos().y());
+  QGraphicsView::dragMoveEvent(event);
-    UBGraphicsWidgetItem* graphicsWidget = dynamic_cast<UBGraphicsWidgetItem*>(graphicsItemAtPos);
+  event->acceptProposedAction();
-
-    if (graphicsWidget) {
-        if (graphicsWidget->acceptDrops()) {
-            if (!mOkOnWidget) {
-                if (!graphicsWidget->isDropableData(event->mimeData())) {
-                    mOkOnWidget = false;
-                    event->ignore();
-                    return;
-                } else {
-                    mOkOnWidget = true;
-                }
-            }
-            QPoint newPoint(graphicsWidget->mapFromScene(mapToScene(event->pos())).toPoint());
-            QDragMoveEvent newEvent(newPoint, event->dropAction(), event->mimeData(), event->mouseButtons(), event->keyboardModifiers());
-            QApplication::sendEvent(graphicsWidget,&newEvent);
-        } else {
-            mOkOnWidget = false;
-            event->ignore();
-        }
-    }  else {
-        event->acceptProposedAction();
-        mOkOnWidget = false;
-    }
 }
 
 void UBBoardView::dropEvent (QDropEvent *event)
 {
-    mOkOnWidget = false;
+  if (!itemAt(event->pos().x(),event->pos().y())) {
-    QGraphicsItem* graphicsItemAtPos = itemAt(event->pos().x(),event->pos().y());
+    if (!event->source() || dynamic_cast<UBThumbnailWidget *>(event->source()) || dynamic_cast<QWebView*>(event->source()) || dynamic_cast<UBTGMediaWidget*>(event->source()) || dynamic_cast<QListView *>(event->source()) || dynamic_cast<UBTGDraggableTreeItem*>(event->source())) {
-    UBGraphicsWidgetItem* graphicsWidget = dynamic_cast<UBGraphicsWidgetItem*>(graphicsItemAtPos);
-
-    if (graphicsWidget && graphicsWidget->acceptDrops()) {
-
-        graphicsWidget->processDropEvent(event);
-        event->acceptProposedAction();
-
-    } else if (!event->source()
-               || dynamic_cast<UBThumbnailWidget *>(event->source())
-               || dynamic_cast<QWebView*>(event->source())
-               || dynamic_cast<UBTGMediaWidget*>(event->source())
-               || dynamic_cast<QListView *>(event->source())
-               || dynamic_cast<UBTGDraggableTreeItem*>(event->source())) {
-
         mController->processMimeData (event->mimeData (), mapToScene (event->pos ()));
         event->acceptProposedAction();
     }
+  }
+  else
+    QGraphicsView::dropEvent(event);
 }
 
 void

src/core/UBDocumentManager.cpp

@@ -128,36 +128,124 @@ UBDocumentProxy* UBDocumentManager::importFile(const QFile& pFile, const QString
 {
     QFileInfo fileInfo(pFile);
 
-    UBDocumentProxy* document = 0;
+    foreach (UBImportAdaptor *adaptor, mImportAdaptors)
-
-    foreach (UBImportAdaptor *importAdaptor, mImportAdaptors)
     {
-        if (importAdaptor->supportedExtentions().lastIndexOf(fileInfo.suffix().toLower()) != -1)
+        if (adaptor->supportedExtentions().lastIndexOf(fileInfo.suffix().toLower()) != -1)
         {
+            UBDocumentProxy* document;
             UBApplication::setDisabled(true);
-            document = importAdaptor->importFile(pFile, pGroup);
+
+            if (adaptor->isDocumentBased())
+            {
+                UBDocumentBasedImportAdaptor* importAdaptor = (UBDocumentBasedImportAdaptor*)adaptor;
+
+                document = importAdaptor->importFile(pFile, pGroup);
+            
+            }
+            else
+            {
+                UBPageBasedImportAdaptor* importAdaptor = (UBPageBasedImportAdaptor*)adaptor;
+
+                // Document import procedure.....
+                QString documentName = QFileInfo(pFile.fileName()).completeBaseName();
+                document = UBPersistenceManager::persistenceManager()->createDocument(pGroup, documentName);
+
+                QUuid uuid = QUuid::createUuid();
+                QString filepath = pFile.fileName();
+                if (importAdaptor->folderToCopy() != "")
+                {
+                    bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(document, pFile.fileName(), importAdaptor->folderToCopy() , uuid, filepath);
+                    if (!b)
+                    {
+                        UBPersistenceManager::persistenceManager()->deleteDocument(document);
+                        UBApplication::setDisabled(false);
+                        return NULL;
+                    }
+                }
+
+                QList<UBGraphicsItem*> pages = importAdaptor->import(uuid, filepath);
+                int nPage = 0;
+                foreach(UBGraphicsItem* page, pages)
+                {
+                    UBApplication::showMessage(tr("Inserting page %1 of %2").arg(++nPage).arg(pages.size()), true);
+                    int pageIndex = document->pageCount();
+                    UBGraphicsScene* scene = UBPersistenceManager::persistenceManager()->createDocumentSceneAt(document, pageIndex);
+                    importAdaptor->placeImportedItemToScene(scene, page);
+                    UBPersistenceManager::persistenceManager()->persistDocumentScene(document, scene, pageIndex);
+                }
+
+                UBPersistenceManager::persistenceManager()->persistDocumentMetadata(document);
+                UBApplication::showMessage(tr("Import successful."));
+            }
+
             UBApplication::setDisabled(false);
+            return document;
         }
-    }
 
-    return document;
+    }
+    return NULL;
 }
 
 
-bool UBDocumentManager::addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile)
+int UBDocumentManager::addFilesToDocument(UBDocumentProxy* document, QStringList fileNames)
 {
-    QFileInfo fileInfo(pFile);
+    int nImportedDocuments = 0;
-    foreach (UBImportAdaptor *importAdaptor, mImportAdaptors)
+    foreach(const QString& fileName, fileNames)
     {
-        if (importAdaptor->supportedExtentions().lastIndexOf(fileInfo.suffix().toLower()) != -1)
+        UBApplication::showMessage(tr("Importing file").arg(fileName));
+
+        QFile file(fileName);
+        QFileInfo fileInfo(file);
+
+        foreach (UBImportAdaptor *adaptor, mImportAdaptors)
         {
-            UBApplication::setDisabled(true);
+            if (adaptor->supportedExtentions().lastIndexOf(fileInfo.suffix().toLower()) != -1)
-            bool result = importAdaptor->addFileToDocument(pDocument, pFile);
+            {
-            UBApplication::setDisabled(false);
+                UBApplication::setDisabled(true);
-            return result;
+
+                if (adaptor->isDocumentBased())
+                {
+                    UBDocumentBasedImportAdaptor* importAdaptor = (UBDocumentBasedImportAdaptor*)adaptor;
+
+                    if (importAdaptor->addFileToDocument(document, file))
+                        nImportedDocuments++;
+                }
+                else
+                {
+                    UBPageBasedImportAdaptor* importAdaptor = (UBPageBasedImportAdaptor*)adaptor;
+
+                    QUuid uuid = QUuid::createUuid();
+                    QString filepath = file.fileName();
+                    if (importAdaptor->folderToCopy() != "")
+                    {
+                        bool b = UBPersistenceManager::persistenceManager()->addFileToDocument(document, file.fileName(), importAdaptor->folderToCopy() , uuid, filepath);
+                        if (!b)
+                        {
+                            continue;
+                        }
+                    }
+
+                    QList<UBGraphicsItem*> pages = importAdaptor->import(uuid, filepath);
+                    int nPage = 0;
+                    foreach(UBGraphicsItem* page, pages)
+                    {
+                        UBApplication::showMessage(tr("Inserting page %1 of %2").arg(++nPage).arg(pages.size()), true);
+                        int pageIndex = document->pageCount();
+                        UBGraphicsScene* scene = UBPersistenceManager::persistenceManager()->createDocumentSceneAt(document, pageIndex);
+                        importAdaptor->placeImportedItemToScene(scene, page);
+                        UBPersistenceManager::persistenceManager()->persistDocumentScene(document, scene, pageIndex);
+                    }
+
+                    UBPersistenceManager::persistenceManager()->persistDocumentMetadata(document);
+                    UBApplication::showMessage(tr("Import of file %1 successful.").arg(file.fileName()));
+                    nImportedDocuments++;
+                }
+
+                UBApplication::setDisabled(false);
+            }
         }
     }
-    return false;
+    return nImportedDocuments;
 }
 
 
@@ -167,14 +255,14 @@ int UBDocumentManager::addImageDirToDocument(const QDir& pDir, UBDocumentProxy*
 
     filenames = UBStringUtils::sortByLastDigit(filenames);
 
-    QStringList fullPathFilenames;
+    QStringList fileNames;
 
     foreach(QString f, filenames)
     {
-        fullPathFilenames << pDir.absolutePath() + "/" + f;
+        fileNames << pDir.absolutePath() + "/" + f;
     }
 
-    return addImageAsPageToDocument(fullPathFilenames, pDocument);
+    return addFilesToDocument(pDocument, fileNames);
 
 }
 
@@ -209,87 +297,6 @@ QList<UBExportAdaptor*> UBDocumentManager::supportedExportAdaptors()
     return mExportAdaptors;
 }
 
-int UBDocumentManager::addImageAsPageToDocument(const QStringList& filenames, UBDocumentProxy* pDocument)
-{
-
-    int result = 0;
-
-    if (filenames.size() > 0)
-    {
-        QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
-
-        QApplication::processEvents();
-
-        int pageIndex = pDocument->pageCount();
-
-                if (pageIndex == 1 && UBPersistenceManager::persistenceManager()->loadDocumentScene(pDocument, 0)->isEmpty())
-                {
-                        pageIndex = 0;
-                }
-
-        int expectedPageCount = filenames.size();
-
-        for(int i = 0; i < filenames.size(); i ++)
-        {
-            UBApplication::showMessage(tr("Importing page %1 of %2").arg(i + 1).arg(expectedPageCount));
-
-            UBGraphicsScene* scene = 0;
-
-            QString fullPath = filenames.at(i);
-
-            QGraphicsItem *gi = 0;
-
-            if (pageIndex == 0)
-            {
-                scene = UBPersistenceManager::persistenceManager()->loadDocumentScene(pDocument, pageIndex);
-            }
-            else
-            {
-                scene = UBPersistenceManager::persistenceManager()->createDocumentSceneAt(pDocument, pageIndex);
-            }
-
-            scene->setBackground(false, false);
-
-            if (fullPath.endsWith(".svg") || fullPath.endsWith(".svgz"))
-            {
-                                gi = scene->addSvg(QUrl::fromLocalFile(fullPath), QPointF(0, 0));
-            }
-            else
-            {
-                QPixmap pix(fullPath);
-
-                if (pix.isNull())
-                {
-                    UBApplication::showMessage(tr("Erronous image data, skipping file %1").arg(filenames.at(i)));
-                    expectedPageCount--;
-                    continue;
-                }
-                else
-                {
-                    gi = scene->addPixmap(pix, NULL, QPointF(0, 0));
-                }
-            }
-
-            if (gi)
-            {
-                scene->setAsBackgroundObject(gi, true);
-
-                UBPersistenceManager::persistenceManager()->persistDocumentScene(pDocument, scene, pageIndex);
-
-                pageIndex++;
-            }
-
-        }
-
-        result = expectedPageCount;
-
-        QApplication::restoreOverrideCursor();
-
-    }
-
-    return result;
-
-}
 
 void UBDocumentManager::emitDocumentUpdated(UBDocumentProxy* pDocument)
 {

src/core/UBDocumentManager.h

@@ -36,13 +36,11 @@ class UBDocumentManager : public QObject
 
         UBDocumentProxy* importFile(const QFile& pFile, const QString& pGroup);
 
-        bool addFileToDocument(UBDocumentProxy* pDocument, const QFile& pFile);
+        int addFilesToDocument(UBDocumentProxy* pDocument, QStringList fileNames);
 
         UBDocumentProxy* importDir(const QDir& pDir, const QString& pGroup);
         int addImageDirToDocument(const QDir& pDir, UBDocumentProxy* pDocument);
 
-        int addImageAsPageToDocument(const QStringList& images, UBDocumentProxy* document);
-
         QList<UBExportAdaptor*> supportedExportAdaptors();
         void emitDocumentUpdated(UBDocumentProxy* pDocument);
 

src/core/UBPersistenceManager.cpp

@@ -878,170 +878,82 @@ QString UBPersistenceManager::addObjectToTeacherGuideDirectory(UBDocumentProxy*
     return destPath;
 }
 
-
+bool UBPersistenceManager::addFileToDocument(UBDocumentProxy* pDocumentProxy, 
-QString UBPersistenceManager::addVideoFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, QUuid objectUuid)
+                                                     QString path, 
+                                                     const QString& subdir,
+                                                     QUuid objectUuid,
+                                                     QString& destinationPath,
+                                                     QByteArray* data)
 {
     QFileInfo fi(path);
 
-    if (!fi.exists() || !pDocumentProxy || objectUuid.isNull())
-        return "";
-
-    QString fileName = UBPersistenceManager::videoDirectory + "/" + objectUuid.toString() + "." + fi.suffix();
-
-    QString destPath = pDocumentProxy->persistencePath() + "/" + fileName;
-
-    if (!QFile::exists(destPath))
-    {
-        QDir dir;
-        dir.mkdir(pDocumentProxy->persistencePath() + "/" + UBPersistenceManager::videoDirectory);
-
-        QFile source(path);
-
-        source.copy(destPath);
-
-    }
-
-    return destPath;
-
-}
-
-
-QString UBPersistenceManager::addVideoFileToDocument(UBDocumentProxy* pDocumentProxy, QUrl sourceUrl, QByteArray pPayload, QUuid objectUuid)
-{
     if (!pDocumentProxy || objectUuid.isNull())
-        return "";
+        return false;
+    if (data == NULL && !fi.exists())
+        return false;
 
-    QString urlPath = sourceUrl.path();
+    QString fileName = subdir + "/" + objectUuid.toString() + "." + fi.suffix();
-    int lastDot = urlPath.lastIndexOf(".");
-    QString suffix = urlPath.right(urlPath.length() - lastDot - 1);
 
-    QString fileName = UBPersistenceManager::videoDirectory + "/" + objectUuid.toString() + "." + suffix;
+    destinationPath = pDocumentProxy->persistencePath() + "/" + fileName;
-    QString destPath = pDocumentProxy->persistencePath() + "/" + fileName;
 
-    if (!QFile::exists(destPath))
+    if (!QFile::exists(destinationPath))
     {
         QDir dir;
-        dir.mkdir(pDocumentProxy->persistencePath() + "/" + UBPersistenceManager::videoDirectory);
+        dir.mkdir(pDocumentProxy->persistencePath() + "/" + subdir);
+        if (!QFile::exists(pDocumentProxy->persistencePath() + "/" + subdir))
+            return false;
 
-        QFile newFile(destPath);
+        if (data == NULL)
-
-        if (newFile.open(QIODevice::WriteOnly))
         {
-            newFile.write(pPayload);
+            QFile source(path);
-            newFile.flush();
+            return source.copy(destinationPath);
-            newFile.close();
         }
-    }
+        else
-
-    return destPath;
-
-}
-
-
-
-QString UBPersistenceManager::addAudioFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, QUuid objectUuid)
-{
-    QFileInfo fi(path);
-
-    if (!fi.exists() || !pDocumentProxy || objectUuid.isNull())
-        return "";
-
-    QString fileName = UBPersistenceManager::audioDirectory + "/" + objectUuid.toString() + "." + fi.suffix();
-
-    QString destPath = pDocumentProxy->persistencePath() + "/" + fileName;
-
-    if (!QFile::exists(destPath))
-    {
-        QDir dir;
-        dir.mkdir(pDocumentProxy->persistencePath() + "/" + UBPersistenceManager::audioDirectory);
-
-        QFile source(path);
-
-        source.copy(destPath);
-
-    }
-
-    return destPath;
-
-}
-
-
-QString UBPersistenceManager::addAudioFileToDocument(UBDocumentProxy* pDocumentProxy, QUrl sourceUrl, QByteArray pPayload, QUuid objectUuid)
-{
-    if (!pDocumentProxy || objectUuid.isNull())
-        return "";
-
-    QString urlPath = sourceUrl.path();
-    int lastDot = urlPath.lastIndexOf(".");
-    QString suffix = urlPath.right(urlPath.length() - lastDot - 1);
-
-    QString fileName = UBPersistenceManager::audioDirectory + "/" + objectUuid.toString() + "." + suffix;
-    QString destPath = pDocumentProxy->persistencePath() + "/" + fileName;
-
-    if (!QFile::exists(destPath))
-    {
-        QDir dir;
-        dir.mkdir(pDocumentProxy->persistencePath() + "/" + UBPersistenceManager::audioDirectory);
-
-        QFile newFile(destPath);
-
-        if (newFile.open(QIODevice::WriteOnly))
         {
-            newFile.write(pPayload);
+            QFile newFile(destinationPath);
-            newFile.flush();
+
-            newFile.close();
+            if (newFile.open(QIODevice::WriteOnly))
+            {
+                qint64 n = newFile.write(*data);
+                newFile.flush();
+                newFile.close();
+                return n == data->size();
+            }
+            else
+            {
+                return false;
+            }
         }
     }
-
+    else
-    //return fileName;
-    return destPath;
-
-}
-
-
-QString UBPersistenceManager::addPdfFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, QUuid objectUuid)
-{
-    QFileInfo fi(path);
-
-    if (!fi.exists() || !pDocumentProxy || objectUuid.isNull())
-        return "";
-
-    QString fileName = UBPersistenceManager::objectDirectory + "/" + objectUuid.toString() + "." + fi.suffix();
-    QString destPath = pDocumentProxy->persistencePath() + "/" + fileName;
-
-    if (!QFile::exists(destPath))
     {
-        QDir dir;
+        return false;    
-        dir.mkpath(pDocumentProxy->persistencePath() + "/" + UBPersistenceManager::objectDirectory);
-
-        QFile source(path);
-        source.copy(destPath);
     }
-
-    return fileName;
 }
-QString UBPersistenceManager::addGraphicsWidgteToDocument(UBDocumentProxy *pDocumentProxy, QString path, QUuid objectUuid)
+
+bool UBPersistenceManager::addGraphicsWidgteToDocument(UBDocumentProxy *pDocumentProxy, 
+                                                       QString path, 
+                                                       QUuid objectUuid,
+                                                       QString& destinationPath)
 {
     QFileInfo fi(path);
 
     if (!fi.exists() || !pDocumentProxy || objectUuid.isNull())
-        return "";
+        return false;
 
     QString widgetRootDir = path;
     QString extension = QFileInfo(widgetRootDir).suffix();
 
-    QString widgetTargetDir = pDocumentProxy->persistencePath() + "/" + widgetDirectory +  "/" + objectUuid.toString() + "." + extension;
+    destinationPath = pDocumentProxy->persistencePath() + "/" + widgetDirectory +  "/" + objectUuid.toString() + "." + extension;
 
-    if (!QFile::exists(widgetTargetDir)) {
+    if (!QFile::exists(destinationPath)) {
         QDir dir;
-        dir.mkpath(widgetTargetDir);
+        if (!dir.mkpath(destinationPath))
-        UBFileSystemUtils::copyDir(widgetRootDir, widgetTargetDir);
+            return false;
+        return UBFileSystemUtils::copyDir(widgetRootDir, destinationPath);
     }
-
+    else
-    if (!QFile::exists(widgetTargetDir))
+        return false;
-        widgetTargetDir = QString();
-
-    return widgetTargetDir;
 }
 
 

src/core/UBPersistenceManager.h

@@ -100,12 +100,8 @@ class UBPersistenceManager : public QObject
         virtual bool isEmpty(UBDocumentProxy* pDocumentProxy);
         virtual void purgeEmptyDocuments();
 
-        virtual QString addVideoFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, QUuid objectUuid);
+        bool addGraphicsWidgteToDocument(UBDocumentProxy *mDocumentProxy, QString path, QUuid objectUuid, QString& destinationPath);
-        virtual QString addVideoFileToDocument(UBDocumentProxy* pDocumentProxy, QUrl sourceUrl, QByteArray pPayload, QUuid objectUuid);
+        bool addFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, const QString& subdir,  QUuid objectUuid, QString& destinationPath, QByteArray* data = NULL);
-        virtual QString addAudioFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, QUuid objectUuid);
-        virtual QString addAudioFileToDocument(UBDocumentProxy* pDocumentProxy, QUrl sourceUrl, QByteArray pPayload, QUuid objectUuid);
-        virtual QString addPdfFileToDocument(UBDocumentProxy* pDocumentProxy, QString path, QUuid objectUuid);
-        virtual QString addGraphicsWidgteToDocument(UBDocumentProxy *mDocumentProxy, QString path, QUuid objectUuid);
 
         bool mayHaveVideo(UBDocumentProxy* pDocumentProxy);
         bool mayHaveAudio(UBDocumentProxy* pDocumentProxy);

src/document/UBDocumentContainer.cpp

@@ -52,12 +52,18 @@ void UBDocumentContainer::duplicatePages(QList<int>& pageIndexes)
     emit documentThumbnailsUpdated(this);
 }
 
-void UBDocumentContainer::movePageToIndex(int source, int target)
+bool UBDocumentContainer::movePageToIndex(int source, int target)
 {
+    if (source==0)
+    {
+        // Title page - cant be moved
+        return false;
+    }
     UBPersistenceManager::persistenceManager()->moveSceneToIndex(mCurrentDocument, source, target);
     deleteThumbPage(source);
     insertThumbPage(target);
     emit documentThumbnailsUpdated(this);
+    return true;
 }
 
 void UBDocumentContainer::deletePages(QList<int>& pageIndexes)

src/document/UBDocumentContainer.h

@@ -37,7 +37,7 @@ class UBDocumentContainer : public QObject
         static int sceneIndexFromPage(int sceneIndex); 
 
         void duplicatePages(QList<int>& pageIndexes);
-        void movePageToIndex(int source, int target);
+        bool movePageToIndex(int source, int target);
         void deletePages(QList<int>& pageIndexes);
         void addPage(int index);
         void updatePage(int index);

src/document/UBDocumentController.cpp

@@ -1006,11 +1006,12 @@ bool UBDocumentController::addFileToDocument(UBDocumentProxy* document)
     if (filePath.length() > 0)
     {
         QApplication::processEvents();
-        QFile selectedFile(filePath);
 
         showMessage(tr("Importing file %1...").arg(fileInfo.baseName()), true);
 
-        success = UBDocumentManager::documentManager()->addFileToDocument(document, selectedFile);
+        QStringList fileNames;
+        fileNames << filePath;
+        success = UBDocumentManager::documentManager()->addFilesToDocument(document, fileNames);
 
         if (success)
         {
@@ -1031,12 +1032,13 @@ bool UBDocumentController::addFileToDocument(UBDocumentProxy* document)
 
 void UBDocumentController::moveSceneToIndex(UBDocumentProxy* proxy, int source, int target)
 {
-    UBDocumentContainer::movePageToIndex(source, target);
+    if (UBDocumentContainer::movePageToIndex(source, target))
-
+    {
-    proxy->setMetaData(UBSettings::documentUpdatedAt, UBStringUtils::toUtcIsoDateTime(QDateTime::currentDateTime()));
+        proxy->setMetaData(UBSettings::documentUpdatedAt, UBStringUtils::toUtcIsoDateTime(QDateTime::currentDateTime()));
-    UBMetadataDcSubsetAdaptor::persist(proxy);
+        UBMetadataDcSubsetAdaptor::persist(proxy);
     
-    mDocumentUI->thumbnailWidget->hightlightItem(target);
+        mDocumentUI->thumbnailWidget->hightlightItem(target);
+    }
 }
 
 
@@ -1438,7 +1440,7 @@ void UBDocumentController::addImages()
             UBSettings::settings()->lastImportFolderPath->set(QVariant(firstImage.absoluteDir().absolutePath()));
 
             int importedImageNumber
-                  = UBDocumentManager::documentManager()->addImageAsPageToDocument(images, document);
+                = UBDocumentManager::documentManager()->addFilesToDocument(document, images);
 
             if (importedImageNumber == 0)
             {

src/domain/UBGraphicsItemDelegate.cpp

@@ -115,6 +115,7 @@ UBGraphicsItemDelegate::UBGraphicsItemDelegate(QGraphicsItem* pDelegated, QObjec
     , mToolBarUsed(useToolBar)
 {
     // NOOP
+    connect(UBApplication::boardController, SIGNAL(zoomChanged(qreal)), this, SLOT(onZoomChanged()));
 }
 
 void UBGraphicsItemDelegate::init()
@@ -535,6 +536,12 @@ void UBGraphicsItemDelegate::commitUndoStep()
     }
 }
 
+void UBGraphicsItemDelegate::onZoomChanged()
+{
+    mAntiScaleRatio = 1 / (UBApplication::boardController->systemScaleFactor() * UBApplication::boardController->currentZoom());
+
+    positionHandles();
+}
 
 void UBGraphicsItemDelegate::buildButtons()
 {

src/domain/UBGraphicsItemDelegate.h

@@ -259,6 +259,8 @@ class UBGraphicsItemDelegate : public QObject
         void increaseZlevelTop();
         void increaseZlevelBottom();
 
+        void onZoomChanged();
+
     protected:
         virtual void buildButtons();
         virtual void decorateMenu(QMenu *menu);

src/domain/UBGraphicsScene.cpp

@@ -317,6 +317,11 @@ void UBGraphicsScene::selectionChangedProcessing()
 
 void UBGraphicsScene::updateGroupButtonState()
 {
+
+    UBStylusTool::Enum currentTool = (UBStylusTool::Enum)UBDrawingController::drawingController()->stylusTool();
+    if (UBStylusTool::Selector != currentTool)
+        return;
+
     QAction *groupAction = UBApplication::mainWindow->actionGroupItems;
     QList<QGraphicsItem*> selItems = selectedItems();
     int selCount = selItems.count();

src/domain/UBGraphicsTextItemDelegate.cpp

@@ -322,6 +322,12 @@ void UBGraphicsTextItemDelegate::positionHandles()
 
 void UBGraphicsTextItemDelegate::ChangeTextSize(qreal factor, textChangeMode changeMode)
 {
+    if (scaleSize == changeMode)
+    {
+        if (1 == factor)
+            return;
+    }
+    else
     if (0 == factor)
         return;
 
@@ -403,3 +409,20 @@ void UBGraphicsTextItemDelegate::scaleTextSize(qreal multiplyer)
 {
     ChangeTextSize(multiplyer, scaleSize);
 }
+
+QVariant UBGraphicsTextItemDelegate::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
+{
+    if (change == QGraphicsItem::ItemSelectedChange)
+    {
+        if (delegated()->isSelected())
+        {
+            QTextCursor c = delegated()->textCursor();
+            if (c.hasSelection())
+            {
+                c.clearSelection();
+                delegated()->setTextCursor(c);
+            }
+        }
+    }
+    return UBGraphicsItemDelegate::itemChange(change, value);
+}

src/domain/UBGraphicsTextItemDelegate.h

@@ -40,6 +40,8 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
         virtual ~UBGraphicsTextItemDelegate();
         bool isEditable();
         void scaleTextSize(qreal multiplyer);
+        virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value);
+
 
     public slots:
         void contentsChanged();

src/domain/UBGraphicsWebView.cpp

@@ -150,11 +150,3 @@ void UBGraphicsWebView::remove()
     if (mDelegate)
         mDelegate->remove(true);
 }
-
-bool UBGraphicsWebView::event(QEvent *event)
-{
-    if (event->type() == QEvent::ShortcutOverride)
-        event->accept();
-
-    return QGraphicsWebView::event(event);
-}

src/domain/UBGraphicsWebView.h

@@ -54,7 +54,6 @@ class UBGraphicsWebView: public QGraphicsWebView, public UBItem, public UBResiza
         virtual void wheelEvent(QGraphicsSceneWheelEvent *event);
         virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
         virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
-        virtual bool event(QEvent *event);
         virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
 
 };

src/domain/UBGraphicsWidgetItem.cpp

@@ -97,7 +97,6 @@ UBGraphicsWidgetItem::~UBGraphicsWidgetItem()
 
 void UBGraphicsWidgetItem::initialize()
 {
-    installEventFilter(this);
     UBGraphicsWebView::setMinimumSize(nominalSize());
     setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); // Necessary to set if we want z value to be assigned correctly
 
@@ -277,9 +276,9 @@ void UBGraphicsWidgetItem::removeScript()
         page()->mainFrame()->evaluateJavaScript("if(widget && widget.onremove) { widget.onremove();}");
 }
 
-void UBGraphicsWidgetItem::processDropEvent(QDropEvent *event)
+void UBGraphicsWidgetItem::processDropEvent(QGraphicsSceneDragDropEvent *event)
 {
-    return mUniboardAPI->ProcessDropEvent(event);
+    mUniboardAPI->ProcessDropEvent(event);
 }
 bool UBGraphicsWidgetItem::isDropableData(const QMimeData *data) const
 {
@@ -486,6 +485,31 @@ void UBGraphicsWidgetItem::unFreeze()
     mIsFrozen = false;
 }
 
+bool UBGraphicsWidgetItem::event(QEvent *event)
+{
+    if (mShouldMoveWidget && event->type() == QEvent::MouseMove) {
+        QMouseEvent *mouseMoveEvent = static_cast<QMouseEvent*>(event);
+        if (mouseMoveEvent->buttons() & Qt::LeftButton) {
+            QPointF scenePos = mapToScene(mouseMoveEvent->pos());
+            QPointF newPos = pos() + scenePos - mLastMousePos;
+            setPos(newPos);
+            mLastMousePos = scenePos;
+            event->accept();
+            return true;
+        }
+    }    
+    else if (event->type() == QEvent::ShortcutOverride)
+        event->accept();
+
+    return UBGraphicsWebView::event(event);
+}
+
+void UBGraphicsWidgetItem::dropEvent(QGraphicsSceneDragDropEvent *event)
+{
+    processDropEvent(event);
+    QGraphicsWebView::dropEvent(event);
+}
+
 void UBGraphicsWidgetItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     UBGraphicsWebView::mousePressEvent(event);
@@ -522,30 +546,6 @@ void UBGraphicsWidgetItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
     UBGraphicsWebView::hoverMoveEvent(event);
 }
 
-bool UBGraphicsWidgetItem::eventFilter(QObject *obj, QEvent *event)
-{
-    if (mShouldMoveWidget && obj == this && event->type() == QEvent::MouseMove) {
-        QMouseEvent *mouseMoveEvent = static_cast<QMouseEvent*>(event);
-
-        if (mouseMoveEvent->buttons() & Qt::LeftButton) {
-            QPointF scenePos = mapToScene(mouseMoveEvent->pos());
-
-            QPointF newPos = pos() + scenePos - mLastMousePos;
-
-            setPos(newPos);
-
-            mLastMousePos = scenePos;
-
-            event->accept();
-
-            return true;
-        }
-    }
-
-    /* standard event processing */
-    return QObject::eventFilter(obj, event);
-}
-
 void UBGraphicsWidgetItem::sendJSEnterEvent()
 {
     if (page() && page()->mainFrame())

src/domain/UBGraphicsWidgetItem.h

@@ -76,7 +76,7 @@ class UBGraphicsWidgetItem : public UBGraphicsWebView
         virtual void remove();
         void removeScript();
 
-        void processDropEvent(QDropEvent *event);
+        void processDropEvent(QGraphicsSceneDragDropEvent *event);
         bool isDropableData(const QMimeData *data) const;
 
         virtual QUrl getOwnFolder() const;
@@ -136,12 +136,13 @@ class UBGraphicsWidgetItem : public UBGraphicsWebView
         QMap<QString, QString> mDatastore;
         QMap<QString, QString> mPreferences;
 
+        virtual bool event(QEvent *event);
+        virtual void dropEvent(QGraphicsSceneDragDropEvent *event);
         virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
         virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
         virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
         virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
         virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
-        virtual bool eventFilter(QObject *obj, QEvent *event);
         virtual void sendJSEnterEvent();
         virtual void sendJSLeaveEvent();
         virtual void injectInlineJavaScript();

src/gui/UBDockPalette.cpp

@@ -17,12 +17,16 @@
 #include <QPainterPath>
 
 #include "UBDockPalette.h"
-#include "core/UBSettings.h"
+
 #include "frameworks/UBPlatformUtils.h"
+
+#include "core/UBSettings.h"
 #include "core/UBApplication.h"
 #include "core/UBPreferencesController.h"
 #include "core/UBDownloadManager.h"
 
+#include "board/UBBoardController.h"
+
 #include "core/memcheck.h"
 
 /**
@@ -79,6 +83,8 @@ UBDockPalette::UBDockPalette(eUBDockPaletteType paletteType, QWidget *parent, co
 	onToolbarPosUpdated();
 	connect(UBSettings::settings()->appToolBarPositionedAtTop, SIGNAL(changed(QVariant)), this, SLOT(onToolbarPosUpdated()));
 	connect(UBDownloadManager::downloadManager(), SIGNAL(allDownloadsFinished()), this, SLOT(onAllDownloadsFinished()));
+
+	connect(UBApplication::boardController,SIGNAL(documentSet(UBDocumentProxy*)),this,SLOT(onDocumentSet(UBDocumentProxy*)));
 }
 
 /**
@@ -98,6 +104,11 @@ UBDockPalette::~UBDockPalette()
 	}
 }
 
+void UBDockPalette::onDocumentSet(UBDocumentProxy* documentProxy)
+{
+	Q_UNUSED(documentProxy);
+}
+
 /**
  * \brief Get the current orientation
  * @return the current orientation

src/gui/UBDockPalette.h

@@ -15,6 +15,8 @@
 #ifndef UBDOCKPALETTE_H
 #define UBDOCKPALETTE_H
 
+class UBDocumentProxy;
+
 #include <QWidget>
 #include <QMouseEvent>
 #include <QBrush>
@@ -131,6 +133,7 @@ public slots:
     void onShowTabWidget(UBDockPaletteWidget* widget);
     void onHideTabWidget(UBDockPaletteWidget* widget);
     void onAllDownloadsFinished();
+    virtual void onDocumentSet(UBDocumentProxy* documentProxy);
 
 protected:
     virtual int border();

src/gui/UBLeftPalette.cpp

@@ -51,6 +51,14 @@ UBLeftPalette::~UBLeftPalette()
 
 }
 
+
+void UBLeftPalette::onDocumentSet(UBDocumentProxy* documentProxy)
+{
+	//This is necessary to force the teacher guide to be showed in priority each time a document is set
+	if(documentProxy && UBSettings::settings()->teacherGuidePageZeroActivated->get().toBool())
+		mLastOpenedTabForMode.insert(eUBDockPaletteWidget_BOARD, 1);
+}
+
 /**
  * \brief Update the maximum width
  */

src/gui/UBLeftPalette.h

@@ -25,6 +25,9 @@ public:
 
     bool switchMode(eUBDockPaletteWidgetMode mode);
 
+public slots:
+    void onDocumentSet(UBDocumentProxy* documentProxy);
+
 protected:
     void updateMaxWidth();
     void resizeEvent(QResizeEvent *event);

src/gui/UBTeacherGuideWidget.cpp

@@ -1149,7 +1149,6 @@ void UBTeacherGuideWidget::onActiveSceneChanged()
     		mpPageZeroWidget->switchToMode(tUBTGZeroPageMode_EDITION);
 
         setCurrentWidget(mpPageZeroWidget);
-
     }
     else{
     	if(mpEditionWidget->isModified()){

src/gui/UBThumbnailWidget.cpp

@@ -210,13 +210,18 @@ void UBThumbnailWidget::mousePressEvent(QMouseEvent *event)
     mMousePressPos = event->pos();
 
     UBSceneThumbnailPixmap* sceneItem = dynamic_cast<UBSceneThumbnailPixmap*>(itemAt(mMousePressPos));
-    if(sceneItem){
+    if(sceneItem==NULL)
-    	int pageIndex = UBDocumentContainer::pageFromSceneIndex(sceneItem->sceneIndex());
+    {
-    	if(pageIndex == 0){
+        event->ignore();
-            event->ignore();
+        return;
-            return;
-    	}
     }
+    //if(sceneItem){
+    //	int pageIndex = UBDocumentContainer::pageFromSceneIndex(sceneItem->sceneIndex());
+    //	if(pageIndex == 0){
+    //        event->ignore();
+    //        return;
+    //	}
+    //}
 
     mMousePressScenePos = mapToScene(mMousePressPos);
     QGraphicsItem* underlyingItem = itemAt(mMousePressPos);

src/gui/UBToolWidget.cpp

@@ -76,7 +76,7 @@ void UBToolWidget::initialize()
     if(!sUnpinPixmap)
         sUnpinPixmap = new QPixmap(":/images/unpin.svg");
     
-    QGraphicsLinearLayout *graphicsLayout = new QGraphicsLinearLayout(Qt::Vertical);
+    QGraphicsLinearLayout *graphicsLayout = new QGraphicsLinearLayout(Qt::Vertical, this);
 
     mFrameWidth = UBSettings::settings()->objectFrameWidth;
     mContentMargin = sClosePixmap->width() / 2 + mFrameWidth;