unit UEditorForm;

Windows,

Winapi.Messages,

Winapi.D2D1,

SynEditPrint,

SysUtils,

Classes,

Graphics,

Forms,

Controls,

StdCtrls,

Menus,

ComCtrls,

ExtCtrls,

System.ImageList,

Vcl.ToolWin,

Vcl.ImgList,

Vcl.BaseImageCollection,

Vcl.VirtualImageList,

Vcl.WinXCtrls,

SVGIconImageCollection,

TB2Item,

SpTBXItem,

SynEdit,

SynEditExport,

SynEditHighlighter,

SynEditMiscClasses,

USynEditEx,

UModel,

UBaseForm,

UJavaParser,

UParseThread;

CInsertBlink = 500;

EcWordLeft = 5; // Move cursor left one word

EcWordRight = 6; // Move cursor right one word

TLineInfo = (dlCurrentDebuggerLine, dlBreakpointLine, dlExecutableLine,

dlSearchLine);

TLineInfos = set of TLineInfo;

{ TFEditForm }

TFEditForm = class(TFForm)

PMain: TPanel;

TVFileStructure: TTreeView;

StatusBar: TStatusBar;

BottomPanel: TPanel;

DesignButton: TButton;

EditformToolbar: TToolBar;

TBClose: TToolButton;

TBExplorer: TToolButton;

TBBrowser: TToolButton;

TBDesignform: TToolButton;

TBStructure: TToolButton;

TBClassOpen: TToolButton;

TBMatchBracket: TToolButton;

TBSystemOutPrintln: TToolButton;

TBStructureIndent: TToolButton;

TBIfStatement: TToolButton;

TBIfElseStatement: TToolButton;

TBWhileStatement: TToolButton;

TBForStatement: TToolButton;

TBDoWhileStatement: TToolButton;

TBSwitchStatement: TToolButton;

TBTryStatement: TToolButton;

TBBlockStatement: TToolButton;

TBComment: TToolButton;

TBIndent: TToolButton;

TBUnindent: TToolButton;

TBWordWrap: TToolButton;

TBBreakpoint: TToolButton;

TBBreakpointsClear: TToolButton;

TBBookmark: TToolButton;

TBGotoBookmark: TToolButton;

TBParagraph: TToolButton;

TBNumbers: TToolButton;

TBZoomIn: TToolButton;

TBZoomOut: TToolButton;

TBValidate: TToolButton;

icEditor: TSVGIconImageCollection;

vilEditorToolbarLight: TVirtualImageList;

vilEditorToolbarDark: TVirtualImageList;

icContextMenu: TSVGIconImageCollection;

vilContextMenuLight: TVirtualImageList;

vilContextMenuDark: TVirtualImageList;

PopUpEditor: TSpTBXPopupMenu;

MISearchDeclaration: TSpTBXItem;

MIAPIHelp: TSpTBXItem;

MIClassOpen: TSpTBXItem;

MIClassEditor: TSpTBXItem;

MICreateStructogram: TSpTBXItem;

MILine0: TSpTBXSeparatorItem;

MIExecute: TSpTBXItem;

MIExecuteWithoutConsole: TSpTBXItem;

MIExecuteWithConsole: TSpTBXItem;

MILine5: TSpTBXSeparatorItem;

MIGit: TSpTBXSubmenuItem;

MIGitStatus: TSpTBXItem;

MIGitAdd: TSpTBXItem;

MIGitCommit: TSpTBXItem;

MIGitLog: TSpTBXItem;

MIGitLine1: TSpTBXSeparatorItem;

MIGitReset: TSpTBXItem;

MIGitCheckout: TSpTBXItem;

MIGitRemove: TSpTBXItem;

MIGitLine2: TSpTBXSeparatorItem;

MIGitRemote: TSpTBXItem;

MIGitFetch: TSpTBXItem;

MIGitPush: TSpTBXItem;

MIGitLine3: TSpTBXSeparatorItem;

MIGitGui: TSpTBXItem;

MIGitViewer: TSpTBXItem;

MIGitConsole: TSpTBXItem;

MIRenewImports: TSpTBXItem;

MICopyPath: TSpTBXItem;

MILine1: TSpTBXSeparatorItem;

MIUndo: TSpTBXItem;

MIRedo: TSpTBXItem;

MILine2: TSpTBXSeparatorItem;

MICut: TSpTBXItem;

MICopy: TSpTBXItem;

MIInsert: TSpTBXItem;

MILine3: TSpTBXSeparatorItem;

MIUnindent: TSpTBXItem;

MIIndent: TSpTBXItem;

MILine4: TSpTBXSeparatorItem;

MIFont: TSpTBXItem;

MIConfiguration: TSpTBXItem;

MIClose: TSpTBXItem;

vilBookmarksLight: TVirtualImageList;

vilBookmarksDark: TVirtualImageList;

MIAssistant: TSpTBXSubmenuItem;

mnAssistantCancel: TSpTBXItem;

mnAssistantOptimize: TSpTBXItem;

mnAssistantFixBugs: TSpTBXItem;

mnAssistantExplain: TSpTBXItem;

mnAssistanSuggest: TSpTBXItem;

SpTBXSeparatorItem1: TSpTBXSeparatorItem;

ActivityIndicator: TActivityIndicator;

icBookmarks: TSVGIconImageCollection;

procedure FormCreate(Sender: TObject);

procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);

procedure FormClose(Sender: TObject; var AAction: TCloseAction); override;

procedure EditorStatusChange(Sender: TObject; Changes: TSynStatusChanges);

procedure Enter(Sender: TObject); override;

procedure UpdateState; override;

procedure BreakpointGutterClick(Sender: TObject; Button: TMouseButton;

X, Y, Row, Line: Integer);

procedure MICutClick(Sender: TObject);

procedure MICopyClick(Sender: TObject);

procedure MIInsertClick(Sender: TObject);

procedure MIUnindentClick(Sender: TObject);

procedure MIIndentClick(Sender: TObject);

procedure MIUndoClick(Sender: TObject);

procedure MIRedoClick(Sender: TObject);

procedure EditorKeyPress(Sender: TObject; var Key: Char);

procedure EditorKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);

procedure MICloseClick(Sender: TObject);

procedure MIAPIHelpClick(Sender: TObject);

procedure EditorPaintTransient(Sender: TObject; ACanvas: TCanvas;

TransientType: TTransientType);

procedure SBParagraphClick(Sender: TObject);

procedure SBNumbersClick(Sender: TObject);

procedure SBMatchBracketClick(Sender: TObject);

procedure SBBookmarkClick(Sender: TObject);

procedure SBGotoBookmarkClick(Sender: TObject);

procedure SBStatementClick(Sender: TObject);

procedure SBIndentClick(Sender: TObject);

procedure SBUnindentClick(Sender: TObject);

procedure SBBreakpointClick(Sender: TObject);

procedure SBBreakpointsClearClick(Sender: TObject);

procedure SBCommentClick(Sender: TObject);

procedure SBDesignformClick(Sender: TObject);

procedure SBClassEditClick(Sender: TObject);

procedure SBClassOpenClick(Sender: TObject);

procedure SBBrowserClick(Sender: TObject);

procedure SBExplorerClick(Sender: TObject);

procedure SBCloseClick(Sender: TObject);

procedure SBStructureIndentClick(Sender: TObject);

procedure SBWordWrapClick(Sender: TObject);

procedure SBValidateClick(Sender: TObject);

procedure SBSystemOutPrintlnClick(Sender: TObject);

procedure SBZoomOutClick(Sender: TObject);

procedure SBZoomInClick(Sender: TObject);

procedure MIFontClick(Sender: TObject);

procedure WMNCButtonDBLClick(var Msg: TMessage); message WM_NCLBUTTONDBLCLK;

procedure MIExecuteClick(Sender: TObject);

procedure PopUpEditorPopup(Sender: TObject);

procedure MIExecuteWithoutConsoleClick(Sender: TObject);

procedure MIExecuteWithConsoleClick(Sender: TObject);

procedure MIRenewImportsClick(Sender: TObject);

procedure MICreateStructogramClick(Sender: TObject);

procedure MICopyPathClick(Sender: TObject);

procedure DoOnMouseOverToken(Sender: TObject; const Token: string;

TokenType: Integer; Caret, Posi: TPoint; Attri: TSynHighlighterAttributes;

var Highlight: Boolean);

procedure DoOnMouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

procedure DoOnBuildStructure(Sender: TObject);

procedure TVFileStructureChange(Sender: TObject; Node: TTreeNode);

procedure MIClassOpenClick(Sender: TObject);

procedure MIClassEditorClick(Sender: TObject);

procedure MISearchDeclarationClick(Sender: TObject);

procedure MIGitStatusClick(Sender: TObject);

procedure MIGitAddClick(Sender: TObject);

procedure MIGitCommitClick(Sender: TObject);

procedure MIGitGuiClick(Sender: TObject);

procedure MIGitRemoveClick(Sender: TObject);

procedure MIGitLogClick(Sender: TObject);

procedure MIGitResetClick(Sender: TObject);

procedure MIGitCheckoutClick(Sender: TObject);

procedure MIGitRemoteClick(Sender: TObject);

procedure MIGitFetchClick(Sender: TObject);

procedure MIGitPushClick(Sender: TObject);

procedure MIGitConsoleClick(Sender: TObject);

procedure MIGitViewerClick(Sender: TObject);

procedure FormDestroy(Sender: TObject);

procedure MIConfigurationClick(Sender: TObject);

procedure DesignButtonClick(Sender: TObject);

procedure FormResize(Sender: TObject);

procedure mnAssistanSuggestClick(Sender: TObject);

procedure mnAssistantExplainClick(Sender: TObject);

procedure mnAssistantFixBugsClick(Sender: TObject);

procedure mnAssistantOptimizeClick(Sender: TObject);

procedure mnAssistantCancelClick(Sender: TObject);

procedure FormShow(Sender: TObject);

private

FBookmark: Integer;

FBreakPointCount: Integer;

FMouseIsInBorderOfStructure: Boolean;

FMouseBorderOfStructure: Integer;

FMousePosition: TBufferCoord;

FModifiedStrs: array [Boolean] of string;

FInsertModeStrs: array [Boolean] of string;

FToolButtons: array [0 .. 29] of TToolButton;

FFrameType: Integer; // 1..8, look in UEditorForm

FCheckAgeEnabled: Boolean;

FDebuglineMark: TSynEditMark;

FEditor: TSynEditEx;

FEditorAge: TDateTime;

FEncoding: string;

FFileExtension: string;

FNeedsParsing: Boolean;

FNeedToSyncFileStructure: Boolean;

FIsJUnitTestClass: Boolean;

FLastToken: string;

FLineBreak: string;

FModel: TObjectModel;

FParameter: string;

FParser: TJavaParser;

FParseThread: TParseThread;

FStartOption: Integer;

FSynEditPrint: TSynEditPrint;

FHidden: Boolean;

procedure Translate;

procedure Statusline(Num: Integer; const Str: string);

procedure CalculateStatusline;

procedure SetNeedsParsing(Value: Boolean);

function GetJavaCodeAt(Caret: TPoint): string;

procedure CreateTooltip(Caret, Posi: TPoint; const Token: string);

function GetFrameType: Integer;

procedure SynEditDebugInfoPaintLines(RenderTarget: ID2D1RenderTarget;

ClipR: TRect; const FirstRow, LastRow: Integer;

var DoDefaultPainting: Boolean);

procedure SynEditGutterDebugInfoMouseCursor(Sender: TObject;

X, Y, Row, Line: Integer; var Cursor: TCursor);

procedure SynEditBookmarkPaintLines(RenderTarget: ID2D1RenderTarget;

ClipR: TRect; const FirstRow, LastRow: Integer;

var DoDefaultPainting: Boolean);

procedure BookmarkGutterClick(Sender: TObject; Button: TMouseButton;

X, Y, Row, Line: Integer);

procedure SynEditChange(Sender: TObject);

public

constructor Create(AOwner: TComponent); override;

procedure New(const FileName: string);

procedure Open(const FileName: string; State: string;

Hidden: Boolean = False);

procedure Save(WithBackup: Boolean); override;

procedure SaveIn(const Dir: string); override;

procedure SaveAs(const FileName: string);

function GetSaveAsName: string; override;

procedure SetHighlighter;

procedure SetToolButtons;

procedure PreparePrint;

procedure Print; override;

procedure PrintAll(AllPages: Boolean);

procedure Show;

procedure Hide;

procedure SetFont(AFont: TFont); override;

function GetFont: TFont; override;

procedure SetFontSize(Delta: Integer); override;

procedure SetOptions; override;

procedure SetDeleteBookmark(Xpos, YPos: Integer);

procedure Unindent;

procedure Indent;

procedure Search; override;

procedure SearchAgain; override;

procedure Replace; override;

procedure SystemOutPrintln;

procedure Matchbracket;

function GetIndent: string;

procedure PutText(Str: string; WithCursor: Boolean = True);

function CBSearchClassOrMethod(Stop: Boolean; Line: Integer): string;

function SourceContainsClass(const AClassname: string): Boolean;

procedure GotoLine(Line: Integer);

procedure CutToClipboard; override;

procedure CopyToClipboard; override;

procedure PasteFromClipboard; override;

procedure Undo; override;

procedure Redo; override;

procedure SetModified(AModified: Boolean); override;

function GetModified: Boolean; override;

procedure DoExport; override;

// Test-Menü

procedure ClearBreakpoints;

procedure SetBreakpoints;

function HasBreakpoints: Boolean;

function HasBreakpoint(Line: Integer): Boolean;

function IsExecutableLine(Line: Integer): Boolean;

procedure SetDebuglineMark(Line: Integer);

procedure DeleteDebuglineMark;

procedure DeleteBreakpoint(Str: string);

function GetBreakpointMark(Line: Integer): TSynEditMark;

function GetMarksBreakpoints: string;

procedure SetMarksBreakpoints(MarkBreakpoint: string);

procedure InsertBreakpointMark(Line: Integer);

procedure DeleteBreakpointAtLine(Line: Integer);

procedure InsertGotoCursorBreakpoint;

procedure InsertBreakpoint;

procedure HTMLforApplet(const AWidth, AHeight, CharSet, AClass: string);

function CurrentCol: Integer;

function CurrentRow: Integer;

procedure ExportToFile(const FileName: string;

Exporter: TSynCustomExporter);

procedure ExportToClipboard(AsHtml: Boolean; AsText: Boolean);

procedure ExportWithNumbers;

procedure ExportRTFNumbered;

procedure SynEditorReplaceText(Sender: TObject;

const ASearch, AReplace: string; Line, Column: Integer;

var AAction: TSynReplaceAction);

procedure SynEditorSpecialLineColors(Sender: TObject; Line: Integer;

var Special: Boolean; var Foreground, Background: TColor);

procedure SynEditGutterGetText(Sender: TObject; ALine: Integer;

var AText: string);

function GetLineInfos(ALine: Integer): TLineInfos;

procedure ParseSourcecodeWithThread(HasChanged: Boolean);

procedure ParseSourceCode(HasChanged: Boolean);

procedure CreateTVFileStructure;

procedure RunTests;

function GetWidthAndHeight: TPoint;

procedure ChangeWidthAndHeight(Width, Height: Integer);

procedure ReplaceWidthHeight(Width, Height: Integer);

function GetLNGStartAttributes: Integer;

function GetLNGEndAttributes: Integer;

function GetLNGStartComponents: Integer;

function GetLNGEndComponents: Integer;

function GetLNGStartEventMethods: Integer;

function GetLNGEndEventMethods: Integer;

function GetLNG(Num, ClassNumber: Integer): string;

procedure EnsureStartEnd(CorI: Integer = 1);

procedure InsertStartEnd;

function HasStartAndEnd(CorI: Integer): Boolean;

function GetLineNumberWith(const Str: string): Integer;

function GetLineNumberWithFrom(From: Integer; const Str: string): Integer;

function GetLineNumberWithFromTill(From, Till: Integer;

const Str: string): Integer;

function GetLineNumberWithWord(const Str: string): Integer;

function GetLineNumberWithWordFrom(From: Integer;

const Str: string): Integer;

function GetLineNumberWithStartsWordFrom(From: Integer;

const Str: string): Integer;

function GetSource(Lines, LineE: Integer): string;

function GetLine(Line: Integer): string;

function ContainsWord(const Key: string; Line: Integer): Boolean;

procedure ReplaceLine(const Str1, Str2: string);

procedure ReplaceLineWith(Line: Integer; const Str: string);

procedure ReplaceLineInLine(Line: Integer; const Old, ANew: string);

procedure ReplaceText(const Str1, Str2: string; All: Boolean);

procedure ReplaceTextWithRegex(const Reg, Str: string; All: Boolean;

From: Integer = -1; Till: Integer = -1);

procedure ReplaceWord(const Str1, Str2: string; All: Boolean);

procedure ReplaceComponentname(const Str1, Str2: string; Events: string);

procedure ReplaceAttributAt(const AtLine, Key, Str: string);

procedure ReplaceAttribute(const Key, Str: string);

procedure ReplaceMethod(var Method: TOperation; const New: string);

procedure SetAttributValue(const Container, Key, Str: string;

After: Integer);

procedure ChangeAttributValue(const Key, Str: string); overload; // Swing

procedure ChangeAttributValue(const Container, Key, Str: string); overload;

// IsFX

function HasComponent(const Key: string; Line: Integer): Boolean;

procedure InsertAttributValue(const Destination, Str: string;

After: Integer);

procedure InsertLinesAt(Line: Integer; Str: string); overload;

procedure InsertLinesAt(const AtLine, Str: string); overload;

procedure InsertAttributAfter(const AtLine, Attribute: string);

procedure InsertAttribute(ClassNumber: Integer; const Str: string);

overload;

procedure InsertAttribute(const Container, AIndent, Variable: string;

IsFX: Boolean); overload;

procedure InsertAttribute(const Container, Variable: string;

IsFX: Boolean); overload;

procedure InsertComponent(const Str: string);

procedure InsertProcedure(const AProcedure: string); overload;

procedure InsertProcedure(ClassNumber: Integer;

const AProcedure: string); overload;

procedure InsertListener(const Component, Listener: string);

procedure InsertConstructor(ClassNumber: Integer; const AProcedure: string);

procedure InsertImport(const Package: string);

procedure DeleteAttribute(const Str: string);

function DeleteAttributeValue(const Str: string): Boolean;

procedure DeleteComponentValue(const Str: string);

procedure DeleteAttributeValues(const Str: string);

procedure DeleteEmptyLines(Line: Integer);

procedure DeleteLine(Line: Integer);

procedure DeleteBlock(StartLine, EndLine: Integer);

procedure DeleteComponent(const Component: string);

procedure DeleteComponentDefault(Control: TControl);

procedure DeleteComponentTotal(ClassNumber: Integer;

const Component, Typ: string);

procedure DeleteMethod(const Method: string;

SourcecodeCheck: Boolean = True); overload;

procedure DeleteMethod(Method: TOperation); overload;

procedure DeleteEventMethod(Method: string);

procedure DeleteListener(const Listener: string);

procedure DeleteFXListener(Listener: string);

procedure DeleteLambdaListener(Listener: string);

procedure DeleteOldAddNewMethods(OldMethods, NewMethods: TStringList);

procedure DeleteFXOldAddNewMethods(OldMethods, NewMethods: TStringList);

procedure DeleteTryCatch(const Key: string);

procedure MoveBlock(From, Till, Dest, DestTill: Integer;

const Blanklines: string);

function GetBlock(From, Lines: Integer): string;

procedure ToForeground(Control: TControl);

procedure ToBackground(Control: TControl);

procedure Go_To(const Str: string);

function GetClassAttribut(const AClass, AAttribute: string): string;

function HasText(const Str: string): Boolean;

function HasWord(const Str: string): Boolean;

function HasEventProcedureInModel(const AMethodname: string): Boolean;

function HasMainInModel: Boolean;

function IsJava: Boolean;

function IsPascal: Boolean;

function IsHTML: Boolean;

function IsCSS: Boolean;

function IsHTMLApplet: Boolean;

function GetFormType: string; override;

function GetState: string; override;

procedure SetState(var Str: string); override;

function EncodingAsString(const AEncoding: string): string;

function LinebreakAsString: string;

function LinebreakAsCtrls(const Str: string): string;

function GetEncodingAsType: TEncoding;

procedure SetEncoding(AEncoding: string);

procedure AutomatedCompleteImports;

procedure SetNewActionEventFormat;

procedure CollectClasses(StringList: TStringList); override;

function GetPackage: string;

procedure CheckAge;

procedure AddShortcutsToHints;

function GetAllPathnames: TStringList; override;

function GetAllClassnames: TStringList; override;

function ClassnameDifferentFromAncestors(const AClassname: string): Boolean;

procedure InitShowCompileErrors;

procedure SetErrorMark(Line, Column: Integer);

procedure UnderlineCompileErrors;

procedure ClearCompilerErrorMarks;

procedure ClearMarks;

procedure TerminateThread(Sender: TObject);

procedure ChangeStyle; override;

procedure RemoveShortCutFromEditor(ShortCut: Integer);

procedure ReplaceShortCutFromEditor(ShortCut, ShortCut2: Integer);

procedure EditShortCuts;

procedure CollapseGUICreation;

procedure DoOnIdle;

procedure SyncFileStructure;

function MakeUpperEvents(Events: string): string;

procedure SetFXBackgroundAsString(const Container, AName, AColor: string);

procedure DPIChanged; override;

function CountClassOrInterface: Integer;

procedure SetActivityIndicator(TurnOn: Boolean; const Hint: string = '';

OnClick: TNotifyEvent = nil);

procedure ShowAssistantError(const Msg: string);

function IsApplet: Boolean;

function IsAWT: Boolean;

function FrameTypToString: string;

property CheckAgeEnabled: Boolean read FCheckAgeEnabled

write FCheckAgeEnabled;

property DebuglineMark: TSynEditMark read FDebuglineMark;

property Editor: TSynEditEx read FEditor;

property EditorAge: TDateTime read FEditorAge write FEditorAge;

property Encoding: string read FEncoding;

property FileExtension: string read FFileExtension;

property IsJUnitTestClass: Boolean read FIsJUnitTestClass;

property NeedsParsing: Boolean read FNeedsParsing write SetNeedsParsing;

property FrameType: Integer read GetFrameType write FFrameType;

property LastToken: string read FLastToken write FLastToken;

property LineBreak: string read FLineBreak;

property Model: TObjectModel read FModel;

property Parameter: string read FParameter write FParameter;

property Parser: TJavaParser read FParser write FParser;

property ParseThread: TParseThread read FParseThread;

property SynEditPrint: TSynEditPrint read FSynEditPrint;

end;

Printers,

Dialogs,

IOUtils,

Types,

UITypes,

Clipbrd,

Math,

StrUtils,

RegularExpressions,

JvGnugettext,

SynExportRTF,

SynExportHTML,

SynEditPrintTypes,

SynEditTypes,

SynHighlighterJava,

SynDWrite,

UJava,

UGUIDesigner,

UJavaCommands,

UUtils,

UConfiguration,

UTree,

UModelEntity,

UFileProvider,

UMessages,

UGUIForm,

UCodeCompletion,

UDlgConfirmReplace,

UUMLForm,

UStringRessources,

UDebugger,

UFileStructure,

UFXComponents,

UGit,

UJUnitTest,

USequenceForm,

UJavaScanner,

UTooltip,

UObjectInspector,

UJEComponents,

UTemplates,

ULLMSupport;

EcMatchBracket = 250; // Go to matching bracket

EcBlockIndent = 610; // Indent selection

EcBlockUnindent = 611; // Unindent selection

NoBreakpointImageIndex = 14;

BreakpointImageIndex = 13;

ErrorMarkIndex = 10;

StopInAt = True;

LNGs: array [1 .. 6] of string;

{ --- TFEditForm --------------------------------------------------------------- }

{ Gutterparts

constructor TFEditForm.Create(AOwner: TComponent);

inherited;

FormTag := 1;

end;

procedure TFEditForm.FormCreate(Sender: TObject);

TranslateComponent(Self);

FEditor := TSynEditEx.Create(Self);

with FEditor do

begin

MaxUndo := 300;

TabWidth := 2;

WantTabs := True;

PopupMenu := PopUpEditor;

BookMarkOptions.BookmarkImages := vilBookmarksLight;

Font.Assign(FConfiguration.EditFont);

Font.Quality:= fqClearTypeNatural;

if not FConfiguration.ShowControlFlowSymbols then

DisplayFlowControl.Enabled := False;

Options := [eoAutoIndent, eoSmartTabs, eoTabIndent,

eoTabsToSpaces, eoSmartTabDelete, eoGroupUndo, eoDropFiles, eoKeepCaretX,

eoBracketsHighlight, eoAccessibility, eoCompleteBrackets,

eoCompleteQuotes, eoEnhanceHomeKey];

if FConfiguration.ShowLigatures then

Options:= Options + [eoShowLigatures];

ScrollOptions := [eoDisableScrollArrows, eoScrollPastEol, eoShowScrollHint];

Gutter.AutoSize := True;

Gutter.BorderStyle := gbsNone;

Gutter.DigitCount := 1;

Gutter.Font.Assign(FConfiguration.Font);

Gutter.Font.Height := FEditor.Font.Height + 2;

Gutter.Font.Quality := fqClearTypeNatural;

Gutter.BorderStyle := gbsNone;

//Gutter.Gradient := True; // ToDo as option

//Gutter.GradientSteps := 30;

Gutter.ShowLineNumbers := FConfiguration.LineNumbering;

Gutter.TrackChanges.Width := 2;

Gutter.TrackChanges.Visible := True;

FJava.ThemeEditorGutter(Gutter);

var

Band := TSynGutterBand(Gutter.Bands.Insert(1));

Band.Kind := gbkCustom;

Band.Width := 17;

Band.OnPaintLines := SynEditDebugInfoPaintLines;

Band.OnClick := BreakpointGutterClick;

Band.OnMouseCursor := SynEditGutterDebugInfoMouseCursor;

Band := Gutter.Bands[0];

Band.Width := 16;

Band.OnPaintLines := SynEditBookmarkPaintLines;

Band.OnClick := BookmarkGutterClick;

Band.OnMouseCursor := SynEditGutterDebugInfoMouseCursor;

IndentGuides.Style := igsDotted;

SelectedColor.Background := clSkyBlue;

UseCodeFolding := True;

WantTabs := True;

WordWrapGlyph.Visible := True;

SearchEngine := FJava.SynEditSearch;

Indent := FConfiguration.Indent;

StructureColorIntensity := FConfiguration.StructureColorIntensity;

SetCaretBlinkTime(CInsertBlink);

ScrollbarAnnotations.SetDefaultAnnotations;

OnBuildStructure := DoOnBuildStructure;

OnGutterGetText := SynEditGutterGetText;

OnSpecialLineColors := SynEditorSpecialLineColors;

OnKeyUp := EditorKeyUp;

OnKeyPress := EditorKeyPress;

OnChange := SynEditChange;

OnStatusChange := EditorStatusChange;

OnReplaceText := SynEditorReplaceText;

OnMouseOverToken := DoOnMouseOverToken;

OnMouseDown := DoOnMouseDown;

OnDropFiles := FJava.DropFiles;

if FConfiguration.EightyColumnLine then

RightEdge := 80

else

RightEdge := 0;

end;

FEditor.Parent := PMain;

FEditor.Align := alClient;

ActivityIndicator.Parent := FEditor;

EditformToolbar.Visible := FConfiguration.VisToolbars[2];

FEncoding := FConfiguration.GetEncoding;

FCheckAgeEnabled := FConfiguration.CheckAge;

FNeedsParsing := False;

FBookmark := 0;

FBreakPointCount := 0;

FEditorAge := 0;

FModel := TObjectModel.Create;

Partner := nil;

FParser := nil;

FLineBreak := #13#10;

FFrameType := 0;

FHidden := False;

CalculateStatusline;

EditorStatusChange(Sender, [scAll]);

OnMouseActivate := FormMouseActivate;

SetOptions;

ToMainPanel;

FToolButtons[0] := TBClose;

FToolButtons[1] := TBExplorer;

FToolButtons[2] := TBBrowser;

FToolButtons[3] := TBDesignform;

FToolButtons[4] := TBStructure;

FToolButtons[5] := TBClassOpen;

FToolButtons[6] := TBMatchBracket;

FToolButtons[7] := TBSystemOutPrintln;

FToolButtons[8] := TBStructureIndent;

FToolButtons[9] := TBIfStatement;

FToolButtons[10] := TBIfElseStatement;

FToolButtons[11] := TBWhileStatement;

FToolButtons[12] := TBForStatement;

FToolButtons[13] := TBDoWhileStatement;

FToolButtons[14] := TBSwitchStatement;

FToolButtons[15] := TBTryStatement;

FToolButtons[16] := TBBlockStatement;

FToolButtons[17] := TBComment;

FToolButtons[18] := TBIndent;

FToolButtons[19] := TBUnindent;

FToolButtons[20] := TBWordWrap;

FToolButtons[21] := TBBreakpoint;

FToolButtons[22] := TBBreakpointsClear;

FToolButtons[23] := TBBookmark;

FToolButtons[24] := TBGotoBookmark;

FToolButtons[25] := TBParagraph;

FToolButtons[26] := TBNumbers;

FToolButtons[27] := TBZoomOut;

FToolButtons[28] := TBZoomIn;

FToolButtons[29] := TBValidate;

Translate;

end;

procedure TFEditForm.SynEditGutterGetText(Sender: TObject; ALine: Integer;

var AText: string);

if ALine = TSynEdit(Sender).CaretY then

Exit;

if ALine mod 10 <> 0 then

if ALine mod 5 <> 0 then

AText := '·'

else

AText := '-';

end;

procedure TFEditForm.AddShortcutsToHints;

var

Str := ShortCutToText(FJava.MIIndent.ShortCut);

if Pos(Str, TBIndent.Hint) = 0 then

TBIndent.Hint := TBIndent.Hint + ' - ' + Str;

Str := ShortCutToText(FJava.MIUnindent.ShortCut);

if Pos(Str, TBUnindent.Hint) = 0 then

TBUnindent.Hint := TBUnindent.Hint + ' - ' + Str;

Str := ShortCutToText(FJava.MIStructuredIndent.ShortCut);

if Pos(Str, TBStructureIndent.Hint) = 0 then

TBStructureIndent.Hint := TBStructureIndent.Hint + ' - ' + Str;

Str := ShortCutToText(FJava.MICommentOnOff.ShortCut);

if Pos(Str, TBComment.Hint) = 0 then

TBComment.Hint := TBComment.Hint + ' - ' + Str;

Str := ShortCutToText(FJava.MISystemOutPrintln.ShortCut);

if Pos(Str, TBSystemOutPrintln.Hint) = 0 then

TBSystemOutPrintln.Hint := TBSystemOutPrintln.Hint + ' - ' + Str;

if Pos(Str, TBBookmark.Hint) = 0 then

TBBookmark.Hint := TBBookmark.Hint + ' - ' + Str;

if Pos(Str, TBGotoBookmark.Hint) = 0 then

TBGotoBookmark.Hint := TBGotoBookmark.Hint + ' - ' + Str;

end;

procedure TFEditForm.Translate;

TBIfStatement.Hint := 'if ' + _(LNGStatement);

TBIfElseStatement.Hint := 'if-else ' + _(LNGStatement);

TBWhileStatement.Hint := 'while ' + _(LNGStatement);

TBForStatement.Hint := 'for ' + _(LNGStatement);

TBDoWhileStatement.Hint := 'do-while ' + _(LNGStatement);

TBSwitchStatement.Hint := 'switch ' + _(LNGStatement);

TBTryStatement.Hint := 'try ' + _(LNGStatement);

TBBlockStatement.Hint := 'block ' + _(LNGStatement);

LNGs[1] := _(LNGStartGUIVariables);

LNGs[2] := _(LNGEndGUIVariables);

LNGs[3] := _(LNGStartComponents);

LNGs[4] := _(LNGEndComponents);

LNGs[5] := _(LNGStartEventMethods);

LNGs[6] := _(LNGEndEventMethods);

FModifiedStrs[False] := '';

FModifiedStrs[True] := _(LNGModified);

FInsertModeStrs[False] := _(LNGModusOverwrite);

FInsertModeStrs[True] := _(LNGModusInsert);

CalculateStatusline;

if UUtils.Left(MIExecuteWithoutConsole.Caption, 4) <> ' ' then

begin

MIExecuteWithoutConsole.Caption := ' ' + MIExecuteWithoutConsole.Caption;

MIExecuteWithConsole.Caption := ' ' + MIExecuteWithConsole.Caption;

end;

end;

procedure TFEditForm.New(const FileName: string);

Caption := FileName;

Pathname := FileName;

FFileExtension := LowerCase(ExtractFileExt(FileName));

DesignButton.Visible := FileExists(ChangeFileExt(FileName, '.jfm'));

SetHighlighter;

SetToolButtons;

if not FHidden then

begin

FJava.AddToWindowMenuAndTabBar(Number, OpenWindow, Self);

FJava.TabModified(Number, Modified);

Enter(Self); // must stay!

if Visible and FEditor.CanFocus then

FEditor.SetFocus;

end;

end;

procedure TFEditForm.Open(const FileName: string; State: string;

Hidden: Boolean = False);

FHidden := Hidden;

try

FEditor.LockUndo;

try

FEditor.Lines.LoadFromFile(FileName);

// set UTF8 as default FEncoding

if (FEditor.Lines.Encoding <> TEncoding.UTF8) and

not IsWriteProtected(FileName) then

begin

var

WriteTime := TFile.GetLastWriteTime(FileName);

FEditor.Lines.SaveToFile(FileName, TEncoding.UTF8);

TFile.SetLastWriteTime(FileName, WriteTime);

FEditor.Lines.LoadFromFile(FileName, TEncoding.UTF8);

end;

FEncoding := EncodingAsString(FEditor.Lines.Encoding.EncodingName);

FLineBreak := FEditor.Lines.LineBreak;

FEditor.ReplaceTabs(FConfiguration.TabWidth);

finally

FEditor.UnlockUndo;

end;

if FEditor.NeedsWordWrap then

SBWordWrapClick(Self);

FileAge(FileName, FEditorAge);

New(FileName);

FEditor.ReadOnly := (Pos(FConfiguration.JavaCache, FileName) = 1) or

IsWriteProtected(FileName);

if FEditor.ReadOnly then

Caption := Caption + ' (' + _(LNGWriteProtected) + ')';

CalculateStatusline;

if IsJava then begin

CollapseGUICreation;

ParseSourceCode(True);

end;

SetState(State);

// ensure vertical scrollbar is visible

FEditor.UpdateScrollBars;

except

on e: Exception do

begin

ErrorMsg(e.Message);

FConfiguration.Log('TFEditForm.Open: ' + FileName, e);

end;

end;

end;

procedure TFEditForm.CollapseGUICreation;

Line: Integer;

Str, Name: string;

if FConfiguration.GUICodeFolding and (GetFrameType > 1) then

begin

Name := ChangeFileExt(ExtractFileName(Pathname), '');

case FFrameType of

8:

Str := 'public void start(Stage';

7, 4:

Str := 'public void init()';

6, 5, 3, 2:

Str := 'public ' + Name + '(';

end;

for var I := 0 to Min(FEditor.AllFoldRanges.Count - 1, 2) do

begin

Line := FEditor.AllFoldRanges[I].FromLine;

if Pos(Str, FEditor.Lines[Line - 1]) > 0 then

FEditor.Collapse(I);

end;

end;

end;

procedure TFEditForm.DoOnIdle;

if not FNeedsParsing then

SyncFileStructure;

end;

procedure TFEditForm.SyncFileStructure;

if FNeedToSyncFileStructure and IsJava then

begin

FFileStructure.ShowEditorCodeElement;

FNeedToSyncFileStructure := False;

end;

end;

procedure TFEditForm.EnsureStartEnd(CorI: Integer = 1);

if Assigned(FEditor) and not FEditor.ReadOnly and not HasStartAndEnd(CorI)

then

InsertStartEnd;

end;

function PointToDisplay(Posi: TPoint): TDisplayCoord;

Result.Column := Posi.X;

Result.Row := Posi.Y;

end;

procedure TFEditForm.SynEditorReplaceText(Sender: TObject;

const ASearch, AReplace: string; Line, Column: Integer;

var AAction: TSynReplaceAction);

APos: TDisplayCoord;

EditRect: TRect;

if ASearch = AReplace then

AAction := raSkip

else

begin

APos := DisplayCoord(Column, Line);

APos := PointToDisplay

(FEditor.ClientToScreen(FEditor.RowColumnToPixels(APos)));

EditRect := ClientRect;

EditRect.TopLeft := ClientToScreen(EditRect.TopLeft);

EditRect.BottomRight := ClientToScreen(EditRect.BottomRight);

with TFConfirmReplace.Create(FJava) do

begin

PrepareShow(EditRect, APos.Column, APos.Row,

APos.Row + FEditor.LineHeight, ASearch);

case ShowModal of

mrYes:

AAction := raReplace;

mrYesToAll:

AAction := raReplaceAll;

mrNo:

AAction := raSkip;

else

AAction := raCancel;

end;

Free;

end;

end;

end;

procedure TFEditForm.SetHighlighter;

if FConfiguration.NoSyntaxHighlighting then

FEditor.Highlighter := nil

else

FEditor.Highlighter := FConfiguration.GetHighlighter(FFileExtension);

if FEditor.Highlighter = nil then

FEditor.StructureColoring := False

else

begin

FEditor.StructureColoring := FConfiguration.StructureColoring;

FEditor.UseCodeFolding := True;

end;

if FEditor.StructureColoring and IsJava then

FNeedsParsing := True;

end;

procedure TFEditForm.SetToolButtons;

for var I := 0 to 29 do

FToolButtons[I].Visible := True;