sysutils/winscp
1
0
Fork 0
mirror of https://github.com/winscp/winscp.git synced 2026-10-24 02:28:55 +03:00
Code Activity

Synchronization runs on top of Synchronization checklist window for easier overview of the process

Browse Source 
Source commit: abd7f530d22980fd0b5bdca40e3bfa1ad30c1450
This commit is contained in:
Martin Prikryl
2018-06-28 14:19:09 +00:00
parent 1f83b8f4f6
commit 0de5a41246
12 changed files with 192 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
source/core/ScpFileSystem.cpp
View File

@@ -1609,11 +1609,13 @@ void __fastcall TSCPFileSystem::CopyToRemote(TStrings * FilesToCopy,
}
}
void * Item = static_cast<void *>(FilesToCopy->Objects[IFile]);
try
{
SCPSource(FileName, TargetDirFull,
CopyParam, Params, OperationProgress, 0);
OperationProgress->Finish(FileName, true, OnceDoneOperation);
FTerminal->OperationFinish(OperationProgress, Item, FileName, true, OnceDoneOperation);
}
catch (EScpFileSkipped &E)
{
@@ -1626,7 +1628,7 @@ void __fastcall TSCPFileSystem::CopyToRemote(TStrings * FilesToCopy,
{
OperationProgress->SetCancel(csCancel);
}
OperationProgress->Finish(FileName, false, OnceDoneOperation);
FTerminal->OperationFinish(OperationProgress, Item, FileName, false, OnceDoneOperation);
if (!FTerminal->HandleException(&E))
{
throw;
@@ -1634,7 +1636,7 @@ void __fastcall TSCPFileSystem::CopyToRemote(TStrings * FilesToCopy,
}
catch (ESkipFile &E)
{
OperationProgress->Finish(FileName, false, OnceDoneOperation);
FTerminal->OperationFinish(OperationProgress, Item, FileName, false, OnceDoneOperation);
{
TSuspendFileOperationProgress Suspend(OperationProgress);
@@ -1647,7 +1649,7 @@ void __fastcall TSCPFileSystem::CopyToRemote(TStrings * FilesToCopy,
}
catch (...)
{
OperationProgress->Finish(FileName, false, OnceDoneOperation);
FTerminal->OperationFinish(OperationProgress, Item, FileName, false, OnceDoneOperation);
throw;
}
}
@@ -2176,12 +2178,12 @@ void __fastcall TSCPFileSystem::CopyToLocal(TStrings * FilesToCopy,
}
}
OperationProgress->Finish(FileName,
(!OperationProgress->Cancel && Success), OnceDoneOperation);
FTerminal->OperationFinish(
OperationProgress, File, FileName, (!OperationProgress->Cancel && Success), OnceDoneOperation);
}
catch (...)
{
OperationProgress->Finish(FileName, false, OnceDoneOperation);
FTerminal->OperationFinish(OperationProgress, File, FileName, false, OnceDoneOperation);
CloseSCP = (OperationProgress->Cancel != csRemoteAbort);
throw;
}

4
source/core/Script.cpp
View File

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

63
source/core/Terminal.cpp
View File

@@ -1053,6 +1053,7 @@ __fastcall TTerminal::TTerminal(TSessionData * SessionData,
FOnCustomCommand = NULL;
FOnClose = NULL;
FOnFindingFile = NULL;
FOnProcessedItem = NULL;
FUseBusyCursor = True;
FLockDirectory = L"";
@@ -3765,6 +3766,18 @@ void __fastcall TTerminal::AnnounceFileListOperation()
FFileSystem->AnnounceFileListOperation();
}
//---------------------------------------------------------------------------
void __fastcall TTerminal::OperationFinish(
TFileOperationProgressType * Progress, const void * Item, const UnicodeString & FileName,
bool Success, TOnceDoneOperation & OnceDoneOperation)
{
Progress->Finish(FileName, Success, OnceDoneOperation);
if ((Item != NULL) && (FOnProcessedItem != NULL) && (Progress->Operation != foCalculateSize))
{
FOnProcessedItem(Item);
}
}
//---------------------------------------------------------------------------
bool __fastcall TTerminal::ProcessFiles(TStrings * FileList,
TFileOperation Operation, TProcessFileEvent ProcessFile, void * Param,
TOperationSide Side, bool Ex)
@@ -3796,6 +3809,7 @@ bool __fastcall TTerminal::ProcessFiles(TStrings * FileList,
while ((Index < FileList->Count) && (Progress.Cancel == csContinue))
{
FileName = FileList->Strings[Index];
TRemoteFile * File = reinterpret_cast<TRemoteFile *>(FileList->Objects[Index]);
try
{
try
@@ -3803,19 +3817,19 @@ bool __fastcall TTerminal::ProcessFiles(TStrings * FileList,
Success = false;
if (!Ex)
{
ProcessFile(FileName, (TRemoteFile *)FileList->Objects[Index], Param);
ProcessFile(FileName, File, Param);
}
else
{
// not used anymore
TProcessFileEventEx ProcessFileEx = (TProcessFileEventEx)ProcessFile;
ProcessFileEx(FileName, (TRemoteFile *)FileList->Objects[Index], Param, Index);
ProcessFileEx(FileName, File, Param, Index);
}
Success = true;
}
__finally
{
Progress.Finish(FileName, Success, OnceDoneOperation);
OperationFinish(&Progress, File, FileName, Success, OnceDoneOperation);
}
}
catch(ESkipFile & E)
@@ -5339,7 +5353,7 @@ bool __fastcall TTerminal::CalculateLocalFilesSize(TStrings * FileList,
CalculateLocalFileSize(FileName, Rec, &Params);
OperationProgress.Finish(FileName, true, OnceDoneOperation);
OperationFinish(&OperationProgress, FileList->Objects[Index], FileName, true, OnceDoneOperation);
}
}
}
@@ -5910,7 +5924,7 @@ void __fastcall TTerminal::DoSynchronizeCollectFile(const UnicodeString FileName
void __fastcall TTerminal::SynchronizeApply(TSynchronizeChecklist * Checklist,
const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
const TCopyParamType * CopyParam, int Params,
TSynchronizeDirectory OnSynchronizeDirectory)
TSynchronizeDirectory OnSynchronizeDirectory, TProcessedItem OnProcessedItem)
{
TSynchronizeData Data;
@@ -5932,6 +5946,9 @@ void __fastcall TTerminal::SynchronizeApply(TSynchronizeChecklist * Checklist,
TStringList * UploadList = new TStringList();
TStringList * DeleteLocalList = new TStringList();
DebugAssert(FOnProcessedItem == NULL);
FOnProcessedItem = OnProcessedItem;
BeginTransaction();
try
@@ -5962,6 +5979,7 @@ void __fastcall TTerminal::SynchronizeApply(TSynchronizeChecklist * Checklist,
(Checklist->Item[IIndex]->Remote.Directory == CurrentRemoteDirectory))
{
ChecklistItem = Checklist->Item[IIndex];
TObject * ChecklistItemToken = const_cast<TObject *>(reinterpret_cast<const TObject *>(ChecklistItem));
if (ChecklistItem->Checked)
{
Count++;
@@ -5972,16 +5990,14 @@ void __fastcall TTerminal::SynchronizeApply(TSynchronizeChecklist * Checklist,
{
case TSynchronizeChecklist::saDownloadUpdate:
DownloadList->AddObject(
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) +
ChecklistItem->Remote.FileName,
(TObject *)(ChecklistItem));
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) + ChecklistItem->Remote.FileName,
ChecklistItemToken);
break;
case TSynchronizeChecklist::saUploadUpdate:
UploadList->AddObject(
IncludeTrailingBackslash(ChecklistItem->Local.Directory) +
ChecklistItem->Local.FileName,
(TObject *)(ChecklistItem));
IncludeTrailingBackslash(ChecklistItem->Local.Directory) + ChecklistItem->Local.FileName,
ChecklistItemToken);
break;
default:
@@ -5996,29 +6012,27 @@ void __fastcall TTerminal::SynchronizeApply(TSynchronizeChecklist * Checklist,
case TSynchronizeChecklist::saDownloadNew:
case TSynchronizeChecklist::saDownloadUpdate:
DownloadList->AddObject(
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) +
ChecklistItem->Remote.FileName,
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) + ChecklistItem->Remote.FileName,
ChecklistItem->RemoteFile);
break;
case TSynchronizeChecklist::saDeleteRemote:
DeleteRemoteList->AddObject(
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) +
ChecklistItem->Remote.FileName,
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) + ChecklistItem->Remote.FileName,
ChecklistItem->RemoteFile);
break;
case TSynchronizeChecklist::saUploadNew:
case TSynchronizeChecklist::saUploadUpdate:
UploadList->Add(
IncludeTrailingBackslash(ChecklistItem->Local.Directory) +
ChecklistItem->Local.FileName);
UploadList->AddObject(
IncludeTrailingBackslash(ChecklistItem->Local.Directory) + ChecklistItem->Local.FileName,
ChecklistItemToken);
break;
case TSynchronizeChecklist::saDeleteLocal:
DeleteLocalList->Add(
IncludeTrailingBackslash(ChecklistItem->Local.Directory) +
ChecklistItem->Local.FileName);
DeleteLocalList->AddObject(
IncludeTrailingBackslash(ChecklistItem->Local.Directory) + ChecklistItem->Local.FileName,
ChecklistItemToken);
break;
default:
@@ -6082,6 +6096,7 @@ void __fastcall TTerminal::SynchronizeApply(TSynchronizeChecklist * Checklist,
}
__finally
{
FOnProcessedItem = NULL;
delete DownloadList;
delete DeleteRemoteList;
delete UploadList;
@@ -6693,7 +6708,7 @@ void __fastcall TTerminal::DoCopyToRemote(
}
__finally
{
OperationProgress->Finish(FileName, Success, OnceDoneOperation);
OperationFinish(OperationProgress, FilesToCopy->Objects[Index], FileName, Success, OnceDoneOperation);
}
Index++;
}
@@ -7131,13 +7146,13 @@ void __fastcall TTerminal::DoCopyToLocal(
{
bool Success = false;
UnicodeString FileName = FilesToCopy->Strings[Index];
const TRemoteFile * File = dynamic_cast<const TRemoteFile *>(FilesToCopy->Objects[Index]);
try
{
try
{
UnicodeString AbsoluteFileName = AbsolutePath(FileName, true);
const TRemoteFile * File = dynamic_cast<const TRemoteFile *>(FilesToCopy->Objects[Index]);
SinkRobust(AbsoluteFileName, File, FullTargetDir, CopyParam, Params, OperationProgress, Flags | tfFirstLevel);
Success = true;
}
@@ -7152,7 +7167,7 @@ void __fastcall TTerminal::DoCopyToLocal(
}
__finally
{
OperationProgress->Finish(FileName, Success, OnceDoneOperation);
OperationFinish(OperationProgress, File, FileName, Success, OnceDoneOperation);
}
Index++;
}

7
source/core/Terminal.h
View File

@@ -55,6 +55,7 @@ typedef int __fastcall (__closure *TFileOperationEvent)
typedef void __fastcall (__closure *TSynchronizeDirectory)
(const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
bool & Continue, bool Collect);
typedef void __fastcall (__closure *TProcessedItem)(const void * Token);
typedef void __fastcall (__closure *TDeleteLocalFileEvent)(
const UnicodeString FileName, bool Alternative);
typedef int __fastcall (__closure *TDirectoryModifiedEvent)
@@ -220,6 +221,7 @@ private:
TEncryptedFileNames FEncryptedFileNames;
std::set<UnicodeString> FFoldersScannedForEncryptedFiles;
RawByteString FEncryptKey;
TProcessedItem FOnProcessedItem;
void __fastcall CommandError(Exception * E, const UnicodeString Msg);
unsigned int __fastcall CommandError(Exception * E, const UnicodeString Msg,
@@ -366,6 +368,9 @@ protected:
void __fastcall UnlockFile(const UnicodeString FileName, const TRemoteFile * File, void * Param);
void __fastcall DoLockFile(const UnicodeString & FileName, const TRemoteFile * File);
void __fastcall DoUnlockFile(const UnicodeString & FileName, const TRemoteFile * File);
void __fastcall OperationFinish(
TFileOperationProgressType * Progress, const void * Item, const UnicodeString & FileName,
bool Success, TOnceDoneOperation & OnceDoneOperation);
virtual void __fastcall Information(const UnicodeString & Str, bool Status);
virtual unsigned int __fastcall QueryUser(const UnicodeString Query,
@@ -540,7 +545,7 @@ public:
void __fastcall SynchronizeApply(TSynchronizeChecklist * Checklist,
const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
const TCopyParamType * CopyParam, int Params,
TSynchronizeDirectory OnSynchronizeDirectory);
TSynchronizeDirectory OnSynchronizeDirectory, TProcessedItem OnProcessedItem);
void __fastcall FilesFind(UnicodeString Directory, const TFileMasks & FileMask,
TFileFoundEvent OnFileFound, TFindingFileEvent OnFindingFile);
void __fastcall SpaceAvailable(const UnicodeString Path, TSpaceAvailable & ASpaceAvailable);

81
source/forms/CustomScpExplorer.cpp
View File

@@ -5236,7 +5236,7 @@ void __fastcall TCustomScpExplorerForm::Synchronize(const UnicodeString LocalDir
// No need to call if !AnyOperation
Terminal->SynchronizeApply(AChecklist, LocalDirectory, RemoteDirectory,
&CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory);
&CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory, NULL);
}
__finally
{
@@ -5327,6 +5327,49 @@ void __fastcall TCustomScpExplorerForm::SynchronizeInNewWindow(
ExecuteNewInstance(SessionName, AdditionalParams);
}
//---------------------------------------------------------------------------
struct TSynchronizeParams
{
UnicodeString LocalDirectory;
UnicodeString RemoteDirectory;
TSynchronizeMode Mode;
TSynchronizeChecklist * Checklist;
int Params;
TCopyParamType * CopyParam;
TDateTime * StartTime;
};
//---------------------------------------------------------------------------
void __fastcall TCustomScpExplorerForm::FullSynchronize(TSynchronizeParams & Params, TProcessedItem OnProcessedItem)
{
DebugAssert(!FAutoOperation);
void * BatchStorage;
BatchStart(BatchStorage);
FAutoOperation = true;
try
{
FSynchronizeProgressForm = new TSynchronizeProgressForm(Application, true, false);
FSynchronizeProgressForm->Start();
Terminal->SynchronizeApply(
Params.Checklist, Params.LocalDirectory, Params.RemoteDirectory,
Params.CopyParam, Params.Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory, OnProcessedItem);
}
__finally
{
FAutoOperation = false;
SAFE_DESTROY(FSynchronizeProgressForm);
BatchEnd(BatchStorage);
ReloadLocalDirectory();
}
}
//---------------------------------------------------------------------------
void __fastcall TCustomScpExplorerForm::DoFullSynchronize(void * Token, TProcessedItem OnProcessedItem)
{
TSynchronizeParams & Params = *static_cast<TSynchronizeParams *>(Token);
*Params.StartTime = Now();
FullSynchronize(Params, OnProcessedItem);
}
//---------------------------------------------------------------------------
bool __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
UnicodeString & LocalDirectory, UnicodeString & RemoteDirectory,
TSynchronizeMode & Mode, bool & SaveMode, bool UseDefaults)
@@ -5390,34 +5433,24 @@ bool __fastcall TCustomScpExplorerForm::DoFullSynchronizeDirectories(
MessageDialog(Message, qtInformation, qaOK,
HELP_SYNCHRONIZE_NO_DIFFERENCES);
}
else if (FLAGCLEAR(Params, TTerminal::spPreviewChanges) ||
DoSynchronizeChecklistDialog(Checklist, Mode, Params,
LocalDirectory, RemoteDirectory, CustomCommandMenu))
else
{
DebugAssert(!FAutoOperation);
void * BatchStorage;
BatchStart(BatchStorage);
FAutoOperation = true;
TSynchronizeParams SynchronizeParams;
SynchronizeParams.LocalDirectory = LocalDirectory;
SynchronizeParams.RemoteDirectory = RemoteDirectory;
SynchronizeParams.Mode = Mode;
SynchronizeParams.CopyParam = &CopyParam;
SynchronizeParams.Params = Params;
SynchronizeParams.Checklist = Checklist;
SynchronizeParams.StartTime = &StartTime;
if (FLAGSET(Params, TTerminal::spPreviewChanges))
{
StartTime = Now();
DoSynchronizeChecklistDialog(
Checklist, Mode, Params, LocalDirectory, RemoteDirectory, CustomCommandMenu, DoFullSynchronize, &SynchronizeParams);
}
try
else
{
FSynchronizeProgressForm = new TSynchronizeProgressForm(Application, true, false);
FSynchronizeProgressForm->Start();
Terminal->SynchronizeApply(Checklist, LocalDirectory, RemoteDirectory,
&CopyParam, Params | TTerminal::spNoConfirmation, TerminalSynchronizeDirectory);
}
__finally
{
FAutoOperation = false;
SAFE_DESTROY(FSynchronizeProgressForm);
BatchEnd(BatchStorage);
ReloadLocalDirectory();
FullSynchronize(SynchronizeParams, NULL);
}
}
}

3
source/forms/CustomScpExplorer.h
View File

@@ -47,6 +47,7 @@ class TEditorData;
class TTransferPresetNoteData;
struct TEditedFileData;
class ITaskbarList3;
struct TSynchronizeParams;
//---------------------------------------------------------------------------
enum TActionAllowed { aaShortCut, aaUpdate, aaExecute };
enum TActionFlag { afLocal = 1, afRemote = 2, afExplorer = 4 , afCommander = 8 };
@@ -600,6 +601,8 @@ protected:
void __fastcall UpdatePixelsPerInchMainWindowCounter();
void __fastcall CopyPopup(TControl * DestControl, TControl * SourceControl);
void __fastcall CreateRemoteDirectory(const UnicodeString & Path, TRemoteProperties & Properties);
void __fastcall DoFullSynchronize(void * Token, TProcessedItem OnProcessedItem);
void __fastcall FullSynchronize(TSynchronizeParams & Params, TProcessedItem OnProcessedItem);
public:
virtual __fastcall ~TCustomScpExplorerForm();

92
source/forms/SynchronizeChecklist.cpp
View File

@@ -27,28 +27,20 @@
//---------------------------------------------------------------------
const int ImageColumnIndex = 4;
//---------------------------------------------------------------------
bool __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
TSynchronizeMode Mode, int Params, const UnicodeString LocalDirectory,
const UnicodeString RemoteDirectory, TCustomCommandMenuEvent OnCustomCommandMenu)
void __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
TSynchronizeMode Mode, int Params,
const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize, void * Token)
{
bool Result;
TSynchronizeChecklistDialog * Dialog = new TSynchronizeChecklistDialog(
Application, Mode, Params, LocalDirectory, RemoteDirectory, OnCustomCommandMenu);
try
{
Result = Dialog->Execute(Checklist);
}
__finally
{
delete Dialog;
}
return Result;
std::unique_ptr<TSynchronizeChecklistDialog> Dialog(
new TSynchronizeChecklistDialog(Application, Mode, Params, LocalDirectory, RemoteDirectory, OnCustomCommandMenu, OnSynchronize, Token));
Dialog->Execute(Checklist);
}
//---------------------------------------------------------------------
__fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
TComponent * AOwner, TSynchronizeMode Mode, int Params,
const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
TCustomCommandMenuEvent OnCustomCommandMenu)
TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize, void * Token)
: TForm(AOwner)
{
FFormRestored = false;
@@ -57,6 +49,9 @@ __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
FLocalDirectory = ExcludeTrailingBackslash(LocalDirectory);
FRemoteDirectory = UnixExcludeTrailingBackslash(RemoteDirectory);
FOnCustomCommandMenu = OnCustomCommandMenu;
DebugAssert(OnSynchronize != NULL);
FOnSynchronize = OnSynchronize;
FToken = Token;
UseSystemSettings(this);
UseDesktopFont(ListView);
UseDesktopFont(StatusBar);
@@ -65,6 +60,7 @@ __fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
FChangingItemIgnore = false;
FChangingItemMass = false;
FGeneralHint = StatusBar->Hint;
FSynchronizing = false;
SelectScaledImageList(ActionImages);
@@ -84,7 +80,7 @@ __fastcall TSynchronizeChecklistDialog::~TSynchronizeChecklistDialog()
ListView->WindowProc = FOrigListViewWindowProc;
}
//---------------------------------------------------------------------
bool __fastcall TSynchronizeChecklistDialog::Execute(TSynchronizeChecklist * Checklist)
void __fastcall TSynchronizeChecklistDialog::Execute(TSynchronizeChecklist * Checklist)
{
FChecklist = Checklist;
@@ -92,13 +88,6 @@ bool __fastcall TSynchronizeChecklistDialog::Execute(TSynchronizeChecklist * Che
if (Result)
{
for (int Index = 0; Index < ListView->Items->Count; Index++)
{
TListItem * Item = ListView->Items->Item[Index];
const TSynchronizeChecklist::TItem * ChecklistItem = GetChecklistItem(Item);
Checklist->Update(ChecklistItem, Item->Checked, GetChecklistItemAction(ChecklistItem));
}
TSynchronizeChecklistConfiguration FormConfiguration =
CustomWinConfiguration->SynchronizeChecklist;
FormConfiguration.ListParams = ListView->ColProperties->ParamsStr;
@@ -115,12 +104,12 @@ bool __fastcall TSynchronizeChecklistDialog::Execute(TSynchronizeChecklist * Che
CustomWinConfiguration->SynchronizeChecklist = FormConfiguration;
}
return Result;
}
//---------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::UpdateControls()
{
Caption = FormatFormCaption(this, LoadStr(FSynchronizing ? SYNCHRONIZE_PROGRESS_SYNCHRONIZE2 : SYNCHRONIZE_CHECKLIST_CAPTION));
StatusBar->Invalidate();
bool AllChecked = true;
@@ -152,15 +141,17 @@ void __fastcall TSynchronizeChecklistDialog::UpdateControls()
Item = ListView->GetNextItem(Item, sdAll, TItemStates() << isSelected);
}
EnableControl(OkButton, (FChecked[0] > 0));
CheckAction->Enabled = !AllChecked;
UncheckAction->Enabled = !AllUnchecked;
CheckAllAction->Enabled = (FChecked[0] < FTotals[0]);
UncheckAllAction->Enabled = (FChecked[0] > 0);
CustomCommandsAction->Enabled = AnyBoth && !AnyNonBoth;
ReverseAction->Enabled = (ListView->SelCount > 0);
EnableControl(OkButton, (FChecked[0] > 0) && !FSynchronizing);
EnableControl(CancelButton, !FSynchronizing);
EnableControl(HelpButton, !FSynchronizing);
CheckAction->Enabled = !AllChecked && !FSynchronizing;
UncheckAction->Enabled = !AllUnchecked && !FSynchronizing;
CheckAllAction->Enabled = (FChecked[0] < FTotals[0]) && !FSynchronizing;
UncheckAllAction->Enabled = (FChecked[0] > 0) && !FSynchronizing;
CustomCommandsAction->Enabled = AnyBoth && !AnyNonBoth && DebugAlwaysTrue(!FSynchronizing);
ReverseAction->Enabled = (ListView->SelCount > 0) && DebugAlwaysTrue(!FSynchronizing);
SelectAllAction->Enabled = (ListView->SelCount < ListView->Items->Count);
SelectAllAction->Enabled = (ListView->SelCount < ListView->Items->Count) && !FSynchronizing;
}
//---------------------------------------------------------------------------
bool __fastcall TSynchronizeChecklistDialog::GetWindowParams(UnicodeString & WindowParams)
@@ -1086,3 +1077,36 @@ void __fastcall TSynchronizeChecklistDialog::CMDpiChanged(TMessage & Message)
UpdateImages();
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::ProcessedItem(const void * Token)
{
TTokens::const_iterator I = FTokens.find(Token);
if (DebugAlwaysTrue(I != FTokens.end()))
{
TListItem * Item = I->second;
DebugAssert(Item->Checked);
Item->Checked = false;
Item->MakeVisible(false);
}
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::OkButtonClick(TObject * /*Sender*/)
{
ListView->SelectAll(smNone);
FTokens.clear();
for (int Index = 0; Index < ListView->Items->Count; Index++)
{
TListItem * Item = ListView->Items->Item[Index];
const TSynchronizeChecklist::TItem * ChecklistItem = GetChecklistItem(Item);
FChecklist->Update(ChecklistItem, Item->Checked, GetChecklistItemAction(ChecklistItem));
FTokens.insert(std::make_pair(ChecklistItem, Item));
if (ChecklistItem->RemoteFile != NULL)
{
FTokens.insert(std::make_pair(ChecklistItem->RemoteFile, Item));
}
}
TAutoFlag Flag(FSynchronizing);
UpdateControls();
FOnSynchronize(FToken, ProcessedItem);
}
//---------------------------------------------------------------------------

3
source/forms/SynchronizeChecklist.dfm
View File

@@ -4,7 +4,7 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
HelpType = htKeyword
HelpKeyword = 'ui_synchronize_checklist'
BorderIcons = [biSystemMenu, biMinimize, biMaximize, biHelp]
Caption = 'Synchronization checklist'
Caption = 'Synchronization checklist X'
ClientHeight = 521
ClientWidth = 695
Color = clBtnFace
@@ -1382,6 +1382,7 @@ object SynchronizeChecklistDialog: TSynchronizeChecklistDialog
Default = True
ModalResult = 1
TabOrder = 0
OnClick = OkButtonClick
end
object CancelButton: TButton
Left = 8

12
source/forms/SynchronizeChecklist.h
View File

@@ -84,15 +84,17 @@ __published:
void __fastcall UncheckAllActionExecute(TObject *Sender);
void __fastcall ReverseActionExecute(TObject *Sender);
void __fastcall ListViewClick(TObject *Sender);
void __fastcall OkButtonClick(TObject *Sender);
public:
__fastcall TSynchronizeChecklistDialog(TComponent * AOwner,
TSynchronizeMode Mode, int Params, const UnicodeString LocalDirectory,
const UnicodeString RemoteDirectory, TCustomCommandMenuEvent OnCustomCommandMenu);
const UnicodeString RemoteDirectory, TCustomCommandMenuEvent OnCustomCommandMenu,
TFullSynchronizeEvent OnSynchronize, void * Token);
virtual __fastcall ~TSynchronizeChecklistDialog();
bool __fastcall Execute(TSynchronizeChecklist * Checklist);
void __fastcall Execute(TSynchronizeChecklist * Checklist);
protected:
bool FFormRestored;
@@ -113,6 +115,11 @@ protected:
TCustomCommandMenuEvent FOnCustomCommandMenu;
typedef std::map<const TSynchronizeChecklist::TItem *, TSynchronizeChecklist::TAction> TActions;
TActions FActions;
TFullSynchronizeEvent FOnSynchronize;
void * FToken;
typedef std::map<const void *, TListItem *> TTokens;
TTokens FTokens;
bool FSynchronizing;
void __fastcall UpdateControls();
virtual void __fastcall CreateParams(TCreateParams & Params);
@@ -137,6 +144,7 @@ protected:
void __fastcall UpdateImages();
void __fastcall CMDpiChanged(TMessage & Message);
bool __fastcall GetWindowParams(UnicodeString & WindowParams);
void __fastcall ProcessedItem(const void * Token);
static int __fastcall CompareNumber(__int64 Value1, __int64 Value2);
};
//----------------------------------------------------------------------------

1
source/resource/TextsWin.h
View File

@@ -606,6 +606,7 @@
#define LOGIN_PUBLIC_KEY_PERMISSIONS 6007
#define LOGIN_PUBLIC_KEY_TITLE 6008
#define LOGIN_PUBLIC_KEY_FILTER 6009
#define SYNCHRONIZE_CHECKLIST_CAPTION 6010
// 2xxx is reserved for TextsFileZilla.h

1
source/resource/TextsWin1.rc
View File

@@ -609,6 +609,7 @@ BEGIN
LOGIN_PUBLIC_KEY_PERMISSIONS, "Though potentially wrong permissions of \"%s\" file and/or its parent folder were detected. Please check them."
LOGIN_PUBLIC_KEY_TITLE, "Select key to install into server"
LOGIN_PUBLIC_KEY_FILTER, "PuTTY Private Key Files (*.ppk)|*.ppk|All Private Key Files (*.ppk;*.pem;*.key;id_*)|*.ppk;*.pem;*.key;id_*|All Files (*.*)|*.*"
SYNCHRONIZE_CHECKLIST_CAPTION, "Synchronization checklist"
WIN_VARIABLE_STRINGS, "WIN_VARIABLE"
WINSCP_COPYRIGHT, "Copyright © 2000-2018 Martin Prikryl"

6
source/windows/WinInterface.h
View File

@@ -6,6 +6,7 @@
#include <Buttons.hpp>
#include <Interface.h>
#include <WinConfiguration.h>
#include <Terminal.h>
#include <SynchronizeController.h>
#ifdef LOCALINTERFACE
@@ -350,10 +351,11 @@ bool __fastcall DoFullSynchronizeDialog(TSynchronizeMode & Mode, int & Params,
class TSynchronizeChecklist;
typedef void __fastcall (__closure *TCustomCommandMenuEvent)
(TAction * Action, TStrings * LocalFileList, TStrings * RemoteFileList);
bool __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
typedef void __fastcall (__closure *TFullSynchronizeEvent)(void * Token, TProcessedItem OnProcessedItem);
void __fastcall DoSynchronizeChecklistDialog(TSynchronizeChecklist * Checklist,
TSynchronizeMode Mode, int Params,
const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
TCustomCommandMenuEvent OnCustomCommandMenu);
TCustomCommandMenuEvent OnCustomCommandMenu, TFullSynchronizeEvent OnSynchronize, void * Token);
// forms\Editor.cpp
typedef void __fastcall (__closure *TFileClosedEvent)