Merge lp:~carlos-mazieri/ubuntu-filemanager-app/app-devel-pre5-final into lp:ubuntu-filemanager-app

[Carlos Jose Mazieri]

it is the last part of https://code.launchpad.net/~carlos-mazieri/ubuntu-filemanager-app/app-devel/+merge/216409 in fact the branches should be equals.

Introduces Trash, Trash browsing by providing TrashLocation class.
  * Add equivalent Disk Loader/Comparing classes for Trash in iorequest.h/iorequest.cpp
  * Add TrashLocation object into LocationsFactory
  * Trash browsing: DirModel::goTrash()
  * fileCompareExists() changed to use absolute path since Trash can have more than an item with same name
    belonging to different sources.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:173
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/195/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2363
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/195
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/195
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/145

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/195/rebuild

review: Approve (continuous-integration)

[Alan Pope 🍺🐧🐱 🦄 (popey)]

I've asked Michael Spencer to take a look at this and the other related branches and review. If he has difficulty with that I've asked him to get back to me so we can find another reviewer.

[Carlos Jose Mazieri (carlos-mazieri)]

> I've asked Michael Spencer to take a look at this and the other related
> branches and review. If he has difficulty with that I've asked him to get back
> to me so we can find another reviewer.

These 5 branches code enable Trash browsing only.

I have also Trash Operations done: "move to Trash", "restore from Trash" and "empty Trash".

I am thinking about proposing these changes which completes Trash support in some more separated branches.

Please let me know if I should wait for a reviewer.

[lp:~carlos-mazieri/ubuntu-filemanager-app/app-devel-pre5-final]

174. By Carlos Jose Mazieri on 2014-05-10

added m_currentPaths to TrashLocation, the reason is TrashLocation::startExternalFsWatcher() can activated any time.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:174
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/219/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2589
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2589/artifact/work/output/*zip*/output.zip
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/128/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/128/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/169
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/17

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/219/rebuild

review: Needs Fixing (continuous-integration)

[lp:~carlos-mazieri/ubuntu-filemanager-app/app-devel-pre5-final]

175. By Carlos Jose Mazieri on 2014-05-15

added virtual destrcutor to classes:
  IORequestLoader
  DirListWorker
  TrashListWorker
  ExternalFileSystemChangesWorker
  ExternalFileSystemTrashChangesWorker

changed TrashLocation destructor to virtual

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:175
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/226/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2640
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2640/artifact/work/output/*zip*/output.zip
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/177
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/177/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/176
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/24

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/226/rebuild

review: Needs Fixing (continuous-integration)

[Arto Jalkanen (ajalkane)]

I did a cursory glance through the code. I only found a little comment snippet that should be clarified:

928 + // move extra data here when exist, avoid extra data than DirItemInfo

I guess that should read "extra data _other_ than DirItemInfo" ?

[Carlos Jose Mazieri (carlos-mazieri)]

extra data means: data members defined only in inherited classes not in base class DirItemInfo.
The operator= works for the case "BaseObject = BaseObject" and "InheritedObject = BaseObject"

But data can be lost in the case "BaseObject = InheritedObject"

Perhaps I can change to:

// move inherited class data members here when exist, avoid data members outside base class DirItemInfo

[Arto Jalkanen (ajalkane)]

Perhaps "copy data specific to this class here, do not unnecessarily copy data that is handled by parent's assignment operator".

Anyway the exact wording doesn't matter so much, the original comment was just grammatically off enough to be a bit confusing. Move is anyway wrong word here as far as I understand, as it makes a copy assignment (ie. the original data is not lost, as would be the case in move).

[lp:~carlos-mazieri/ubuntu-filemanager-app/app-devel-pre5-final]

176. By Carlos Jose Mazieri on 2014-05-17

improved comments in TrashItemInfo::operator=(const DirItemInfo &other), disabled code not used so far.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:176
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/231/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2675/console
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/212/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/181/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/29/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/231/rebuild

review: Needs Fixing (continuous-integration)

[lp:~carlos-mazieri/ubuntu-filemanager-app/app-devel-pre5-final]

177. By Carlos Jose Mazieri on 2014-05-17

fixed type error stoptExternalFsWatcher() to stopExternalFsWatcher()

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:177
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/232/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2676
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2676/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/213
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/213/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/182
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/30

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/232/rebuild

review: Approve (continuous-integration)

[Carlos Jose Mazieri (carlos-mazieri)]

revision 176 improves comments stated in https://code.launchpad.net/~carlos-mazieri/ubuntu-filemanager-app/app-devel-pre5-final/+merge/218062/comments/525128

revision 177 fixes a type error, so it is OK now.

review: Approve

[Carlos Jose Mazieri (carlos-mazieri)]

I am approving this myself to get it ready to receive other changes already done.

review: Approve

=== modified file 'src/plugin/folderlistmodel/CMakeLists.txt'
--- src/plugin/folderlistmodel/CMakeLists.txt	2014-05-02 10:42:48 +0000
+++ src/plugin/folderlistmodel/CMakeLists.txt	2014-05-17 11:47:42 +0000
@@ -43,7 +43,13 @@
     disk/disklocation.cpp
     disk/disklocation.h
     trash/qtrashdir.cpp
-    trash/qtrashdir.h
+    trash/qtrashdir.h   
+    trash/qtrashutilinfo.cpp
+    trash/qtrashutilinfo.h
+    trash/trashiteminfo.cpp
+    trash/trashiteminfo.h
+    trash/trashlocation.cpp
+    trash/trashlocation.h
 )
 
 add_library(nemofolderlistmodel MODULE

=== modified file 'src/plugin/folderlistmodel/dirmodel.cpp'
--- src/plugin/folderlistmodel/dirmodel.cpp	2014-05-15 23:27:42 +0000
+++ src/plugin/folderlistmodel/dirmodel.cpp	2014-05-17 11:47:42 +0000
@@ -207,7 +207,6 @@
 
 
 
-
 QHash<int, QByteArray> DirModel::buildRoleNames() const
 {
     QHash<int, QByteArray> roles;
@@ -395,6 +394,7 @@
     return QVariant();
 }
 
+
 void DirModel::setPath(const QString &pathName)
 {
     if (pathName.isEmpty())
@@ -663,6 +663,12 @@
 }
 
 
+void DirModel::goTrash()
+{
+    setPath(LocationUrl::TrashRootURL);
+}
+
+
 bool DirModel::cdUp()
 {
     int ret = mCurLocation && mCurLocation->becomeParent();

=== modified file 'src/plugin/folderlistmodel/dirmodel.h'
--- src/plugin/folderlistmodel/dirmodel.h	2014-05-02 10:42:48 +0000
+++ src/plugin/folderlistmodel/dirmodel.h	2014-05-17 11:47:42 +0000
@@ -297,6 +297,11 @@
     void  goHome();
 
     /*!
+     * \brief goTrash() goes to logical folder trash:///
+     */
+    void goTrash();
+
+    /*!
      * \brief cdUp() sets the parent directory as current directory
      *
      *  It can work as a back function if there is no user input path

=== modified file 'src/plugin/folderlistmodel/folderlistmodel.pri'
--- src/plugin/folderlistmodel/folderlistmodel.pri	2014-05-02 10:42:48 +0000
+++ src/plugin/folderlistmodel/folderlistmodel.pri	2014-05-17 11:47:42 +0000
@@ -9,12 +9,14 @@
            $$PWD/fmutil.cpp \
            $$PWD/dirselection.cpp \
            $$PWD/diriteminfo.cpp \
-           $$PWD/trash/qtrashdir.cpp \          
+           $$PWD/trash/qtrashdir.cpp \
+           $$PWD/trash/trashiteminfo.cpp \
            $$PWD/location.cpp \
            $$PWD/locationsfactory.cpp \
-           $$PWD/disk/disklocation.cpp \          
+           $$PWD/disk/disklocation.cpp \
+           $$PWD/trash/trashlocation.cpp \
            $$PWD/locationurl.cpp \
-
+           $$PWD/trash/qtrashutilinfo.cpp
 
 
 HEADERS += $$PWD/dirmodel.h \
@@ -29,11 +31,14 @@
            $$PWD/dirselection.h \          
            $$PWD/diritemabstractlistmodel.h \
            $$PWD/diriteminfo.h \
-           $$PWD/trash/qtrashdir.h \          
+           $$PWD/trash/qtrashdir.h \
+           $$PWD/trash/trashiteminfo.h \
            $$PWD/location.h \
            $$PWD/locationsfactory.h \
-           $$PWD/disk/disklocation.h \           
-           $$PWD/locationurl.h \          
+           $$PWD/disk/disklocation.h \
+           $$PWD/trash/trashlocation.h \
+           $$PWD/locationurl.h \
+           $$PWD/trash/qtrashutilinfo.h
 
 
 INCLUDEPATH  += $$PWD $$PWD/trash $$PWD/disk

=== modified file 'src/plugin/folderlistmodel/iorequest.cpp'
--- src/plugin/folderlistmodel/iorequest.cpp	2014-05-02 08:29:53 +0000
+++ src/plugin/folderlistmodel/iorequest.cpp	2014-05-17 11:47:42 +0000
@@ -30,7 +30,9 @@
  */
 
 #include "iorequest.h"
+#include "qtrashutilinfo.h"
 #include "diriteminfo.h"
+#include "trashiteminfo.h"
 
 #include <QDirIterator>
 #include <QDebug>
@@ -44,6 +46,11 @@
 {
 }
 
+IORequest::~IORequest()
+{
+
+}
+
 IORequest::RequestType IORequest::type() const
 {
     return m_type;
@@ -59,33 +66,32 @@
       , mFilter(filter)
       , mIsRecursive(isRecursive)
 {
-
-}
-
-//-----------------------------------------------------------------------------------------------
-DirListWorker::DirListWorker(const QString &pathName, QDir::Filter filter, const bool isRecursive)
-    : IORequestLoader(pathName, filter, isRecursive)
-{
-
-}
-
-
-void DirListWorker::run()
-{
-#if DEBUG_MESSAGES
-    qDebug() << Q_FUNC_INFO << "Running on: " << QThread::currentThreadId();
-#endif
-
-    DirItemInfoList directoryContents = getContents();
-
-    // last batch
-    emit itemsAdded(directoryContents);
-    emit workerFinished();
+}
+
+IORequestLoader::IORequestLoader(const QString& trashRootDir,
+                                 const QString &pathName,
+                                 QDir::Filter filter,
+                                 bool isRecursive)
+      : IORequest()
+      , mLoaderType(TrashLoader)
+      , mPathName(pathName)
+      , mFilter(filter)
+      , mIsRecursive(isRecursive)
+      , mTtrashRootDir(trashRootDir)
+{
+
+}
+
+IORequestLoader::~IORequestLoader()
+{
+
 }
 
 DirItemInfoList  IORequestLoader::getContents()
 {
-   return  getNormalContent();
+   return mLoaderType == NormalLoader ?
+                getNormalContent() :
+                getTrashContent();
 }
 
 DirItemInfoList  IORequestLoader::getNormalContent()
@@ -123,17 +129,87 @@
             directoryContents.erase(directoryContents.begin(), directoryContents.end());
         }
     }
-
     return directoryContents;
 }
 
+DirItemInfoList  IORequestLoader::getTrashContent()
+{
+   DirItemInfoList directoryContents;
+   QTrashUtilInfo trashInfo;
+   QDir tmpDir = QDir(mPathName, QString(), QDir::NoSort, mFilter);
+   bool isTopLevel = QFileInfo(mPathName).absolutePath() == mTtrashRootDir;
+   QDirIterator it(tmpDir);
+   while (it.hasNext())
+   {
+       it.next();
+       trashInfo.setInfo(mTtrashRootDir, it.fileInfo().absoluteFilePath());
+       if (!isTopLevel || (isTopLevel && trashInfo.existsInfoFile() && trashInfo.existsFile()) )
+       {
+          //TODO read the trashinfo file and set it into  a display field
+          //     the display field can be a string the usally points to absoluteFilePath()
+          //     it would be used only in the DirModel::data()
+           TrashItemInfo item(QTrashUtilInfo::filesTrashDir(mTtrashRootDir),
+                              it.fileInfo().absoluteFilePath());
+           directoryContents.append(item);
+       }
+   }
+   return directoryContents;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+DirListWorker::DirListWorker(const QString &pathName, QDir::Filter filter, const bool isRecursive)
+    : IORequestLoader(pathName, filter, isRecursive)
+{
+
+}
+
+
+DirListWorker::DirListWorker(const QString& trashRootDir, const QString &pathName, QDir::Filter filter, const bool isRecursive)
+    : IORequestLoader(trashRootDir, pathName, filter, isRecursive)
+{
+
+}
+
+DirListWorker::~DirListWorker()
+{
+
+}
+
+void DirListWorker::run()
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "Running on: " << QThread::currentThreadId();
+#endif
+
+    DirItemInfoList directoryContents = getContents();
+
+    // last batch
+    emit itemsAdded(directoryContents);
+    emit workerFinished();
+}
+
+
+
+
+//-------------------------------------------------------------------------------------
+TrashListWorker::TrashListWorker(const QString& trashRoot, const QString &path, QDir::Filter filter)
+  : DirListWorker(trashRoot, path, filter, false)
+{
+    mLoaderType = TrashLoader;
+}
+
+TrashListWorker::~TrashListWorker()
+{
+
+}
 
 //---------------------------------------------------------------------------------------------------------
 ExternalFileSystemChangesWorker::ExternalFileSystemChangesWorker(const DirItemInfoList &content,
                                                    const QString &pathName,
                                                    QDir::Filter filter,
                                                    const bool isRecursive)
-    : DirListWorker(pathName, filter, isRecursive)
+    : IORequestLoader(pathName, filter, isRecursive)
 
 {
     m_type        = DirListExternalFSChanges;
@@ -145,14 +221,11 @@
 }
 
 
-void ExternalFileSystemChangesWorker::run()
+ExternalFileSystemChangesWorker::~ExternalFileSystemChangesWorker()
 {
-    DirItemInfoList directoryContents = getContents();
-    int remainingitemsCounter = compareItems(directoryContents);
-    emit finished(remainingitemsCounter);
+
 }
 
-
 int ExternalFileSystemChangesWorker::compareItems(const DirItemInfoList& contentNew)
 {
     int   addedCounter=0;
@@ -207,4 +280,37 @@
    return counter;
 }
 
-
+void ExternalFileSystemChangesWorker::run()
+{
+    DirItemInfoList directoryContents = getContents();    
+    int remainingitemsCounter = compareItems(directoryContents);
+    emit finished(remainingitemsCounter);
+}
+
+
+//---------------------------------------------------------------------
+ExternalFileSystemTrashChangesWorker::ExternalFileSystemTrashChangesWorker(const QStringList &pathNames,
+                                                                           const DirItemInfoList &list,
+                                                                           QDir::Filter filter)
+    :  ExternalFileSystemChangesWorker(list, pathNames.at(0), filter, false)
+    ,  m_pathList(pathNames)
+{
+    mLoaderType = TrashLoader;
+}
+
+ExternalFileSystemTrashChangesWorker::~ExternalFileSystemTrashChangesWorker()
+{
+
+}
+
+void ExternalFileSystemTrashChangesWorker::run()
+{
+    DirItemInfoList directoryContents;
+    for(int counter = 0; counter < m_pathList.count(); counter++)
+    {
+        mPathName = QTrashUtilInfo::filesTrashDir(m_pathList.at(counter));
+        directoryContents += getContents();
+    }
+    int remainingitemsCounter = compareItems(directoryContents);
+    emit finished(remainingitemsCounter);
+}

=== modified file 'src/plugin/folderlistmodel/iorequest.h'
--- src/plugin/folderlistmodel/iorequest.h	2014-05-02 08:29:53 +0000
+++ src/plugin/folderlistmodel/iorequest.h	2014-05-17 11:47:42 +0000
@@ -42,6 +42,7 @@
     Q_OBJECT
 public:   
     explicit IORequest();
+    virtual ~IORequest();
     
 public:
     enum RequestType
@@ -75,21 +76,29 @@
     IORequestLoader( const QString &pathName,
                      QDir::Filter filter,
                      bool isRecursive
-                   );    
+                   );
+    IORequestLoader( const QString& trashRootDir,
+                     const QString &pathName,
+                     QDir::Filter filter,
+                     bool isRecursive
+                   );                   
+    virtual ~IORequestLoader();
     DirItemInfoList     getContents();
 
 signals:
     void itemsAdded(const DirItemInfoList &files);
 
 private:
-    DirItemInfoList getNormalContent();   
+    DirItemInfoList getNormalContent();
+    DirItemInfoList getTrashContent();
     DirItemInfoList add(const QString &pathName, QDir::Filter filter,
                         bool isRecursive, DirItemInfoList directoryContents);
 protected:
     LoaderType    mLoaderType;
     QString       mPathName;
     QDir::Filter  mFilter;
-    bool          mIsRecursive;   
+    bool          mIsRecursive;
+    QString       mTtrashRootDir;
 };
 
 
@@ -99,7 +108,9 @@
 {
     Q_OBJECT
 public:
-    explicit DirListWorker(const QString &pathName, QDir::Filter filter, const bool isRecursive);    
+    explicit DirListWorker(const QString &pathName, QDir::Filter filter, const bool isRecursive);
+    explicit DirListWorker(const QString& trashRootDir, const QString &pathName, QDir::Filter filter, const bool isRecursive);
+    virtual ~DirListWorker();
     void run();
 protected:
 signals:
@@ -108,7 +119,19 @@
 };
 
 
-class  ExternalFileSystemChangesWorker : public DirListWorker
+
+
+class TrashListWorker  : public DirListWorker
+{
+    Q_OBJECT
+public:
+    explicit TrashListWorker(const QString &trashRoot, const QString& path, QDir::Filter filter);
+    virtual ~TrashListWorker();
+};
+
+
+
+class  ExternalFileSystemChangesWorker : public IORequestLoader
 {
     Q_OBJECT
 public:
@@ -116,6 +139,7 @@
                                       const QString &pathName,
                                       QDir::Filter filter,
                                       const bool isRecursive);
+    virtual ~ExternalFileSystemChangesWorker();
     void     run();
 
 protected:
@@ -132,6 +156,19 @@
 
 
 
+class ExternalFileSystemTrashChangesWorker : public ExternalFileSystemChangesWorker
+{
+ Q_OBJECT
+
+public:
+  ExternalFileSystemTrashChangesWorker(const QStringList& pathNames,
+                                       const DirItemInfoList& list,
+                                       QDir::Filter filter);
+  virtual ~ExternalFileSystemTrashChangesWorker();
+  void run();
+private:
+  QStringList    m_pathList;
+};
 
 
 

=== modified file 'src/plugin/folderlistmodel/locationsfactory.cpp'
--- src/plugin/folderlistmodel/locationsfactory.cpp	2014-05-14 22:51:47 +0000
+++ src/plugin/folderlistmodel/locationsfactory.cpp	2014-05-17 11:47:42 +0000
@@ -24,7 +24,8 @@
 #include "location.h"
 #include "locationurl.h"
 #include "disklocation.h"
-
+#include "trashlocation.h"
+#include "trashiteminfo.h"
 
 #include <QDir>
 #include <QDebug>
@@ -36,7 +37,8 @@
  , m_curLoc(0)
  , m_lastValidFileInfo(0)
 {
-   m_locations.append(new DiskLocation(LocalDisk)); 
+   m_locations.append(new DiskLocation(LocalDisk));
+   m_locations.append(new TrashLocation(TrashDisk));
 }
 
 

=== modified file 'src/plugin/folderlistmodel/trash/qtrashdir.cpp'
--- src/plugin/folderlistmodel/trash/qtrashdir.cpp	2014-02-15 15:18:24 +0000
+++ src/plugin/folderlistmodel/trash/qtrashdir.cpp	2014-05-17 11:47:42 +0000
@@ -20,6 +20,7 @@
  */
 
 #include "qtrashdir.h"
+#include "qtrashutilinfo.h"
 
 #include <QFileInfo>
 #include <QDir>
@@ -39,6 +40,7 @@
 
 }
 
+
 bool QTrashDir::validate(const QString &trashDir, bool create) const
 {
    bool ret = false;
@@ -49,8 +51,8 @@
    }
    if (checkUserDirPermissions(trashDir))
    {
-       QString  files(filesTrashDir(trashDir));
-       QString  info(infoTrashDir(trashDir));
+       QString  files(QTrashUtilInfo::filesTrashDir(trashDir));
+       QString  info(QTrashUtilInfo::infoTrashDir(trashDir));
        if ( (checkUserDirPermissions(files) || (create && createUserDir(files)))  &&
             (checkUserDirPermissions(info)  || (create && createUserDir(info)))
           )
@@ -170,18 +172,6 @@
 }
 
 
-QString QTrashDir::filesTrashDir(const QString &trashDir) const
-{
-   QString filesDir(trashDir + QDir::separator() + QLatin1String("files"));
-   return filesDir;
-}
-
-
-QString QTrashDir::infoTrashDir(const QString &trashDir) const
-{
-   QString infoDir(trashDir + QDir::separator() + QLatin1String("info"));
-   return infoDir;
-}
 
 
 /*!
@@ -333,3 +323,13 @@
     }
     return trashDir;
 }
+
+
+bool QTrashDir::suitableTrash(const QString &fullPathName, QTrashUtilInfo &fullInfo) const
+{
+    fullInfo.setInfo(suitableTrash(fullPathName), fullPathName);
+    return fullInfo.isValid();
+}
+
+
+

=== modified file 'src/plugin/folderlistmodel/trash/qtrashdir.h'
--- src/plugin/folderlistmodel/trash/qtrashdir.h	2014-02-15 15:18:24 +0000
+++ src/plugin/folderlistmodel/trash/qtrashdir.h	2014-05-17 11:47:42 +0000
@@ -24,7 +24,7 @@
 
 #include <QStringList>
 #include <QDateTime>
-
+struct QTrashUtilInfo;
 
 /*!
  * \brief The QTrashDir class is a Qt implementation of the Trash Directories specification
@@ -93,19 +93,8 @@
      */
     QString       suitableTrash(const QString &fullPathName) const;
 
-    /*!
-     * \brief filesTrashDir() gets the "files" directory under Trash Dir
-     * \param trashDir
-     * \return trashDir/files
-     */
-    QString       filesTrashDir(const QString& trashDir) const;
+    bool          suitableTrash(const QString &fullPathName, QTrashUtilInfo& fullInfo) const;
 
-    /*!
-     * \brief infoTrashDir() gets gets the "info" directory under Trash Dir
-     * \param trashDir
-     * \return trashDir/info
-     */
-    QString       infoTrashDir(const QString& trashDir)  const;
 
 private:          
     bool          validate(const QString& trashDir, bool create=false) const;
@@ -120,7 +109,7 @@
 
 private:
     uint          m_userId;
- #if defined(REGRESSION_TEST_FOLDERLISTMODEL) //used in Unit/Regression tests
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL) //used in Unit/Regression tests
    friend class TestDirModel;
 #endif
 };

=== added file 'src/plugin/folderlistmodel/trash/qtrashutilinfo.cpp'
--- src/plugin/folderlistmodel/trash/qtrashutilinfo.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/trash/qtrashutilinfo.cpp	2014-05-17 11:47:42 +0000
@@ -0,0 +1,153 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * File: qtrashutilinfo.cpp
+ * Date: 16/03/2014
+ */
+
+#include "qtrashutilinfo.h"
+
+#include <QDir>
+#include <QSettings>
+#include <QDateTime>
+
+QLatin1String filesDirString("files");
+QLatin1String infoDirString("info");
+
+void QTrashUtilInfo::clear()
+{
+    trashRoot.clear();
+    filesDir.clear();
+    absFile.clear();
+    infoDir.clear();
+    absInfo.clear();
+    valid = false;
+}
+
+
+QString QTrashUtilInfo::filesTrashDir(const QString &trashDir)
+{
+   QString filesDir(trashDir + QDir::separator() + filesDirString);
+   return filesDir;
+}
+
+
+QString QTrashUtilInfo::infoTrashDir(const QString &trashDir)
+{
+   QString infoDir(trashDir + QDir::separator() + infoDirString);
+   return infoDir;
+}
+
+
+void QTrashUtilInfo::setInfoFromTrashItem(const QString &absTrashItem)
+{
+    valid = false;
+    QFileInfo item(absTrashItem);
+    if (item.absolutePath().endsWith(filesDirString))
+    {
+        QFileInfo filesUnderRoot(item.absolutePath());
+        QTrashUtilInfo::setInfo(filesUnderRoot.absolutePath(), absTrashItem);
+    }
+    else
+    {
+        clear();
+    }
+}
+
+
+void QTrashUtilInfo::setInfo(const QString& trashRootDir, const QString& filename)
+{
+    valid = !trashRootDir.isEmpty();
+    if (valid)
+    {
+        QFileInfo f(filename);
+        trashRoot  = trashRootDir;
+        filesDir   = filesTrashDir(trashRootDir);
+        absFile    = filesDir + QDir::separator() + f.fileName();
+        infoDir    = infoTrashDir(trashRootDir) ;
+        absInfo    = infoDir + QDir::separator() + f.fileName() +
+                     QLatin1String(".trashinfo");
+    }
+    else
+    {
+        clear();
+    }
+}
+
+
+bool QTrashUtilInfo::isValid()
+{
+    return valid;
+}
+
+
+bool QTrashUtilInfo::existsFile()
+{
+    return QFileInfo(absFile).exists();
+}
+
+
+bool QTrashUtilInfo::existsInfoFile()
+{
+    return QFileInfo(absInfo).exists();
+}
+
+
+QString QTrashUtilInfo::getOriginalPathName()
+{
+    QString path;
+    if (isValid())
+    {
+        QSettings inff(absInfo, QSettings::IniFormat);
+        inff.beginGroup(QLatin1String("Trash Info"));
+        QFileInfo f (inff.value(QLatin1String("Path")).toString());
+        //Path contains the full pathname
+        path = f.absoluteFilePath();
+    }
+    return path;
+}
+
+
+bool QTrashUtilInfo::createTrashInfoFile(const QString& orignalPathname)
+{
+    bool ret = isValid();
+    if (ret)
+    {
+        QByteArray content("[Trash Info]\nPath=");
+        content += orignalPathname + QLatin1Char('\n');
+        content += "DeletionDate=";
+        content += QDateTime::currentDateTime().toString(Qt::ISODate) + QLatin1Char('\n');
+        QFile f(absInfo);
+        ret = f.open(QFile::WriteOnly | QFile::Truncate) &&
+              f.write(content) == content.size();
+        f.close();
+    }
+    return ret;
+}
+
+
+
+bool QTrashUtilInfo::removeTrashInfoFile()
+{
+    QFile infoFile(absInfo);
+    bool ret = false;
+    if (valid && infoFile.exists())
+    {
+        ret = infoFile.remove();
+    }
+    return ret;
+}

=== added file 'src/plugin/folderlistmodel/trash/qtrashutilinfo.h'
--- src/plugin/folderlistmodel/trash/qtrashutilinfo.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/trash/qtrashutilinfo.h	2014-05-17 11:47:42 +0000
@@ -0,0 +1,82 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * File: qtrashutilinfo.h
+ * Date: 16/03/2014
+ */
+
+#ifndef QTRASHUTILINFO_H
+#define QTRASHUTILINFO_H
+
+#include <QString>
+
+
+/*!
+ * \brief The QTrashUtilInfo struct just provides helper functions and information using a file structure like
+ *
+ *  Trash/
+ *        files/           info/
+ *              item           item.trashinfo
+ */
+struct QTrashUtilInfo
+{
+public:
+    /*!
+     * \brief setInfo()          build the whole Trash information
+     * \param trashRootDir       the root Trash Dir usually a folder "Trash"
+     * \param filename           the item, it can be either a relative file name or a full path name
+     */
+    void setInfo(const QString& trashRootDir, const QString& filename);
+
+    /*!
+     * \brief setInfoFromTrashItem() build the whole Trash information from the absolute path name from a trash item
+     * \param absTrashItem       the full path, something like <TrashRoot>/files/item
+     *
+     *  The item pointed by \a absTrashItem does not need to exist
+     */
+    void setInfoFromTrashItem(const QString& absTrashItem);
+    void clear();
+    bool existsInfoFile();
+    bool existsFile();
+    bool isValid();
+    QString getOriginalPathName();
+    bool createTrashInfoFile(const QString& orignalPathname);
+    bool removeTrashInfoFile();
+
+    /*!
+     * \brief filesTrashDir() gets the "files" directory under Trash Dir
+     * \param trashDir
+     * \return trashDir/files
+     */
+    static QString       filesTrashDir(const QString& trashDir);
+
+    /*!
+     * \brief infoTrashDir() gets gets the "info" directory under Trash Dir
+     * \param trashDir
+     * \return trashDir/info
+     */
+    static QString       infoTrashDir(const QString& trashDir);
+
+    QString  trashRoot; // root
+    QString  filesDir;  // root/files
+    QString  absFile;   // root/files/item
+    QString  infoDir;   // root/info
+    QString  absInfo;   // root/info/item.trashinfo
+    bool     valid;
+};
+
+#endif // QTRASHUTILINFO_H

=== added file 'src/plugin/folderlistmodel/trash/trashiteminfo.cpp'
--- src/plugin/folderlistmodel/trash/trashiteminfo.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/trash/trashiteminfo.cpp	2014-05-17 11:47:42 +0000
@@ -0,0 +1,147 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * File: trashiteminfo.cpp
+ * Date: 05/03/2014
+ */
+
+#include "trashiteminfo.h"
+#include "locationurl.h"
+
+
+TrashItemInfo::TrashItemInfo(const QString &urlPath)
+    : DirItemInfo()  
+{  
+   d_ptr->_path            = urlPath;
+   d_ptr->_isLocal         = true;
+   d_ptr->_normalizedPath  = urlPath;
+   if (urlPath == LocationUrl::TrashRootURL)
+   {
+      setRoot();
+   }
+}
+
+
+TrashItemInfo::TrashItemInfo(const TrashItemInfo &other)
+       : DirItemInfo(other)       
+{
+}
+
+
+TrashItemInfo::TrashItemInfo(const QString& trashPath, const QString &urlPath)
+   : DirItemInfo(urlPath)  
+{
+    init(trashPath);
+}
+
+
+void TrashItemInfo::setRoot()
+{
+    d_ptr->_isValid      = true;
+    d_ptr->_isRoot       = true;
+    d_ptr->_isDir        = true;
+    d_ptr->_isReadable   = true;
+    d_ptr->_isExecutable = true;
+    d_ptr->_exists       = true;
+    d_ptr->_fileName.clear();
+}
+
+
+void TrashItemInfo::init(const QString& trashPath)
+{
+    if (trashPath == absoluteFilePath())
+    {
+        d_ptr->_path = trashPath;
+        setRoot();
+    }
+    else
+    {
+        if (!d_ptr->_path.startsWith(trashPath))
+        {
+            d_ptr->_isValid = false;
+        }
+    }
+    QString abs(d_ptr->_path);
+    d_ptr->_normalizedPath = abs.replace(0,trashPath.length()+1, LocationUrl::TrashRootURL);
+}
+
+
+TrashItemInfo& TrashItemInfo::operator=(const DirItemInfo &other)
+{
+    DirItemInfo::operator  = (other);
+    //the following code is disabled because TrashItemInfo does not define any data member
+    //but it is kept for the case any specific data member be necessary in the future
+    //and it is also kept to warn that doing so would cause a bug
+#if 0
+    const TrashItemInfo *isTrash = dynamic_cast<const TrashItemInfo*> (&other);   
+    if (isTrash)
+    {
+      //copy data specific to this class here,
+      //do not unnecessarily copy data that is handled by parent's assignment operator
+    }
+#endif
+    return *this;
+}
+
+
+TrashItemInfo& TrashItemInfo::operator=(const TrashItemInfo &other)
+{
+    DirItemInfo::operator = (other);   
+    return *this;
+}
+
+
+/*!
+ * \brief TrashItemInfo::getTrashDir()
+ *
+ *  Lets suppose a directory in the trash named DIR:
+ *    absFilePath()        = /home/user/.local/share/Trash/files/DIR
+ *    normalizedFilePath() =                            trash:///DIR
+ *
+ *    The trash dir is /home/user/.local/share/Trash/files
+ *
+ * \return The trash dir
+ */
+QString TrashItemInfo::getTrashDir() const
+{
+    QString trashDir;
+    QString norm(urlPath());
+    if (    norm.length() > LocationUrl::TrashRootURL.length()
+         && norm.startsWith(LocationUrl::TrashRootURL)
+       )
+    {
+        QStringRef  trashItemRef(norm.midRef(LocationUrl::TrashRootURL.length()));
+        QString abs(absoluteFilePath());
+        int length = abs.lastIndexOf(trashItemRef);
+        if (length > 0)
+        {
+            trashDir = abs.left(length-1);
+        }
+    }
+    return trashDir;
+}
+
+
+QString TrashItemInfo::getRootTrashDir() const
+{
+    QString ret = getTrashDir();
+    if (!isRoot())
+    {
+        ret = QFileInfo(ret).absolutePath();
+    }
+    return ret;
+}

=== added file 'src/plugin/folderlistmodel/trash/trashiteminfo.h'
--- src/plugin/folderlistmodel/trash/trashiteminfo.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/trash/trashiteminfo.h	2014-05-17 11:47:42 +0000
@@ -0,0 +1,58 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * File: trashiteminfo.h
+ * Date: 05/03/2014
+ */
+
+#ifndef TRASHITEMINFO_H
+#define TRASHITEMINFO_H
+
+#include "diriteminfo.h"
+
+
+/*!
+ * \brief The TrashItemInfo class provides a QFileInfo like information for files in Trash
+ *
+ *  Basically it differs from DirItemInfo in the field \a d_ptr->_normalizedPath, it must store the
+ *  url like trash:///Item, while the field d_ptr->_path stores the current path in the file system as usual.
+ *
+ *  So suppose a Item in the trash:
+ *  \li \ref absoluteFilePath()  returns like /home/user/.local/share/Trash/files/Item
+ *  \li \ref urlPath()           returns      trash:///Item
+ *  \li \ref getTrashDir()  does a right-to-left comparing in order to find out the Trash Dir, in this case /home/user/.local/share/Trash/files
+ *
+ *  The constructor \ref TrashItemInfo(const QString& urlPath) is used only to store the logical root trash folder trash:///
+ */
+class TrashItemInfo : public DirItemInfo
+{
+public:
+    TrashItemInfo(const QString& urlPath);
+    TrashItemInfo(const QString& trashPath, const QString& urlPath);   
+    TrashItemInfo(const TrashItemInfo &other);
+public:
+    virtual TrashItemInfo& operator=(const DirItemInfo &other);
+    virtual TrashItemInfo& operator=(const TrashItemInfo &other);
+public:
+    QString getTrashDir() const;
+    QString getRootTrashDir() const;
+private:
+    void    setRoot();
+    void    init(const QString& trashPath);
+};
+
+#endif // TRASHITEMINFO_H

=== added file 'src/plugin/folderlistmodel/trash/trashlocation.cpp'
--- src/plugin/folderlistmodel/trash/trashlocation.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/trash/trashlocation.cpp	2014-05-17 11:47:42 +0000
@@ -0,0 +1,260 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * File: trashlocation.cpp
+ * Date: 08/03/2014
+ */
+
+#include "iorequest.h"
+#include "ioworkerthread.h"
+#include "trashlocation.h"
+#include "trashiteminfo.h"
+#include "qtrashutilinfo.h"
+#include "locationurl.h"
+#include "externalfswatcher.h"
+
+#include <QDebug>
+
+TrashLocation::TrashLocation(int type, QObject *parent) :
+    DiskLocation(type, parent)
+   ,QTrashDir()
+
+{
+}
+
+TrashLocation::~TrashLocation()
+{
+
+}
+
+bool TrashLocation::becomeParent()
+{
+
+    bool ret = false;
+    TrashItemInfo *trashInfo = static_cast<TrashItemInfo*> (m_info);
+    if (trashInfo && !trashInfo->isRoot())
+    {
+        QString trashDir = trashInfo->getTrashDir();
+        if (!trashDir.isEmpty())
+        {
+            TrashItemInfo *other = new TrashItemInfo(trashDir, trashInfo->absolutePath());
+            if (other->isValid() && other->isDir())
+            {
+                delete m_info;
+                m_info = other;
+                ret = true;
+            }
+            else
+            {
+                delete other;
+            }
+        }
+    }
+    return ret;
+}
+
+
+DirItemInfo * TrashLocation::validateUrlPath(const QString& urlPath)
+{
+     TrashItemInfo *item  =  0;
+     QString  myPath(urlPath);
+
+    //first void any relative path when is root
+    if (m_info  && m_info->isRoot() && myPath.startsWith(QLatin1String("..")))
+    {
+        return item;
+    }
+
+    int firstSlash       = -1;
+
+    // handle relative paths to the current
+    if (!myPath.startsWith(LocationUrl::TrashRootURL) && m_info)
+    {
+        QFileInfo f;
+        f.setFile(m_info->absoluteFilePath(), myPath);
+        if (f.exists() && f.isDir())
+        {
+            TrashItemInfo *trashItem = static_cast<TrashItemInfo*> (m_info);
+            item = new TrashItemInfo(trashItem->getTrashDir(), f.canonicalFilePath());
+#if DEBUG_MESSAGES
+            qDebug() << Q_FUNC_INFO << "cur path:" << m_info->absoluteFilePath()
+                     << " new path:"  << item->absoluteFilePath()
+                     << "url:"   << item->urlPath();
+#endif
+        }
+        else
+        {
+           myPath = LocationUrl::TrashRootURL + urlPath;
+        }
+    }
+    else
+    {
+        item  = new TrashItemInfo(myPath);
+        if (!item->isRoot())
+        {
+            delete item;
+            item = 0;
+        }
+    }
+
+    //Not Relative, handle absolute path but it is not root
+    if (item == 0)
+    {       
+        QString absTrashItem;
+        QString trashItemFromRoot = myPath.mid(LocationUrl::TrashRootURL.size());
+        foreach(const QString& trashRoot, allTrashes())
+        {
+            //this is the full path of the item, it does not mean it is a Trash top level item
+            //example: trash:///Dir1/Dir2/Dir3  may be in /home/user/.local/share/Trash//Dir1/Dir2/Dir3
+            absTrashItem = QTrashUtilInfo::filesTrashDir(trashRoot) + QDir::separator() + trashItemFromRoot;
+            const QFileInfo info(absTrashItem);
+            if (info.exists())
+            {
+                //check top level trash item
+                firstSlash = trashItemFromRoot.indexOf(QDir::separator());
+                QString toplevelDir = firstSlash != -1 ? trashItemFromRoot.left(firstSlash)
+                                                       : trashItemFromRoot;
+
+                QTrashUtilInfo topLevelTrashDirInfo;
+                topLevelTrashDirInfo.setInfo(trashRoot, toplevelDir);
+#if DEBUG_MESSAGES
+                    qDebug() << Q_FUNC_INFO
+                             <<  topLevelTrashDirInfo.absFile << "exists" << topLevelTrashDirInfo.existsFile()
+                             <<  topLevelTrashDirInfo.absInfo << "exists" << topLevelTrashDirInfo.existsInfoFile();
+#endif
+                //check if a .trashinfo file for toplevel dir exists
+                if (topLevelTrashDirInfo.existsInfoFile())
+                {
+                    item = new TrashItemInfo(QTrashUtilInfo::filesTrashDir(trashRoot), absTrashItem);
+                    break;
+                }
+            }
+        }
+    }
+
+    if (item)
+    {
+        if (!item->isValid() || !item->isContentReadable())
+        {
+            delete item;
+            item = 0;
+        }
+        else
+        {
+            if (firstSlash != -1)
+            {
+                // TODO get the trashinfo information and carry into the item
+            }
+        }
+    }
+    return item;
+}
+
+
+
+
+void TrashLocation::refreshInfo()
+{
+    if (m_info && !m_info->isRoot())
+    {
+        TrashItemInfo *trashItem = static_cast<TrashItemInfo*>(m_info);
+        TrashItemInfo *item = new TrashItemInfo(trashItem->getTrashDir(), trashItem->absoluteFilePath());
+        delete m_info;
+        m_info = item;
+    }
+}
+
+
+void TrashLocation::startExternalFsWatcher()
+{
+    //TODO implement a Watcher for this
+    //modify the existent watcher to work having  a list of paths
+    if (m_usingExternalWatcher && m_extWatcher == 0 && isRoot())
+    {     
+        m_extWatcher = new ExternalFSWatcher(this);
+        m_extWatcher->setIntervalToNotifyChanges(EX_FS_WATCHER_TIMER_INTERVAL);      
+        m_extWatcher->setCurrentPaths(m_currentPaths);
+
+        connect(m_extWatcher, SIGNAL(pathModified(QString)),
+                this,         SIGNAL(extWatcherPathChanged(QString)));
+    }
+}
+
+
+void TrashLocation::fetchItems(QDir::Filter dirFilter, bool recursive)
+{
+    Q_UNUSED(recursive)
+    if (!m_info->isRoot()) //any item under the logical trash folder
+    {
+        //sub items inside Trash do not need external watcher, they will never be updated
+        stopExternalFsWatcher();
+        TrashItemInfo *trashItem = static_cast<TrashItemInfo*> (m_info);
+        TrashListWorker *dlw  = new TrashListWorker(trashItem->getRootTrashDir(),
+                                                    trashItem->absoluteFilePath(),
+                                                    dirFilter);
+       addTrashFetchRequest(dlw);
+    }
+    else    
+    {
+        m_currentPaths = allTrashes();
+        startExternalFsWatcher();
+
+        //the trash a is logical folder, its content can be composed by more than one physical folder
+        foreach (const QString& trashRootDir, m_currentPaths)
+        {
+            TrashListWorker *dlw  = new TrashListWorker(trashRootDir,
+                                                        QTrashUtilInfo::filesTrashDir(trashRootDir),
+                                                        dirFilter);
+            addTrashFetchRequest(dlw);
+         }
+    }
+}
+
+
+void TrashLocation::addTrashFetchRequest(TrashListWorker *workerObject)
+{
+    connect(workerObject,  SIGNAL(itemsAdded(DirItemInfoList)),
+            this,          SIGNAL(itemsAdded(DirItemInfoList)));
+    //it differs from DiskLocation
+    connect(workerObject,  SIGNAL(workerFinished()),
+            this,          SIGNAL(itemsFetched()));
+    workerThread()->addRequest(workerObject);
+}
+
+
+
+void TrashLocation::fetchExternalChanges(const QString& urlPath,
+                                         const DirItemInfoList& list,
+                                         QDir::Filter dirFilter)
+{
+    Q_UNUSED(urlPath);
+    if (m_extWatcher)
+    {
+       ExternalFileSystemTrashChangesWorker * extFsWorker =
+        new ExternalFileSystemTrashChangesWorker( m_extWatcher->pathsWatched(),
+                                                  list,
+                                                  dirFilter
+                                                );
+       addExternalFsWorkerRequest(extFsWorker);
+    }
+}
+
+
+void TrashLocation::startWorking()
+{
+   // do nothing, the startExternalFsWatcher() is called in fetchItems()
+}

=== added file 'src/plugin/folderlistmodel/trash/trashlocation.h'
--- src/plugin/folderlistmodel/trash/trashlocation.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/trash/trashlocation.h	2014-05-17 11:47:42 +0000
@@ -0,0 +1,55 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * File: trashlocation.h
+ * Date: 08/03/2014
+ */
+
+#ifndef TRASHLOCATION_H
+#define TRASHLOCATION_H
+
+#include "disk/disklocation.h"
+#include "trash/qtrashdir.h"
+
+class TrashListWorker;
+
+class TrashLocation : public DiskLocation, public QTrashDir
+{
+    Q_OBJECT
+public:
+    explicit TrashLocation(int type, QObject *parent=0);
+    virtual ~TrashLocation();
+    virtual bool        becomeParent();
+    virtual void        refreshInfo();
+    virtual void        fetchItems(QDir::Filter dirFilter, bool recursive=0);
+    virtual void        fetchExternalChanges(const QString& urlPath,
+                                             const DirItemInfoList& list,
+                                             QDir::Filter dirFilter) ;
+
+    virtual void        startWorking();
+    virtual void        startExternalFsWatcher();
+
+    virtual DirItemInfo *validateUrlPath(const QString& urlPath);
+
+private:
+    void               addTrashFetchRequest(TrashListWorker *workerObject);
+
+private:
+    QStringList        m_currentPaths;  //!< also used in the startExternalFsWatcher(), it can br activated any time
+};
+
+#endif // TRASHLOCATION_H

=== modified file 'src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp'
--- src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp	2014-05-02 10:42:48 +0000
+++ src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp	2014-05-17 11:47:42 +0000
@@ -8,6 +8,7 @@
 #include "locationurl.h"
 #include "locationsfactory.h"
 #include "disklocation.h"
+#include "qtrashutilinfo.h"
 
 #if defined(Q_OS_UNIX)
 #include <stdio.h>
@@ -147,10 +148,11 @@
     void modelSelectionItemsRange();
 
     void trashDiretories();
+
     void locationFactory();
 
-
 private:
+    bool createTempHomeTrashDir(const QString& existentDir);
     void initDeepDirs();
     void cleanDeepDirs();
     void initModels();
@@ -1415,16 +1417,114 @@
     QCOMPARE(ret,                        true);
     QCOMPARE(m_currentPath,              m_deepDir_01->path());
     QCOMPARE(m_dirModel_01->rowCount(), 1);
+    QCOMPARE(m_receivedErrorSignal,      false);
 
     ret = m_dirModel_01->openPath(QLatin1String(".."));
     QTest::qWait(TIME_TO_REFRESH_DIR);
     QCOMPARE(ret,                        true);   
     QCOMPARE(m_currentPath,              QDir::tempPath());
+    QCOMPARE(m_receivedErrorSignal,      false);
 
     ret = m_dirModel_01->openPath(orig);
     QTest::qWait(TIME_TO_REFRESH_DIR);
     QCOMPARE(ret,                        true);
     QCOMPARE(m_currentPath,              m_deepDir_01->path());
+    QCOMPARE(m_receivedErrorSignal,      false);
+
+    // trash --------------------------------------
+    TempFiles files;
+    QCOMPARE(files.addSubDirLevel(m_deepDir_01->path()),  true);
+
+    createTempHomeTrashDir(m_deepDir_01->path());
+
+    QTrashDir tempTrash;
+    QCOMPARE(files.addSubDirLevel(tempTrash.homeTrash()),  true);
+    QCOMPARE(files.addSubDirLevel(QTrashUtilInfo::filesTrashDir(tempTrash.homeTrash())),  true);
+
+    QString level1("Level1");
+    QCOMPARE(files.addSubDirLevel(level1),  true);
+
+    QTrashUtilInfo trashInfo;
+    trashInfo.setInfo(tempTrash.homeTrash(), level1);
+    QCOMPARE(trashInfo.existsFile()   , true);
+    QFile infoFile(trashInfo.absInfo);
+    QCOMPARE(infoFile.open(QFile::WriteOnly),  true);
+    infoFile.close();
+
+    //check if "Level1" is valid item under trash
+    QCOMPARE(trashInfo.existsInfoFile()   , true);
+
+    QString level2("level2");
+    QString level3("level3");
+
+    QCOMPARE(files.addSubDirLevel(level2),  true);
+    QCOMPARE(files.addSubDirLevel(level3),  true);
+
+    files.create(1);
+
+    // using trash:///
+    ret = m_dirModel_01->openPath(LocationUrl::TrashRootURL);
+    QTest::qWait(TIME_TO_REFRESH_DIR);
+    QCOMPARE(ret,                        true);
+    QCOMPARE(m_currentPath,              LocationUrl::TrashRootURL);
+    QCOMPARE(m_receivedErrorSignal,      false);
+
+    // using relative "Level1"
+    ret = m_dirModel_01->openPath(level1);
+    QTest::qWait(TIME_TO_REFRESH_DIR);
+    QCOMPARE(ret,                        true);
+    QCOMPARE(m_currentPath,              QString(LocationUrl::TrashRootURL + level1) );
+    QCOMPARE(m_receivedErrorSignal,      false);
+
+   //using trash:///Level1/Level2/Level3
+   QString deep(LocationUrl::TrashRootURL + level1 + QDir::separator() + level2 + QDir::separator() + level3);
+   ret = m_dirModel_01->openPath(deep);
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   //using ../ to go up into Level2
+   ret = m_dirModel_01->openPath("../");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   //using .. to go up into Level1
+   ret = m_dirModel_01->openPath("..");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   //back to trash:///
+   ret = m_dirModel_01->openPath("..");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);   
+   QCOMPARE(m_currentPath,              LocationUrl::TrashRootURL);
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   //now it must fail
+   ret = m_dirModel_01->openPath("..");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        false);
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   ret = m_dirModel_01->openPath("file:///");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);
+   QCOMPARE(m_currentPath,              QDir::rootPath());
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   ret = m_dirModel_01->openPath("file://");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);
+   QCOMPARE(m_currentPath,              QDir::rootPath());
+   QCOMPARE(m_receivedErrorSignal,      false);
+
+   ret = m_dirModel_01->openPath("file:/");
+   QTest::qWait(TIME_TO_REFRESH_DIR);
+   QCOMPARE(ret,                        true);
+   QCOMPARE(m_currentPath,              QDir::rootPath());
+   QCOMPARE(m_receivedErrorSignal,      false);
 }
 
 
@@ -2314,9 +2414,9 @@
    QCOMPARE(trash.checkUserDirPermissions(trashDir),  true);
 
    //create files in Trash
-   QCOMPARE(trash.createUserDir(trash.filesTrashDir(trashDir)),  true);
+   QCOMPARE(trash.createUserDir(QTrashUtilInfo::filesTrashDir(trashDir)),  true);
    //create info in Trash
-   QCOMPARE(trash.createUserDir(trash.infoTrashDir(trashDir)),  true);
+   QCOMPARE(trash.createUserDir(QTrashUtilInfo::infoTrashDir(trashDir)),  true);
    //test validate Trash Dir(), now it MUST pass
    QCOMPARE(trash.validate(trashDir, false),  true);
 
@@ -2333,16 +2433,18 @@
    QString xdgTrash("xdg_Trash");
    m_deepDir_02 = new DeepDir(xdgTrash,0);
 
+   if (::qgetenv("XDG_DATA_HOME").size() == 0)
+   {
+       QString myTrash(QDir::homePath() + "/.local/share/Trash");
+       QCOMPARE(trash.homeTrash(), myTrash);
+   }
+
    //test XDG Home Trash
    ::setenv("XDG_DATA_HOME", m_deepDir_02->path().toLatin1().constData(), true );
-
    QString xdgTrashDir(trash.homeTrash());
    QCOMPARE(trash.validate(xdgTrashDir, false),  true);
    QCOMPARE(trash.homeTrash() , xdgTrashDir);
 
-   ::setenv("XDG_DATA_HOME", "\0", true );
-   QCOMPARE(trash.homeTrash() , QDir::homePath() + "/.local/share/Trash");
-
    QCOMPARE(trash.getMountPoint(QDir::rootPath()), QDir::rootPath());  
 
    QStringList mountedPoints = trash.mountedPoints();
@@ -2398,12 +2500,46 @@
 void TestDirModel::locationFactory()
 {
     LocationsFactory factoryLocations(this);
-    const Location *location = 0;   
+    const Location *location = 0;
+
+    QString validTrashURL(LocationUrl::TrashRootURL);
 
    //Due to current File Manager UI typing method both: "file:" and "trash:" are supported
    // location = factoryLocations.setNewPath("trash:");
    // QVERIFY(location == 0);
 
+    location = factoryLocations.setNewPath("trash:/");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::TrashDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   validTrashURL);
+    QCOMPARE(location->urlPath(), validTrashURL);
+    QCOMPARE(location->isRoot(), true);
+
+    location = factoryLocations.setNewPath("trash://");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::TrashDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   validTrashURL);
+    QCOMPARE(location->urlPath(), validTrashURL);
+    QCOMPARE(location->isRoot(), true);
+
+    location = factoryLocations.setNewPath("trash:///");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::TrashDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   validTrashURL);
+    QCOMPARE(location->urlPath(), validTrashURL);
+    QCOMPARE(location->isRoot(), true);
+
+    location = factoryLocations.setNewPath("trash://////");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::TrashDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   validTrashURL);
+    QCOMPARE(location->urlPath(), validTrashURL);
+    QCOMPARE(location->isRoot(), true);
+
+    QString myDir("___myDir_must_NOT_EXIST___");
+    location = factoryLocations.setNewPath(QString("trash:/") + myDir);
+    QVERIFY(location == 0);
+
     location = factoryLocations.setNewPath("file://////");
     QVERIFY(location);
     QVERIFY(location->type() == LocationsFactory::LocalDisk);
@@ -2430,10 +2566,49 @@
     QVERIFY(location->type() == LocationsFactory::LocalDisk);
     QCOMPARE(location->info()->absoluteFilePath(),   QLatin1String("/bin"));
     QCOMPARE(location->urlPath(), QLatin1String("/bin"));
-    QCOMPARE(location->isRoot(), false);   
+    QCOMPARE(location->isRoot(), false);
+
+    QTrashDir  trash;
+    QString dirName("trashDirectory");
+    m_deepDir_01 = new DeepDir(dirName,0);
+
+    //create a Trash to have
+
+    ::setenv("XDG_DATA_HOME", m_deepDir_01->path().toLatin1().constData(), true );
+    QString xdgTrashDir(trash.homeTrash());
+    QCOMPARE(trash.validate(xdgTrashDir, true),  true);
+    QCOMPARE(trash.homeTrash() , xdgTrashDir);
+
+    QString trash3("trash:///Dir1/Dir2/Dir3");
+    QString trash2("trash:///Dir1/Dir2");
+    QString trash1("trash:///Dir1");
+
+    QCOMPARE(QDir().mkpath(QTrashUtilInfo::filesTrashDir(xdgTrashDir) + "/Dir1/Dir2/Dir3"), true);
+
+
+    //create a empty .trashinfo file to validate the Trash
+    QFile trashinfo (QTrashUtilInfo::infoTrashDir(xdgTrashDir) + "/Dir1.trashinfo");
+    QCOMPARE(trashinfo.open(QFile::WriteOnly),  true);
+    trashinfo.close();
+
+    location =  factoryLocations.setNewPath(trash3);
+    Location * myLocation = const_cast<Location*> (location);
+    QCOMPARE(myLocation->becomeParent(),   true);
+    QCOMPARE(location->urlPath(),  trash2);
+    QCOMPARE(location->isRoot(), false);
+
+    location =  factoryLocations.setNewPath(trash2);
+    myLocation = const_cast<Location*> (location);
+    QCOMPARE(myLocation->becomeParent(),   true);
+    QCOMPARE(location->urlPath(),  trash1);
+    QCOMPARE(location->isRoot(), false);
+
+    myLocation = const_cast<Location*> (location);
+    QCOMPARE(myLocation->becomeParent(),  true);
+    QCOMPARE(location->urlPath(),  LocationUrl::TrashRootURL);
+    QCOMPARE(location->isRoot(), true);
 }
 
-
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
@@ -2489,6 +2664,21 @@
     return ret;
 }
 
+
+bool TestDirModel::createTempHomeTrashDir(const QString& existentDir)
+{
+    QDir d(existentDir);
+    bool ret = false;
+    if (existentDir.startsWith(QDir::tempPath()) && (d.exists() || d.mkpath(existentDir)))
+    {
+        QTrashDir trash;
+        ::setenv("XDG_DATA_HOME", existentDir.toLatin1().constData(), true );
+        QString xdgTrashDir(trash.homeTrash());
+        ret = trash.validate(xdgTrashDir, true);
+    }
+    return ret;
+}
+
 #if defined(Q_OS_UNIX)
 /*!
  * \brief updateAndSetModificationTime()