//---------------------------------------------------------------------------
void __fastcall TCopyDialog::UpdateControls()
{
if (!FToRemote && FLAGSET(FOptions, coAllowRemoteTransfer))
{
UnicodeString Directory = DirectoryEdit->Text;
bool RemoteTransfer = (Directory.Pos(L"\\") == 0) && (Directory.Pos(L"/") > 0);
if (RemoteTransfer != FLAGSET(FOutputOptions, cooRemoteTransfer))
{
FOutputOptions =
(FOutputOptions & ~cooRemoteTransfer) |
FLAGMASK(RemoteTransfer, cooRemoteTransfer);
AdjustTransferControls();
}
}
UnicodeString InfoStr = FCopyParams.GetInfoStr(L"; ", FCopyParamAttrs);
CopyParamLabel->Caption = InfoStr;
CopyParamLabel->Hint = InfoStr;
CopyParamLabel->ShowHint =
(CopyParamLabel->Canvas->TextWidth(InfoStr) > (CopyParamLabel->Width * 3 / 2));
bool RemoteTransfer = FLAGSET(FOutputOptions, cooRemoteTransfer);
EnableControl(QueueCheck2,
((FOptions & (coDisableQueue | coTemp)) == 0) && !RemoteTransfer);
QueueIndividuallyCheck->Visible =
FLAGCLEAR(FOptions, coNoQueueIndividually) &&
QueueCheck2->Enabled && QueueCheck2->Checked &&
(FFileList != NULL) && (FFileList->Count > 1);
TransferSettingsButton->Style =
FLAGCLEAR(FOptions, coDoNotUsePresets) ?
TCustomButton::bsSplitButton : TCustomButton::bsPushButton;
}
//---------------------------------------------------------------------------
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 __fastcall TSynchronizeDialog::UpdateControls()
{
EnableControl(StartButton, !LocalDirectoryEdit->Text.IsEmpty() &&
!RemoteDirectoryEdit->Text.IsEmpty());
TButton * OldButton = FSynchronizing ? StartButton : StopButton;
TButton * NewButton = FSynchronizing ? StopButton : StartButton;
if (!NewButton->Visible || OldButton->Visible)
{
NewButton->Visible = true;
if (OldButton->Focused())
{
NewButton->SetFocus();
}
OldButton->Default = false;
NewButton->Default = true;
OldButton->Visible = false;
// some of the above steps hides accelerators when start button is pressed with mouse
ResetSystemSettings(this);
}
Caption = FormatFormCaption(this, LoadStr(FSynchronizing ? SYNCHRONIZE_SYCHRONIZING : SYNCHRONIZE_TITLE));
EnableControl(TransferSettingsButton, !FSynchronizing);
CancelButton->Visible = !FSynchronizing || FLAGSET(FOptions, soNoMinimize);
EnableControl(CancelButton, !FSynchronizing);
EnableControl(DirectoriesGroup, !FSynchronizing);
EnableControl(OptionsGroup, !FSynchronizing);
EnableControl(CopyParamGroup, !FSynchronizing);
MinimizeButton->Visible = FSynchronizing && FLAGCLEAR(FOptions, soNoMinimize);
EnableControl(SynchronizeSelectedOnlyCheck,
OptionsGroup->Enabled && FLAGSET(FOptions, soAllowSelectedOnly));
UnicodeString InfoStr = CopyParams.GetInfoStr(L"; ", ActualCopyParamAttrs());
CopyParamLabel->Caption = InfoStr;
CopyParamLabel->Hint = InfoStr;
CopyParamLabel->ShowHint =
(CopyParamLabel->Canvas->TextWidth(InfoStr) > (CopyParamLabel->Width * 3 / 2));
TransferSettingsButton->Style =
FLAGCLEAR(Options, soDoNotUsePresets) ?
TCustomButton::bsSplitButton : TCustomButton::bsPushButton;
if (LogPanel->Visible != FSynchronizing)
{
if (FSynchronizing)
{
LogPanel->Visible = true;
ClientHeight = ClientHeight + LogPanel->Height;
}
else
{
ClientHeight = ClientHeight - LogPanel->Height;
LogPanel->Visible = false;
}
}
// When minimizing to tray globally, no point showing special "minimize to tray" command
MinimizeButton->Style =
!WinConfiguration->MinimizeToTray ? TCustomButton::bsSplitButton : TCustomButton::bsPushButton;
}
bool IsPasswordOrPassphrasePrompt(TPromptKind Kind, TStrings * Prompts)
{
return
(Prompts->GetCount() == 1) && FLAGCLEAR(reinterpret_cast<intptr_t>(Prompts->GetObj(0)), pupEcho) &&
((Kind == pkPassword) || (Kind == pkPassphrase) || (Kind == pkKeybInteractive) ||
(Kind == pkTIS) || (Kind == pkCryptoCard));
}
//---------------------------------------------------------------------------
unsigned int __fastcall FatalExceptionMessageDialog(Exception * E, TQueryType Type,
int SessionReopenTimeout, const UnicodeString MessageFormat, unsigned int Answers,
UnicodeString HelpKeyword, const TMessageParams * Params)
{
assert(FLAGCLEAR(Answers, qaRetry));
Answers |= qaRetry;
TQueryButtonAlias Aliases[1];
Aliases[0].Button = qaRetry;
Aliases[0].Alias = LoadStr(RECONNECT_BUTTON);
TMessageParams AParams;
if (Params != NULL)
{
AParams = *Params;
}
assert(AParams.Timeout == 0);
// the condition is de facto excess
if (SessionReopenTimeout > 0)
{
AParams.Timeout = SessionReopenTimeout;
AParams.TimeoutAnswer = qaRetry;
}
assert(AParams.Aliases == NULL);
AParams.Aliases = Aliases;
AParams.AliasesCount = LENOF(Aliases);
return ExceptionMessageDialog(E, Type, MessageFormat, Answers, HelpKeyword, &AParams);
}
//---------------------------------------------------------------------------
bool __fastcall TCopyDialog::Execute()
{
// at start assume that copy param is current preset
FPreset = GUIConfiguration->CopyParamCurrent;
DirectoryEdit->Items = CustomWinConfiguration->History[
FToRemote ? L"RemoteTarget" : L"LocalTarget"];
bool Result = (ShowModal() == DefaultResult(this));
if (Result)
{
Configuration->BeginUpdate();
try
{
if (FLAGSET(OutputOptions, cooSaveSettings) &&
FLAGCLEAR(FOptions, coDisableSaveSettings))
{
GUIConfiguration->DefaultCopyParam = Params;
}
DirectoryEdit->SaveToHistory();
CustomWinConfiguration->History[FToRemote ?
L"RemoteTarget" : L"LocalTarget"] = DirectoryEdit->Items;
}
__finally
{
Configuration->EndUpdate();
}
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TFullSynchronizeDialog::CopyParamGroupContextPopup(
TObject * /*Sender*/, TPoint & MousePos, bool & Handled)
{
if (FLAGCLEAR(FOptions, fsoDoNotUsePresets))
{
CopyParamListPopup(CalculatePopupRect(CopyParamGroup, MousePos), cplCustomizeDefault);
Handled = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TFullSynchronizeDialog::UpdateControls()
{
EnableControl(SynchronizeTimestampsButton, FLAGCLEAR(Options, fsoDisableTimestamp));
if (SynchronizeTimestampsButton->Checked)
{
SynchronizeExistingOnlyCheck->Checked = true;
SynchronizeDeleteCheck->Checked = false;
SynchronizeByTimeCheck->Checked = true;
}
if (SynchronizeBothButton->Checked)
{
SynchronizeByTimeCheck->Checked = true;
SynchronizeBySizeCheck->Checked = false;
if (MirrorFilesButton->Checked)
{
SynchronizeFilesButton->Checked = true;
}
}
EnableControl(MirrorFilesButton, !SynchronizeBothButton->Checked);
EnableControl(SynchronizeDeleteCheck, !SynchronizeBothButton->Checked &&
!SynchronizeTimestampsButton->Checked);
EnableControl(SynchronizeExistingOnlyCheck, !SynchronizeTimestampsButton->Checked);
EnableControl(SynchronizeByTimeCheck, !SynchronizeBothButton->Checked &&
!SynchronizeTimestampsButton->Checked);
EnableControl(SynchronizeBySizeCheck, !SynchronizeBothButton->Checked);
EnableControl(SynchronizeSelectedOnlyCheck, FLAGSET(FOptions, fsoAllowSelectedOnly));
EnableControl(OkButton, !LocalDirectoryEdit->Text.IsEmpty() &&
!RemoteDirectoryEdit->Text.IsEmpty());
UnicodeString InfoStr = FCopyParams.GetInfoStr(L"; ", ActualCopyParamAttrs());
CopyParamLabel->Caption = InfoStr;
CopyParamLabel->Hint = InfoStr;
CopyParamLabel->ShowHint =
(CopyParamLabel->Canvas->TextWidth(InfoStr) > (CopyParamLabel->Width * 3 / 2));
SynchronizeBySizeCheck->Caption = SynchronizeTimestampsButton->Checked ?
LoadStr(SYNCHRONIZE_SAME_SIZE) : UnicodeString(FSynchronizeBySizeCaption);
TransferSettingsButton->Style =
FLAGCLEAR(Options, fsoDoNotUsePresets) ?
TCustomButton::bsSplitButton : TCustomButton::bsPushButton;
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::TransferSettingsButtonClick(TObject * /*Sender*/)
{
if (FLAGCLEAR(FOptions, coDoNotUsePresets) && !SupportsSplitButton())
{
CopyParamListPopup(CalculatePopupRect(TransferSettingsButton), 0);
}
else
{
CopyParamGroupClick(NULL);
}
}
//---------------------------------------------------------------------------
TCopyParamType __fastcall TFullSynchronizeDialog::GetCopyParams()
{
TCopyParamType Result = FCopyParams;
// when synchronizing by time, we force preserving time,
// otherwise it does not make any sense
if (FLAGCLEAR(Params, spNotByTime))
{
Result.PreserveTime = true;
}
Result.NewerOnly = false;
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TFullSynchronizeDialog::CopyParamClick(TObject * Sender)
{
assert(FLAGCLEAR(FOptions, fsoDoNotUsePresets));
// PreserveTime is forced for some settings, but avoid hard-setting it until
// user really confirms it on custom dialog
TCopyParamType ACopyParams = CopyParams;
if (CopyParamListPopupClick(Sender, ACopyParams, FPreset,
ActualCopyParamAttrs()))
{
FCopyParams = ACopyParams;
UpdateControls();
}
}
//---------------------------------------------------------------------------
void __fastcall TCopyDialog::CopyParamListPopup(TRect R, int AdditionalOptions)
{
bool RemoteTransfer = FLAGSET(FOutputOptions, cooRemoteTransfer);
::CopyParamListPopup(R, FPresetsMenu,
FCopyParams, FPreset, CopyParamClick,
cplCustomize | AdditionalOptions |
FLAGMASK(
FLAGCLEAR(FOptions, coDisableSaveSettings) && !RemoteTransfer,
cplSaveSettings),
FCopyParamAttrs,
FSaveSettings);
}
//---------------------------------------------------------------------------
int __fastcall TFullSynchronizeDialog::GetParams()
{
return FParams |
FLAGMASK(SynchronizeDeleteCheck->Checked, spDelete) |
FLAGMASK(SynchronizeExistingOnlyCheck->Checked, spExistingOnly) |
FLAGMASK(SynchronizePreviewChangesCheck->Checked, spPreviewChanges) |
FLAGMASK(SynchronizeSelectedOnlyCheck->Checked, spSelectedOnly) |
FLAGMASK(SynchronizeTimestampsButton->Checked && FLAGCLEAR(Options, fsoDisableTimestamp),
spTimestamp) |
FLAGMASK(MirrorFilesButton->Checked, spMirror) |
FLAGMASK(!SynchronizeByTimeCheck->Checked, spNotByTime) |
FLAGMASK(SynchronizeBySizeCheck->Checked, spBySize);
}
//---------------------------------------------------------------------------
void __fastcall TAuthenticateForm::Banner(const UnicodeString & Banner,
bool & NeverShowAgain, int Options)
{
BannerMemo->Lines->Text = Banner;
NeverShowAgainCheck->Visible = FLAGCLEAR(Options, boDisableNeverShowAgain);
NeverShowAgainCheck->Checked = NeverShowAgain;
bool Result = Execute(LoadStr(AUTHENTICATION_BANNER), BannerPanel, BannerCloseButton,
BannerCloseButton, BannerCloseButton, false, true, false);
if (Result)
{
NeverShowAgain = NeverShowAgainCheck->Checked;
}
}
//---------------------------------------------------------------------------
void __fastcall TFullSynchronizeDialog::SetParams(int value)
{
FParams = value & ~(spDelete | spExistingOnly |
spPreviewChanges | spTimestamp | spNotByTime | spBySize | spSelectedOnly | spMirror);
SynchronizeDeleteCheck->Checked = FLAGSET(value, spDelete);
SynchronizeExistingOnlyCheck->Checked = FLAGSET(value, spExistingOnly);
SynchronizePreviewChangesCheck->Checked = FLAGSET(value, spPreviewChanges);
SynchronizeSelectedOnlyCheck->Checked = FLAGSET(value, spSelectedOnly);
if (FLAGSET(value, spTimestamp) && FLAGCLEAR(Options, fsoDisableTimestamp))
{
SynchronizeTimestampsButton->Checked = true;
}
else if (FLAGSET(value, spMirror))
{
MirrorFilesButton->Checked = true;
}
else
{
SynchronizeFilesButton->Checked = true;
}
SynchronizeByTimeCheck->Checked = FLAGCLEAR(value, spNotByTime);
SynchronizeBySizeCheck->Checked = FLAGSET(value, spBySize);
UpdateControls();
}
//---------------------------------------------------------------------------
__fastcall TCustomCommandDialog::TCustomCommandDialog(TComponent* Owner,
const TCustomCommandList * CustomCommandList, TCustomCommandsMode Mode,
int Options, TCustomCommandValidate OnValidate, const TShortCuts * ShortCuts)
: TForm(Owner)
{
SetCorrectFormParent(this);
UseSystemSettings(this);
FCustomCommandList = CustomCommandList;
FMode = Mode;
FOnValidate = OnValidate;
HintLabel(HintText, LoadStr(CUSTOM_COMMAND_PATTERNS_HINT3));
int CaptionRes;
switch (FMode)
{
case ccmAdd:
CaptionRes = CUSTOM_COMMAND_ADD;
break;
case ccmEdit:
CaptionRes = CUSTOM_COMMAND_EDIT;
break;
case ccmAdHoc:
default:
CaptionRes = CUSTOM_COMMAND_AD_HOC;
break;
}
Caption = LoadStr(CaptionRes);
if (FMode == ccmAdHoc)
{
int Shift = CommandEdit->Top - DescriptionEdit->Top;
int Shift2 = Group->Height - ShortCutLabel->Top;
DescriptionLabel->Visible = false;
DescriptionEdit->Visible = false;
for (int i = 0; i < Group->ControlCount; i++)
{
TControl * Control = Group->Controls[i];
if (Control->Visible)
{
if (Control->Top > DescriptionLabel->Top)
{
Control->Top = Control->Top - Shift;
}
}
}
ShortCutLabel->Visible = false;
ShortCutCombo->Visible = false;
ClientHeight = ClientHeight - Shift - Shift2;
}
else
{
assert(ShortCuts != NULL);
InitializeShortCutCombo(ShortCutCombo, *ShortCuts);
}
EnableControl(RemoteCommandButton, FLAGCLEAR(Options, ccoDisableRemote));
UpdateControls();
}
//---------------------------------------------------------------------------
bool __fastcall TAuthenticateForm::PromptUser(TPromptKind Kind, UnicodeString Name,
UnicodeString Instructions, TStrings * Prompts, TStrings * Results, bool ForceLog,
bool StoredCredentialsTried)
{
bool Result;
TList * Edits = GeneratePrompt(Instructions, Prompts);
try
{
bool ShowSessionRememberPasswordPanel = false;
bool ShowSavePasswordPanel = false;
TSessionData * Data = NULL;
bool PasswordPrompt =
((Kind == pkPassword) || (Kind == pkTIS) || (Kind == pkCryptoCard) ||
(Kind == pkKeybInteractive)) &&
(Prompts->Count == 1) && FLAGCLEAR(int(Prompts->Objects[0]), pupEcho);
if (PasswordPrompt && StoredCredentialsTried)
{
Data = StoredSessions->FindSame(FSessionData);
ShowSavePasswordPanel = (Data != NULL) && !Data->Password.IsEmpty();
}
// do not offer to rememeber password,
// if we are offering to save the password to stored session
if (!ShowSavePasswordPanel &&
(Prompts->Count == 1) &&
FLAGSET(int(Prompts->Objects[0]), pupRemember) &&
ALWAYS_TRUE(PasswordPrompt))
{
ShowSessionRememberPasswordPanel = true;
}
SavePasswordCheck->Checked = false;
SavePasswordPanel->Visible = ShowSavePasswordPanel;
SessionRememberPasswordCheck->Checked = false;
SessionRememberPasswordPanel->Visible = ShowSessionRememberPasswordPanel;
if (PasswordPanel->AutoSize)
{
PasswordPanel->AutoSize = false;
PasswordPanel->AutoSize = true;
}
PasswordPanel->Realign();
assert(Results->Count == Edits->Count);
for (int Index = 0; Index < Edits->Count; Index++)
{
TCustomEdit * Edit = reinterpret_cast<TCustomEdit *>(Edits->Items[Index]);
Edit->Text = Results->Strings[Index];
}
Result = Execute(Name, PasswordPanel,
((Edits->Count > 0) ?
reinterpret_cast<TWinControl *>(Edits->Items[0]) :
static_cast<TWinControl *>(PasswordOKButton)),
PasswordOKButton, PasswordCancelButton, true, false, ForceLog);
if (Result)
{
for (int Index = 0; Index < Edits->Count; Index++)
{
TCustomEdit * Edit = reinterpret_cast<TCustomEdit *>(Edits->Items[Index]);
Results->Strings[Index] = Edit->Text;
Prompts->Objects[Index] = (TObject *)
((int(Prompts->Objects[Index]) & ~pupRemember) |
FLAGMASK(((Index == 0) && SessionRememberPasswordCheck->Checked), pupRemember));
}
if (SavePasswordCheck->Checked)
{
assert(Data != NULL);
assert(Results->Count >= 1);
FSessionData->Password = Results->Strings[0];
Data->Password = Results->Strings[0];
// modified only, explicit
StoredSessions->Save(false, true);
}
}
}
__finally
{
delete Edits;
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall CopyParamListPopup(TRect Rect, TPopupMenu * Menu,
const TCopyParamType & Param, UnicodeString Preset, TNotifyEvent OnClick,
int Options, int CopyParamAttrs, bool SaveSettings)
{
Menu->Items->Clear();
TMenuItem * CustomizeItem = NULL;
TMenuItem * Item;
if (FLAGSET(Options, cplCustomize))
{
Item = new TMenuItem(Menu);
Item->Caption = LoadStr(COPY_PARAM_CUSTOM);
Item->Tag = cpiCustom;
Item->Default = FLAGSET(Options, cplCustomizeDefault);
Item->OnClick = OnClick;
Menu->Items->Add(Item);
CustomizeItem = Item;
}
if (FLAGSET(Options, cplSaveSettings))
{
Item = new TMenuItem(Menu);
Item->Caption = LoadStr(COPY_PARAM_SAVE_SETTINGS);
Item->Tag = cpiSaveSettings;
Item->Checked = SaveSettings;
Item->OnClick = OnClick;
Menu->Items->Add(Item);
}
Item = new TMenuItem(Menu);
Item->Caption = LoadStr(COPY_PARAM_PRESET_HEADER);
Item->Visible = false;
Item->Enabled = false;
Menu->Items->Add(Item);
bool AnyChecked = false;
Item = new TMenuItem(Menu);
Item->Caption = LoadStr(COPY_PARAM_DEFAULT);
Item->Tag = cpiDefault;
Item->Checked =
Preset.IsEmpty() && (GUIConfiguration->CopyParamPreset[L""] == Param);
AnyChecked = AnyChecked || Item->Checked;
Item->OnClick = OnClick;
Menu->Items->Add(Item);
TCopyParamType DefaultParam;
const TCopyParamList * CopyParamList = GUIConfiguration->CopyParamList;
for (int i = 0; i < CopyParamList->Count; i++)
{
UnicodeString Name = CopyParamList->Names[i];
TCopyParamType AParam = GUIConfiguration->CopyParamPreset[Name];
if (AParam.AnyUsableCopyParam(CopyParamAttrs) ||
// This makes "Binary" preset visible,
// as long as we care about transfer mode
((AParam == DefaultParam) &&
FLAGCLEAR(CopyParamAttrs, cpaIncludeMaskOnly) &&
FLAGCLEAR(CopyParamAttrs, cpaNoTransferMode)))
{
Item = new TMenuItem(Menu);
Item->Caption = Name;
Item->Tag = i;
Item->Checked =
(Preset == Name) && (AParam == Param);
AnyChecked = AnyChecked || Item->Checked;
Item->OnClick = OnClick;
Menu->Items->Add(Item);
}
}
if (CustomizeItem != NULL)
{
CustomizeItem->Checked = !AnyChecked;
}
Item = new TMenuItem(Menu);
Item->Caption = L"-";
Menu->Items->Add(Item);
Item = new TMenuItem(Menu);
Item->Caption = LoadStr(COPY_PARAM_CONFIGURE);
Item->Tag = cpiConfigure;
Item->OnClick = OnClick;
Menu->Items->Add(Item);
MenuPopup(Menu, Rect, NULL);
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeChecklistDialog::StatusBarDrawPanel(
TStatusBar * StatusBar, TStatusPanel * Panel, const TRect & Rect)
{
bool Possible;
TSynchronizeChecklist::TAction Action = TSynchronizeChecklist::TAction(Panel->Index);
switch (Action)
{
case TSynchronizeChecklist::saNone:
Possible = true;
break;
case TSynchronizeChecklist::saUploadNew:
Possible = ((FMode == smRemote) || (FMode == smBoth)) &&
FLAGCLEAR(FParams, spTimestamp);
break;
case TSynchronizeChecklist::saDownloadNew:
Possible = ((FMode == smLocal) || (FMode == smBoth)) &&
FLAGCLEAR(FParams, spTimestamp);
break;
case TSynchronizeChecklist::saUploadUpdate:
Possible =
((FMode == smRemote) || (FMode == smBoth)) &&
(FLAGCLEAR(FParams, spNotByTime) || FLAGSET(FParams, spBySize));
break;
case TSynchronizeChecklist::saDownloadUpdate:
Possible =
((FMode == smLocal) || (FMode == smBoth)) &&
(FLAGCLEAR(FParams, spNotByTime) || FLAGSET(FParams, spBySize));
break;
case TSynchronizeChecklist::saDeleteRemote:
Possible = (FMode == smRemote) &&
FLAGCLEAR(FParams, spTimestamp);
break;
case TSynchronizeChecklist::saDeleteLocal:
Possible = (FMode == smLocal) &&
FLAGCLEAR(FParams, spTimestamp);
break;
default:
assert(false);
Possible = false;
break;
}
int ImageIndex = Panel->Index;
UnicodeString PanelText;
if (Possible)
{
PanelText = FORMAT(LoadStrPart(SYNCHRONIZE_SELECTED_ACTIONS, 1),
(FormatNumber(FChecked[Panel->Index]),
FormatNumber(FTotals[Panel->Index])));
}
else
{
PanelText = LoadStrPart(SYNCHRONIZE_SELECTED_ACTIONS, 2);
}
int TextHeight = StatusBar->Canvas->TextHeight(PanelText);
int X = Rect.Left + ActionImages->Width + 4;
int Y = (Rect.Top + Rect.Bottom - TextHeight) / 2;
StatusBar->Canvas->TextRect(Rect, X, Y, PanelText);
X = Rect.Left + 1;
Y = ((Rect.Top + Rect.Bottom - ActionImages->Height) / 2);
ActionImages->Draw(StatusBar->Canvas, X, Y, ImageIndex, Possible);
}
void TCopyParamType::DoGetInfoStr(
const UnicodeString & Separator, intptr_t Options,
UnicodeString & Result, bool & SomeAttrIncluded,
const UnicodeString & Link, UnicodeString & ScriptArgs, bool & NoScriptArgs, /*TAssemblyLanguage Language, UnicodeString & AssemblyCode,*/
bool & NoCodeProperties) const
{
TCopyParamType Defaults;
bool SomeAttrExcluded = false;
NoScriptArgs = false;
NoCodeProperties = false;
SomeAttrIncluded = false;
#define ADD(STR, EXCEPT) \
if (FLAGCLEAR(Options, EXCEPT)) \
{ \
AddToList(Result, (STR), Separator); \
SomeAttrIncluded = true; \
} \
else \
{ \
SomeAttrExcluded = true; \
}
bool AsciiFileMaskDiffers = (GetTransferMode() == tmAutomatic) && !(GetAsciiFileMask() == Defaults.GetAsciiFileMask());
bool TransferModeDiffers = ((GetTransferMode() != Defaults.GetTransferMode()) || AsciiFileMaskDiffers);
if (FLAGCLEAR(Options, cpaIncludeMaskOnly | cpaNoTransferMode))
{
// Adding Transfer type unconditionally
bool FormatMask;
int Ident;
switch (GetTransferMode())
{
case tmBinary:
FormatMask = false;
Ident = 2;
break;
case tmAscii:
FormatMask = false;
Ident = 3;
break;
case tmAutomatic:
default:
FormatMask = !(GetAsciiFileMask() == Defaults.GetAsciiFileMask());
Ident = FormatMask ? 4 : 5;
break;
}
UnicodeString S = FORMAT(LoadStrPart(COPY_INFO_TRANSFER_TYPE2, 1).c_str(),
LoadStrPart(COPY_INFO_TRANSFER_TYPE2, Ident).c_str());
if (FormatMask)
{
S = FORMAT(S.c_str(), GetAsciiFileMask().GetMasks().c_str());
}
AddToList(Result, S, Separator);
if (TransferModeDiffers)
{
ADD("", cpaIncludeMaskOnly | cpaNoTransferMode);
/*ScriptArgs += RtfSwitchValue(TRANSFER_SWITCH, Link, TransferModeNames[TransferMode]);
const wchar_t * TransferModeMembers[] = { L"Binary", L"Ascii", L"Automatic" };
AssemblyCode += AssemblyProperty(
Language, TransferOptionsClassName, L"TransferMode", L"TransferMode", TransferModeMembers[TransferMode], false);
if (AsciiFileMaskDiffers)
{
NoScriptArgs = true;
NoCodeProperties = true;
}*/
}
}
else
{
if (TransferModeDiffers)
{
SomeAttrExcluded = true;
NoScriptArgs = true;
NoCodeProperties = true;
}
}
if (GetFileNameCase() != Defaults.GetFileNameCase())
{
ADD(FORMAT(LoadStrPart(COPY_INFO_FILENAME, 1).c_str(),
LoadStrPart(COPY_INFO_FILENAME, GetFileNameCase() + 2).c_str()),
cpaIncludeMaskOnly);
NoScriptArgs = true;
NoCodeProperties = true;
}
if ((GetInvalidCharsReplacement() == NoReplacement) !=
(Defaults.GetInvalidCharsReplacement() == NoReplacement))
{
DebugAssert(GetInvalidCharsReplacement() == NoReplacement);
if (GetInvalidCharsReplacement() == NoReplacement)
{
ADD(LoadStr(COPY_INFO_DONT_REPLACE_INV_CHARS).c_str(), cpaIncludeMaskOnly);
}
NoScriptArgs = true;
NoCodeProperties = true;
}
if ((GetPreserveRights() != Defaults.GetPreserveRights()) ||
(GetPreserveRights() &&
((GetRights() != Defaults.GetRights()) || (GetAddXToDirectories() != Defaults.GetAddXToDirectories()))))
{
const int Except = cpaIncludeMaskOnly | cpaNoRights;
if (DebugAlwaysTrue(GetPreserveRights()))
{
UnicodeString RightsStr = GetRights().GetText();
if (GetAddXToDirectories())
{
RightsStr += L", " + LoadStr(COPY_INFO_ADD_X_TO_DIRS);
}
ADD(FORMAT(LoadStr(COPY_INFO_PERMISSIONS).c_str(), RightsStr.c_str()),
Except);
if (FLAGCLEAR(Options, Except))
{
// ScriptArgs += RtfSwitchValue(PERMISSIONS_SWITCH, Link, Rights.Octal);
// const UnicodeString FilePermissionsClassName = L"FilePermissions";
// const bool Inline = true;
// UnicodeString FilePermissions =
// AssemblyNewClassInstanceStart(Language, FilePermissionsClassName, Inline) +
// AssemblyProperty(Language, FilePermissionsClassName, L"Octal", Rights.Octal, Inline) +
// AssemblyNewClassInstanceEnd(Language, Inline);
// AssemblyCode += AssemblyPropertyRaw(Language, TransferOptionsClassName, L"FilePermissions", FilePermissions, false);
}
}
if ((GetAddXToDirectories() != Defaults.GetAddXToDirectories()) && FLAGCLEAR(Options, Except))
{
NoScriptArgs = true;
NoCodeProperties = true;
}
}
bool APreserveTimeDirs = GetPreserveTime() && GetPreserveTimeDirs();
if ((GetPreserveTime() != Defaults.GetPreserveTime()) || (APreserveTimeDirs != Defaults.GetPreserveTimeDirs()))
{
bool AddPreserveTime = false;
UnicodeString Str = LoadStr(GetPreserveTime() ? COPY_INFO_TIMESTAMP : COPY_INFO_DONT_PRESERVE_TIME);
const int ExceptDirs = cpaNoPreserveTimeDirs;
if (APreserveTimeDirs != Defaults.GetPreserveTimeDirs())
{
if (DebugAlwaysTrue(GetPreserveTimeDirs()))
{
if (FLAGCLEAR(Options, ExceptDirs))
{
Str = FMTLOAD(COPY_INFO_PRESERVE_TIME_DIRS, (Str));
AddPreserveTime = true;
}
}
ADD("", ExceptDirs);
}
const int Except = cpaIncludeMaskOnly | cpaNoPreserveTime;
if (GetPreserveTime() != Defaults.GetPreserveTime())
{
if (FLAGCLEAR(Options, Except))
{
AddPreserveTime = true;
}
ADD(L"", Except);
}
if (AddPreserveTime)
{
AddToList(Result, Str, Separator);
}
if (FLAGCLEAR(Options, Except))
{
if (GetPreserveTime())
{
if (GetPreserveTimeDirs() && FLAGCLEAR(Options, ExceptDirs))
{
//ScriptArgs += RtfSwitchValue(PRESERVETIME_SWITCH, Link, PRESERVETIMEDIRS_SWITCH_VALUE);
NoCodeProperties = true;
}
else
{
DebugFail(); // should never get here
//ScriptArgs += RtfSwitch(PRESERVETIME_SWITCH, Link);
}
}
else
{
// ScriptArgs += RtfSwitch(NOPRESERVETIME_SWITCH, Link);
// AssemblyCode += AssemblyProperty(Language, TransferOptionsClassName, L"PreserveTimestamp", false, false);
}
}
}
if ((GetPreserveRights() || GetPreserveTime()) &&
(GetIgnorePermErrors() != Defaults.GetIgnorePermErrors()))
{
if (DebugAlwaysTrue(GetIgnorePermErrors()))
{
const int Except = cpaIncludeMaskOnly | cpaNoIgnorePermErrors;
ADD(LoadStr(COPY_INFO_IGNORE_PERM_ERRORS), Except);
if (FLAGCLEAR(Options, Except))
{
NoScriptArgs = true;
NoCodeProperties = true;
}
}
}
if (GetPreserveReadOnly() != Defaults.GetPreserveReadOnly())
{
if (DebugAlwaysTrue(GetPreserveReadOnly()))
{
const int Except = cpaIncludeMaskOnly | cpaNoPreserveReadOnly;
ADD(LoadStr(COPY_INFO_PRESERVE_READONLY), Except);
if (FLAGCLEAR(Options, Except))
{
NoScriptArgs = true;
NoCodeProperties = true;
}
}
}
if (GetCalculateSize() != Defaults.GetCalculateSize())
{
if (DebugAlwaysTrue(!GetCalculateSize()))
{
ADD(LoadStr(COPY_INFO_DONT_CALCULATE_SIZE), cpaIncludeMaskOnly);
// Always false in scripting, in assembly controlled by use of FileTransferProgress
}
}
if (GetClearArchive() != Defaults.GetClearArchive())
{
if (DebugAlwaysTrue(GetClearArchive()))
{
const int Except = cpaIncludeMaskOnly | cpaNoClearArchive;
ADD(LoadStr(COPY_INFO_CLEAR_ARCHIVE), Except);
if (FLAGCLEAR(Options, Except))
{
NoScriptArgs = true;
NoCodeProperties = true;
}
}
}
if ((GetTransferMode() == tmAscii) || (GetTransferMode() == tmAutomatic))
{
if (GetRemoveBOM() != Defaults.GetRemoveBOM())
{
if (DebugAlwaysTrue(GetRemoveBOM()))
{
const int Except = cpaIncludeMaskOnly | cpaNoRemoveBOM | cpaNoTransferMode;
ADD(LoadStr(COPY_INFO_REMOVE_BOM), Except);
if (FLAGCLEAR(Options, Except))
{
NoScriptArgs = true;
NoCodeProperties = true;
}
}
}
if (GetRemoveCtrlZ() != Defaults.GetRemoveCtrlZ())
{
if (DebugAlwaysTrue(GetRemoveCtrlZ()))
{
const int Except = cpaIncludeMaskOnly | cpaNoRemoveCtrlZ | cpaNoTransferMode;
ADD(LoadStr(COPY_INFO_REMOVE_CTRLZ),Except);
if (FLAGCLEAR(Options, Except))
{
NoScriptArgs = true;
NoCodeProperties = true;
}
}
}
}
if (!(GetIncludeFileMask() == Defaults.GetIncludeFileMask()))
{
ADD(FORMAT(LoadStr(COPY_INFO_FILE_MASK).c_str(), GetIncludeFileMask().GetMasks().c_str()),
cpaNoIncludeMask);
// ScriptArgs += RtfSwitch(FILEMASK_SWITCH, Link, IncludeFileMask.Masks);
// AssemblyCode += AssemblyProperty(Language, TransferOptionsClassName, L"FileMask", IncludeFileMask.Masks, false);
}
DebugAssert(FTransferSkipList.get() == nullptr);
DebugAssert(FTransferResumeFile.IsEmpty());
if (GetCPSLimit() > 0)
{
intptr_t LimitKB = intptr_t(GetCPSLimit() / 1024);
ADD(FMTLOAD(COPY_INFO_CPS_LIMIT2, (LimitKB)), cpaIncludeMaskOnly);
// ScriptArgs += RtfSwitch(SPEED_SWITCH, Link, LimitKB);
// AssemblyCode += AssemblyProperty(Language, TransferOptionsClassName, L"Speed", LimitKB, false);
}
if (GetNewerOnly() != Defaults.GetNewerOnly())
{
if (DebugAlwaysTrue(GetNewerOnly()))
{
const int Except = cpaIncludeMaskOnly | cpaNoNewerOnly;
ADD(StripHotkey(LoadStr(COPY_PARAM_NEWER_ONLY)), Except);
if (FLAGCLEAR(Options, Except))
{
// ScriptArgs += RtfSwitch(NEWERONLY_SWICH, Link);
NoCodeProperties = true;
}
}
}
bool ResumeThresholdDiffers = ((GetResumeSupport() == rsSmart) && (GetResumeThreshold() != Defaults.GetResumeThreshold()));
if (((GetResumeSupport() != Defaults.GetResumeSupport()) || ResumeThresholdDiffers) &&
(GetTransferMode() != tmAscii) && FLAGCLEAR(Options, cpaNoResumeSupport))
{
UnicodeString Value;
UnicodeString CodeState;
intptr_t ResumeThresholdKB = (GetResumeThreshold() / 1024);
switch (GetResumeSupport())
{
case rsOff:
Value = ToggleNames[ToggleOff];
CodeState = L"Off";
break;
case rsOn:
Value = ToggleNames[ToggleOn];
CodeState = L"On";
break;
case rsSmart:
Value = IntToStr(ResumeThresholdKB);
break;
}
// ScriptArgs += RtfSwitchValue(RESUMESUPPORT_SWITCH, Link, Value);
const UnicodeString ResumeSupportClassName = L"TransferResumeSupport";
// const bool Inline = true;
// UnicodeString ResumeSupportCode =
// AssemblyNewClassInstanceStart(Language, ResumeSupportClassName, Inline);
if (GetResumeSupport() == rsSmart)
{
// ResumeSupportCode += AssemblyProperty(Language, ResumeSupportClassName, L"Threshold", ResumeThresholdKB, Inline);
}
else
{
// ResumeSupportCode += AssemblyProperty(Language, ResumeSupportClassName, L"State", L"TransferResumeSupportState", CodeState, Inline);
}
// ResumeSupportCode += AssemblyNewClassInstanceEnd(Language, Inline);
// AssemblyCode += AssemblyPropertyRaw(Language, TransferOptionsClassName, L"ResumeSupport", ResumeSupportCode, false);
}
if (SomeAttrExcluded)
{
Result += (Result.IsEmpty() ? UnicodeString() : Separator) +
FORMAT(LoadStrPart(COPY_INFO_NOT_USABLE, 1).c_str(),
LoadStrPart(COPY_INFO_NOT_USABLE, (SomeAttrIncluded ? 2 : 3)).c_str());
}
else if (Result.IsEmpty())
{
Result = LoadStr(COPY_INFO_DEFAULT);
}
#undef ADD
}
