4.3

1 files changed, 212 insertions, 15 deletions

diff --git a/file_hierarchy.cpp b/file_hierarchy.cpp
index cfe1b6a0..39b789fd 100644
--- a/file_hierarchy.cpp
+++ b/file_hierarchy.cpp
@@ -5,6 +5,8 @@
 // **************************************************************************
 
 #include "file_hierarchy.h"
+#include <zen/i18n.h>
+#include <zen/utf8.h>
 
 using namespace zen;
 
@@ -31,12 +33,12 @@ void HierarchyObject::removeEmptyRec()
     std::for_each(refSubDirs().begin(), refSubDirs().end(), std::mem_fun_ref(&HierarchyObject::removeEmptyRec));
 }
 
-
-SyncOperation FileSystemObject::getSyncOperation(
-    CompareFilesResult cmpResult,
-    bool selectedForSynchronization,
-    SyncDirection syncDir,
-    const std::wstring& syncDirConflict)
+namespace
+{
+SyncOperation proposedSyncOperation(CompareFilesResult cmpResult,
+                                    bool selectedForSynchronization,
+                                    SyncDirection syncDir,
+                                    const std::wstring& syncDirConflict)
 {
     if (!selectedForSynchronization)
         return cmpResult == FILE_EQUAL ?
@@ -105,8 +107,6 @@ SyncOperation FileSystemObject::getSyncOperation(
 }
 
 
-namespace
-{
 template <class Predicate> inline
 bool hasDirectChild(const HierarchyObject& hierObj, Predicate p)
 {
@@ -117,6 +117,22 @@ bool hasDirectChild(const HierarchyObject& hierObj, Predicate p)
 }
 
 
+SyncOperation FileSystemObject::testSyncOperation(SyncDirection testSyncDir) const
+{
+    return proposedSyncOperation(getCategory(), selectedForSynchronization, testSyncDir, syncDirConflict);
+}
+
+
+SyncOperation FileSystemObject::getSyncOperation() const
+{
+    return FileSystemObject::testSyncOperation(syncDir);
+    //no *not* make a virtual call to testSyncOperation()! See FileMapping::testSyncOperation()!
+}
+
+
+//SyncOperation DirMapping::testSyncOperation() const -> not required: we do NOT want to consider child elements when testing!
+
+
 SyncOperation DirMapping::getSyncOperation() const
 {
     if (!syncOpUpToDate)
@@ -124,7 +140,7 @@ SyncOperation DirMapping::getSyncOperation() const
         syncOpUpToDate = true;
         //redetermine...
 
-        //suggested operation for directory only
+        //suggested operation *not* considering child elements
         syncOpBuffered = FileSystemObject::getSyncOperation();
 
         //action for child elements may occassionally have to overwrite parent task:
@@ -132,6 +148,10 @@ SyncOperation DirMapping::getSyncOperation() const
         {
             case SO_OVERWRITE_LEFT:
             case SO_OVERWRITE_RIGHT:
+            case SO_MOVE_LEFT_SOURCE:
+            case SO_MOVE_LEFT_TARGET:
+            case SO_MOVE_RIGHT_SOURCE:
+            case SO_MOVE_RIGHT_TARGET:
                 assert(false);
             case SO_CREATE_NEW_LEFT:
             case SO_CREATE_NEW_RIGHT:
@@ -149,19 +169,32 @@ SyncOperation DirMapping::getSyncOperation() const
                     //1. if at least one child-element is to be created, make sure parent folder is created also
                     //note: this automatically fulfills "create parent folders even if excluded";
                     //see http://sourceforge.net/tracker/index.php?func=detail&aid=2628943&group_id=234430&atid=1093080
-                    if (hasDirectChild(*this, [](const FileSystemObject& fsObj) { return fsObj.getSyncOperation() == SO_CREATE_NEW_LEFT; }))
-                    syncOpBuffered = SO_CREATE_NEW_LEFT;
+                    if (hasDirectChild(*this,
+                                       [](const FileSystemObject& fsObj) -> bool { const SyncOperation op = fsObj.getSyncOperation(); return  op == SO_CREATE_NEW_LEFT || op == SO_MOVE_LEFT_TARGET; }))
+                        syncOpBuffered = SO_CREATE_NEW_LEFT;
                     //2. cancel parent deletion if only a single child is not also scheduled for deletion
                     else if (syncOpBuffered == SO_DELETE_RIGHT &&
-                    hasDirectChild(*this, [](const FileSystemObject& fsObj) { return fsObj.getSyncOperation() != SO_DELETE_RIGHT; }))
+                             hasDirectChild(*this,
+                                            [](const FileSystemObject& fsObj) -> bool
+                {
+                    if (fsObj.isEmpty()) return false; //fsObj may already be empty because it once contained a "move source"
+                        const SyncOperation op = fsObj.getSyncOperation(); return op != SO_DELETE_RIGHT && op != SO_MOVE_RIGHT_SOURCE;
+                    }))
                     syncOpBuffered = SO_DO_NOTHING;
                 }
                 else if (isEmpty<RIGHT_SIDE>())
                 {
-                    if (hasDirectChild(*this, [](const FileSystemObject& fsObj) { return fsObj.getSyncOperation() == SO_CREATE_NEW_RIGHT; }))
-                    syncOpBuffered = SO_CREATE_NEW_RIGHT;
+                    if (hasDirectChild(*this,
+                                       [](const FileSystemObject& fsObj) -> bool  { const SyncOperation op = fsObj.getSyncOperation();  return  op == SO_CREATE_NEW_RIGHT || op == SO_MOVE_RIGHT_TARGET;  }))
+                        syncOpBuffered = SO_CREATE_NEW_RIGHT;
                     else if (syncOpBuffered == SO_DELETE_LEFT &&
-                    hasDirectChild(*this, [](const FileSystemObject& fsObj) { return fsObj.getSyncOperation() != SO_DELETE_LEFT; }))
+                             hasDirectChild(*this,
+                                            [](const FileSystemObject& fsObj) -> bool
+                {
+                    if (fsObj.isEmpty()) return false;
+                        const SyncOperation op = fsObj.getSyncOperation();
+                        return op != SO_DELETE_LEFT && op != SO_MOVE_LEFT_SOURCE;
+                    }))
                     syncOpBuffered = SO_DO_NOTHING;
                 }
             }
@@ -170,3 +203,167 @@ SyncOperation DirMapping::getSyncOperation() const
     }
     return syncOpBuffered;
 }
+
+
+SyncOperation FileMapping::testSyncOperation(SyncDirection testSyncDir) const
+{
+    SyncOperation op = FileSystemObject::testSyncOperation(testSyncDir);
+
+    /*
+        check whether we can optimize "create + delete" via "move":
+        note: as long as we consider "create + delete" cases only, detection of renamed files, should be fine even for "binary" comparison variant!
+    */
+    if (const FileMapping* refFile = dynamic_cast<const FileMapping*>(FileSystemObject::retrieve(moveFileRef)))
+    {
+        SyncOperation opRef = refFile->FileSystemObject::getSyncOperation(); //do *not* make a virtual call!
+
+        if (op    == SO_CREATE_NEW_LEFT &&
+            opRef == SO_DELETE_LEFT)
+            op = SO_MOVE_LEFT_TARGET;
+        else if (op    == SO_DELETE_LEFT &&
+                 opRef == SO_CREATE_NEW_LEFT)
+            op = SO_MOVE_LEFT_SOURCE;
+        else if (op    == SO_CREATE_NEW_RIGHT &&
+                 opRef == SO_DELETE_RIGHT)
+            op = SO_MOVE_RIGHT_TARGET;
+        else if (op    == SO_DELETE_RIGHT &&
+                 opRef == SO_CREATE_NEW_RIGHT)
+            op = SO_MOVE_RIGHT_SOURCE;
+    }
+    return op;
+}
+
+
+SyncOperation FileMapping::getSyncOperation() const
+{
+    return FileMapping::testSyncOperation(getSyncDir());
+}
+
+
+std::wstring zen::getCategoryDescription(CompareFilesResult cmpRes)
+{
+    switch (cmpRes)
+    {
+        case FILE_LEFT_SIDE_ONLY:
+            return _("File/folder exists on left side only");
+        case FILE_RIGHT_SIDE_ONLY:
+            return _("File/folder exists on right side only");
+        case FILE_LEFT_NEWER:
+            return _("Left file is newer");
+        case FILE_RIGHT_NEWER:
+            return _("Right file is newer");
+        case FILE_DIFFERENT:
+            return _("Files have different content");
+        case FILE_EQUAL:
+            return _("Both sides are equal");
+        case FILE_DIFFERENT_METADATA:
+            return _("Files/folders differ in attributes only");
+        case FILE_CONFLICT:
+            return _("Conflict/file cannot be categorized");
+    }
+    assert(false);
+    return std::wstring();
+}
+
+
+std::wstring zen::getCategoryDescription(const FileSystemObject& fsObj)
+{
+    const CompareFilesResult cmpRes = fsObj.getCategory();
+    if (cmpRes == FILE_CONFLICT)
+        return fsObj.getCatConflict();
+
+    return getCategoryDescription(cmpRes);
+}
+
+
+std::wstring zen::getSyncOpDescription(SyncOperation op)
+{
+    switch (op)
+    {
+        case SO_CREATE_NEW_LEFT:
+            return _("Copy new file/folder to left");
+        case SO_CREATE_NEW_RIGHT:
+            return _("Copy new file/folder to right");
+        case SO_DELETE_LEFT:
+            return _("Delete left file/folder");
+        case SO_DELETE_RIGHT:
+            return _("Delete right file/folder");
+        case SO_MOVE_LEFT_SOURCE:
+        case SO_MOVE_LEFT_TARGET:
+            return _("Move file on left");
+        case SO_MOVE_RIGHT_SOURCE:
+        case SO_MOVE_RIGHT_TARGET:
+            return _("Move file on right");
+        case SO_OVERWRITE_LEFT:
+            return _("Overwrite left file/folder with right one");
+        case SO_OVERWRITE_RIGHT:
+            return _("Overwrite right file/folder with left one");
+        case SO_DO_NOTHING:
+            return _("Do nothing");
+        case SO_EQUAL:
+            return _("Both sides are equal");
+        case SO_COPY_METADATA_TO_LEFT:
+            return _("Copy file attributes only to left");
+        case SO_COPY_METADATA_TO_RIGHT:
+            return _("Copy file attributes only to right");
+        case SO_UNRESOLVED_CONFLICT: //not used on GUI, but in .csv
+            _("Conflict/file cannot be categorized");
+    }
+    assert(false);
+    return std::wstring();
+}
+
+
+std::wstring zen::getSyncOpDescription(const FileSystemObject& fsObj)
+{
+    const SyncOperation op = fsObj.getSyncOperation();
+    switch (op)
+    {
+        case SO_CREATE_NEW_LEFT:
+        case SO_CREATE_NEW_RIGHT:
+        case SO_DELETE_LEFT:
+        case SO_DELETE_RIGHT:
+        case SO_OVERWRITE_LEFT:
+        case SO_OVERWRITE_RIGHT:
+        case SO_DO_NOTHING:
+        case SO_EQUAL:
+        case SO_COPY_METADATA_TO_LEFT:
+        case SO_COPY_METADATA_TO_RIGHT:
+            return getSyncOpDescription(op); //use generic description
+
+        case SO_MOVE_LEFT_SOURCE:
+        case SO_MOVE_LEFT_TARGET:
+        case SO_MOVE_RIGHT_SOURCE:
+        case SO_MOVE_RIGHT_TARGET:
+            if (const FileMapping* sourceFile = dynamic_cast<const FileMapping*>(&fsObj))
+                if (const FileMapping* targetFile = dynamic_cast<const FileMapping*>(FileSystemObject::retrieve(sourceFile->getMoveRef())))
+                {
+                    const bool onLeft   = op == SO_MOVE_LEFT_SOURCE || op == SO_MOVE_LEFT_TARGET;
+                    const bool isSource = op == SO_MOVE_LEFT_SOURCE || op == SO_MOVE_RIGHT_SOURCE;
+
+                    if (!isSource)
+                        std::swap(sourceFile, targetFile);
+
+                    auto getRelName = [&](const FileSystemObject& fso, bool leftSide) { return leftSide ? fso.getRelativeName<LEFT_SIDE>() : fso.getRelativeName<RIGHT_SIDE>(); };
+
+                    const Zstring relSource = getRelName(*sourceFile,  onLeft);
+                    const Zstring relTarget = getRelName(*targetFile, !onLeft);
+
+                    return getSyncOpDescription(op) + L"\n" +
+                           (EqualFilename()(beforeLast(relSource, FILE_NAME_SEPARATOR), beforeLast(relTarget, FILE_NAME_SEPARATOR)) ? //returns empty string if ch not found
+                            //detected pure "rename"
+                            L"\"" + utf8CvrtTo<std::wstring>(afterLast(relSource, FILE_NAME_SEPARATOR)) + L"\"" + L" ->\n" + //show short name only
+                            L"\"" + utf8CvrtTo<std::wstring>(afterLast(relTarget, FILE_NAME_SEPARATOR)) + L"\"" :
+                            //"move" or "move + rename"
+                            L"\"" + utf8CvrtTo<std::wstring>(relSource) + L"\"" + L" ->\n" +
+                            L"\"" + utf8CvrtTo<std::wstring>(relTarget) + L"\"");
+                    //attention: ::SetWindowText() doesn't handle tab characters correctly in combination with certain file names, so don't use them
+                }
+            break;
+        case SO_UNRESOLVED_CONFLICT:
+            return fsObj.getSyncOpConflict();
+    }
+
+    assert(false);
+    return std::wstring();
+}