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

[Carlos Jose Mazieri]

it is the fourth part of https://code.launchpad.net/~carlos-mazieri/ubuntu-filemanager-app/app-devel/+merge/216409

Introduces Location, it basicaly handles Urls and their internal paths.

IORequest/DirListWorker and ExternalFSWatcher calls were moved from DirModel class to DiskLocation class

Location provides:
         current path/url -> Location::urlPath()
         its content -> Location::fetchItems()
         navigation -> up=Location::becomeParent() into sub-folders=Location::setFromInfoItem()
         notification about external changes in its current path.

Changed navigation in the file manager:
  DirModel::setPath() now calls LocationsFactory::setNewPath() which can change the location or set a path in the current location.
  DirModel::cdUp()
  DirModel::cdIntoIndex()
  DirModel::openPath()

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

PASSED: Continuous integration, rev:172
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/193/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2360
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/193
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/193
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/143

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/193/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.

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

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

Fixed using m_info when it can be null.

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

FAILED: Continuous integration, rev:173
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/218/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2588
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2588/artifact/work/output/*zip*/output.zip
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-utopic/127/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/127/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/168
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/16

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

review: Needs Fixing (continuous-integration)

[Arto Jalkanen (ajalkane)]

1)

Non-virtual destructors on classes that either inherit or are inherited other classes with virtual functions, these should be virtual destructors:
~Location()
~DiskLocation()
~LocationsFactory()

Especially important are the Location ones and the classes deriving from it. A basic rule-of-thumb is to have a virtual destructor on any class that has virtual functions or that derives from a class that has virtual destructors. Deviating from this rule-of-thumb is sometimes acceptable but there should be heavy reasons for it, and some comment for why it is so would be appreciated. Right now I do not see anything in the code that would warrant them not-being virtual destructors.

It'd be good to check the code on the whole that there's not more than what I noticed in this code-review.

2)

There is const_cast<...> calls. It's a red flag, casting should only be used if definitely needed. Either document why it's needed or try to refactor the code to get rid of it. For example:
const Location * LocationsFactory::setNewPath(const QString& uPath)

Why does it need to return const pointer as it's used in such a way that it's modified? Why not have it return non-const pointer and get rid of the const_casts.

3)

in someplaces when checking pointer there is:
if (m_somePointer == 0)
and other times just:
if (m_somePointer)

Either is fine IMO, but it'd be good to keep the code-base consistent. So use one or the other.

4)

This perplexes me:

void Location::setFromInfoItem(const DirItemInfo *itemInfo)
917 +{
918 + if (m_info)
919 + {
920 + delete m_info;
921 + }
922 + m_info = const_cast<DirItemInfo*> (itemInfo);
923 +}

the name of the function, setFromInfoItem, along with the const parameter to me gives an impression that it will make a copy for the class to use. Instead it does a cast and uses the pointer directly. Perhaps do not use parameter as "const" and rename the function to setInfoItem(DireItemInfo *itemInfo) ? Here I may not understand some details, so feel free to correct me.

5)

Typos:

LocationsFactory::stringAfterSlahes() -> LocationsFactory::stringAfterSlashes()
DiskLocation::stoptExternalFsWatcher() -> DiskLocation::stopExternalFsWatcher()

review: Needs Fixing

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

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

* changed destructor to virtual from classes Location() and DiskLocation
* changed Location::setFromInfoItem(const DirItemInfo *itemInfo) to:
          Location::setInfoItem(DireItemInfo *itemInfo)
* changed const Location * LocationsFactory::setNewPath(const QString& uPath) to
                Location * LocationsFactory::setNewPath(const QString& uPath)
* changed const Location * LocationsFactory::parse(const QString& urlPath) to
                Location * LocationsFactory::parse(const QString& urlPath)
* changed const Location * LocationsFactory::location() const to
                Location * LocationsFactory::location() const

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

PASSED: Continuous integration, rev:174
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/225/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2637
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2637/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/174
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/174/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/175
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/23

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

review: Approve (continuous-integration)

[Carlos Jose Mazieri (carlos-mazieri)]

> 1)
>
> Non-virtual destructors on classes that either inherit or are inherited other
> classes with virtual functions, these should be virtual destructors:
> ~Location()
> ~DiskLocation()
> ~LocationsFactory()
>
> Especially important are the Location ones and the classes deriving from it. A
> basic rule-of-thumb is to have a virtual destructor on any class that has
> virtual functions or that derives from a class that has virtual destructors.
> Deviating from this rule-of-thumb is sometimes acceptable but there should be
> heavy reasons for it, and some comment for why it is so would be appreciated.
> Right now I do not see anything in the code that would warrant them not-being
> virtual destructors.
>

> It'd be good to check the code on the whole that there's not more than what I
> noticed in this code-review

DONE. added virtual for destructors. LocationsFactory does not have any virtual method nor any descendent class.

.
>
> 2)
>
> There is const_cast<...> calls. It's a red flag, casting should only be used
> if definitely needed. Either document why it's needed or try to refactor the
> code to get rid of it. For example:
> const Location * LocationsFactory::setNewPath(const QString& uPath)
>
> Why does it need to return const pointer as it's used in such a way that it's
> modified? Why not have it return non-const pointer and get rid of the
> const_casts.

DONE. removed const

>
> 3)
>
> in someplaces when checking pointer there is:
> if (m_somePointer == 0)
> and other times just:
> if (m_somePointer)
>
> Either is fine IMO, but it'd be good to keep the code-base consistent. So use
> one or the other.

I am used to use "if (pointer)" when asking for avalid address and "if (pointer == 0)" when asking if a pointer is NULL, I could use "if (pointer != 0)" when asking for avalid address, but not "if (!pointer)" which looks like the variable is a bool.

>
> 4)
>
> This perplexes me:
>
> void Location::setFromInfoItem(const DirItemInfo *itemInfo)
> 917 +{
> 918 + if (m_info)
> 919 + {
> 920 + delete m_info;
> 921 + }
> 922 + m_info = const_cast<DirItemInfo*> (itemInfo);
> 923 +}
>

DONE. Changed to Location::setInfoItem(DireItemInfo *itemInfo) (const removed)

>
> the name of the function, setFromInfoItem, along with the const parameter to
> me gives an impression that it will make a copy for the class to use. Instead
> it does a cast and uses the pointer directly. Perhaps do not use parameter as
> "const" and rename the function to setInfoItem(DireItemInfo *itemInfo) ? Here
> I may not understand some details, so feel free to correct me.
>
> 5)
>
> Typos:
>
> LocationsFactory::stringAfterSlahes() ->
> LocationsFactory::stringAfterSlashes()
> DiskLocation::stoptExternalFsWatcher() ->
> DiskLocation::stopExternalFsWatcher()

DONE. Changed.

[Arto Jalkanen (ajalkane)]

Thanks for the fixes! A couple of things anymore:

> > It'd be good to check the code on the whole that there's not more than what
> I
> > noticed in this code-review
>
>
> DONE. added virtual for destructors. LocationsFactory does not have any
> virtual method nor any descendent class.

But LocationsFactory inherits QObject which does have virtual methods so it's a potential hard to find error even if it's not a problem in code-base currently. Consider for example Qt's resource management where parent QObject is responsible for deleting its children. If LocationsFactory (or any other similar class) is set as a child of some other QObject (practically speaking using the new LocationsFactory(QObject *parent) constructor where parent is not null), then when the parent QObject is deleted then LocationsFactory's destructor is not called - unless you make it virtual.

> I am used to use "if (pointer)" when asking for avalid address and "if
> (pointer == 0)" when asking if a pointer is NULL, I could use "if (pointer !=
> 0)" when asking for avalid address, but not "if (!pointer)" which looks like
> the variable is a bool.

That makes sense, I misread that line. It's good.

> >
> > 4)
> >
> > This perplexes me:
> >
> > void Location::setFromInfoItem(const DirItemInfo *itemInfo)
> > 917 +{
> > 918 + if (m_info)
> > 919 + {
> > 920 + delete m_info;
> > 921 + }
> > 922 + m_info = const_cast<DirItemInfo*> (itemInfo);
> > 923 +}
> >
>
> DONE. Changed to Location::setInfoItem(DireItemInfo *itemInfo) (const removed)

There's still two places with unnecessary const_casts:

143 + mCurLocation = const_cast<Location*> (location);
235 + mCurLocation = const_cast<Location*> (location);

review: Needs Fixing

[Carlos Jose Mazieri (carlos-mazieri)]

> Thanks for the fixes! A couple of things anymore:
>
> > > It'd be good to check the code on the whole that there's not more than
> what
> > I
> > > noticed in this code-review
> >
> >
> > DONE. added virtual for destructors. LocationsFactory does not have any
> > virtual method nor any descendent class.
>
> But LocationsFactory inherits QObject which does have virtual methods so it's
> a potential hard to find error even if it's not a problem in code-base
> currently. Consider for example Qt's resource management where parent QObject
> is responsible for deleting its children. If LocationsFactory (or any other
> similar class) is set as a child of some other QObject (practically speaking
> using the new LocationsFactory(QObject *parent) constructor where parent is
> not null), then when the parent QObject is deleted then LocationsFactory's
> destructor is not called - unless you make it virtual.
>

  I agree that it is a good programming practice and I can do it, no problem.
  But I am not sure it happens, QObject DOES HAVE virtual destructor which in my opinion makes all descendant destructors to be called.

> > I am used to use "if (pointer)" when asking for avalid address and "if
> > (pointer == 0)" when asking if a pointer is NULL, I could use "if (pointer
> !=
> > 0)" when asking for avalid address, but not "if (!pointer)" which looks like
> > the variable is a bool.
>
> That makes sense, I misread that line. It's good.
>
> > >
> > > 4)
> > >
> > > This perplexes me:
> > >
> > > void Location::setFromInfoItem(const DirItemInfo *itemInfo)
> > > 917 +{
> > > 918 + if (m_info)
> > > 919 + {
> > > 920 + delete m_info;
> > > 921 + }
> > > 922 + m_info = const_cast<DirItemInfo*> (itemInfo);
> > > 923 +}
> > >
> >
> > DONE. Changed to Location::setInfoItem(DireItemInfo *itemInfo) (const
> removed)
>
> There's still two places with unnecessary const_casts:
>
> 143 + mCurLocation = const_cast<Location*> (location);
> 235 + mCurLocation = const_cast<Location*> (location);

[Arto Jalkanen (ajalkane)]

> > Thanks for the fixes! A couple of things anymore:
> >
> > > > It'd be good to check the code on the whole that there's not more than
> > what
> > > I
> > > > noticed in this code-review
> > >
> > >
> > > DONE. added virtual for destructors. LocationsFactory does not have any
> > > virtual method nor any descendent class.
> >
> > But LocationsFactory inherits QObject which does have virtual methods so
> it's
> > a potential hard to find error even if it's not a problem in code-base
> > currently. Consider for example Qt's resource management where parent
> QObject
> > is responsible for deleting its children. If LocationsFactory (or any other
> > similar class) is set as a child of some other QObject (practically speaking
> > using the new LocationsFactory(QObject *parent) constructor where parent is
> > not null), then when the parent QObject is deleted then LocationsFactory's
> > destructor is not called - unless you make it virtual.
> >
>
> I agree that it is a good programming practice and I can do it, no problem.
> But I am not sure it happens, QObject DOES HAVE virtual destructor which in
> my opinion makes all descendant destructors to be called.

You're right. Shame on me forgetting that when base class has virtual destructor, it makes all descendant classes destructors virtual automatic even without specifically declaring them such.

So yes, it's not a problem.

>
> > > I am used to use "if (pointer)" when asking for avalid address and "if
> > > (pointer == 0)" when asking if a pointer is NULL, I could use "if (pointer
> > !=
> > > 0)" when asking for avalid address, but not "if (!pointer)" which looks
> like
> > > the variable is a bool.
> >
> > That makes sense, I misread that line. It's good.
> >
> > > >
> > > > 4)
> > > >
> > > > This perplexes me:
> > > >
> > > > void Location::setFromInfoItem(const DirItemInfo *itemInfo)
> > > > 917 +{
> > > > 918 + if (m_info)
> > > > 919 + {
> > > > 920 + delete m_info;
> > > > 921 + }
> > > > 922 + m_info = const_cast<DirItemInfo*> (itemInfo);
> > > > 923 +}
> > > >
> > >
> > > DONE. Changed to Location::setInfoItem(DireItemInfo *itemInfo) (const
> > removed)
> >
> > There's still two places with unnecessary const_casts:
> >
> > 143 + mCurLocation = const_cast<Location*> (location);
> > 235 + mCurLocation = const_cast<Location*> (location);

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

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

removed row no necessary const_cast<Location*>

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

PASSED: Continuous integration, rev:175
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/229/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2659
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2659/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/196
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/196/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/179
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/27

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

review: Approve (continuous-integration)

[Carlos Jose Mazieri (carlos-mazieri)]

revision 175 removes:
  143 + mCurLocation = const_cast<Location*> (location);
  235 + mCurLocation = const_cast<Location*> (location);

I think that completes those 5 items, they all have been solved.

[Arto Jalkanen (ajalkane)]

Thank you for doing these!

review: Approve

[David Planella (dpm)]

Thanks guys, top-approving as per Arto's last comment.

@Arto, in the future, please feel free to top-approve the merge proposal yourself if you think it's ready to land. Thanks!

=== modified file 'src/plugin/folderlistmodel/CMakeLists.txt'
--- src/plugin/folderlistmodel/CMakeLists.txt	2014-04-28 10:21:05 +0000
+++ src/plugin/folderlistmodel/CMakeLists.txt	2014-05-15 23:31:23 +0000
@@ -1,5 +1,7 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
+    disk
+    trash
 )
 
 set(PLUGIN_DIR org/nemomobile/folderlistmodel)
@@ -32,6 +34,14 @@
     ioworkerthread.h
     plugin.cpp
     plugin.h
+    location.cpp
+    location.h
+    locationsfactory.cpp
+    locationsfactory.h
+    locationurl.cpp
+    locationurl.h
+    disk/disklocation.cpp
+    disk/disklocation.h
     trash/qtrashdir.cpp
     trash/qtrashdir.h
 )

=== modified file 'src/plugin/folderlistmodel/dirmodel.cpp'
--- src/plugin/folderlistmodel/dirmodel.cpp	2014-05-15 23:31:22 +0000
+++ src/plugin/folderlistmodel/dirmodel.cpp	2014-05-15 23:31:23 +0000
@@ -31,12 +31,13 @@
 
 #include "dirselection.h"
 #include "dirmodel.h"
-#include "iorequest.h"
-#include "ioworkerthread.h"
 #include "filesystemaction.h"
-#include "externalfswatcher.h"
 #include "clipboard.h"
 #include "fmutil.h"
+#include "locationsfactory.h"
+#include "location.h"
+#include "locationurl.h"
+#include "disklocation.h"
 
 
 #ifndef DO_NOT_USE_TAG_LIB
@@ -75,7 +76,6 @@
 #define IS_FILE_MANAGER_IDLE()            (!mAwaitingResults)
 
 
-Q_GLOBAL_STATIC(IOWorkerThread, ioWorkerThread)
 
 namespace {
     QHash<QByteArray, int> roleMapping;
@@ -108,9 +108,11 @@
     , mSortBy(SortByName)
     , mSortOrder(SortAscending)
     , mCompareFunction(0)  
-    , mExtFSWatcher(0)
-    , mClipboard(new Clipboard(this))    
-    , m_fsAction(new FileSystemAction(this) )    
+    , mExtFSWatcher(false)
+    , mClipboard(new Clipboard(this))
+    , mLocationFactory(new LocationsFactory(this))
+    , mCurLocation(0)
+    , m_fsAction(new FileSystemAction(this) )
 {
     mNameFilters = QStringList() << "*";
 
@@ -155,13 +157,40 @@
     {
         FMUtil::setThemeName();
     }
+
+    foreach (const Location* l, mLocationFactory->availableLocations())
+    {
+       connect(l,     SIGNAL(itemsAdded(DirItemInfoList)),
+               this,  SLOT(onItemsAdded(DirItemInfoList)));
+
+       connect(l,     SIGNAL(itemsFetched()),
+               this,  SLOT(onItemsFetched()));
+
+       connect(l,     SIGNAL(extWatcherItemAdded(DirItemInfo)),
+               this,  SLOT(onItemAddedOutsideFm(DirItemInfo)));
+
+       connect(l,     SIGNAL(extWatcherItemRemoved(DirItemInfo)),
+               this,  SLOT(onItemRemovedOutSideFm(DirItemInfo)));
+
+       connect(l,     SIGNAL(extWatcherItemChanged(DirItemInfo)),
+               this,  SLOT(onItemChangedOutSideFm(DirItemInfo)));
+
+       connect(l,     SIGNAL(extWatcherChangesFetched(int)),
+               this,  SLOT(onExternalFsWorkerFinished(int)));
+
+       connect(l,     SIGNAL(extWatcherPathChanged(QString)),
+               this,  SLOT(onThereAreExternalChanges(QString)));
+
+       connect(this,  SIGNAL(enabledExternalFSWatcherChanged(bool)),
+               l,     SLOT(setUsingExternalWatcher(bool)));
+    }
 }
 
 
 
 DirModel::~DirModel()
 {
-    stoptExternalFsWatcher();
+
 }
 
 
@@ -371,38 +400,48 @@
     if (pathName.isEmpty())
         return;   
 
-    if (!canReadDir(pathName))
-    {
-        emit error(tr("cannot read path"), pathName);
-        return;
-    }
-
-    if (mAwaitingResults) {
+   if (mAwaitingResults) {
         // TODO: handle the case where pathName != our current path, cancel old
         // request, start a new one
-        qDebug() << Q_FUNC_INFO << this << "Ignoring path change request, request already running";
-        return;
-    }
-
+        qDebug() << Q_FUNC_INFO << this << "Ignoring path change request, request already running in" << pathName;
+        return;
+    }
+
+    Location *location = mLocationFactory->setNewPath(pathName);
+    if (location == 0)
+    {
+        emit error(tr("path or url may not exist or cannot be read"), pathName);
+        qDebug() << Q_FUNC_INFO << this << "path or url may not exist or cannot be read:" << pathName;
+        return;
+    }
+
+    mCurLocation = location;
+    setPathFromCurrentLocation();
+}
+
+/*!
+ * \brief DirModel::setPathFromCurrentLocation() changes current Path using current Location
+ *
+ *  Used in \ref cdUp() and \ref cdIntoIndex()
+ */
+void DirModel::setPathFromCurrentLocation()
+{   
     mAwaitingResults = true;
     emit awaitingResultsChanged();
 #if DEBUG_MESSAGES
-    qDebug() << Q_FUNC_INFO << this << "Changing to " << pathName << " on " << QThread::currentThreadId();
+    qDebug() << Q_FUNC_INFO << this << "Changing to " << mCurLocation->urlPath();
 #endif
 
     clear();
 
-    DirListWorker *dlw  = createWorkerRequest(IORequest::DirList, pathName);
-    connect(dlw, SIGNAL(itemsAdded(DirItemInfoList)), SLOT(onItemsAdded(DirItemInfoList)));
-    connect(dlw, SIGNAL(workerFinished()), SLOT(onResultsFetched()));
-    ioWorkerThread()->addRequest(dlw);
+    mCurLocation->fetchItems(currentDirFilter(), mIsRecursive);
 
-    mCurrentDir = pathName;
-    emit pathChanged(pathName);
+    mCurrentDir = mCurLocation->urlPath();
+    emit pathChanged(mCurLocation->urlPath());
 }
 
 
-void DirModel::onResultsFetched() {
+void DirModel::onItemsFetched() {
     if (mAwaitingResults) {
 #if DEBUG_MESSAGES
         qDebug() << Q_FUNC_INFO << this << "No longer awaiting results";
@@ -611,7 +650,9 @@
 }
 ExternalFSWatcher * DirModel::getExternalFSWatcher() const
 {
-   return mExtFSWatcher;
+   const Location *l = mLocationFactory->availableLocations().at(LocationsFactory::LocalDisk);
+   const DiskLocation *disk = static_cast<const DiskLocation*> (l);
+   return disk->getExternalFSWatcher();
 }
 #endif
 
@@ -624,15 +665,10 @@
 
 bool DirModel::cdUp()
 {
-    int ret = false;
-    if (!mCurrentDir.isEmpty()) // we are in any dir
+    int ret = mCurLocation && mCurLocation->becomeParent();
+    if (ret)
     {
-        QDir current(mCurrentDir);
-        if (current.cdUp())
-        {
-            setPath(current.absolutePath());
-            ret = true;
-        }
+       setPathFromCurrentLocation();
     }
     return ret;
 }
@@ -720,7 +756,9 @@
         mDirectoryContents.at(row).isDir()      &&
         mDirectoryContents.at(row).isContentReadable())
     {
-        ret = cdInto(mDirectoryContents.at(row));
+        mCurLocation->setInfoItem(mDirectoryContents.at(row));
+        setPathFromCurrentLocation();
+        ret = true;
     }
     else
     {
@@ -1114,8 +1152,28 @@
 
 bool DirModel::openPath(const QString &filename)
 {
-    DirItemInfo fi(setParentIfRelative(filename));
-    return openItem(fi);
+    bool ret = false;
+    //first void any relative path when is root
+    if ( !(mCurLocation && mCurLocation->isRoot() && filename.startsWith(QLatin1String(".."))) )
+    {
+        Location *location = mLocationFactory->setNewPath(filename);
+        if (location)
+        {
+            mCurLocation = location;
+            setPathFromCurrentLocation();
+            ret = true;
+        }
+        else
+        {
+           const DirItemInfo *item = mLocationFactory->lastValidFileInfo();
+           // DirItemInfo fi(setParentIfRelative(filename));
+           if (item && item->isFile())
+           {
+               ret =  openItem(*item);
+           }
+        }
+    }
+    return ret;
 }
 
 /*!
@@ -1144,76 +1202,8 @@
     return ret;
 }
 
-/*!
- * \brief DirModel::createWorkerRequest() create a request for IORequestWorker
- * \param requestType the common IORequest::DirList to fill a directory content
- *                    or IORequest::DirAutoRefresh that will verify any external File System modification
- * \param pathName  the path to get content
- * \return          the thread object
- */
-DirListWorker * DirModel::createWorkerRequest(IORequest::RequestType requestType,
-                                              const QString& pathName)
-{
-    DirListWorker * reqThread = 0;
-    QDir::Filter dirFilter = currentDirFilter();
-    if (requestType == IORequest::DirList)
-    {
-        // TODO: we need to set a spinner active before we start getting results from DirListWorker
-        reqThread = new DirListWorker(pathName, dirFilter, mIsRecursive);
-    }
-    else
-    {
-        reqThread = new ExternalFileSystemChangesWorker(mDirectoryContents,
-                                                  pathName,
-                                                  dirFilter, mIsRecursive);
-    }  
-    return reqThread;
-}
-
-
-
-/*!
- * \brief DirModel::startExternalFsWatcher() starts the External File System Watcher
- */
-void DirModel::startExternalFsWatcher()
-{
-#if DEBUG_EXT_FS_WATCHER
-        qDebug() << "[extFsWorker]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
-                  << Q_FUNC_INFO << this;
-
-#endif
-    if (!mExtFSWatcher)
-    {
-        mExtFSWatcher = new ExternalFSWatcher(this);
-        mExtFSWatcher->setIntervalToNotifyChanges(EX_FS_WATCHER_TIMER_INTERVAL);
-        connect(this,          SIGNAL(pathChanged(QString)),
-                mExtFSWatcher, SLOT(setCurrentPath(QString)));
-
-        connect(mExtFSWatcher, SIGNAL(pathModified(QString)),
-                this,          SLOT(onThereAreExternalChanges(QString)));
-
-       //setCurrentPath() checks for empty paths
-       mExtFSWatcher->setCurrentPath(mCurrentDir);
-    }
-}
-
-
-
-/*!
- * \brief DirModel::stoptExternalFsWatcher stops the External File System Watcher
- */
-void DirModel::stoptExternalFsWatcher()
-{
-#if DEBUG_EXT_FS_WATCHER
-        qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
-                  << Q_FUNC_INFO << this;
-#endif
-   if (mExtFSWatcher)
-   {
-       delete mExtFSWatcher;
-       mExtFSWatcher = 0;
-   }
-}
+
+
 
 
 void DirModel::onThereAreExternalChanges(const QString& pathModifiedOutside)
@@ -1222,27 +1212,11 @@
     {
 #if DEBUG_EXT_FS_WATCHER
         qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
-                 << Q_FUNC_INFO << this << "File System modified" << pathModifiedOutside;
-#else
-  Q_UNUSED(pathModifiedOutside);
+                 << Q_FUNC_INFO << this << "File System modified in" << pathModifiedOutside;
 #endif
-        DirListWorker *w =
-                createWorkerRequest(IORequest::DirListExternalFSChanges,
-                                    mCurrentDir
-                                   );
-        ExternalFileSystemChangesWorker *extFsWorker =
-                static_cast<ExternalFileSystemChangesWorker*> (w);
-
-        connect(extFsWorker,    SIGNAL(added(DirItemInfo)),
-                this,         SLOT(onItemAddedOutsideFm(DirItemInfo)));
-        connect(extFsWorker,    SIGNAL(removed(DirItemInfo)),
-                this,         SLOT(onItemRemovedOutSideFm(DirItemInfo)));
-        connect(extFsWorker,    SIGNAL(changed(DirItemInfo)),
-                this,         SLOT(onItemChangedOutSideFm(DirItemInfo)));
-        connect(extFsWorker,    SIGNAL(finished(int)),
-                this,         SLOT(onExternalFsWorkerFinished(int)));
-
-        ioWorkerThread()->addRequest(extFsWorker);
+        mCurLocation->fetchExternalChanges(pathModifiedOutside,
+                                           mDirectoryContents,
+                                           currentDirFilter());
     }
 #if DEBUG_EXT_FS_WATCHER
     else
@@ -1342,7 +1316,7 @@
  */
 bool DirModel::getEnabledExternalFSWatcher() const
 {
-   return mExtFSWatcher ? true : false;
+   return mExtFSWatcher;
 }
 
 
@@ -1351,15 +1325,8 @@
  * \param enable
  */
 void DirModel::setEnabledExternalFSWatcher(bool enable)
-{
-    if(enable)
-    {
-        startExternalFsWatcher();
-    }
-    else
-    {
-        stoptExternalFsWatcher();
-    }
+{   
+    emit enabledExternalFSWatcherChanged(enable);
 }
 
 

=== modified file 'src/plugin/folderlistmodel/dirmodel.h'
--- src/plugin/folderlistmodel/dirmodel.h	2014-05-15 23:31:22 +0000
+++ src/plugin/folderlistmodel/dirmodel.h	2014-05-15 23:31:23 +0000
@@ -42,17 +42,11 @@
 #include "diriteminfo.h"
 
 class FileSystemAction;
-class ExternalFSWatcher;
 class Clipboard;
 class DirSelection;
-
-/*!
- *  When the External File System Wathcer is enabled,
- *  this is the interval used to check if there has been any change in the current path
- *
- *  \sa setEnabledExternalFSWatcher()
- */
-#define EX_FS_WATCHER_TIMER_INTERVAL   900
+class LocationsFactory;
+class Location;
+class ExternalFSWatcher;
 
 class DirModel : public DirItemAbstractListModel
 {
@@ -150,7 +144,7 @@
 
 public slots:
     void onItemsAdded(const DirItemInfoList &newFiles);
-    void onResultsFetched();
+    void onItemsFetched();
 
 signals:
     void awaitingResultsChanged();
@@ -206,7 +200,7 @@
     Q_PROPERTY(int clipboardUrlsCounter READ getClipboardUrlsCounter NOTIFY clipboardChanged)
     int getClipboardUrlsCounter() const;
 
-    Q_PROPERTY(bool enableExternalFSWatcher READ getEnabledExternalFSWatcher WRITE setEnabledExternalFSWatcher)
+    Q_PROPERTY(bool enableExternalFSWatcher READ getEnabledExternalFSWatcher WRITE setEnabledExternalFSWatcher NOTIFY enabledExternalFSWatcherChanged)
     bool  getEnabledExternalFSWatcher() const;
 
     Q_INVOKABLE QString homePath() const;
@@ -360,8 +354,8 @@
     void     showHiddenFilesChanged();
     void     sortByChanged();
     void     sortOrderChanged();
-
     void     clipboardChanged();
+    void     enabledExternalFSWatcherChanged(bool);
 
 private slots:
     void onItemRemoved(const QString&);
@@ -377,12 +371,11 @@
     QDir::Filter  currentDirFilter()  const;
     QString       dirItems(const DirItemInfo& fi) const;
     bool          cdInto(const DirItemInfo& fi);
-    bool          openItem(const DirItemInfo& fi);
-    DirListWorker * createWorkerRequest(IORequest::RequestType requestType,
-                                                  const QString& pathName);
+    bool          openItem(const DirItemInfo& fi);  
     bool          canReadDir(const QFileInfo& d)   const;
     bool          canReadFile(const QFileInfo& f)  const;
     QFileInfo     setParentIfRelative(const QString &fileOrDir) const;
+    void          setPathFromCurrentLocation();
 
 private:
     void          startExternalFsWatcher();
@@ -401,9 +394,11 @@
     SortBy              mSortBy;
     SortOrder           mSortOrder;
     CompareFunction     mCompareFunction;
-    ExternalFSWatcher*  mExtFSWatcher;
+    bool                mExtFSWatcher;
     Clipboard *         mClipboard;
     DirSelection *      mSelection;
+    LocationsFactory *  mLocationFactory;
+    Location         *  mCurLocation;
 
 
 private:

=== added directory 'src/plugin/folderlistmodel/disk'
=== added file 'src/plugin/folderlistmodel/disk/disklocation.cpp'
--- src/plugin/folderlistmodel/disk/disklocation.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/disk/disklocation.cpp	2014-05-15 23:31:23 +0000
@@ -0,0 +1,222 @@
+/**************************************************************************
+ *
+ * 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: disklocation.cpp
+ * Date: 08/03/2014
+ */
+
+#include "disklocation.h"
+#include "iorequest.h"
+#include "ioworkerthread.h"
+#include "externalfswatcher.h"
+
+#include <QDebug>
+
+#if defined(DEBUG_EXT_FS_WATCHER)
+# define DEBUG_WATCHER()  qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz") \
+                                   << Q_FUNC_INFO << this
+#else
+# define DEBUG_WATCHER() /**/
+#endif
+
+DiskLocation::DiskLocation(int type, QObject *parent)
+   : Location(type, parent)
+   , m_extWatcher(0)
+{
+}
+
+
+DiskLocation::~ DiskLocation()
+{
+    stopExternalFsWatcher();
+}
+
+
+void DiskLocation::fetchItems(QDir::Filter dirFilter, bool recursive)
+{
+    DirListWorker *dlw  = new DirListWorker(m_info->absoluteFilePath(), dirFilter, recursive);
+    connect(dlw,  SIGNAL(itemsAdded(DirItemInfoList)),
+            this, SIGNAL(itemsAdded(DirItemInfoList)));
+    connect(dlw,  SIGNAL(workerFinished()),
+            this, SLOT(onItemsFetched()));
+    workerThread()->addRequest(dlw);
+}
+
+
+bool DiskLocation::becomeParent()
+{
+    bool ret = false;
+    if (m_info && !m_info->isRoot())
+    {
+        DirItemInfo *other = new DirItemInfo(m_info->absolutePath());
+        if (other->isValid())
+        {
+            delete m_info;
+            m_info = other;
+            ret = true;
+        }
+        else
+        {
+            delete other;
+        }
+    }
+    return ret;
+}
+
+
+void DiskLocation::refreshInfo()
+{
+    if (m_info)
+    {
+        DirItemInfo *item = new DirItemInfo(m_info->absoluteFilePath());
+        delete m_info;
+        m_info = item;
+    }
+}
+
+
+/*!
+ * \brief DiskLocation::stopExternalFsWatcher() stops the External File System Watcher
+ */
+void DiskLocation::stopExternalFsWatcher()
+{
+        if (m_extWatcher)
+        {
+            DEBUG_WATCHER();
+            delete m_extWatcher;
+            m_extWatcher = 0;
+        }
+}
+
+
+/*!
+ * \brief DiskLocation::startExternalFsWatcher() starts the External File System Watcher
+ */
+void DiskLocation::startExternalFsWatcher()
+{
+    if (m_extWatcher == 0)
+    {
+        DEBUG_WATCHER();
+        m_extWatcher = new ExternalFSWatcher(this);
+        m_extWatcher->setIntervalToNotifyChanges(EX_FS_WATCHER_TIMER_INTERVAL);
+
+        connect(m_extWatcher, SIGNAL(pathModified(QString)),
+                this,         SIGNAL(extWatcherPathChanged(QString)));       
+       if (m_info)
+       {               //setCurrentPath() checks for empty paths
+           m_extWatcher->setCurrentPath(m_info->absoluteFilePath());
+       }     
+    }
+}
+
+
+void DiskLocation::onItemsFetched()
+{
+    if (m_extWatcher)
+    {
+         m_extWatcher->setCurrentPath(m_info->absoluteFilePath());
+    }
+    emit itemsFetched();
+}
+
+
+void DiskLocation::startWorking()
+{
+    if (m_usingExternalWatcher)
+    {
+        startExternalFsWatcher();
+    }
+}
+
+
+void DiskLocation::stopWorking()
+{
+    stopExternalFsWatcher();
+}
+
+
+void DiskLocation::fetchExternalChanges(const QString &path,
+                                        const DirItemInfoList &list,
+                                        QDir::Filter dirFilter)
+{
+     ExternalFileSystemChangesWorker *extFsWorker =
+          new ExternalFileSystemChangesWorker(list,
+                                              path,
+                                              dirFilter, false);
+     addExternalFsWorkerRequest(extFsWorker);
+
+
+}
+
+void DiskLocation::addExternalFsWorkerRequest(ExternalFileSystemChangesWorker *extFsWorker)
+{
+    connect(extFsWorker,    SIGNAL(added(DirItemInfo)),
+            this,           SIGNAL(extWatcherItemAdded(DirItemInfo)));
+
+    connect(extFsWorker,    SIGNAL(removed(DirItemInfo)),
+            this,           SIGNAL(extWatcherItemRemoved(DirItemInfo)));
+
+    connect(extFsWorker,    SIGNAL(changed(DirItemInfo)),
+            this,           SIGNAL(extWatcherItemChanged(DirItemInfo)));
+
+    connect(extFsWorker,    SIGNAL(finished(int)),
+            this,           SIGNAL(extWatcherChangesFetched(int)));
+
+        workerThread()->addRequest(extFsWorker);
+}
+
+
+ExternalFSWatcher  * DiskLocation::getExternalFSWatcher() const
+{   
+    return m_extWatcher;
+}
+
+
+void DiskLocation::setUsingExternalWatcher(bool use)
+{
+    Location::setUsingExternalWatcher(use);
+    if (m_usingExternalWatcher)
+    {
+        startExternalFsWatcher();
+    }
+    else
+    {
+        stopExternalFsWatcher();
+    }
+}
+
+
+DirItemInfo * DiskLocation::validateUrlPath(const QString& uPath)
+{
+    QString myPath(uPath);
+    QFileInfo tmpUrl(uPath);
+    if (tmpUrl.isRelative() && m_info)
+    {
+        tmpUrl.setFile(m_info->absoluteFilePath(), uPath);
+        myPath  =  tmpUrl.absoluteFilePath();
+    }
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "path:" << myPath;
+#endif
+    DirItemInfo * item = new DirItemInfo(myPath);
+    if (!item->isValid() || !item->exists() || !item->isContentReadable())
+    {
+        delete item;
+        item = 0;
+    }
+    return item;
+}

=== added file 'src/plugin/folderlistmodel/disk/disklocation.h'
--- src/plugin/folderlistmodel/disk/disklocation.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/disk/disklocation.h	2014-05-15 23:31:23 +0000
@@ -0,0 +1,81 @@
+/**************************************************************************
+ *
+ * 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: disklocation.h
+ * Date: 08/03/2014
+ */
+
+#ifndef DISKLOCATION_H
+#define DISKLOCATION_H
+
+#include "location.h"
+#include <QList>
+
+/*!
+ *  When the External File System Wathcer is enabled,
+ *  this is the interval used to check if there has been any change in the current path
+ *
+ *  \sa setEnabledExternalFSWatcher()
+ */
+#define EX_FS_WATCHER_TIMER_INTERVAL   900
+
+
+class ExternalFSWatcher;
+class ExternalFileSystemChangesWorker;
+
+/*!
+ * \brief The DiskLocation class extends \ref Location for Local Disk and provides a External File System watcher
+ */
+class DiskLocation : public Location
+{
+    Q_OBJECT
+public:
+    explicit DiskLocation(int type, QObject *parent=0);
+    virtual ~DiskLocation();
+
+    ExternalFSWatcher  * getExternalFSWatcher() const;
+
+    virtual void        fetchItems(QDir::Filter dirFilter, bool recursive = false) ;
+    virtual void        fetchExternalChanges(const QString& urlPath,
+                                             const DirItemInfoList& list,
+                                             QDir::Filter dirFilter) ;
+    virtual bool        becomeParent();
+    virtual void        refreshInfo();
+
+    virtual void        startExternalFsWatcher();
+    virtual void        stopExternalFsWatcher();
+
+    virtual void        startWorking();
+    virtual void        stopWorking();
+
+    virtual DirItemInfo *validateUrlPath(const QString& urlPath);
+
+protected:
+    void    addExternalFsWorkerRequest(ExternalFileSystemChangesWorker *);
+
+public slots:
+    virtual void setUsingExternalWatcher(bool use);
+
+protected slots:
+    void                onItemsFetched();
+
+protected:
+    ExternalFSWatcher *   m_extWatcher ;
+
+};
+
+#endif // DISKLOCATION_H

=== modified file 'src/plugin/folderlistmodel/filecompare.cpp'
--- src/plugin/folderlistmodel/filecompare.cpp	2014-02-05 15:31:44 +0000
+++ src/plugin/folderlistmodel/filecompare.cpp	2014-05-15 23:31:23 +0000
@@ -50,11 +50,10 @@
     if (b.isDir() && !a.isDir())
         return false;
 
-    bool ret = QString::localeAwareCompare(a.fileName(), b.fileName()) < 0;
+    bool ret = QString::localeAwareCompare(a.absoluteFilePath(), b.absoluteFilePath()) < 0;
 #if DEBUG_MESSAGES
-    qDebug() <<  Q_FUNC_INFO << ret << a.fileName() << b.fileName();
+    qDebug() <<  Q_FUNC_INFO << ret << a.absoluteFilePath() << b.absoluteFilePath();
 #endif
-
     return ret;
 }
 

=== modified file 'src/plugin/folderlistmodel/folderlistmodel.pri'
--- src/plugin/folderlistmodel/folderlistmodel.pri	2014-02-10 23:41:50 +0000
+++ src/plugin/folderlistmodel/folderlistmodel.pri	2014-05-15 23:31:23 +0000
@@ -9,7 +9,12 @@
            $$PWD/fmutil.cpp \
            $$PWD/dirselection.cpp \
            $$PWD/diriteminfo.cpp \
-           $$PWD/trash/qtrashdir.cpp
+           $$PWD/trash/qtrashdir.cpp \          
+           $$PWD/location.cpp \
+           $$PWD/locationsfactory.cpp \
+           $$PWD/disk/disklocation.cpp \          
+           $$PWD/locationurl.cpp \
+
 
 
 HEADERS += $$PWD/dirmodel.h \
@@ -24,10 +29,14 @@
            $$PWD/dirselection.h \          
            $$PWD/diritemabstractlistmodel.h \
            $$PWD/diriteminfo.h \
-           $$PWD/trash/qtrashdir.h
-
-
-INCLUDEPATH  += $$PWD $$PWD/trash
+           $$PWD/trash/qtrashdir.h \          
+           $$PWD/location.h \
+           $$PWD/locationsfactory.h \
+           $$PWD/disk/disklocation.h \           
+           $$PWD/locationurl.h \          
+
+
+INCLUDEPATH  += $$PWD $$PWD/trash $$PWD/disk
 
 greaterThan(QT_MAJOR_VERSION, 4) {
    QT += qml

=== added file 'src/plugin/folderlistmodel/location.cpp'
--- src/plugin/folderlistmodel/location.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/location.cpp	2014-05-15 23:31:23 +0000
@@ -0,0 +1,140 @@
+/**************************************************************************
+ *
+ * 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: location.cpp
+ * Date: 08/03/2014
+ */
+/**************************************************************************
+ *
+ * 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: locations.cpp
+ * Date: 04/03/2014
+ */
+
+#include "location.h"
+#include "ioworkerthread.h"
+
+Q_GLOBAL_STATIC(IOWorkerThread, ioWorkerThread)
+
+
+Location::Location(int type, QObject *parent)
+    : QObject(parent)
+    , m_info(0)
+    , m_type(type)
+    , m_usingExternalWatcher(false)
+{
+
+}
+
+Location::~Location()
+{
+    if (m_info)
+    {
+        delete m_info;
+        m_info = 0;
+    }
+}
+
+
+bool Location::isRoot() const
+{
+     return m_info ? m_info->isRoot() : false;
+}
+
+
+bool Location::isWritable() const
+{
+    return m_info->isWritable();
+}
+
+
+bool Location::isReadable() const
+{
+    return m_info ? m_info->isContentReadable() : false;
+}
+
+void Location::setInfoItem(const DirItemInfo &itemInfo)
+{
+    setInfoItem (new DirItemInfo(itemInfo));
+}
+
+void Location::setInfoItem(DirItemInfo *itemInfo)
+{
+    if (m_info)
+    {
+        delete m_info;
+    }
+    m_info = itemInfo;
+}
+
+
+QString Location::urlPath() const
+{
+    return m_info ? m_info->urlPath(): QString();
+}
+
+
+void Location::startWorking()
+{
+
+}
+
+void Location::stopWorking()
+{
+
+}
+
+bool Location::becomeParent()
+{
+    return false;
+}
+
+IOWorkerThread * Location::workerThread() const
+{
+    return ioWorkerThread();
+}
+
+
+//providing an empty method
+void Location::fetchExternalChanges(const QString &path,
+                                    const DirItemInfoList &list,
+                                    QDir::Filter dirFilter)
+{
+    Q_UNUSED(path);
+    Q_UNUSED(list);
+    Q_UNUSED(dirFilter);
+}
+
+
+void Location::setUsingExternalWatcher(bool use)
+{
+    m_usingExternalWatcher = use;
+}

=== added file 'src/plugin/folderlistmodel/location.h'
--- src/plugin/folderlistmodel/location.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/location.h	2014-05-15 23:31:23 +0000
@@ -0,0 +1,132 @@
+/**************************************************************************
+ *
+ * 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: location.h
+ * Date: 08/03/2014
+ */
+
+#ifndef LOCATION_H
+#define LOCATION_H
+
+#include "diriteminfo.h"
+
+#include <QObject>
+
+class IOWorkerThread;
+
+/*!
+ * \brief The Location class represents any location (full path) where there are items to browse: directories, shares, from Disk and from Network.
+ *
+ *  It is an abstract class the must be inherited for specific Location handling as example: \ref DiskLocation and \ref TrashLocation
+ *
+ *  The location must be able to:
+ *     \li  provide the browsing for the location in \ref fetchItems()
+ *     \li  become itself its parent in \ref becomeParent() it will allow easy \ref DirModel::cdUp()
+ *     \li  refresh its information in  \ref refreshInfo()
+ *     \li  validate its location (creates a valid DirItemInfo object or any descendent) from a url string
+ *
+ *  The \ref startWorking() is called by \ref LocationsFactory just before this location becomes the current in the File Manager
+ *  In the same way the \ref stopWorking() is called by \ref LocationsFactory just before this location no longer be the current in the File Manager
+ */
+class Location : public QObject
+{
+   Q_OBJECT
+public:
+    explicit Location( int type, QObject *parent=0);
+    virtual ~Location();
+
+    IOWorkerThread * workerThread() const;
+
+signals:
+    void     itemsAdded(const DirItemInfoList &files);
+    void     itemsFetched();
+    void     extWatcherPathChanged(const QString&);
+    void     extWatcherItemRemoved(const DirItemInfo&);
+    void     extWatcherItemChanged(const DirItemInfo&);
+    void     extWatcherItemAdded(const   DirItemInfo&);
+    void     extWatcherChangesFetched(int);
+
+public slots:
+    virtual void setUsingExternalWatcher(bool use);
+
+public: //pure functions
+    /*!
+     * \brief fetchItems() gets the content of the Location
+     *
+     * \param dirFilter   current Filter
+     * \param recursive   should get the content all sub dirs or not, (hardly ever it is true)
+     */
+    virtual void        fetchItems(QDir::Filter dirFilter, bool recursive=0) = 0;
+
+    /*!
+     * \brief refreshInfo() It must refresh the DirItemInfo
+     *
+     *  It can be used for example after receiving the signal about external disk file system changes
+     *  due to the current path permissions might have changed.
+     */
+    virtual void        refreshInfo() = 0;
+
+     /*!
+     * \brief becomeParent() The current path location becomes the parent Location
+     *
+     * When \ref isRoot() returns false  the current path location becomes the parent path location
+     *   in order to make it the current.
+     * It acts like a cdUp, but without fetching items; then calling \ref fetchItems() may get contents.
+     *
+     * \note It must take care of deleting \ref m_info when creating a new DirItemInfo/TrashItemInfo etc.
+     *
+     * \return true if it is possible to do like a cdUp.
+     */
+     virtual bool        becomeParent() = 0;
+
+    /*!
+      * \brief validateUrlPath()  Validates the urlPath (file or Directory) and creates a new Obeject from this path
+      *
+      *  If urlPath is a valid Directory it can be used later to set a new Location.
+      *
+      * \param urlPath
+      * \return a valid pointer to DirItemInfo object or NULL indicating something wrong with the path
+      */
+     virtual DirItemInfo *       validateUrlPath(const QString& urlPath)  = 0;
+
+public:
+    virtual void        fetchExternalChanges(const QString& urlPath,
+                                             const DirItemInfoList& list,
+                                             QDir::Filter dirFilter) ;
+    virtual void        setInfoItem(const DirItemInfo &itemInfo);
+    virtual void        setInfoItem(DirItemInfo *itemInfo);
+    virtual bool        isRoot() const;
+    virtual bool        isWritable() const;
+    virtual bool        isReadable() const;
+    virtual QString     urlPath() const;
+    virtual void        startWorking();
+    virtual void        stopWorking();
+
+    inline const DirItemInfo*  info() const  { return m_info; }
+    inline int                 type() const  { return m_type; }
+
+protected:
+     DirItemInfo *                m_info;
+     int                          m_type;
+     bool                         m_usingExternalWatcher;
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    friend class TestDirModel;
+#endif
+
+};
+#endif // LOCATION_H

=== added file 'src/plugin/folderlistmodel/locationsfactory.cpp'
--- src/plugin/folderlistmodel/locationsfactory.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/locationsfactory.cpp	2014-05-15 23:31:23 +0000
@@ -0,0 +1,181 @@
+/**************************************************************************
+ *
+ * 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: locationsfactory.cpp
+ * Date: 05/03/2014
+ */
+
+#include "diriteminfo.h"
+#include "locationsfactory.h"
+#include "location.h"
+#include "locationurl.h"
+#include "disklocation.h"
+
+
+#include <QDir>
+#include <QDebug>
+
+
+
+LocationsFactory::LocationsFactory(QObject *parent)
+ : QObject(parent)
+ , m_curLoc(0)
+ , m_lastValidFileInfo(0)
+{
+   m_locations.append(new DiskLocation(LocalDisk)); 
+}
+
+
+LocationsFactory::~LocationsFactory()
+{
+    ::qDeleteAll(m_locations);
+    m_locations.clear();
+}
+
+
+/*!
+ * \brief LocationsFactory::parse() identifies what main location that path/url refers to
+ * \param path it is supposed to be always a full path like: file:///myDir /myDir trash:/// trash:///myDir
+ * \return
+ */
+
+Location * LocationsFactory::parse(const QString& uPath)
+{
+    int index = -1;
+    int type  = -1;
+    Location * location = 0;   
+    if ( (index = uPath.indexOf(QChar(':'))) != -1 )
+    {
+#if defined(Q_OS_WIN)
+#else
+#if defined(Q_OS_UNIX)
+        if (uPath.startsWith(LocationUrl::TrashRootURL.midRef(0,6)))
+        {
+            type = TrashDisk;
+            m_tmpPath  = LocationUrl::TrashRootURL + stringAfterSlashes(uPath, index+1);
+        }
+        else
+#endif //Q_OS_UNIX
+#endif //Q_OS_UNIX
+        if (uPath.startsWith(LocationUrl::DiskRootURL.midRef(0,5)))
+        {
+            type = LocalDisk;
+            m_tmpPath  = QDir::rootPath() + stringAfterSlashes(uPath, index+1);
+        }
+    }
+    else
+    {
+        m_tmpPath = stringAfterSlashes(uPath, -1);
+        type    = LocalDisk;
+        if (!m_tmpPath.startsWith(QDir::rootPath()) && m_curLoc)
+        {
+            //it can be any, check current location
+            type = m_curLoc->type();
+        }
+    }
+    if (!m_tmpPath.isEmpty() && type != -1)
+    {
+        location = m_locations.at(type);       
+    }
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "input path:" << uPath  << "location result:" << location;
+#endif
+    return location;
+}
+
+
+Location * LocationsFactory::setNewPath(const QString& uPath)
+{
+    storeValidFileInfo(0);
+    Location *location = parse(uPath);
+    if (location)
+    {
+        DirItemInfo *item = location->validateUrlPath(m_tmpPath);
+        if (item)
+        {
+            //isContentReadable() must already carry execution permission
+            if (item->isValid() && item->isDir() && item->isContentReadable())
+            {
+                location->setInfoItem(item);
+                if (location != m_curLoc)
+                {
+                    if (m_curLoc)
+                    {
+                        m_curLoc->stopWorking();
+                    }
+                    emit locationChanged(m_curLoc, location);
+                    location->startWorking();
+                    m_curLoc = location;
+                }
+            }
+            else
+            {
+                storeValidFileInfo(item);
+            }
+        }
+        else
+        {   // not valid
+            location = 0;
+        }
+    }
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "input path:" << uPath  << "location result:" << location;
+#endif
+    return location;
+}
+
+
+QString  LocationsFactory::stringAfterSlashes(const QString &url, int firstSlashIndex) const
+{
+    QString ret;
+    if (firstSlashIndex >=0)
+    {
+        while ( firstSlashIndex < url.length() && url.at(firstSlashIndex) == QDir::separator())
+        {
+            ++firstSlashIndex;
+        }
+        if (firstSlashIndex < url.length())
+        {
+            ret = url.mid(firstSlashIndex);
+        }
+    }
+    else
+    {
+        ret = url;
+        firstSlashIndex = 0;
+    }
+    //replace any double slashes by just one
+    for(int charCounter = ret.size() -1; charCounter > 0; --charCounter)
+    {
+        if (ret.at(charCounter) == QDir::separator() &&
+                ret.at(charCounter-1) == QDir::separator())
+        {
+            ret.remove(charCounter,1);
+        }
+    }
+    return ret;
+}
+
+
+void LocationsFactory::storeValidFileInfo(const DirItemInfo *item)
+{
+    if (m_lastValidFileInfo)
+    {
+        delete m_lastValidFileInfo;
+    }
+    m_lastValidFileInfo = item;
+}

=== added file 'src/plugin/folderlistmodel/locationsfactory.h'
--- src/plugin/folderlistmodel/locationsfactory.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/locationsfactory.h	2014-05-15 23:31:23 +0000
@@ -0,0 +1,136 @@
+/**************************************************************************
+ *
+ * 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: locationsfactory.h
+ * Date: 05/03/2014
+ */
+
+#ifndef LOCATIONSFACTORY_H
+#define LOCATIONSFACTORY_H
+
+#include <QObject>
+#include <QList>
+
+
+class Location;
+class DirItemInfo;
+
+/*!
+ * \brief The LocationsFactory class represents the set of main
+ *        URL locations the File Manager supports.
+ *
+ *  It is basically devided into main groups:
+ *   \li Disk: \ref LocalDisk and \ref TrashDisk
+ *   \li Net:  \ref NetSambaShare and NetFishShare
+ *
+ * smb://   browses workgroup
+ *
+ * Location parser: \ref parser()
+ * \li   \\workkgroup                    becomes smb://workgroup
+ * \li   \\                              becomes smb://
+ * \li   trash:/  and  trash://          becomes trash:///
+ * \li   fish:/   and  fish://           becomes fish:///
+ * \li   file:/ , file://  and file:///  becomes /
+ *
+ * \note Due to current File Manager UI typing method both: "file:" and "trash:" are supported
+ */
+class LocationsFactory : public QObject
+{
+   Q_OBJECT
+public:
+    explicit LocationsFactory(QObject *parent = 0);
+    ~LocationsFactory();
+
+    Q_ENUMS(Locations)
+    enum Locations
+    {
+        LocalDisk,     //<! any mounted file system
+        TrashDisk      //<! special trash location in the disk
+#if 0
+        NetSambaShare  //<! SAMBA or CIFS shares
+        NetFishShare   //<! FISH protocol over ssh that provides file sharing
+#endif
+    };
+
+    inline const Location * getLocation(Locations index) const {return m_locations.at(index);}
+
+
+    /*!
+     * \brief parse()  Just parses (does not set/change the current location) according to \a urlPath
+     * \param urlPath  urlPath the url like: file:///Item trash:///item /item, it MUST point to a valid Directory
+     * \return   The location which supports the \a  urlPath
+     */
+    Location * parse(const QString& urlPath);
+
+    /*!
+     * \brief setNewPath() Sets a new path, it can be in the current location or on another location
+     *
+     *   When the location changes, the signal \ref locationChanged() is fired.
+     *
+     * \param urlPath the url like: file:///Item trash:///item /item, it MUST point to a valid Directory
+     * \return the location that supports the urlPath or NULL when \a urlPath is NOT a valid url or it is not a valid Directory
+     *
+     *  \sa \ref parse() \ref location()
+     */
+    Location * setNewPath(const QString& urlPath);
+
+    /*!
+     * \brief location()
+     * \return The current location
+     */
+    Location * location() const { return m_curLoc; }
+
+    /*!
+     * \brief availableLocations()
+     * \return
+     */
+    const QList<Location*>&
+                     availableLocations() const { return m_locations; }
+
+    /*!
+     * \brief lastValidFileInfo()
+     *
+     * When calling setNewPath(file_path) using a path to a File instead of a Directory
+     * the setNewPath() is not able to set a new path (current location or other), however it uses
+     * Location::validateUrlPath() which validates the path for files also, then this valid DirItemInfo object
+     * is saved using \ref  storeValidFileInfo() for further use.
+     *
+     * \return The last valid DirItemInfo parsed which is not a Directory
+     */
+    const DirItemInfo* lastValidFileInfo() const { return m_lastValidFileInfo; }
+
+    void        storeValidFileInfo(const DirItemInfo *item);
+
+signals:
+    void        locationChanged(const Location *old, const Location *current);
+
+private:
+    QString     stringAfterSlashes(const QString& url, int firstSlashIndex) const;
+
+private:
+     Location         *  m_curLoc;
+     QList<Location*>    m_locations;
+     QString             m_tmpPath;
+     const DirItemInfo * m_lastValidFileInfo;
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    friend class TestDirModel;
+#endif
+
+};
+
+#endif // LOCATIONSFACTORY_H

=== added file 'src/plugin/folderlistmodel/locationurl.cpp'
--- src/plugin/folderlistmodel/locationurl.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/locationurl.cpp	2014-05-15 23:31:23 +0000
@@ -0,0 +1,34 @@
+/**************************************************************************
+ *
+ * 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: locationurl.cpp
+ * Date: 11/03/2014
+ */
+
+#include "locationurl.h"
+
+const QString LocationUrl::TrashRootURL("trash:///");
+const QString LocationUrl::DiskRootURL("file:///");
+#if 0
+QString LocationURL::SmbURL("smb://");
+QString LocationURL::FishURL("fish:///");
+#endif
+
+
+LocationUrl::LocationUrl()
+{
+}

=== added file 'src/plugin/folderlistmodel/locationurl.h'
--- src/plugin/folderlistmodel/locationurl.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/locationurl.h	2014-05-15 23:31:23 +0000
@@ -0,0 +1,40 @@
+/**************************************************************************
+ *
+ * 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: locationurl.h
+ * Date: 11/03/2014
+ */
+
+#ifndef LOCATIONURL_H
+#define LOCATIONURL_H
+
+#include <QString>
+
+class LocationUrl
+{
+public:
+    static const   QString DiskRootURL;
+    static const   QString TrashRootURL;
+#if 0
+    static const   QString SmbURL;
+    static const   QString FishURL;
+#endif
+private:
+    LocationUrl();
+};
+
+#endif // LOCATIONURL_H

=== modified file 'src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp'
--- src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp	2014-05-15 23:31:22 +0000
+++ src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp	2014-05-15 23:31:23 +0000
@@ -3,7 +3,11 @@
 #include "tempfiles.h"
 #include "externalfswatcher.h"
 #include "dirselection.h"
-#include "trash/qtrashdir.h"
+#include "qtrashdir.h"
+#include "location.h"
+#include "locationurl.h"
+#include "locationsfactory.h"
+#include "disklocation.h"
 
 #if defined(Q_OS_UNIX)
 #include <stdio.h>
@@ -143,6 +147,8 @@
     void modelSelectionItemsRange();
 
     void trashDiretories();
+    void locationFactory();
+
 
 private:
     void initDeepDirs();
@@ -2389,6 +2395,45 @@
 }
 
 
+void TestDirModel::locationFactory()
+{
+    LocationsFactory factoryLocations(this);
+    const Location *location = 0;   
+
+   //Due to current File Manager UI typing method both: "file:" and "trash:" are supported
+   // location = factoryLocations.setNewPath("trash:");
+   // QVERIFY(location == 0);
+
+    location = factoryLocations.setNewPath("file://////");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::LocalDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   QDir::rootPath());
+    QCOMPARE(location->urlPath(), QDir::rootPath());
+    QCOMPARE(location->isRoot(), true);
+
+    location = factoryLocations.setNewPath("/");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::LocalDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   QDir::rootPath());
+    QCOMPARE(location->urlPath(), QDir::rootPath());
+    QCOMPARE(location->isRoot(), true);
+
+    location = factoryLocations.setNewPath("//");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::LocalDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   QDir::rootPath());
+    QCOMPARE(location->urlPath(), QDir::rootPath());
+    QCOMPARE(location->isRoot(), true);
+
+    location = factoryLocations.setNewPath("//bin");
+    QVERIFY(location);
+    QVERIFY(location->type() == LocationsFactory::LocalDisk);
+    QCOMPARE(location->info()->absoluteFilePath(),   QLatin1String("/bin"));
+    QCOMPARE(location->urlPath(), QLatin1String("/bin"));
+    QCOMPARE(location->isRoot(), false);   
+}
+
+
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);