Unstable branch init

src/board/UBBoardPaletteManager.cpp

@@ -153,6 +153,10 @@ void UBBoardPaletteManager::setupDockPaletteWidgets()
 
     mRightPalette = new UBRightPalette(mContainer);
     // RIGHT palette widgets
+
+	mRightPalette->registerWidget(mpFeaturesWidget);
+	mRightPalette->addTab(mpFeaturesWidget);
+
     mRightPalette->registerWidget(mpLibWidget);
     mRightPalette->addTab(mpLibWidget);
     // The cache widget will be visible only if a cache is put on the page

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

@@ -800,17 +800,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.cpp

+#include <QGraphicsItem>
+#include <QPointF>
+
+#include "core/UBApplication.h"
+#include "board/UBBoardController.h"
+#include "UBFeaturesController.h"
+#include "core/UBSettings.h"
+#include "tools/UBToolsManager.h"
+#include "frameworks/UBFileSystemUtils.h"
+#include "frameworks/UBPlatformUtils.h"
+
+
+#include "core/UBDownloadManager.h"
+#include "domain/UBAbstractWidget.h"
+#include "domain/UBGraphicsScene.h"
+#include "domain/UBGraphicsSvgItem.h"
+#include "domain/UBGraphicsPixmapItem.h"
+#include "domain/UBGraphicsVideoItem.h"
+#include "domain/UBGraphicsWidgetItem.h"
+
+UBFeature::UBFeature(const QString &url, const QPixmap &icon, const QString &name, const QString &realPath, UBFeatureElementType type)
+: virtualPath(url), mThumbnail(icon), mName(name), mPath(realPath), elementType(type)
+{
+	
+}
+
+UBFeature::UBFeature(const UBFeature &f)
+{
+	virtualPath = f.getUrl();
+	mPath = f.getPath();
+	mThumbnail = f.getThumbnail();
+	mName = f.getName();
+	elementType = f.getType();
+}
+
+
+
+UBFeaturesController::UBFeaturesController(QWidget *pParentWidget) :
+        QObject(pParentWidget),
+		mLastItemOffsetIndex(0)
+{
+	rootPath = "/root";
+	initDirectoryTree();
+}
+
+void UBFeaturesController::initDirectoryTree()
+{
+	mUserAudioDirectoryPath = UBSettings::settings()->userAudioDirectory();
+	mUserVideoDirectoryPath = UBSettings::settings()->userVideoDirectory();
+    mUserPicturesDirectoryPath = UBSettings::settings()->userImageDirectory();
+    mUserInteractiveDirectoryPath = UBSettings::settings()->userInteractiveDirectory();
+    mUserAnimationDirectoryPath = UBSettings::settings()->userAnimationDirectory();
+
+	mLibPicturesDirectoryPath = UBSettings::settings()->applicationImageLibraryDirectory();
+	mLibInteractiveDirectoryPath = UBSettings::settings()->applicationInteractivesDirectory();
+	mLibApplicationsDirectoryPath = UBSettings::settings()->applicationApplicationsLibraryDirectory();
+	mLibShapesDirectoryPath = UBSettings::settings()->applicationShapeLibraryDirectory() ;
+
+	featuresList = new QVector <UBFeature>();
+
+	QList <UBToolsManager::UBToolDescriptor> tools = UBToolsManager::manager()->allTools();
+
+	featuresList->push_back( UBFeature( "", QPixmap( ":images/libpalette/home.png" ), "root", "" ) );
+	
+	appPath = rootPath + "/Applications";
+	audiosPath = rootPath + "/Audios";
+	moviesPath = rootPath + "/Movies";
+	picturesPath = rootPath + "/Pictures";
+	flashPath = rootPath + "/Animations";
+	interactPath = rootPath + "/Interactivities";
+	shapesPath = rootPath + "/Shapes";
+
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/AudiosCategory.svg"), "Audios" , mUserAudioDirectoryPath ) );
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/MoviesCategory.svg"), "Movies" , mUserVideoDirectoryPath ) );
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/PicturesCategory.svg"), "Pictures" , mUserPicturesDirectoryPath ) );
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/ApplicationsCategory.svg"), "Applications" , mUserInteractiveDirectoryPath ) );
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/FlashCategory.svg"), "Animations" , mUserAnimationDirectoryPath ) );
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/InteractivesCategory.svg"), "Interactivities" ,  mLibInteractiveDirectoryPath ) );
+	featuresList->push_back( UBFeature( rootPath, QPixmap(":images/libpalette/ShapesCategory.svg"), "Shapes" , mLibShapesDirectoryPath ) );
+
+	foreach (UBToolsManager::UBToolDescriptor tool, tools)
+	{
+		featuresList->push_back( UBFeature( appPath, tool.icon, tool.label, mUserInteractiveDirectoryPath, FEATURE_INTERACTIVE ) );
+	}
+	fileSystemScan( mUserInteractiveDirectoryPath, appPath  );
+	fileSystemScan( mUserAudioDirectoryPath, audiosPath  );
+	fileSystemScan( mUserPicturesDirectoryPath, picturesPath  );
+	fileSystemScan( mUserVideoDirectoryPath, moviesPath  );
+	fileSystemScan( mUserAnimationDirectoryPath, flashPath  );
+
+	fileSystemScan( mLibApplicationsDirectoryPath, appPath  );
+	fileSystemScan( mLibPicturesDirectoryPath, picturesPath  );
+	fileSystemScan( mLibShapesDirectoryPath, shapesPath  );
+	fileSystemScan( mLibInteractiveDirectoryPath, interactPath  );
+
+}
+
+void UBFeaturesController::fileSystemScan(const QString & currentPath, const QString & currVirtualPath)
+{
+	QFileInfoList fileInfoList = UBFileSystemUtils::allElementsInDirectory(currentPath);
+
+    QFileInfoList::iterator fileInfo;
+    for ( fileInfo = fileInfoList.begin(); fileInfo != fileInfoList.end(); fileInfo +=  1)
+	{
+		UBFeatureElementType fileType = fileInfo->isDir() ? FEATURE_FOLDER : FEATURE_ITEM;
+
+        QString fileName = fileInfo->fileName();
+        if ( UBFileSystemUtils::mimeTypeFromFileName(fileName).contains("application") ) {
+            fileType = FEATURE_INTERACTIVE;
+        }
+		QString itemName = (fileType != FEATURE_ITEM) ? fileName : fileInfo->completeBaseName();
+		QPixmap icon = QPixmap(":images/libpalette/soundIcon.svg");
+		QString fullFileName = currentPath + "/" + fileName;
+
+		if ( fileType == FEATURE_FOLDER ) 
+		{
+            icon = QPixmap(":images/libpalette/folder.svg");
+        }
+        else if ( fileType == FEATURE_INTERACTIVE )
+		{
+			icon = QPixmap( UBAbstractWidget::iconFilePath( QUrl::fromLocalFile(fullFileName) ) );
+		}
+		else
+		{
+			if ( fullFileName.contains(".thumbnail.") )
+                continue;
+			icon = thumbnailForFile( fullFileName );
+			/*QString thumbnailPath = UBFileSystemUtils::thumbnailPath( fullFileName );
+
+			if (QFileInfo( thumbnailPath).exists() )
+				icon = QPixmap( thumbnailPath );
+			else icon = createThumbnail( fullFileName );*/
+		}
+		featuresList->push_back( UBFeature( currVirtualPath, icon, fileName, currentPath, fileType ) );
+
+		if ( fileType == FEATURE_FOLDER )
+		{
+			fileSystemScan( fullFileName, currVirtualPath + "/" + fileName );
+		}
+
+	}
+}
+
+QPixmap UBFeaturesController::thumbnailForFile(const QString &path)
+{
+	QPixmap thumb;
+	QString thumbnailPath = UBFileSystemUtils::thumbnailPath( path );
+
+	if ( QFileInfo( thumbnailPath ).exists() )
+		thumb = QPixmap( thumbnailPath );
+	else thumb = createThumbnail( path );
+	return thumb;
+}
+
+QPixmap UBFeaturesController::createThumbnail(const QString &path)
+{
+    QString thumbnailPath = UBFileSystemUtils::thumbnailPath(path);
+    QString mimetype = UBFileSystemUtils::mimeTypeFromFileName(path);
+	QString extension = QFileInfo(path).completeSuffix();
+    //UBApplication::showMessage(tr("Creating image thumbnail for %1.").arg(pElement->name()));
+
+    if ( mimetype.contains("audio" ))
+        thumbnailPath = ":images/libpalette/soundIcon.svg";
+    else if ( mimetype.contains("video") )
+        thumbnailPath = ":images/libpalette/movieIcon.svg";
+    else 
+	{
+        if ( extension.startsWith("svg", Qt::CaseInsensitive) || extension.startsWith("svgz", Qt::CaseInsensitive) ) 
+		{
+            thumbnailPath = path;
+        }
+        else 
+		{
+            QPixmap pix(path);
+            if (!pix.isNull()) 
+			{
+                pix = pix.scaledToWidth(qMin(UBSettings::maxThumbnailWidth, pix.width()), Qt::SmoothTransformation);
+                pix.save(thumbnailPath);
+                UBPlatformUtils::hideFile(thumbnailPath);
+            }
+            else{
+                thumbnailPath = ":images/libpalette/notFound.png";
+            }
+        }
+    }
+
+    return QPixmap(thumbnailPath);
+}
+
+void UBFeaturesController::addItemToPage(const UBFeature &item)
+{
+	UBApplication::boardController->downloadURL( QUrl::fromLocalFile( item.getFullPath() ) );
+}
+
+UBFeature UBFeaturesController::moveItemToFolder( const QUrl &url, const UBFeature &destination )
+{
+	QString sourcePath = url.toLocalFile();
+
+	Q_ASSERT( QFileInfo( sourcePath ).exists() );
+
+	QString name = QFileInfo( sourcePath ).fileName();
+	QString destPath = destination.getFullPath();
+	QString destVirtualPath = destination.getUrl() + "/" + destination.getName();
+	QString newFullPath = destPath + "/" + name;
+	QFile( sourcePath ).copy( newFullPath );
+	QFile::remove( sourcePath );
+
+	QString thumbnailPath = UBFileSystemUtils::thumbnailPath( sourcePath );
+    if (thumbnailPath.length() && QFileInfo( thumbnailPath ).exists()) 
+	{
+        QFile::remove(thumbnailPath);
+    }
+
+	QPixmap thumb = thumbnailForFile( newFullPath );
+	
+	UBFeatureElementType type = UBFeatureElementType::FEATURE_ITEM;
+	if ( UBFileSystemUtils::mimeTypeFromFileName( newFullPath ).contains("application") ) 
+        type = UBFeatureElementType::FEATURE_INTERACTIVE;
+	UBFeature newElement( destVirtualPath, thumb, name, destPath, type );
+	return newElement;
+}
+/*
+void UBFeaturesController::addImageToCurrentPage( const QString &path )
+{
+	QPointF pos = UBApplication::boardController->activeScene()->normalizedSceneRect().center();
+	mLastItemOffsetIndex = qMin(mLastItemOffsetIndex, 5);
+
+    QGraphicsItem* itemInScene = 0;
+
+    if ( UBApplication::boardController->activeScene() ) 
+	{
+        QString mimeType = UBFileSystemUtils::mimeTypeFromFileName( path );
+
+        pos = QPointF( pos.x() + 50 * mLastItemOffsetIndex, pos.y() + 50 * mLastItemOffsetIndex );
+        mLastItemOffsetIndex++;
+        //TODO UB 4.x move this logic to the scene ..
+        if (mimeType == "image/svg+xml") 
+		{
+			itemInScene = UBApplication::boardController->activeScene()->addSvg( QUrl::fromLocalFile(path), pos );
+        } 
+		else 
+		{
+            itemInScene = UBApplication::boardController->activeScene()->addPixmap( QPixmap(path), pos );
+        }
+    }
+
+    if (itemInScene) 
+	{
+        itemInScene = UBApplication::boardController->activeScene()->scaleToFitDocumentSize(itemInScene, false, UBSettings::objectInControlViewMargin);
+    }
+}
+*/
+
+UBFeaturesController::~UBFeaturesController()
+{
+}

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_ITEM
+};
+
+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 + "/" + mName; };
+	UBFeatureElementType getType() const { return elementType; } ;
+private:
+	QString virtualPath;
+	QString mPath;
+    QPixmap mThumbnail;
+    QString mName;
+	UBFeatureElementType elementType;
+};
+Q_DECLARE_METATYPE( UBFeature )
+
+
+class UBFeaturesController : public QObject
+{
+Q_OBJECT
+public:
+	UBFeaturesController(QWidget *parentWidget);
+    virtual ~UBFeaturesController();
+
+	QVector <UBFeature>* getFeatures()const { return featuresList; };
+	
+	QString getRootPath()const { return rootPath; };
+
+	void addItemToPage(const UBFeature &item);
+	static QPixmap thumbnailForFile( const QString &path );
+	static UBFeature moveItemToFolder( const QUrl &url, const UBFeature &destination );
+private:
+	void initDirectoryTree();
+	void fileSystemScan(const QString &currPath, const QString & currVirtualPath);
+	static QPixmap createThumbnail(const QString &path);
+	//void addImageToCurrentPage( const QString &path );
+
+	QVector <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 rootPath;
+	QString audiosPath;
+	QString moviesPath;
+	QString picturesPath;
+	QString appPath;
+	QString flashPath;
+	QString shapesPath;
+	QString interactPath;
+
+	int mLastItemOffsetIndex;
+};
+
+
+
+#endif
\ No newline at end of file

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/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 "UBDockPaletteWidget.h"
+#include "UBLibActionBar.h"
+#include "board/UBFeaturesController.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 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; };
+private:
+	void switchToListView();
+	void switchToProperties();
+
+	UBFeaturesController *controller;
+	
+	UBFeaturesItemDelegate *itemDelegate;
+	UBFeaturesPathItemDelegate *pathItemDelegate;
+	
+	UBFeaturesModel *featuresModel;
+	UBFeaturesProxyModel *featuresProxyModel;
+	UBFeaturesSearchProxyModel *featuresSearchModel;
+	UBFeaturesPathProxyModel *featuresPathModel;
+
+	QListView *featuresListView;
+	QListView *pathListView;
+	QVBoxLayout *layout;
+	UBFeaturesPathViewer *pathViewer;
+	QGraphicsScene *pathScene;
+	UBLibActionBar *mActionBar;
+	UBFeatureProperties *featureProperties;
+	QStackedWidget *stackedWidget;
+
+	int currentStackedWidget;
+private slots:
+	void currentSelected(const QModelIndex &);
+	void currentPathChanged(const QString &);
+	void currentPathChanged( const QModelIndex & );
+	void searchStarted(QString);
+};
+
+class UBFeaturesPathViewer : public QGraphicsView
+{
+	Q_OBJECT
+public:
+	UBFeaturesPathViewer(const QPixmap &root, const QString &rootPath, QGraphicsScene *sc, QWidget* parent=0, const char* name="UBFeaturesPathViewer");
+	virtual ~UBFeaturesPathViewer() {} ;
+	void addPathElement(const QPixmap &p, const QString &s);
+	void truncatePath(int number);
+private:
+	QGraphicsLinearLayout *layout;
+	QGraphicsWidget *container;
+	QPixmap *arrowPixmap;
+};
+
+
+class UBFolderWidget : public QLabel
+{
+	Q_OBJECT
+public:
+	UBFolderWidget( QWidget * parent = 0, Qt::WindowFlags f = 0 ) : QLabel( parent, f ) {};
+	virtual ~UBFolderWidget() {};
+	virtual QString getPath()const { return path; };
+	virtual void setPath( const QString &p ) { path = p; };
+signals:
+	void clicked(const QString &);
+protected:
+	virtual void mouseReleaseEvent ( QMouseEvent * ev ) 
+	{ 
+		emit clicked(path); 
+	}; 
+	virtual void mousePressEvent ( QMouseEvent * ev ) 
+	{ 
+		ev->accept();
+	}; 
+private:
+	QString path;
+};
+
+
+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 ) { };
+	virtual ~UBFeaturesModel(){};
+
+	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( QVector <UBFeature> *flist ) { featuresList = flist; };
+private:
+	QVector <UBFeature> *featuresList;
+};
+
+class UBFeaturesProxyModel : public QSortFilterProxyModel
+{
+	Q_OBJECT
+public:
+	UBFeaturesProxyModel(QObject *parent = 0) { QSortFilterProxyModel::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::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::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
\ No newline at end of file

src/gui/UBLibraryWidget.h

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

src/gui/gui.pri

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