//---------------------------------------------------------------------------
intptr_t TInteractiveCustomCommand::PatternLen(const UnicodeString & Command, intptr_t Index)
{
intptr_t Len = 0;
switch (Command[Index + 1])
{
case L'?':
{
const wchar_t * Ptr = Command.c_str() + Index - 1;
const wchar_t * PatternEnd = wcschr(Ptr + 1, L'!');
if (PatternEnd == nullptr)
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_UNTERMINATED, Command[Index + 1], Index));
}
Len = PatternEnd - Ptr + 1;
}
break;
case L'`':
{
const wchar_t * Ptr = Command.c_str() + Index - 1;
const wchar_t * PatternEnd = wcschr(Ptr + 2, L'`');
if (PatternEnd == nullptr)
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_UNTERMINATED, Command[Index + 1], Index));
}
Len = PatternEnd - Ptr + 1;
}
break;
default:
Len = FChildCustomCommand->PatternLen(Command, Index);
break;
}
return Len;
}
//---------------------------------------------------------------------------
void __fastcall TCustomCommandDialog::FormCloseQuery(TObject * /*Sender*/,
bool & /*CanClose*/)
{
if (ModalResult == DefaultResult(this))
{
if ((FMode == ccmAdd) || (FMode == ccmEdit))
{
UnicodeString Desc = DescriptionEdit->Text;
if (Desc.Pos(L"=") > 0)
{
DescriptionEdit->SetFocus();
throw Exception(FMTLOAD(CUSTOM_COMMAND_INVALID, (L"=")));
}
if (((FMode == ccmAdd) || ((FMode == ccmEdit) && (Desc != FOrigDescription))) &&
(FCustomCommandList->Find(Desc) != 0))
{
DescriptionEdit->SetFocus();
throw Exception(FMTLOAD(CUSTOM_COMMAND_DUPLICATE, (Desc)));
}
}
try
{
bool RemoteCommand = RemoteCommandButton->Checked;
TRemoteCustomCommand RemoteCustomCommand;
TLocalCustomCommand LocalCustomCommand;
TFileCustomCommand * FileCustomCommand =
(RemoteCommand ? &RemoteCustomCommand : &LocalCustomCommand);
TInteractiveCustomCommand InteractiveCustomCommand(FileCustomCommand);
UnicodeString Command = CommandEdit->Text;
InteractiveCustomCommand.Validate(Command);
Command = InteractiveCustomCommand.Complete(Command, false);
FileCustomCommand->Validate(Command);
}
catch(...)
{
CommandEdit->SetFocus();
throw;
}
if (FOnValidate)
{
TCustomCommandType Command;
GetCommand(Command);
FOnValidate(Command);
}
}
}
void RaiseLastOSError(DWORD LastError)
{
if (LastError == 0) LastError = ::GetLastError();
UnicodeString ErrorMsg;
if (LastError != 0)
{
ErrorMsg = FMTLOAD(SOSError, LastError, ::SysErrorMessage(LastError).c_str());
}
else
{
ErrorMsg = FMTLOAD(SUnkOSError);
}
throw EOSError(ErrorMsg, LastError);
}
//---------------------------------------------------------------------------
void TCustomCommand::GetToken(
const UnicodeString & Command, intptr_t Index, intptr_t & Len, wchar_t & PatternCmd)
{
assert(Index <= Command.Length());
const wchar_t * Ptr = Command.c_str() + Index - 1;
if (Ptr[0] == L'!')
{
PatternCmd = Ptr[1];
if (PatternCmd == L'\0')
{
Len = 1;
}
else if (PatternCmd == L'!')
{
Len = 2;
}
else
{
Len = PatternLen(Command, Index);
}
if (Len <= 0)
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_UNKNOWN, PatternCmd, Index));
}
else
{
if ((Command.Length() - Index + 1) < Len)
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_UNTERMINATED, PatternCmd, Index));
}
}
}
else
{
PatternCmd = TEXT_TOKEN;
const wchar_t * NextPattern = wcschr(Ptr, L'!');
if (NextPattern == nullptr)
{
Len = Command.Length() - Index + 1;
}
else
{
Len = NextPattern - Ptr;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::AdjustControls()
{
RemoteDirectoryEdit->Visible = false;
LocalDirectoryEdit->Visible = false;
DirectoryEdit->Visible = FLAGCLEAR(FOptions, coTemp);
EnableControl(DirectoryEdit, FLAGCLEAR(FOptions, coDisableDirectory));
EnableControl(DirectoryLabel, DirectoryEdit->Enabled);
EnableControl(LocalDirectoryBrowseButton, DirectoryEdit->Enabled);
DirectoryLabel->FocusControl = DirectoryEdit;
UnicodeString QueueLabel = LoadStr(COPY_BACKGROUND);
if (FLAGCLEAR(FOptions, coNoQueue))
{
QueueLabel = FMTLOAD(COPY_QUEUE, (QueueLabel));
}
QueueCheck2->Caption = QueueLabel;
AdjustTransferControls();
LocalDirectoryBrowseButton->Visible = !FToRemote &&
FLAGCLEAR(FOptions, coTemp);
if (FLAGCLEAR(FOptions, coDoNotShowAgain))
{
NeverShowAgainCheck->Visible = false;
ClientHeight = NeverShowAgainCheck->Top;
}
UpdateControls();
}
//---------------------------------------------------------------------
void TCopyParamList::ValidateName(const UnicodeString & Name)
{
if (Name.LastDelimiter(FInvalidChars) > 0)
{
throw Exception(FMTLOAD(ITEM_NAME_INVALID, Name.c_str(), FInvalidChars.c_str()));
}
}
void * TMemoryStream::Realloc(__int64 & NewCapacity)
{
if ((NewCapacity > 0) && (NewCapacity != FSize))
{
NewCapacity = (NewCapacity + (MemoryDelta - 1)) & ~(MemoryDelta - 1);
}
void * Result = FMemory;
if (NewCapacity != FCapacity)
{
if (NewCapacity == 0)
{
nb_free(FMemory);
FMemory = nullptr;
Result = nullptr;
}
else
{
if (FCapacity == 0)
{
Result = nb_malloc(static_cast<size_t>(NewCapacity));
}
else
{
Result = nb_realloc(FMemory, static_cast<size_t>(NewCapacity));
}
if (Result == nullptr)
{
throw EStreamError(FMTLOAD(SMemoryStreamError));
}
}
}
return Result;
}
void TStream::WriteBuffer(const void * Buffer, __int64 Count)
{
if ((Count != 0) && (Write(Buffer, Count) != Count))
{
throw Exception(FMTLOAD(SWriteError));
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall BookmarkNameValidateName(const UnicodeString Name)
{
if (Name.IsEmpty() || IsNumber(Name))
{
throw Exception(FMTLOAD(BOOKMARK_INVALID_NAME, (Name)));
}
}
void TCopyParamList::ValidateName(const UnicodeString & Name)
{
if (Name.LastDelimiter(CONST_INVALID_CHARS) > 0)
{
throw Exception(FMTLOAD(ITEM_NAME_INVALID, Name.c_str(), CONST_INVALID_CHARS));
}
}
bool TOptions::SwitchValue(const UnicodeString & Switch, bool Default, bool DefaultOnNonExistence)
{
bool Result = false;
int64_t IntValue = 0;
UnicodeString Value;
if (!FindSwitch(Switch, Value))
{
Result = DefaultOnNonExistence;
}
else if (Value.IsEmpty())
{
Result = Default;
}
else if (::SameText(Value, L"on"))
{
Result = true;
}
else if (::SameText(Value, L"off"))
{
Result = false;
}
else if (::TryStrToInt(Value, IntValue))
{
Result = (IntValue != 0);
}
else
{
throw Exception(FMTLOAD(URL_OPTION_BOOL_VALUE_ERROR, Value.c_str()));
}
return Result;
}
//---------------------------------------------------------------------
void __fastcall TCopyParamList::ValidateName(const UnicodeString Name)
{
if (Name.LastDelimiter(FInvalidChars) > 0)
{
throw Exception(FMTLOAD(ITEM_NAME_INVALID, (Name, FInvalidChars)));
}
}
void TStream::ReadBuffer(void * Buffer, __int64 Count)
{
if ((Count != 0) && (Read(Buffer, Count) != Count))
{
throw Exception(FMTLOAD(SReadError));
}
}
//---------------------------------------------------------------------------
void __fastcall BookmarkFolderValidateName(const UnicodeString Name,
bool AllowEmpty)
{
if ((!AllowEmpty && Name.IsEmpty()) || Name.Pos(L"\\"))
{
throw Exception(FMTLOAD(BOOKMARK_FOLDER_INVALID_NAME, (Name)));
}
}
//---------------------------------------------------------------------
void __fastcall TBookmarkNameDialog::DoValidate()
{
if (NameCombo->Text.IsEmpty() || IsNumber(NameCombo->Text))
{
throw Exception(FMTLOAD(BOOKMARK_INVALID_NAME, (NameCombo->Text)));
}
TCustomDialog::DoValidate();
}
uintptr_t GetSpeedLimit(const UnicodeString & Text)
{
uintptr_t Speed = 0;
if (!TryGetSpeedLimit(Text, Speed))
{
throw Exception(FMTLOAD(SPEED_INVALID, Text.c_str()));
}
return Speed;
}
UnicodeString SysErrorMessageForError(intptr_t LastError)
{
UnicodeString Result;
if (LastError != 0)
{
//Result = FORMAT("System Error. Code: %d.\r\n%s", LastError, SysErrorMessage(LastError).c_str());
Result = FMTLOAD(SOSError, LastError, ::SysErrorMessage(LastError).c_str(), L"");
}
return Result;
}
//---------------------------------------------------------------------------
void TFileCustomCommand::Validate(const UnicodeString & Command)
{
int Found[2] = { 0, 0 };
CustomValidate(Command, &Found);
if ((Found[0] > 0) && (Found[1] > 0))
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_FILELIST_ERROR,
Found[1], Found[0]));
}
}
//---------------------------------------------------------------------------
void __fastcall TWinInteractiveCustomCommand::Prompt(
const UnicodeString & Prompt, UnicodeString & Value)
{
UnicodeString APrompt = Prompt;
if (APrompt.IsEmpty())
{
APrompt = FMTLOAD(CUSTOM_COMMANDS_PARAM_PROMPT, (FCustomCommandName));
}
TStrings * History = CustomWinConfiguration->History[L"CustomCommandParam"];
if (InputDialog(FMTLOAD(CUSTOM_COMMANDS_PARAM_TITLE, (FCustomCommandName)),
APrompt, Value, HELP_CUSTOM_COMMAND_PARAM, History))
{
CustomWinConfiguration->History[L"CustomCommandParam"] = History;
}
else
{
Abort();
}
}
//---------------------------------------------------------------------------
IShellLink * __fastcall CreateDesktopSessionShortCut(
const UnicodeString & SessionName, UnicodeString Name,
const UnicodeString & AdditionalParams, int SpecialFolder, int IconIndex,
bool Return)
{
bool DefaultsOnly;
UnicodeString InfoTip;
bool IsFolder = StoredSessions->IsFolder(SessionName);
bool IsWorkspace = StoredSessions->IsWorkspace(SessionName);
if (IsFolder || IsWorkspace)
{
InfoTip = FMTLOAD(
(IsFolder ? SHORTCUT_INFO_TIP_FOLDER : SHORTCUT_INFO_TIP_WORKSPACE),
(SessionName));
if (Name.IsEmpty())
{
// no slashes in filename
Name = UnixExtractFileName(SessionName);
}
}
else
{
TSessionData * SessionData =
StoredSessions->ParseUrl(SessionName, NULL, DefaultsOnly);
InfoTip =
FMTLOAD(SHORTCUT_INFO_TIP, (SessionName, SessionData->InfoTip));
if (Name.IsEmpty())
{
// no slashes in filename
Name = SessionData->LocalName;
}
delete SessionData;
}
return
CreateDesktopShortCut(ValidLocalFileName(Name), Application->ExeName,
FORMAT(L"\"%s\"%s%s", (SessionName, (AdditionalParams.IsEmpty() ? L"" : L" "), AdditionalParams)),
InfoTip, SpecialFolder, IconIndex, Return);
}
UnicodeString TConfiguration::GetVersionStr() const
{
UnicodeString Result;
TGuard Guard(FCriticalSection);
try
{
TVSFixedFileInfo * Info = GetFixedApplicationInfo();
/*return FMTLOAD(VERSION,
HIWORD(Info->dwFileVersionMS),
LOWORD(Info->dwFileVersionMS),
HIWORD(Info->dwFileVersionLS),
LOWORD(Info->dwFileVersionLS));*/
UnicodeString BuildStr;
if (!GetIsUnofficial())
{
BuildStr = LoadStr(VERSION_BUILD);
}
else
{
#ifdef _DEBUG
BuildStr = LoadStr(VERSION_DEBUG_BUILD);
#else
BuildStr = LoadStr(VERSION_DEV_BUILD);
#endif
}
int Build = LOWORD(Info->dwFileVersionLS);
if (Build > 0)
{
BuildStr += L" " + ::IntToStr(Build);
}
// #ifndef BUILD_OFFICIAL
// UnicodeString BuildDate = __DATE__;
// UnicodeString MonthStr = CutToChar(BuildDate, L' ', true);
// int Month = ParseShortEngMonthName(MonthStr);
// int Day = StrToInt64(CutToChar(BuildDate, L' ', true));
// int Year = StrToInt64(Trim(BuildDate));
// UnicodeString DateStr = FORMAT("%d-%2.2d-%2.2d", Year, Month, Day);
// AddToList(BuildStr, DateStr, L" ");
// #endif
Result = FMTLOAD(VERSION2, GetVersion().c_str(), Build);
// #ifndef BUILD_OFFICIAL
// Result += L" " + LoadStr(VERSION_DONT_DISTRIBUTE);
// #endif
}
catch (Exception & E)
{
throw ExtException(&E, "Can't get application version");
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TAboutDialog::LoadData()
{
UnicodeString Version = FConfiguration->VersionStr;
if (!FConfiguration->ProductName.IsEmpty() &&
(FConfiguration->Version != FConfiguration->ProductVersion))
{
Version = FMTLOAD(ABOUT_BASED_ON_PRODUCT,
(Version, FConfiguration->ProductName, FConfiguration->ProductVersion));
}
VersionLabel->Caption = Version;
}
//---------------------------------------------------------------------------
void __fastcall ExecuteNewInstance(const UnicodeString & Param)
{
UnicodeString Arg = Param;
if (!Arg.IsEmpty())
{
Arg = FORMAT(L"\"%s\"", (Arg));
}
if (!ExecuteShell(Application->ExeName, Arg))
{
throw Exception(FMTLOAD(EXECUTE_APP_ERROR, (Application->ExeName)));
}
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::FormCloseQuery(TObject * /*Sender*/,
bool &CanClose)
{
if (ModalResult == DefaultResult(this))
{
if (!RemotePaths() && ((FOptions & coTemp) == 0))
{
UnicodeString Dir = Directory;
UnicodeString Drive = ExtractFileDrive(Dir);
if (!DirectoryExists(Dir))
{
if (MessageDialog(MainInstructions(FMTLOAD(CREATE_LOCAL_DIRECTORY, (Dir))),
qtConfirmation, qaOK | qaCancel, HELP_NONE) != qaCancel)
{
if (!ForceDirectories(Dir))
{
SimpleErrorDialog(FMTLOAD(CREATE_LOCAL_DIR_ERROR, (Dir)));
CanClose = false;
}
}
else
{
CanClose = False;
}
}
if (!CanClose)
{
DirectoryEdit->SelectAll();
DirectoryEdit->SetFocus();
}
};
if (CanClose)
{
ExitActiveControl(this);
}
}
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::LogOperation(TSynchronizeOperation Operation,
const UnicodeString FileName)
{
TSynchronizeLogEntry Entry;
UnicodeString Message;
switch (Operation)
{
case soDelete:
Entry = slDelete;
Message = FMTLOAD(SYNCHRONIZE_DELETED, (FileName));
break;
default:
assert(false);
// fallthru
case soUpload:
Entry = slUpload;
Message = FMTLOAD(SYNCHRONIZE_UPLOADED, (FileName));
break;
}
SynchronizeLog(Entry, Message);
}
//---------------------------------------------------------------------------
void __fastcall TFileFindDialog::UpdateControls()
{
bool Finding = IsFinding();
Caption = LoadStr(Finding ? FIND_FILE_FINDING : FIND_FILE_TITLE);
UnicodeString StartStopCaption;
if (Finding)
{
EnableControl(StartStopButton, true);
StartStopCaption = LoadStr(FIND_FILE_STOP);
}
else
{
EnableControl(StartStopButton, !RemoteDirectoryEdit->Text.IsEmpty());
StartStopCaption = LoadStr(FIND_FILE_START);
}
StartStopButton->Caption = StartStopCaption;
CancelButton->Visible = !Finding;
EnableControl(FilterGroup, !Finding);
MinimizeButton->Visible = Finding;
EnableControl(FocusButton, (FileView->ItemFocused != NULL));
switch (FState)
{
case ffInit:
StatusBar->SimpleText = L"";
case ffFinding:
case ffAborting:
if (!FFindingInDirectory.IsEmpty())
{
StatusBar->SimpleText = FMTLOAD(FIND_FILE_IN_DIRECTORY, (FFindingInDirectory));
}
else
{
StatusBar->SimpleText = L"";
}
break;
case ffAborted:
StatusBar->SimpleText = LoadStr(FIND_FILE_ABORTED);
break;
case ffDone:
StatusBar->SimpleText = LoadStr(FIND_FILE_DONE);
break;
default:
assert(false);
break;
}
}
static FILE *LocalOpenLogFile(UnicodeString LogFileName, TDateTime Started, TSessionData *SessionData, bool Append, UnicodeString &ANewFileName)
{
UnicodeString NewFileName = StripPathQuotes(GetExpandedLogFileName(LogFileName, Started, SessionData));
FILE *Result = _wfsopen(ApiPath(NewFileName).c_str(),
Append ? L"ab" : L"wb", SH_DENYWR);
if (Result != nullptr)
{
setvbuf(Result, nullptr, _IONBF, BUFSIZ);
ANewFileName = NewFileName;
}
else
{
throw ECRTExtException(FMTLOAD(LOG_OPENERROR, NewFileName));
}
return Result;
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TConfiguration::GetVersionStr()
{
TGuard Guard(FCriticalSection);
try
{
TVSFixedFileInfo * Info = FixedApplicationInfo;
return FMTLOAD(VERSION, (
HIWORD(Info->dwFileVersionMS),
LOWORD(Info->dwFileVersionMS),
HIWORD(Info->dwFileVersionLS),
LOWORD(Info->dwFileVersionLS)));
}
catch (Exception &E)
{
throw ExtException(&E, L"Can't get application version");
}
}
static bool ExceptionMessage(const Exception * E, bool /*Count*/,
bool Formatted, UnicodeString & Message, bool & InternalError)
{
bool Result = true;
const wchar_t * CounterName = nullptr;
InternalError = false; // see also IsInternalException
// this list has to be in sync with CloneException
if (isa<EAbort>(E))
{
Result = false;
}
else if (WellKnownException(E, &Message, &CounterName, nullptr, false))
{
InternalError = true;
}
else if (E && E->Message.IsEmpty())
{
Result = false;
}
else if (E)
{
Message = E->Message;
}
if (!Formatted)
{
Message = UnformatMessage(Message);
}
if (InternalError)
{
Message = FMTLOAD(REPORT_ERROR, Message.c_str());
}
/*
if (Count && (CounterName != nullptr) && (Configuration->Usage != nullptr))
{
Configuration->Usage->Inc(CounterName);
UnicodeString ExceptionDebugInfo =
E->ClassName() + L":" + GetExceptionDebugInfo();
Configuration->Usage->Set(LastInternalExceptionCounter, ExceptionDebugInfo);
}
*/
return Result;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
FILE * OpenFile(const UnicodeString & LogFileName, TSessionData * SessionData, bool Append, UnicodeString & NewFileName)
{
FILE * Result;
UnicodeString ANewFileName = StripPathQuotes(GetExpandedLogFileName(LogFileName, SessionData));
// Result = _wfopen(ANewFileName.c_str(), (Append ? L"a" : L"w"));
Result = _fsopen(W2MB(ANewFileName.c_str()).c_str(),
Append ? "a" : "w", SH_DENYWR); // _SH_DENYNO); //
if (Result != nullptr)
{
setvbuf(Result, nullptr, _IONBF, BUFSIZ);
NewFileName = ANewFileName;
}
else
{
throw Exception(FMTLOAD(LOG_OPENERROR, ANewFileName.c_str()));
}
return Result;
}