Showing overall synchronization progress on progress window and taskbar (by operations count for now only)

Source commit: ed687a18cea4487d37d881e4d669097b171f2700

source/core/RemoteFiles.cpp

@@ -2899,3 +2899,27 @@ bool __fastcall TSynchronizeChecklist::IsItemSizeIrrelevant(TAction Action)
       return false;
   }
 }
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+TSynchronizeProgress::TSynchronizeProgress(const TSynchronizeChecklist * Checklist)
+{
+  for (int Index = 0; Index < Checklist->Count; Index++)
+  {
+    const TSynchronizeChecklist::TItem * ChecklistItem = Checklist->Item[Index];
+    if (ChecklistItem->Checked)
+    {
+      FItems.insert(std::make_pair(ChecklistItem, TItemData()));
+    }
+  }
+  FItemsProcessed = 0;
+}
+//---------------------------------------------------------------------------
+void TSynchronizeProgress::ItemProcessed(const TSynchronizeChecklist::TItem * /*ChecklistItem*/)
+{
+  FItemsProcessed++;
+}
+//---------------------------------------------------------------------------
+int TSynchronizeProgress::Progress() const
+{
+  return (FItemsProcessed * 100) / FItems.size();
+}

source/core/RemoteFiles.h

@@ -517,6 +517,25 @@ private:
   static int __fastcall Compare(void * Item1, void * Item2);
 };
 //---------------------------------------------------------------------------
+class TSynchronizeProgress
+{
+public:
+  TSynchronizeProgress(const TSynchronizeChecklist * Checklist);
+
+  void ItemProcessed(const TSynchronizeChecklist::TItem * ChecklistItem);
+  int Progress() const;
+
+private:
+  TSynchronizeChecklist * FChecklist;
+  int FItemsProcessed;
+
+  struct TItemData
+  {
+  };
+
+  std::map<const TSynchronizeChecklist::TItem *, TItemData> FItems;
+};
+//---------------------------------------------------------------------------
 bool __fastcall IsUnixStyleWindowsPath(const UnicodeString & Path);
 bool __fastcall UnixIsAbsolutePath(const UnicodeString & Path);
 UnicodeString __fastcall UnixIncludeTrailingBackslash(const UnicodeString Path);

source/core/Script.cpp

@@ -1973,7 +1973,8 @@ void __fastcall TScript::SynchronizeProc(TScriptProcParams * Parameters)
         else
         {
           PrintLine(LoadStr(SCRIPT_SYNCHRONIZE_SYNCHRONIZING));
-          FTerminal->SynchronizeApply(Checklist, &CopyParam, SynchronizeParams, OnTerminalSynchronizeDirectory, NULL, NULL);
+          FTerminal->SynchronizeApply(
+            Checklist, &CopyParam, SynchronizeParams, OnTerminalSynchronizeDirectory, NULL, NULL, NULL);
         }
       }
       else
@@ -2007,7 +2008,8 @@ void __fastcall TScript::Synchronize(const UnicodeString LocalDirectory,
     {
       if (AChecklist->Count > 0)
       {
-        FTerminal->SynchronizeApply(AChecklist, &CopyParam, SynchronizeParams, OnTerminalSynchronizeDirectory, NULL, NULL);
+        FTerminal->SynchronizeApply(
+          AChecklist, &CopyParam, SynchronizeParams, OnTerminalSynchronizeDirectory, NULL, NULL, NULL);
       }
     }
     __finally

source/core/Terminal.cpp

@@ -5873,7 +5873,7 @@ void __fastcall TTerminal::SynchronizeApply(
   TSynchronizeChecklist * Checklist,
   const TCopyParamType * CopyParam, int Params,
   TSynchronizeDirectory OnSynchronizeDirectory, TProcessedSynchronizationChecklistItem OnProcessedItem,
-  TUpdatedSynchronizationChecklistItems OnUpdatedSynchronizationChecklistItems)
+  TUpdatedSynchronizationChecklistItems OnUpdatedSynchronizationChecklistItems, void * Token)
 {
   TSynchronizeData Data;
 
@@ -6006,7 +6006,7 @@ void __fastcall TTerminal::SynchronizeApply(
 
         if (OnProcessedItem != NULL)
         {
-          OnProcessedItem(ChecklistItem);
+          OnProcessedItem(Token, ChecklistItem);
         }
       }
 

source/core/Terminal.h

@@ -57,7 +57,8 @@ typedef void __fastcall (__closure *TSynchronizeDirectory)
    bool & Continue, bool Collect);
 typedef void __fastcall (__closure *TUpdatedSynchronizationChecklistItems)(
   const TSynchronizeChecklist::TItemList & Items);
-typedef void __fastcall (__closure *TProcessedSynchronizationChecklistItem)(const TSynchronizeChecklist::TItem * Item);
+typedef void __fastcall (__closure *TProcessedSynchronizationChecklistItem)(
+  void * Token, const TSynchronizeChecklist::TItem * Item);
 typedef void __fastcall (__closure *TDeleteLocalFileEvent)(
   const UnicodeString FileName, bool Alternative);
 typedef int __fastcall (__closure *TDirectoryModifiedEvent)
@@ -560,7 +561,7 @@ public:
     TSynchronizeChecklist * Checklist,
     const TCopyParamType * CopyParam, int Params,
     TSynchronizeDirectory OnSynchronizeDirectory, TProcessedSynchronizationChecklistItem OnProcessedItem,
-    TUpdatedSynchronizationChecklistItems OnUpdatedSynchronizationChecklistItems);
+    TUpdatedSynchronizationChecklistItems OnUpdatedSynchronizationChecklistItems, void * Token);
   void __fastcall SynchronizeChecklistCalculateSize(
     TSynchronizeChecklist * Checklist, const TSynchronizeChecklist::TItemList & Items,
     const TCopyParamType * CopyParam);

source/forms/CustomScpExplorer.cpp

@@ -829,8 +829,18 @@ void __fastcall TCustomScpExplorerForm::SetTaskbarListProgressValue(TFileOperati
 {
   if (ProgressData->Operation != foCalculateSize)
   {
+    int OverallProgress;
+    if (DebugAlwaysTrue(FProgressForm != NULL) && (FProgressForm->SynchronizeProgress != NULL))
+    {
+      OverallProgress = FProgressForm->SynchronizeProgress->Progress();
+    }
+    else
+    {
+      OverallProgress = ProgressData->OverallProgress();
+    }
+
     // implies TBPF_NORMAL
-    FTaskbarList->SetProgressValue(GetMainForm()->Handle, ProgressData->OverallProgress(), 100);
+    FTaskbarList->SetProgressValue(GetMainForm()->Handle, OverallProgress, 100);
   }
   else
   {
@@ -1346,11 +1356,11 @@ UnicodeString __fastcall TCustomScpExplorerForm::GetToolbarsButtonsStr()
   return Result;
 }
 //---------------------------------------------------------------------------
-void __fastcall TCustomScpExplorerForm::CreateProgressForm(const TSynchronizeChecklist * SynchronizeChecklist)
+void __fastcall TCustomScpExplorerForm::CreateProgressForm(TSynchronizeProgress * SynchronizeProgress)
 {
   DebugAssert(FProgressForm == NULL);
   FProgressForm =
-    new TProgressForm(Application, (FTransferResumeList != NULL), Terminal->IsCapable[fsSkipTransfer], SynchronizeChecklist);
+    new TProgressForm(Application, (FTransferResumeList != NULL), Terminal->IsCapable[fsSkipTransfer], SynchronizeProgress);
 
   FProgressForm->DeleteLocalToRecycleBin =
     (WinConfiguration->DeleteToRecycleBin != FAlternativeDelete);
@@ -1405,7 +1415,7 @@ void __fastcall TCustomScpExplorerForm::FileOperationProgress(
     }
   }
   // operation is finished (or terminated), so we hide progress form
-  else if (!ProgressData.InProgress && (FProgressForm != NULL) && (FProgressForm->SynchronizeChecklist == NULL))
+  else if (!ProgressData.InProgress && (FProgressForm != NULL) && (FProgressForm->SynchronizeProgress == NULL))
   {
     DestroyProgressForm();
 
@@ -1508,13 +1518,13 @@ UnicodeString __fastcall TCustomScpExplorerForm::GetProgressTitle(const TFileOpe
   UnicodeString Result;
   if (ProgressData.InProgress)
   {
-    const TSynchronizeChecklist * SynchronizeChecklist = NULL;
+    TSynchronizeProgress * SynchronizeProgress = NULL;
     if (FProgressForm != NULL)
     {
-      SynchronizeChecklist = FProgressForm->SynchronizeChecklist;
+      SynchronizeProgress = FProgressForm->SynchronizeProgress;
     }
 
-    Result = TProgressForm::ProgressStr(SynchronizeChecklist, &ProgressData);
+    Result = TProgressForm::ProgressStr(SynchronizeProgress, &ProgressData);
   }
   return Result;
 }
@@ -5260,11 +5270,14 @@ void __fastcall TCustomScpExplorerForm::Synchronize(const UnicodeString LocalDir
     AnyOperation = (AChecklist->CheckedCount > 0);
     if (AnyOperation)
     {
-      CreateProgressForm(AChecklist);
+      TSynchronizeProgress SynchronizeProgress(AChecklist);
+      CreateProgressForm(&SynchronizeProgress);
 
       try
       {
-        Terminal->SynchronizeApply(AChecklist, &CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory, NULL, NULL);
+        Terminal->SynchronizeApply(
+          AChecklist, &CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory,
+          SynchronizeProcessedItem, NULL, NULL);
       }
       __finally
       {
@@ -5371,6 +5384,7 @@ struct TSynchronizeParams
   int Params;
   TCopyParamType * CopyParam;
   TDateTime * StartTime;
+  TProcessedSynchronizationChecklistItem OnProcessedItem;
 };
 //---------------------------------------------------------------------------
 void __fastcall TCustomScpExplorerForm::FullSynchronize(
@@ -5384,14 +5398,18 @@ void __fastcall TCustomScpExplorerForm::FullSynchronize(
 
   try
   {
-    CreateProgressForm(Params.Checklist);
+    Params.OnProcessedItem = OnProcessedItem;
+
+    TSynchronizeProgress SynchronizeProgress(Params.Checklist);
+    CreateProgressForm(&SynchronizeProgress);
 
     Terminal->SynchronizeApply(
       Params.Checklist, Params.CopyParam, Params.Params | TTerminal::spNoConfirmation,
-      TerminalSynchronizeDirectory, OnProcessedItem, OnUpdatedSynchronizationChecklistItems);
+      TerminalSynchronizeDirectory, SynchronizeProcessedItem, OnUpdatedSynchronizationChecklistItems, &Params);
   }
   __finally
   {
+    Params.OnProcessedItem = NULL;
     FAutoOperation = false;
     DestroyProgressForm();
     BatchEnd(BatchStorage);
@@ -5399,6 +5417,24 @@ void __fastcall TCustomScpExplorerForm::FullSynchronize(
   }
 }
 //---------------------------------------------------------------------------
+void __fastcall TCustomScpExplorerForm::SynchronizeProcessedItem(void * Token, const TSynchronizeChecklist::TItem * ChecklistItem)
+{
+  if (DebugAlwaysTrue(FProgressForm != NULL) && DebugAlwaysTrue(FProgressForm->SynchronizeProgress != NULL))
+  {
+    FProgressForm->SynchronizeProgress->ItemProcessed(ChecklistItem);
+  }
+
+  // Not set in keep-up-to-date mode - Synchronize() method
+  if (Token != NULL)
+  {
+    TSynchronizeParams & Params = *static_cast<TSynchronizeParams *>(Token);
+    if (Params.OnProcessedItem != NULL)
+    {
+      Params.OnProcessedItem(NULL, ChecklistItem);
+    }
+  }
+}
+//---------------------------------------------------------------------------
 void __fastcall TCustomScpExplorerForm::DoFullSynchronize(
   void * Token, TProcessedSynchronizationChecklistItem OnProcessedItem,
   TUpdatedSynchronizationChecklistItems OnUpdatedSynchronizationChecklistItems)
@@ -5490,6 +5526,7 @@ bool __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
       SynchronizeParams.Params = Params;
       SynchronizeParams.Checklist = Checklist;
       SynchronizeParams.StartTime = &StartTime;
+      SynchronizeParams.OnProcessedItem = NULL;
       if (FLAGSET(Params, TTerminal::spPreviewChanges))
       {
         if (Checklist->Count > 0)

source/forms/CustomScpExplorer.h

@@ -383,7 +383,7 @@ protected:
     TOperationSide Side, bool Temp, const UnicodeString & FileName, bool Success,
     TOnceDoneOperation & OnceDoneOperation);
   virtual void __fastcall DoOpenDirectoryDialog(TOpenDirectoryMode Mode, TOperationSide Side);
-  void __fastcall CreateProgressForm(const TSynchronizeChecklist * SynchronizeChecklist);
+  void __fastcall CreateProgressForm(TSynchronizeProgress * SynchronizeProgress);
   void __fastcall DestroyProgressForm();
   virtual void __fastcall FileOperationProgress(TFileOperationProgressType & ProgressData);
   void __fastcall OperationComplete(const TDateTime & StartTime);
@@ -616,6 +616,7 @@ protected:
   void __fastcall FullSynchronize(
     TSynchronizeParams & Params, TProcessedSynchronizationChecklistItem OnProcessedItem,
     TUpdatedSynchronizationChecklistItems OnUpdatedSynchronizationChecklistItems);
+  void __fastcall SynchronizeProcessedItem(void * Token, const TSynchronizeChecklist::TItem * ChecklistItem);
   void __fastcall CreateOpenDirMenuList(TTBCustomItem * Menu, TOperationSide Side, TBookmarkList * BookmarkList);
   void __fastcall CreateOpenDirMenu(TTBCustomItem * Menu, TOperationSide Side);
 

source/forms/Progress.cpp

@@ -35,7 +35,7 @@ bool __fastcall TProgressForm::IsIndeterminateOperation(TFileOperation Operation
 }
 //---------------------------------------------------------------------
 UnicodeString __fastcall TProgressForm::ProgressStr(
-  const TSynchronizeChecklist * SynchronizeChecklist, const TFileOperationProgressType * ProgressData)
+  const TSynchronizeProgress * SynchronizeProgress, const TFileOperationProgressType * ProgressData)
 {
   static const int Captions[] = { 0, 0, PROGRESS_DELETE,
     PROGRESS_SETPROPERTIES, 0, PROGRESS_CUSTOM_COMAND, PROGRESS_CALCULATE_SIZE,
@@ -53,19 +53,19 @@ UnicodeString __fastcall TProgressForm::ProgressStr(
     DebugAssert(Id != 0);
   }
   UnicodeString Result = LoadStr(Id);
-  if (!IsIndeterminateOperation(ProgressData->Operation))
+  if (SynchronizeProgress != NULL)
   {
-    Result = FORMAT(L"%d%% %s", (ProgressData->OverallProgress(), Result));
+    Result = FORMAT(L"%d%% %s - %s", (SynchronizeProgress->Progress(), LoadStr(SYNCHRONIZE_PROGRESS_SYNCHRONIZE2), Result));
   }
-  if (SynchronizeChecklist != NULL)
+  else if (!IsIndeterminateOperation(ProgressData->Operation))
   {
-    Result = FORMAT(L"%s - %s", (LoadStr(SYNCHRONIZE_PROGRESS_SYNCHRONIZE2), Result));
+    Result = FORMAT(L"%d%% %s", (ProgressData->OverallProgress(), Result));
   }
   return Result;
 }
 //---------------------------------------------------------------------
 __fastcall TProgressForm::TProgressForm(
-  TComponent * AOwner, bool AllowMoveToQueue, bool AllowSkip, const TSynchronizeChecklist * SynchronizeChecklist)
+  TComponent * AOwner, bool AllowMoveToQueue, bool AllowSkip, TSynchronizeProgress * SynchronizeProgress)
     : FData(), TForm(AOwner)
 {
   FLastOperation = foNone;
@@ -85,7 +85,7 @@ __fastcall TProgressForm::TProgressForm(
   FModalBeginHooked = false;
   FModalLevel = -1;
   FPendingSkip = false;
-  FSynchronizeChecklist = SynchronizeChecklist;
+  FSynchronizeProgress = SynchronizeProgress;
   FAllowSkip = AllowSkip;
   UseSystemSettings(this);
 
@@ -212,7 +212,7 @@ void __fastcall TProgressForm::UpdateControls()
 
     OperationProgress->Style = IsIndeterminateOperation(FData.Operation) ? pbstMarquee : pbstNormal;
 
-    if (FSynchronizeChecklist != NULL)
+    if (SynchronizeProgress != NULL)
     {
       Animation = L"SynchronizeDirectories";
     }
@@ -277,10 +277,26 @@ void __fastcall TProgressForm::UpdateControls()
     FileLabel->Caption = FileCaption;
     FPendingSkip = false;
   }
-  int OverallProgress = FData.OverallProgress();
-  OperationProgress->Position = OverallProgress;
-  OperationProgress->Hint = IsIndeterminateOperation(FData.Operation) ? UnicodeString() : FORMAT(L"%d%%", (OverallProgress));
-  Caption = FormatFormCaption(this, ProgressStr(FSynchronizeChecklist, &FData));
+
+  int OverallProgress;
+  if (SynchronizeProgress != NULL)
+  {
+    OverallProgress = SynchronizeProgress->Progress();
+  }
+  else
+  {
+    if (IsIndeterminateOperation(FData.Operation))
+    {
+      OverallProgress = -1;
+    }
+    else
+    {
+      OverallProgress = FData.OverallProgress();
+    }
+  }
+  OperationProgress->Position = std::max(0, OverallProgress);
+  OperationProgress->Hint = (OverallProgress < 0) ? UnicodeString() : FORMAT(L"%d%%", (OverallProgress));
+  Caption = FormatFormCaption(this, ProgressStr(SynchronizeProgress, &FData));
 
   if (TransferOperation)
   {

source/forms/Progress.h

@@ -111,7 +111,7 @@ private:
   typedef BiDiMap<TOnceDoneOperation, TTBCustomItem *> TOnceDoneItems;
   TOnceDoneItems FOnceDoneItems;
   bool FAllowSkip;
-  const TSynchronizeChecklist * FSynchronizeChecklist;
+  TSynchronizeProgress * FSynchronizeProgress;
 
   void __fastcall SetOnceDoneOperation(TOnceDoneOperation value);
   TTBCustomItem * __fastcall CurrentOnceDoneItem();
@@ -137,10 +137,10 @@ protected:
 
 public:
   static UnicodeString __fastcall ProgressStr(
-    const TSynchronizeChecklist * SynchronizeChecklist, const TFileOperationProgressType * ProgressData);
+    const TSynchronizeProgress * SynchronizeProgress, const TFileOperationProgressType * ProgressData);
 
   virtual __fastcall TProgressForm(
-    TComponent * AOwner, bool AllowMoveToQueue, bool AllowSkip, const TSynchronizeChecklist * SynchronizeChecklist);
+    TComponent * AOwner, bool AllowMoveToQueue, bool AllowSkip, TSynchronizeProgress * SynchronizeProgress);
   virtual __fastcall ~TProgressForm();
   void __fastcall SetProgressData(TFileOperationProgressType & AData);
   void __fastcall ClearCancel();
@@ -151,7 +151,7 @@ public:
   __property bool DeleteLocalToRecycleBin = { read=FDeleteLocalToRecycleBin, write=FDeleteLocalToRecycleBin };
   __property bool DeleteRemoteToRecycleBin = { read=FDeleteRemoteToRecycleBin, write=FDeleteRemoteToRecycleBin };
   __property bool ReadOnly = { read=FReadOnly, write=SetReadOnly };
-  __property const TSynchronizeChecklist * SynchronizeChecklist = { read = FSynchronizeChecklist };
+  __property TSynchronizeProgress * SynchronizeProgress = { read = FSynchronizeProgress };
 };
 //----------------------------------------------------------------------------
 #endif

source/forms/SynchronizeChecklist.cpp

@@ -1055,7 +1055,7 @@ void __fastcall TSynchronizeChecklistDialog::CMDpiChanged(TMessage & Message)
   UpdateImages();
 }
 //---------------------------------------------------------------------------
-void __fastcall TSynchronizeChecklistDialog::ProcessedItem(const TSynchronizeChecklist::TItem * ChecklistItem)
+void __fastcall TSynchronizeChecklistDialog::ProcessedItem(void * /*Token*/, const TSynchronizeChecklist::TItem * ChecklistItem)
 {
   TListItem * Item = FChecklistToListViewMap[ChecklistItem];
   DebugAssert(Item->Checked);

source/forms/SynchronizeChecklist.h

@@ -147,7 +147,7 @@ protected:
   void __fastcall UpdateImages();
   void __fastcall CMDpiChanged(TMessage & Message);
   bool __fastcall GetWindowParams(UnicodeString & WindowParams);
-  void __fastcall ProcessedItem(const TSynchronizeChecklist::TItem * ChecklistItem);
+  void __fastcall ProcessedItem(void * Token, const TSynchronizeChecklist::TItem * ChecklistItem);
   void __fastcall UpdatedSynchronizationChecklistItems(const TSynchronizeChecklist::TItemList & Items);
   void __fastcall CountItemSize(const TSynchronizeChecklist::TItem * ChecklistItem, int Factor);
   void __fastcall CountItem(const TSynchronizeChecklist::TItem * ChecklistItem, int Factor);