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

Sankore_3.1.pro

@@ -367,6 +367,7 @@ linux-g++-32 {
 
 linux-g++-64 { 
     LIBS += -lcrypto
+    LIBS += -lX11
     QMAKE_CFLAGS += -fopenmp
     QMAKE_CXXFLAGS += -fopenmp
     QMAKE_LFLAGS += -fopenmp

resources/forms/mainWindow.ui

@@ -69,6 +69,7 @@
    <addaction name="actionForward"/>
    <addaction name="separator"/>
    <addaction name="actionErase"/>
+   <addaction name="actionGroupItems"/>
    <addaction name="actionBoard"/>
    <addaction name="actionTutorial"/>
    <addaction name="actionWeb"/>
@@ -1633,6 +1634,21 @@
     <string>Import old Sankore or Uniboard documents</string>
    </property>
   </action>
+  <action name="actionGroupItems">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="icon">
+    <iconset resource="../sankore.qrc">
+     <normaloff>:/images/toolbar/library.png</normaloff>:/images/toolbar/library.png</iconset>
+   </property>
+   <property name="text">
+    <string>Gtorup items</string>
+   </property>
+   <property name="toolTip">
+    <string>Erase Content</string>
+   </property>
+  </action>
  </widget>
  <resources>
   <include location="../sankore.qrc"/>

resources/style.qss

@@ -4,7 +4,8 @@ QWidget#UBLibPathViewer,
 QWidget#UBLibNavigatorWidget,
 QWidget#UBLibItemProperties,
 QWidget#UBDownloadWidget,
-QWidget#UBTeacherGuideWidget
+QWidget#UBTeacherGuideWidget,
+QWidget#UBFeatureProperties
 {
 	background: #EEEEEE;
 	border-radius: 10px;
@@ -25,6 +26,13 @@ QWidget#UBLibWebView
 	border: 2px solid #999999;
 }
 
+QListView
+{
+	background: #EEEEEE;
+	border-radius : 10px;
+	border: 2px solid #999999;
+}
+
 QWebView#SearchEngineView
 {
 	background:white;

src/board/UBBoardController.cpp

@@ -1809,7 +1809,7 @@ UBGraphicsWidgetItem *UBBoardController::addW3cWidget(const QUrl &pUrl, const QP
 
     newUrl = QUrl::fromLocalFile(UBPersistenceManager::persistenceManager()->addGraphicsWidgteToDocument(mActiveDocument, pUrl.toLocalFile(), uuid));
 
-    w3cWidgetItem = mActiveScene->addW3CWidget(pUrl, pos);
+    w3cWidgetItem = mActiveScene->addW3CWidget(newUrl, pos);
 
     if (w3cWidgetItem) {
         w3cWidgetItem->setUuid(uuid);

src/board/UBBoardPaletteManager.cpp

@@ -138,6 +138,7 @@ void UBBoardPaletteManager::setupDockPaletteWidgets()
 
     mpDownloadWidget = new UBDockDownloadWidget();
     mpTeacherGuideWidget = new UBDockTeacherGuideWidget();
+	mpFeaturesWidget = new UBFeaturesWidget();
 
     // Add the dock palettes
     mLeftPalette = new UBLeftPalette(mContainer);
@@ -153,8 +154,15 @@ void UBBoardPaletteManager::setupDockPaletteWidgets()
 
     mRightPalette = new UBRightPalette(mContainer);
     // RIGHT palette widgets
-    mRightPalette->registerWidget(mpLibWidget);
-    mRightPalette->addTab(mpLibWidget);
+
+	mRightPalette->registerWidget(mpFeaturesWidget);
+	mRightPalette->addTab(mpFeaturesWidget);
+
+    //Do not show deprecated lib widget to prevent collisions. Uncomment to return lib widget
+//    mRightPalette->registerWidget(mpLibWidget);
+//    mRightPalette->addTab(mpLibWidget);
+
+
     // The cache widget will be visible only if a cache is put on the page
     mRightPalette->registerWidget(mpCachePropWidget);
 

src/board/UBBoardPaletteManager.h

@@ -27,6 +27,7 @@
 #include "gui/UBCachePropertiesWidget.h"
 #include "gui/UBDockDownloadWidget.h"
 #include "core/UBApplicationController.h"
+#include "gui/UBFeaturesWidget.h"
 
 
 class UBStylusPalette;
@@ -129,6 +130,8 @@ class UBBoardPaletteManager : public QObject
         /** The cache properties widget */
         UBCachePropertiesWidget* mpCachePropWidget;
 
+		UBFeaturesWidget *mpFeaturesWidget;
+
         /** The download widget */
         UBDockDownloadWidget* mpDownloadWidget;
         // HACK: here we duplicate the lib widget for the desktop mode

src/board/UBBoardView.cpp

@@ -16,6 +16,7 @@
 
 #include <QtGui>
 #include <QtXml>
+#include <QListView>
 
 #include "UBDrawingController.h"
 
@@ -433,7 +434,9 @@ void UBBoardView::mousePressEvent (QMouseEvent *event)
                 || movingItem->type() == UBGraphicsPolygonItem::Type
                 || movingItem->type() == UBGraphicsCache::Type
                 || movingItem->type() == UBGraphicsTriangle::Type
-                || movingItem == this->scene()->backgroundObject())
+                || movingItem == this->scene()->backgroundObject()
+                || movingItem->group())
+
                 {
                     movingItem = NULL;
                     QGraphicsView::mousePressEvent (event);
@@ -841,17 +844,17 @@ void UBBoardView::dropEvent (QDropEvent *event)
     QGraphicsItem* graphicsItemAtPos = itemAt(event->pos().x(),event->pos().y());
     UBGraphicsWidgetItem* graphicsWidget = dynamic_cast<UBGraphicsWidgetItem*>(graphicsItemAtPos);
 
-    qDebug() << event->source();
-
     if (graphicsWidget && graphicsWidget->acceptDrops()) {
+
         graphicsWidget->processDropEvent(event);
         event->acceptProposedAction();
 
-    }
-    else if (!event->source()
+	} else if (!event->source()
              || dynamic_cast<UBThumbnailWidget *>(event->source())
              || dynamic_cast<QWebView*>(event->source())
-             || dynamic_cast<UBTGMediaWidget*>(event->source())) {
+             || dynamic_cast<UBTGMediaWidget*>(event->source())
+	         || dynamic_cast<QListView *>(event->source()) ) {
+
         mController->processMimeData (event->mimeData (), mapToScene (event->pos ()));
         event->acceptProposedAction();
     }

src/board/UBFeaturesController.h

+#ifndef UBFEATURESCONTROLLER_H
+#define UBFEATURESCONTROLLER_H
+
+#include <QMetaType>
+#include <QObject>
+#include <QWidget>
+#include <QVector>
+#include <QString>
+#include <QPixmap>
+
+//#include "UBDockPaletteWidget.h"
+
+enum UBFeatureElementType
+{
+    FEATURE_CATEGORY,
+    FEATURE_VIRTUALFOLDER,
+    FEATURE_FOLDER,
+    FEATURE_INTERACTIVE,
+	FEATURE_INTERNAL,
+    FEATURE_ITEM,
+	FEATURE_TRASH,
+	FEATURE_FAVORITE
+};
+
+class UBFeature
+{
+public:
+    UBFeature() {;}
+	//UBFeature(const UBFeature &f);
+    UBFeature(const QString &url, const QPixmap &icon, const QString &name, const QString &realPath, UBFeatureElementType type = FEATURE_CATEGORY);
+    virtual ~UBFeature() {;}
+    QString getName() const { return mName; }
+    QPixmap getThumbnail() const {return mThumbnail;}
+    QString getUrl() const { return virtualPath; }
+	//QString getPath() const { return mPath; };
+    QString getFullPath() const { return mPath; }
+    UBFeatureElementType getType() const { return elementType; }
+	bool isFolder() const;
+private:
+	QString virtualPath;
+    QPixmap mThumbnail;
+    QString mName;
+	QString mPath;
+    UBFeatureElementType elementType;
+};
+Q_DECLARE_METATYPE( UBFeature )
+
+
+class UBFeaturesController : public QObject
+{
+Q_OBJECT
+public:
+	UBFeaturesController(QWidget *parentWidget);
+    virtual ~UBFeaturesController();
+
+    QList <UBFeature>* getFeatures()const { return featuresList; }
+	
+    const QString& getRootPath()const { return rootPath; }
+
+	void addItemToPage(const UBFeature &item);
+	const UBFeature& getCurrentElement()const { return currentElement; }
+	void setCurrentElement( const UBFeature &elem ) { currentElement = elem; }
+	const UBFeature & getTrashElement () const { return trashElement; }
+	UBFeature moveItemToFolder( const QUrl &url, const UBFeature &destination );
+	UBFeature copyItemToFolder( const QUrl &url, const UBFeature &destination );
+	void deleteItem( const QUrl &url );
+	bool isTrash( const QUrl &url );
+	UBFeature newFolder( const QString &name );
+	UBFeature addToFavorite( const QUrl &path );
+	void removeFromFavorite( const QUrl &path );
+
+	static QString fileNameFromUrl( const QUrl &url );
+	static QPixmap thumbnailForFile( const QString &path );
+private:
+	void initDirectoryTree();
+	void fileSystemScan(const QString &currPath, const QString & currVirtualPath);
+	static QPixmap createThumbnail(const QString &path);
+	//void addImageToCurrentPage( const QString &path );
+	void loadFavoriteList();
+	void saveFavoriteList();
+
+	static UBFeatureElementType fileTypeFromUrl( const QString &path );
+
+	QList <UBFeature> *featuresList;
+	UBFeature *rootElement;
+
+	QString mUserAudioDirectoryPath;
+    QString mUserVideoDirectoryPath;
+    QString mUserPicturesDirectoryPath;
+    QString mUserInteractiveDirectoryPath;
+    QString mUserAnimationDirectoryPath;
+
+	QString libraryPath;
+	QString mLibAudioDirectoryPath;
+    QString mLibVideoDirectoryPath;
+    QString mLibPicturesDirectoryPath;
+    QString mLibInteractiveDirectoryPath;
+    QString mLibAnimationDirectoryPath;
+	QString mLibApplicationsDirectoryPath;
+	QString mLibShapesDirectoryPath;
+	QString trashDirectoryPath;
+
+	QString rootPath;
+	QString audiosPath;
+	QString moviesPath;
+	QString picturesPath;
+	QString appPath;
+	QString flashPath;
+	QString shapesPath;
+	QString interactPath;
+	QString trashPath;
+	QString favoritePath;
+
+	int mLastItemOffsetIndex;
+	UBFeature currentElement;
+	UBFeature trashElement;
+	UBFeature favoriteElement;
+
+	QSet <QString> *favoriteSet;
+};
+
+
+
+#endif

src/board/board.pri

@@ -3,13 +3,15 @@ HEADERS      += src/board/UBBoardController.h \
                 src/board/UBBoardPaletteManager.h \
                 src/board/UBBoardView.h \
                 src/board/UBLibraryController.h \
-                src/board/UBDrawingController.h
+                src/board/UBDrawingController.h \
+		src/board/UBFeaturesController.h
 
 SOURCES      += src/board/UBBoardController.cpp \
                 src/board/UBBoardPaletteManager.cpp \
                 src/board/UBBoardView.cpp \
                 src/board/UBLibraryController.cpp \
-                src/board/UBDrawingController.cpp
+                src/board/UBDrawingController.cpp \
+		src/board/UBFeaturesController.cpp
 
     
     

src/document/UBDocumentProxy.cpp

@@ -297,6 +297,8 @@ QString UBDocumentProxy::sessionAuthors()
 
 QDateTime UBDocumentProxy::documentDate()
 {
+    qDebug()<< UBSettings::documentDate;
+    qDebug()<<mMetaDatas;
     if(mMetaDatas.contains(UBSettings::documentDate))
         return UBStringUtils::fromUtcIsoDate(metaData(UBSettings::documentDate).toString());
     return QDateTime::currentDateTime();

src/domain/UBAppleWidget.cpp

@@ -64,7 +64,6 @@ UBAppleWidget::UBAppleWidget(const QUrl& pWidgetUrl, QWidget *parent)
     mNominalSize = defaultPixmap.size();
 }
 
-
 UBAppleWidget::~UBAppleWidget()
 {
     // NOOP

src/domain/UBGraphicsItemDelegate.cpp

@@ -207,7 +207,7 @@ void UBGraphicsItemDelegate::setMimeData(QMimeData *mimeData)
 
 bool UBGraphicsItemDelegate::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-    if((NULL != mMimeData) && ((event->pos() - mDragStartPosition).manhattanLength() < QApplication::startDragDistance()))
+    if(NULL != mMimeData)
     {
         QDrag* mDrag = new QDrag(event->widget());
         mDrag->setMimeData(mMimeData);
@@ -227,7 +227,7 @@ bool UBGraphicsItemDelegate::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
         return true;
     }
     else
-        return true;
+        return false;
 }
 
 bool UBGraphicsItemDelegate::weelEvent(QGraphicsSceneWheelEvent *event)

src/domain/UBGraphicsItemDelegate.h

@@ -184,15 +184,12 @@ class UBGraphicsItemDelegate : public QObject
         QList<DelegateButton*> mButtons;
 
 protected slots:
-
         virtual void gotoContentSource(bool checked);
 
 private:
         void updateFrame();
         void updateButtons(bool showUpdated = false);
 
-
-
         QPointF mOffset;
         QTransform mPreviousTransform;
         QPointF mPreviousPosition;

src/domain/UBGraphicsPolygonItem.cpp

@@ -184,6 +184,19 @@ void UBGraphicsPolygonItem::paint ( QPainter * painter, const QStyleOptionGraphi
     QGraphicsPolygonItem::paint(painter, option, widget);
 }
 
+QPainterPath UBGraphicsPolygonItem::shape() const
+{
+
+    QPainterPath path;
+    path.addRect(boundingRect());
+
+    return path;
+
+//    static QPainterPath shapePath = QGraphicsPolygonItem::shape();
+
+//    return shapePath;
+}
+
 
 UBGraphicsScene* UBGraphicsPolygonItem::scene()
 {

src/domain/UBGraphicsPolygonItem.h

@@ -115,6 +115,8 @@ class UBGraphicsPolygonItem : public QGraphicsPolygonItem, public UBItem
 
     protected:
         void paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget);
+        QPainterPath shape () const;
+
 
     private:
 

src/domain/UBGraphicsScene.cpp

@@ -30,6 +30,7 @@
 #include "core/UBPersistenceManager.h"
 
 #include "gui/UBMagnifer.h"
+#include "gui/UBMainWindow.h"
 
 #include "tools/UBGraphicsRuler.h"
 #include "tools/UBGraphicsProtractor.h"
@@ -56,6 +57,8 @@
 #include "UBGraphicsTextItem.h"
 #include "UBGraphicsStrokesGroup.h"
 
+#include "domain/ubgraphicsgroupcontaineritem.h"
+
 #include "UBAppleWidget.h"
 #include "UBW3CWidget.h"
 #include "UBGraphicsStroke.h"
@@ -158,9 +161,6 @@ qreal UBZLayerController::changeZLevelTo(QGraphicsItem *item, moveDestination de
                 while (iCurElement.hasNext() && iCurElement.peekNext().value()->data(UBGraphicsItemData::ItemOwnZValue).toReal() == nextZ) {
                     UBGraphicsItem::assignZValue(iCurElement.next().value(), nextZ);
                 }
-
-                item->scene()->clearSelection();
-                item->setSelected(true);
             }
         }
 
@@ -256,6 +256,7 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
     , mDocument(parent)
     , mDarkBackground(false)
     , mCrossedBackground(false)
+    , mIsDesktopMode(false)
     , mIsModified(true)
     , mBackgroundObject(0)
     , mPreviousWidth(0)
@@ -269,7 +270,6 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
     , magniferControlViewWidget(0)
     , magniferDisplayViewWidget(0)
     , mZLayerController(new UBZLayerController(this))
-    , mIsDesktopMode(false)
     , mpLastPolygon(NULL)
 {
     UBCoreGraphicsScene::setObjectName("BoardScene");
@@ -291,6 +291,9 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
     }
 
     connect(this, SIGNAL(selectionChanged()), this, SLOT(selectionChangedProcessing()));
+    connect(this, SIGNAL(selectionChanged()), this, SLOT(enableGroupingButton()));
+
+    connect(UBApplication::mainWindow->actionGroupItems, SIGNAL(triggered()), this, SLOT(processGroupItems()));
 }
 
 UBGraphicsScene::~UBGraphicsScene()
@@ -309,6 +312,36 @@ void UBGraphicsScene::selectionChangedProcessing()
         UBApplication::showMessage("ZValue is " + QString::number(selectedItems().first()->zValue(), 'f') + "own z value is "
                                                 + QString::number(selectedItems().first()->data(UBGraphicsItemData::ItemOwnZValue).toReal(), 'f'));
 }
+void UBGraphicsScene::enableGroupingButton()
+{
+    QAction *groupAction = UBApplication::mainWindow->actionGroupItems;
+
+    if (selectedItems().count() > 1) {
+        groupAction->setEnabled(true);
+    } else {
+        groupAction->setEnabled(false);
+    }
+}
+void UBGraphicsScene::processGroupItems()
+{
+    qDebug() << "processing grouping items";
+
+    UBGraphicsGroupContainerItem *groupItem = new UBGraphicsGroupContainerItem();
+
+    foreach (QGraphicsItem *item, selectedItems()) {
+        item->setSelected(false);
+        item->setFlag(QGraphicsItem::ItemIsSelectable, false);
+        item->setFlag( QGraphicsItem::ItemIsMovable, false);
+        item->setFlag(QGraphicsItem::ItemIsFocusable);
+        groupItem->addToGroup(item);
+    }
+
+    addItem(groupItem);
+//    groupItem->setPos(50, 50);
+    groupItem->setVisible(true);
+    groupItem->setFocus();
+    qDebug() << groupItem->boundingRect();
+}
 
 // MARK: -
 // MARK: Mouse/Tablet events handling
@@ -1984,6 +2017,14 @@ void UBGraphicsScene::setOwnZlevel(QGraphicsItem *item)
 {
     item->setZValue(item->data(UBGraphicsItemData::ItemOwnZValue).toReal());
 }
+void UBGraphicsScene::groupItems(QList<QGraphicsItem *> &itemList)
+{
+    foreach (QGraphicsItem *item, itemList) {
+        qDebug() << "selected item found";
+        item->setSelected(false);
+    }
+}
+
 
 qreal UBGraphicsScene::changeZLevelTo(QGraphicsItem *item, UBZLayerController::moveDestination dest)
 {

src/domain/UBGraphicsScene.h

@@ -287,6 +287,8 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
 
         void setSelectedZLevel(QGraphicsItem *item);
         void setOwnZlevel(QGraphicsItem *item);
+
+        void groupItems(QList<QGraphicsItem *> &itemList);
 public slots:
 
         void hideEraser();
@@ -303,6 +305,8 @@ public slots:
         void setToolCursor(int tool);
 
         void selectionChangedProcessing();
+        void enableGroupingButton();
+        void processGroupItems();
 
         void moveMagnifier(QPoint newPos);
         void closeMagnifier();

src/domain/domain.pri

@@ -24,6 +24,8 @@ HEADERS      += src/domain/UBGraphicsScene.h \
     src/domain/UBGraphicsAudioItemDelegate.h \
     src/domain/UBAbstractUndoCommand.h\
     src/domain/UBAngleWidget.h \
+    src/domain/ubgraphicsgroupcontaineritem.h \
+    src/domain/ubgraphicsgroupcontaineritemdelegate.h \
     src/domain/UBGraphicsStrokesGroup.h
                 
 HEADERS      += src/domain/UBGraphicsItemDelegate.h \
@@ -58,6 +60,8 @@ SOURCES      += src/domain/UBGraphicsScene.cpp \
     src/domain/UBGraphicsAudioItemDelegate.cpp \
     src/domain/UBAbstractUndoCommand.cpp \
     src/domain/UBAngleWidget.cpp \
+    src/domain/ubgraphicsgroupcontaineritem.cpp \
+    src/domain/ubgraphicsgroupcontaineritemdelegate.cpp \
     src/domain/UBGraphicsStrokesGroup.cpp
                 
 SOURCES      += src/domain/UBGraphicsItemDelegate.cpp \

src/domain/ubgraphicsgroupcontaineritem.cpp

+#include "ubgraphicsgroupcontaineritem.h"
+
+#include <QtGui>
+
+#include "domain/UBGraphicsItemDelegate.h"
+#include "domain/ubgraphicsgroupcontaineritemdelegate.h"
+#include "domain/UBGraphicsScene.h"
+
+UBGraphicsGroupContainerItem::UBGraphicsGroupContainerItem(QGraphicsItem *parent)
+    : QGraphicsItemGroup(parent)
+{
+    setData(UBGraphicsItemData::ItemLayerType, UBItemLayerType::Object);
+
+    mDelegate = new UBGraphicsGroupContainerItemDelegate(this, 0);
+    mDelegate->init();
+
+    setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
+    setFlag(QGraphicsItem::ItemIsSelectable, true);
+    setFlag(QGraphicsItem::ItemIsMovable, true);
+
+    UBGraphicsGroupContainerItem::setAcceptHoverEvents(true);
+
+    setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); //Necessary to set if we want z value to be assigned correctly
+}
+
+
+UBGraphicsScene *UBGraphicsGroupContainerItem::scene()
+{
+    UBGraphicsScene *castScene = dynamic_cast<UBGraphicsScene*>(scene());
+
+    return castScene;
+}
+UBGraphicsGroupContainerItem *UBGraphicsGroupContainerItem::deepCopy() const
+{
+
+    UBGraphicsGroupContainerItem *copy = new UBGraphicsGroupContainerItem(parentItem());
+
+    copy->setPos(this->pos());
+    copy->setTransform(this->transform());
+    copy->setFlag(QGraphicsItem::ItemIsMovable, true);
+    copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
+    copy->setData(UBGraphicsItemData::ItemLayerType, this->data(UBGraphicsItemData::ItemLayerType));
+    copy->setData(UBGraphicsItemData::ItemLocked, this->data(UBGraphicsItemData::ItemLocked));
+    copy->setUuid(this->uuid()); // this is OK for now as long as Widgets are imutable
+
+//    copy->resize(this->size());
+
+    return copy;
+}
+void UBGraphicsGroupContainerItem::remove()
+{
+    if (mDelegate)
+        mDelegate->remove();
+}
+
+
+void UBGraphicsGroupContainerItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (mDelegate->mousePressEvent(event)) {
+        //NOOP
+    } else {
+        QGraphicsItemGroup::mousePressEvent(event);
+        setSelected(true);
+    }
+}
+
+void UBGraphicsGroupContainerItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+    if (mDelegate->mouseMoveEvent(event)) {
+        // NOOP;
+    } else {
+        QGraphicsItemGroup::mouseMoveEvent(event);
+    }
+}
+
+void UBGraphicsGroupContainerItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+    mDelegate->mouseReleaseEvent(event);
+    QGraphicsItemGroup::mouseReleaseEvent(event);
+}
+
+QVariant UBGraphicsGroupContainerItem::itemChange(GraphicsItemChange change, const QVariant &value)
+{
+    QVariant newValue = mDelegate->itemChange(change, value);
+    return QGraphicsItemGroup::itemChange(change, newValue);
+}

src/domain/ubgraphicsgroupcontaineritem.h

+#ifndef UBGRAPHICSGROUPCONTAINERITEM_H
+#define UBGRAPHICSGROUPCONTAINERITEM_H
+
+#include <QGraphicsItem>
+
+#include "domain/UBItem.h"
+
+class UBGraphicsGroupContainerItem : public QGraphicsItemGroup, public UBItem, public UBGraphicsItem
+{
+
+public:
+    UBGraphicsGroupContainerItem (QGraphicsItem *parent = 0);
+    virtual UBGraphicsItemDelegate* Delegate() const { return mDelegate;}
+
+    virtual UBGraphicsScene* scene();
+    virtual UBGraphicsGroupContainerItem *deepCopy() const;
+    virtual void remove();
+
+
+protected:
+
+    virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
+    virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+    virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+
+    virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
+
+private:
+
+};
+
+#endif // UBGRAPHICSGROUPCONTAINERITEM_H

src/domain/ubgraphicsgroupcontaineritemdelegate.cpp

+#include "ubgraphicsgroupcontaineritemdelegate.h"
+
+#include <QtGui>
+
+#include "UBGraphicsScene.h"
+#include "gui/UBResources.h"
+
+#include "domain/UBGraphicsDelegateFrame.h"
+#include "domain/ubgraphicsgroupcontaineritem.h"
+
+#include "core/memcheck.h"
+#include "board/UBBoardController.h"
+
+UBGraphicsGroupContainerItemDelegate::UBGraphicsGroupContainerItemDelegate(QGraphicsItem *pDelegated, QObject *parent) :
+    UBGraphicsItemDelegate(pDelegated, parent), mDestroyGroupButton(0)
+
+{
+
+}
+
+UBGraphicsGroupContainerItem *UBGraphicsGroupContainerItemDelegate::delegated()
+{
+    return dynamic_cast<UBGraphicsGroupContainerItem*>(mDelegated);
+}
+
+void UBGraphicsGroupContainerItemDelegate::decorateMenu(QMenu *menu)
+{
+    mLockAction = menu->addAction(tr("Locked"), this, SLOT(lock(bool)));
+    QIcon lockIcon;
+    lockIcon.addPixmap(QPixmap(":/images/locked.svg"), QIcon::Normal, QIcon::On);
+    lockIcon.addPixmap(QPixmap(":/images/unlocked.svg"), QIcon::Normal, QIcon::Off);
+    mLockAction->setIcon(lockIcon);
+    mLockAction->setCheckable(true);
+
+    mShowOnDisplayAction = mMenu->addAction(tr("Visible on Extended Screen"), this, SLOT(showHide(bool)));
+    mShowOnDisplayAction->setCheckable(true);
+
+    QIcon showIcon;
+    showIcon.addPixmap(QPixmap(":/images/eyeOpened.svg"), QIcon::Normal, QIcon::On);
+    showIcon.addPixmap(QPixmap(":/images/eyeClosed.svg"), QIcon::Normal, QIcon::Off);
+    mShowOnDisplayAction->setIcon(showIcon);
+}
+
+void UBGraphicsGroupContainerItemDelegate::buildButtons()
+{
+    UBGraphicsItemDelegate::buildButtons();
+
+    mDestroyGroupButton = new DelegateButton(":/images/font.svg", mDelegated, mFrame, Qt::TopLeftSection);
+
+    mButtons << mDestroyGroupButton;
+
+    connect(mDestroyGroupButton, SIGNAL(clicked()), (UBGraphicsGroupContainerItemDelegate*)this, SLOT(destroyGroup()));
+}
+
+void UBGraphicsGroupContainerItemDelegate::destroyGroup()
+{
+    qDebug() << "got an event";
+    foreach (QGraphicsItem *item, delegated()->childItems()) {
+        delegated()->removeFromGroup(item);
+        item->setFlag(QGraphicsItem::ItemIsSelectable, true);
+    }
+
+    remove(true);
+}

src/domain/ubgraphicsgroupcontaineritemdelegate.h

+#ifndef UBGRAPHICSGROUPCONTAINERITEMDELEGATE_H
+#define UBGRAPHICSGROUPCONTAINERITEMDELEGATE_H
+
+#include "domain/UBGraphicsItemDelegate.h"
+
+class UBGraphicsGroupContainerItem;
+
+class UBGraphicsGroupContainerItemDelegate : public UBGraphicsItemDelegate
+{
+Q_OBJECT
+
+public:
+    UBGraphicsGroupContainerItemDelegate(QGraphicsItem* pDelegated, QObject * parent = 0);
+    UBGraphicsGroupContainerItem *delegated();
+
+protected:
+    virtual void decorateMenu(QMenu *menu);
+    virtual void buildButtons();
+
+
+private slots:
+    void destroyGroup();
+
+private:
+    DelegateButton *mDestroyGroupButton;
+};
+
+#endif // UBGRAPHICSGROUPCONTAINERITEMDELEGATE_H

src/gui/UBFeaturesActionBar.cpp

+#include "UBFeaturesActionBar.h"
+
+UBFeaturesActionBar::UBFeaturesActionBar( UBFeaturesController *controller, QWidget* parent, const char* name ) : QWidget (parent)
+	, featuresController(controller)
+    , mButtonGroup(NULL)
+    , mSearchBar(NULL)
+    , mLayout(NULL)
+    , mpFavoriteAction(NULL)
+    , mpSocialAction(NULL)
+    , mpDeleteAction(NULL)
+    , mpSearchAction(NULL)
+    , mpCloseAction(NULL)
+    , mpRemoveFavorite(NULL)
+    , mpNewFolderAction(NULL)
+    , mpFavoriteBtn(NULL)
+    , mpSocialBtn(NULL)
+    , mpDeleteBtn(NULL)
+    , mpCloseBtn(NULL)
+    , mpRemoveFavoriteBtn(NULL)
+    , mpNewFolderBtn(NULL)
+{
+	setObjectName(name);
+    setStyleSheet(QString("background: #EEEEEE; border-radius : 10px; border : 2px solid #999999;"));
+
+    setAcceptDrops(true);
+
+    mButtonGroup = new QButtonGroup(this);
+    mSearchBar = new QLineEdit(this);
+    mSearchBar->setStyleSheet(QString("background-color:white; border-radius : 10px; padding : 2px;"));
+    //connect(mSearchBar, SIGNAL(returnPressed()), this, SLOT(onActionSearch()));
+
+    mLayout = new QHBoxLayout();
+    setLayout(mLayout);
+
+    setMaximumHeight(ACTIONBAR_HEIGHT);
+
+    // Create the actions
+    mpFavoriteAction = new QAction(QIcon(":/images/libpalette/miniFavorite.png"), tr("Add to favorites"), this);
+    mpSocialAction = new QAction(QIcon(":/images/libpalette/social.png"), tr("Share"), this);
+    mpSearchAction = new QAction(QIcon(":/images/libpalette/miniSearch.png"), tr("Search"), this);
+    mpDeleteAction = new QAction(QIcon(":/images/libpalette/miniTrash.png"), tr("Delete"), this);
+    mpCloseAction = new QAction(QIcon(":/images/close.svg"), tr("Back to folder"), this);
+    mpRemoveFavorite = new QAction(QIcon(":/images/libpalette/trash_favorite.svg"), tr("Remove from favorites"), this);
+    mpNewFolderAction = new QAction(QIcon(":/images/libpalette/miniNewFolder.png"), tr("Create new folder"), this);
+
+    // Create the buttons
+    mpFavoriteBtn = new UBActionButton(this, mpFavoriteAction);
+    mpSocialBtn = new UBActionButton(this, mpSocialAction);
+    //mpSearchBtn = new UBActionButton(this, mpSearchAction);
+    mpDeleteBtn = new UBActionButton(this, mpDeleteAction);
+    mpCloseBtn = new UBActionButton(this, mpCloseAction);
+    mpRemoveFavoriteBtn = new UBActionButton(this, mpRemoveFavorite);
+    mpNewFolderBtn = new UBActionButton(this, mpNewFolderAction);
+
+    // Initialize the buttons
+    //mpSearchBtn->setEnabled(false);
+    mpNewFolderBtn->setEnabled(false);
+
+    // Add the buttons to the button group
+    mButtonGroup->addButton(mpFavoriteBtn);
+    mButtonGroup->addButton(mpSocialBtn);
+    //mButtonGroup->addButton(mpSearchBtn);
+    mButtonGroup->addButton(mpDeleteBtn);
+    mButtonGroup->addButton(mpCloseBtn);
+    mButtonGroup->addButton(mpRemoveFavoriteBtn);
+    mButtonGroup->addButton(mpNewFolderBtn);
+    // Connect signals & slots
+    /*connect(mpFavoriteAction,SIGNAL(triggered()), this, SLOT(onActionFavorite()));
+    connect(mpSocialAction,SIGNAL(triggered()), this, SLOT(onActionSocial()));
+    connect(mpSearchAction,SIGNAL(triggered()), this, SLOT(onActionSearch()));
+    connect(mpDeleteAction,SIGNAL(triggered()), this, SLOT(onActionTrash()));
+    connect(mpCloseAction, SIGNAL(triggered()), this, SLOT(onActionClose()));
+    connect(mpRemoveFavorite, SIGNAL(triggered()), this, SLOT(onActionRemoveFavorite()));
+    connect(mSearchBar, SIGNAL(textChanged(QString)), this, SLOT(onSearchTextChanged(QString)));
+    connect(mpNewFolderAction, SIGNAL(triggered()), this, SLOT(onActionNewFolder()));*/
+
+	connect(mSearchBar, SIGNAL(textChanged(QString)), this, SLOT(onSearchTextChanged(QString)));
+	connect(mpNewFolderAction, SIGNAL(triggered()), this, SLOT(onActionNewFolder()));
+
+    // Build the default toolbar
+    mLayout->addWidget(mpFavoriteBtn);
+    mLayout->addWidget(mpSocialBtn);
+    mLayout->addWidget(mpNewFolderBtn);
+    mLayout->addWidget(mSearchBar);
+    //mLayout->addWidget(mpSearchBtn);
+    mLayout->addWidget(mpDeleteBtn);
+    mLayout->addWidget(mpCloseBtn);
+    mLayout->addWidget(mpRemoveFavoriteBtn);
+	setCurrentState( IN_ROOT );
+	mpDeleteBtn->setAcceptDrops(true);
+	setAcceptDrops( true );
+}
+
+void UBFeaturesActionBar::setCurrentState( UBFeaturesActionBarState state )
+{
+	currentState = state;
+	setButtons();
+}
+
+void UBFeaturesActionBar::setButtons()
+{
+    switch( currentState )
+    {
+	case IN_FOLDER:
+		mpFavoriteBtn->show();
+        mpSocialBtn->hide();
+        mSearchBar->show();
+        mpDeleteBtn->show();
+        mpCloseBtn->hide();
+        mpRemoveFavoriteBtn->hide();
+        mpNewFolderBtn->show();
+		mpNewFolderBtn->setEnabled(true);
+		mpDeleteBtn->setEnabled(true);
+		break;
+    case IN_ROOT:
+        mpFavoriteBtn->show();
+        mpSocialBtn->hide();
+        mSearchBar->show();
+        mpDeleteBtn->show();
+        mpCloseBtn->hide();
+        mpRemoveFavoriteBtn->hide();
+        mpNewFolderBtn->show();
+		mpNewFolderBtn->setEnabled(false);
+		mpDeleteBtn->setEnabled(false);
+        break;
+    case IN_PROPERTIES:
+        mpFavoriteBtn->show();
+        mpSocialBtn->hide();
+        mSearchBar->show();
+        //mpSearchBtn->show();
+        mpDeleteBtn->hide();
+        mpCloseBtn->hide();
+        mpRemoveFavoriteBtn->hide();
+        mpNewFolderBtn->hide();
+        break;
+    case IN_FAVORITE:
+        mpFavoriteBtn->hide();
+        mpSocialBtn->hide();
+        mSearchBar->show();
+        //mpSearchBtn->show();
+        mpDeleteBtn->hide();
+        mpCloseBtn->hide();
+        mpRemoveFavoriteBtn->show();
+        mpNewFolderBtn->hide();
+        break;
+    default:
+        break;
+    }
+}
+
+void UBFeaturesActionBar::onSearchTextChanged(QString txt)
+{
+    Q_UNUSED(txt)
+    emit searchElement(mSearchBar->text());
+}
+   
+void UBFeaturesActionBar::onActionNewFolder()
+{
+    emit newFolderToCreate();
+}
+
+/*
+void UBFeaturesActionBar::dragMoveEvent(QDragMoveEvent *event)
+{
+    event->acceptProposedAction();
+}
+*/
+
+void UBFeaturesActionBar::dragEnterEvent( QDragEnterEvent *event )
+{
+    if (event->mimeData()->hasFormat("text/uri-list"))
+        event->acceptProposedAction();
+}
+
+void UBFeaturesActionBar::dropEvent( QDropEvent *event )
+{	
+	QWidget *dest = childAt( event->pos() );
+	if ( dest == mpDeleteBtn )
+	{
+		event->setDropAction( Qt::MoveAction );
+		event->accept();
+		emit deleteElements( *event->mimeData() );
+	}
+	else if ( dest == mpFavoriteBtn )
+	{
+		event->setDropAction( Qt::CopyAction );
+		event->accept();
+		emit addToFavorite( *event->mimeData() );
+	}
+	else if ( dest == mpRemoveFavoriteBtn )
+	{
+		event->setDropAction( Qt::MoveAction );
+		event->accept();
+		emit removeFromFavorite( *event->mimeData() );
+	}
+}
+
+UBFeaturesActionBar::~UBFeaturesActionBar()
+{
+}

src/gui/UBFeaturesActionBar.h

+#ifndef UBFEATURESACTIONBAR_H
+#define UBFEATURESACTIONBAR_H
+
+#include <QWidget>
+#include <QToolButton>
+#include <QDropEvent>
+#include "UBLibActionBar.h"
+#include "board/UBFeaturesController.h"
+
+enum UBFeaturesActionBarState
+{
+	IN_ROOT,
+	IN_FOLDER,
+	IN_PROPERTIES,
+	IN_FAVORITE
+};
+
+class UBFeaturesActionBar : public QWidget
+{
+	Q_OBJECT
+public:
+	UBFeaturesActionBar(UBFeaturesController *controller, QWidget* parent=0, const char* name="UBFeaturesActionBar");
+    ~UBFeaturesActionBar();
+	
+	void setCurrentState( UBFeaturesActionBarState state );
+signals:
+	void searchElement(const QString &text);
+	void newFolderToCreate();
+	void deleteElements( const QMimeData &data );
+	void addToFavorite( const QMimeData &data );
+	void removeFromFavorite( const QMimeData &data );
+private slots:
+	void onSearchTextChanged(QString txt);
+	void onActionNewFolder();
+protected:
+	//void dragMoveEvent(QDragMoveEvent *event);
+	void dragEnterEvent( QDragEnterEvent *event );
+	void dropEvent( QDropEvent *event );
+private:
+	void setButtons();
+	UBFeaturesController *featuresController;
+	UBFeaturesActionBarState currentState;
+
+	eButtonSet mCrntButtonSet;
+    eButtonSet mPreviousButtonSet;
+
+	QButtonGroup* mButtonGroup;
+    QLineEdit* mSearchBar;
+    QHBoxLayout* mLayout;
+    QAction* mpFavoriteAction;
+    QAction* mpSocialAction;
+    QAction* mpDeleteAction;
+    QAction* mpSearchAction;
+    QAction* mpCloseAction;
+    QAction* mpRemoveFavorite;
+    QAction* mpNewFolderAction;
+    UBActionButton* mpFavoriteBtn;
+    UBActionButton* mpSocialBtn;
+    UBActionButton* mpDeleteBtn;
+    //UBActionButton* mpSearchBtn;
+    UBActionButton* mpCloseBtn;
+    UBActionButton* mpRemoveFavoriteBtn;
+    UBActionButton* mpNewFolderBtn;
+
+};
+
+
+#endif
\ No newline at end of file

src/gui/UBFeaturesWidget.h

+#ifndef UBFEATURESWIDGET_H
+#define UBFEATURESWIDGET_H
+
+#include <QWidget>
+#include <QListView>
+#include <QGraphicsView>
+#include <QAbstractListModel>
+#include <QPixmap>
+#include <QVBoxLayout>
+#include <QSlider>
+#include <QUrl>
+#include <QStyledItemDelegate>
+#include <QLocale>
+#include <QGraphicsLinearLayout>
+#include <QStackedWidget>
+#include <QDropEvent>
+
+#include "UBDockPaletteWidget.h"
+//#include "UBLibActionBar.h"
+#include "board/UBFeaturesController.h"
+#include "UBFeaturesActionBar.h"
+
+
+#define THUMBNAIL_WIDTH 400
+#define ID_LISTVIEW 0
+#define ID_PROPERTIES 1
+
+class UBListModel;
+
+class UBFeaturesModel;
+class UBFeaturesItemDelegate;
+class UBFeaturesPathItemDelegate;
+class UBFeaturesProxyModel;
+class UBFeaturesSearchProxyModel;
+class UBFeaturesPathProxyModel;
+class UBFeaturesPathViewer;
+class UBFeatureProperties;
+class UBFeatureItemButton;
+class UBFeaturesListView;
+
+class UBFeaturesWidget : public UBDockPaletteWidget
+{
+    Q_OBJECT
+public:
+	UBFeaturesWidget(QWidget* parent=0, const char* name="UBFeaturesWidget");
+    virtual ~UBFeaturesWidget();
+
+	bool visibleInMode(eUBDockPaletteWidgetMode mode)
+    {
+        return mode == eUBDockPaletteWidget_BOARD
+            || mode == eUBDockPaletteWidget_DESKTOP;
+    }
+	UBFeaturesController * getFeaturesController()const { return controller; };
+
+	static const int minThumbnailSize = 20;
+	static const int maxThumbnailSize = 100;
+	static const int defaultThumbnailSize = 40;
+private:
+	void switchToListView();
+	void switchToProperties();
+
+	UBFeaturesController *controller;
+	
+	UBFeaturesItemDelegate *itemDelegate;
+	UBFeaturesPathItemDelegate *pathItemDelegate;
+	
+	UBFeaturesModel *featuresModel;
+	UBFeaturesProxyModel *featuresProxyModel;
+	UBFeaturesSearchProxyModel *featuresSearchModel;
+	UBFeaturesPathProxyModel *featuresPathModel;
+
+	UBFeaturesListView *featuresListView;
+	UBFeaturesListView *pathListView;
+
+	QSlider *thumbSlider;
+	QVBoxLayout *layout;
+	//UBFeaturesPathViewer *pathViewer;
+	QGraphicsScene *pathScene;
+	UBFeaturesActionBar *mActionBar;
+	UBFeatureProperties *featureProperties;
+	QStackedWidget *stackedWidget;
+
+	int currentStackedWidget;
+	QModelIndex trashIndex;
+private slots:
+	void currentSelected( const QModelIndex & );
+	//void currentPathChanged(const QString &);
+	void currentPathChanged( const QModelIndex & );
+	void searchStarted( const QString & );
+	void createNewFolder();
+	void deleteElements( const QMimeData & );
+	void addToFavorite( const QMimeData & );
+	void removeFromFavorite( const QMimeData & );
+	void thumbnailSizeChanged( int );
+protected:
+	bool eventFilter(QObject *target, QEvent *event);
+};
+
+class UBFeaturesListView : public QListView
+{
+	Q_OBJECT
+public:
+	UBFeaturesListView( QWidget* parent=0, const char* name="UBFeaturesListView" );
+    virtual ~UBFeaturesListView() {;}
+protected:
+	virtual void dragEnterEvent( QDragEnterEvent *event );
+	virtual void dropEvent( QDropEvent *event );
+};
+
+
+class UBFeatureProperties : public QWidget
+{
+    Q_OBJECT
+public:
+    UBFeatureProperties(QWidget* parent=0, const char* name="UBFeatureProperties");
+    ~UBFeatureProperties();
+
+    void showElement(const UBFeature &elem);
+
+
+protected:
+    //void resizeEvent(QResizeEvent *event);
+    //void showEvent(QShowEvent *event);
+
+private slots:
+    void onAddToPage();
+    //void onAddToLib();
+    //void onSetAsBackground();
+    //void onBack();
+
+private:
+    QVBoxLayout* mpLayout;
+    QHBoxLayout* mpButtonLayout;
+    UBFeatureItemButton* mpAddPageButton;
+    UBFeatureItemButton* mpAddToLibButton;
+    UBFeatureItemButton* mpSetAsBackgroundButton;
+    QLabel* mpObjInfoLabel;
+    //QTreeWidget* mpObjInfos;
+    QLabel* mpThumbnail;
+    QPixmap* mpOrigPixmap;
+    int maxThumbHeight;
+    UBFeature *mpElement;
+    //QTreeWidgetItem* mpItem;
+};
+
+
+
+
+class UBFeatureItemButton : public QPushButton
+{
+public:
+    UBFeatureItemButton(QWidget* parent=0, const char* name="UBFeatureItemButton");
+    ~UBFeatureItemButton();
+};
+
+class UBFeaturesModel : public QAbstractListModel
+{
+	Q_OBJECT
+public:
+    UBFeaturesModel( QObject *parent = 0 ) : QAbstractListModel(parent) {;}
+    virtual ~UBFeaturesModel(){;}
+
+	void addItem( const UBFeature &item );
+	void deleteFavoriteItem( const QString &path );
+
+	QVariant data( const QModelIndex &index, int role = Qt::DisplayRole ) const;
+	QMimeData *mimeData( const QModelIndexList &indexes ) const;
+	QStringList mimeTypes() const;
+	int rowCount( const QModelIndex &parent ) const;
+	Qt::ItemFlags flags( const QModelIndex &index ) const;
+    bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent);
+	bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+	bool removeRow(int row, const QModelIndex &parent = QModelIndex());
+	
+    Qt::DropActions supportedDropActions() const { return Qt::MoveAction | Qt::CopyAction; }
+
+    void setFeaturesList( QList <UBFeature> *flist ) { featuresList = flist; }
+private:
+	QList <UBFeature> *featuresList;
+};
+
+class UBFeaturesProxyModel : public QSortFilterProxyModel
+{
+	Q_OBJECT
+public:
+    UBFeaturesProxyModel(QObject *parent = 0) : QSortFilterProxyModel(parent) {;}
+    virtual ~UBFeaturesProxyModel() {}
+protected:
+	virtual bool filterAcceptsRow ( int sourceRow, const QModelIndex & sourceParent ) const;
+};
+
+class UBFeaturesSearchProxyModel : public QSortFilterProxyModel
+{
+	Q_OBJECT
+public:
+    UBFeaturesSearchProxyModel(QObject *parent = 0) : QSortFilterProxyModel(parent) {;}
+    virtual ~UBFeaturesSearchProxyModel() {}
+protected:
+	virtual bool filterAcceptsRow ( int sourceRow, const QModelIndex & sourceParent ) const;
+};
+
+class UBFeaturesPathProxyModel : public QSortFilterProxyModel
+{
+	Q_OBJECT
+public:
+    UBFeaturesPathProxyModel(QObject *parent = 0) : QSortFilterProxyModel(parent) {;}
+    virtual ~UBFeaturesPathProxyModel() {}
+    void setPath( const QString &p ) { path = p; }
+protected:
+	virtual bool filterAcceptsRow ( int sourceRow, const QModelIndex & sourceParent ) const;
+private:
+	QString path;
+};
+
+class UBFeaturesItemDelegate : public QStyledItemDelegate
+{
+	Q_OBJECT
+public:
+    UBFeaturesItemDelegate(QWidget *parent = 0, const QListView *lw = 0) : QStyledItemDelegate(parent) { listView = lw; }
+    ~UBFeaturesItemDelegate() {}
+	//UBFeaturesItemDelegate(const QListView *lw = 0) { listView = lw; };
+	//void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
+    //QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
+	virtual QString	displayText ( const QVariant & value, const QLocale & locale ) const;
+private:
+	const QListView *listView;
+};
+
+class UBFeaturesPathItemDelegate : public QStyledItemDelegate
+{
+	Q_OBJECT
+public:
+	UBFeaturesPathItemDelegate(QWidget *parent = 0);
+	~UBFeaturesPathItemDelegate();
+	virtual QString	displayText ( const QVariant & value, const QLocale & locale ) const;
+	void paint( QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
+private:
+	QPixmap *arrowPixmap;
+};
+
+#endif // UBFEATURESWIDGET_H

src/gui/UBLibraryWidget.h

@@ -29,6 +29,7 @@
 #include <QVBoxLayout>
 
 #include "UBThumbnailWidget.h"
+#include "board/UBLibraryController.h"
 
 class UBLibraryController;
 class UBChainedLibElement;

src/gui/UBMagnifer.cpp

@@ -314,9 +314,6 @@ void UBMagnifier::grabPoint()
 
     QPointF pfScLtF(UBApplication::boardController->controlView()->mapToScene(QPoint(itemPos.x(), itemPos.y())));
    
-    
-    QRect magnifierRect = rect();
-
     float x = pfScLtF.x() - zWidthHalf;
     float y = pfScLtF.y() - zHeightHalf;
 
@@ -351,9 +348,6 @@ void UBMagnifier::grabPoint(const QPoint &pGrab)
 
     QPointF pfScLtF(UBApplication::boardController->controlView()->mapToScene(QPoint(itemPos.x(), itemPos.y())));
    
-    
-    QRect magnifierRect = rect();
-
     float x = pfScLtF.x() - zWidthHalf;
     float y = pfScLtF.y() - zHeightHalf;
 

src/gui/UBTeacherGuideWidget.cpp

@@ -723,10 +723,10 @@ void UBTeacherGuidePageZeroEditionWidget::onActiveSceneChanged()
 {
     UBDocumentProxy* documentProxy = UBApplication::documentController ? UBApplication::documentController->getCurrentDocument() : 0;
     if(UBApplication::documentController && UBApplication::boardController->activeSceneIndex() == 0){
-        QDateTime creationDate = documentProxy->documentDate();
-        mpCreationLabel->setText(tr("Created the:") + creationDate.toString(Qt::SystemLocaleShortDate));
-        QDateTime updatedDate = documentProxy->lastUpdate();
-        mpLastModifiedLabel->setText(tr("Updated the:") + updatedDate.toString(Qt::SystemLocaleShortDate));
+//        QDateTime creationDate = documentProxy->documentDate();
+//        mpCreationLabel->setText(tr("Created the:") + creationDate.toString(Qt::SystemLocaleShortDate));
+//        QDateTime updatedDate = documentProxy->lastUpdate();
+//        mpLastModifiedLabel->setText(tr("Updated the:") + updatedDate.toString(Qt::SystemLocaleShortDate));
     }
 }
 

src/gui/UBThumbnailWidget.cpp

@@ -32,8 +32,9 @@ UBThumbnailWidget::UBThumbnailWidget(QWidget* parent)
     , mSpacing(UBSettings::thumbnailSpacing)
     , mLastSelectedThumbnail(0)
     , mSelectionSpan(0)
-    , mLassoRectItem(0)
     , mPrevLassoRect(QRect())
+    , mLassoRectItem(0)
+
 {
     // By default, the drag is possible
     bCanDrag = true;

src/gui/gui.pri

@@ -46,6 +46,8 @@ HEADERS      += src/gui/UBThumbnailView.h \
                 src/gui/UBLibWebView.h \
                 src/gui/UBDownloadWidget.h \
                 src/gui/UBDockDownloadWidget.h \
+		src/gui/UBFeaturesWidget.h \
+		src/gui/UBFeaturesActionBar.h \
     src/gui/UBDockTeacherGuideWidget.h \
     src/gui/UBTeacherGuideWidget.h \
     src/gui/UBTeacherGuideWidgetsTools.h \
@@ -99,6 +101,8 @@ SOURCES      += src/gui/UBThumbnailView.cpp \
                 src/gui/UBLibWebView.cpp \
                 src/gui/UBDownloadWidget.cpp \
                 src/gui/UBDockDownloadWidget.cpp \
+		src/gui/UBFeaturesWidget.cpp \
+		src/gui/UBFeaturesActionBar.cpp \
     src/gui/UBDockTeacherGuideWidget.cpp \
     src/gui/UBTeacherGuideWidget.cpp \
     src/gui/UBTeacherGuideWidgetsTools.cpp \