//---------------------------------------------------------------------------
bool __fastcall TRemoteTransferDialog::Execute(void *& Session, UnicodeString & Target,
UnicodeString & FileMask, bool & DirectCopy)
{
FCurrentSession = -1;
for (int Index = 0; Index < SessionCombo->Items->Count; Index++)
{
if (SessionCombo->Items->Objects[Index] == Session)
{
FCurrentSession = Index;
SessionCombo->ItemIndex = Index;
break;
}
}
assert(FCurrentSession >= 0);
DirectoryEdit->Items = CustomWinConfiguration->History[L"RemoteTarget"];
DirectoryEdit->Text = UnixIncludeTrailingBackslash(Target) + FileMask;
FDirectCopy = DirectCopy;
NotDirectCopyCheck->Checked = !DirectCopy;
bool Result = (ShowModal() == DefaultResult(this));
if (Result)
{
Session = SessionCombo->Items->Objects[SessionCombo->ItemIndex];
CustomWinConfiguration->History[L"RemoteTarget"] = DirectoryEdit->Items;
Target = UnixExtractFilePath(DirectoryEdit->Text);
FileMask = UnixExtractFileName(DirectoryEdit->Text);
DirectCopy = !NotDirectCopyCheck->Checked;
}
return Result;
}
//---------------------------------------------------------------------------
bool TFileCustomCommand::PatternReplacement(
const UnicodeString & Pattern, UnicodeString & Replacement, bool & Delimit)
{
// keep consistent with TSessionLog::OpenLogFile
if (Pattern == L"!@")
{
Replacement = FData.HostName;
}
else if (AnsiSameText(Pattern, L"!u"))
{
Replacement = FData.UserName;
}
else if (AnsiSameText(Pattern, L"!p"))
{
Replacement = FData.Password;
}
else if (Pattern == L"!/")
{
Replacement = UnixIncludeTrailingBackslash(FPath);
}
else if (Pattern == L"!&")
{
Replacement = FFileList;
// already delimited
Delimit = false;
}
else
{
assert(Pattern.Length() == 1);
Replacement = FFileName;
}
return true;
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::SetDirectory(UnicodeString value)
{
if (!value.IsEmpty())
{
value = RemotePaths() ?
UnicodeString(UnixIncludeTrailingBackslash(value)) : IncludeTrailingBackslash(value);
}
DirectoryEdit->Text = value + GetFileMask();
}
//---------------------------------------------------------------------------
void __fastcall TRemoteTransferDialog::SessionComboChange(TObject * /*Sender*/)
{
DirectoryEdit->Text =
UnixIncludeTrailingBackslash(FDirectories->Strings[SessionCombo->ItemIndex]) +
UnixExtractFileName(DirectoryEdit->Text);
if (SessionCombo->ItemIndex == FCurrentSession)
{
NotDirectCopyCheck->Checked = !FDirectCopy;
}
else
{
NotDirectCopyCheck->Checked = true;
}
UpdateControls();
}
//---------------------------------------------------------------------------
void __fastcall Upload(TTerminal * Terminal, TStrings * FileList, bool UseDefaults)
{
UnicodeString TargetDirectory;
TGUICopyParamType CopyParam = GUIConfiguration->DefaultCopyParam;
TargetDirectory = UnixIncludeTrailingBackslash(Terminal->CurrentDirectory);
int Options = coDisableQueue;
int CopyParamAttrs = Terminal->UsableCopyParamAttrs(0).Upload;
if (UseDefaults ||
DoCopyDialog(true, false, FileList, TargetDirectory, &CopyParam, Options,
CopyParamAttrs, NULL))
{
Terminal->CopyToRemote(FileList, TargetDirectory, &CopyParam, 0);
}
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::CustomCommandsButtonClick(
TObject * /*Sender*/)
{
TStrings * LocalFileList = new TStringList();
TStrings * RemoteFileList = new TStringList();
try
{
TListItem * Item = ListView->Selected;
assert(Item != NULL);
while (Item != NULL)
{
const TSynchronizeChecklist::TItem * ChecklistItem =
static_cast<const TSynchronizeChecklist::TItem *>(Item->Data);
assert((ChecklistItem->Action == TSynchronizeChecklist::saUploadUpdate) ||
(ChecklistItem->Action == TSynchronizeChecklist::saDownloadUpdate));
assert(ChecklistItem->RemoteFile != NULL);
UnicodeString LocalPath =
IncludeTrailingBackslash(ChecklistItem->Local.Directory) +
ChecklistItem->Local.FileName;
LocalFileList->Add(LocalPath);
UnicodeString RemotePath =
UnixIncludeTrailingBackslash(ChecklistItem->Remote.Directory) +
ChecklistItem->Remote.FileName;
RemoteFileList->AddObject(RemotePath, ChecklistItem->RemoteFile);
Item = ListView->GetNextItem(Item, sdAll, TItemStates() << isSelected);
}
}
catch(...)
{
delete LocalFileList;
delete RemoteFileList;
throw;
}
assert(FOnCustomCommandMenu != NULL);
FOnCustomCommandMenu(CustomCommandsButton,
CalculatePopupRect(CustomCommandsButton), LocalFileList, RemoteFileList);
}
//---------------------------------------------------------------------------
void __fastcall TFileFindDialog::FileFound(TTerminal * /*Terminal*/,
const UnicodeString FileName, const TRemoteFile * AFile, bool & Cancel)
{
TListItem * Item = FileView->Items->Add();
TRemoteFile * File = AFile->Duplicate(true);
Item->Data = File;
Item->ImageIndex = File->IconIndex;
UnicodeString Caption = File->FileName;
if (File->IsDirectory)
{
Caption = UnixIncludeTrailingBackslash(Caption);
}
Item->Caption = Caption;
UnicodeString Directory = UnixExtractFilePath(File->FullFileName);
if (AnsiSameText(FDirectory, Directory.SubString(1, FDirectory.Length())))
{
Directory[1] = L'.';
Directory.Delete(2, FDirectory.Length() - 1);
}
else
{
assert(false);
}
Item->SubItems->Add(Directory);
if (File->IsDirectory)
{
Item->SubItems->Add(L"");
}
else
{
Item->SubItems->Add(
FormatBytes(File->Size,
WinConfiguration->FormatSizeBytes, WinConfiguration->FormatSizeBytes));
}
Item->SubItems->Add(UserModificationStr(File->Modification, File->ModificationFmt));
UpdateControls();
Cancel = (FState == ffAborting);
Application->ProcessMessages();
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TCopyDialog::GetDirectory()
{
assert(DirectoryEdit);
UnicodeString Result = DirectoryEdit->Text;
if (RemotePaths())
{
Result = UnixExtractFilePath(Result);
if (!Result.IsEmpty())
{
Result = UnixIncludeTrailingBackslash(Result);
}
}
else
{
Result = ExtractFilePath(Result);
if (!Result.IsEmpty())
{
Result = IncludeTrailingBackslash(Result);
}
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::SynchronizeChange(
TObject * /*Sender*/, const UnicodeString Directory, bool & SubdirsChanged)
{
try
{
UnicodeString RemoteDirectory;
UnicodeString RootLocalDirectory;
RootLocalDirectory = IncludeTrailingBackslash(FSynchronizeParams.LocalDirectory);
RemoteDirectory = UnixIncludeTrailingBackslash(FSynchronizeParams.RemoteDirectory);
UnicodeString LocalDirectory = IncludeTrailingBackslash(Directory);
assert(LocalDirectory.SubString(1, RootLocalDirectory.Length()) ==
RootLocalDirectory);
RemoteDirectory = RemoteDirectory +
ToUnixPath(LocalDirectory.SubString(RootLocalDirectory.Length() + 1,
LocalDirectory.Length() - RootLocalDirectory.Length()));
SynchronizeLog(slChange, FMTLOAD(SYNCHRONIZE_CHANGE,
(ExcludeTrailingBackslash(LocalDirectory))));
if (FOnSynchronize != NULL)
{
// this is completelly wrong as the options structure
// can contain non-root specific options in future
TSynchronizeOptions * Options =
((LocalDirectory == RootLocalDirectory) ? FOptions : NULL);
TSynchronizeChecklist * Checklist = NULL;
FOnSynchronize(this, LocalDirectory, RemoteDirectory, FCopyParam,
FSynchronizeParams, &Checklist, Options, false);
if (Checklist != NULL)
{
try
{
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
SubdirsChanged = false;
assert(Checklist != NULL);
for (int Index = 0; Index < Checklist->Count; Index++)
{
const TSynchronizeChecklist::TItem * Item = Checklist->Item[Index];
// note that there may be action saDeleteRemote even if nothing has changed
// so this is sub-optimal
if (Item->IsDirectory)
{
if ((Item->Action == TSynchronizeChecklist::saUploadNew) ||
(Item->Action == TSynchronizeChecklist::saDeleteRemote))
{
SubdirsChanged = true;
break;
}
else
{
assert(false);
}
}
}
}
else
{
SubdirsChanged = false;
}
}
__finally
{
delete Checklist;
}
}
}
}
catch(Exception & E)
{
SynchronizeAbort(dynamic_cast<EFatal*>(&E) != NULL);
}
}