//---------------------------------------------------------------------------
__fastcall TSynchronizeProgressForm::~TSynchronizeProgressForm()
{
ClearGlobalMinimizeHandler(GlobalMinimize);
ReleaseAsModal(this, FShowAsModalStorage);
if (IsApplicationMinimized() && FMinimizedByMe)
{
ShowNotification(
NULL, MainInstructions(LoadStr(BALLOON_OPERATION_COMPLETE)),
qtInformation);
}
}
//---------------------------------------------------------------------------
void __fastcall TEditorForm::Reload()
{
if (!EditorMemo->Modified ||
(MessageDialog(MainInstructions(LoadStr(EDITOR_MODIFIED_RELOAD)), qtConfirmation,
qaOK | qaCancel) != qaCancel))
{
if (FOnFileReload)
{
FOnFileReload(this);
}
LoadFile();
}
}
//---------------------------------------------------------------------------
void __fastcall TAboutDialog::OKButtonMouseDown(TObject * /*Sender*/,
TMouseButton Button, TShiftState Shift, int /*X*/, int /*Y*/)
{
if ((Button == mbRight) && Shift.Contains(ssAlt))
{
try
{
ACCESS_VIOLATION_TEST;
}
catch (Exception & E)
{
throw ExtException(&E, MainInstructions(L"Internal error test."));
}
}
}
//---------------------------------------------------------------------------
void __fastcall TEditorForm::FormCloseQuery(TObject * /*Sender*/,
bool &CanClose)
{
if (EditorMemo->Modified)
{
SetFocus();
UnicodeString Message = MainInstructions(LoadStr(SAVE_CHANGES));
unsigned int Answer = MessageDialog(Message, qtConfirmation,
qaYes | qaNo | qaCancel);
CanClose = (Answer != qaCancel);
if (Answer == qaYes)
{
SaveAction->Execute();
}
}
}
//---------------------------------------------------------------------------
void __fastcall TEditorForm::GoToLine()
{
UnicodeString Str;
if (InputDialog(LoadStr(EDITOR_GO_TO_LINE), LoadStr(EDITOR_LINE_NUMBER), Str))
{
int Line = StrToIntDef(Str, -1);
if (Line <= 0 || Line > EditorMemo->Lines->Count)
{
throw Exception(MainInstructions(LoadStr(EDITOR_INVALID_LINE)));
}
else
{
EditorMemo->CaretPos = TPoint(0, Line-1);
}
}
}
//---------------------------------------------------------------------------
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 TLocationProfilesDialog::RemoveBookmark(TObject * Sender)
{
TBookmarkList * BookmarkList = GetBookmarkList(Sender);
TTreeView * ProfilesView = GetProfilesView(Sender);
TStringList * Folders = GetFolders(Sender);
assert(ProfilesView->Selected);
TTreeNode * Node = ProfilesView->Selected;
if (Node->Data)
{
BookmarkList->Delete((TBookmark *)Node->Data);
TTreeNode * ParentNode = Node->Parent;
Node->Delete();
if (ParentNode && !ParentNode->Count)
{
assert(Folders->IndexOfObject(ParentNode) >= 0);
Folders->Delete(Folders->IndexOfObject(ParentNode));
ParentNode->Delete();
}
}
else
{
UnicodeString Message = MainInstructions(LoadStr(DELETE_BOOKMARK_FOLDER));
if (MessageDialog(Message, qtConfirmation,
qaYes | qaNo, HELP_LOCATION_PROFILE_DELETE) == qaYes)
{
assert(Node->Count);
for (int i = 0; i < Node->Count; i++)
{
BookmarkList->Delete((TBookmark *)Node->Item[i]->Data);
}
assert(Folders->IndexOfObject(Node) >= 0);
Folders->Delete(Folders->IndexOfObject(Node));
Node->Delete();
}
}
UpdateControls();
}
//---------------------------------------------------------------------------
void __fastcall TEditorForm::ChangeEncoding(TEncoding * Encoding)
{
if (FEncoding != Encoding)
{
if (!EditorMemo->Modified ||
(MessageDialog(MainInstructions(LoadStr(EDITOR_MODIFIED_ENCODING)), qtConfirmation,
qaOK | qaCancel) != qaCancel))
{
TEncoding * PrevEncoding = FEncoding;
try
{
FEncoding = Encoding;
LoadFile();
}
catch(...)
{
// try to restore
FEncoding = PrevEncoding;
LoadFile();
throw;
}
}
}
}
static bool WellKnownException(
const Exception * E, UnicodeString * AMessage, const wchar_t ** ACounterName, Exception ** AClone, bool Rethrow)
{
UnicodeString Message;
const wchar_t * CounterName = nullptr;
std::unique_ptr<Exception> Clone;
bool Result = true;
bool IgnoreException = false;
// if (!IgnoredExceptions.empty())
// {
// TGuard Guard(*IgnoredExceptionsCriticalSection.get());
// UnicodeString ClassName = ""; // NormalizeClassName(E->QualifiedClassName());
// IgnoreException = (IgnoredExceptions.find(ClassName) != IgnoredExceptions.end());
// }
if (IgnoreException)
{
Result = false;
}
// EAccessViolation is EExternal
else if (isa<EAccessViolation>(E))
{
if (Rethrow)
{
throw EAccessViolation(E->Message);
}
Message = MainInstructions(LoadStr(ACCESS_VIOLATION_ERROR3));
CounterName = L"AccessViolations";
Clone.reset(new EAccessViolation(E->Message));
}
/*
// EIntError and EMathError are EExternal
// EClassNotFound is EFilerError
else if ((dyn_cast<EListError>(E) != nullptr) ||
(dyn_cast<EStringListError>(E) != nullptr) ||
(dyn_cast<EIntError>(E) != nullptr) ||
(dyn_cast<EMathError>(E) != nullptr) ||
(dyn_cast<EVariantError>(E) != nullptr) ||
(dyn_cast<EInvalidOperation>(E) != nullptr))
(dynamic_cast<EFilerError*>(E) != NULL))
{
if (Rethrow)
{
throw EIntError(E->Message);
}
Message = MainInstructions(E->Message);
CounterName = L"InternalExceptions";
Clone.reset(new EIntError(E->Message));
}
else if (dyn_cast<EExternal>(E) != nullptr)
{
if (Rethrow)
{
throw EExternal(E->Message);
}
Message = MainInstructions(E->Message);
CounterName = L"ExternalExceptions";
Clone.reset(new EExternal(E->Message));
}
else if (dyn_cast<EHeapException>(E) != nullptr)
{
if (Rethrow)
{
throw EHeapException(E->Message);
}
Message = MainInstructions(E->Message);
CounterName = L"HeapExceptions";
Clone.reset(new EHeapException(E->Message));
}
*/
else
{
Result = false;
}
if (Result)
{
if (AMessage != nullptr)
{
(*AMessage) = Message;
}
if (ACounterName != nullptr)
{
(*ACounterName) = CounterName;
}
if (AClone != nullptr)
{
(*AClone) = DebugNotNull(Clone.release());
}
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TEditorForm::LoadFromFile(bool PrimaryEncoding)
{
TStream * Stream = new TFileStream(FFileName, fmOpenRead | fmShareDenyWrite);
try
{
bool CanTrySecondary;
if (FEncoding == NULL)
{
int Encoding;
if (ContainsPreamble(Stream, TEncoding::UTF8->GetPreamble()))
{
Encoding = CP_UTF8;
CanTrySecondary = false;
}
else
{
Encoding = WinConfiguration->Editor.Encoding;
CanTrySecondary = true;
}
switch (Encoding)
{
case CP_UTF8:
FEncoding = PrimaryEncoding ? TEncoding::UTF8 : TEncoding::Default;
break;
default:
CanTrySecondary = false;
FAIL;
// fallthru
case CP_ACP:
FEncoding = PrimaryEncoding ? TEncoding::Default : TEncoding::UTF8;
break;
}
}
else
{
CanTrySecondary = false;
}
FEncodingName = GetCodePageName(FEncoding);
bool EncodingError;
if (!EditorMemo->LoadFromStream(Stream, FEncoding, EncodingError))
{
if (EncodingError)
{
UnicodeString Message = FMTLOAD(EDITOR_ENCODING_ERROR, (FFileName, FEncodingName));
if (CanTrySecondary)
{
TEncoding * EncodingBackup = FEncoding;
UnicodeString EncodingNameBackup = FEncodingName;
try
{
FEncoding = NULL;
LoadFromFile(false);
TEditorConfiguration EditorConfiguration = WinConfiguration->Editor;
if (EditorConfiguration.WarnOnEncodingFallback)
{
// by now the FEncodingName is the secondary encoding
Message = Message + L" " + FMTLOAD(EDITOR_ENCODING_REVERTED, (FEncodingName));
TMessageParams Params(mpNeverAskAgainCheck);
unsigned int Answer =
MessageDialog(MainInstructions(Message), qtInformation, qaOK, HELP_NONE, &Params);
if (Answer == qaNeverAskAgain)
{
EditorConfiguration.WarnOnEncodingFallback = false;
WinConfiguration->Editor = EditorConfiguration;
}
}
}
catch(...)
{
// restored values are never used anyway, as this can get here only
// when opening editor and this is fatal error preventing the editor from opening
FEncoding = EncodingBackup;
FEncodingName = EncodingNameBackup;
throw Exception(Message);
}
}
else
{
throw Exception(Message);
}
}
else
{
throw Exception(MainInstructions(FMTLOAD(EDITOR_LOAD_ERROR, (FFileName))));
}
}
}
__finally
{
delete Stream;
}
SendMessage(EditorMemo->Handle, EM_EXLIMITTEXT, 0, 0x7FFFFFF0);
}
//---------------------------------------------------------------------------
void __fastcall TEditorForm::Find()
{
int NewPos;
int Replacements = 0;
do
{
assert(FLastFindDialog);
TSearchTypes SearchTypes;
// length condition is there to improve performance when large
// block is selected in editor
if (FLastFindDialog == FReplaceDialog &&
(FReplaceDialog->Options.Contains(frReplace) ||
FReplaceDialog->Options.Contains(frReplaceAll)) &&
FReplaceDialog->FindText.Length() == EditorMemo->SelLength &&
AnsiSameText(FReplaceDialog->FindText, EditorMemo->SelText))
{
EditorMemo->SelText = FReplaceDialog->ReplaceText;
Replacements++;
}
TEditorConfiguration EditorConfiguration = WinConfiguration->Editor;
EditorConfiguration.FindText = FLastFindDialog->FindText;
EditorConfiguration.ReplaceText = FReplaceDialog->ReplaceText;
EditorConfiguration.FindMatchCase = FLastFindDialog->Options.Contains(frMatchCase);
EditorConfiguration.FindWholeWord = FLastFindDialog->Options.Contains(frWholeWord);
EditorConfiguration.FindDown = FLastFindDialog->Options.Contains(frDown);
WinConfiguration->Editor = EditorConfiguration;
if (EditorConfiguration.FindMatchCase)
{
SearchTypes << stMatchCase;
}
if (EditorConfiguration.FindWholeWord)
{
SearchTypes << stWholeWord;
}
NewPos = EditorMemo->FindText(EditorConfiguration.FindText,
EditorMemo->SelLength ? EditorMemo->SelStart+1 : EditorMemo->SelStart,
EditorMemo->Text.Length(), SearchTypes, EditorConfiguration.FindDown);
if (NewPos >= 0)
{
EditorMemo->SelStart = NewPos;
EditorMemo->SelLength = EditorConfiguration.FindText.Length();
}
if (FLastFindDialog->Handle)
{
PositionFindDialog(true);
}
if (NewPos < 0)
{
if ((Replacements == 0) || FReplaceDialog->Options.Contains(frReplaceAll))
{
// now Screen->ActiveForm can be NULL when other form was meanwhile
// activated and then focus was returned back to "find" dialog
// (non VCL form)
if (Screen->ActiveForm != this)
{
SetFocus();
FLastFindDialog->Execute();
}
if (Replacements == 0)
{
UnicodeString Message = MainInstructions(FMTLOAD(EDITOR_FIND_END, (EditorConfiguration.FindText)));
MessageDialog(Message, qtInformation, qaOK, HELP_NONE);
}
else if (FReplaceDialog->Options.Contains(frReplaceAll))
{
UnicodeString Message = MainInstructions(FMTLOAD(EDITOR_REPLACE_END, (Replacements)));
MessageDialog(Message, qtInformation, qaOK, HELP_NONE);
}
}
}
}
while (NewPos >= 0 && FLastFindDialog == FReplaceDialog &&
FReplaceDialog->Options.Contains(frReplaceAll));
}
static bool WellKnownException(
const Exception * E, UnicodeString * AMessage, const wchar_t ** ACounterName, Exception ** AClone, bool Rethrow)
{
UnicodeString Message;
const wchar_t * CounterName = nullptr;
std::unique_ptr<Exception> Clone;
bool Result = true;
// EAccessViolation is EExternal
if (NB_STATIC_DOWNCAST_CONST(EAccessViolation, E) != nullptr)
{
if (Rethrow)
{
throw EAccessViolation(E->Message);
}
Message = MainInstructions(LoadStr(ACCESS_VIOLATION_ERROR3));
CounterName = L"AccessViolations";
Clone.reset(new EAccessViolation(E->Message));
}
/*
// EIntError and EMathError are EExternal
else if ((NB_STATIC_DOWNCAST(EListError, E) != nullptr) ||
(NB_STATIC_DOWNCAST(EStringListError, E) != nullptr) ||
(NB_STATIC_DOWNCAST(EIntError, E) != nullptr) ||
(NB_STATIC_DOWNCAST(EMathError, E) != nullptr) ||
(NB_STATIC_DOWNCAST(EVariantError, E) != nullptr) ||
(NB_STATIC_DOWNCAST(EInvalidOperation, E) != nullptr))
{
if (Rethrow)
{
throw EIntError(E->Message);
}
Message = E->Message;
CounterName = L"InternalExceptions";
Clone.reset(new EIntError(E->Message));
}
else if (NB_STATIC_DOWNCAST(EExternal, E) != nullptr)
{
if (Rethrow)
{
throw EExternal(E->Message);
}
Message = MainInstructions(E->Message);
CounterName = L"ExternalExceptions";
Clone.reset(new EExternal(E->Message));
}
else if (NB_STATIC_DOWNCAST(EHeapException, E) != nullptr)
{
if (Rethrow)
{
throw EHeapException(E->Message);
}
Message = MainInstructions(E->Message);
CounterName = L"HeapExceptions";
Clone.reset(new EHeapException(E->Message));
}
*/
else
{
Result = false;
}
if (Result)
{
if (AMessage != nullptr)
{
(*AMessage) = Message;
}
if (ACounterName != nullptr)
{
(*ACounterName) = CounterName;
}
if (AClone != nullptr)
{
(*AClone) = NOT_NULL(Clone.release());
}
}
return Result;
}