Merge lp:~dpm/ubuntu-filemanager-app/include-plugin into lp:ubuntu-filemanager-app

[David Planella]

Merge the C++ folderlistmodel plugin into the app's source tree

After a conversation with sergiusens it seems we can no longer build the File Manager app click package in our CI infrastructure if the plugin lives outside of the app's source tree.

This merge proposal does exactly that: bring the plugin into the app's source tree. It should be considered as work in progress, but as I'm not a cmake expert, I'm sending it as a request for feedback before merging it in.

What works:
- Project builds in Qt Creator
- click-buddy builds and packages the plugin and the app successfully
- Ctrl+R in Qt Creator runs the app
- Debian packaging: two independent packages (app and plugin) are generated

What's not yet implemented:
- The plugin depends on taglib1-dev. If it's not installed, cmake will fail. It'd be nice to add a check for it, but it seems cmake has only in-built checks for a certain number of libraries.

What will be addressed in a separate MP:
- Fix copyright headers of the plugin, which don't seem to point to the original sources

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

FAILED: Continuous integration, rev:158
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~dpm/ubuntu-filemanager-app/include-plugin/+merge/213368/+edit-commit-message

http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/149/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/1918/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/149/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/149/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/99/console

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

review: Needs Fixing (continuous-integration)

[Sergio Schvezov (sergiusens)]

20 + set(EXEC "qmlscene -qt5 qml/${MAIN_QML} -I ../plugin")

Prefer to use the upstart app launch set import dirs of lib/$arch/ and remove -I ../plugin"
If not set QT_IMPORTS_DIR will need to be set to this.

Additionally, and not related, I thought this project was forked from org.nemo but the copyright headers have:
197 + * Copyright 2014 Canonical Ltd.
198 + * Copyright 2014 Carlos J Mazieri <email address hidden>

and no trace of the original.

review: Needs Fixing

[David Planella (dpm)]

On Tue, Apr 1, 2014 at 10:12 AM, Sergio Schvezov <
<email address hidden>> wrote:

> Review: Needs Fixing
>
> 20 + set(EXEC "qmlscene -qt5 qml/${MAIN_QML} -I ../plugin")
>
> Prefer to use the upstart app launch set import dirs of lib/$arch/ and
> remove -I ../plugin"
> If not set QT_IMPORTS_DIR will need to be set to this.
>
>
Ok, thanks for the review! I think I've addressed this now, at least for
the click package build.

>
> Additionally, and not related, I thought this project was forked from
> org.nemo but the copyright headers have:
> 197 + * Copyright 2014 Canonical Ltd.
> 198 + * Copyright 2014 Carlos J Mazieri <email address hidden>
>
> and no trace of the original.
>

Oh, wow, I hadn't seen it. Yes, this needs to be addressed for all headers,
I'll send a separate MP fixing this.

[Sergio Schvezov (sergiusens)]

> On Tue, Apr 1, 2014 at 10:12 AM, Sergio Schvezov <
> <email address hidden>> wrote:
>
> > Review: Needs Fixing
> >
> > 20 + set(EXEC "qmlscene -qt5 qml/${MAIN_QML} -I ../plugin")
> >
> > Prefer to use the upstart app launch set import dirs of lib/$arch/ and
> > remove -I ../plugin"
> > If not set QT_IMPORTS_DIR will need to be set to this.
> >
> >
> Ok, thanks for the review! I think I've addressed this now, at least for
> the click package build.

Seems this looks good now

[Sergio Schvezov (sergiusens)]

95 +add_executable(filemanager ${filemanager_SRCS})
108 + install(TARGETS filemanager DESTINATION ${BIN_DIR})

I thought filemanager was launched with qmlscene $@

Is there a reason for building this? If so the exec needs to indeed change; but I'm guessing this isn't supposed to be there

[David Planella (dpm)]

On Tue, Apr 1, 2014 at 4:28 PM, Sergio Schvezov <
<email address hidden>> wrote:

> 95 +add_executable(filemanager ${filemanager_SRCS})
> 108 + install(TARGETS filemanager DESTINATION ${BIN_DIR})
>
> I thought filemanager was launched with qmlscene $@
>
> Is there a reason for building this? If so the exec needs to indeed
> change; but I'm guessing this isn't supposed to be there
>

This is intentional. The original intention was to use qmlscene, but as
pointed out in the original description, then Qt Creator could not launch
the app. After digging deeper into this and a conversation with zbenjamin,
it seems Qt Creator's cmake plugin cannot handle mixed (QML + C++) projects
to be launched with qmlscene, as it cannot actually detect which type of
project it is.

So the suggestion was to use a binary that does the work of qmlscene, so
that Qt Creator can launch that. Essentially, we're now doing what
Reminders does too.

So if this is needed, which exec needs to be changed?

[Carlos Jose Mazieri (carlos-mazieri)]

> 20 + set(EXEC "qmlscene -qt5 qml/${MAIN_QML} -I ../plugin")
>
> Prefer to use the upstart app launch set im3port dirs of lib/$arch/ and remove
> -I ../plugin"
> If not set QT_IMPORTS_DIR will need to be set to this.
>
>
> Additionally, and not related, I thought this project was forked from org.nemo
> but the copyright headers have:
> 197 + * Copyright 2014 Canonical Ltd.
> 198 + * Copyright 2014 Carlos J Mazieri <email address hidden>
>
> and no trace of the original.

The project was forked from Nemo Mobile, orignal files were using BSD license, several files were added I just mentioned GPLv3 as result of some discussion we had about it in the meetings.

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

FAILED: Continuous integration, rev:160
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~dpm/ubuntu-filemanager-app/include-plugin/+merge/213368/+edit-commit-message

http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/150/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2017/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/150/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/150/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/100/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:161
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/151/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2024/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/151/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/151/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/101/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:167
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/152/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2025/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/152/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/152/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/102/console

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

review: Needs Fixing (continuous-integration)

[Carlos Jose Mazieri (carlos-mazieri)]

It looks OK to me, everything is there.

I downloaded and tested https://code.launchpad.net/~dpm/ubuntu-filemanager-app/include-plugin using "qmake" instead of "cmake".

review: Approve

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

FAILED: Continuous integration, rev:168
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/153/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2036
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/153
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/153
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/103

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

review: Needs Fixing (continuous-integration)

[Nicholas Skaggs (nskaggs)]

Looking close!

[Nicholas Skaggs (nskaggs)]

I'm proposing a merge to solve the AP launch issue.

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

FAILED: Continuous integration, rev:170
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/155/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2089/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/155/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/155/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/105/console

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

review: Needs Fixing (continuous-integration)

[Nicholas Skaggs (nskaggs)]

Work happening here:

https://code.launchpad.net/~nskaggs/ubuntu-filemanager-app/ap-binary-support/+merge/215706

I've kicked off a build of jenkins including my commits, and I'll iterate if needed till we see proper launching.

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

FAILED: Continuous integration, rev:171
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/156/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2090/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/156/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/156/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/106/console

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

review: Needs Fixing (continuous-integration)

[Nicholas Skaggs (nskaggs)]

All working on my side; merge away :-)

https://code.launchpad.net/~nskaggs/ubuntu-filemanager-app/ap-binary-support/+merge/215724

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

PASSED: Continuous integration, rev:171
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/165/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2111
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-raring-amd64-ci/165
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-saucy-amd64-ci/165
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/115

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

review: Approve (continuous-integration)

[Nicholas Skaggs (nskaggs)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2013-12-30 20:31:12 +0000
+++ .bzrignore	2014-04-15 08:19:22 +0000
@@ -6,3 +6,5 @@
 debian/app-template/
 debian/*.debhelper.log
 debian/*.substvars
+.excludes
+*.user

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-03-26 14:25:39 +0000
+++ CMakeLists.txt	2014-04-15 08:19:22 +0000
@@ -1,6 +1,9 @@
-project(com.ubuntu.filemanager)
+project(com.ubuntu.filemanager C CXX)
 cmake_minimum_required(VERSION 2.8.9)
 
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra -fPIC")
+
 # Standard install paths
 include(GNUInstallDirs)
 
@@ -8,49 +11,56 @@
 option(CLICK_MODE "Installs to a contained location" off)
 
 set(APP_NAME filemanager)
-set(DESKTOP_FILE "${PROJECT_NAME}_${APP_NAME}.desktop")
+set(DESKTOP_FILE "${PROJECT_NAME}.desktop")
 set(URLS_FILE "${PROJECT_NAME}_${APP_NAME}.url-dispatcher")
 set(APP_HARDCODE ubuntu-filemanager-app)
 set(MAIN_QML ${APP_HARDCODE}.qml)
 set(ICON_FILE filemanager64.png)
 set(AUTOPILOT_DIR ubuntu_filemanager_app)
+set(EXEC "filemanager")
 
 if(CLICK_MODE)
     if(NOT DEFINED BZR_SOURCE)
         set(BZR_SOURCE "lp:${APP_HARDCODE}")
         message("-- Setting BZR_SOURCE to ${BZR_SOURCE}")
     endif(NOT DEFINED BZR_SOURCE)
+    # Find out the architecture for package building
+    # to determine the plugin's installation path
+    execute_process(
+        COMMAND dpkg-architecture -qDEB_HOST_MULTIARCH
+        OUTPUT_VARIABLE ARCH_TRIPLET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
     set(CMAKE_INSTALL_PREFIX /)
     set(CMAKE_INSTALL_BINDIR /)
     set(DATA_DIR /)
     set(ICON ${ICON_FILE})
-    set(EXEC "qmlscene -qt5 ${MAIN_QML}")
+    set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
+    set(BIN_DIR /lib/${ARCH_TRIPLET}/bin)
     set(DESKTOP_DIR ${DATA_DIR})
     set(URLS_DIR ${DATA_DIR})
+    install(FILES manifest.json apparmor.json DESTINATION ${CMAKE_INSTALL_PREFIX})
 else(CLICK_MODE)
+    execute_process(
+        COMMAND qmake -query QT_INSTALL_QML
+        OUTPUT_VARIABLE QT_IMPORTS_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
     set(DATA_DIR ${CMAKE_INSTALL_DATADIR}/${APP_HARDCODE})
-    set(EXEC ${APP_HARDCODE})
     set(ICON ${CMAKE_INSTALL_PREFIX}/${DATA_DIR}/${ICON_FILE})
-    configure_file(${APP_HARDCODE}.in
-        ${CMAKE_CURRENT_BINARY_DIR}/${APP_HARDCODE})
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${APP_HARDCODE}
-        DESTINATION ${CMAKE_INSTALL_BINDIR})
     set(DESKTOP_DIR ${CMAKE_INSTALL_DATADIR}/applications)
     set(URLS_DIR ${CMAKE_INSTALL_DATADIR}/url-dispatcher/urls)
 endif(CLICK_MODE)
 
 file(GLOB_RECURSE I18N_SRC_FILES
      RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
-     rc/**.qml desktop/**.desktop.in)
+     src/app/**.qml *.desktop.in)
 list(SORT I18N_SRC_FILES)
 
-
 file(GLOB SRC_FILES
      RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
-     *.qml *.js *.png *.js *.json)
-install(DIRECTORY ui components icons
-    DESTINATION ${DATA_DIR})
-install(FILES ${SRC_FILES} ${ICON_FILE} DESTINATION ${DATA_DIR})
+     *.qml *.js *.png *.js)
+install(FILES ${SRC_FILES}  DESTINATION ${DATA_DIR})
 
 configure_file(${DESKTOP_FILE}.in ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE}
@@ -61,6 +71,6 @@
 # Tests
 enable_testing()
 
-add_subdirectory(click)
 add_subdirectory(po)
 add_subdirectory(tests)
+add_subdirectory(src)

=== renamed file 'click/apparmor.json' => 'apparmor.json'
--- click/apparmor.json	2014-01-31 20:03:12 +0000
+++ apparmor.json	2014-04-15 08:19:22 +0000
@@ -1,4 +1,4 @@
 {
-    "policy_version": 1.0, 
+    "policy_version": 1.1, 
     "template": "unconfined"
-}
\ No newline at end of file
+}

=== removed directory 'click'
=== removed file 'click/CMakeLists.txt'
--- click/CMakeLists.txt	2014-01-31 20:03:12 +0000
+++ click/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-if(CLICK_MODE)
-    if(NOT BZR_REVNO)
-        set(BZR_REVNO "latest")
-    endif(NOT BZR_REVNO)
-    configure_file(manifest.json.in ${CMAKE_CURRENT_BINARY_DIR}/manifest.json)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json apparmor.json
-            DESTINATION ${CMAKE_INSTALL_PREFIX})
-endif(CLICK_MODE)

=== renamed file 'com.ubuntu.filemanager_filemanager.desktop.in' => 'com.ubuntu.filemanager.desktop.in'
=== modified file 'debian/changelog'
--- debian/changelog	2013-04-19 20:30:19 +0000
+++ debian/changelog	2014-04-15 08:19:22 +0000
@@ -1,3 +1,10 @@
+ubuntu-filemanager-app (0.2) trusty; urgency=medium
+
+  * Merged the plugin code into the main tree, now the main source package
+    generates a binary package for the app and another for the plugin
+
+ -- David Planella <[e-mail]>  Thu, 10 Apr 2014 09:23:41 +0200
+
 ubuntu-filemanager-app (0.1.1) raring; urgency=low
 
   * Initial release

=== modified file 'debian/control'
--- debian/control	2014-03-07 21:10:42 +0000
+++ debian/control	2014-04-15 08:19:22 +0000
@@ -4,14 +4,19 @@
 Build-Depends: cmake,
                debhelper (>= 9),
                python,
-Standards-Version: 3.9.4
+               qtbase5-dev,
+               qtdeclarative5-dev,
+               qt5-default,
+               pkg-kde-tools,
+               libtag1-dev,
+Standards-Version: 3.9.5
 Section: misc
 Homepage: https://launchpad.net/ubuntu-filemanager-app
 Vcs-Bzr: https://code.launchpad.net/~ubuntu-filemanager-dev/ubuntu-filemanager-app/trunk
 
 Package: ubuntu-filemanager-app
 Section: misc
-Architecture: all
+Architecture: any
 Depends: qmlscene,
          qtdeclarative5-hud1.0,
          qtdeclarative5-nemo-qml-plugin-folderlistmodel,
@@ -22,6 +27,18 @@
 Description: File Manager application
  Core File Manager application
 
+Package: qtdeclarative5-nemo-qml-plugin-folderlistmodel
+Architecture: any
+Multi-Arch: same
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Description: Nemo QML plugin - folder list model
+ Qt is a cross-platform C++ application framework. Qt's primary feature
+ is its rich set of widgets that provide standard GUI functionality.
+ .
+ This package contains the Folder List model plugin of the Nemo QML 
+ plugins collection.
+
 Package: ubuntu-filemanager-app-autopilot
 Architecture: all
 Depends: libautopilot-qt (>= 1.4),

=== added file 'debian/qtdeclarative5-nemo-qml-plugin-folderlistmodel.install'
--- debian/qtdeclarative5-nemo-qml-plugin-folderlistmodel.install	1970-01-01 00:00:00 +0000
+++ debian/qtdeclarative5-nemo-qml-plugin-folderlistmodel.install	2014-04-15 08:19:22 +0000
@@ -0,0 +1,1 @@
+usr/lib/*/qt5/qml/org/nemomobile/folderlistmodel/

=== renamed file 'click/manifest.json.in' => 'manifest.json'
--- click/manifest.json.in	2014-04-11 22:15:18 +0000
+++ manifest.json	2014-04-15 08:19:22 +0000
@@ -1,23 +1,24 @@
 {
     "description": "File Manager application",
-    "framework": "ubuntu-sdk-13.10",
+    "framework": "ubuntu-sdk-14.04-dev1",
+    "architecture": "armhf",
     "hooks": {
-        "@APP_NAME@": {
+        "filemanager": {
             "apparmor": "apparmor.json",
-            "desktop": "@DESKTOP_FILE@",
-            "urls": "@URLS_FILE@"
+            "desktop": "com.ubuntu.filemanager.desktop",
+            "urls": "com.ubuntu.filemanager_filemanager.url-dispatcher"
         }
     },
-    "icon": "@ICON@",
+    "icon": "filemanager64.png",
     "maintainer": "Ubuntu App Cats <[e-mail]>",
-    "name": "@PROJECT_NAME@",
+    "name": "com.ubuntu.filemanager",
     "title": "File Manager",
-    "version": "0.1.1.@BZR_REVNO@",
+    "version": "0.3",
     "x-source": {
-        "vcs-bzr": "@BZR_SOURCE@",
-        "vcs-bzr-revno": "@BZR_REVNO@"
+        "vcs-bzr": "lp:ubuntu-filemanager-app",
+        "vcs-bzr-revno": "latest"
     },
     "x-test": {
-        "autopilot": "@AUTOPILOT_DIR@"
+        "autopilot": "ubuntu_filemanager_app"
     }
-}
+}
\ No newline at end of file

=== removed file 'plugins.json'
--- plugins.json	2013-10-10 16:43:14 +0000
+++ plugins.json	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-[
-{
-    "package": "qtdeclarative5-nemo-qml-plugin-folderlistmodel",
-    "ppa": "ppa:ubuntu-touch-coreapps-drivers/daily"
-}
-]

=== added directory 'src'
=== added file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/CMakeLists.txt	2014-04-15 08:19:22 +0000
@@ -0,0 +1,2 @@
+add_subdirectory(plugin)
+add_subdirectory(app)

=== added directory 'src/app'
=== added file 'src/app/CMakeLists.txt'
--- src/app/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/app/CMakeLists.txt	2014-04-15 08:19:22 +0000
@@ -0,0 +1,24 @@
+file(GLOB_RECURSE QML_SRCS *.qml *.js)
+
+set(filemanager_SRCS
+    main.cpp
+    ${QML_SRCS}
+)
+
+add_executable(filemanager ${filemanager_SRCS})
+
+qt5_use_modules(filemanager Gui Qml Quick)
+
+if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+add_custom_target(filemanager-qmlfiles ALL
+    COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/qml ${CMAKE_CURRENT_BINARY_DIR}
+    DEPENDS ${QMLFILES}
+)
+endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+
+install(DIRECTORY qml DESTINATION ${DATA_DIR})
+if(CLICK_MODE)
+  install(TARGETS filemanager DESTINATION ${BIN_DIR})
+else()
+  install(TARGETS filemanager RUNTIME DESTINATION bin)
+endif()

=== added file 'src/app/main.cpp'
--- src/app/main.cpp	1970-01-01 00:00:00 +0000
+++ src/app/main.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,114 @@
+/*
+ * Copyright: 2013 - 2014 Canonical, Ltd
+ *
+ * This file is part of ubuntu-filemanager-app
+ *
+ * ubuntu-filemanager-app is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * ubuntu-filemanager-app 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Michael Zanetti <[e-mail]>
+ *          Riccardo Padovani <[e-mail]>
+ *          David Planella <[e-mail]>
+ */
+
+#include <QtGui/QGuiApplication>
+#include <QtQuick/QQuickView>
+#include <QtQml/QtQml>
+#include <QLibrary>
+
+#include <QDebug>
+
+int main(int argc, char *argv[])
+{
+    QGuiApplication a(argc, argv);
+    QQuickView view;
+    view.setResizeMode(QQuickView::SizeRootObjectToView);
+
+    // Set up import paths
+    QStringList importPathList = view.engine()->importPathList();
+    importPathList.append(QDir::currentPath() + "/../plugin/");
+
+    QStringList args = a.arguments();
+    if (args.contains("-h") || args.contains("--help")) {
+        qDebug() << "usage: " + args.at(0) + " [-p|--phone] [-t|--tablet] [-h|--help] [-I <path>]";
+        qDebug() << "    -p|--phone    If running on Desktop, start in a phone sized window.";
+        qDebug() << "    -t|--tablet   If running on Desktop, start in a tablet sized window.";
+        qDebug() << "    -h|--help     Print this help.";
+        qDebug() << "    -I <path>     Give a path for an additional QML import directory. May be used multiple times.";
+        qDebug() << "    -q <qmlfile>  Give an alternative location for the main qml file.";
+        return 0;
+    }
+
+    QString qmlfile;
+    for (int i = 0; i < args.count(); i++) {
+        if (args.at(i) == "-I" && args.count() > i + 1) {
+            QString addedPath = args.at(i+1);
+            if (addedPath.startsWith('.')) {
+                addedPath = addedPath.right(addedPath.length() - 1);
+                addedPath.prepend(QDir::currentPath());
+            }
+            importPathList.append(addedPath);
+        } else if (args.at(i) == "-q" && args.count() > i + 1) {
+            qmlfile = args.at(i+1);
+        }
+    }
+
+    if (args.contains(QLatin1String("-testability")) || getenv("QT_LOAD_TESTABILITY")) {
+        QLibrary testLib(QLatin1String("qttestability"));
+        if (testLib.load()) {
+            typedef void (*TasInitialize)(void);
+            TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
+            if (initFunction) {
+                initFunction();
+            } else {
+                qCritical("Library qttestability resolve failed!");
+            }
+        } else {
+            qCritical("Library qttestability load failed!");
+        }
+    }
+
+    view.engine()->rootContext()->setContextProperty("tablet", QVariant(false));
+    view.engine()->rootContext()->setContextProperty("phone", QVariant(false));
+    if (args.contains("-t") || args.contains("--tablet")) {
+        qDebug() << "running in tablet mode";
+        view.engine()->rootContext()->setContextProperty("tablet", QVariant(true));
+    } else if (args.contains("-p") || args.contains("--phone")){
+        qDebug() << "running in phone mode";
+        view.engine()->rootContext()->setContextProperty("phone", QVariant(true));
+    } else if (qgetenv("QT_QPA_PLATFORM") != "ubuntumirclient") {
+        // Default to tablet size on X11
+        view.engine()->rootContext()->setContextProperty("tablet", QVariant(true));
+    }
+
+    view.engine()->setImportPathList(importPathList);
+
+    // load the qml file
+    if (qmlfile.isEmpty()) {
+        QStringList paths = QStandardPaths::standardLocations(QStandardPaths::DataLocation);
+        paths.prepend(".");
+
+        foreach (const QString &path, paths) {
+            QFileInfo fi(path + "/qml/ubuntu-filemanager-app.qml");
+            if (fi.exists()) {
+                qmlfile = path +  "/qml/ubuntu-filemanager-app.qml";
+                break;
+            }
+        }
+    }
+    qDebug() << "using main qml file from:" << qmlfile;
+    view.setSource(QUrl::fromLocalFile(qmlfile));
+    view.show();
+
+    return a.exec();
+}

=== renamed directory 'components' => 'src/app/qml'
=== added directory 'src/app/qml/components'
=== renamed file 'components/AutoSpacedGrid.qml' => 'src/app/qml/components/AutoSpacedGrid.qml'
=== renamed file 'components/FolderIconDelegate.qml' => 'src/app/qml/components/FolderIconDelegate.qml'
=== renamed file 'components/FolderIconView.qml' => 'src/app/qml/components/FolderIconView.qml'
=== renamed file 'components/FolderListDelegate.qml' => 'src/app/qml/components/FolderListDelegate.qml'
=== renamed file 'components/FolderListView.qml' => 'src/app/qml/components/FolderListView.qml'
=== renamed file 'components/PathBar.qml' => 'src/app/qml/components/PathBar.qml'
=== renamed file 'components/PlacesSidebar.qml' => 'src/app/qml/components/PlacesSidebar.qml'
=== renamed file 'components/Sidebar.qml' => 'src/app/qml/components/Sidebar.qml'
=== renamed file 'components/SuruSheetStyle.qml' => 'src/app/qml/components/SuruSheetStyle.qml'
=== renamed file 'components/VerticalDivider.qml' => 'src/app/qml/components/VerticalDivider.qml'
=== renamed file 'ubuntu-filemanager-app.qml' => 'src/app/qml/ubuntu-filemanager-app.qml'
=== renamed directory 'ui' => 'src/app/qml/ui'
=== added directory 'src/plugin'
=== added file 'src/plugin/CMakeLists.txt'
--- src/plugin/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/plugin/CMakeLists.txt	2014-04-15 08:19:22 +0000
@@ -0,0 +1,7 @@
+include(FindPkgConfig)
+find_package(Qt5Core)
+find_package(Qt5Qml)
+find_package(Qt5Quick)
+find_package(Qt5Widgets)
+
+add_subdirectory(folderlistmodel)

=== added directory 'src/plugin/folderlistmodel'
=== added file 'src/plugin/folderlistmodel/CMakeLists.txt'
--- src/plugin/folderlistmodel/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/CMakeLists.txt	2014-04-15 08:19:22 +0000
@@ -0,0 +1,54 @@
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set(folderlistmodel_SRCS
+    clipboard.cpp
+    clipboard.h
+    diritemabstractlistmodel.h
+    diriteminfo.cpp
+    diriteminfo.h
+    dirmodel.cpp
+    dirmodel.h
+    dirselection.cpp
+    dirselection.h
+    externalfswatcher.cpp
+    externalfswatcher.h
+    filecompare.cpp
+    filecompare.h
+    filesystemaction.cpp
+    filesystemaction.h
+    fmutil.cpp
+    fmutil.h
+    imageprovider.cpp
+    imageprovider.h
+    iorequest.cpp
+    iorequest.h
+    iorequestworker.cpp
+    iorequestworker.h
+    ioworkerthread.cpp
+    ioworkerthread.h
+    plugin.cpp
+    plugin.h
+    trash/qtrashdir.cpp
+    trash/qtrashdir.h
+)
+
+add_library(folderlistmodel MODULE
+    ${folderlistmodel_SRCS}
+)
+
+qt5_use_modules(folderlistmodel Gui Qml Quick Widgets)
+
+# Copy qmldir file to build dir for running in QtCreator
+if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+    add_custom_target(folderlistmodel-qmldir ALL
+        COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/qmldir ${CMAKE_CURRENT_BINARY_DIR}
+        DEPENDS ${QMLFILES}
+    )
+endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+
+# Install plugin file
+install(TARGETS folderlistmodel DESTINATION ${QT_IMPORTS_DIR}/org/nemomobile/folderlistmodel/)
+install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/org/nemomobile/folderlistmodel/)
+

=== added file 'src/plugin/folderlistmodel/README'
--- src/plugin/folderlistmodel/README	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/README	2014-04-15 08:19:22 +0000
@@ -0,0 +1,14 @@
+Building and installing
+=======================
+
+qmake [available-defines]
+
+  where available-debug-messages are:
+      DEBUG_MESSAGES         -> enable generic debug messages                  use:  qmake "DEINES+=DEBUG_MESSAGES"
+      DEBUG_EXT_FS_WATCHER   -> enable External File System Watcher messages   use:  qmake "DEINES+=DEBUG_EXT_FS_WATCHER"
+      DEBUG_REMOVE           -> enable message about every remove              use:  qmake "DEINES+=DEBUG_REMOVE"
+      DO_NOT_USE_TAG_LIB     -> disable using TAGLIB and getting metada        use:  qmake "DEINES+=DO_NOT_USE_TAG_LIB"
+
+make
+sudo make install
+

=== added file 'src/plugin/folderlistmodel/clipboard.cpp'
--- src/plugin/folderlistmodel/clipboard.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/clipboard.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,495 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: clipboard.cpp
+ * Date: 1/22/2014
+ */
+
+#include "clipboard.h"
+
+#include <QClipboard>
+#include <QApplication>
+#include <QDir>
+#include <QFileInfo>
+#include <QDebug>
+
+static  QLatin1String GNOME_COPIED_MIME_TYPE  ("x-special/gnome-copied-files");
+static  QLatin1String KDE_CUT_MIME_TYPE       ("application/x-kde-cutselection");
+
+
+int DirModelMimeData::m_instances = 0;
+DirModelMimeData*  DirModelMimeData::m_globalMimeData = 0;
+
+
+bool DirModelMimeData::hasFormat ( const QString & mimeType ) const
+{
+   bool ret = false;
+   if (  mimeType == KDE_CUT_MIME_TYPE  )
+   {
+      ret = true;
+   }
+   else
+   {
+      ret = m_formats.contains(mimeType);
+   }
+   return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::DirModelMimeData
+ */
+DirModelMimeData::DirModelMimeData() :
+    QMimeData()
+  , m_appMime(0)
+{
+    m_formats.append("text/uri-list");
+    m_formats.append(GNOME_COPIED_MIME_TYPE);
+    m_formats.append("text/plain");
+    m_formats.append("COMPOUND_TEXT");
+    m_formats.append("TARGETS");
+    m_formats.append("MULTIPLE");
+    m_formats.append("TIMESTAMP");
+    m_formats.append("SAVE_TARGETS");
+
+    ++m_instances;
+#if DEBUG_MESSAGES
+     qDebug() << Q_FUNC_INFO << this << "instances" << m_instances;
+#endif
+}
+
+
+
+
+DirModelMimeData::~DirModelMimeData()
+{
+    --m_instances;
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << this  << "instances" << m_instances
+             << "m_globalMimeData" << m_globalMimeData;
+#endif
+    if (m_instances == 1 && m_globalMimeData)
+    {
+        DirModelMimeData * tmp = m_globalMimeData;
+        m_globalMimeData = 0;
+        delete tmp;
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::gnomeUrls
+ * \param mime
+ * \param operation
+ * \return
+ */
+QList<QUrl>
+DirModelMimeData::gnomeUrls(const QMimeData * mime,
+                            ClipboardOperation& operation)
+{
+    QList<QUrl>  urls;
+    if (mime->hasFormat(GNOME_COPIED_MIME_TYPE))
+    {
+       QByteArray  bytes = mime->data(GNOME_COPIED_MIME_TYPE);
+       QList<QString>  d = QString(bytes).split(QLatin1String("\n"),
+                                                QString::SkipEmptyParts);
+       operation = ClipboardCopy;
+       if (d.count() > 0)
+       {
+           if (d.at(0).trimmed().startsWith(QLatin1String("cut")))
+           {
+               operation = ClipboardCut;
+           }
+           for (int counter= 1; counter < d.count(); counter++)
+           {
+               urls.append(d.at(counter).trimmed());
+           }
+       }
+    }
+    return urls;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::clipBoardOperation()
+ * \param mime
+ * \return
+ */
+ClipboardOperation DirModelMimeData::clipBoardOperation()
+{
+    ClipboardOperation op = ClipboardCopy;
+    m_appMime = clipboardMimeData();
+    if (m_appMime)
+    {
+       //first check for GNOME clipboard format, op comes with Copy/Cut
+        if (gnomeUrls(m_appMime, op).count() == 0)
+        { // there is no gnome format, tries KDE format
+            QStringList formats = m_appMime->formats();
+            int f = formats.count();
+            while(f--)
+            {
+                const QString &mi = formats.at(f);
+                if(mi.startsWith(QLatin1String("application/x-kde")) )
+                {
+                    if (mi.contains(QLatin1String("cut")))
+                    {
+                        op = ClipboardCut;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return op;
+}
+
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::setIntoClipboard
+ *
+ *  Try to put data in the global cliboard
+ *
+ *  \note:
+ *       On mobile devices clipboard might not work, in this case a local Clipboard is simulated
+ *
+ * \param files
+ * \param path
+ * \param isCut
+ * \return who is owner of clipboard data
+ */
+DirModelMimeData::ClipBoardDataOwner
+DirModelMimeData::setIntoClipboard(const QStringList &files, const QString& path, ClipboardOperation operation)
+{
+    static bool firstTime = true;
+    DirModelMimeData::ClipBoardDataOwner  ret = Nobody;
+    QClipboard *clipboard = QApplication::clipboard();
+    if (clipboard)
+    {
+        ret = Application;
+        DirModelMimeData *mime = m_globalMimeData ? m_globalMimeData
+                                                  : new DirModelMimeData();
+        if (mime->fillClipboard(files, path, operation))
+        {
+            clipboard->setMimeData(mime);
+            //it looks like some mobile devices does not have X or Clipboard does work for other reason
+            //in this case we simulate our own clipboard, the QClipboard::dataChanged() signal is also
+            //checked in \ref Clipboard::storeOnClipboard()
+            if (firstTime)
+            {
+                firstTime = false;
+                if (!m_globalMimeData && !testClipboardContent(files, path))
+                {
+                    qWarning() << "QClipboard does not work,  using own QMimeData storage";
+                    m_globalMimeData = mime;
+                }
+            }
+#if DEBUG_MESSAGES
+            qDebug() << Q_FUNC_INFO << "mime" << mime
+                     << "own Clipboard Mime Data" << m_globalMimeData;
+#endif
+        }
+        else
+            if (m_globalMimeData != mime)
+            {
+                delete mime;
+            }
+        //check if it is necessary to send notification about Clipboard changed
+        if (m_globalMimeData)
+        {
+            ret = MySelf;
+        }
+    }
+    return ret;
+}
+
+
+
+bool DirModelMimeData::fillClipboard(const QStringList& files, const QString &path, ClipboardOperation operation)
+{
+    bool ret = false;
+    int index = m_formats.indexOf(KDE_CUT_MIME_TYPE);
+    if (index != -1 && operation != ClipboardCut)
+    {
+        m_formats.removeAt(index);
+    }
+    else
+    if (operation == ClipboardCut)
+    {
+        m_formats.append(KDE_CUT_MIME_TYPE);
+    }
+    m_urls.clear();
+    m_gnomeData.clear();
+    m_gnomeData += operation == ClipboardCut ?
+                                    QLatin1String("cut") :
+                                    QLatin1String("copy");
+    QStringList fullPaths = makeFullPath(files, path);
+    for(int counter = 0; counter < fullPaths.count(); counter++)
+    {
+        QUrl item = QUrl::fromLocalFile(fullPaths.at((counter)));
+        m_urls.append(item);
+        m_gnomeData += QLatin1Char('\n') + item.toEncoded() ;
+    }
+    if (m_urls.count() > 0)
+    {
+        setData(GNOME_COPIED_MIME_TYPE, m_gnomeData);
+        setUrls(m_urls);
+        ret = true;
+    }
+    else
+    {
+     // emit error( QObject::tr("Item does not exist"), item);
+    }
+    return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::clipboardMimeData
+ * \return
+ */
+const QMimeData *DirModelMimeData::clipboardMimeData()
+{
+    const QMimeData *ret = 0;
+    QClipboard *clipboard = QApplication::clipboard();
+    if (m_globalMimeData)
+    {
+        ret = m_globalMimeData;
+    }
+    else
+    if (clipboard)
+    {
+        ret = clipboard->mimeData();
+    }
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "clipboard" << clipboard
+                << "m_ownClipboardMimeData" << m_globalMimeData
+                << "clipboard->mimeData()" << ret;
+#endif
+    return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::localUrls
+ * \return
+ */
+QStringList
+DirModelMimeData::localUrls(ClipboardOperation& operation)
+{
+     m_appMime = clipboardMimeData();
+     QStringList paths;
+     //it may have external urls
+     if (m_appMime)
+     {
+         QList<QUrl> urls;
+         if (m_appMime->hasUrls())
+         {
+             urls =  m_appMime->urls();
+             operation = clipBoardOperation();
+         }
+         else
+         {
+             urls = gnomeUrls(m_appMime, operation);
+         }
+         for (int counter=0; counter < urls.count(); counter++)
+         {
+             if (urls.at(counter).toString().startsWith(QLatin1String("file://")))
+             {
+                 paths.append(urls.at(counter).toLocalFile());
+             }
+         }
+     }
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << paths;
+#endif
+     return paths;
+}
+
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::testClipboardContent() Gets the clipboard content and compare with data previously stored
+ * \param files
+ * \param path
+ * \return true if clipboard has content and it matches data previously stored
+ */
+bool  DirModelMimeData::testClipboardContent(const QStringList &files, const QString &path)
+{
+    bool ret = false;
+    ClipboardOperation tmpOperation;
+    QStringList expectedList = makeFullPath(files,path);
+    QStringList realList     = localUrls(tmpOperation);
+    if (realList == expectedList)
+    {
+        ret = true;
+    }
+    else
+    {
+        qWarning() << Q_FUNC_INFO << "FAILED, Clipboard does not work";
+    }
+    return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::makeFullPath() Just creates a fulpath file list when they do exist
+ * \param files
+ * \param path
+ * \return the list itself
+ */
+QStringList DirModelMimeData::makeFullPath(const QStringList& files, const QString &path)
+{
+    QStringList fullPathnameList;
+    QFileInfo fi;
+    for(int counter = 0; counter < files.count(); counter++)
+    {
+        const QString& item = files.at(counter);
+        fi.setFile(item);
+        if (!fi.isAbsolute())
+        {
+            fi.setFile(path + QDir::separator() + item);
+        }
+        if (fi.exists())
+        {
+            fullPathnameList.append(fi.absoluteFilePath());
+        }
+    }
+    return fullPathnameList;
+}
+
+
+//===========================================================================
+//
+//===========================================================================
+Clipboard::Clipboard(QObject *parent):
+    QObject(parent)
+  , m_mimeData ( new DirModelMimeData() )
+  , m_clipboardModifiedByOther(false)
+{
+    QClipboard *clipboard = QApplication::clipboard();
+
+    connect(clipboard, SIGNAL(dataChanged()), this,    SIGNAL(clipboardChanged()));
+    connect(clipboard, SIGNAL(dataChanged()), this,    SLOT(onClipboardChanged()));
+}
+
+
+Clipboard::~Clipboard()
+{
+    delete m_mimeData;
+}
+
+//================================================================================
+/*!
+ * \brief Clipboard::clipboardHasChanged() used to identify if the clipboard changed during a Cut operation
+ *
+ *  \sa \ref endCurrentAction()
+ */
+void Clipboard::onClipboardChanged()
+{
+    m_clipboardModifiedByOther = true;
+}
+
+
+//==================================================================
+/*!
+ * \brief Clipboard::storeOnClipboard() store data on Clipboard
+ * \param pathnames files list
+ * \param op \ref ClipboardOperation as  \ref ClipboardCopy or  \ref ClipboardCut
+ *
+ *  Stores data on clipboard by calling \ref DirModelMimeData::setIntoClipboard() which uses Qt class QClipboard
+ *  It is expected that QClipboard class emits the dataChanged() signal when a new content is set into it,
+ *  if it does we caught that signal in \ref clipboardHasChanged() which sets \ref m_clipboardModifiedByOther to true.
+ */
+void  Clipboard::storeOnClipboard(const QStringList &names, ClipboardOperation op, const QString& curPath)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << names << "ClipboardOperation" << op;
+#endif
+     DirModelMimeData::ClipBoardDataOwner owner =
+         m_mimeData->setIntoClipboard(names, curPath, op);
+     if (owner == DirModelMimeData::MySelf || !m_clipboardModifiedByOther)
+     {
+         emit clipboardChanged();
+     }
+     m_clipboardModifiedByOther = false;
+}
+
+//===============================================================================================
+/*!
+ * \brief Clipboard::copy
+ * \param pathnames
+ */
+void Clipboard::copy(const QStringList &names, const QString& path)
+{
+    storeOnClipboard(names, ClipboardCopy, path);
+}
+
+//===============================================================================================
+/*!
+ * \brief Clipboard::cut
+ * \param pathnames
+ */
+void Clipboard::cut(const QStringList &names, const QString &path)
+{
+    storeOnClipboard(names, ClipboardCut, path);
+}
+
+
+//=======================================================
+/*!
+ * \brief Clipboard::clipboardLocalUrlsCounter
+ * \return
+ */
+int Clipboard::clipboardLocalUrlsCounter()
+{
+    ClipboardOperation operation;
+    return m_mimeData->localUrls(operation).count();
+}
+
+
+//=======================================================
+/*!
+ * \brief Clipboard::paste
+ * \param operation
+ * \return
+ */
+QStringList Clipboard::paste(ClipboardOperation &operation)
+{
+    QStringList items = m_mimeData->localUrls(operation);
+    if (operation == ClipboardCut)
+    {
+        //this must still be false when cut finishes to change the clipboard to the target
+        m_clipboardModifiedByOther = false;
+    }
+    return items;
+}

=== added file 'src/plugin/folderlistmodel/clipboard.h'
--- src/plugin/folderlistmodel/clipboard.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/clipboard.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,132 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Canonical Ltd.
+ * Copyright 2014 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: clipboard.h
+ * Date: 1/22/2014
+ */
+
+#ifndef  CLIPBOARD_H
+#define  CLIPBOARD_H
+
+#include <QMimeData>
+#include <QUrl>
+#include <QStringList>
+
+class DirModelMimeData;
+
+enum ClipboardOperation
+{
+    NoClipboard, ClipboardCopy, ClipboardCut
+};
+
+
+
+/*!
+ * \brief The Clipboard class handles global clipboard storage
+ */
+class Clipboard : public QObject
+{
+   Q_OBJECT
+public:
+   explicit Clipboard(QObject *parent = 0);
+    ~Clipboard();
+    QStringList  paste(ClipboardOperation& operation);
+    int          clipboardLocalUrlsCounter();
+    inline bool  hasClipboardModifiedByOtherApplication() const {return m_clipboardModifiedByOther;}
+
+public slots:
+   void         cut(const QStringList&  names, const QString &path);
+   void         copy(const QStringList& names, const QString &path);
+
+
+signals:
+   void         clipboardChanged();
+
+private slots:
+   void         onClipboardChanged ();
+
+private:
+   void         storeOnClipboard(const QStringList &names,
+                                 ClipboardOperation op,
+                                 const QString &curPath);
+private:
+   DirModelMimeData  *     m_mimeData;
+   bool                    m_clipboardModifiedByOther;
+};
+
+
+
+/*!
+ * \brief The DirModelMimeData class is the storage on Clipboard
+ */
+class DirModelMimeData : public QMimeData
+{
+public:
+    explicit DirModelMimeData();
+    ~DirModelMimeData();
+    virtual QStringList     formats() const    { return m_formats; }
+    virtual bool            hasFormat ( const QString & mimeType ) const;
+
+public:
+    enum ClipBoardDataOwner
+    {
+        Nobody,    // might have failed
+        Application,
+        MySelf
+    };
+
+    ClipBoardDataOwner      setIntoClipboard(const QStringList& files,
+                                             const QString &path,
+                                             ClipboardOperation operation);
+    const QMimeData *       clipboardMimeData();
+    QStringList             localUrls(ClipboardOperation& operation);
+
+private:
+    static QList<QUrl>      gnomeUrls(const QMimeData *mime, ClipboardOperation& operation);
+    ClipboardOperation      clipBoardOperation();
+    bool                    fillClipboard(const QStringList& files, const QString &path, ClipboardOperation operation);
+    QStringList             makeFullPath(const QStringList& files, const QString &path);
+    bool                    testClipboardContent(const QStringList& files, const QString &path);
+
+private:
+    QStringList              m_formats;
+    const QMimeData *        m_appMime;
+    QByteArray               m_gnomeData;
+    QList<QUrl>              m_urls;
+    static DirModelMimeData* m_globalMimeData; //!< some mobile devices do not use X, they may not have clipboard
+    static   int             m_instances;
+};
+
+
+
+#endif //CLIPBOARD_H
+

=== added file 'src/plugin/folderlistmodel/diritemabstractlistmodel.h'
--- src/plugin/folderlistmodel/diritemabstractlistmodel.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/diritemabstractlistmodel.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,46 @@
+/**************************************************************************
+ *
+ * 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: diritemabstractlistmodel.h
+ * Date: 30/01/2014
+ */
+
+#ifndef DIRITEMABSTRACTLISTMODEL_H
+#define DIRITEMABSTRACTLISTMODEL_H
+
+#include <QObject>
+
+#include <QAbstractListModel>
+
+
+class DirItemInfo;
+class DirItemModel;
+
+class DirItemAbstractListModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    virtual int                 getIndex(const QString& name) = 0;
+    virtual void                notifyItemChanged(int index)  = 0;
+protected:
+    explicit DirItemAbstractListModel(QObject *parent = 0) :
+        QAbstractListModel(parent)
+    {
+    }
+};
+
+#endif // DIRITEMABSTRACTLISTMODEL_H

=== added file 'src/plugin/folderlistmodel/diriteminfo.cpp'
--- src/plugin/folderlistmodel/diriteminfo.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/diriteminfo.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,345 @@
+/**************************************************************************
+ *
+ * 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: diriteminfo.cpp
+ * Date: 30/01/2014
+ */
+
+#include "diriteminfo.h"
+
+
+
+
+#include <QUrl>
+#include <QDir>
+
+
+class  DirItemInfoPrivate : public QSharedData
+{
+public:
+    DirItemInfoPrivate();
+    DirItemInfoPrivate(const DirItemInfoPrivate& other);
+    DirItemInfoPrivate(const QFileInfo& fi);
+    void setFileInfo(const QFileInfo&);
+
+public:
+    bool      _isValid     :1;
+    bool      _isLocal     :1;
+    bool      _isRemote    :1;
+    bool      _isSelected  :1;
+    bool      _isAbsolute  :1;
+    bool      _exists      :1;
+    bool      _isFile      :1;
+    bool      _isDir       :1;
+    bool      _isSymLink   :1;
+    bool      _isRoot      :1;
+    bool      _isReadable  :1;
+    bool      _isWritable  :1;
+    bool      _isExecutable:1;
+    QFile::Permissions  _permissions;
+    qint64    _size;
+    QDateTime _created;
+    QDateTime _lastModified;
+    QDateTime _lastRead;
+    QString   _path;
+    QString   _fileName;
+    static QMimeDatabase mimeDatabase;
+};
+
+
+QMimeDatabase DirItemInfoPrivate::mimeDatabase;
+
+
+DirItemInfoPrivate::DirItemInfoPrivate() :
+   _isValid(false)
+  ,_isLocal(false)
+  ,_isRemote(false)
+  ,_isSelected(false)
+  ,_isAbsolute(false)
+  ,_exists(false)
+  ,_isDir(false)
+  ,_isSymLink(false)
+  ,_isRoot(false)
+  ,_isReadable(false)
+  ,_isWritable(false)
+  ,_isExecutable(false)
+  ,_permissions(0)
+  ,_size(0)
+{
+
+}
+
+
+DirItemInfoPrivate::DirItemInfoPrivate(const DirItemInfoPrivate &other):
+   QSharedData(other)
+  ,_isValid(other._isValid)
+  ,_isLocal(other._isLocal)
+  ,_isRemote(other._isRemote)
+  ,_isSelected(other._isSelected)
+  ,_isAbsolute(other._isAbsolute)
+  ,_exists(other._exists)
+  ,_isDir(other._isDir)
+  ,_isSymLink(other._isSymLink)
+  ,_isRoot(other._isRoot)
+  ,_isReadable(other._isReadable)
+  ,_isWritable(other._isWritable)
+  ,_isExecutable(other._isExecutable)
+  ,_permissions(other._permissions)
+  ,_size(other._size)
+  ,_created(other._created)
+  ,_lastModified(other._lastModified)
+  ,_lastRead(other._lastRead)
+  ,_path(other._path)
+  ,_fileName(other._fileName)
+{
+
+}
+
+
+DirItemInfoPrivate::DirItemInfoPrivate(const QFileInfo &fi):
+   _isValid(true)
+  ,_isLocal(true)
+  ,_isRemote(false)
+  ,_isSelected(false)
+{
+    setFileInfo(fi);
+}
+
+void DirItemInfoPrivate::setFileInfo(const QFileInfo &fi)
+{
+    if (fi.exists() && fi.isRelative())
+    {
+        QFileInfo abs(fi.absoluteFilePath());
+        setFileInfo(abs);
+    }
+    else
+    {
+        _path          = fi.absolutePath();
+        _fileName      = fi.fileName();
+        _isAbsolute    = fi.isAbsolute();
+        _exists        = fi.exists();
+        _isDir         = fi.isDir();
+        _isFile        = fi.isFile();
+        _isSymLink     = fi.isSymLink();
+        _isRoot        = fi.isRoot();
+        _isReadable    = fi.isReadable();
+        _isWritable    = fi.isWritable();
+        _isExecutable  = fi.isExecutable();
+        _permissions   = fi.permissions();
+        _size          = fi.size();
+        _created       = fi.created();
+        _lastRead      = fi.lastRead();
+        _lastModified  = fi.lastModified();
+    }
+}
+
+//================================================================
+
+DirItemInfo::DirItemInfo(): d_ptr(new DirItemInfoPrivate())
+{
+}
+
+
+DirItemInfo::~DirItemInfo()
+{
+}
+
+
+
+DirItemInfo::DirItemInfo(const QFileInfo &fi):
+    d_ptr(new DirItemInfoPrivate(fi))
+{
+
+}
+
+
+
+DirItemInfo::DirItemInfo(const QString& urlOrPath):
+    d_ptr(  new DirItemInfoPrivate(QFileInfo(urlOrPath)) )
+{
+
+}
+
+
+DirItemInfo::DirItemInfo(const DirItemInfo& other)
+{
+   d_ptr = other.d_ptr;
+}
+
+
+bool DirItemInfo::isSelected() const
+{
+    return d_ptr->_isSelected;
+}
+
+/*!
+ * \brief DirItemInfo::setSelection()
+ * \param selected true/false new selection state
+ * \return true if a new state was set, false if the selection is already equal to \a selected
+ */
+bool DirItemInfo::setSelection(bool selected)
+{
+    bool ret = selected != isSelected();
+    d_ptr->_isSelected = selected;
+    return ret;
+}
+
+
+bool DirItemInfo::isValid() const
+{
+    return d_ptr->_isValid;
+}
+
+bool DirItemInfo::isLocal() const
+{
+    return d_ptr->_isLocal;
+}
+
+bool DirItemInfo::isRemote() const
+{
+    return d_ptr->_isRemote;
+}
+
+bool DirItemInfo::exists() const
+{
+    return d_ptr->_exists;
+}
+
+QString DirItemInfo::filePath() const
+{
+   QString filepath;
+   if (!d_ptr->_path.isEmpty())
+   {
+       filepath = d_ptr->_path;
+       if (d_ptr->_path != QDir::rootPath())
+       {
+           filepath += QDir::separator();
+       }
+   }
+   filepath += d_ptr->_fileName;
+   return filepath;
+}
+
+QString DirItemInfo::fileName() const
+{
+    return d_ptr->_fileName;
+}
+
+QString DirItemInfo::absoluteFilePath() const
+{
+    return filePath();
+}
+
+QString DirItemInfo::absolutePath() const
+{
+    return d_ptr->_path;
+}
+
+bool  DirItemInfo::isReadable() const
+{
+    return d_ptr->_isReadable;
+}
+
+bool DirItemInfo::isWritable() const
+{
+    return d_ptr->_isWritable;
+}
+
+bool DirItemInfo::isExecutable() const
+{
+    return d_ptr->_isExecutable;
+}
+
+bool DirItemInfo::isRelative() const
+{
+    return ! isAbsolute();
+}
+
+bool  DirItemInfo::isAbsolute() const
+{
+    return d_ptr->_isAbsolute;
+}
+
+bool  DirItemInfo::isFile() const
+{
+    return d_ptr->_isFile;
+}
+
+bool DirItemInfo::isDir() const
+{
+    return d_ptr->_isDir;
+}
+
+bool DirItemInfo::isSymLink() const
+{
+    return d_ptr->_isSymLink;
+}
+
+bool DirItemInfo::isRoot() const
+{
+    return d_ptr->_isRoot;
+}
+
+QFile::Permissions  DirItemInfo::permissions() const
+{
+    return d_ptr->_permissions;
+}
+
+qint64 DirItemInfo::size() const
+{
+    return d_ptr->_size;
+}
+
+QDateTime DirItemInfo::created() const
+{
+    return d_ptr->_created;
+}
+
+QDateTime DirItemInfo::lastModified() const
+{
+    return d_ptr->_lastModified;
+}
+
+QDateTime DirItemInfo::lastRead() const
+{
+    return d_ptr->_lastRead;
+}
+
+void DirItemInfo::setFile(const QString &dir, const QString &file)
+{
+   QFileInfo f;
+   f.setFile(dir,file);
+   d_ptr->setFileInfo(f);
+}
+
+QFileInfo DirItemInfo::diskFileInfo() const
+{
+    QFileInfo fi(absoluteFilePath());
+    return fi;
+}
+
+QString DirItemInfo::path() const
+{
+    return d_ptr->_path;
+}
+
+
+QMimeType DirItemInfo::mimeType() const
+{
+    return d_ptr->mimeDatabase.mimeTypeForFile(diskFileInfo());
+}
+

=== added file 'src/plugin/folderlistmodel/diriteminfo.h'
--- src/plugin/folderlistmodel/diriteminfo.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/diriteminfo.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,123 @@
+/**************************************************************************
+ *
+ * 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: diriteminfo.h
+ * Date: 30/01/2014
+ */
+
+#ifndef DIRITEMINFO_H
+#define DIRITEMINFO_H
+
+#include <QtGlobal>
+#include <QVector>
+#include <QFileInfo>
+#include <QSharedData>
+#include <QDateTime>
+
+#include <QMimeType>
+#include <QMimeDatabase>
+
+class DirItemInfoPrivate;
+
+
+/*!
+ * \brief The DirItemInfo class
+ *
+ *  It intends to provide the same information as QFileInfo for Local Files:
+ *     * selection state
+ *     * any information about the item type, if it is Local/Remove
+ *     *
+ */
+class DirItemInfo
+{
+public:
+     DirItemInfo();
+     DirItemInfo(const QString& urlOrPath);
+     DirItemInfo(const QFileInfo&);
+     DirItemInfo(const DirItemInfo& other);
+
+     virtual ~DirItemInfo();
+
+public:
+    bool              isSelected() const;
+    bool              setSelection(bool selected);
+    virtual bool      isValid() const;
+
+    /*!
+     * \brief isLocal()
+     * \return true if the file is the disk: valid for Trash and any mounted FS
+     */
+    virtual bool      isLocal() const;
+
+    /*!
+     * \brief isRemote()
+     * \return true if the file is in any remote host, mounted File Sharing is considered as Local
+     */
+    virtual bool      isRemote() const;
+
+    QFileInfo diskFileInfo() const;
+
+    inline void swap(DirItemInfo &other)
+    { qSwap(d_ptr, other.d_ptr); }
+
+    inline DirItemInfo& operator=(const DirItemInfo &other)
+    {  swap(*(const_cast<DirItemInfo*>(&other))); return *this; }
+
+    virtual bool      exists()   const;
+    virtual QString   filePath() const;
+    virtual QString   fileName() const;
+    virtual QString   path() const;
+    virtual QString   absolutePath() const;
+    virtual QString   absoluteFilePath() const;     
+    virtual bool      isReadable() const;
+    virtual bool      isWritable() const;
+    virtual bool      isExecutable() const;
+    virtual bool      isRelative() const;
+    virtual bool      isAbsolute() const;
+    virtual bool      isFile() const;
+    virtual bool      isDir() const;
+    virtual bool      isSymLink() const;
+    virtual bool      isRoot() const;
+    virtual QFile::Permissions  permissions() const;
+    virtual qint64    size() const;
+    virtual QDateTime created() const;
+    virtual QDateTime lastModified() const;
+    virtual QDateTime lastRead() const;
+    virtual QMimeType mimeType() const;
+
+    virtual void      setFile(const QString &dir, const QString & file);
+
+#if 0
+    virtual QString   path() const;
+    virtual QString   owner()   const;
+    virtual uint      ownerId() const;
+    virtual QString   group()   const;
+    virtual uint      groupId() const;
+    virtual bool      permission(QFile::Permissions permissions) const;
+#endif
+
+
+protected:
+    QSharedDataPointer<DirItemInfoPrivate> d_ptr;
+};
+
+typedef QVector<DirItemInfo>   DirItemInfoList;
+
+Q_DECLARE_SHARED(DirItemInfo)
+Q_DECLARE_METATYPE(DirItemInfo)
+
+#endif // DIRITEMINFO_H

=== added file 'src/plugin/folderlistmodel/dirmodel.cpp'
--- src/plugin/folderlistmodel/dirmodel.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/dirmodel.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,1563 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include "dirselection.h"
+#include "dirmodel.h"
+#include "iorequest.h"
+#include "ioworkerthread.h"
+#include "filesystemaction.h"
+#include "externalfswatcher.h"
+#include "clipboard.h"
+#include "fmutil.h"
+
+
+#ifndef DO_NOT_USE_TAG_LIB
+#include <taglib/attachedpictureframe.h>
+#include <taglib/id3v2tag.h>
+#include <taglib/fileref.h>
+#include <taglib/mpegfile.h>
+#include <taglib/tag.h>
+#include <taglib/audioproperties.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <QDirIterator>
+#include <QDir>
+#include <QDebug>
+#include <QFileIconProvider>
+#include <QUrl>
+#include <QDesktopServices>
+#include <QMetaType>
+#include <QDateTime>
+#include <QMimeType>
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+# include <QColor>
+# include <QBrush>
+#endif
+
+
+
+
+
+#define IS_VALID_ROW(row)             (row >=0 && row < mDirectoryContents.count())
+#define WARN_ROW_OUT_OF_RANGE(row)    qWarning() << Q_FUNC_INFO << this << "row:" << row << "Out of bounds access"
+
+#define IS_FILE_MANAGER_IDLE()            (!mAwaitingResults)
+
+
+Q_GLOBAL_STATIC(IOWorkerThread, ioWorkerThread)
+
+namespace {
+    QHash<QByteArray, int> roleMapping;
+}
+
+
+
+/*!
+ *  Sort was originally done in \ref onItemsAdded() and that code is now in \ref addItem(),
+ *  the reason to keep doing sort and do not let QDir does it is that when adding new items
+ *  by \ref mkdir() or \paste() it is not necessary to call refresh() to load the entire directory
+ *  to organize it items again. New items order/position are organized by \ref addItem()
+ *
+ */
+static CompareFunction availableCompareFunctions[2][2] =
+{
+    {fileCompareAscending, fileCompareDescending}
+   ,{dateCompareAscending, dateCompareDescending}
+};
+
+
+DirModel::DirModel(QObject *parent)
+    : DirItemAbstractListModel(parent)
+    , mFilterDirectories(false)
+    , mShowDirectories(true)
+    , mAwaitingResults(false)
+    , mIsRecursive(false)
+    , mReadsMediaMetadata(false)
+    , mShowHiddenFiles(false)
+    , mSortBy(SortByName)
+    , mSortOrder(SortAscending)
+    , mCompareFunction(0)  
+    , mExtFSWatcher(0)
+    , mClipboard(new Clipboard(this))    
+    , m_fsAction(new FileSystemAction(this) )    
+{
+    mNameFilters = QStringList() << "*";
+
+    mSelection   =  new DirSelection(this, &mDirectoryContents);
+
+    connect(m_fsAction, SIGNAL(progress(int,int,int)),
+            this,     SIGNAL(progress(int,int,int)));
+
+    connect(m_fsAction, SIGNAL(added(DirItemInfo)),
+            this,     SLOT(onItemAdded(DirItemInfo)));
+
+    connect(m_fsAction, SIGNAL(added(QString)),
+            this,     SLOT(onItemAdded(QString)));
+
+    connect(m_fsAction, SIGNAL(removed(DirItemInfo)),
+            this,     SLOT(onItemRemoved(DirItemInfo)));
+
+    connect(m_fsAction, SIGNAL(removed(QString)),
+            this,     SLOT(onItemRemoved(QString)));  
+
+    connect(m_fsAction, SIGNAL(error(QString,QString)),
+            this,     SIGNAL(error(QString,QString)));
+
+    connect(this,     SIGNAL(pathChanged(QString)),
+            m_fsAction, SLOT(pathChanged(QString)));
+
+    connect(mClipboard, SIGNAL(clipboardChanged()),
+            this,       SIGNAL(clipboardChanged()));
+
+    connect(m_fsAction,  SIGNAL(changed(DirItemInfo)),
+           this,        SLOT(onItemChanged(DirItemInfo)));
+
+    connect(mClipboard, SIGNAL(clipboardChanged()),
+            m_fsAction, SLOT(onClipboardChanged()));
+
+    connect(m_fsAction, SIGNAL(recopy(QStringList,QString)),
+            mClipboard, SLOT(copy(QStringList,QString)));
+
+    setCompareAndReorder();
+
+    if (QIcon::themeName().isEmpty() && !FMUtil::hasTriedThemeName())
+    {
+        FMUtil::setThemeName();
+    }
+}
+
+
+
+DirModel::~DirModel()
+{
+    stoptExternalFsWatcher();
+}
+
+
+
+QHash<int, QByteArray> DirModel::roleNames() const
+{
+    static QHash<int, QByteArray> roles;
+    if (roles.isEmpty()) {
+        roles = buildRoleNames();
+    }
+
+    return roles;
+}
+
+
+
+
+QHash<int, QByteArray> DirModel::buildRoleNames() const
+{
+    QHash<int, QByteArray> roles;
+        roles.insert(FileNameRole, QByteArray("fileName"));
+        roles.insert(AccessedDateRole, QByteArray("accessedDate"));
+        roles.insert(CreationDateRole, QByteArray("creationDate"));
+        roles.insert(ModifiedDateRole, QByteArray("modifiedDate"));
+        roles.insert(FileSizeRole, QByteArray("fileSize"));
+        roles.insert(IconSourceRole, QByteArray("iconSource"));
+        roles.insert(FilePathRole, QByteArray("filePath"));
+        roles.insert(IsDirRole, QByteArray("isDir"));
+        roles.insert(IsFileRole, QByteArray("isFile"));
+        roles.insert(IsReadableRole, QByteArray("isReadable"));
+        roles.insert(IsWritableRole, QByteArray("isWritable"));
+        roles.insert(IsExecutableRole, QByteArray("isExecutable"));
+        roles.insert(IsSelectedRole, QByteArray("isSelected"));
+        roles.insert(TrackTitleRole, QByteArray("trackTitle"));
+        roles.insert(TrackArtistRole, QByteArray("trackArtist"));
+        roles.insert(TrackAlbumRole, QByteArray("trackAlbum"));
+        roles.insert(TrackYearRole, QByteArray("trackYear"));
+        roles.insert(TrackNumberRole, QByteArray("trackNumber"));
+        roles.insert(TrackGenreRole, QByteArray("trackGenre"));
+        roles.insert(TrackLengthRole, QByteArray("trackLength"));
+        roles.insert(TrackCoverRole, QByteArray("trackCover"));
+
+    // populate reverse mapping
+    if (roleMapping.isEmpty()) {
+        QHash<int, QByteArray>::ConstIterator it = roles.constBegin();
+        for (;it != roles.constEnd(); ++it)
+            roleMapping.insert(it.value(), it.key());
+
+        // make sure we cover all roles
+        //    Q_ASSERT(roles.count() == IsFileRole - FileNameRole);
+    }
+
+    return roles;
+}
+
+QVariant DirModel::data(int row, const QByteArray &stringRole) const
+{
+    QHash<QByteArray, int>::ConstIterator it = roleMapping.constFind(stringRole);
+
+    if (it == roleMapping.constEnd())
+        return QVariant();
+
+    return data(index(row, 0), *it);
+}
+
+QVariant DirModel::data(const QModelIndex &index, int role) const
+{
+//its not for QML
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    if (!index.isValid() ||
+        (role != Qt::DisplayRole && role != Qt::DecorationRole && role != Qt::BackgroundRole)
+       )
+    {
+        return QVariant();
+    }
+    if (role == Qt::DecorationRole && index.column() == 0)
+    {             
+        QIcon icon;      
+        QMimeType mime = mDirectoryContents.at(index.row()).mimeType();
+        if (mime.isValid())
+        {
+            if (QIcon::hasThemeIcon(mime.iconName()) ) {
+               icon = QIcon::fromTheme(mime.iconName());
+            }
+            else if (QIcon::hasThemeIcon(mime.genericIconName())) {
+               icon = QIcon::fromTheme(mime.genericIconName());
+            }
+        }
+        if (icon.isNull())
+        {
+            if (mDirectoryContents.at(index.row()).isLocal())
+            {
+                icon =  QFileIconProvider().icon(mDirectoryContents.at(index.row()).diskFileInfo());
+            }
+            else
+            if (mDirectoryContents.at(index.row()).isDir())
+            {
+                icon =  QFileIconProvider().icon(QFileIconProvider::Folder);
+            }
+            else
+            {
+                icon =  QFileIconProvider().icon(QFileIconProvider::File);
+            }
+        }
+        return icon;
+    }
+    if (role == Qt::BackgroundRole && index.column() == 0)
+    {
+        if (mDirectoryContents.at(index.row()).isSelected())
+        {
+           //TODO it'd better to get some style or other default
+           //     background color
+           return QBrush(Qt::lightGray);
+        }
+        return QVariant();
+    }
+    role = FileNameRole + index.column();
+#else
+    if (role < FileNameRole || role > TrackCoverRole) {
+        qWarning() << Q_FUNC_INFO << this << "Got an out of range role: " << role;
+        return QVariant();
+    }
+
+    if (index.row() < 0 || index.row() >= mDirectoryContents.count()) {
+        qWarning() << "Attempted to access out of range row: " << index.row();
+        return QVariant();
+    }
+
+    if (index.column() != 0)
+        return QVariant();
+#endif
+
+    const DirItemInfo &fi = mDirectoryContents.at(index.row());
+
+    switch (role) {
+        case FileNameRole:
+            return fi.fileName();
+        case AccessedDateRole:
+            return fi.lastRead();
+        case CreationDateRole:
+            return fi.created();
+        case ModifiedDateRole:
+            return fi.lastModified();
+        case FileSizeRole: {
+             if (fi.isDir() && fi.isLocal())
+             {
+                return dirItems(fi.diskFileInfo());
+             }
+             return fileSize(fi.size());
+        }
+        case IconSourceRole: {
+            const QString &fileName = fi.fileName();
+
+            if (fi.isDir())
+                return QLatin1String("image://theme/icon-m-common-directory");
+
+            if (fileName.endsWith(QLatin1String(".jpg"), Qt::CaseInsensitive) ||
+                fileName.endsWith(QLatin1String(".png"), Qt::CaseInsensitive)) {
+                return QLatin1String("image://nemoThumbnail/") + fi.filePath();
+            }
+
+            return "image://theme/icon-m-content-document";
+        }
+        case FilePathRole:
+            return fi.filePath();
+        case IsDirRole:
+            return fi.isDir();
+        case IsFileRole:
+            return !fi.isDir();
+        case IsReadableRole:
+            return fi.isReadable();
+        case IsWritableRole:
+            return fi.isWritable();
+        case IsExecutableRole:
+            return fi.isExecutable();
+        case IsSelectedRole:
+            return fi.isSelected();
+#ifndef DO_NOT_USE_TAG_LIB
+        case TrackTitleRole:
+        case TrackArtistRole:
+        case TrackAlbumRole:
+        case TrackYearRole:
+        case TrackNumberRole:
+        case TrackGenreRole:
+        case TrackLengthRole:
+        case TrackCoverRole:
+             if (mReadsMediaMetadata && fi.isLocal())
+             {
+                 return getAudioMetaData(fi.diskFileInfo(), role);
+             }
+             break;
+#endif
+        default:
+#if !defined(REGRESSION_TEST_FOLDERLISTMODEL)
+            // this should not happen, ever
+            Q_ASSERT(false);
+            qWarning() << Q_FUNC_INFO << this << "Got an unknown role: " << role;
+#endif
+            break;
+    }
+
+    return QVariant();
+}
+
+void DirModel::setPath(const QString &pathName)
+{
+    if (pathName.isEmpty())
+        return;   
+
+    if (!canReadDir(pathName))
+    {
+        emit error(tr("cannot read path"), pathName);
+        return;
+    }
+
+    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;
+    }
+
+    mAwaitingResults = true;
+    emit awaitingResultsChanged();
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << this << "Changing to " << pathName << " on " << QThread::currentThreadId();
+#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);
+
+    mCurrentDir = pathName;
+    emit pathChanged(pathName);
+}
+
+
+void DirModel::onResultsFetched() {
+    if (mAwaitingResults) {
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << this << "No longer awaiting results";
+#endif
+        mAwaitingResults = false;
+        emit awaitingResultsChanged();
+    }    
+}
+
+void DirModel::onItemsAdded(const DirItemInfoList &newFiles)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << this << "Got new files: " << newFiles.count();
+#endif
+
+    if (newFiles.count() > 0)
+    {
+        mDirectoryContents.reserve(newFiles.count()) ;
+    }
+    foreach (const DirItemInfo &fi, newFiles) {
+
+        bool doAdd = false;
+        foreach (const QString &nameFilter, mNameFilters) {
+            // TODO: using QRegExp for wildcard matching is slow
+            QRegExp re(nameFilter, Qt::CaseInsensitive, QRegExp::Wildcard);
+            if (re.exactMatch(fi.fileName()) || (fi.isDir() && !mFilterDirectories)) {
+                doAdd = true;
+                break;
+            }
+        }
+
+        if (!doAdd)
+            continue;
+
+        addItem(fi);
+    }
+}
+
+void DirModel::rm(const QStringList &paths)
+{
+   m_fsAction->remove(paths);
+}
+
+
+bool DirModel::rename(const QString& oldName, const QString &newName)
+{
+    return rename(getIndex(oldName), newName);
+}
+
+
+bool DirModel::rename(int row, const QString &newName)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << this << "Renaming " << row << " to " << newName;
+#endif
+
+    if (!IS_VALID_ROW(row)) {
+        WARN_ROW_OUT_OF_RANGE(row);
+        return false;
+    }
+
+    const DirItemInfo &fi = mDirectoryContents.at(row);
+    QString newFullFilename(fi.absolutePath() + QDir::separator() + newName);
+
+    //QFile::rename() works for File and Dir
+    QFile f(fi.absoluteFilePath());
+    bool retval = f.rename(newFullFilename);
+    if (!retval)
+    {
+        qDebug() << Q_FUNC_INFO << this << "Rename returned error code: " << f.error() << f.errorString();
+        emit(QObject::tr("Rename error"), f.errorString());
+    }
+    else
+    {
+        bool isSelected =  mDirectoryContents.at(row).isSelected();
+        onItemRemoved(mDirectoryContents.at(row));
+        int newRow = addItem(DirItemInfo(QFileInfo(newFullFilename)));
+        //keep previous selected state, selection takes care of everything
+        mSelection->setIndex(newRow,isSelected);
+    }
+    return retval;
+}
+
+void DirModel::mkdir(const QString &newDir)
+{
+    QDir dir(mCurrentDir);
+    bool retval = dir.mkdir(newDir);
+    if (!retval) {
+        const char *errorStr = strerror(errno);
+        qDebug() << Q_FUNC_INFO << this << "Error creating new directory: " << errno << " (" << errorStr << ")";
+        emit error(QObject::tr("Error creating new folder"), errorStr);
+    } else {
+        onItemAdded(dir.filePath(newDir));
+    }
+}
+
+bool DirModel::showDirectories() const
+{
+    return mShowDirectories;
+}
+
+void DirModel::setShowDirectories(bool showDirectories)
+{
+    mShowDirectories = showDirectories;
+    refresh();
+    emit showDirectoriesChanged();
+}
+
+bool DirModel::isRecursive() const
+{
+    return mIsRecursive;
+}
+
+void DirModel::setIsRecursive(bool isRecursive)
+{
+    mIsRecursive = isRecursive;
+    refresh();
+    emit isRecursiveChanged();
+}
+
+bool DirModel::readsMediaMetadata() const
+{
+    return mReadsMediaMetadata;
+}
+
+void DirModel::setReadsMediaMetadata(bool readsMediaMetadata)
+{
+    mReadsMediaMetadata = readsMediaMetadata;
+    refresh();
+    emit readsMediaMetadataChanged();
+}
+
+bool DirModel::filterDirectories() const
+{
+    return mFilterDirectories;
+}
+
+void DirModel::setFilterDirectories(bool filterDirectories)
+{
+    mFilterDirectories = filterDirectories;
+    refresh();
+    emit filterDirectoriesChanged();
+}
+
+QStringList DirModel::nameFilters() const
+{
+    return mNameFilters;
+}
+
+void DirModel::setNameFilters(const QStringList &nameFilters)
+{
+    mNameFilters = nameFilters;
+    refresh();
+    emit nameFiltersChanged();
+}
+
+bool DirModel::awaitingResults() const
+{
+    return mAwaitingResults;
+}
+
+
+QString DirModel::parentPath() const
+{
+    QDir dir(mCurrentDir);
+    if (dir.isRoot()) {
+        qDebug() << Q_FUNC_INFO << this << "already at root";
+        return mCurrentDir;
+    }
+
+    bool success = dir.cdUp();
+    if (!success) {
+        qWarning() << Q_FUNC_INFO << this << "Failed to to go to parent of " << mCurrentDir;
+        return mCurrentDir;
+    }
+    qDebug() << Q_FUNC_INFO << this << "returning" << dir.absolutePath();
+    return dir.absolutePath();
+}
+
+QString DirModel::homePath() const
+{
+    return QDir::homePath();
+}
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+ QVariant  DirModel::headerData(int section, Qt::Orientation orientation, int role) const
+ {
+   if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
+   {
+       QVariant ret;
+       QHash<int, QByteArray> roles = this->roleNames();
+       section += FileNameRole;
+       if (roles.contains(section))
+       {
+           QString header=  QString(roles.value(section));
+           ret = header;
+       }
+       return ret;
+   }
+   return QAbstractItemModel::headerData(section, orientation, role);
+ }
+#endif
+
+
+void DirModel::goHome()
+{
+    setPath(QDir::homePath());
+}
+
+
+bool DirModel::cdUp()
+{
+    int ret = false;
+    if (!mCurrentDir.isEmpty()) // we are in any dir
+    {
+        QDir current(mCurrentDir);
+        if (current.cdUp())
+        {
+            setPath(current.absolutePath());
+            ret = true;
+        }
+    }
+    return ret;
+}
+
+
+void DirModel::removeIndex(int row)
+{
+    if (IS_VALID_ROW(row))
+    {
+        const DirItemInfo &fi = mDirectoryContents.at(row);
+        QStringList list(fi.absoluteFilePath());
+        this->rm(list);
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+}
+
+void DirModel::removePaths(const QStringList& items)
+{
+     this->rm(items);
+}
+
+void DirModel::copyIndex(int row)
+{
+    if (IS_VALID_ROW(row))
+    {
+        const DirItemInfo &fi = mDirectoryContents.at(row);
+        QStringList list(fi.absoluteFilePath());
+        this->copyPaths(list);
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+}
+
+void DirModel::copyPaths(const QStringList &items)
+{
+   mClipboard->copy(items, mCurrentDir);
+}
+
+
+void DirModel::cutIndex(int row)
+{
+    if (IS_VALID_ROW(row))
+    {
+        const DirItemInfo &fi = mDirectoryContents.at(row);
+        QStringList list(fi.absoluteFilePath());
+        this->cutPaths(list);
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+}
+
+
+void DirModel::cutPaths(const QStringList &items)
+{
+     mClipboard->cut(items, mCurrentDir);
+}
+
+
+void DirModel::paste()
+{
+    ClipboardOperation operation;
+    QStringList items = mClipboard->paste(operation);
+    if (operation == ClipboardCut)
+    {
+         m_fsAction->moveIntoCurrentPath(items);
+    }
+    else
+    {
+        m_fsAction->copyIntoCurrentPath(items);
+    }   
+}
+
+
+bool  DirModel::cdIntoIndex(int row)
+{
+    bool ret = false;
+    if (IS_VALID_ROW(row))
+    {
+        ret = cdInto(mDirectoryContents.at(row));
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+    return ret;
+}
+
+
+bool  DirModel::cdIntoPath(const QString &filename)
+{
+    bool ret = false;
+    DirItemInfo fi(filename);
+    if (fi.isValid())
+    {
+        if (fi.isRelative())
+        {
+            fi.setFile(mCurrentDir, filename);
+        }
+        ret =  cdInto(fi);
+    }
+    return ret;
+}
+
+
+bool  DirModel::cdInto(const DirItemInfo &fi)
+{
+    bool ret = false;
+    if (canReadDir(fi.diskFileInfo()))
+    {
+        if (fi.isRelative())
+        {
+            QDir childDir(mCurrentDir);
+            if ( childDir.cd(fi.fileName()) )
+            {
+                setPath(childDir.absolutePath());
+                ret = true;
+            }
+        }
+        else
+        {
+            ret = true;
+            setPath(fi.absoluteFilePath());
+        }
+    }
+    return ret;
+}
+
+/*!
+ * \brief DirModel::onItemRemoved()
+ * \param pathname full pathname of removed file
+ */
+void DirModel::onItemRemoved(const QString &pathname)
+{
+    DirItemInfo info(pathname);
+    onItemRemoved(info);
+}
+
+
+void DirModel::onItemRemoved(const DirItemInfo &fi)
+{  
+    int row = rowOfItem(fi);
+#if DEBUG_MESSAGES || DEBUG_EXT_FS_WATCHER
+    qDebug() <<  Q_FUNC_INFO << this
+             << "row" << row
+             << "name" << fi.absoluteFilePath()
+             << "removed[True|False]:" << (row >= 0);
+#endif
+    if (row >= 0)
+    {
+        beginRemoveRows(QModelIndex(), row, row);
+        if (mDirectoryContents.at(row).isSelected())
+        {
+            mSelection->itemGoingToBeRemoved(mDirectoryContents.at(row));
+        }
+        mDirectoryContents.remove(row,1);
+        endRemoveRows();
+    }
+}
+
+
+/*!
+ * \brief DirModel::onItemAdded()
+ * \param pathname full pathname of the added file
+ */
+void DirModel::onItemAdded(const QString &pathname)
+{
+    DirItemInfo info(pathname);
+    onItemAdded(info);
+}
+
+
+void DirModel::onItemAdded(const DirItemInfo &fi)
+{
+    int newRow = addItem(fi);
+    emit insertedRow(newRow);
+}
+
+/*!
+ * \brief DirModel::addItem() adds an item into the model
+ *        This code was moved from onItemsAdded(const QVector<QFileInfo> &newFiles),
+ *           the reason is:  this code now is used for \ref mkdir() and for \ref paste() operations
+ *           that inserts new items
+ * \param fi
+ * \return  the index where it was inserted, it can be used in the view
+ * \sa insertedRow()
+ */
+int DirModel::addItem(const DirItemInfo &fi)
+{
+    DirItemInfoList::Iterator it = qLowerBound(mDirectoryContents.begin(),
+                                                  mDirectoryContents.end(),
+                                                  fi,
+                                                  mCompareFunction);
+    int idx =  mDirectoryContents.count();
+
+    if (it == mDirectoryContents.end()) {
+        beginInsertRows(QModelIndex(), idx, idx);
+        mDirectoryContents.append(fi);
+        endInsertRows();
+    } else {
+        idx = it - mDirectoryContents.begin();
+        beginInsertRows(QModelIndex(), idx, idx);
+        mDirectoryContents.insert(it, fi);
+        endInsertRows();
+    }   
+    return idx;
+}
+
+/*!
+ * \brief DirModel::onItemChanged() Changes an item data
+ *
+ * \note If the item does  not exist it is inserted
+ *
+ * \param fi DirItemInfo of the item
+ */
+void DirModel::onItemChanged(const DirItemInfo &fi)
+{
+    int row = rowOfItem(fi);
+    if (row >= 0)
+    {       
+        if (mDirectoryContents.at(row).isSelected())
+        {
+            mSelection->itemGoingToBeReplaced(mDirectoryContents.at(row), fi);
+            DirItemInfo *myFi = const_cast<DirItemInfo*> (&fi);
+            myFi->setSelection(true);
+        }
+        mDirectoryContents[row] = fi;
+        notifyItemChanged(row);
+    }
+    else
+    {   // it simplifies some logic outside, when removing and adding on the same operation
+        onItemAdded(fi);
+    }
+}
+
+
+void DirModel::cancelAction()
+{
+    m_fsAction->cancel();
+}
+
+
+QString DirModel::fileSize(qint64 size) const
+{
+    struct UnitSizes
+    {
+        qint64      bytes;
+        const char *name;
+    };
+
+    static UnitSizes m_unitBytes[5] =
+    {
+        { 1,           "Bytes" }
+       ,{1024,         "kB"}
+        // got it from http://wiki.answers.com/Q/How_many_bytes_are_in_a_megabyte
+       ,{1000 * 1000,  "MB"}
+       ,{1000 *  m_unitBytes[2].bytes,   "GB"}
+       ,{1000 *  m_unitBytes[3].bytes, "TB"}
+    };
+
+    QString ret;
+    int unit = sizeof(m_unitBytes)/sizeof(m_unitBytes[0]);
+    while( unit-- > 1 && size < m_unitBytes[unit].bytes );
+    if (unit > 0 )
+    {
+        ret.sprintf("%0.1f %s", (float)size/m_unitBytes[unit].bytes,
+                    m_unitBytes[unit].name);
+    }
+    else
+    {
+        ret.sprintf("%ld %s", (long int)size, m_unitBytes[0].name);
+    }
+    return ret;
+}
+
+
+
+bool DirModel::getShowHiddenFiles() const
+{
+    return mShowHiddenFiles;
+}
+
+
+void DirModel::setShowHiddenFiles(bool show)
+{
+    if (show != mShowHiddenFiles)
+    {
+        mShowHiddenFiles = show;
+        refresh();
+        emit showHiddenFilesChanged();
+    }
+}
+
+
+void DirModel::toggleShowDirectories()
+{
+    setShowDirectories(!mShowDirectories);
+}
+
+
+void DirModel::toggleShowHiddenFiles()
+{
+    setShowHiddenFiles(!mShowHiddenFiles);
+}
+
+
+DirModel::SortBy
+DirModel::getSortBy()  const
+{
+    return mSortBy;
+}
+
+
+void DirModel::setSortBy(SortBy field)
+{
+    if (field != mSortBy)
+    {
+        mSortBy = field;
+        setCompareAndReorder();
+        emit sortByChanged();
+    }
+}
+
+
+DirModel::SortOrder
+DirModel::getSortOrder() const
+{
+    return mSortOrder;
+}
+
+void DirModel::setSortOrder(SortOrder order)
+{
+    if ( order != mSortOrder )
+    {
+        mSortOrder = order;
+        setCompareAndReorder();
+        emit sortOrderChanged();
+    }
+}
+
+
+void DirModel::toggleSortOrder()
+{
+    SortOrder  order = static_cast<SortOrder> (mSortOrder ^ 1);
+    setSortOrder(order);
+}
+
+
+void DirModel::toggleSortBy()
+{
+    SortBy by = static_cast<SortBy> (mSortBy ^ 1);
+    setSortBy(by);
+}
+
+/*!
+ * \brief DirModel::setCompareAndReorder() called when  SortOrder or SortBy change
+ *
+ *  It does not reload items from disk, just reorganize items from \a mDirectoryContents array
+ */
+void DirModel::setCompareAndReorder()
+{
+    mCompareFunction = availableCompareFunctions[mSortBy][mSortOrder];
+    if (mDirectoryContents.count() > 0 && !mAwaitingResults )
+    {
+        DirItemInfoList tmpDirectoryContents = mDirectoryContents;
+        beginResetModel();
+        mDirectoryContents.clear();
+        endResetModel();
+        for(int counter=0; counter < tmpDirectoryContents.count(); counter++)
+        {
+            addItem(tmpDirectoryContents.at(counter));
+        }
+    }
+}
+
+
+int DirModel::getClipboardUrlsCounter() const
+{
+    return mClipboard->clipboardLocalUrlsCounter();
+}
+
+
+int DirModel::rowOfItem(const DirItemInfo& fi)
+{
+    int row = -1;
+    //to use qBinaryFind() the array needs to be ordered ascending
+    if (mCompareFunction == fileCompareAscending)
+    {
+        DirItemInfoList::Iterator it = qBinaryFind(mDirectoryContents.begin(),
+                                                      mDirectoryContents.end(),
+                                                      fi,
+                                                      fileCompareExists);
+        if (it != mDirectoryContents.end())
+        {
+            row = it - mDirectoryContents.begin();
+        }
+    }
+    else //walk through whole array
+    {
+       //TODO improve this search
+       int counter = mDirectoryContents.count();
+       while (counter--)
+       {
+           if ( 0 == QString::localeAwareCompare(fi.absoluteFilePath(),
+                              mDirectoryContents.at(counter).absoluteFilePath()) )
+           {
+               row = counter;
+               break;
+           }
+       }
+    }
+    return row;
+}
+
+
+QDir::Filter DirModel::currentDirFilter() const
+{
+    int filter = QDir::AllEntries | QDir::NoDotAndDotDot ;
+    if (!mShowDirectories)
+    {
+        filter &= ~QDir::AllDirs;
+        filter &= ~QDir::Dirs;
+    }
+    if (mShowHiddenFiles)
+    {
+        filter |= QDir::Hidden;
+    }
+    if (mIsRecursive)
+    {
+        filter |= QDir::NoSymLinks;
+    }
+    QDir::Filter dirFilter = static_cast<QDir::Filter>(filter);
+    return dirFilter;
+}
+
+QString DirModel::dirItems(const DirItemInfo& fi) const
+{
+    int counter = 0;
+    QDir d(fi.absoluteFilePath(), QString(), QDir::NoSort, currentDirFilter());
+    counter = d.count();
+    if (counter < 0)
+    {
+        counter = 0;
+    }
+    QString ret (QString::number(counter) + QLatin1Char(' '));
+    ret += QObject::tr("items");
+    return ret;
+}
+
+
+bool DirModel::openIndex(int row)
+{
+    bool ret = false;
+    if (IS_VALID_ROW(row))
+    {
+        ret = openItem(mDirectoryContents.at(row));
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+    return ret;
+}
+
+bool DirModel::openPath(const QString &filename)
+{
+    DirItemInfo fi(setParentIfRelative(filename));
+    return openItem(fi);
+}
+
+/*!
+ * \brief DirModel::openItem() opens a directory/file
+ * \param fi
+ * \return  true it could open the item
+ */
+bool DirModel::openItem(const DirItemInfo &fi)
+{
+    bool ret = false;
+    if (fi.isLocal())
+    {
+        if (canReadDir(fi.diskFileInfo()))
+        {
+            ret = cdInto(fi.diskFileInfo());
+        }
+        else
+        {
+            //TODO open executables
+            if (canReadFile(fi.diskFileInfo()))
+            {
+                ret = QDesktopServices::openUrl(QUrl::fromLocalFile(fi.absoluteFilePath()));
+            }
+        }
+    }
+    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()),
+                this,          SLOT(onThereAreExternalChanges()));
+
+       //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()
+{
+    if ( IS_FILE_MANAGER_IDLE() )
+    {
+#if DEBUG_EXT_FS_WATCHER
+        qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
+                 << Q_FUNC_INFO << this << "File System modified";
+#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);
+    }
+#if DEBUG_EXT_FS_WATCHER
+    else
+    {
+        qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
+                  << Q_FUNC_INFO << this << "Busy, nothing to do";
+    }
+#endif
+}
+
+/*!
+ * \brief DirModel::onItemAddedOutsideFm() It receives a  signal saying an item was added by other application
+ * \param fi
+ */
+void DirModel::onItemAddedOutsideFm(const DirItemInfo &fi)
+{
+#if DEBUG_EXT_FS_WATCHER
+    int before  = rowCount();
+#endif
+    if (IS_FILE_MANAGER_IDLE())
+    {
+        int row = rowOfItem(fi);
+        if (row == -1)
+        {
+            onItemAdded(fi);
+        }
+    }
+#if DEBUG_EXT_FS_WATCHER
+        qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
+                 << Q_FUNC_INFO << this
+                 << "counterBefore:" << before
+                 << "added" << fi.absoluteFilePath()
+                 << "counterAfter:" << rowCount();
+#endif
+}
+
+/*!
+ * \brief DirModel::onItemRemovedOutSideFm() It receives a  signal saying an item was removed by other application
+ *
+ * Just calls \ref onItemRemoved() which already checks if the item exists
+ *
+ * \param fi
+ */
+void DirModel::onItemRemovedOutSideFm(const DirItemInfo &fi)
+{
+    if (IS_FILE_MANAGER_IDLE())
+    {
+#if DEBUG_EXT_FS_WATCHER
+        qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
+                 << Q_FUNC_INFO << this << "removed" << fi.absoluteFilePath();
+#endif
+        onItemRemoved(fi);
+    }
+}
+
+/*!
+ * \brief DirModel::onItemChangedOutSideFm()
+ *
+ * A File or a Dir modified by other applications: size,date, permissions
+ */
+void DirModel::onItemChangedOutSideFm(const DirItemInfo &fi)
+{   
+    if (IS_FILE_MANAGER_IDLE())
+    {       
+        onItemChanged(fi);
+#if DEBUG_EXT_FS_WATCHER
+        qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
+                 << Q_FUNC_INFO << this << "changed" << fi.absoluteFilePath()
+                 << "from row" << rowOfItem(fi);
+#endif
+    }
+}
+
+
+/*!
+ * \brief DirModel::onExternalFsWatcherFinihed()
+ */
+void DirModel::onExternalFsWorkerFinished(int currentDirCounter)
+{
+
+#if DEBUG_EXT_FS_WATCHER
+    qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz")
+             << Q_FUNC_INFO << this
+             << "currentDirCounter:"  << currentDirCounter;
+
+#endif
+    if (currentDirCounter == 0 && IS_FILE_MANAGER_IDLE())
+    {
+        clear();
+    }
+}
+
+
+/*!
+ * \brief DirModel:getEnabledExternalFSWatcher()
+ * \return true if the External File System Watcher is enabled
+ */
+bool DirModel::getEnabledExternalFSWatcher() const
+{
+   return mExtFSWatcher ? true : false;
+}
+
+
+/*!
+ * \brief DirModel::setEnabledExternalFSWatcher() enable/disable External File Sysmte Watcher
+ * \param enable
+ */
+void DirModel::setEnabledExternalFSWatcher(bool enable)
+{
+    if(enable)
+    {
+        startExternalFsWatcher();
+    }
+    else
+    {
+        stoptExternalFsWatcher();
+    }
+}
+
+
+bool DirModel::existsDir(const QString &folderName) const
+{
+    DirItemInfo d(setParentIfRelative(folderName));
+    return d.exists() && d.isDir();
+}
+
+bool  DirModel::canReadDir(const QString &folderName) const
+{
+    DirItemInfo d(setParentIfRelative(folderName));
+    return canReadDir(d.diskFileInfo());
+}
+
+bool  DirModel::canReadDir(const QFileInfo & d) const
+{
+    return d.exists() && d.isDir() && d.isReadable() && d.isExecutable();
+}
+
+bool DirModel::existsFile(const QString &fileName) const
+{
+     DirItemInfo f(setParentIfRelative(fileName));
+     return f.exists() && f.isFile();
+}
+
+bool DirModel::canReadFile(const QString &fileName) const
+{
+    DirItemInfo  f(setParentIfRelative(fileName));
+    return canReadFile(f.diskFileInfo());
+}
+
+bool DirModel::canReadFile(const QFileInfo &f) const
+{
+    return f.exists() && f.isFile() && f.isReadable();
+}
+
+
+
+QDateTime DirModel::curPathCreatedDate() const
+{
+   QDateTime d;
+   QFileInfo f(mCurrentDir);
+   if (f.exists())
+   {
+       d = f.created();
+   }
+   return d;
+}
+
+
+QDateTime DirModel::curPathModifiedDate() const
+{
+    QDateTime d;
+    QFileInfo f(mCurrentDir);
+    if (f.exists())
+    {
+        d = f.lastModified();
+    }
+    return d;
+}
+
+
+QDateTime DirModel::curPathAccessedDate() const
+{
+    QDateTime d;
+    QFileInfo f(mCurrentDir);
+    if (f.exists())
+    {
+        d = f.lastRead();
+    }
+    return d;
+}
+
+
+bool  DirModel::curPathIsWritable() const
+{
+    QFileInfo f(mCurrentDir);
+    return f.exists() && f.isWritable();
+}
+
+QString DirModel::curPathCreatedDateLocaleShort() const
+{
+    QString date;
+    QDateTime d(curPathCreatedDate());
+    if (!d.isNull())
+    {
+        date = d.toString(Qt::SystemLocaleShortDate);
+    }
+    return date;
+}
+
+
+QString DirModel::curPathModifiedDateLocaleShort() const
+{
+    QString date;
+    QDateTime d(curPathModifiedDate());
+    if (!d.isNull())
+    {
+        date = d.toString(Qt::SystemLocaleShortDate);
+    }
+    return date;
+}
+
+
+QString DirModel::curPathAccessedDateLocaleShort() const
+{
+    QString date;
+    QDateTime d(curPathAccessedDate());
+    if (!d.isNull())
+    {
+        date = d.toString(Qt::SystemLocaleShortDate);
+    }
+    return date;
+}
+
+
+QFileInfo  DirModel::setParentIfRelative(const QString &fileOrDir) const
+{
+    QFileInfo myFi(fileOrDir);
+    if (myFi.isRelative())
+    {
+        myFi.setFile(mCurrentDir, fileOrDir);
+        QFileInfo abs(myFi.absoluteFilePath());
+        myFi = abs;
+    }
+    return myFi;
+}
+
+
+int DirModel::getProgressCounter() const
+{
+    return m_fsAction->getProgressCounter();
+}
+
+
+void DirModel::clear()
+{
+    beginResetModel();
+    mDirectoryContents.clear();
+    mSelection->clear();
+    endResetModel();
+}
+
+
+DirSelection * DirModel::selectionObject() const
+{
+    return mSelection;
+}
+
+
+void DirModel::registerMetaTypes()
+{
+    qRegisterMetaType<DirItemInfoList>("DirItemInfoList");
+    qRegisterMetaType<DirItemInfo>("DirItemInfo");
+}
+
+void DirModel::notifyItemChanged(int row)
+{   
+    QModelIndex first = index(row,0);
+#if REGRESSION_TEST_FOLDERLISTMODEL
+    QModelIndex last  = index(row, columnCount()); //Table only when testing
+#else
+    QModelIndex last  = first; //QML uses Listview, just one column
+#endif
+    emit dataChanged(first, last);
+}
+
+
+int DirModel::getIndex(const QString &name)
+{
+    QFileInfo i(name);
+    return rowOfItem(DirItemInfo(i));
+}
+
+
+#ifndef DO_NOT_USE_TAG_LIB
+QVariant DirModel::getAudioMetaData(const QFileInfo& fi, int role) const
+{
+    QVariant empty;
+    if (!fi.isDir()) {
+        TagLib::FileRef f(fi.absoluteFilePath().toStdString().c_str(), true, TagLib::AudioProperties::Fast);
+        TagLib::MPEG::File mp3(fi.absoluteFilePath().toStdString().c_str(), true, TagLib::MPEG::Properties::Fast);        
+        TagLib::Tag *tag = f.tag();
+        if (tag)
+        {
+            TagLib::ID3v2::FrameList list = mp3.ID3v2Tag()->frameListMap()["APIC"];
+            switch (role) {
+            case TrackTitleRole:
+                return QString::fromUtf8(tag->title().toCString(true));
+            case TrackArtistRole:
+                return QString::fromUtf8(tag->artist().toCString(true));
+            case TrackAlbumRole:
+                return QString::fromUtf8(tag->album().toCString(true));
+            case TrackYearRole:
+                return QString::number(tag->year());
+            case TrackNumberRole:
+                return QString::number(tag->track());
+            case TrackGenreRole:
+                return QString::fromUtf8(tag->genre().toCString(true));
+            case TrackLengthRole:
+                if(!f.isNull() && f.audioProperties()) {
+                    return QString::number(f.audioProperties()->length());
+                } else {
+                    return QString::number(0);
+                }
+            case TrackCoverRole:
+                if(!list.isEmpty()) {
+                    TagLib::ID3v2::AttachedPictureFrame *Pic = static_cast<TagLib::ID3v2::AttachedPictureFrame *>(list.front());
+                    QImage img;
+                    img.loadFromData((const uchar *) Pic->picture().data(), Pic->picture().size());
+                    return img;
+                }
+            default:
+                break;
+            } //switch
+        }//if (tag)
+    }
+    return empty;
+}
+#endif

=== added file 'src/plugin/folderlistmodel/dirmodel.h'
--- src/plugin/folderlistmodel/dirmodel.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/dirmodel.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,430 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef DIRMODEL_H
+#define DIRMODEL_H
+
+
+#include <QStringList>
+#include <QDir>
+
+#include "iorequest.h"
+#include "filecompare.h"
+#include "diritemabstractlistmodel.h"
+#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 DirModel : public DirItemAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum Roles {
+        FileNameRole = Qt::UserRole,
+        AccessedDateRole,
+        CreationDateRole,
+        ModifiedDateRole,
+        FileSizeRole,
+        IconSourceRole,
+        FilePathRole,
+        IsDirRole,
+        IsFileRole,
+        IsReadableRole,
+        IsWritableRole,
+        IsExecutableRole,
+        IsSelectedRole,
+        TrackTitleRole,
+        TrackArtistRole,
+        TrackAlbumRole,
+        TrackYearRole,
+        TrackNumberRole,
+        TrackGenreRole,
+        TrackLengthRole,
+        TrackCoverRole
+    };
+
+public:
+    explicit DirModel(QObject *parent = 0);
+    ~DirModel();
+
+    static void registerMetaTypes();
+
+    //DirItemAbstractListModel
+    virtual int                 getIndex(const QString& name);
+    virtual void                notifyItemChanged(int row);
+
+    int rowCount(const QModelIndex &index = QModelIndex()) const
+    {
+        if (index.parent() != QModelIndex())
+            return 0;
+        return mDirectoryContents.count();
+    }
+
+    // TODO: this won't be safe if the model can change under the holder of the row
+    Q_INVOKABLE QVariant data(int row, const QByteArray &stringRole) const;
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+    Q_INVOKABLE void refresh()
+    {
+        // just some syntactical sugar really
+        setPath(path());
+    }
+
+    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
+    inline QString path() const { return mCurrentDir; }
+    void setPath(const QString &pathName);
+
+    Q_INVOKABLE QDateTime   curPathAccessedDate() const;
+    Q_INVOKABLE QDateTime   curPathCreatedDate()  const;
+    Q_INVOKABLE QDateTime   curPathModifiedDate() const;
+    Q_INVOKABLE QString     curPathAccessedDateLocaleShort() const;
+    Q_INVOKABLE QString     curPathCreatedDateLocaleShort()  const;
+    Q_INVOKABLE QString     curPathModifiedDateLocaleShort() const;
+    Q_INVOKABLE bool        curPathIsWritable() const;
+
+    Q_PROPERTY(bool awaitingResults READ awaitingResults NOTIFY awaitingResultsChanged)
+    bool awaitingResults() const;
+
+    Q_INVOKABLE void rm(const QStringList &paths);
+
+    Q_INVOKABLE bool rename(const QString& oldName, const QString& newName);
+    Q_INVOKABLE bool rename(int row, const QString &newName);
+
+    Q_INVOKABLE void mkdir(const QString &newdir);
+
+    Q_PROPERTY(bool filterDirectories READ filterDirectories WRITE setFilterDirectories NOTIFY filterDirectoriesChanged)
+    bool filterDirectories() const;
+
+    Q_PROPERTY(bool isRecursive READ isRecursive WRITE setIsRecursive NOTIFY isRecursiveChanged)
+    bool isRecursive() const;
+
+    Q_PROPERTY(bool readsMediaMetadata READ readsMediaMetadata WRITE setReadsMediaMetadata NOTIFY readsMediaMetadataChanged)
+    bool readsMediaMetadata() const;
+
+    Q_PROPERTY(bool showDirectories READ showDirectories WRITE setShowDirectories NOTIFY showDirectoriesChanged)
+    bool showDirectories() const;
+
+    Q_PROPERTY(QStringList nameFilters READ nameFilters WRITE setNameFilters NOTIFY nameFiltersChanged)
+    QStringList nameFilters() const;
+    void setNameFilters(const QStringList &nameFilters);
+
+public slots:
+    void onItemsAdded(const DirItemInfoList &newFiles);
+    void onResultsFetched();
+
+signals:
+    void awaitingResultsChanged();
+    void nameFiltersChanged();
+    void filterDirectoriesChanged();
+    void isRecursiveChanged();
+    void readsMediaMetadataChanged();
+    void showDirectoriesChanged();
+    void pathChanged(const QString& newPath);
+    void error(const QString &errorTitle, const QString &errorMessage);
+
+private:
+    QHash<int, QByteArray> buildRoleNames() const;   
+    QHash<int, QByteArray> roleNames() const;
+    QStringList mNameFilters;
+    bool mFilterDirectories;
+    bool mShowDirectories;
+    bool mAwaitingResults;
+    bool mIsRecursive;
+    bool mReadsMediaMetadata;
+    QString mCurrentDir;
+    DirItemInfoList  mDirectoryContents;
+
+public:
+
+    Q_INVOKABLE DirSelection * selectionObject() const ;
+
+    //[0] new stuff Ubuntu File Manager
+    Q_PROPERTY(QString parentPath READ parentPath NOTIFY pathChanged)
+    QString parentPath() const;
+
+    Q_PROPERTY(bool showHiddenFiles READ getShowHiddenFiles WRITE setShowHiddenFiles NOTIFY showHiddenFilesChanged)
+    bool getShowHiddenFiles() const;
+
+    Q_ENUMS(SortBy)
+    enum SortBy
+    {
+        SortByName,
+        SortByDate
+    };
+    Q_PROPERTY(SortBy sortBy READ getSortBy WRITE setSortBy NOTIFY sortByChanged)
+    SortBy getSortBy() const;
+
+    Q_ENUMS(SortOrder)
+    enum SortOrder
+    {
+        SortAscending   = Qt::AscendingOrder,
+        SortDescending = Qt::DescendingOrder
+    };
+    Q_PROPERTY(SortOrder sortOrder READ getSortOrder WRITE setSortOrder NOTIFY sortOrderChanged)
+    SortOrder getSortOrder() const;
+
+    Q_PROPERTY(int clipboardUrlsCounter READ getClipboardUrlsCounter NOTIFY clipboardChanged)
+    int getClipboardUrlsCounter() const;
+
+    Q_PROPERTY(bool enableExternalFSWatcher READ getEnabledExternalFSWatcher WRITE setEnabledExternalFSWatcher)
+    bool  getEnabledExternalFSWatcher() const;
+
+    Q_INVOKABLE QString homePath() const;
+
+    /*!
+     *    \brief Tries to make the directory pointed by row as the current to be browsed
+     *    \return true if row points to a directory and the directory is readble, false otherwise
+     */
+    Q_INVOKABLE  bool cdIntoIndex(int row);
+    Q_INVOKABLE  bool cdIntoPath(const QString& filename);
+
+    /*!
+     * \brief copyIndex() puts the item pointed by \a row (dir or file) into the clipboard
+     * \param row points to the item file or directory
+     */
+    Q_INVOKABLE void  copyIndex(int row);
+
+    /*!
+     *  \brief copyPaths(const QStringList& urls) several items (dirs or files) into the clipboard
+     *  \param items  fullpathnames or names only
+     */
+    Q_INVOKABLE void  copyPaths(const QStringList& items);
+
+    /*!
+     * \brief cutIndex() puts the item into the clipboard as \ref copy(),
+     *        mark the item to be removed after \ref paste()
+     * \param row points to the item file or directory
+     */
+    Q_INVOKABLE void  cutIndex(int row);
+
+    /*!
+     *  \brief cut() puts several items (dirs or files) into the clipboard as \ref copy(),
+     *         mark the item to be removed after \ref paste()
+     *   \param items  fullpathnames or names only
+     */
+    Q_INVOKABLE void  cutPaths(const QStringList& items);
+
+    /*!
+     * \brief removeIndex();  remove a item file or directory
+     *
+     * I gets the item indicated by \row and calls \ref rm()
+     *
+     * \param row points to the item to b e removed
+     * \return true if it was possible to remove the item
+     */
+    Q_INVOKABLE void removeIndex(int row);
+
+    /*!
+     *  Just calls \ref rm()
+     */
+    Q_INVOKABLE void removePaths(const QStringList& items);
+
+    /*!
+     *  Tries to open a file using a suitable application, if the index points to a directory
+     *  it goes into it using \ref cdIntoIndex() or \ref cdIntoPath()
+     *
+     *  \note Qt uses Qt QDesktopServices::openUrl()
+     */
+    Q_INVOKABLE bool  openIndex(int row);
+
+    /*!
+     *  Same as \ref openIndex() but using a file name instead of index
+     *
+     *  It allows to open directories and files using absoulte paths
+     *
+     *  \sa \ref cdIntoPath()
+     */
+    Q_INVOKABLE bool  openPath(const QString& filename);
+
+    /*!
+     *   \brief getProgressCounter() returns the number of \ref progress() notifications an Action will perform
+     *
+     *   It may be useful to decide about showing or not a progress dialog for Remove/Copy/Cut/Paste Actions
+     *
+     *   This function can be called just after receiving first \ref progress() notification
+     *
+     *   \note In the future this \ref getProgressCounter() and \ref progress() will merge to single signal that
+     *         will send the Action full information, it will allow to have multi thread Actions.
+     *         Also \ref cancelAction() needs to  change
+     */
+    Q_INVOKABLE int   getProgressCounter() const;
+
+    // some helper functions that can be useful to other QML applications than File Manager
+    Q_INVOKABLE  bool  existsDir(const QString&  folderName) const;
+    Q_INVOKABLE  bool  canReadDir(const QString& folderName) const;
+    Q_INVOKABLE  bool  existsFile(const QString& fileName)   const;
+    Q_INVOKABLE  bool  canReadFile(const QString& fileName)  const;
+
+public slots:
+    /*!
+     * \brief goHome() goes to user home dir
+     *  Go to user home dir, we may have a tab for places or something like that
+     */
+    void  goHome();
+
+    /*!
+     * \brief cdUp() sets the parent directory as current directory
+     *
+     *  It can work as a back function if there is no user input path
+     * \return true if it was possible to change to parent dir, otherwise false
+     */
+    bool  cdUp();
+
+    /*!
+     * \brief paste() copy item(s) from \ref copy() and \ref paste() into the current directory
+     *
+     *  If the operation was \ref cut(), then remove the original item
+     */
+    void paste();
+
+    /*!
+     * \brief cancelAction() any copy/cut/remove can be cancelled
+     */
+    void cancelAction();    
+
+    void setIsRecursive(bool isRecursive);
+    void setReadsMediaMetadata(bool readsMediaMetadata);
+    void setFilterDirectories(bool filterDirectories);
+    void setShowDirectories(bool showDirectories);
+    void setShowHiddenFiles(bool show);
+    void setSortBy(SortBy field);
+    void setSortOrder(SortOrder order);
+    void setEnabledExternalFSWatcher(bool enable);
+
+
+    void toggleShowDirectories();
+    void toggleShowHiddenFiles();
+    void toggleSortOrder();
+    void toggleSortBy();
+
+signals:
+    /*!
+     * \brief insertedItem()
+     *
+     *  It happens when a new file is inserted in an existent view,
+     *  for example from  \ref mkdir() or \ref paste()
+     *
+     *  It can be used to make the new row visible to the user doing a scroll to
+     */
+    void  insertedRow(int row);
+    /*!
+     * \brief progress()
+     *  Sends status about recursive and multi-items remove/move/copy
+     *
+     * \param curItem     current item being handled
+     * \param totalItems  total of items including recursive directories content
+     * \param percent     a percent done
+     */
+    void     progress(int curItem, int totalItems, int percent);
+
+    void     showHiddenFilesChanged();
+    void     sortByChanged();
+    void     sortOrderChanged();
+
+    void     clipboardChanged();
+
+private slots:
+    void onItemRemoved(const QString&);
+    void onItemRemoved(const DirItemInfo&);
+    void onItemAdded(const QString&);
+    void onItemAdded(const DirItemInfo&);
+    void onItemChanged(const DirItemInfo&);
+
+private:
+    int           addItem(const DirItemInfo& fi);
+    void          setCompareAndReorder();
+    int           rowOfItem(const DirItemInfo& fi);
+    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          canReadDir(const QFileInfo& d)   const;
+    bool          canReadFile(const QFileInfo& f)  const;
+    QFileInfo     setParentIfRelative(const QString &fileOrDir) const;
+
+private:
+    void          startExternalFsWatcher();
+    void          stoptExternalFsWatcher();
+    void          clear();
+private slots:
+    void          onItemAddedOutsideFm(const DirItemInfo&fi);
+    void          onItemRemovedOutSideFm(const DirItemInfo&);
+    void          onItemChangedOutSideFm(const DirItemInfo&fi);
+    void          onThereAreExternalChanges();
+    void          onExternalFsWorkerFinished(int);
+
+
+private:
+    bool                mShowHiddenFiles;
+    SortBy              mSortBy;
+    SortOrder           mSortOrder;
+    CompareFunction     mCompareFunction;
+    ExternalFSWatcher*  mExtFSWatcher;
+    Clipboard *         mClipboard;
+    DirSelection *      mSelection;
+
+
+private:
+    FileSystemAction  *  m_fsAction;  //!< it does file system recursive remove/copy/move
+    QString  fileSize(qint64 size)  const;
+#ifndef DO_NOT_USE_TAG_LIB
+    QVariant getAudioMetaData(const QFileInfo& fi, int role) const;
+#endif
+//[0]
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    //make this work with tables
+    virtual int columnCount(const QModelIndex &parent = QModelIndex()) const
+    {
+        Q_UNUSED(parent);
+        return TrackCoverRole - FileNameRole + 1;
+    }
+    virtual QVariant  headerData(int section, Qt::Orientation orientation, int role) const;
+    friend class TestDirModel;
+#endif
+};
+
+
+#endif // DIRMODEL_H

=== added file 'src/plugin/folderlistmodel/dirselection.cpp'
--- src/plugin/folderlistmodel/dirselection.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/dirselection.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,298 @@
+/**************************************************************************
+ *
+ * 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: dirselection.cpp
+ * Date: 29/01/2014
+ */
+
+#include "dirselection.h"
+#include "diritemabstractlistmodel.h"
+#include <QTimer>
+#include <QDebug>
+
+
+#define  VALID_INDEX(index)   (index >= 0 && index < m_model->rowCount())
+
+DirSelection::DirSelection(QObject *parent) :  QObject(parent)
+{
+}
+
+DirSelection::DirSelection(DirItemAbstractListModel *parent, DirItemInfoList *listItems) :
+    QObject(parent)
+   ,m_selectedCounter(0)
+   ,m_model(parent)
+   ,m_listItems(listItems)
+   ,m_mode(Single)  
+   ,m_lastSelectedItem(-1)
+{
+}
+
+
+
+QStringList DirSelection::selectedAbsFilePaths() const
+{
+    QStringList ret;
+    int counter = m_model->rowCount();
+    for(int index = 0 ; index < counter; ++index)
+    {
+        if (m_listItems->at(index).isSelected())
+        {
+            ret.append(m_listItems->at(index).absoluteFilePath());
+        }
+    }
+    return ret;
+}
+
+QStringList DirSelection::selectedNames() const
+{
+    QStringList ret;
+    int counter = m_model->rowCount();
+    for(int index = 0 ; index < counter; ++index)
+    {
+        if (m_listItems->at(index).isSelected())
+        {
+            ret.append(m_listItems->at(index).fileName());
+        }
+    }
+    return ret;
+}
+
+
+
+QList<int>  DirSelection::selectedIndexes()    const
+{
+    QList<int> ret;
+    int counter = m_model->rowCount();
+    for(int index = 0 ; index < counter; ++index)
+    {
+        if (m_listItems->at(index).isSelected())
+        {
+            ret.append(index);
+        }
+    }
+    return ret;
+}
+
+
+void DirSelection::clear()
+{   
+    if (priv_clear())
+    {
+        notifyChanges();
+    }
+}
+
+
+bool DirSelection::priv_clear()
+{
+    bool notify = m_selectedCounter != 0;
+    if (notify)
+    {
+        int counter = m_model->rowCount();
+        DirItemInfo *data =  m_listItems->data();
+        while (m_selectedCounter > 0  && counter-- )
+        {
+            if ( data[counter].setSelection(false) )
+            {
+                --m_selectedCounter;
+                m_model->notifyItemChanged(counter);              
+            }
+        }
+    }
+    //force it to zero, works when cleaning the buffer first
+    m_selectedCounter  = 0;
+    m_lastSelectedItem = -1;
+    return notify;
+}
+
+
+void DirSelection::selectAll()
+{
+    int counter = m_model->rowCount();
+    bool notify = m_selectedCounter != counter;
+    if (notify)
+    {
+        DirItemInfo *data =  m_listItems->data();
+        while ( counter-- )
+        {
+            if ( data[counter].setSelection(true) )
+            {
+                ++m_selectedCounter;
+                m_model->notifyItemChanged(counter);              
+            }
+        }
+        notifyChanges();
+    }
+}
+
+
+int DirSelection::counter() const
+{
+    return m_selectedCounter;
+}
+
+
+DirSelection::Mode DirSelection::mode() const
+{
+    return m_mode;
+}
+
+
+void DirSelection::itemGoingToBeRemoved(const DirItemInfo &item)
+{
+    if (m_selectedCounter > 0 && item.isSelected())
+    {      
+        --m_selectedCounter;
+        notifyChanges();
+    }
+    // item is going to be removed, no QAbstractItemModel::dataChanged() signal is necessary to refresh views
+}
+
+
+void DirSelection::setIndex(int index, bool selected)
+{
+     if (VALID_INDEX(index))
+     {
+         int old_selectedCounter = m_selectedCounter;
+         if (selected && m_mode == Single && m_selectedCounter > 0)
+         {
+             priv_clear();
+         }       
+         if (    priv_setIndex(index, selected)
+              || old_selectedCounter != m_selectedCounter
+            )
+         {
+             notifyChanges();
+         }
+     }
+}
+
+
+void DirSelection::toggleIndex(int index)
+{
+    if (VALID_INDEX(index))
+    {
+        setIndex(index, !m_listItems->at(index).isSelected());
+    }
+}
+
+
+void DirSelection::setMode(Mode m)
+{
+    if (m != m_mode)
+    {
+        m_mode = m;
+        emit modeChanged(m_mode);
+    }
+}
+
+
+void DirSelection::notifyChanges()
+{
+    emit selectionChanged(m_selectedCounter);    
+}
+
+
+/*!
+ * \brief DirSelection::itemGoingToBeReplaced() it is supposed to control selection writable and readabble states
+ *
+ *     So far it does nothing
+ *
+ * \param oldItemInfo
+ * \param newItemInfo
+ */
+void DirSelection::itemGoingToBeReplaced(const DirItemInfo &oldItemInfo,
+                                         const DirItemInfo &newItemInfo)
+{
+    if (oldItemInfo.isSelected())
+    {
+       // we may add selection writable state in the future
+        Q_UNUSED(newItemInfo);
+    }   
+}
+
+
+void DirSelection::selectRange(int indexClicked)
+{
+    bool changed = false;
+    if (   VALID_INDEX(indexClicked)
+        && m_selectedCounter > 0
+        && indexClicked != m_lastSelectedItem
+        && VALID_INDEX(m_lastSelectedItem)
+        && !m_listItems->at(indexClicked).isSelected()
+       )
+    {
+        //go from indexClicked to  m_lastSelectedItem
+        int  increment = indexClicked > m_lastSelectedItem?  -1 : 1;
+        int  nextItem  = indexClicked;
+        int  saved_lastSelectedItem = m_lastSelectedItem;
+        while (priv_setIndex(nextItem, true) && nextItem != saved_lastSelectedItem)
+        {
+            nextItem  += increment;
+            changed    = true;
+        }
+    }
+    if (changed)
+    {
+        notifyChanges();
+    }
+}
+
+
+bool DirSelection::priv_setIndex(int index, bool selected)
+{
+    DirItemInfo *data  = m_listItems->data();
+    bool changed = false;
+    if ((changed = data[index].setSelection(selected)))
+    {
+        m_model->notifyItemChanged(index);
+        if (selected)
+        {
+            ++m_selectedCounter;         
+            m_lastSelectedItem = index;
+        }
+        else
+        {
+            --m_selectedCounter;          
+        }
+    }
+    return changed;
+}
+
+
+void DirSelection::select(int index, bool range, bool multiSelection )
+{
+    if (range && VALID_INDEX(m_lastSelectedItem))
+    {
+        selectRange(index);
+    }
+    else
+    {
+        if (multiSelection || m_mode == Multi)
+        {
+            Mode saveMode = m_mode;
+            //set Multi selection do not  call clear()
+            m_mode = Multi;
+            toggleIndex(index);
+            m_mode = saveMode;
+        }
+        else
+        {
+            setIndex(index, true);
+        }
+    }
+}

=== added file 'src/plugin/folderlistmodel/dirselection.h'
--- src/plugin/folderlistmodel/dirselection.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/dirselection.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,116 @@
+/**************************************************************************
+ *
+ * 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: dirselection.h
+ * Date: 29/01/2014
+ */
+
+#ifndef DIRSELECTION_H
+#define DIRSELECTION_H
+
+#include "diriteminfo.h"
+
+#include <QObject>
+#include <QStringList>
+
+
+class DirItemAbstractListModel;
+
+class DirSelection : public QObject
+{
+    Q_OBJECT
+public:
+    explicit DirSelection(DirItemAbstractListModel *parent,  DirItemInfoList *listItems);
+    explicit DirSelection(QObject *parent = 0);
+public slots:
+        void        selectRange(int indexClicked);
+        void        selectAll();
+        void        clear();      
+        void        toggleIndex(int index);     
+        void        setIndex(int index, bool selected);
+
+public:
+        Q_ENUMS(Mode)
+        enum Mode
+        {
+            Single,
+            Multi
+        };
+        Q_PROPERTY(int counter   READ counter   NOTIFY selectionChanged)
+        Q_PROPERTY(Mode mode  READ mode WRITE setMode NOTIFY modeChanged)
+        Q_INVOKABLE  QStringList selectedNames()      const;
+        Q_INVOKABLE  void        setMode(Mode m);
+        Q_INVOKABLE  QStringList selectedAbsFilePaths()  const;   //full path
+        Q_INVOKABLE  QList<int>  selectedIndexes()    const;
+        int                      counter()            const;
+        Mode                     mode()               const;
+
+public:
+       /*!
+        *   It allows to pass Control Modifiers directly to perform the  most common selection behaviour.
+        *
+        *   Usage Example:
+        *        \li  1 When selecting an item with Shit key pressed it selects the rage calling \ref selectRange()
+        *        \li  2 When selecting an item with Crtl key pressed it temporarily forces Multi Selection Mode
+        *             calling \ref toggleIndex() instead of \ref setIndex();
+        *
+        * \param range when true it calls \ref selectRange() and does not consider the \a multiSelection parameter
+        *
+        * \param multiSelection when \a false it respects the current selection mode: calls \ref setIndex()
+        *          for \ref Single selection mode or \ref toggleIndex() for \ref Multi selection mode.
+        *          When \a true it calls \ref toggleIndex()
+        *
+        * QML example:
+        *  \code
+        *       property FolderListSelection selectionManager: pageModel.selectionObject()
+        *       ...
+        *
+        *       MouseArea   {
+        *           anchors.fill: parent
+        *           onClicked: {
+        *               selectionManager.select(model.index,
+        *                                       (mouse.modifiers & Qt.ShiftModifier),
+        *                                       (mouse.modifiers & Qt.ControlModifier) );
+        *           }
+        *       }
+        *  \endcode
+        *
+        */
+        Q_INVOKABLE  void        select(int index, bool range, bool multiSelection );
+
+public:
+        void        itemGoingToBeRemoved(const DirItemInfo& item);
+        void        itemGoingToBeReplaced(const DirItemInfo& oldItemInfo, const DirItemInfo& newItemInfo);
+
+private:      
+        bool        priv_clear();
+        void        notifyChanges();
+        bool        priv_setIndex(int index, bool selected);
+
+signals:
+        void        selectionChanged(int);
+        void        modeChanged(int);
+
+private:
+        int                        m_selectedCounter;
+        DirItemAbstractListModel*  m_model;
+        DirItemInfoList *          m_listItems;
+        Mode                       m_mode;       
+        int                        m_lastSelectedItem;
+};
+
+#endif // DIRSELECTION_H

=== added file 'src/plugin/folderlistmodel/externalfswatcher.cpp'
--- src/plugin/folderlistmodel/externalfswatcher.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/externalfswatcher.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,114 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 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: externalfswatcher.cpp
+ * Date: 9/14/2013
+ */
+
+#include "externalfswatcher.h"
+
+#include <QTimer>
+#include <QDateTime>
+#include <QDebug>
+
+#if DEBUG_EXT_FS_WATCHER
+# define DEBUG_FSWATCHER()    \
+    qDebug() << "[extFsWatcher]" << QDateTime::currentDateTime().toString("hh:mm:ss.zzz") \
+             << Q_FUNC_INFO << "m_setPath:" << m_setPath \
+             << "m_changedPath:" << m_changedPath        \
+             << "m_waitingEmit:" << m_waitingEmitCounter
+#else
+# define DEBUG_FSWATCHER()  /**/
+#endif //
+
+
+ExternalFSWatcher::ExternalFSWatcher(QObject *parent) :
+    QFileSystemWatcher(parent)
+  , m_waitingEmitCounter(0)
+  , m_msWaitTime(DEFAULT_NOTICATION_PERIOD)
+{
+    connect(this,   SIGNAL(directoryChanged(QString)),
+            this,   SLOT(slotDirChanged(QString)));
+}
+
+
+void ExternalFSWatcher::setCurrentPath(const QString &curPath)
+{
+    if (!curPath.isEmpty())
+    {
+        if (m_setPath != curPath)
+        {
+            if (!m_setPath.isEmpty())
+            {
+                removePath(m_setPath);
+            }
+            m_setPath = curPath;
+            addPath(m_setPath);
+        }        
+    }
+    DEBUG_FSWATCHER();
+}
+
+
+void ExternalFSWatcher::slotDirChanged(const QString &dir)
+{
+    DEBUG_FSWATCHER();
+    if (    (m_setPath == dir)
+         && ( m_waitingEmitCounter == 0 || m_setPath != m_changedPath )
+       )
+    {
+        removePath(m_setPath);
+        ++m_waitingEmitCounter;
+        m_changedPath = m_setPath;
+        QTimer::singleShot(m_msWaitTime, this, SLOT(slotFireChanges()));       
+    }
+}
+
+
+/*!
+ * \brief ExternalFSWatcher::slotFireChanges() emits \ref pathModified() only when it is sure
+ *  that the  current path was changed.
+ *
+ *  A change for the current path (the last current) MUST be notified at least once.
+ */
+void ExternalFSWatcher::slotFireChanges()
+{
+   if (--m_waitingEmitCounter == 0)
+   {
+       addPath(m_setPath);
+       if (m_setPath == m_changedPath)
+       {
+           emit pathModified();
+#if DEBUG_EXT_FS_WATCHER
+       DEBUG_FSWATCHER() << "emit pathModified()";
+#endif
+       }
+   }  
+}
+
+
+
+void ExternalFSWatcher::setIntervalToNotifyChanges(int ms)
+{
+    m_msWaitTime = ms;
+}
+
+
+int ExternalFSWatcher::getIntervalToNotifyChanges() const
+{
+    return m_msWaitTime;
+}

=== added file 'src/plugin/folderlistmodel/externalfswatcher.h'
--- src/plugin/folderlistmodel/externalfswatcher.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/externalfswatcher.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,68 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 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: externalfswatcher.h
+ * Date: 9/14/2013
+ */
+
+#ifndef EXTERNALFSWATCHER_H
+#define EXTERNALFSWATCHER_H
+
+#include <QFileSystemWatcher>
+
+#define DEFAULT_NOTICATION_PERIOD  500
+
+
+/*!
+ * \brief The ExternalFSWatcher class notifies the owner when the File System when the current path \a m_setPath has changed
+ *            emitting pathModified() signal.
+ *
+ *  The current path \a m_setPath is set by using the slot \ref  setCurrentPath()
+ *
+ *  The idea of this class is to minimize notifications as the current path can change quickly.
+ *  A notification will occur if it was requested for a path and this path is still the current at the moment
+ *  of the notification.
+ *
+ *  Once it detects a change it will wait \ref getIntervalToNotifyChanges() milliseconds to notify that change.
+ *  At this moment it checks if no \ref setCurrentPath() has been called during this time and then notifies that change.
+ */
+class ExternalFSWatcher : public QFileSystemWatcher
+{
+    Q_OBJECT
+public:
+    explicit ExternalFSWatcher(QObject *parent = 0);
+    int      getIntervalToNotifyChanges() const;
+
+signals:
+     void      pathModified();
+
+     public slots:
+     void      setCurrentPath(const QString& curPath);
+     void      setIntervalToNotifyChanges(int ms);     
+
+private slots:
+     void      slotDirChanged(const QString&);
+     void      slotFireChanges();
+
+ private:
+     QString   m_setPath;
+     QString   m_changedPath;   
+     unsigned  m_waitingEmitCounter;
+     int       m_msWaitTime;
+};
+
+#endif // EXTERNALFSWATCHER_H

=== added file 'src/plugin/folderlistmodel/filecompare.cpp'
--- src/plugin/folderlistmodel/filecompare.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/filecompare.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,108 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: filecompare.cpp
+ * Date: 6/25/2013
+ */
+
+#include "filecompare.h"
+#include "diriteminfo.h"
+#include <QString>
+#include <QDateTime>
+#include <QDebug>
+
+
+
+bool fileCompareExists(const DirItemInfo &a, const DirItemInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    bool ret = QString::localeAwareCompare(a.fileName(), b.fileName()) < 0;
+#if DEBUG_MESSAGES
+    qDebug() <<  Q_FUNC_INFO << ret << a.fileName() << b.fileName();
+#endif
+
+    return ret;
+}
+
+
+bool fileCompareAscending(const DirItemInfo &a, const DirItemInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return QString::localeAwareCompare(a.fileName(), b.fileName()) < 0;
+}
+
+
+bool fileCompareDescending(const DirItemInfo &a, const DirItemInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return QString::localeAwareCompare(a.fileName(), b.fileName()) > 0;
+}
+
+
+bool dateCompareDescending(const DirItemInfo &a, const DirItemInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return a.lastModified() > b.lastModified();
+}
+
+
+bool dateCompareAscending(const DirItemInfo &a, const DirItemInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return a.lastModified() < b.lastModified();
+}
+

=== added file 'src/plugin/folderlistmodel/filecompare.h'
--- src/plugin/folderlistmodel/filecompare.h	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/filecompare.h	2014-04-15 08:19:22 +0000
@@ -0,0 +1,51 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: filecompare.h
+ * Date: 6/25/2013
+ */
+
+#ifndef FILECOMPARE_H
+#define FILECOMPARE_H
+
+class DirItemInfo;
+
+typedef bool  (*CompareFunction)(const DirItemInfo &a, const DirItemInfo &b);
+
+bool fileCompareExists(const DirItemInfo &a, const DirItemInfo &b);
+bool fileCompareAscending(const DirItemInfo &a, const DirItemInfo &b);
+bool fileCompareDescending(const DirItemInfo &a, const DirItemInfo &b);
+
+bool dateCompareDescending(const DirItemInfo &a, const DirItemInfo &b);
+bool dateCompareAscending(const DirItemInfo &a, const DirItemInfo &b);
+
+#endif // FILECOMPARE_H

=== added file 'src/plugin/folderlistmodel/filesystemaction.cpp'
--- src/plugin/folderlistmodel/filesystemaction.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/folderlistmodel/filesystemaction.cpp	2014-04-15 08:19:22 +0000
@@ -0,0 +1,1302 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: filesystemaction.cpp
+ * Date: 3/13/2013
+ */
+
+#include "filesystemaction.h"
+#include "clipboard.h"
+
+#if defined(Q_OS_UNIX)
+#include <sys/statvfs.h>
+#endif
+
+#include <errno.h>
+
+#include <QDirIterator>
+#include <QDebug>
+#include <QTimer>
+#include <QFileInfo>
+#include <QDir>
+#include <QThread>
+#include <QTemporaryFile>
+
+/*!
+ *   number of the files to work on a step, when this number is reached a signal is emitted
+ */
+#define  STEP_FILES               5
+
+/*!
+  * buffer size to to single read/write operation
+ */
+#define  COPY_BUFFER_SIZE         4096
+
+/*!
+ *  Auxiliar Actions do not emit progress() signal
+ *  \sa moveDirToTempAndRemoveItLater()
+ */
+#define SHOULD_EMIT_PROGRESS_SIGNAL(action)       (!action->isAux)
+
+#define   COMMON_SIZE_ITEM       120
+
+
+
+
+void FileSystemAction::CopyFile::clear()
+{
+    bytesWritten = 0;
+    if (source)   delete source;
+    if (target)   delete target;
+    source = 0;
+    target = 0;
+}
+
+
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::FileSystemAction
+ * \param parent
+ */
+FileSystemAction::FileSystemAction(QObject *parent) :
+    QObject(parent)
+  , m_curAction(0)
+  , m_cancelCurrentAction(false)
+  , m_busy(false)  
+  , m_clipboardChanged(false)
+{
+
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::~FileSystemAction
+ */
+FileSystemAction::~FileSystemAction()
+{   
+
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::remove
+ * \param paths
+ */
+void FileSystemAction::remove(const QStringList &paths)
+{
+    createAndProcessAction(ActionRemove, paths);
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::createAction
+ * \param type
+ * \param origBase
+ * \return
+ */
+FileSystemAction::Action* FileSystemAction::createAction(ActionType type, int  origBase)
+{
+    Action * action = new Action();
+    action->type         = type;
+    action->baseOrigSize = origBase;
+    action->targetPath   = m_path;
+    action->totalItems   = 0;
+    action->currItem     = 0;
+    action->currEntryIndex    = 0;
+    action->totalBytes   = 0;
+    action->bytesWritten = 0;
+    action->done         = false;
+    action->auxAction    = 0;
+    action->isAux        = false;
+    action->currEntry    = 0;
+    action->steps        = 1;
+
+    return action;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::addEntry
+ * \param action
+ * \param pathname
+ */
+void  FileSystemAction::addEntry(Action* action, const QString& pathname)
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << pathname;
+#endif
+    DirItemInfo info(pathname);
+    if (!info.isAbsolute())
+    {
+        info.setFile(action->targetPath, pathname);
+    }
+    if (!info.exists())
+    {
+        emit error(QObject::tr("File or Directory does not exist"),
+                   pathname + QObject::tr(" does not exist")
+                  );       
+        return;
+    }
+    ActionEntry * entry = new ActionEntry();
+    //this is the item being handled
+    entry->reversedOrder.append(info);
+    // verify if the destination item already exists
+    if (action->type == ActionCopy ||
+        action->type == ActionMove ||
+        action->type == ActionHardMoveCopy)
+    {
+        DirItemInfo destination(targetFom(info.absoluteFilePath(), action));
+        entry->alreadyExists = destination.exists();
+    }
+    //ActionMove will perform a rename, so no Directory expanding is necessary
+    if (action->type != ActionMove && info.isDir() && !info.isSymLink())
+    {
+        QDirIterator it(info.absoluteFilePath(),
+                        QDir::AllEntries | QDir::System |
+                              QDir::NoDotAndDotDot | QDir::Hidden,
+                        QDirIterator::Subdirectories);
+        while (it.hasNext() &&  !it.next().isEmpty())
+        {
+            entry->reversedOrder.prepend(it.fileInfo());
+        }
+    }
+    //set steps and total bytes considering all items in the Entry
+    int counter = entry->reversedOrder.count();
+    qint64 size = 0;
+    int sizeSteps = 0;
+    int bufferSize = (COPY_BUFFER_SIZE * STEP_FILES);
+    while (counter--)
+            {
+        const DirItemInfo & item =  entry->reversedOrder.at(counter);
+        size =  (item.isFile() && !item.isDir() && !item.isSymLink()) ?
+                 item.size() :   COMMON_SIZE_ITEM;
+        action->totalBytes +=  size;
+        if (action->type == ActionCopy || action->type == ActionHardMoveCopy)
+        {
+            if ( (sizeSteps = size / bufferSize) )
+            {
+                if ( !(size % bufferSize) )
+                {
+                    --sizeSteps;
+            }
+                action->steps      += sizeSteps ;
+        }
+    }
+    }
+    //set final steps for the Entry based on Items number
+    int entrySteps = entry->reversedOrder.count() / STEP_FILES;
+    if ( entry->reversedOrder.count() % STEP_FILES) entrySteps++;
+    action->steps      += entrySteps;
+    action->totalItems += entry->reversedOrder.count();
+#if DEBUG_MESSAGES
+    qDebug() << "entrySteps" << entrySteps << "from entry counter" << entry->reversedOrder.count()
+             << "total steps" << action->steps;
+#endif
+    //now put the Entry in the Action
+    action->entries.append(entry);
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::processAction
+ */
+void FileSystemAction::processAction()
+{
+    if (m_curAction)
+    {
+        //it will be ActionHardMoveRemove only when switched from ActionHardMoveCopy
+        //in this case the move is done in two steps COPY and REMOVE
+        if (m_curAction->type != ActionHardMoveCopy)
+        {
+            delete m_curAction;
+            m_curAction = 0;
+        }
+    }
+    if (!m_curAction && m_queuedActions.count())
+    {
+        m_curAction = m_queuedActions.at(0);
+        m_curAction->currEntry = static_cast<ActionEntry*>
+                ( m_curAction->entries.at(0));
+        m_queuedActions.remove(0,1);
+    }
+    if (m_curAction)
+    {
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << "performing action type" << m_curAction->type;
+#endif
+        m_busy = true;
+        m_cancelCurrentAction = false;
+        m_errorMsg.clear();
+        m_errorTitle.clear();
+        scheduleSlot(SLOT(processActionEntry()));
+        if (SHOULD_EMIT_PROGRESS_SIGNAL(m_curAction))
+        {
+            emit progress(0,m_curAction->totalItems, 0);
+        }
+    }
+    else
+    {
+         m_busy = false;
+    }
+}
+
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::processActionEntry
+ */
+void FileSystemAction::processActionEntry()
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO;
+#endif
+
+    ActionEntry * curEntry = m_curAction->currEntry;
+
+#if defined(SIMULATE_LONG_ACTION)
+    {
+        unsigned int delay = SIMULATE_LONG_ACTION;
+        if (delay == 1)
+        {
+            delay = 100;           //each (10 * STEP_FILES) files will waits a second
+            QThread::currentThread()->wait(delay);
+        }
+    }
+#endif
+    if (!m_cancelCurrentAction)
+    {
+        switch(m_curAction->type)
+        {
+           case ActionRemove:
+           case ActionHardMoveRemove:
+                removeEntry(curEntry);
+                endActionEntry();
+                break;
+           case ActionCopy:
+           case ActionHardMoveCopy:
+                processCopyEntry();          // specially: this is a slot
+                break;
+          case ActionMove:
+                moveEntry(curEntry);
+                endActionEntry();
+                break;
+        }
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::endActionEntry
+ */
+void FileSystemAction::endActionEntry()
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO;
+#endif
+     ActionEntry * curEntry = m_curAction->currEntry;
+
+    // first of all check for any error or a cancel issued by the user
+    if (m_cancelCurrentAction)
+    {
+        if (!m_errorTitle.isEmpty())
+        {
+            emit error(m_errorTitle, m_errorMsg);
+        }
+        //it may have other actions to do
+        scheduleSlot(SLOT(processAction()));
+        return;
+    }
+    // check if the current entry has finished
+    // if so Views need to receive the notification about that
+    if (curEntry->currItem == curEntry->reversedOrder.count())
+    {
+        const DirItemInfo & mainItem = curEntry->reversedOrder.at(curEntry->currItem -1);
+        m_curAction->currEntryIndex++;
+        switch(m_curAction->type)
+        {
+           case ActionRemove:           
+                emit removed(mainItem);
+                break;
+           case ActionHardMoveRemove: // nothing to do
+                break;
+           case ActionHardMoveCopy:
+                //check if is doing a hard move and the copy part has finished
+                //if so switch the action to remove
+                if (m_curAction->currEntryIndex == m_curAction->entries.count())
+                {
+                   m_curAction->type      = ActionHardMoveRemove;
+                   m_curAction->currEntryIndex = 0;
+                   int entryCounter = m_curAction->entries.count();
+                   ActionEntry * entry;
+                   while (entryCounter--)
+                   {
+                       entry = m_curAction->entries.at(entryCounter);
+                       entry->currItem = 0;
+                       entry->currStep = 0;
+                   }
+                }
+           case ActionCopy: // ActionHardMoveCopy is also checked here
+           case ActionMove:
+                {
+                    QString addedItem = targetFom(mainItem.absoluteFilePath(), m_curAction);
+                    if (!curEntry->added && !curEntry->alreadyExists)
+                    {
+                        emit added(addedItem);
+                        curEntry->added = true;
+                    }
+                    else
+                    {
+                        emit changed(DirItemInfo(addedItem));
+                    }
+                }
+                break;
+        }//switch
+
+    }//end if (curEntry->currItem == curEntry->reversedOrder.count())
+
+    if (curEntry->currStep == STEP_FILES)
+    {
+        curEntry->currStep = 0;
+    }
+
+    int percent = notifyProgress();
+    //Check if the current action has finished or cancelled
+    if (m_cancelCurrentAction ||
+        m_curAction->currEntryIndex == m_curAction->entries.count())
+    {
+        if (!m_cancelCurrentAction)
+        {
+            endCurrentAction();
+            if (percent < 100)
+            {
+                notifyProgress(100);
+            }
+        }
+        //it may have other actions to do
+        scheduleSlot(SLOT(processAction()));
+    }
+    else
+    {
+        m_curAction->currEntry = static_cast<ActionEntry*>
+                ( m_curAction->entries.at(m_curAction->currEntryIndex) );
+        //keep working on current Action maybe more entries
+        scheduleSlot(SLOT(processActionEntry()));
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::cancel
+ */
+void FileSystemAction::cancel()
+{
+    m_cancelCurrentAction = true;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::removeEntry
+ * \param entry
+ */
+void FileSystemAction::removeEntry(ActionEntry *entry)
+{
+    QDir dir;
+    //do one step at least
+    for(; !m_cancelCurrentAction                          &&
+          entry->currStep       < STEP_FILES              &&
+          m_curAction->currItem < m_curAction->totalItems &&
+          entry->currItem       < entry->reversedOrder.count()
+        ; entry->currStep++,    m_curAction->currItem++, entry->currItem++
+        )
+
+    {
+        const DirItemInfo &fi = entry->reversedOrder.at(entry->currItem);
+        if (fi.isDir() && !fi.isSymLink())
+        {
+            m_cancelCurrentAction = !dir.rmdir(fi.absoluteFilePath());
+        }
+        else
+        {
+            m_cancelCurrentAction = !QFile::remove(fi.absoluteFilePath());
+        }
+#if DEBUG_REMOVE
+        qDebug() << Q_FUNC_INFO << "remove ret=" << !m_cancelCurrentAction << fi.absoluteFilePath();
+#endif
+        if (m_cancelCurrentAction)
+        {
+            m_errorTitle = QObject::tr("Could not remove the item ") +
+                                       fi.absoluteFilePath();
+            m_errorMsg   = ::strerror(errno);
+        }
+    }
+}
+
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::copyEntry
+ * \param entry
+ */
+void  FileSystemAction::processCopyEntry()
+{
+     ActionEntry * entry = m_curAction->currEntry;
+
+#if DEBUG_MESSAGES
+     qDebug() << Q_FUNC_INFO << "processing"
+              << entry->reversedOrder.at(entry->reversedOrder.count() -1).absoluteFilePath();
+#endif
+    /*
+     * This flag will be true when processCopySingleFile() has put any slot in the execution queue
+     * it will work to stop the loop.
+     * Later processCopyEntry() will be called again to continue working
+     */
+    bool scheduleAnySlot = false;
+
+    //first item from an Entry,    
+    if (entry->currItem == 0 && entry->alreadyExists && entry->newName == 0)
+    {
+        //making backup only if the targetpath == origPath, otherwise the item is overwritten
+        if (m_curAction->targetPath == m_curAction->origPath)
+        {
+            //it will check again if the target exists
+            //if so, sets the entry->newName
+            //then targetFom() will use entry->newName for
+            //  sub items in the Entry if the Entry is a directory
+            if (!makeBackupNameForCurrentItem(m_curAction) )
+            {
+                m_cancelCurrentAction = true;
+                m_errorTitle = QObject::tr("Could not find a suitable name to backup");
+                m_errorMsg   = entry->reversedOrder.at(
+                            entry->reversedOrder.count() -1
+                            ).absoluteFilePath();
+            }
+        }
+#if DEBUG_MESSAGES
+        else
+        {
+            qDebug() <<  entry->reversedOrder.at(entry->reversedOrder.count() -1).absoluteFilePath()
+                     << " already exists and will be overwritten";
+        }
+#endif
+    }
+
+    for(; !m_cancelCurrentAction  && !scheduleAnySlot     &&
+          entry->currStep       < STEP_FILES              &&
+          m_curAction->currItem < m_curAction->totalItems &&
+          entry->currItem       < entry->reversedOrder.count()
+        ; entry->currStep++,    entry->currItem++
+        )
+
+    {
+        const DirItemInfo &fi = entry->reversedOrder.at(entry->currItem);
+        QString orig    = fi.absoluteFilePath();
+        QString target = targetFom(orig, m_curAction);
+        QString path(target);
+        // do this here to allow progress send right item number, copySingleFile will emit progress()
+        m_curAction->currItem++;
+        //--
+        if (fi.isFile() || fi.isSymLink())
+        {
+            DirItemInfo  t(target);
+            path = t.path();