Merge lp:~carlos-mazieri/ubuntu-filemanager-app/trash-operations-2 into lp:ubuntu-filemanager-app

[Carlos Jose Mazieri]

ActionPaths now is used in Actions

ActionPaths now is used in Actions.
FileSystemAction::Action::type is kept to indentify the whole Action.

Each entry (item being handled) has its own FileSystemAction::ActionEntry::type,
so they are independent from the whole Action itself.

When restoring items from Trash for example they need to be independent;
the check for different file systems is also made for every item (when moving items),
it used to be done just once for the whole Action.
There will be a "ActionRestoreFromTrash" for the whole action where some items can be retored to different file system while others to the same file system. Items restored to the same file system will have FileSystemAction::ActionEntry::type = ActionMove, while items restored to different file systems will perform two actions: FileSystemAction::ActionEntry::type = ActionHardMoveCopy and FileSystemAction::ActionEntry::type = ActionHardMoveRemove.

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

PASSED: Continuous integration, rev:186
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/235/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2680
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2680/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/217
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/217/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/185
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/33

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

review: Approve (continuous-integration)

[Arto Jalkanen (ajalkane)]

1)

39 + delete auxAction;
40 + auxAction = 0;

On line incorrect indentation.

2)

FileSystemAction::Action::~Action()

why not delete auxAction like in reset() ? Looks like it could leak memory.

3)

Not part of the diff, but noticed during review:

void FileSystemAction::processAction()
{
    if (m_curAction)
    {
            delete m_curAction;
            m_curAction = 0;
    }
    if (!m_curAction && m_queuedActions.count())

if (!m_curAction) is unnecessary since it can never happen as it's been deleted just above.

4)

446 + m_errorTitle = QObject::tr("Could remove the directory/file ") +
447 + targetInfo.absoluteFilePath();

Should be "Could not remove ..."

5)

500 + Action *myAction = 0;
501 + myAction = createAction(actionType);

For clarity, replace with:

Action *myAction = createAction(actionType);

6)

Weird function name:
542 +QString FileSystemAction::targetFom

This probably is meant to be targetFrom?

review: Needs Fixing

[lp:~carlos-mazieri/ubuntu-filemanager-app/trash-operations-2]

187. By Carlos Jose Mazieri on 2014-05-24

renamed FileSystemAction::targetFom() para FileSystemAction::targetFrom()
fixed memory leak in FileSystemAction::addEntry()
fixed memory leak in FileSystemAction::~FileSystemAction()
fixed memory leak in LocationsFactory::~LocationsFactory()

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

PASSED: Continuous integration, rev:187
http://91.189.93.70:8080/job/ubuntu-filemanager-app-ci/245/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2841
        deb: http://91.189.93.70:8080/job/generic-mediumtests-trusty/2841/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-utopic/379
        deb: http://91.189.93.70:8080/job/generic-mediumtests-utopic/379/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-trusty-amd64-ci/195
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-filemanager-app-utopic-amd64-ci/43

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

review: Approve (continuous-integration)

[Carlos Jose Mazieri (carlos-mazieri)]

revision 187 solves all requirements.

The auxAction commented in item 2) does not need be deleted in FileSystemAction::Action::~Action(), when it is created is stored in the array as other Actions, the auxAction variable is kept only because two Actions need this relationship.

[Arto Jalkanen (ajalkane)]

Thanks for the fixes and the explanation.

review: Approve

=== modified file 'src/plugin/folderlistmodel/filesystemaction.cpp'
--- src/plugin/folderlistmodel/filesystemaction.cpp	2014-02-05 15:31:44 +0000
+++ src/plugin/folderlistmodel/filesystemaction.cpp	2014-05-24 01:40:38 +0000
@@ -70,7 +70,97 @@
 #define   COMMON_SIZE_ITEM       120
 
 
-
+//===============================================================================================
+FileSystemAction::CopyFile::CopyFile():
+                    bytesWritten(0),
+                    source(0),
+                    target(0),
+                    isEntryItem(false) ,
+                    amountSavedToRefresh(AMOUNT_COPIED_TO_REFRESH_ITEM_INFO)
+{
+
+}
+
+
+FileSystemAction::CopyFile::~CopyFile()
+{
+    clear();
+}
+
+
+
+//===============================================================================================
+FileSystemAction::Action::Action()
+   : auxAction(0), isAux(false)
+{
+    reset();
+}
+
+FileSystemAction::Action::~Action()
+{
+   ::qDeleteAll(entries);
+   entries.clear();
+   copyFile.clear();  
+   //it is not necessary to delete auxAction, because it should be
+   //inside FileSystemAction::m_queuedActions
+}
+
+/*!
+ * \brief FileSystemAction::Action::reset() Used for Undo operations
+ */
+void FileSystemAction::Action::reset()
+{
+    totalItems     = 0;
+    currItem       = 0;
+    currEntryIndex = 0;
+    totalBytes     = 0;
+    bytesWritten   = 0;
+    done           = false;
+    isAux          = false;
+    currEntry      = 0;
+    steps          = 1;    
+    //auxAction should be in FileSystemAction::m_queuedActions
+    //it is not necessary to delete
+    auxAction      = 0;
+    copyFile.clear();
+
+}
+
+
+
+//===============================================================================================
+FileSystemAction::ActionEntry::ActionEntry(): newName(0)
+{
+    init();
+}
+
+FileSystemAction::ActionEntry::~ActionEntry()
+{
+    reversedOrder.clear();
+    if (newName) { delete newName; }
+}
+
+void FileSystemAction::ActionEntry::init()
+{
+    currItem      = 0 ;
+    currStep      = 0;
+    added         = false;
+    alreadyExists = false;
+    if (newName)
+    {
+        delete newName;
+        newName = 0;
+    }
+}
+
+/*!
+ * \brief FileSystemAction::Action::reset() Used for Undo operations
+ */
+void FileSystemAction::ActionEntry::reset()
+{
+    init();
+    reversedOrder.clear();   
+}
 
 void FileSystemAction::CopyFile::clear()
 {
@@ -94,6 +184,9 @@
   , m_cancelCurrentAction(false)
   , m_busy(false)  
   , m_clipboardChanged(false)
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL) //used in Unit/Regression tests
+  , m_forceUsingOtherFS(false)
+#endif
 {
 
 }
@@ -104,7 +197,12 @@
  */
 FileSystemAction::~FileSystemAction()
 {   
-
+    if (m_curAction)
+    {
+        delete m_curAction;
+    }
+    ::qDeleteAll(m_queuedActions);
+    m_queuedActions.clear();
 }
 
 //===============================================================================================
@@ -124,23 +222,10 @@
  * \param origBase
  * \return
  */
-FileSystemAction::Action* FileSystemAction::createAction(ActionType type, int  origBase)
+FileSystemAction::Action* FileSystemAction::createAction(ActionType type)
 {
     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;
-
+    action->type  = type;
     return action;
 }
 
@@ -150,36 +235,54 @@
  * \param action
  * \param pathname
  */
-void  FileSystemAction::addEntry(Action* action, const QString& pathname)
+void  FileSystemAction::addEntry(Action* action, const ActionPaths& pairPaths)
 {
 #if DEBUG_MESSAGES
-        qDebug() << Q_FUNC_INFO << pathname;
+        qDebug() << Q_FUNC_INFO << pairPaths.source();
 #endif
-    DirItemInfo info(pathname);
-    if (!info.isAbsolute())
-    {
-        info.setFile(action->targetPath, pathname);
-    }
+
+    ActionEntry * entry = new ActionEntry();
+    entry->itemPaths    = pairPaths;       
+    if (populateEntry(action, entry))
+    {
+        //now put the Entry in the Action
+        action->entries.append(entry);
+    }
+    else
+    {
+        delete entry;
+    }
+}
+
+bool FileSystemAction::populateEntry(Action* action, ActionEntry* entry)
+{
+    DirItemInfo info(entry->itemPaths.source());
     if (!info.exists())
     {
         emit error(QObject::tr("File or Directory does not exist"),
-                   pathname + QObject::tr(" does not exist")
-                  );       
-        return;
+                   info.absoluteFilePath() + QObject::tr(" does not exist")
+                  );
+        return false;
     }
-    ActionEntry * entry = new ActionEntry();
+    //action->type is top level for all items, entry->type drives item behaviour  
+    entry->type = action->type; //normal behaviour
     //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)
+    // verify if the destination item already exists and it the destination path is in other file system
+    if (entry->type == ActionCopy ||
+        entry->type == ActionMove
+       )
     {
-        DirItemInfo destination(targetFom(info.absoluteFilePath(), action));
+        DirItemInfo destination(entry->itemPaths.target());
         entry->alreadyExists = destination.exists();
+        //check if it is possible to move items
+        if (entry->type == ActionMove && !moveUsingSameFileSystem(entry->itemPaths) )
+        {
+            entry->type = ActionHardMoveCopy; // first step
+        }
     }
     //ActionMove will perform a rename, so no Directory expanding is necessary
-    if (action->type != ActionMove && info.isDir() && !info.isSymLink())
+    if (entry->type != ActionMove && info.isDir() && !info.isSymLink())
     {
         QDirIterator it(info.absoluteFilePath(),
                         QDir::AllEntries | QDir::System |
@@ -196,23 +299,23 @@
     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 (entry->type == ActionCopy || entry->type == ActionHardMoveCopy)
         {
             if ( (sizeSteps = size / bufferSize) )
             {
                 if ( !(size % bufferSize) )
                 {
                     --sizeSteps;
+                }
             }
-                action->steps      += 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++;
@@ -222,8 +325,8 @@
     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);
+
+    return true;
 }
 
 //===============================================================================================
@@ -233,16 +336,11 @@
 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())
+    if (m_queuedActions.count())
     {
         m_curAction = m_queuedActions.at(0);
         m_curAction->currEntry = static_cast<ActionEntry*>
@@ -277,12 +375,12 @@
  */
 void FileSystemAction::processActionEntry()
 {
-#if DEBUG_MESSAGES
-        qDebug() << Q_FUNC_INFO;
-#endif
-
     ActionEntry * curEntry = m_curAction->currEntry;
 
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << "entry:" << curEntry << "type:" << curEntry->type;
+#endif
+
 #if defined(SIMULATE_LONG_ACTION)
     {
         unsigned int delay = SIMULATE_LONG_ACTION;
@@ -295,7 +393,7 @@
 #endif
     if (!m_cancelCurrentAction)
     {
-        switch(m_curAction->type)
+        switch(curEntry->type)
         {
            case ActionRemove:
            case ActionHardMoveRemove:
@@ -310,6 +408,8 @@
                 moveEntry(curEntry);
                 endActionEntry();
                 break;
+          default:
+                break;
         }
     }
 }
@@ -320,11 +420,12 @@
  */
 void FileSystemAction::endActionEntry()
 {
-#if DEBUG_MESSAGES
-        qDebug() << Q_FUNC_INFO;
-#endif
      ActionEntry * curEntry = m_curAction->currEntry;
 
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << "entry:" << curEntry << "type:" << curEntry->type;
+#endif
+
     // first of all check for any error or a cancel issued by the user
     if (m_cancelCurrentAction)
     {
@@ -336,60 +437,54 @@
         scheduleSlot(SLOT(processAction()));
         return;
     }
+
+    int percent = notifyProgress();
+
     // 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:           
+
+           switch(curEntry->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
-
+            case ActionHardMoveRemove: // nothing to do
+                break;
+            case ActionHardMoveCopy:
+            case ActionCopy: // ActionHardMoveCopy is  lso checked here
+            case ActionMove:
+                if (!curEntry->added && !curEntry->alreadyExists)
+                {
+                    emit added(curEntry->itemPaths.target());
+                    curEntry->added = true;
+                }
+                else
+                {
+                    emit changed(DirItemInfo(curEntry->itemPaths.target()));
+                }
+                if (curEntry->type == ActionHardMoveCopy)
+                {
+                    //process same Entry again,
+                    m_curAction->currEntryIndex--;
+                    curEntry->type = ActionHardMoveRemove;
+                    m_curAction->currItem -= curEntry->reversedOrder.count();
+                    curEntry->init();
+                }
+                break;
+             default:
+                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())
@@ -485,14 +580,14 @@
     //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)
+        //making backup only if the targetpath == origPath, otherwise the item is overwritten        
+        if (entry->itemPaths.areEquals())
         {
             //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) )
+            if (!makeBackupNameForCurrentItem(entry) )
             {
                 m_cancelCurrentAction = true;
                 m_errorTitle = QObject::tr("Could not find a suitable name to backup");
@@ -520,7 +615,7 @@
     {
         const DirItemInfo &fi = entry->reversedOrder.at(entry->currItem);
         QString orig    = fi.absoluteFilePath();
-        QString target = targetFom(orig, m_curAction);
+        QString target = targetFrom(orig, entry);
         QString path(target);
         // do this here to allow progress send right item number, copySingleFile will emit progress()
         m_curAction->currItem++;
@@ -537,7 +632,7 @@
             && !entry->reversedOrder.last().isSymLink()
            )
         {
-            QString entryDir = targetFom(entry->reversedOrder.last().absoluteFilePath(), m_curAction);
+            QString entryDir = targetFrom(entry->reversedOrder.last().absoluteFilePath(), entry);
             QDir entryDirObj(entryDir);
             if (!entryDirObj.exists() && entryDirObj.mkpath(entryDir))
             {
@@ -600,7 +695,7 @@
                     m_curAction->copyFile.target->close();
                 }
                 //check if there is disk space to copy source to target
-                if (needsSize > 0 && !isThereDiskSpace( needsSize ))
+                if (needsSize > 0 && !isThereDiskSpace(entry, needsSize ))
                 {
                     m_cancelCurrentAction = true;
                     m_errorTitle = QObject::tr("There is no space on disk to copy");
@@ -666,8 +761,7 @@
     {
         const DirItemInfo &fi = entry->reversedOrder.at(entry->currItem);
         file.setFileName(fi.absoluteFilePath());
-        QString target(targetFom(fi.absoluteFilePath(), m_curAction));
-        DirItemInfo targetInfo(target);
+        DirItemInfo targetInfo(entry->itemPaths.target());
         //rename will fail
         if (targetInfo.exists())
         {
@@ -675,10 +769,11 @@
             entry->added = true;
             if (targetInfo.isFile() || targetInfo.isSymLink())
             {
-                if (!QFile::remove(target))
+                if (!QFile::remove(targetInfo.absoluteFilePath()))
                 {
                     m_cancelCurrentAction = true;
-                    m_errorTitle = QObject::tr("Could remove the directory/file ") + target;
+                    m_errorTitle = QObject::tr("Could not remove the directory/file ") +
+                                      targetInfo.absoluteFilePath();
                     m_errorMsg   = ::strerror(errno);
                 }
             }
@@ -687,13 +782,14 @@
             {
                //move target to /tmp and remove it later by creating an Remove action
                //this will emit removed()
-               moveDirToTempAndRemoveItLater(target);
+               moveDirToTempAndRemoveItLater(targetInfo.absoluteFilePath());
             }
         }
-        if (!m_cancelCurrentAction && !file.rename(target))
+        if (!m_cancelCurrentAction && !file.rename(entry->itemPaths.target()))
         {
             m_cancelCurrentAction = true;
-            m_errorTitle = QObject::tr("Could not move the directory/file ") + target;
+            m_errorTitle = QObject::tr("Could not move the directory/file ") +
+                                     targetInfo.absoluteFilePath();
             m_errorMsg   = ::strerror(errno);
         }
     }//for
@@ -759,12 +855,7 @@
         {
             emit error(titleError, noWriteError + origin.absoluteFilePath());
             return;
-        }
-        //check if it is possible to move items
-        if ( !moveUsingSameFileSystem(items.at(0)) )
-        {
-            actionType = ActionHardMoveCopy; // first step
-        }
+        }        
         if (!destination.isWritable())
         {
             emit error(titleError, noWriteError + destination.absoluteFilePath());
@@ -780,28 +871,33 @@
  * \brief FileSystemAction::createAndProcessAction
  * \param actionType
  * \param paths
- * \param operation
+ *
  */
 void  FileSystemAction::createAndProcessAction(ActionType actionType, const QStringList& paths)
 {
 #if DEBUG_MESSAGES
         qDebug() << Q_FUNC_INFO << paths;
 #endif
-    Action       *myAction       = 0;
-    int           origPathLen    = 0;
-    myAction                     = createAction(actionType, origPathLen);
-    myAction->origPath           = DirItemInfo(paths.at(0)).absolutePath();
-    myAction->baseOrigSize       = myAction->origPath.length();
+    Action       *myAction       = createAction(actionType);
     for (int counter=0; counter < paths.count(); counter++)
     {
-        addEntry(myAction, paths.at(counter));
+        DirItemInfo info(paths.at(counter));
+        if (!info.isAbsolute())
+        {
+            info.setFile(m_path, paths.at(counter));
+        }
+        ActionPaths pairPaths(info.absoluteFilePath());
+        pairPaths.setTargetPathOnly(m_path);
+        addEntry(myAction, pairPaths);
     }
+    queueAction(myAction);
+}
+
+
+void  FileSystemAction::queueAction(Action *myAction)
+{
     if (myAction->totalItems > 0)
-    {
-        if (actionType == ActionHardMoveCopy)
-        {
-            myAction->totalItems *= 2; //duplicate this
-        }
+    {       
         /*
         if (actionType == ActionHardMoveCopy || actionType == ActionCopy)
         {
@@ -830,21 +926,24 @@
 //===============================================================================================
 /*!
  * \brief FileSystemAction::targetFom() makes a destination full pathname from \a origItem
- * \param origItem full pathname from a item intended to be copied or moved into current path
+ * \param origItem full pathname from a item intended to be copied or moved under entry->itemPaths.target
+ * \param entry which the item belongs to (item may be a sub item if the entry is a Directory)
  * \return full pathname of target
+ *
+ * \sa makeBackupNameForCurrentItem()
  */
-QString FileSystemAction::targetFom(const QString& origItem, const Action* const action)
+QString FileSystemAction::targetFrom(const QString& origItem, ActionEntry *entry)
 {
-    QString destinationUnderTarget(origItem.mid(action->baseOrigSize));
-    if (action->currEntry  && action->currEntry->newName)
+    QString destinationUnderTarget(origItem.mid(entry->itemPaths.baseOrigSize()));
+    if (entry->newName)
     {
         int len = destinationUnderTarget.indexOf(QDir::separator(), 1);
         if (len == -1) {
             len = destinationUnderTarget.size();
         }
-        destinationUnderTarget.replace(1, len -1, *action->currEntry->newName);
+        destinationUnderTarget.replace(1, len -1, *entry->newName);
     }
-    QString target(action->targetPath + destinationUnderTarget);
+    QString target(entry->itemPaths.targetPath() + destinationUnderTarget);
 
 #if DEBUG_MESSAGES
      qDebug() << Q_FUNC_INFO << "orig" << origItem
@@ -856,31 +955,39 @@
 
 //===============================================================================================
 /*!
- * \brief FileSystemAction::moveUsingSameFileSystem() Checks if the item being moved to
- *   current m_path belongs to the same File System
+ * \brief FileSystemAction::moveUsingSameFileSystem() Checks if the item being moved to another path
+ *   belongs to the same File System as the target path
  *
  *  It is used to set ActionHardMoveCopy or ActionMove for cut operations.
  *
- * \param itemToMovePathname  first item being moved from a paste operation
+ * \param paths
  *
- * \return true if the item being moved to the current m_path belongs to the same file system as m_path
+ * \return true if the operation is going to performed in the same file system
  */
-bool FileSystemAction::moveUsingSameFileSystem(const QString& itemToMovePathname)
+bool FileSystemAction::moveUsingSameFileSystem(const ActionPaths& movedItem)
 {
     unsigned long targetFsId = 0xffff;
     unsigned long originFsId = 0xfffe;
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    if (m_forceUsingOtherFS)
+    {
+      return false;
+    }
+#endif
+
 #if defined(Q_OS_UNIX)
     struct statvfs  vfs;
-    if ( ::statvfs( QFile::encodeName(m_path).constData(), &vfs) == 0 )
+    if ( ::statvfs( QFile::encodeName(movedItem.source()).constData(), &vfs) == 0 )
     {
         targetFsId = vfs.f_fsid;
     }
-    if ( ::statvfs(QFile::encodeName(itemToMovePathname).constData(), &vfs) == 0)
+    if ( ::statvfs(QFile::encodeName(movedItem.targetPath()).constData(), &vfs) == 0)
     {
         originFsId = vfs.f_fsid;
     }   
 #else
-    Q_UNUSED(itemToMovePathname); 
+    Q_UNUSED(movedItem);
 #endif
     return targetFsId == originFsId;
 }
@@ -899,26 +1006,23 @@
 void FileSystemAction::endCurrentAction()
 {
 
-    if ( !m_clipboardChanged  &&
-          m_curAction->origPath != m_curAction->targetPath &&
-         (m_curAction->type == ActionMove  || m_curAction->type == ActionHardMoveRemove)
-       )
-    {
-         QStringList items;
-         const ActionEntry *entry;
-         int   last;
-         for(int e = 0; e < m_curAction->entries.count(); e++)
-         {
-             entry   = m_curAction->entries.at(e);
-             last    = entry->reversedOrder.count() -1;
-             QString item(targetFom(entry->reversedOrder.at(last).absoluteFilePath(), m_curAction));
-             items.append(item);
-         }
-         if (items.count())
-         {
-             QString targetPath = m_curAction->targetPath;
-             //it is not necessary to handle own clipboard here
-             emit recopy(items, targetPath);
+    if ( !m_clipboardChanged  && m_curAction->type == ActionMove )
+    {        
+         const ActionEntry *entry = m_curAction->entries.at(0);
+         if (!entry->itemPaths.arePathsEquals())
+         {
+             QString destinationPath = entry->itemPaths.targetPath();
+             QStringList items;
+             for(int e = 0; e < m_curAction->entries.count(); e++)
+             {
+                 entry   = m_curAction->entries.at(e);
+                 items.append(entry->itemPaths.target());
+             }
+             if (items.count())
+             {
+                 //it is not necessary to handle own clipboard here
+                 emit recopy(items, destinationPath);
+             }
          }
     }
 }
@@ -1055,7 +1159,9 @@
 
     //copying empty files will have totalBytes==0
     if ( m_curAction->totalBytes > 0 &&
-         (m_curAction->type == ActionCopy || m_curAction->type == ActionHardMoveCopy)
+         (m_curAction->currEntry->type == ActionCopy ||
+          m_curAction->currEntry->type  == ActionHardMoveCopy
+         )
        )
     {
         percent = (m_curAction->bytesWritten * 100) / m_curAction->totalBytes ;
@@ -1086,17 +1192,12 @@
     {
         percent = 1;
     }
-    if (SHOULD_EMIT_PROGRESS_SIGNAL(m_curAction) && !m_curAction->done)
-    {
-        if (m_curAction->type == ActionHardMoveCopy ||
-            m_curAction->type ==ActionHardMoveRemove)
-        {
-            emit progress(m_curAction->currItem/2,  m_curAction->totalItems/2, percent);
-        }
-        else
-        {
-            emit progress(m_curAction->currItem,  m_curAction->totalItems, percent);
-        }
+    if ( SHOULD_EMIT_PROGRESS_SIGNAL(m_curAction) &&
+        !m_curAction->done &&
+         m_curAction->currEntry->type != ActionHardMoveRemove
+       )
+    {       
+        emit progress(m_curAction->currItem,  m_curAction->totalItems, percent);
         if (percent == 100 && m_curAction->currItem == m_curAction->totalItems)
         {
             m_curAction->done = true;
@@ -1171,13 +1272,14 @@
 #endif
     if (QFile::rename(dir, tempDir))
     {
-        if (!m_curAction->auxAction)
+        if (m_curAction->auxAction == 0)
         {   // this new action as Remove will remove all dirs
             m_curAction->auxAction            = createAction(ActionRemove);
             m_curAction->auxAction->isAux     = true;
             m_queuedActions.append(m_curAction->auxAction);
         }
-        addEntry(m_curAction->auxAction, tempDir);
+        ActionPaths pathToRemove(tempDir);
+        addEntry(m_curAction->auxAction, pathToRemove);
     }
 }
 
@@ -1199,13 +1301,13 @@
  * The newName field from current entry will be set to a suitable name
  * \param action
  */
-bool FileSystemAction::makeBackupNameForCurrentItem(Action *action)
+bool FileSystemAction::makeBackupNameForCurrentItem(ActionEntry *entry)
 {
     bool ret = false;
-    if (action->currEntry->alreadyExists)
+    if (entry->alreadyExists)
     {
         const DirItemInfo& fi =
-              action->currEntry->reversedOrder.at(action->currEntry->reversedOrder.count() -1);
+              entry->reversedOrder.at(entry->reversedOrder.count() -1);
         DirItemInfo backuped;
         int counter=0;
         QString name;
@@ -1233,7 +1335,8 @@
         } while (backuped.exists() && counter < 100);
         if (counter < 100)
         {
-            action->currEntry->newName = new QString(backuped.fileName());
+            entry->newName = new QString(backuped.fileName());
+            entry->itemPaths.setTargetFullName( backuped.absoluteFilePath() );
             ret = true;
         }
     }
@@ -1275,12 +1378,12 @@
 }
 
 //==================================================================
-bool FileSystemAction::isThereDiskSpace(qint64 requiredSize)
+bool FileSystemAction::isThereDiskSpace(const ActionEntry *entry, qint64 requiredSize)
 {
     bool ret = true;
 #if defined(Q_OS_UNIX)
     struct statvfs  vfs;
-    if ( ::statvfs( QFile::encodeName(m_path).constData(), &vfs) == 0 )
+    if ( ::statvfs( QFile::encodeName(entry->itemPaths.targetPath()).constData(), &vfs) == 0 )
     {
         qint64 free =  vfs.f_bsize * vfs.f_bfree;
         ret = free > requiredSize;

=== modified file 'src/plugin/folderlistmodel/filesystemaction.h'
--- src/plugin/folderlistmodel/filesystemaction.h	2014-02-05 15:31:44 +0000
+++ src/plugin/folderlistmodel/filesystemaction.h	2014-05-24 01:40:38 +0000
@@ -142,12 +142,9 @@
    struct CopyFile
    {
      public:
-       CopyFile() : bytesWritten(0), source(0), target(0),
-                    isEntryItem(false) , amountSavedToRefresh(AMOUNT_COPIED_TO_REFRESH_ITEM_INFO)
-       {}
-       ~CopyFile() { clear(); }
+       CopyFile();
+       ~CopyFile();
        void clear();
-
        qint64            bytesWritten;           // set 0 when reach  bytesToNotify, notify progress
        QFile          *  source;
        QFile          *  target;
@@ -164,42 +161,40 @@
    struct ActionEntry
    {
      public:
-       ActionEntry(): currStep(0),currItem(0),alreadyExists(false), newName(0), added(false) {}
-       ~ActionEntry()
-       {
-           reversedOrder.clear();
-           if (newName) { delete newName; }
-       }
-       QList<DirItemInfo>   reversedOrder;   //!< last item must be the item from the list
+       ActionEntry();
+       ~ActionEntry();
+       void init();
+       void reset();
+       ActionPaths        itemPaths;            //!< identifies the item being handled source and destination
+       ActionType         type;
+       QList<DirItemInfo> reversedOrder;   //!< last item must be the item from the list
        int                currStep;
-       int                currItem;
-       bool               alreadyExists;
+       int                currItem;      
        QString *          newName; //TODO:  allow to rename an existent file when it already exists.
                                    //       So far it is possible to backup items when copy/paste in the
                                    //       same place, in this case it is renamed to "<name> Copy (%d).termination"
-
-       bool               added;   //!< signal added() already emitted for the current ActionEntry
+       bool               added :1;   //!< signal added() already emitted for the current ActionEntry
+       bool               alreadyExists :1;
    };
 
    struct Action
    {
     public:
-       ~Action()           {qDeleteAll(entries); entries.clear(); copyFile.clear();}
+       Action();
+       ~Action();
+       void                reset();
        ActionType          type;
        QList<ActionEntry*> entries;
        int                 totalItems;
-       int                 currItem;
-       int                 baseOrigSize;
-       QString             origPath;
-       QString             targetPath;
+       int                 currItem;              
        quint64             totalBytes;
        quint64             bytesWritten;
        int                 currEntryIndex;
        ActionEntry  *      currEntry;     
-       CopyFile            copyFile;
-       bool                done;
+       CopyFile            copyFile;       
        Action *            auxAction;
-       bool                isAux;
+       bool                isAux   :1;
+       bool                done    :1; 
        int                 steps;
    };
 
@@ -215,12 +210,13 @@
 
 
 private:  
-   Action * createAction(ActionType, int origBase = 0);
-   void     addEntry(Action* action, const QString &pathname);
+   Action * createAction(ActionType);
+   void     addEntry(Action* action, const ActionPaths& pairPaths);
+   bool     populateEntry(Action* action, ActionEntry* entry);
    void     removeEntry(ActionEntry *);   
    void     moveEntry(ActionEntry *entry);
-   bool     moveUsingSameFileSystem(const QString& itemToMovePathname);
-   QString  targetFom(const QString& origItem, const Action * const action);
+   bool     moveUsingSameFileSystem(const ActionPaths &movedItem);
+   QString  targetFrom(const QString& origItem, ActionEntry * entry);
    void     endCurrentAction();
    int      percentWorkDone();
    int      notifyProgress(int forcePercent = 0);
@@ -228,11 +224,13 @@
    bool     copySymLink(const QString& target, const QFileInfo& orig);
    void     scheduleSlot(const char *slot);
    void     moveDirToTempAndRemoveItLater(const QString& dir);
-   bool     makeBackupNameForCurrentItem(Action *action);   
+   bool     makeBackupNameForCurrentItem(ActionEntry *entry);
    bool     endCopySingleFile();
-   bool     isThereDiskSpace(qint64 requiredSize);
+   bool     isThereDiskSpace(const ActionEntry *entry, qint64 requiredSize);
+   void     queueAction(Action *myAction);  
 
 #if defined(REGRESSION_TEST_FOLDERLISTMODEL) //used in Unit/Regression tests
+   bool     m_forceUsingOtherFS;
    friend class TestDirModel;
 #endif
 };

=== modified file 'src/plugin/folderlistmodel/locationsfactory.cpp'
--- src/plugin/folderlistmodel/locationsfactory.cpp	2014-05-17 12:57:46 +0000
+++ src/plugin/folderlistmodel/locationsfactory.cpp	2014-05-24 01:40:38 +0000
@@ -46,6 +46,10 @@
 {
     ::qDeleteAll(m_locations);
     m_locations.clear();
+    if (m_lastValidFileInfo)
+    {
+        delete m_lastValidFileInfo;
+    }
 }
 
 
@@ -173,7 +177,7 @@
 }
 
 
-void LocationsFactory::storeValidFileInfo(const DirItemInfo *item)
+void LocationsFactory::storeValidFileInfo(DirItemInfo *item)
 {
     if (m_lastValidFileInfo)
     {

=== modified file 'src/plugin/folderlistmodel/locationsfactory.h'
--- src/plugin/folderlistmodel/locationsfactory.h	2014-05-14 22:51:47 +0000
+++ src/plugin/folderlistmodel/locationsfactory.h	2014-05-24 01:40:38 +0000
@@ -113,7 +113,7 @@
      */
     const DirItemInfo* lastValidFileInfo() const { return m_lastValidFileInfo; }
 
-    void        storeValidFileInfo(const DirItemInfo *item);
+    void        storeValidFileInfo(DirItemInfo *item);
 
 signals:
     void        locationChanged(const Location *old, const Location *current);
@@ -125,7 +125,7 @@
      Location         *  m_curLoc;
      QList<Location*>    m_locations;
      QString             m_tmpPath;
-     const DirItemInfo * m_lastValidFileInfo;
+     DirItemInfo      * m_lastValidFileInfo;
 
 #if defined(REGRESSION_TEST_FOLDERLISTMODEL)
     friend class TestDirModel;

=== modified file 'src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp'
--- src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp	2014-05-02 12:22:11 +0000
+++ src/plugin/test_folderlistmodel/regression/tst_folderlistmodel.cpp	2014-05-24 01:40:38 +0000
@@ -914,7 +914,8 @@
      QStringList allFiles(m_deepDir_01->firstLevel());
      allFiles.append(tempFiles.createdList());
 
-     m_dirModel_02->m_fsAction->createAndProcessAction(FileSystemAction::ActionHardMoveCopy,
+     m_dirModel_02->m_fsAction->m_forceUsingOtherFS = true;
+     m_dirModel_02->m_fsAction->createAndProcessAction(FileSystemAction::ActionMove,
                                                        allFiles);
 
      QTest::qWait(TIME_TO_PROCESS);