Refactoring in anticipation of synchronization not always being local-remote (Issue 2020)

Source commit: 2d05944202efceaff012888c6b0de956314c91b6

source/core/RemoteFiles.cpp

@@ -2866,12 +2866,12 @@ void __fastcall TRemoteProperties::Save(THierarchicalStorage * Storage) const
 TSynchronizeChecklist::TItem::TItem() :
   Action(saNone), IsDirectory(false), ImageIndex(-1), Checked(true), RemoteFile(NULL), FDirectoryHasSize(false)
 {
-  Local.ModificationFmt = mfFull;
-  Local.Modification = 0;
-  Local.Size = 0;
-  Remote.ModificationFmt = mfFull;
-  Remote.Modification = 0;
-  Remote.Size = 0;
+  Info1.ModificationFmt = mfFull;
+  Info1.Modification = 0;
+  Info1.Size = 0;
+  Info2.ModificationFmt = mfFull;
+  Info2.Modification = 0;
+  Info2.Size = 0;
 }
 //---------------------------------------------------------------------------
 TSynchronizeChecklist::TItem::~TItem()
@@ -2881,14 +2881,14 @@ TSynchronizeChecklist::TItem::~TItem()
 //---------------------------------------------------------------------------
 const UnicodeString& TSynchronizeChecklist::TItem::GetFileName() const
 {
-  if (!Remote.FileName.IsEmpty())
+  if (!Info2.FileName.IsEmpty())
   {
-    return Remote.FileName;
+    return Info2.FileName;
   }
   else
   {
-    DebugAssert(!Local.FileName.IsEmpty());
-    return Local.FileName;
+    DebugAssert(!Info1.FileName.IsEmpty());
+    return Info1.FileName;
   }
 }
 //---------------------------------------------------------------------------
@@ -2921,12 +2921,12 @@ __int64 __fastcall TSynchronizeChecklist::TItem::GetBaseSize(TAction AAction) co
     case saUploadNew:
     case saUploadUpdate:
     case saDeleteLocal:
-      return Local.Size;
+      return Info1.Size;
 
     case saDownloadNew:
     case saDownloadUpdate:
     case saDeleteRemote:
-      return Remote.Size;
+      return Info2.Size;
 
     default:
       DebugFail();
@@ -2936,32 +2936,32 @@ __int64 __fastcall TSynchronizeChecklist::TItem::GetBaseSize(TAction AAction) co
 //---------------------------------------------------------------------------
 UnicodeString TSynchronizeChecklist::TItem::GetLocalPath() const
 {
-  return CombinePaths(Local.Directory, Local.FileName);
+  return CombinePaths(Info1.Directory, Info1.FileName);
 }
 //---------------------------------------------------------------------------
 UnicodeString TSynchronizeChecklist::TItem::ForceGetLocalPath() const
 {
-  return CombinePaths(Local.Directory, DefaultStr(Local.FileName, Remote.FileName));
+  return CombinePaths(Info1.Directory, DefaultStr(Info1.FileName, Info2.FileName));
 }
 //---------------------------------------------------------------------------
 UnicodeString TSynchronizeChecklist::TItem::GetRemotePath() const
 {
-  return UnixCombinePaths(Remote.Directory, Remote.FileName);
+  return UnixCombinePaths(Info2.Directory, Info2.FileName);
 }
 //---------------------------------------------------------------------------
 UnicodeString TSynchronizeChecklist::TItem::ForceGetRemotePath() const
 {
-  return UnixCombinePaths(Remote.Directory, GetFileName());
+  return UnixCombinePaths(Info2.Directory, GetFileName());
 }
 //---------------------------------------------------------------------------
 UnicodeString TSynchronizeChecklist::TItem::GetLocalTarget() const
 {
-  return IncludeTrailingBackslash(Local.Directory);
+  return IncludeTrailingBackslash(Info1.Directory);
 }
 //---------------------------------------------------------------------------
 UnicodeString TSynchronizeChecklist::TItem::GetRemoteTarget() const
 {
-  return UnixIncludeTrailingBackslash(Remote.Directory);
+  return UnixIncludeTrailingBackslash(Info2.Directory);
 };
 //---------------------------------------------------------------------------
 TStrings * TSynchronizeChecklist::TItem::GetFileList() const
@@ -3012,14 +3012,14 @@ void TSynchronizeChecklist::Add(TItem * Item)
 int TSynchronizeChecklist::Compare(const TItem * Item1, const TItem * Item2)
 {
   int Result;
-  if (!Item1->Local.Directory.IsEmpty())
+  if (!Item1->Info1.Directory.IsEmpty())
   {
-    Result = AnsiCompareText(Item1->Local.Directory, Item2->Local.Directory);
+    Result = AnsiCompareText(Item1->Info1.Directory, Item2->Info1.Directory);
   }
   else
   {
-    DebugAssert(!Item1->Remote.Directory.IsEmpty());
-    Result = AnsiCompareText(Item1->Remote.Directory, Item2->Remote.Directory);
+    DebugAssert(!Item1->Info2.Directory.IsEmpty());
+    Result = AnsiCompareText(Item1->Info2.Directory, Item2->Info2.Directory);
   }
 
   if (Result == 0)
@@ -3108,11 +3108,11 @@ void __fastcall TSynchronizeChecklist::UpdateDirectorySize(const TItem * Item, _
 
     if (Item->IsRemoteOnly())
     {
-      MutableItem->Remote.Size = Size;
+      MutableItem->Info2.Size = Size;
     }
     else if (Item->IsLocalOnly())
     {
-      MutableItem->Local.Size = Size;
+      MutableItem->Info1.Size = Size;
     }
     else
     {

source/core/RemoteFiles.h

@@ -483,8 +483,8 @@ public:
 
     TAction Action;
     bool IsDirectory;
-    TFileInfo Local;
-    TFileInfo Remote;
+    TFileInfo Info1;
+    TFileInfo Info2;
     int ImageIndex;
     bool Checked;
     TRemoteFile * RemoteFile;

source/core/Script.cpp

@@ -1848,8 +1848,7 @@ void __fastcall TScript::SynchronizeDirectories(TScriptProcParams * Parameters,
 UnicodeString __fastcall TScript::SynchronizeFileRecord(
   const UnicodeString & RootDirectory, const TSynchronizeChecklist::TItem * Item, bool Local)
 {
-  const TSynchronizeChecklist::TItem::TFileInfo & FileInfo =
-    Local ? Item->Local : Item->Remote;
+  const TSynchronizeChecklist::TItem::TFileInfo & FileInfo = Local ? Item->Info1 : Item->Info2;
   UnicodeString Path = UniversalIncludeTrailingBackslash(!Local, FileInfo.Directory) + FileInfo.FileName;
 
   if (SameText(RootDirectory, Path.SubString(1, RootDirectory.Length())))

source/core/SessionInfo.cpp

@@ -355,11 +355,11 @@ public:
 
     if (RecordLocal)
     {
-      SynchronizeChecklistItemFileInfo(Item->GetLocalPath(), Item->IsDirectory, Item->Local);
+      SynchronizeChecklistItemFileInfo(Item->GetLocalPath(), Item->IsDirectory, Item->Info1);
     }
     if (RecordRemote)
     {
-      SynchronizeChecklistItemFileInfo(Item->GetRemotePath(), Item->IsDirectory, Item->Remote);
+      SynchronizeChecklistItemFileInfo(Item->GetRemotePath(), Item->IsDirectory, Item->Info2);
     }
   }
 

source/core/Terminal.cpp

@@ -6000,49 +6000,68 @@ struct TSynchronizeFileData
   bool New;
   bool IsDirectory;
   TSynchronizeChecklist::TItem::TFileInfo Info;
-  TSynchronizeChecklist::TItem::TFileInfo MatchingRemoteFile;
-  TRemoteFile * MatchingRemoteFileFile;
-  int MatchingRemoteFileImageIndex;
+  TSynchronizeChecklist::TItem::TFileInfo MatchingFile2;
+  TRemoteFile * MatchingRemoteFile2;
+  int MatchingRemoteFile2ImageIndex;
   FILETIME LocalLastWriteTime;
 };
 //---------------------------------------------------------------------------
 const int sfFirstLevel = 0x01;
 struct TSynchronizeData
 {
-  UnicodeString LocalDirectory;
-  UnicodeString RemoteDirectory;
+  UnicodeString Directory1;
+  UnicodeString Directory2;
   TTerminal::TSynchronizeMode Mode;
   int Params;
   TSynchronizeDirectory OnSynchronizeDirectory;
   TSynchronizeOptions * Options;
+  TStringList * LeftFileList;
   int Flags;
-  TStringList * LocalFileList;
   const TCopyParamType * CopyParam;
   TSynchronizeChecklist * Checklist;
+
+  void ClearLevelSpecific()
+  {
+    LeftFileList = NULL;
+  }
+
+  TSynchronizeData CloneFor(const UnicodeString & ADirectory1, const UnicodeString & ADirectory2)
+  {
+    TSynchronizeData Result = *this;
+    Result.ClearLevelSpecific();
+    Result.Directory1 = ADirectory1;
+    Result.Directory2 = ADirectory2;
+    Result.Flags = (Result.Flags & ~sfFirstLevel);
+    return Result;
+  }
 };
 //---------------------------------------------------------------------------
-TSynchronizeChecklist * __fastcall TTerminal::SynchronizeCollect(const UnicodeString LocalDirectory,
-  const UnicodeString RemoteDirectory, TSynchronizeMode Mode,
-  const TCopyParamType * CopyParam, int Params,
+TSynchronizeChecklist * TTerminal::SynchronizeCollect(
+  const UnicodeString & Directory1, const UnicodeString & Directory2,
+  TSynchronizeMode Mode, const TCopyParamType * CopyParam, int Params,
   TSynchronizeDirectory OnSynchronizeDirectory,
   TSynchronizeOptions * Options)
 {
   TValueRestorer<bool> UseBusyCursorRestorer(FUseBusyCursor, false);
 
-  TSynchronizeChecklist * Checklist = new TSynchronizeChecklist();
-  try
-  {
-    DoSynchronizeCollectDirectory(LocalDirectory, RemoteDirectory, Mode,
-      CopyParam, Params, OnSynchronizeDirectory, Options, sfFirstLevel,
-      Checklist);
-    Checklist->Sort();
-  }
-  catch(...)
-  {
-    delete Checklist;
-    throw;
-  }
-  return Checklist;
+  std::unique_ptr<TSynchronizeChecklist> Checklist(new TSynchronizeChecklist());
+
+  TSynchronizeData Data;
+  Data.Directory1 = Directory1;
+  Data.Directory2 = Directory2;
+  Data.Mode = Mode;
+  Data.CopyParam = CopyParam;
+  Data.Params = Params;
+  Data.OnSynchronizeDirectory = OnSynchronizeDirectory;
+  Data.Options = Options;
+  Data.Flags = sfFirstLevel;
+  Data.Checklist = Checklist.get();
+  Data.ClearLevelSpecific();
+
+  DoSynchronizeCollectDirectory(Data);
+  Checklist->Sort();
+
+  return Checklist.release();
 }
 //---------------------------------------------------------------------------
 static void __fastcall AddFlagName(UnicodeString & ParamsStr, int & Params, int Param, const UnicodeString & Name)
@@ -6180,71 +6199,58 @@ void DestroyLocalFileList(TStringList * LocalFileList)
   }
 }
 //---------------------------------------------------------------------------
-void __fastcall TTerminal::DoSynchronizeCollectDirectory(const UnicodeString LocalDirectory,
-  const UnicodeString RemoteDirectory, TSynchronizeMode Mode,
-  const TCopyParamType * CopyParam, int Params,
-  TSynchronizeDirectory OnSynchronizeDirectory, TSynchronizeOptions * Options,
-  int Flags, TSynchronizeChecklist * Checklist)
+void TTerminal::DoSynchronizeCollectDirectory(TSynchronizeData Data)
 {
-  TSynchronizeData Data;
-
-  Data.LocalDirectory = IncludeTrailingBackslash(LocalDirectory);
-  Data.RemoteDirectory = UnixIncludeTrailingBackslash(RemoteDirectory);
-  Data.Mode = Mode;
-  Data.Params = Params;
-  Data.OnSynchronizeDirectory = OnSynchronizeDirectory;
-  Data.LocalFileList = NULL;
-  Data.CopyParam = CopyParam;
-  Data.Options = Options;
-  Data.Flags = Flags;
-  Data.Checklist = Checklist;
+  Data.Directory1 = IncludeTrailingBackslash(Data.Directory1);
+  Data.Directory2 = UnixIncludeTrailingBackslash(Data.Directory2);
 
-  LogEvent(FORMAT(L"Collecting synchronization list for local directory '%s' and remote directory '%s', "
-    "mode = %s, params = 0x%x (%s), file mask = '%s'", (LocalDirectory, RemoteDirectory,
-    SynchronizeModeStr(Mode), int(Params), SynchronizeParamsStr(Params), CopyParam->IncludeFileMask.Masks)));
+  LogEvent(FORMAT(
+    L"Collecting synchronization list for '%s' and '%s', mode = %s, params = 0x%x (%s), file mask = '%s'",
+    (Data.Directory1, Data.Directory2, SynchronizeModeStr(Data.Mode), int(Data.Params), SynchronizeParamsStr(Data.Params),
+     Data.CopyParam->IncludeFileMask.Masks)));
 
-  if (FLAGCLEAR(Params, spDelayProgress))
+  if (FLAGCLEAR(Data.Params, spDelayProgress))
   {
     DoSynchronizeProgress(Data, true);
   }
 
   try
   {
-    Data.LocalFileList = CreateSortedStringList(FLAGSET(Params, spCaseSensitive));
+    Data.LeftFileList = CreateSortedStringList(FLAGSET(Data.Params, spCaseSensitive));
 
     TSearchRecOwned SearchRec;
-    if (LocalFindFirstLoop(Data.LocalDirectory + L"*.*", SearchRec))
+    if (LocalFindFirstLoop(Data.Directory1 + L"*.*", SearchRec))
     {
       do
       {
         UnicodeString FileName = SearchRec.Name;
         UnicodeString FullLocalFileName = SearchRec.GetFilePath();
-        UnicodeString RemoteFileName = ChangeFileName(CopyParam, FileName, osLocal, false);
+        UnicodeString RemoteFileName = ChangeFileName(Data.CopyParam, FileName, osLocal, false);
         if (SearchRec.IsRealFile() &&
-            DoAllowLocalFileTransfer(FullLocalFileName, SearchRec, CopyParam, true) &&
-            (FLAGCLEAR(Flags, sfFirstLevel) ||
-             (Options == NULL) ||
-             Options->MatchesFilter(FileName) ||
-             Options->MatchesFilter(RemoteFileName)))
+            DoAllowLocalFileTransfer(FullLocalFileName, SearchRec, Data.CopyParam, true) &&
+            (FLAGCLEAR(Data.Flags, sfFirstLevel) ||
+             (Data.Options == NULL) ||
+             Data.Options->MatchesFilter(FileName) ||
+             Data.Options->MatchesFilter(RemoteFileName)))
         {
           TSynchronizeFileData * FileData = new TSynchronizeFileData;
 
           FileData->IsDirectory = SearchRec.IsDirectory();
           FileData->Info.FileName = FileName;
-          FileData->Info.Directory = Data.LocalDirectory;
+          FileData->Info.Directory = Data.Directory1;
           FileData->Info.Modification = SearchRec.GetLastWriteTime();
           FileData->Info.ModificationFmt = mfFull;
           FileData->Info.Size = SearchRec.Size;
           FileData->LocalLastWriteTime = SearchRec.FindData.ftLastWriteTime;
           FileData->New = true;
           FileData->Modified = false;
-          Data.LocalFileList->AddObject(FileName, reinterpret_cast<TObject*>(FileData));
-          LogEvent(0, FORMAT(L"Local file %s included to synchronization",
+          Data.LeftFileList->AddObject(FileName, reinterpret_cast<TObject*>(FileData));
+          LogEvent(0, FORMAT(L"Left file %s included to synchronization",
             (FormatFileDetailsForLog(FullLocalFileName, SearchRec.GetLastWriteTime(), SearchRec.Size))));
         }
         else
         {
-          LogEvent(0, FORMAT(L"Local file %s excluded from synchronization",
+          LogEvent(0, FORMAT(L"Left file %s excluded from synchronization",
             (FormatFileDetailsForLog(FullLocalFileName, SearchRec.GetLastWriteTime(), SearchRec.Size))));
         }
 
@@ -6255,33 +6261,32 @@ void __fastcall TTerminal::DoSynchronizeCollectDirectory(const UnicodeString Loc
 
       // can we expect that ProcessDirectory would take so little time
       // that we can postpone showing progress window until anything actually happens?
-      bool Cached = FLAGSET(Params, spUseCache) && SessionData->CacheDirectories &&
-        FDirectoryCache->HasFileList(RemoteDirectory);
+      bool Directory2ShouldBeQuick =
+        (FLAGSET(Data.Params, spUseCache) && SessionData->CacheDirectories && FDirectoryCache->HasFileList(Data.Directory2));
 
-      if (!Cached && FLAGSET(Params, spDelayProgress))
+      if (!Directory2ShouldBeQuick && FLAGSET(Data.Params, spDelayProgress))
       {
         DoSynchronizeProgress(Data, true);
       }
 
-      ProcessDirectory(RemoteDirectory, SynchronizeCollectFile, &Data,
-        FLAGSET(Params, spUseCache));
+      ProcessDirectory(Data.Directory2, SynchronizeCollectFile, &Data, FLAGSET(Data.Params, spUseCache));
 
       TSynchronizeFileData * FileData;
-      for (int Index = 0; Index < Data.LocalFileList->Count; Index++)
+      for (int Index = 0; Index < Data.LeftFileList->Count; Index++)
       {
         FileData = reinterpret_cast<TSynchronizeFileData *>
-          (Data.LocalFileList->Objects[Index]);
+          (Data.LeftFileList->Objects[Index]);
         // add local file either if we are going to upload it
         // (i.e. if it is updated or we want to upload even new files)
         // or if we are going to delete it (i.e. all "new"=obsolete files)
-        bool Modified = (FileData->Modified && ((Mode == smBoth) || (Mode == smRemote)));
+        bool Modified = (FileData->Modified && ((Data.Mode == smBoth) || (Data.Mode == smRemote)));
         bool New = (FileData->New &&
-          ((Mode == smLocal) ||
-           (((Mode == smBoth) || (Mode == smRemote)) && FLAGCLEAR(Params, spTimestamp))));
+          ((Data.Mode == smLocal) ||
+           (((Data.Mode == smBoth) || (Data.Mode == smRemote)) && FLAGCLEAR(Data.Params, spTimestamp))));
 
         if (New)
         {
-          LogEvent(FORMAT(L"Local file %s is new",
+          LogEvent(FORMAT(L"Left file %s is new",
             (FormatFileDetailsForLog(FileData->Info.Directory + FileData->Info.FileName,
              FileData->Info.Modification, FileData->Info.Size))));
         }
@@ -6293,37 +6298,37 @@ void __fastcall TTerminal::DoSynchronizeCollectDirectory(const UnicodeString Loc
           {
             ChecklistItem->IsDirectory = FileData->IsDirectory;
 
-            ChecklistItem->Local = FileData->Info;
+            ChecklistItem->Info1 = FileData->Info;
             ChecklistItem->FLocalLastWriteTime = FileData->LocalLastWriteTime;
 
             if (Modified)
             {
-              DebugAssert(!FileData->MatchingRemoteFile.Directory.IsEmpty());
-              ChecklistItem->Remote = FileData->MatchingRemoteFile;
-              ChecklistItem->ImageIndex = FileData->MatchingRemoteFileImageIndex;
-              ChecklistItem->RemoteFile = FileData->MatchingRemoteFileFile;
+              DebugAssert(!FileData->MatchingFile2.Directory.IsEmpty());
+              ChecklistItem->Info2 = FileData->MatchingFile2;
+              ChecklistItem->ImageIndex = FileData->MatchingRemoteFile2ImageIndex;
+              ChecklistItem->RemoteFile = FileData->MatchingRemoteFile2;
             }
             else
             {
-              ChecklistItem->Remote.Directory = Data.RemoteDirectory;
+              ChecklistItem->Info2.Directory = Data.Directory2;
             }
 
-            if ((Mode == smBoth) || (Mode == smRemote))
+            if ((Data.Mode == smBoth) || (Data.Mode == smRemote))
             {
               ChecklistItem->Action =
                 (Modified ? TSynchronizeChecklist::saUploadUpdate : TSynchronizeChecklist::saUploadNew);
               ChecklistItem->Checked =
-                (Modified || FLAGCLEAR(Params, spExistingOnly)) &&
-                (!ChecklistItem->IsDirectory || FLAGCLEAR(Params, spNoRecurse) ||
-                 FLAGSET(Params, spSubDirs));
+                (Modified || FLAGCLEAR(Data.Params, spExistingOnly)) &&
+                (!ChecklistItem->IsDirectory || FLAGCLEAR(Data.Params, spNoRecurse) ||
+                 FLAGSET(Data.Params, spSubDirs));
             }
-            else if ((Mode == smLocal) && FLAGCLEAR(Params, spTimestamp))
+            else if ((Data.Mode == smLocal) && FLAGCLEAR(Data.Params, spTimestamp))
             {
               ChecklistItem->Action = TSynchronizeChecklist::saDeleteLocal;
               ChecklistItem->Checked =
-                FLAGSET(Params, spDelete) &&
-                (!ChecklistItem->IsDirectory || FLAGCLEAR(Params, spNoRecurse) ||
-                 FLAGSET(Params, spSubDirs));
+                FLAGSET(Data.Params, spDelete) &&
+                (!ChecklistItem->IsDirectory || FLAGCLEAR(Data.Params, spNoRecurse) ||
+                 FLAGSET(Data.Params, spSubDirs));
             }
 
             if (ChecklistItem->Action != TSynchronizeChecklist::saNone)
@@ -6341,7 +6346,7 @@ void __fastcall TTerminal::DoSynchronizeCollectDirectory(const UnicodeString Loc
         {
           if (FileData->Modified)
           {
-            delete FileData->MatchingRemoteFileFile;
+            delete FileData->MatchingRemoteFile2;
           }
         }
       }
@@ -6349,7 +6354,7 @@ void __fastcall TTerminal::DoSynchronizeCollectDirectory(const UnicodeString Loc
   }
   __finally
   {
-    DestroyLocalFileList(Data.LocalFileList);
+    DestroyLocalFileList(Data.LeftFileList);
   }
 }
 //---------------------------------------------------------------------------
@@ -6394,7 +6399,7 @@ void __fastcall TTerminal::CollectCalculatedChecksum(
   FCollectedCalculatedChecksum = Hash;
 }
 //---------------------------------------------------------------------------
-bool TTerminal::SameFileChecksum(const UnicodeString & LocalFileName, const TRemoteFile * File)
+bool TTerminal::SameFileChecksum(const UnicodeString & LeftFileName, const TRemoteFile * RightFile)
 {
   UnicodeString DefaultAlg = Sha256ChecksumAlg;
   UnicodeString Algs =
@@ -6418,22 +6423,22 @@ bool TTerminal::SameFileChecksum(const UnicodeString & LocalFileName, const TRem
   }
 
   std::unique_ptr<TStrings> FileList(new TStringList());
-  FileList->AddObject(File->FullFileName, const_cast<TRemoteFile *>(File));
+  FileList->AddObject(RightFile->FullFileName, const_cast<TRemoteFile *>(RightFile));
   DebugAssert(FCollectedCalculatedChecksum.IsEmpty());
   FCollectedCalculatedChecksum = EmptyStr;
   CalculateFilesChecksum(Alg, FileList.get(), CollectCalculatedChecksum);
-  UnicodeString RemoteChecksum = FCollectedCalculatedChecksum;
+  UnicodeString RightChecksum = FCollectedCalculatedChecksum;
   FCollectedCalculatedChecksum = EmptyStr;
 
-  UnicodeString LocalChecksum;
+  UnicodeString LeftChecksum;
   FILE_OPERATION_LOOP_BEGIN
   {
-    std::unique_ptr<THandleStream> Stream(TSafeHandleStream::CreateFromFile(LocalFileName, fmOpenRead | fmShareDenyWrite));
-    LocalChecksum = CalculateFileChecksum(Stream.get(), Alg);
+    std::unique_ptr<THandleStream> Stream(TSafeHandleStream::CreateFromFile(LeftFileName, fmOpenRead | fmShareDenyWrite));
+    LeftChecksum = CalculateFileChecksum(Stream.get(), Alg);
   }
-  FILE_OPERATION_LOOP_END(FMTLOAD(CHECKSUM_ERROR, (LocalFileName)));
+  FILE_OPERATION_LOOP_END(FMTLOAD(CHECKSUM_ERROR, (LeftFileName)));
 
-  return SameText(RemoteChecksum, LocalChecksum);
+  return SameText(RightChecksum, LeftChecksum);
 }
 //---------------------------------------------------------------------------
 void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName,
@@ -6462,11 +6467,11 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
       ChecklistItem->IsDirectory = File->IsDirectory;
       ChecklistItem->ImageIndex = File->IconIndex;
 
-      ChecklistItem->Remote.FileName = File->FileName;
-      ChecklistItem->Remote.Directory = Data->RemoteDirectory;
-      ChecklistItem->Remote.Modification = File->Modification;
-      ChecklistItem->Remote.ModificationFmt = File->ModificationFmt;
-      ChecklistItem->Remote.Size = File->Resolve()->Size;
+      ChecklistItem->Info2.FileName = File->FileName;
+      ChecklistItem->Info2.Directory = Data->Directory2;
+      ChecklistItem->Info2.Modification = File->Modification;
+      ChecklistItem->Info2.ModificationFmt = File->ModificationFmt;
+      ChecklistItem->Info2.Size = File->Resolve()->Size;
 
       bool Modified = false;
       bool New = false;
@@ -6476,12 +6481,12 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
       }
       else
       {
-        int LocalIndex = Data->LocalFileList->IndexOf(LocalFileName);
+        int LocalIndex = Data->LeftFileList->IndexOf(LocalFileName);
         New = (LocalIndex < 0);
         if (!New)
         {
           TSynchronizeFileData * LocalData =
-            reinterpret_cast<TSynchronizeFileData *>(Data->LocalFileList->Objects[LocalIndex]);
+            reinterpret_cast<TSynchronizeFileData *>(Data->LeftFileList->Objects[LocalIndex]);
 
           LocalData->New = false;
           UnicodeString FullLocalFileName = LocalData->Info.Directory + LocalData->Info.FileName;
@@ -6493,22 +6498,22 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
           }
           else if (!File->IsDirectory)
           {
-            ChecklistItem->Local = LocalData->Info;
+            ChecklistItem->Info1 = LocalData->Info;
 
-            ChecklistItem->Local.Modification =
-              ReduceDateTimePrecision(ChecklistItem->Local.Modification, File->ModificationFmt);
+            ChecklistItem->Info1.Modification =
+              ReduceDateTimePrecision(ChecklistItem->Info1.Modification, File->ModificationFmt);
 
-            bool LocalModified = false;
+            bool LeftModified = false;
             // for spTimestamp+spBySize require that the file sizes are the same
             // before comparing file time
             int TimeCompare;
             if (FLAGCLEAR(Data->Params, spNotByTime) &&
                 (FLAGCLEAR(Data->Params, spTimestamp) ||
                  FLAGCLEAR(Data->Params, spBySize) ||
-                 (ChecklistItem->Local.Size == ChecklistItem->Remote.Size)))
+                 (ChecklistItem->Info1.Size == ChecklistItem->Info2.Size)))
             {
-              TimeCompare = CompareFileTime(ChecklistItem->Local.Modification,
-                   ChecklistItem->Remote.Modification);
+              TimeCompare =
+                CompareFileTime(ChecklistItem->Info1.Modification, ChecklistItem->Info2.Modification);
             }
             else
             {
@@ -6523,7 +6528,7 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
               }
               else
               {
-                LocalModified = true;
+                LeftModified = true;
               }
             }
             else if (TimeCompare > 0)
@@ -6531,7 +6536,7 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
               if ((FLAGCLEAR(Data->Params, spTimestamp) && FLAGCLEAR(Data->Params, spMirror)) ||
                   (Data->Mode == smBoth) || (Data->Mode == smRemote))
               {
-                LocalModified = true;
+                LeftModified = true;
               }
               else
               {
@@ -6539,11 +6544,11 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
               }
             }
             else if (FLAGSET(Data->Params, spBySize) &&
-                     (ChecklistItem->Local.Size != ChecklistItem->Remote.Size) &&
+                     (ChecklistItem->Info1.Size != ChecklistItem->Info2.Size) &&
                      FLAGCLEAR(Data->Params, spTimestamp))
             {
               Modified = true;
-              LocalModified = true;
+              LeftModified = true;
             }
             else if (FLAGSET(Data->Params, spByChecksum) &&
                      FLAGCLEAR(Data->Params, spTimestamp) &&
@@ -6551,42 +6556,38 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
                      FLAGCLEAR(Data->Params, spTimestamp))
             {
               Modified = true;
-              LocalModified = true;
+              LeftModified = true;
             }
 
-            if (LocalModified)
+            if (LeftModified)
             {
               LocalData->Modified = true;
-              LocalData->MatchingRemoteFile = ChecklistItem->Remote;
-              LocalData->MatchingRemoteFileImageIndex = ChecklistItem->ImageIndex;
+              LocalData->MatchingFile2 = ChecklistItem->Info2;
+              LocalData->MatchingRemoteFile2ImageIndex = ChecklistItem->ImageIndex;
               // we need this for custom commands over checklist only,
               // not for sync itself
-              LocalData->MatchingRemoteFileFile = File->Duplicate();
-              LogEvent(FORMAT(L"Local file %s is modified comparing to remote file %s",
+              LocalData->MatchingRemoteFile2 = File->Duplicate();
+              LogEvent(FORMAT(L"Left file %s is modified comparing to right file %s",
                 (FormatFileDetailsForLog(FullLocalFileName, LocalData->Info.Modification, LocalData->Info.Size),
                  FormatFileDetailsForLog(FullRemoteFileName, File->Modification, File->Size, File->LinkedFile))));
             }
 
             if (Modified)
             {
-              LogEvent(FORMAT(L"Remote file %s is modified comparing to local file %s",
+              LogEvent(FORMAT(L"Right file %s is modified comparing to left file %s",
                 (FormatFileDetailsForLog(FullRemoteFileName, File->Modification, File->Size, File->LinkedFile),
                  FormatFileDetailsForLog(FullLocalFileName, LocalData->Info.Modification, LocalData->Info.Size))));
             }
           }
           else if (FLAGCLEAR(Data->Params, spNoRecurse))
           {
-            DoSynchronizeCollectDirectory(
-              FullLocalFileName, FullRemoteFileName,
-              Data->Mode, Data->CopyParam, Data->Params, Data->OnSynchronizeDirectory,
-              Data->Options, (Data->Flags & ~sfFirstLevel),
-              Data->Checklist);
+            DoSynchronizeCollectDirectory(Data->CloneFor(FullLocalFileName, FullRemoteFileName));
           }
         }
         else
         {
-          ChecklistItem->Local.Directory = Data->LocalDirectory;
-          LogEvent(FORMAT(L"Remote file %s is new",
+          ChecklistItem->Info1.Directory = Data->Directory1;
+          LogEvent(FORMAT(L"Right file %s is new",
             (FormatFileDetailsForLog(FullRemoteFileName, File->Modification, File->Size, File->LinkedFile))));
         }
       }
@@ -6635,7 +6636,7 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
   }
   else
   {
-    LogEvent(0, FORMAT(L"Remote file %s excluded from synchronization",
+    LogEvent(0, FORMAT(L"Right file %s excluded from synchronization",
       (FormatFileDetailsForLog(FullRemoteFileName, File->Modification, File->Size, File->LinkedFile))));
   }
 }
@@ -6754,15 +6755,15 @@ void __fastcall TTerminal::SynchronizeApply(
     {
       UnicodeString LocalTarget = ChecklistItem->GetLocalTarget();
       UnicodeString RemoteTarget = ChecklistItem->GetRemoteTarget();
-      if (!SamePaths(Data.LocalDirectory, LocalTarget) ||
-          !UnixSamePath(Data.RemoteDirectory, RemoteTarget))
+      if (!SamePaths(Data.Directory1, LocalTarget) ||
+          !UnixSamePath(Data.Directory2, RemoteTarget))
       {
-        Data.LocalDirectory = LocalTarget;
-        Data.RemoteDirectory = RemoteTarget;
+        Data.Directory1 = LocalTarget;
+        Data.Directory2 = RemoteTarget;
 
         LogEvent(
           FORMAT(L"Synchronizing local directory '%s' with remote directory '%s', params = 0x%x (%s)",
-          (Data.LocalDirectory, Data.RemoteDirectory, int(Params), SynchronizeParamsStr(Params))));
+          (Data.Directory1, Data.Directory2, int(Params), SynchronizeParamsStr(Params))));
 
         DoSynchronizeProgress(Data, false);
       }
@@ -6952,7 +6953,7 @@ void __fastcall TTerminal::DoSynchronizeProgress(const TSynchronizeData & Data,
   {
     bool Continue = true;
     Data.OnSynchronizeDirectory(
-      Data.LocalDirectory, Data.RemoteDirectory, Continue, Collect, Data.Options);
+      Data.Directory1, Data.Directory2, Continue, Collect, Data.Options);
 
     if (!Continue)
     {
@@ -6974,7 +6975,7 @@ void __fastcall TTerminal::SynchronizeLocalTimestamp(const UnicodeString /*FileN
     HANDLE Handle;
     OpenLocalFile(LocalFile, GENERIC_WRITE, NULL, &Handle,
       NULL, NULL, NULL, NULL);
-    FILETIME WrTime = DateTimeToFileTime(ChecklistItem->Remote.Modification,
+    FILETIME WrTime = DateTimeToFileTime(ChecklistItem->Info2.Modification,
       SessionData->DSTMode);
     bool Result = SetFileTime(Handle, NULL, NULL, &WrTime);
     int Error = GetLastError();

source/core/Terminal.h

@@ -350,11 +350,7 @@ protected:
     const TOverwriteFileParams * FileParams, unsigned int Answers, TQueryParams * QueryParams,
     TOperationSide Side, const TCopyParamType * CopyParam, int Params,
     TFileOperationProgressType * OperationProgress, UnicodeString Message = L"");
-  void __fastcall DoSynchronizeCollectDirectory(const UnicodeString LocalDirectory,
-    const UnicodeString RemoteDirectory, TSynchronizeMode Mode,
-    const TCopyParamType * CopyParam, int Params,
-    TSynchronizeDirectory OnSynchronizeDirectory,
-    TSynchronizeOptions * Options, int Level, TSynchronizeChecklist * Checklist);
+  void DoSynchronizeCollectDirectory(TSynchronizeData Data);
   bool __fastcall LocalFindFirstLoop(const UnicodeString & Directory, TSearchRecChecked & SearchRec);
   bool __fastcall LocalFindNextLoop(TSearchRecChecked & SearchRec);
   bool __fastcall DoAllowLocalFileTransfer(
@@ -369,7 +365,7 @@ protected:
     const TRemoteFile * File, /*TSynchronizeData*/ void * Param);
   void __fastcall SynchronizeCollectFile(const UnicodeString FileName,
     const TRemoteFile * File, /*TSynchronizeData*/ void * Param);
-  bool SameFileChecksum(const UnicodeString & LocalFileName, const TRemoteFile * File);
+  bool SameFileChecksum(const UnicodeString & LeftFileName, const TRemoteFile * RightFile);
   void __fastcall CollectCalculatedChecksum(
     const UnicodeString & FileName, const UnicodeString & Alg, const UnicodeString & Hash);
   void __fastcall SynchronizeRemoteTimestamp(const UnicodeString FileName,
@@ -610,9 +606,9 @@ public:
   void __fastcall CalculateFilesChecksum(
     const UnicodeString & Alg, TStrings * FileList, TCalculatedChecksumEvent OnCalculatedChecksum);
   void __fastcall ClearCaches();
-  TSynchronizeChecklist * __fastcall SynchronizeCollect(const UnicodeString LocalDirectory,
-    const UnicodeString RemoteDirectory, TSynchronizeMode Mode,
-    const TCopyParamType * CopyParam, int Params,
+  TSynchronizeChecklist * SynchronizeCollect(
+    const UnicodeString & Directory1, const UnicodeString & Directory2,
+    TSynchronizeMode Mode, const TCopyParamType * CopyParam, int Params,
     TSynchronizeDirectory OnSynchronizeDirectory, TSynchronizeOptions * Options);
   void __fastcall SynchronizeApply(
     TSynchronizeChecklist * Checklist,

source/forms/CustomScpExplorer.cpp

@@ -6229,7 +6229,7 @@ bool __fastcall TCustomScpExplorerForm::SynchronizeAllowSelectedOnly()
 {
   // can be called from command line
   return Visible &&
-    ((DirView(osRemote)->SelCount > 0) ||
+    ((DirView(osOther)->SelCount > 0) ||
      (HasDirView[osLocal] && (DirView(osLocal)->SelCount > 0)));
 }
 //---------------------------------------------------------------------------
@@ -6248,9 +6248,9 @@ void __fastcall TCustomScpExplorerForm::GetSynchronizeOptions(
     Options.Filter->CaseSensitive = false;
     Options.Filter->Duplicates = Types::dupAccept;
 
-    if (DirView(osRemote)->SelCount > 0)
+    if (DirView(osOther)->SelCount > 0)
     {
-      DirView(osRemote)->CreateFileList(false, false, Options.Filter);
+      DirView(osOther)->CreateFileList(false, false, Options.Filter);
     }
     if (HasDirView[osLocal] && (DirView(osLocal)->SelCount > 0))
     {
@@ -6517,12 +6517,12 @@ void __fastcall TCustomScpExplorerForm::DoSynchronizeMove(
 //---------------------------------------------------------------------------
 void __fastcall TCustomScpExplorerForm::DoSynchronizeExplore(TOperationSide Side, TSynchronizeChecklist::TAction Action, const TSynchronizeChecklist::TItem * Item)
 {
-  UnicodeString LocalPath = ExcludeTrailingBackslash(Item->Local.Directory);
+  UnicodeString Path1 = ExcludeTrailingBackslash(Item->Info1.Directory);
   if (Side == osLocal)
   {
     if (Action == TSynchronizeChecklist::saDownloadNew)
     {
-      OpenFolderInExplorer(LocalPath);
+      OpenFolderInExplorer(Path1);
     }
     else
     {
@@ -6533,10 +6533,10 @@ void __fastcall TCustomScpExplorerForm::DoSynchronizeExplore(TOperationSide Side
   {
     // Similar to CreateHiddenDuplicateSession, except that it modifies the initial directories
     std::unique_ptr<TSessionData> SessionData(CloneCurrentSessionData());
-    SessionData->RemoteDirectory = UnixExcludeTrailingBackslash(Item->Remote.Directory);
-    if (!LocalPath.IsEmpty())
+    SessionData->RemoteDirectory = UnixExcludeTrailingBackslash(Item->Info2.Directory);
+    if (!Path1.IsEmpty())
     {
-      SessionData->LocalDirectory = LocalPath;
+      SessionData->LocalDirectory = Path1;
     }
 
     UnicodeString SessionName = SaveHiddenDuplicateSession(SessionData.get());
@@ -6545,7 +6545,7 @@ void __fastcall TCustomScpExplorerForm::DoSynchronizeExplore(TOperationSide Side
 }
 //---------------------------------------------------------------------------
 void __fastcall TCustomScpExplorerForm::FullSynchronizeInNewWindow(
-  TSynchronizeMode Mode, int Params, const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory,
+  TSynchronizeMode Mode, int Params, const UnicodeString & Directory1, const UnicodeString & Directory2,
    const TCopyParamType * CopyParams)
 {
   UnicodeString SessionName = CreateHiddenDuplicateSession();
@@ -6555,13 +6555,13 @@ void __fastcall TCustomScpExplorerForm::FullSynchronizeInNewWindow(
       TProgramParams::FormatSwitch(DEFAULTS_SWITCH),
       SerializeCopyParamForCommandLine(CopyParams),
       TProgramParams::FormatSwitch(SYNCHRONIZE_SWITCH),
-      LocalDirectory, RemoteDirectory, Mode, Params));
+      Directory1, Directory2, Mode, Params));
 
   ExecuteNewInstance(SessionName, AdditionalParams);
 }
 //---------------------------------------------------------------------------
 int __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
-  UnicodeString & LocalDirectory, UnicodeString & RemoteDirectory,
+  UnicodeString & Directory1, UnicodeString & Directory2,
   TSynchronizeMode & Mode, int Params, bool & SaveMode, int UseDefaults)
 {
   int Result;
@@ -6575,13 +6575,14 @@ int __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
   TUsableCopyParamAttrs CopyParamAttrs = Terminal->UsableCopyParamAttrs(0);
   bool Continue =
     ((UseDefaults == 0) ||
-     DoFullSynchronizeDialog(Mode, Params, LocalDirectory, RemoteDirectory,
+     DoFullSynchronizeDialog(
+       Mode, Params, Directory1, Directory2,
        &CopyParam, SaveSettings, SaveMode, Options, CopyParamAttrs, FullSynchronizeInNewWindow, UseDefaults)) &&
     (FLAGCLEAR(Params, TTerminal::spByChecksum) || EnsureCommandSessionFallback(fcCalculatingChecksum));
   if (Continue)
   {
     Configuration->Usage->Inc(L"Synchronizations");
-    CopyParam.IncludeFileMask.SetRoots(LocalDirectory, RemoteDirectory);
+    CopyParam.IncludeFileMask.SetRoots(Directory1, Directory2);
     UpdateCopyParamCounters(CopyParam);
 
     TSynchronizeOptions SynchronizeOptions;
@@ -6607,7 +6608,7 @@ int __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
       try
       {
         UnicodeString SessionKey = Terminal->SessionData->SessionKey;
-        std::unique_ptr<TStrings> DataList(Configuration->LoadDirectoryStatisticsCache(SessionKey, RemoteDirectory, CopyParam));
+        std::unique_ptr<TStrings> DataList(Configuration->LoadDirectoryStatisticsCache(SessionKey, Directory2, CopyParam));
 
         int Files = -1;
         if (DataList->Count >= 1)
@@ -6622,15 +6623,17 @@ int __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
         FSynchronizeProgressForm = new TSynchronizeProgressForm(Application, true, Files);
         FSynchronizeProgressForm->Start();
 
-        Checklist = Terminal->SynchronizeCollect(LocalDirectory, RemoteDirectory,
-          static_cast<TTerminal::TSynchronizeMode>(Mode),
-          &CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory,
-          &SynchronizeOptions);
+        Checklist =
+          ManagedSession->SynchronizeCollect(
+            Directory1, Directory2,
+            static_cast<TTerminal::TSynchronizeMode>(Mode),
+            &CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory,
+            &SynchronizeOptions);
 
         if (Terminal->SessionData->CacheDirectories)
         {
           DataList->Strings[0] = IntToStr(SynchronizeOptions.Files);
-          Configuration->SaveDirectoryStatisticsCache(SessionKey, RemoteDirectory, CopyParam, DataList.get());
+          Configuration->SaveDirectoryStatisticsCache(SessionKey, Directory2, CopyParam, DataList.get());
         }
       }
       __finally
@@ -6658,8 +6661,9 @@ int __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
           {
             OnQueueSynchronize = DoQueueSynchronize;
           }
+
           if (!DoSynchronizeChecklistDialog(
-                Checklist, Mode, Params, LocalDirectory, RemoteDirectory, CustomCommandMenu, DoFullSynchronize,
+                Checklist, Mode, Params, Directory1, Directory2, CustomCommandMenu, DoFullSynchronize,
                 OnQueueSynchronize, DoSynchronizeChecklistCalculateSize, DoSynchronizeMove, DoSynchronizeExplore,
                 &SynchronizeParams))
           {

source/forms/CustomScpExplorer.h

@@ -518,7 +518,7 @@ protected:
   UnicodeString __fastcall SerializeCopyParamForCommandLine(const TCopyParamType * CopyParams);
   void __fastcall SynchronizeInNewWindow(const TSynchronizeParamType & Params, const TCopyParamType * CopyParams);
   void __fastcall FullSynchronizeInNewWindow(
-    TSynchronizeMode Mode, int Params, const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory,
+    TSynchronizeMode Mode, int Params, const UnicodeString & Directory1, const UnicodeString & Directory2,
      const TCopyParamType * CopyParams);
   bool __fastcall SynchronizeAllowSelectedOnly();
   virtual void __fastcall BatchStart(void *& Storage);
@@ -884,8 +884,8 @@ public:
   bool __fastcall DoSynchronizeDirectories(
     UnicodeString & LocalDirectory, UnicodeString & RemoteDirectory, int UseDefaults);
   int __fastcall DoFullSynchronizeDirectories(
-    UnicodeString & LocalDirectory, UnicodeString & RemoteDirectory, TSynchronizeMode & Mode,
-    int Params, bool & SaveMode, int UseDefaults);
+    UnicodeString & Directory1, UnicodeString & Directory2,
+    TSynchronizeMode & Mode, int Params, bool & SaveMode, int UseDefaults);
   void __fastcall StandaloneEdit(const UnicodeString & FileName);
   bool __fastcall CanPasteFromClipBoard();
   virtual void __fastcall PasteFromClipBoard();

source/forms/FullSynchronize.cpp

@@ -9,8 +9,9 @@
 #pragma link "HistoryComboBox"
 #pragma resource "*.dfm"
 //---------------------------------------------------------------------------
-bool __fastcall DoFullSynchronizeDialog(TSynchronizeMode & Mode, int & Params,
-  UnicodeString & LocalDirectory, UnicodeString & RemoteDirectory,
+bool DoFullSynchronizeDialog(
+  TSynchronizeMode & Mode, int & Params,
+  UnicodeString & Directory1, UnicodeString & Directory2,
   TCopyParamType * CopyParams, bool & SaveSettings, bool & SaveMode, int Options,
   const TUsableCopyParamAttrs & CopyParamAttrs, TFullSynchronizeInNewWindow OnFullSynchronizeInNewWindow,
   int AutoSubmit)
@@ -22,8 +23,8 @@ bool __fastcall DoFullSynchronizeDialog(TSynchronizeMode & Mode, int & Params,
     Dialog->Init(Options, CopyParamAttrs, OnFullSynchronizeInNewWindow);
     Dialog->Mode = Mode;
     Dialog->Params = Params;
-    Dialog->LocalDirectory = LocalDirectory;
-    Dialog->RemoteDirectory = RemoteDirectory;
+    Dialog->Directory1 = Directory1;
+    Dialog->Directory2 = Directory2;
     Dialog->CopyParams = *CopyParams;
     Dialog->SaveSettings = SaveSettings;
     Dialog->SaveMode = SaveMode;
@@ -36,8 +37,8 @@ bool __fastcall DoFullSynchronizeDialog(TSynchronizeMode & Mode, int & Params,
     {
       Mode = Dialog->Mode;
       Params = Dialog->Params;
-      LocalDirectory = Dialog->LocalDirectory;
-      RemoteDirectory = Dialog->RemoteDirectory;
+      Directory1 = Dialog->Directory1;
+      Directory2 = Dialog->Directory2;
       *CopyParams = Dialog->CopyParams;
       SaveSettings = Dialog->SaveSettings;
       SaveMode = Dialog->SaveMode;
@@ -192,22 +193,22 @@ void __fastcall TFullSynchronizeDialog::Submitted()
   CustomWinConfiguration->History[L"RemoteDirectory"] = RemoteDirectoryEdit->Items;
 }
 //---------------------------------------------------------------------------
-void __fastcall TFullSynchronizeDialog::SetRemoteDirectory(const UnicodeString value)
+void TFullSynchronizeDialog::SetDirectory2(const UnicodeString & value)
 {
   RemoteDirectoryEdit->Text = value;
 }
 //---------------------------------------------------------------------------
-UnicodeString __fastcall TFullSynchronizeDialog::GetRemoteDirectory()
+UnicodeString TFullSynchronizeDialog::GetDirectory2()
 {
   return RemoteDirectoryEdit->Text;
 }
 //---------------------------------------------------------------------------
-void __fastcall TFullSynchronizeDialog::SetLocalDirectory(const UnicodeString value)
+void TFullSynchronizeDialog::SetDirectory1(const UnicodeString & value)
 {
   LocalDirectoryEdit->Text = value;
 }
 //---------------------------------------------------------------------------
-UnicodeString __fastcall TFullSynchronizeDialog::GetLocalDirectory()
+UnicodeString TFullSynchronizeDialog::GetDirectory1()
 {
   return LocalDirectoryEdit->Text;
 }
@@ -470,7 +471,7 @@ void __fastcall TFullSynchronizeDialog::StartInNewWindow()
 {
   Submitted();
   TCopyParamType ACopyParams = CopyParams;
-  FOnFullSynchronizeInNewWindow(Mode, Params, LocalDirectory, RemoteDirectory, &ACopyParams);
+  FOnFullSynchronizeInNewWindow(Mode, Params, Directory1, Directory2, &ACopyParams);
   Close();
 }
 //---------------------------------------------------------------------------

source/forms/FullSynchronize.h

@@ -78,10 +78,10 @@ private:
   UnicodeString FPreset;
   UnicodeString FSynchronizeBySizeCaption;
   TFullSynchronizeInNewWindow FOnFullSynchronizeInNewWindow;
-  void __fastcall SetRemoteDirectory(const UnicodeString value);
-  UnicodeString __fastcall GetRemoteDirectory();
-  void __fastcall SetLocalDirectory(const UnicodeString value);
-  UnicodeString __fastcall GetLocalDirectory();
+  void SetDirectory2(const UnicodeString & value);
+  UnicodeString GetDirectory2();
+  void SetDirectory1(const UnicodeString & value);
+  UnicodeString GetDirectory1();
   void __fastcall SetMode(TSynchronizeMode value);
   TSynchronizeMode __fastcall GetMode();
   void __fastcall SetParams(int value);
@@ -107,8 +107,8 @@ public:
 
   bool __fastcall Execute();
 
-  __property UnicodeString RemoteDirectory = { read = GetRemoteDirectory, write = SetRemoteDirectory };
-  __property UnicodeString LocalDirectory = { read = GetLocalDirectory, write = SetLocalDirectory };
+  __property UnicodeString Directory1 = { read = GetDirectory1, write = SetDirectory1 };
+  __property UnicodeString Directory2 = { read = GetDirectory2, write = SetDirectory2 };
   __property int Params = { read = GetParams, write = SetParams };
   __property TSynchronizeMode Mode = { read = GetMode, write = SetMode };
   __property bool SaveSettings = { read = GetSaveSettings, write = SetSaveSettings };

source/forms/NonVisual.cpp

@@ -435,7 +435,7 @@ void __fastcall TNonVisualDataModule::ExplorerActionsUpdate(
   // COMMAND
   UPD(CompareDirectoriesAction2, HasManagedSession) // Or simply true, as the command is in Commander only and it always has a managed session
   UPD(SynchronizeAction, HasTerminal)
-  UPD(FullSynchronizeAction, HasTerminal)
+  UPD(FullSynchronizeAction2, HasTerminal)
   UPD(ConsoleAction, ScpExplorer->CanConsole())
   UPD(PuttyAction, HasTerminal && TTerminalManager::Instance()->CanOpenInPutty())
   UPD(SynchronizeBrowsingAction2, HasTerminal)
@@ -791,7 +791,7 @@ void __fastcall TNonVisualDataModule::ExplorerActionsExecute(
     // COMMAND
     EXE(CompareDirectoriesAction2, ScpExplorer->CompareDirectories())
     EXE(SynchronizeAction, ScpExplorer->SynchronizeDirectories())
-    EXE(FullSynchronizeAction, ScpExplorer->FullSynchronizeDirectories())
+    EXE(FullSynchronizeAction2, ScpExplorer->FullSynchronizeDirectories())
     EXE(ConsoleAction, ScpExplorer->OpenConsole())
     EXE(PuttyAction, TTerminalManager::Instance()->OpenInPutty())
     EXE(SynchronizeBrowsingAction2, ScpExplorer->SynchronizeBrowsingChanged())

source/forms/NonVisual.dfm

@@ -1501,12 +1501,12 @@ object NonVisualDataModule: TNonVisualDataModule
       HelpKeyword = 'directory_cache'
       Hint = 'Clear directory listing and directory changes caches'
     end
-    object FullSynchronizeAction: TAction
+    object FullSynchronizeAction2: TAction
       Tag = 15
       Category = 'Command'
       Caption = '&Synchronize...'
       HelpKeyword = 'task_synchronize_full'
-      Hint = 'Synchronize local directory with remote directory'
+      Hint = 'Synchronize files between two directories'
       ImageIndex = 66
       ShortCut = 16467
     end

source/forms/NonVisual.h

@@ -197,7 +197,7 @@ __published:    // IDE-managed Components
   TAction *DonatePageAction;
   TAction *FileSystemInfoAction;
   TAction *ClearCachesAction;
-  TAction *FullSynchronizeAction;
+  TAction *FullSynchronizeAction2;
   TAction *RemoteMoveToAction;
   TAction *RemoteMoveToFocusedAction;
   TAction *SelectOneAction;

source/forms/ScpCommander.cpp

@@ -1261,14 +1261,14 @@ void __fastcall TScpCommanderForm::SynchronizeDirectories()
 void __fastcall TScpCommanderForm::FullSynchronizeDirectories()
 {
   DebugAssert(!IsLocalBrowserMode());
-  UnicodeString LocalDirectory = LocalDirView->PathName;
-  UnicodeString RemoteDirectory = RemoteDirView->PathName;
+  UnicodeString Directory1 = LocalDirView->PathName;
+  UnicodeString Directory2 = DirView(osOther)->PathName;
   bool SaveMode = !(GUIConfiguration->SynchronizeModeAuto < 0);
   TSynchronizeMode Mode =
     (SaveMode ? (TSynchronizeMode)GUIConfiguration->SynchronizeModeAuto :
       ((FCurrentSide == osLocal) ? smRemote : smLocal));
   int Params = GUIConfiguration->SynchronizeParams;
-  if (DoFullSynchronizeDirectories(LocalDirectory, RemoteDirectory, Mode, Params, SaveMode, -1) >= 0)
+  if (DoFullSynchronizeDirectories(Directory1, Directory2, Mode, Params, SaveMode, -1) >= 0)
   {
     if (SaveMode)
     {

source/forms/ScpCommander.dfm

@@ -331,7 +331,7 @@ inherited ScpCommanderForm: TScpCommanderForm
           Action = NonVisualDataModule.SynchronizeAction
         end
         object TBXItem44: TTBXItem
-          Action = NonVisualDataModule.FullSynchronizeAction
+          Action = NonVisualDataModule.FullSynchronizeAction2
         end
         object TBXItem45: TTBXItem
           Action = NonVisualDataModule.SynchronizeBrowsingAction2
@@ -1021,7 +1021,7 @@ inherited ScpCommanderForm: TScpCommanderForm
         Action = NonVisualDataModule.SynchronizeAction
       end
       object TBXItem156: TTBXItem
-        Action = NonVisualDataModule.FullSynchronizeAction
+        Action = NonVisualDataModule.FullSynchronizeAction2
         DisplayMode = nbdmImageAndText
       end
       object TBXSeparatorItem41: TTBXSeparatorItem

source/forms/ScpExplorer.dfm

@@ -149,7 +149,7 @@ inherited ScpExplorerForm: TScpExplorerForm
           Action = NonVisualDataModule.SynchronizeAction
         end
         object TBXItem44: TTBXItem
-          Action = NonVisualDataModule.FullSynchronizeAction
+          Action = NonVisualDataModule.FullSynchronizeAction2
         end
         object TBXItem3: TTBXItem
           Action = NonVisualDataModule.RemoteFindFilesAction2
@@ -762,7 +762,7 @@ inherited ScpExplorerForm: TScpExplorerForm
         Action = NonVisualDataModule.SynchronizeAction
       end
       object TBXItem65: TTBXItem
-        Action = NonVisualDataModule.FullSynchronizeAction
+        Action = NonVisualDataModule.FullSynchronizeAction2
         DisplayMode = nbdmImageAndText
       end
     end

source/forms/SynchronizeChecklist.cpp

@@ -14,9 +14,9 @@
 //---------------------------------------------------------------------
 const int ImageColumnIndex = 4;
 //---------------------------------------------------------------------
-bool __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
-  TSynchronizeMode Mode, int Params,
-  const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
+bool DoSynchronizeChecklistDialog(
+  TSynchronizeChecklist * Checklist, TSynchronizeMode Mode, int Params,
+  const UnicodeString & Directory1, const UnicodeString & Directory2,
   TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize,
   TQueueSynchronizeEvent OnQueueSynchronize,
   TSynchronizeChecklistCalculateSize OnSynchronizeChecklistCalculateSize, TSynchronizeMoveEvent OnSynchronizeMove,
@@ -24,14 +24,14 @@ bool __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
 {
   std::unique_ptr<TSynchronizeChecklistDialog> Dialog(
     new TSynchronizeChecklistDialog(
-      Application, Mode, Params, LocalDirectory, RemoteDirectory, OnCustomCommandMenu, OnSynchronize,
+      Application, Mode, Params, Directory1, Directory2, OnCustomCommandMenu, OnSynchronize,
       OnQueueSynchronize, OnSynchronizeChecklistCalculateSize, OnSynchronizeMove, OnSynchronizeExplore, Token));
   return Dialog->Execute(Checklist);
 }
 //---------------------------------------------------------------------
 __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
   TComponent * AOwner, TSynchronizeMode Mode, int Params,
-  const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory,
+  const UnicodeString & Directory1, const UnicodeString & Directory2,
   TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize,
   TQueueSynchronizeEvent OnQueueSynchronize,
   TSynchronizeChecklistCalculateSize OnSynchronizeChecklistCalculateSize, TSynchronizeMoveEvent OnSynchronizeMove,
@@ -41,8 +41,8 @@ __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
   FFormRestored = false;
   FMode = Mode;
   FParams = Params;
-  FLocalDirectory = ExcludeTrailingBackslash(LocalDirectory);
-  FRemoteDirectory = UnixExcludeTrailingBackslash(RemoteDirectory);
+  FDirectory1 = ExcludeTrailingBackslash(Directory1);
+  FDirectory2 = UnixExcludeTrailingBackslash(Directory2);
   FOnCustomCommandMenu = OnCustomCommandMenu;
   FOnSynchronizeChecklistCalculateSize = OnSynchronizeChecklistCalculateSize;
   FOnSynchronizeMove = OnSynchronizeMove;
@@ -53,7 +53,7 @@ __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
   FToken = Token;
   UseSystemSettings(this);
   UseDesktopFont(ListView2);
-  UseDesktopFont(StatusBar);
+  UseDesktopFont(StatusBar2);
   FChecklist = NULL;
   FChangingItem = NULL;
   FChangingItemIgnore = false;
@@ -66,8 +66,8 @@ __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
 
   FOrigListViewWindowProc = ListView2->WindowProc;
   ListView2->WindowProc = ListViewWindowProc;
-  FOrigStatusBarWindowProc = StatusBar->WindowProc;
-  StatusBar->WindowProc = StatusBarWindowProc;
+  FOrigStatusBarWindowProc = StatusBar2->WindowProc;
+  StatusBar2->WindowProc = StatusBarWindowProc;
 
   UpdateImages();
 
@@ -86,7 +86,7 @@ __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
 //---------------------------------------------------------------------
 __fastcall TSynchronizeChecklistDialog::~TSynchronizeChecklistDialog()
 {
-  StatusBar->WindowProc = FOrigStatusBarWindowProc;
+  StatusBar2->WindowProc = FOrigStatusBarWindowProc;
   ListView2->WindowProc = FOrigListViewWindowProc;
 }
 //---------------------------------------------------------------------
@@ -261,7 +261,7 @@ void __fastcall TSynchronizeChecklistDialog::UpdateControls()
 {
   UpdateCaption();
 
-  StatusBar->Invalidate();
+  StatusBar2->Invalidate();
 
   bool AllChecked = true;
   bool AllUnchecked = true;
@@ -408,11 +408,11 @@ void __fastcall TSynchronizeChecklistDialog::LoadItem(TListItem * Item)
   }
   else
   {
-    S = ChecklistItem->Local.Directory;
-    if (AnsiSameText(FLocalDirectory, S.SubString(1, FLocalDirectory.Length())))
+    S = ChecklistItem->Info1.Directory;
+    if (AnsiSameText(FDirectory1, S.SubString(1, FDirectory1.Length())))
     {
       S[1] = L'.';
-      S.Delete(2, FLocalDirectory.Length() - 1);
+      S.Delete(2, FDirectory1.Length() - 1);
     }
     else
     {
@@ -433,11 +433,11 @@ void __fastcall TSynchronizeChecklistDialog::LoadItem(TListItem * Item)
       else
       {
         AddSubItem(Item, Index,
-          FormatPanelBytes(ChecklistItem->Local.Size, WinConfiguration->FormatSizeBytes));
+          FormatPanelBytes(ChecklistItem->Info1.Size, WinConfiguration->FormatSizeBytes));
       }
       AddSubItem(Item, Index,
-        UserModificationStr(ChecklistItem->Local.Modification,
-          ChecklistItem->Local.ModificationFmt));
+        UserModificationStr(ChecklistItem->Info1.Modification,
+          ChecklistItem->Info1.ModificationFmt));
     }
   }
 
@@ -452,11 +452,11 @@ void __fastcall TSynchronizeChecklistDialog::LoadItem(TListItem * Item)
   }
   else
   {
-    S = ChecklistItem->Remote.Directory;
-    if (AnsiSameText(FRemoteDirectory, S.SubString(1, FRemoteDirectory.Length())))
+    S = ChecklistItem->Info2.Directory;
+    if (AnsiSameText(FDirectory2, S.SubString(1, FDirectory2.Length())))
     {
       S[1] = L'.';
-      S.Delete(2, FRemoteDirectory.Length() - 1);
+      S.Delete(2, FDirectory2.Length() - 1);
     }
     else
     {
@@ -477,10 +477,10 @@ void __fastcall TSynchronizeChecklistDialog::LoadItem(TListItem * Item)
       else
       {
         AddSubItem(Item, Index,
-          FormatPanelBytes(ChecklistItem->Remote.Size, WinConfiguration->FormatSizeBytes));
+          FormatPanelBytes(ChecklistItem->Info2.Size, WinConfiguration->FormatSizeBytes));
       }
-      AddSubItem(Item, Index, UserModificationStr(ChecklistItem->Remote.Modification,
-        ChecklistItem->Remote.ModificationFmt));
+      AddSubItem(Item, Index, UserModificationStr(ChecklistItem->Info2.Modification,
+        ChecklistItem->Info2.ModificationFmt));
     }
   }
 }
@@ -705,18 +705,18 @@ void __fastcall TSynchronizeChecklistDialog::StatusBarHintShow(TCMHintShow & Hin
 
   if (IPanel >= 0)
   {
-    TStatusPanel * Panel = StatusBar->Panels->Items[IPanel];
-    HintShow.HintInfo->HintStr = FORMAT(L"%s|%s", (Panel->Text, StatusBar->Hint));
+    TStatusPanel * Panel = StatusBar2->Panels->Items[IPanel];
+    HintShow.HintInfo->HintStr = FORMAT(L"%s|%s", (Panel->Text, StatusBar2->Hint));
 
     HintShow.HintInfo->CursorRect.Left = 0;
     while (IPanel > 0)
     {
       IPanel--;
-      HintShow.HintInfo->CursorRect.Left += StatusBar->Panels->Items[IPanel]->Width;
+      HintShow.HintInfo->CursorRect.Left += StatusBar2->Panels->Items[IPanel]->Width;
     }
 
     HintShow.HintInfo->CursorRect.Top = 0;
-    HintShow.HintInfo->CursorRect.Bottom = StatusBar->ClientHeight;
+    HintShow.HintInfo->CursorRect.Bottom = StatusBar2->ClientHeight;
     HintShow.HintInfo->CursorRect.Right = HintShow.HintInfo->CursorRect.Left + Panel->Width;
 
     HintShow.Result = 0;
@@ -748,7 +748,7 @@ void __fastcall TSynchronizeChecklistDialog::ListView2AdvancedCustomDrawSubItem(
   // this is just fake handler that makes the list view request custom draw notification above
 }
 //---------------------------------------------------------------------------
-void __fastcall TSynchronizeChecklistDialog::StatusBarDrawPanel(
+void __fastcall TSynchronizeChecklistDialog::StatusBar2DrawPanel(
   TStatusBar * StatusBar, TStatusPanel * Panel, const TRect & Rect)
 {
   bool Possible;
@@ -839,20 +839,20 @@ void __fastcall TSynchronizeChecklistDialog::StatusBarDrawPanel(
 int __fastcall TSynchronizeChecklistDialog::PanelCount()
 {
   // last "panel" is technical
-  return StatusBar->Panels->Count - 1;
+  return StatusBar2->Panels->Count - 1;
 }
 //---------------------------------------------------------------------------
 int __fastcall TSynchronizeChecklistDialog::PanelAt(int X)
 {
   int Result = 0;
-  while ((X > StatusBar->Panels->Items[Result]->Width) &&
+  while ((X > StatusBar2->Panels->Items[Result]->Width) &&
     (Result < PanelCount()))
   {
-    X -= StatusBar->Panels->Items[Result]->Width;
+    X -= StatusBar2->Panels->Items[Result]->Width;
     Result++;
   }
 
-  return ((Result < StatusBar->Panels->Count - 1) ? Result : -1);
+  return ((Result < StatusBar2->Panels->Count - 1) ? Result : -1);
 }
 //---------------------------------------------------------------------------
 void __fastcall TSynchronizeChecklistDialog::ListView2Change(
@@ -1015,7 +1015,7 @@ void __fastcall TSynchronizeChecklistDialog::SelectAllActionExecute(
   SelectAll(true);
 }
 //---------------------------------------------------------------------------
-void __fastcall TSynchronizeChecklistDialog::StatusBarMouseDown(
+void __fastcall TSynchronizeChecklistDialog::StatusBar2MouseDown(
   TObject * /*Sender*/, TMouseButton /*Button*/, TShiftState Shift, int X,
   int /*Y*/)
 {
@@ -1059,12 +1059,12 @@ void __fastcall TSynchronizeChecklistDialog::ListView2Compare(
       break;
 
     case 2: // local size
-      Compare = CompareNumber(ChecklistItem1->Local.Size, ChecklistItem2->Local.Size);
+      Compare = CompareNumber(ChecklistItem1->Info1.Size, ChecklistItem2->Info1.Size);
       break;
 
     case 3: // local changed
-      Compare = CompareFileTime(ChecklistItem1->Local.Modification,
-        ChecklistItem2->Local.Modification);
+      Compare = CompareFileTime(ChecklistItem1->Info1.Modification,
+        ChecklistItem2->Info1.Modification);
       break;
 
     case ImageColumnIndex: // action
@@ -1072,12 +1072,12 @@ void __fastcall TSynchronizeChecklistDialog::ListView2Compare(
       break;
 
     case 6: // remote size
-      Compare = CompareNumber(ChecklistItem1->Remote.Size, ChecklistItem2->Remote.Size);
+      Compare = CompareNumber(ChecklistItem1->Info2.Size, ChecklistItem2->Info2.Size);
       break;
 
     case 7: // remote changed
-      Compare = CompareFileTime(ChecklistItem1->Remote.Modification,
-        ChecklistItem2->Remote.Modification);
+      Compare = CompareFileTime(ChecklistItem1->Info2.Modification,
+        ChecklistItem2->Info2.Modification);
       break;
   }
 
@@ -1150,14 +1150,14 @@ void __fastcall TSynchronizeChecklistDialog::CustomCommandsActionExecute(
 //---------------------------------------------------------------------------
 void __fastcall TSynchronizeChecklistDialog::UpdateStatusBarSize()
 {
-  int PanelWidth = Min(StatusBar->Width / PanelCount(), ScaleByTextHeight(this, 160));
+  int PanelWidth = Min(StatusBar2->Width / PanelCount(), ScaleByTextHeight(this, 160));
   for (int Index = 0; Index < PanelCount(); Index++)
   {
-    StatusBar->Panels->Items[Index]->Width = PanelWidth;
+    StatusBar2->Panels->Items[Index]->Width = PanelWidth;
   }
 }
 //---------------------------------------------------------------------------
-void __fastcall TSynchronizeChecklistDialog::StatusBarResize(TObject * /*Sender*/)
+void __fastcall TSynchronizeChecklistDialog::StatusBar2Resize(TObject * /*Sender*/)
 {
   UpdateStatusBarSize();
 }
@@ -1445,12 +1445,12 @@ void __fastcall TSynchronizeChecklistDialog::MoveActionExecute(TObject *)
   if (DeleteAction->Action == TSynchronizeChecklist::saDeleteRemote)
   {
     Side = osRemote;
-    NewFileName = UnixCombinePaths(TransferChecklistItem->Remote.Directory, TransferChecklistItem->Local.FileName);
+    NewFileName = UnixCombinePaths(TransferChecklistItem->Info2.Directory, TransferChecklistItem->Info1.FileName);
   }
   else if (DebugAlwaysTrue(DeleteAction->Action == TSynchronizeChecklist::saDeleteLocal))
   {
     Side = osLocal;
-    NewFileName = CombinePaths(TransferChecklistItem->Local.Directory, TransferChecklistItem->Remote.FileName);
+    NewFileName = CombinePaths(TransferChecklistItem->Info1.Directory, TransferChecklistItem->Info2.FileName);
   }
 
   if (DebugAlwaysTrue(!NewFileName.IsEmpty()))
@@ -1502,7 +1502,7 @@ void __fastcall TSynchronizeChecklistDialog::CheckDirectory(bool Check)
   {
     const TSynchronizeChecklist::TItem * ChecklistItem = GetChecklistItem(Item);
     // It does not matter if we use local or remote directory
-    Directories->Add(IncludeTrailingBackslash(ChecklistItem->Local.Directory));
+    Directories->Add(IncludeTrailingBackslash(ChecklistItem->Info1.Directory));
   }
 
   TAutoFlag ChangingItemMassSwitch(FChangingItemMass);
@@ -1510,7 +1510,7 @@ void __fastcall TSynchronizeChecklistDialog::CheckDirectory(bool Check)
   {
     TListItem * Item = ListView2->Items->Item[Index];
     const TSynchronizeChecklist::TItem * ChecklistItem = GetChecklistItem(Item);
-    UnicodeString Directory = IncludeTrailingBackslash(ChecklistItem->Local.Directory);
+    UnicodeString Directory = IncludeTrailingBackslash(ChecklistItem->Info1.Directory);
     for (int Index2 = 0; Index2 < Directories->Count; Index2++)
     {
       if (StartsText(Directories->Strings[Index2], Directory))
@@ -1699,12 +1699,12 @@ void __fastcall TSynchronizeChecklistDialog::FindMoveCandidateActionExecute(TObj
                 else if ((Action == TSynchronizeChecklist::saDeleteLocal) ||
                          (Action == TSynchronizeChecklist::saDownloadNew))
                 {
-                  IsCandidate = SamePaths(ChecklistItem->Local.Directory, ChecklistItem2->Local.Directory);
+                  IsCandidate = SamePaths(ChecklistItem->Info1.Directory, ChecklistItem2->Info1.Directory);
                 }
                 else if ((Action == TSynchronizeChecklist::saDeleteRemote) ||
                          (Action == TSynchronizeChecklist::saUploadNew))
                 {
-                  IsCandidate = UnixSamePath(ChecklistItem->Remote.Directory, ChecklistItem2->Remote.Directory);
+                  IsCandidate = UnixSamePath(ChecklistItem->Info2.Directory, ChecklistItem2->Info2.Directory);
                 }
                 else
                 {

source/forms/SynchronizeChecklist.dfm

@@ -1563,7 +1563,7 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
     OnSelectItem = ListView2SelectItem
     OnSecondaryColumnHeader = ListView2SecondaryColumnHeader
   end
-  object StatusBar: TStatusBar
+  object StatusBar2: TStatusBar
     Left = 0
     Top = 500
     Width = 695
@@ -1577,32 +1577,32 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
       end
       item
         Style = psOwnerDraw
-        Text = 'New local files'
+        Text = 'New left files'
         Width = 95
       end
       item
         Style = psOwnerDraw
-        Text = 'New remote files'
+        Text = 'New right files'
         Width = 95
       end
       item
         Style = psOwnerDraw
-        Text = 'Updated local files'
+        Text = 'Updated left files'
         Width = 95
       end
       item
         Style = psOwnerDraw
-        Text = 'Updated remote files'
+        Text = 'Updated right files'
         Width = 95
       end
       item
         Style = psOwnerDraw
-        Text = 'Obsolete remote files'
+        Text = 'Obsolete right files'
         Width = 95
       end
       item
         Style = psOwnerDraw
-        Text = 'Obsolete local files'
+        Text = 'Obsolete left files'
         Width = 95
       end
       item
@@ -1610,9 +1610,9 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
       end>
     ParentShowHint = False
     ShowHint = True
-    OnMouseDown = StatusBarMouseDown
-    OnDrawPanel = StatusBarDrawPanel
-    OnResize = StatusBarResize
+    OnMouseDown = StatusBar2MouseDown
+    OnDrawPanel = StatusBar2DrawPanel
+    OnResize = StatusBar2Resize
   end
   object ActionImages: TPngImageList
     PngImages = <
@@ -2111,8 +2111,8 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
       object TMenuItem
       end
     end
-    object LocalDirectory1: TMenuItem
-      Caption = '&Local Directory'
+    object LeftDirectory1: TMenuItem
+      Caption = '&Left Directory'
       object ExploreLocalDirectory1: TMenuItem
         Action = ExploreLocalAction2
       end
@@ -2120,8 +2120,8 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
         Action = LocalPathToClipboardAction
       end
     end
-    object RemoteDirectory1: TMenuItem
-      Caption = '&Remote Directory'
+    object RightDirectory1: TMenuItem
+      Caption = 'Rig&ht Directory'
       object ExploreRemoteDirectory1: TMenuItem
         Action = ExploreRemoteAction2
       end

source/forms/SynchronizeChecklist.h

@@ -24,7 +24,7 @@ class TSynchronizeChecklistDialog : public TForm
 __published:
   TPanel * Panel;
   TIEListView *ListView2;
-  TStatusBar *StatusBar;
+  TStatusBar *StatusBar2;
   TPngImageList *ActionImages;
   TButton *OkButton;
   TButton *CancelButton;
@@ -81,15 +81,15 @@ __published:
   TPopupMenu *OkPopupMenu;
   TMenuItem *StartItem;
   TMenuItem *StartQueueItem;
-  TMenuItem *LocalDirectory1;
-  TMenuItem *RemoteDirectory1;
+  TMenuItem *LeftDirectory1;
+  TMenuItem *RightDirectory1;
   TAction *RemotePathToClipboardAction;
   TMenuItem *CopyPathtoClipboard1;
   TAction *LocalPathToClipboardAction;
   TMenuItem *CopyPathtoClipboard2;
   void __fastcall HelpButtonClick(TObject * Sender);
   void __fastcall FormShow(TObject * Sender);
-  void __fastcall StatusBarDrawPanel(TStatusBar *StatusBar,
+  void __fastcall StatusBar2DrawPanel(TStatusBar *StatusBar,
           TStatusPanel *Panel, const TRect &Rect);
   void __fastcall ListView2Change(TObject *Sender, TListItem *Item,
           TItemChange Change);
@@ -101,7 +101,7 @@ __published:
           bool Selected);
   void __fastcall UpdateTimerTimer(TObject *Sender);
   void __fastcall SelectAllActionExecute(TObject *Sender);
-  void __fastcall StatusBarMouseDown(TObject *Sender, TMouseButton Button,
+  void __fastcall StatusBar2MouseDown(TObject *Sender, TMouseButton Button,
           TShiftState Shift, int X, int Y);
   void __fastcall ListView2Compare(TObject *Sender, TListItem *Item1,
           TListItem *Item2, int Data, int &Compare);
@@ -112,7 +112,7 @@ __published:
   void __fastcall CustomCommandsActionExecute(TObject *Sender);
   void __fastcall ListView2AdvancedCustomDrawSubItem(TCustomListView *Sender, TListItem *Item,
           int SubItem, TCustomDrawState State, TCustomDrawStage Stage, bool &DefaultDraw);
-  void __fastcall StatusBarResize(TObject *Sender);
+  void __fastcall StatusBar2Resize(TObject *Sender);
   void __fastcall UncheckActionExecute(TObject *Sender);
   void __fastcall UncheckAllActionExecute(TObject *Sender);
   void __fastcall ReverseActionExecute(TObject *Sender);
@@ -138,7 +138,7 @@ __published:
 public:
   __fastcall TSynchronizeChecklistDialog(
     TComponent * AOwner, TSynchronizeMode Mode, int Params,
-    const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory,
+    const UnicodeString & Directory1, const UnicodeString & Directory2,
     TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize,
     TQueueSynchronizeEvent OnQueueSynchronize,
     TSynchronizeChecklistCalculateSize OnSynchronizeChecklistCalculateSize, TSynchronizeMoveEvent OnSynchronizeMove,
@@ -152,8 +152,8 @@ protected:
   TSynchronizeChecklist * FChecklist;
   TSynchronizeMode FMode;
   int FParams;
-  UnicodeString FLocalDirectory;
-  UnicodeString FRemoteDirectory;
+  UnicodeString FDirectory1;
+  UnicodeString FDirectory2;
   TWndMethod FOrigListViewWindowProc;
   TWndMethod FOrigStatusBarWindowProc;
   int FTotals[1 + TSynchronizeChecklist::ActionCount];

source/forms/SynchronizeProgress.cpp

@@ -81,11 +81,11 @@ void __fastcall TSynchronizeProgressForm::Start()
 }
 //---------------------------------------------------------------------------
 int __fastcall TSynchronizeProgressForm::SetData(
-  const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory, int Progress, bool & Continue)
+  const UnicodeString & Directory1, const UnicodeString & Directory2, int Progress, bool & Continue)
 {
   DebugAssert(FStarted);
-  LocalDirectoryLabel->Caption = LocalDirectory;
-  RemoteDirectoryLabel->Caption = RemoteDirectory;
+  LeftDirectoryLabel->Caption = Directory1;
+  RightDirectoryLabel->Caption = Directory2;
   OperationProgress->Position = Progress;
   Continue = !FCanceled;
 

source/forms/SynchronizeProgress.dfm

@@ -50,7 +50,7 @@ object SynchronizeProgressForm: TSynchronizeProgressForm
     Caption = 'Remote:'
     ShowAccelChar = False
   end
-  object RemoteDirectoryLabel: TPathLabel
+  object RightDirectoryLabel: TPathLabel
     Left = 141
     Top = 32
     Width = 273
@@ -62,7 +62,7 @@ object SynchronizeProgressForm: TSynchronizeProgressForm
     Anchors = [akLeft, akTop, akRight]
     AutoSize = False
   end
-  object LocalDirectoryLabel: TPathLabel
+  object LeftDirectoryLabel: TPathLabel
     Left = 141
     Top = 14
     Width = 273

source/forms/SynchronizeProgress.h

@@ -23,8 +23,8 @@ class TSynchronizeProgressForm : public TForm
 __published:
   TLabel *Label1;
   TLabel *Label2;
-  TPathLabel *RemoteDirectoryLabel;
-  TPathLabel *LocalDirectoryLabel;
+  TPathLabel *RightDirectoryLabel;
+  TPathLabel *LeftDirectoryLabel;
   TLabel *StartTimeLabel;
   TLabel *StartTimeLabelLabel;
   TLabel *Label3;
@@ -54,7 +54,7 @@ public:
 
   void __fastcall Start();
   int __fastcall SetData(
-    const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory, int Progress, bool & Continue);
+    const UnicodeString & Directory1, const UnicodeString & Directory2, int Progress, bool & Continue);
 
   __property bool Started = { read = FStarted };
 

source/windows/WinInterface.h

@@ -379,10 +379,11 @@ const int fsoDoNotUsePresets =  0x02;
 const int fsoAllowSelectedOnly = 0x04;
 const int fsoDisableByChecksum = 0x08;
 typedef void __fastcall (__closure *TFullSynchronizeInNewWindow)
-  (TSynchronizeMode Mode, int Params, const UnicodeString & LocalDirectory, const UnicodeString & RemoteDirectory,
+  (TSynchronizeMode Mode, int Params, const UnicodeString & Directory1, const UnicodeString & Directory2,
    const TCopyParamType * CopyParams);
-bool __fastcall DoFullSynchronizeDialog(TSynchronizeMode & Mode, int & Params,
-  UnicodeString & LocalDirectory, UnicodeString & RemoteDirectory,
+bool DoFullSynchronizeDialog(
+  TSynchronizeMode & Mode, int & Params,
+  UnicodeString & Directory1, UnicodeString & Directory2,
   TCopyParamType * CopyParams, bool & SaveSettings, bool & SaveMode,
   int Options, const TUsableCopyParamAttrs & CopyParamAttrs,
   TFullSynchronizeInNewWindow OnFullSynchronizeInNewWindow, int AutoSubmit);
@@ -401,9 +402,9 @@ typedef void __fastcall (__closure *TSynchronizeMoveEvent)(
   TOperationSide Side, TStrings * FileList, const UnicodeString & NewFileName, bool TargetIsDirectory, void * Token);
 typedef void __fastcall (__closure *TSynchronizeExploreEvent)(
   TOperationSide Side, TSynchronizeChecklist::TAction Action, const TSynchronizeChecklist::TItem * Item);
-bool __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
-  TSynchronizeMode Mode, int Params,
-  const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
+bool DoSynchronizeChecklistDialog(
+  TSynchronizeChecklist * Checklist, TSynchronizeMode Mode, int Params,
+  const UnicodeString & Directory1, const UnicodeString & Directory2,
   TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize,
   TQueueSynchronizeEvent OnQueueSynchronize,
   TSynchronizeChecklistCalculateSize OnSynchronizeChecklistCalculateSize, TSynchronizeMoveEvent OnSynchronizeMove,