//---------------------------------------------------------------------
__fastcall TSynchronizeChecklistDialog::TSynchronizeChecklistDialog(
TComponent * AOwner, TSynchronizeMode Mode, int Params,
const UnicodeString LocalDirectory, const UnicodeString RemoteDirectory,
TCustomCommandMenuEvent OnCustomCommandMenu)
: TForm(AOwner)
{
FFormRestored = false;
FMode = Mode;
FParams = Params;
FLocalDirectory = ExcludeTrailingBackslash(LocalDirectory);
FRemoteDirectory = UnixExcludeTrailingBackslash(RemoteDirectory);
FOnCustomCommandMenu = OnCustomCommandMenu;
UseSystemSettings(this);
UseDesktopFont(ListView);
UseDesktopFont(StatusBar);
FChecklist = NULL;
FChangingItem = NULL;
FChangingItemIgnore = false;
FChangingItemMass = false;
FGeneralHint = StatusBar->Hint;
FOrigListViewWindowProc = ListView->WindowProc;
ListView->WindowProc = ListViewWindowProc;
FSystemImageList = SharedSystemImageList(false);
ListView->SmallImages = FSystemImageList;
// header images mut be assigned after the small images, so it cannot
// be done via DFM
ListView->HeaderImages = ArrowImages;
CustomCommandsButton->Visible = (FOnCustomCommandMenu != NULL);
MenuButton(CustomCommandsButton);
}
//---------------------------------------------------------------------------
void __fastcall TFileFindDialog::Start()
{
if (MaskEdit->Focused())
{
MaskEditExit(NULL);
}
RemoteDirectoryEdit->SaveToHistory();
CustomWinConfiguration->History[L"RemoteDirectory"] = RemoteDirectoryEdit->Items;
MaskEdit->SaveToHistory();
WinConfiguration->History[L"Mask"] = MaskEdit->Items;
WinConfiguration->SelectMask = MaskEdit->Text;
assert(FState != ffFinding);
FState = ffFinding;
try
{
UpdateControls();
Repaint();
TOperationVisualizer Visualizer;
assert(FOnFind != NULL);
FDirectory = UnixExcludeTrailingBackslash(RemoteDirectoryEdit->Text);
FOnFind(FDirectory, MaskEdit->Text, FileFound, FindingFile);
}
__finally
{
FFindingInDirectory = L"";
if (FState == ffFinding)
{
FState = ffDone;
}
if (FState == ffAborting)
{
FState = ffAborted;
}
if (IsApplicationMinimized() && FMinimizedByMe)
{
ShowNotification(NULL, LoadStr(BALLOON_OPERATION_COMPLETE), qtInformation);
FMinimizedByMe = false;
}
UpdateControls();
}
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TScpExplorerForm::RemotePathComboBoxText()
{
UnicodeString Result;
if (WinConfiguration->ScpExplorer.ShowFullAddress)
{
Result = UnixExcludeTrailingBackslash(RemoteDirView->Path);
}
else
{
// this is called couple of times before the combo box is populated
if (UnixPathComboBox->Strings->Count > 0)
{
Result = UnixPathComboBox->Strings->Strings[UnixPathComboBox->Strings->Count - 1];
}
}
return Result;
}
//---------------------------------------------------------------------------
bool TFileMasks::Matches(const UnicodeString & FileName, bool Local,
bool Directory, const TParams * Params, bool & ImplicitMatch) const
{
bool Result;
if (Local)
{
UnicodeString Path = ExtractFilePath(FileName);
if (!Path.IsEmpty())
{
Path = ToUnixPath(ExcludeTrailingBackslash(Path));
}
Result = Matches(ExtractFileName(FileName, false), Directory, Path, Params,
ImplicitMatch);
}
else
{
Result = Matches(UnixExtractFileName(FileName), Directory,
UnixExcludeTrailingBackslash(::UnixExtractFilePath(FileName)), Params,
ImplicitMatch);
}
return Result;
}
//---------------------------------------------------------------------------
bool __fastcall TFileFindDialog::Execute(UnicodeString Directory, UnicodeString & Path)
{
MaskEdit->Text = WinConfiguration->SelectMask;
RemoteDirectoryEdit->Text = UnixExcludeTrailingBackslash(Directory);
// have to set history after value, to prevent autocompletition
MaskEdit->Items = WinConfiguration->History[L"Mask"];
RemoteDirectoryEdit->Items = CustomWinConfiguration->History[L"RemoteDirectory"];
bool Result = (ShowModal() == FocusButton->ModalResult);
if (Result)
{
Path = static_cast<TRemoteFile *>(FileView->ItemFocused->Data)->FullFileName;
}
TFindFileConfiguration FormConfiguration = CustomWinConfiguration->FindFile;
FormConfiguration.ListParams = FileView->ColProperties->ParamsStr;
FormConfiguration.WindowParams = StoreFormSize(this);
CustomWinConfiguration->FindFile = FormConfiguration;
return Result;
}
//---------------------------------------------------------------------------
void TFileMasks::CreateMask(
const UnicodeString & MaskStr, intptr_t MaskStart, intptr_t /*MaskEnd*/, bool Include)
{
bool Directory = false; // shut up
TMask Mask;
Mask.MaskStr = MaskStr;
Mask.UserStr = MaskStr;
Mask.FileNameMask.Kind = TMaskMask::Any;
Mask.FileNameMask.Mask = nullptr;
Mask.DirectoryMask.Kind = TMaskMask::Any;
Mask.DirectoryMask.Mask = nullptr;
Mask.HighSizeMask = TMask::None;
Mask.LowSizeMask = TMask::None;
Mask.HighModificationMask = TMask::None;
Mask.LowModificationMask = TMask::None;
wchar_t NextPartDelimiter = L'\0';
intptr_t NextPartFrom = 1;
while (NextPartFrom <= MaskStr.Length())
{
wchar_t PartDelimiter = NextPartDelimiter;
intptr_t PartFrom = NextPartFrom;
UnicodeString PartStr = CopyToChars(MaskStr, NextPartFrom, L"<>", false, &NextPartDelimiter, true);
intptr_t PartStart = MaskStart + PartFrom - 1;
intptr_t PartEnd = MaskStart + NextPartFrom - 1 - 2;
TrimEx(PartStr, PartStart, PartEnd);
if (PartDelimiter != L'\0')
{
bool Low = (PartDelimiter == L'>');
TMask::TMaskBoundary Boundary;
if ((PartStr.Length() >= 1) && (PartStr[1] == L'='))
{
Boundary = TMask::Close;
PartStr.Delete(1, 1);
}
else
{
Boundary = TMask::Open;
}
TFormatSettings FormatSettings = TFormatSettings::Create(GetDefaultLCID());
FormatSettings.DateSeparator = L'-';
FormatSettings.TimeSeparator = L':';
FormatSettings.ShortDateFormat = L"yyyy/mm/dd";
FormatSettings.ShortTimeFormat = L"hh:nn:ss";
TDateTime Modification;
if (TryStrToDateTime(PartStr, Modification, FormatSettings) ||
TryRelativeStrToDateTime(PartStr, Modification))
{
TMask::TMaskBoundary & ModificationMask =
(Low ? Mask.LowModificationMask : Mask.HighModificationMask);
if ((ModificationMask != TMask::None) || Directory)
{
// include delimiter into size part
ThrowError(PartStart - 1, PartEnd);
}
ModificationMask = Boundary;
(Low ? Mask.LowModification : Mask.HighModification) = Modification;
}
else
{
TMask::TMaskBoundary & SizeMask = (Low ? Mask.LowSizeMask : Mask.HighSizeMask);
__int64 & Size = (Low ? Mask.LowSize : Mask.HighSize);
if ((SizeMask != TMask::None) || Directory)
{
// include delimiter into size part
ThrowError(PartStart - 1, PartEnd);
}
SizeMask = Boundary;
Size = ParseSize(PartStr);
}
}
else if (!PartStr.IsEmpty())
{
intptr_t D = PartStr.LastDelimiter(DirectoryMaskDelimiters);
Directory = (D > 0) && (D == PartStr.Length());
if (Directory)
{
do
{
PartStr.SetLength(PartStr.Length() - 1);
Mask.UserStr.Delete(PartStart - MaskStart + D, 1);
D--;
}
while (PartStr.IsDelimiter(DirectoryMaskDelimiters, PartStr.Length()));
D = PartStr.LastDelimiter(DirectoryMaskDelimiters);
if (FForceDirectoryMasks == 0)
{
Directory = false;
Mask.MaskStr = Mask.UserStr;
}
}
else if (FForceDirectoryMasks > 0)
{
Directory = true;
Mask.MaskStr.Insert(DirectoryMaskDelimiters[1], PartStart - MaskStart + PartStr.Length());
}
if (D > 0)
{
// make sure sole "/" (root dir) is preserved as is
CreateMaskMask(
UnixExcludeTrailingBackslash(ToUnixPath(PartStr.SubString(1, D))),
PartStart, PartStart + D - 1, false,
Mask.DirectoryMask);
CreateMaskMask(
PartStr.SubString(D + 1, PartStr.Length() - D),
PartStart + D, PartEnd, true,
Mask.FileNameMask);
}
else
{
CreateMaskMask(PartStr, PartStart, PartEnd, true, Mask.FileNameMask);
}
}
}
FMasks[MASK_INDEX(Directory, Include)].push_back(Mask);
}
//---------------------------------------------------------------------------
bool TFileMasks::MatchesMasks(const UnicodeString & FileName, bool Directory,
const UnicodeString & Path, const TParams * Params, const TMasks & Masks, bool Recurse)
{
bool Result = false;
TMasks::const_iterator it = Masks.begin();
while (!Result && (it != Masks.end()))
{
const TMask & Mask = *it;
Result =
MatchesMaskMask(Mask.DirectoryMask, Path) &&
MatchesMaskMask(Mask.FileNameMask, FileName);
if (Result)
{
bool HasSize = (Params != nullptr);
switch (Mask.HighSizeMask)
{
case TMask::None:
Result = true;
break;
case TMask::Open:
Result = HasSize && (Params->Size < Mask.HighSize);
break;
case TMask::Close:
Result = HasSize && (Params->Size <= Mask.HighSize);
break;
}
if (Result)
{
switch (Mask.LowSizeMask)
{
case TMask::None:
Result = true;
break;
case TMask::Open:
Result = HasSize && (Params->Size > Mask.LowSize);
break;
case TMask::Close:
Result = HasSize && (Params->Size >= Mask.LowSize); //-V595
break;
}
}
bool HasModification = (Params != nullptr);
if (Result)
{
switch (Mask.HighModificationMask)
{
case TMask::None:
Result = true;
break;
case TMask::Open:
Result = HasModification && (Params->Modification < Mask.HighModification);
break;
case TMask::Close:
Result = HasModification && (Params->Modification <= Mask.HighModification);
break;
}
}
if (Result)
{
switch (Mask.LowModificationMask)
{
case TMask::None:
Result = true;
break;
case TMask::Open:
Result = HasModification && (Params->Modification > Mask.LowModification);
break;
case TMask::Close:
Result = HasModification && (Params->Modification >= Mask.LowModification);
break;
}
}
}
++it;
}
if (!Result && Directory && !IsUnixRootPath(Path) && Recurse)
{
UnicodeString ParentFileName = UnixExtractFileName(Path);
UnicodeString ParentPath = UnixExcludeTrailingBackslash(::UnixExtractFilePath(Path));
// Pass Params down or not?
// Currently it includes Size/Time only, what is not used for directories.
// So it depends of future use. Possibly we should make a copy
// and pass on only relevant fields.
Result = MatchesMasks(ParentFileName, true, ParentPath, Params, Masks, Recurse);
}
return Result;
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TLocationProfilesDialog::GetRemoteDirectory()
{
return UnixExcludeTrailingBackslash(RemoteDirectoryEdit->Text);
}
