Fix an issue where compare flags may not update properly when doing a "Left to Right...

diff --git a/Src/DirActions.cpp b/Src/DirActions.cpp
index 190c019..24429d5 100644 (file)
--- a/Src/DirActions.cpp
+++ b/Src/DirActions.cpp
@@ -237,7 +237,8 @@ void ConfirmActionList(const CDiffContext& ctxt, const FileActionScript & action
  * @brief Update results for FileActionItem.
  * This functions is called to update DIFFITEM after FileActionItem.
  * @param [in] act Action that was done.
- * @param [in] pos List position for DIFFITEM affected.
+ * @param [in] ctxt Compare context: contains difflist, encoding info etc.
+ * @param [in,out] di Item to update the results.
  */
 UPDATEITEM_TYPE UpdateDiffAfterOperation(const FileActionItem & act, CDiffContext& ctxt, DIFFITEM &di)
 {
@@ -257,7 +258,7 @@ UPDATEITEM_TYPE UpdateDiffAfterOperation(const FileActionItem & act, CDiffContex
                if (ctxt.GetCompareDirs() > 2)
                        SetDiffCompare(di, DIFFCODE::NOCMP);
                else
-                       SetDiffCompare(di, DIFFCODE::SAME);
+                       UpdateCompareFlagsAfterSync(di, ctxt.m_bRecursive);
                SetDiffCounts(di, 0, 0);
                break;
 
@@ -1101,6 +1102,59 @@ void UpdateStatusFromDisk(CDiffContext& ctxt, DIFFITEM& di, int index)
 }
 
 /**
+ * @brief Update compare flags recursively after sync.
+ * @param [in,out] di Item to update the compare flag.
+ * @param [in] bRecursive `true` if tree mode is on
+ * @return number of diff items
+ */
+int UpdateCompareFlagsAfterSync(DIFFITEM& di, bool bRecursive)
+{
+       // Do not update compare flags for filtered items.
+       if (di.diffcode.isResultFiltered())
+               return 0;
+
+       int res = 0;
+       if (di.HasChildren())
+       {
+               for (DIFFITEM* pdic = di.GetFirstChild(); pdic; pdic = pdic->GetFwdSiblingLink())
+               {
+                       int ndiff = UpdateCompareFlagsAfterSync(*pdic, bRecursive);
+                       if (ndiff > 0)
+                       {
+                               res += ndiff;
+                       }
+               }
+
+               // Update compare flags for items that exist on both sides.
+               // (Do not update compare flags for items that exist on only one side.)
+               if (di.diffcode.existAll())
+               {
+                       di.diffcode.diffcode &= (~DIFFCODE::COMPAREFLAGS);
+                       unsigned flag = (res > 0) ? DIFFCODE::DIFF : DIFFCODE::SAME;
+                       di.diffcode.diffcode |= flag;
+               }
+       }
+       else {
+               // Update compare flags for files and directories in tree mode.
+               // (Do not update directory compare flags when not in tree mode.)
+               if (!di.diffcode.isDirectory() || bRecursive)
+               {
+                       if (di.diffcode.existAll())
+                       {
+                               di.diffcode.diffcode &= (~DIFFCODE::COMPAREFLAGS);
+                               di.diffcode.diffcode |= DIFFCODE::SAME;
+                       }
+                       else
+                       {
+                               res++;
+                       }
+               }
+       }
+
+       return res;
+}
+
+/**
  * @brief Update the paths of the diff items recursively.
  * @param[in] nDirs Number of directories to compare.
  * @param[in,out] di\81@Item to update the path.

diff --git a/Src/DirActions.h b/Src/DirActions.h
index 913596e..5da09f7 100644 (file)
--- a/Src/DirActions.h
+++ b/Src/DirActions.h
@@ -168,6 +168,7 @@ void SetDiffCompare(DIFFITEM& di, unsigned diffcode);
 void CopyDiffSideAndProperties(DIFFITEM& di, int src, int dst);
 void UnsetDiffSide(DIFFITEM& di, int index);
 void UpdateStatusFromDisk(CDiffContext& ctxt, DIFFITEM& di, int index);
+int UpdateCompareFlagsAfterSync(DIFFITEM& di, bool bRecursive);
 void UpdatePaths(int nDirs, DIFFITEM& di);
 void SetDiffCounts(DIFFITEM& di, unsigned diffs, unsigned ignored);
 void SetItemViewFlag(DIFFITEM& di, unsigned flag, unsigned mask);