Typo in identifier name

Source commit: 5475cc676e9ba774bce3a0ce2db540b228e88c20

source/core/FileOperationProgress.cpp

@@ -51,7 +51,7 @@ void __fastcall TFileOperationProgressType::Clear()
   FSuspendTime = 0;
   FInProgress = false;
   FFileInProgress = false;
-  FTotalTransfered = 0;
+  FTotalTransferred = 0;
   FTotalSkipped = 0;
   FTotalSize = 0;
   FSkippedSize = 0;
@@ -71,16 +71,16 @@ void __fastcall TFileOperationProgressType::Clear()
 //---------------------------------------------------------------------------
 void __fastcall TFileOperationProgressType::ClearTransfer()
 {
-  if ((TransferSize > 0) && (TransferedSize < TransferSize))
+  if ((TransferSize > 0) && (TransferredSize < TransferSize))
   {
-    __int64 RemainingSize = (TransferSize - TransferedSize);
+    __int64 RemainingSize = (TransferSize - TransferredSize);
     FTotalSkipped += RemainingSize;
   }
   FLocalSize = 0;
   FTransferSize = 0;
   FLocallyUsed = 0;
   FSkippedSize = 0;
-  FTransferedSize = 0;
+  FTransferredSize = 0;
   FTransferingFile = false;
   FLastSecond = 0;
 }
@@ -169,7 +169,7 @@ int __fastcall TFileOperationProgressType::TransferProgress()
   int Result;
   if (TransferSize)
   {
-    Result = (int)((TransferedSize * 100)/TransferSize);
+    Result = (int)((TransferredSize * 100)/TransferSize);
   }
   else
   {
@@ -181,7 +181,7 @@ int __fastcall TFileOperationProgressType::TransferProgress()
 int __fastcall TFileOperationProgressType::TotalTransferProgress()
 {
   DebugAssert(TotalSizeSet);
-  int Result = TotalSize > 0 ? (int)(((TotalTransfered + TotalSkipped) * 100)/TotalSize) : 0;
+  int Result = TotalSize > 0 ? (int)(((TotalTransferred + TotalSkipped) * 100)/TotalSize) : 0;
   return Result < 100 ? Result : 100;
 }
 //---------------------------------------------------------------------------
@@ -408,44 +408,44 @@ void __fastcall TFileOperationProgressType::ChangeTransferSize(__int64 ASize)
 //---------------------------------------------------------------------------
 void __fastcall TFileOperationProgressType::RollbackTransfer()
 {
-  FTransferedSize -= SkippedSize;
-  DebugAssert(TransferedSize <= TotalTransfered);
-  FTotalTransfered -= TransferedSize;
+  FTransferredSize -= SkippedSize;
+  DebugAssert(TransferredSize <= TotalTransferred);
+  FTotalTransferred -= TransferredSize;
   DebugAssert(SkippedSize <= TotalSkipped);
   FTicks.clear();
   FTotalTransferredThen.clear();
   FTotalSkipped -= SkippedSize;
   FSkippedSize = 0;
-  FTransferedSize = 0;
+  FTransferredSize = 0;
   FTransferSize = 0;
   FLocallyUsed = 0;
 }
 //---------------------------------------------------------------------------
-void __fastcall TFileOperationProgressType::AddTransfered(__int64 ASize,
+void __fastcall TFileOperationProgressType::AddTransferred(__int64 ASize,
   bool AddToTotals)
 {
-  FTransferedSize += ASize;
-  if (TransferedSize > TransferSize)
+  FTransferredSize += ASize;
+  if (TransferredSize > TransferSize)
   {
     // this can happen with SFTP when downloading file that
     // grows while being downloaded
     if (TotalSizeSet)
     {
       // we should probably guard this with AddToTotals
-      FTotalSize += (TransferedSize - TransferSize);
+      FTotalSize += (TransferredSize - TransferSize);
     }
-    FTransferSize = TransferedSize;
+    FTransferSize = TransferredSize;
   }
   if (AddToTotals)
   {
-    FTotalTransfered += ASize;
+    FTotalTransferred += ASize;
     unsigned long Ticks = GetTickCount();
     if (FTicks.empty() ||
         (FTicks.back() > Ticks) || // ticks wrap after 49.7 days
         ((Ticks - FTicks.back()) >= MSecsPerSec))
     {
       FTicks.push_back(Ticks);
-      FTotalTransferredThen.push_back(TotalTransfered);
+      FTotalTransferredThen.push_back(TotalTransferred);
     }
 
     if (FTicks.size() > 10)
@@ -461,7 +461,7 @@ void __fastcall TFileOperationProgressType::AddResumed(__int64 ASize)
 {
   FTotalSkipped += ASize;
   FSkippedSize += ASize;
-  AddTransfered(ASize, false);
+  AddTransferred(ASize, false);
   AddLocallyUsed(ASize);
 }
 //---------------------------------------------------------------------------
@@ -474,9 +474,9 @@ void __fastcall TFileOperationProgressType::AddSkippedFileSize(__int64 ASize)
 unsigned long __fastcall TFileOperationProgressType::TransferBlockSize()
 {
   unsigned long Result = TRANSFER_BUF_SIZE;
-  if (TransferedSize + Result > TransferSize)
+  if (TransferredSize + Result > TransferSize)
   {
-    Result = (unsigned long)(TransferSize - TransferedSize);
+    Result = (unsigned long)(TransferSize - TransferredSize);
   }
   Result = AdjustToCPSLimit(Result);
   return Result;
@@ -489,8 +489,8 @@ unsigned long __fastcall TFileOperationProgressType::StaticBlockSize()
 //---------------------------------------------------------------------------
 bool __fastcall TFileOperationProgressType::IsTransferDone()
 {
-  DebugAssert(TransferedSize <= TransferSize);
-  return (TransferedSize == TransferSize);
+  DebugAssert(TransferredSize <= TransferSize);
+  return (TransferredSize == TransferSize);
 }
 //---------------------------------------------------------------------------
 void __fastcall TFileOperationProgressType::SetAsciiTransfer(bool AAsciiTransfer)
@@ -531,7 +531,7 @@ unsigned int __fastcall TFileOperationProgressType::CPS()
     }
     else
     {
-      __int64 Transferred = (TotalTransfered - FTotalTransferredThen.front());
+      __int64 Transferred = (TotalTransferred - FTotalTransferredThen.front());
       Result = (unsigned int)(Transferred * MSecsPerSec / TimeSpan);
     }
   }
@@ -543,7 +543,7 @@ TDateTime __fastcall TFileOperationProgressType::TimeExpected()
   unsigned int CurCps = CPS();
   if (CurCps)
   {
-    return TDateTime((double)(((double)(TransferSize - TransferedSize)) / CurCps) / SecsPerDay);
+    return TDateTime((double)(((double)(TransferSize - TransferredSize)) / CurCps) / SecsPerDay);
   }
   else
   {
@@ -572,9 +572,9 @@ TDateTime __fastcall TFileOperationProgressType::TotalTimeLeft()
   DebugAssert(TotalSizeSet);
   unsigned int CurCps = CPS();
   // sanity check
-  if ((CurCps > 0) && (TotalSize > TotalSkipped + TotalTransfered))
+  if ((CurCps > 0) && (TotalSize > TotalSkipped + TotalTransferred))
   {
-    return TDateTime((double)((double)(TotalSize - TotalSkipped - TotalTransfered) / CurCps) /
+    return TDateTime((double)((double)(TotalSize - TotalSkipped - TotalTransferred) / CurCps) /
       SecsPerDay);
   }
   else

source/core/FileOperationProgress.h

@@ -34,14 +34,14 @@ private:
   __int64 FLocalSize;
   __int64 FLocallyUsed;
   __int64 FTransferSize;
-  __int64 FTransferedSize;
+  __int64 FTransferredSize;
   __int64 FSkippedSize;
   bool FInProgress;
   bool FFileInProgress;
   TCancelStatus FCancel;
   int FCount;
   TDateTime FStartTime;
-  __int64 FTotalTransfered;
+  __int64 FTotalTransferred;
   __int64 FTotalSkipped;
   __int64 FTotalSize;
   TBatchOverwrite FBatchOverwrite;
@@ -52,7 +52,7 @@ private:
 
   // when it was last time suspended (to calculate suspend time in Resume())
   unsigned int FSuspendTime;
-  // when current file was started being transfered
+  // when current file was started being transferred
   TDateTime FFileStartTime;
   int FFilesFinished;
   TFileOperationProgressEvent FOnProgress;
@@ -86,7 +86,7 @@ public:
   __property __int64 LocalSize = { read = FLocalSize };
   __property __int64 LocallyUsed = { read = FLocallyUsed };
   __property __int64 TransferSize = { read = FTransferSize };
-  __property __int64 TransferedSize = { read = FTransferedSize };
+  __property __int64 TransferredSize = { read = FTransferredSize };
   __property __int64 SkippedSize = { read = FSkippedSize };
   __property bool InProgress = { read = FInProgress };
   __property bool FileInProgress = { read = FFileInProgress };
@@ -94,8 +94,8 @@ public:
   __property int Count = { read = FCount };
   // when operation started
   __property TDateTime StartTime = { read = FStartTime };
-  // bytes transfered
-  __property __int64 TotalTransfered = { read = FTotalTransfered };
+  // bytes transferred
+  __property __int64 TotalTransferred = { read = FTotalTransferred };
   __property __int64 TotalSkipped = { read = FTotalSkipped };
   __property __int64 TotalSize = { read = FTotalSize };
 
@@ -113,7 +113,7 @@ public:
   __fastcall ~TFileOperationProgressType();
   void __fastcall AssignButKeepSuspendState(const TFileOperationProgressType & Other);
   void __fastcall AddLocallyUsed(__int64 ASize);
-  void __fastcall AddTransfered(__int64 ASize, bool AddToTotals = true);
+  void __fastcall AddTransferred(__int64 ASize, bool AddToTotals = true);
   void __fastcall AddResumed(__int64 ASize);
   void __fastcall AddSkippedFileSize(__int64 ASize);
   void __fastcall Clear();

source/core/FtpFileSystem.cpp

@@ -1440,10 +1440,10 @@ void __fastcall TFTPFileSystem::DoFileTransferProgress(__int64 TransferSize,
     FFileTransferResumed = 0;
   }
 
-  __int64 Diff = Bytes - OperationProgress->TransferedSize;
+  __int64 Diff = Bytes - OperationProgress->TransferredSize;
   if (DebugAlwaysTrue(Diff >= 0))
   {
-    OperationProgress->AddTransfered(Diff);
+    OperationProgress->AddTransferred(Diff);
     FFileTransferAny = true;
   }
 

source/core/Queue.cpp

@@ -1714,7 +1714,7 @@ __int64 __fastcall TQueueItemProxy::GetTotalTransferred()
   // for which GetProgressData() is NULL
   return
     (FProgressData->Operation == Info->Operation) || (Status == TQueueItem::qsDone) ?
-      FProgressData->TotalTransfered : -1;
+      FProgressData->TotalTransferred : -1;
 }
 //---------------------------------------------------------------------------
 bool __fastcall TQueueItemProxy::Update()

source/core/ScpFileSystem.cpp

@@ -1869,9 +1869,9 @@ void __fastcall TSCPFileSystem::SCPSource(const UnicodeString FileName,
               {
                 unsigned long BlockSize = OperationProgress->TransferBlockSize();
                 FSecureShell->Send(
-                  reinterpret_cast<unsigned char *>(AsciiBuf.Data + (unsigned int)OperationProgress->TransferedSize),
+                  reinterpret_cast<unsigned char *>(AsciiBuf.Data + (unsigned int)OperationProgress->TransferredSize),
                   BlockSize);
-                OperationProgress->AddTransfered(BlockSize);
+                OperationProgress->AddTransferred(BlockSize);
                 if (OperationProgress->Cancel == csCancelTransfer)
                 {
                   throw Exception(MainInstructions(LoadStr(USER_TERMINATED)));
@@ -1883,7 +1883,7 @@ void __fastcall TSCPFileSystem::SCPSource(const UnicodeString FileName,
           // At end of BINARY transfer pass, send current block
           if (!OperationProgress->AsciiTransfer)
           {
-            if (!OperationProgress->TransferedSize)
+            if (!OperationProgress->TransferredSize)
             {
               FTerminal->LogEvent(FORMAT(L"Sending BINARY data (first block, %u bytes)",
                 (BlockBuf.Size)));
@@ -1894,7 +1894,7 @@ void __fastcall TSCPFileSystem::SCPSource(const UnicodeString FileName,
                 (BlockBuf.Size)));
             }
             FSecureShell->Send(reinterpret_cast<const unsigned char *>(BlockBuf.Data), BlockBuf.Size);
-            OperationProgress->AddTransfered(BlockBuf.Size);
+            OperationProgress->AddTransferred(BlockBuf.Size);
           }
 
           if ((OperationProgress->Cancel == csCancelTransfer) ||
@@ -2574,7 +2574,7 @@ void __fastcall TSCPFileSystem::SCPSink(const UnicodeString TargetDir,
                   BlockBuf.Position = 0;
 
                   FSecureShell->Receive(reinterpret_cast<unsigned char *>(BlockBuf.Data), BlockBuf.Size);
-                  OperationProgress->AddTransfered(BlockBuf.Size);
+                  OperationProgress->AddTransferred(BlockBuf.Size);
 
                   if (OperationProgress->AsciiTransfer)
                   {

source/core/Script.cpp

@@ -2265,19 +2265,19 @@ void __fastcall TManagementScript::TerminalOperationProgress(
         {
           FileName = ProgressFileName;
         }
-        UnicodeString TransferedSizeStr;
-        if (ProgressData.TransferedSize < 1024)
+        UnicodeString TransferredSizeStr;
+        if (ProgressData.TransferredSize < 1024)
         {
-          TransferedSizeStr = FORMAT("%d B", (static_cast<int>(ProgressData.TransferedSize)));
+          TransferredSizeStr = FORMAT("%d B", (static_cast<int>(ProgressData.TransferredSize)));
         }
         else
         {
-          TransferedSizeStr = FORMAT("%d KB", (static_cast<int>(ProgressData.TransferedSize / 1024)));
+          TransferredSizeStr = FORMAT("%d KB", (static_cast<int>(ProgressData.TransferredSize / 1024)));
         }
 
         UnicodeString ProgressMessage = FORMAT(L"%-*s | %14s | %6.1f KB/s | %-6.6s | %3d%%",
           (WidthFileName, FileName,
-           TransferedSizeStr,
+           TransferredSizeStr,
            static_cast<float>(ProgressData.CPS()) / 1024,
            ProgressData.AsciiTransfer ? L"ascii" : L"binary",
            ProgressData.TransferProgress()));

source/core/SftpFileSystem.cpp

@@ -1446,11 +1446,11 @@ public:
   }
   virtual __fastcall ~TSFTPDownloadQueue(){}
 
-  bool __fastcall Init(int QueueLen, const RawByteString & AHandle,__int64 ATransfered,
+  bool __fastcall Init(int QueueLen, const RawByteString & AHandle,__int64 ATransferred,
     TFileOperationProgressType * AOperationProgress)
   {
     FHandle = AHandle;
-    FTransfered = ATransfered;
+    FTransferred = ATransferred;
     OperationProgress = AOperationProgress;
 
     return TSFTPFixedLenQueue::Init(QueueLen);
@@ -1474,9 +1474,9 @@ protected:
   virtual bool __fastcall InitRequest(TSFTPQueuePacket * Request)
   {
     unsigned int BlockSize = FFileSystem->DownloadBlockSize(OperationProgress);
-    InitRequest(Request, FTransfered, BlockSize);
+    InitRequest(Request, FTransferred, BlockSize);
     Request->Token = reinterpret_cast<void*>(BlockSize);
-    FTransfered += BlockSize;
+    FTransferred += BlockSize;
     return true;
   }
 
@@ -1496,7 +1496,7 @@ protected:
 
 private:
   TFileOperationProgressType * OperationProgress;
-  __int64 FTransfered;
+  __int64 FTransferred;
   RawByteString FHandle;
 };
 //---------------------------------------------------------------------------
@@ -1520,14 +1520,14 @@ public:
 
   bool __fastcall Init(const UnicodeString AFileName,
     HANDLE AFile, TFileOperationProgressType * AOperationProgress,
-    const RawByteString AHandle, __int64 ATransfered,
+    const RawByteString AHandle, __int64 ATransferred,
     int ConvertParams)
   {
     FFileName = AFileName;
     FStream = new TSafeHandleStream((THandle)AFile);
     OperationProgress = AOperationProgress;
     FHandle = AHandle;
-    FTransfered = ATransfered;
+    FTransferred = ATransferred;
     FConvertParams = ConvertParams;
 
     return TSFTPAsynchronousQueue::Init();
@@ -1571,16 +1571,16 @@ protected:
         if (FFileSystem->FTerminal->Configuration->ActualLogProtocol >= 1)
         {
           FFileSystem->FTerminal->LogEvent(FORMAT(L"Write request offset: %d, len: %d",
-            (int(FTransfered), int(BlockBuf.Size))));
+            (int(FTransferred), int(BlockBuf.Size))));
         }
 
         Request->ChangeType(SSH_FXP_WRITE);
         Request->AddString(FHandle);
-        Request->AddInt64(FTransfered);
+        Request->AddInt64(FTransferred);
         Request->AddData(BlockBuf.Data, BlockBuf.Size);
         FLastBlockSize = BlockBuf.Size;
 
-        FTransfered += BlockBuf.Size;
+        FTransferred += BlockBuf.Size;
       }
     }
 
@@ -1590,7 +1590,7 @@ protected:
   virtual void __fastcall SendPacket(TSFTPQueuePacket * Packet)
   {
     TSFTPAsynchronousQueue::SendPacket(Packet);
-    OperationProgress->AddTransfered(FLastBlockSize);
+    OperationProgress->AddTransferred(FLastBlockSize);
   }
 
   virtual void __fastcall ReceiveResponse(
@@ -1644,7 +1644,7 @@ private:
   UnicodeString FFileName;
   unsigned long FLastBlockSize;
   bool FEnd;
-  __int64 FTransfered;
+  __int64 FTransferred;
   RawByteString FHandle;
   bool FConvertToken;
   int FConvertParams;
@@ -4682,7 +4682,7 @@ void __fastcall TSFTPFileSystem::SFTPSource(const UnicodeString FileName,
 
           if (ResumeAllowed)
           {
-            FTerminal->LogEvent(L"Checking existence of partially transfered file.");
+            FTerminal->LogEvent(L"Checking existence of partially transferred file.");
             if (RemoteFileExists(DestPartialFullName, &File))
             {
               ResumeOffset = File->Size;
@@ -4823,7 +4823,7 @@ void __fastcall TSFTPFileSystem::SFTPSource(const UnicodeString FileName,
             FLAGMASK(CopyParam->RemoveBOM, cpRemoveBOM);
           Queue.Init(FileName, File, OperationProgress,
             OpenParams.RemoteFileHandle,
-            DestWriteOffset + OperationProgress->TransferedSize,
+            DestWriteOffset + OperationProgress->TransferredSize,
             ConvertParams);
 
           while (Queue.Continue())
@@ -5674,10 +5674,10 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
         DestPartialFullName = DestFullName + FTerminal->Configuration->PartialExt;
         LocalFileName = DestPartialFullName;
 
-        FTerminal->LogEvent(L"Checking existence of partially transfered file.");
+        FTerminal->LogEvent(L"Checking existence of partially transferred file.");
         if (FileExists(ApiPath(DestPartialFullName)))
         {
-          FTerminal->LogEvent(L"Partially transfered file exists.");
+          FTerminal->LogEvent(L"Partially transferred file exists.");
           FTerminal->OpenLocalFile(DestPartialFullName, GENERIC_WRITE,
             NULL, &LocalHandle, NULL, NULL, NULL, &ResumeOffset);
 
@@ -5692,7 +5692,7 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
             ResumeTransfer = !PartialBiggerThanSource;
             if (!ResumeTransfer)
             {
-              FTerminal->LogEvent(L"Partially transfered file is bigger that original file.");
+              FTerminal->LogEvent(L"Partially transferred file is bigger that original file.");
             }
           }
 
@@ -5873,7 +5873,7 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
           {
             QueueLen = 1;
           }
-          Queue.Init(QueueLen, RemoteHandle, OperationProgress->TransferedSize,
+          Queue.Init(QueueLen, RemoteHandle, OperationProgress->TransferredSize,
             OperationProgress);
 
           bool Eof = false;
@@ -5889,7 +5889,7 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
           {
             if (Missing > 0)
             {
-              Queue.InitFillGapRequest(OperationProgress->TransferedSize, Missing,
+              Queue.InitFillGapRequest(OperationProgress->TransferredSize, Missing,
                 &DataPacket);
               GapFillCount++;
               SendPacketAndReceiveResponse(&DataPacket, &DataPacket,
@@ -5923,7 +5923,7 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
                 FTerminal->LogEvent(FORMAT(
                   L"Received incomplete data packet before end of file, "
                    "offset: %s, size: %d, requested: %d",
-                  (IntToStr(OperationProgress->TransferedSize), int(DataLen),
+                  (IntToStr(OperationProgress->TransferredSize), int(DataLen),
                   int(BlockSize))));
                 FTerminal->TerminalError(NULL, LoadStr(SFTP_INCOMPLETE_BEFORE_EOF));
               }
@@ -5941,7 +5941,7 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
               }
               else if (DataLen < BlockSize)
               {
-                if (OperationProgress->TransferedSize + DataLen !=
+                if (OperationProgress->TransferredSize + DataLen !=
                       OperationProgress->TransferSize)
                 {
                   // with native text transfer mode (SFTP>=4), do not bother about
@@ -5961,7 +5961,7 @@ void __fastcall TSFTPFileSystem::SFTPSink(const UnicodeString FileName,
               DebugAssert(DataLen <= BlockSize);
               BlockBuf.Insert(0, reinterpret_cast<const char *>(DataPacket.GetNextData(DataLen)), DataLen);
               DataPacket.DataConsumed(DataLen);
-              OperationProgress->AddTransfered(DataLen);
+              OperationProgress->AddTransferred(DataLen);
 
               if ((FVersion >= 6) && DataPacket.CanGetBool() && (Missing == 0))
               {

source/core/Terminal.cpp

@@ -2821,7 +2821,7 @@ void __fastcall TTerminal::LogFileDone(TFileOperationProgressType * OperationPro
   // optimization
   if (Log->Logging)
   {
-    LogEvent(FORMAT("Transfer done: '%s' [%s]", (OperationProgress->FullFileName, IntToStr(OperationProgress->TransferedSize))));
+    LogEvent(FORMAT("Transfer done: '%s' [%s]", (OperationProgress->FullFileName, IntToStr(OperationProgress->TransferredSize))));
   }
 }
 //---------------------------------------------------------------------------

source/core/WebDAVFileSystem.cpp

@@ -2598,7 +2598,7 @@ void TWebDAVFileSystem::NeonNotifier(void * UserData, ne_session_status Status,
       DebugAlwaysTrue(OperationProgress != NULL))
   {
     __int64 Progress = StatusInfo->sr.progress;
-    __int64 Diff = Progress - OperationProgress->TransferedSize;
+    __int64 Diff = Progress - OperationProgress->TransferredSize;
 
     if (Diff > 0)
     {
@@ -2612,18 +2612,18 @@ void TWebDAVFileSystem::NeonNotifier(void * UserData, ne_session_status Status,
     {
       if (Diff >= 0)
       {
-        OperationProgress->AddTransfered(Diff);
+        OperationProgress->AddTransferred(Diff);
       }
       else
       {
         // Session total has been reset. A new stream started
-        OperationProgress->AddTransfered(Progress);
+        OperationProgress->AddTransferred(Progress);
       }
     }
     else
     {
       OperationProgress->SetTransferSize(Total);
-      OperationProgress->AddTransfered(Diff);
+      OperationProgress->AddTransferred(Diff);
     }
   }
 }

source/forms/Progress.cpp

@@ -294,7 +294,7 @@ void __fastcall TProgressForm::UpdateControls()
         FData.TotalTimeLeft());
     }
     TimeElapsedLabel->Caption = FormatDateTimeSpan(Configuration->TimeFormat, FData.TimeElapsed());
-    BytesTransferedLabel->Caption = FormatBytes(FData.TotalTransfered);
+    BytesTransferredLabel->Caption = FormatBytes(FData.TotalTransferred);
     CPSLabel->Caption = FORMAT(L"%s/s", (FormatBytes(FData.CPS())));
     FFileProgress->Position = FData.TransferProgress();
     FFileProgress->Hint = FORMAT(L"%d%%", (FFileProgress->Position));

source/forms/Progress.dfm

@@ -142,7 +142,7 @@ object ProgressForm: TProgressForm
       AutoSize = False
       Caption = '00:00:00'
     end
-    object BytesTransferedLabel: TLabel
+    object BytesTransferredLabel: TLabel
       Left = 88
       Top = 18
       Width = 65

source/forms/Progress.h

@@ -40,7 +40,7 @@ __published:
   TLabel *StartTimeLabelLabel;
   TLabel *StartTimeLabel;
   TLabel *Label4;
-  TLabel *BytesTransferedLabel;
+  TLabel *BytesTransferredLabel;
   TLabel *Label12;
   TLabel *CPSLabel;
   TProgressBar *BottomProgress;

source/windows/QueueController.cpp

@@ -416,7 +416,7 @@ void __fastcall TQueueController::FillQueueViewItem(TListItem * Item,
       if (ProgressData->Operation == Info->Operation)
       {
         Values[2] =
-          FormatPanelBytes(ProgressData->TransferedSize, WinConfiguration->FormatSizeBytes);
+          FormatPanelBytes(ProgressData->TransferredSize, WinConfiguration->FormatSizeBytes);
         Values[5] = FORMAT(L"%d%%", (ProgressData->TransferProgress()));
       }
     }