innosetup/Components/ScintEdit.pas

unit ScintEdit;

{
  Inno Setup
  Copyright (C) 1997-2026 Jordan Russell
  Portions by Martijn Laan
  For conditions of distribution and use, see LICENSE.TXT.

  TScintEdit component: a VCL wrapper for Scintilla
}

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Generics.Collections, ScintInt;

const
  StyleNumbers = 32; { The syntax highlighting can use up to 32 styles }
  StyleNumberBits = 5; { 5 bits are needed to store 32 values }
  StyleNumberMask = StyleNumbers-1; { To get the 5 bits from a byte it needs to be AND-ed with $1F = 31 }
  StyleNumberUnusedBits = 8-StyleNumberBits; { 3 bits of a byte are unused }

type
  TScintChangeHistory = (schDisabled, schMarkers, schIndicators);
  TScintCommand = type NativeInt;
  TScintEditAutoCompleteSelectionEvent = TNotifyEvent;
  TScintEditCallTipArrowClick = procedure(Sender: TObject; const Up: Boolean) of object;
  TScintEditChangeInfo = record
    Inserting: Boolean;
    StartPos, Length, LinesDelta: Integer;
  end;
  TScintEditChangeEvent = procedure(Sender: TObject;
    const Info: TScintEditChangeInfo) of object;
  TScintEditCharAddedEvent = procedure(Sender: TObject; Ch: AnsiChar) of object;
  TScintEditDropFilesEvent = procedure(Sender: TObject; X, Y: Integer;
    AFiles: TStrings) of object;
  TScintHintInfo = Controls.THintInfo;
  TScintEditHintShowEvent = procedure(Sender: TObject;
    var Info: TScintHintInfo) of object;
  TScintEditMarginClickEvent = procedure(Sender: TObject; MarginNumber: Integer;
    Line: Integer) of object;
  TScintEditUpdate = (suContent, suSelection, suVScroll, suHScroll);
  TScintEditUpdates = set of TScintEditUpdate;
  TScintEditUpdateUIEvent = procedure(Sender: TObject; Updated: TScintEditUpdates) of object;
  TScintFindOption = (sfoMatchCase, sfoWholeWord, sfoRegEx);
  TScintFindOptions = set of TScintFindOption;
  TScintFoldFlag = (sffLineBeforeExpanded, sffLineBeforeContracted,
    sffLineAfterExpanded, sffLineAfterContracted, sffLevelNumbers, sffLineState);
  TScintFoldFlags = set of TScintFoldFlag;
  TScintIndentationGuides = (sigNone, sigReal, sigLookForward, sigLookBoth);
  TScintKeyCode = type Word;
  TScintKeyDefinition = type Cardinal;
  TScintReplaceMode = (srmNormal, srmMinimal, srmRegEx);
  TScintStyleByteIndicatorNumber = 0..1; { Could be increased to 0..StyleNumberUnusedBits-1 }
  TScintStyleByteIndicatorNumbers = set of TScintStyleByteIndicatorNumber;
  TScintIndicatorNumber = INDICATOR_CONTAINER..INDICATOR_MAX;
  TScintLineEndings = (sleCRLF, sleCR, sleLF);
  TScintLineState = type Integer;
  TScintMarkerNumber = 0..31;
  TScintMarkerNumbers = set of TScintMarkerNumber;
  TScintRange = record
    StartPos, EndPos: Integer;
    constructor Create(const AStartPos, AEndPos: Integer);
    function Empty: Boolean;
    function Overlaps(const ARange: TScintRange): Boolean;
    function Within(const ARange: TScintRange): Boolean;
  end;
  TScintRangeList = class(TList<TScintRange>)
    function Count: Integer;
    function Overlaps(const ARange: TScintRange;
      var AOverlappingRange: TScintRange): Boolean;
  end;
  TScintCaretAndAnchor = record
    CaretPos, AnchorPos: Integer;
    constructor Create(const ACaretPos, AAnchorPos: Integer);
    function Range: TScintRange;
  end;
  TScintCaretAndAnchorList = class(TList<TScintCaretAndAnchor>)
    function Count: Integer;
  end;
  TScintRawCharSet = set of AnsiChar;
  TScintRawString = type RawByteString;
  TScintRectangle = record
    Left, Top, Right, Bottom: Integer;
  end;
  TScintSelectionMode = (ssmStream, ssmRectangular, ssmLines, ssmThinRectangular);
  TScintStyleNumber = 0..StyleNumbers-1;
  TScintVirtualSpaceOption = (svsRectangularSelection, svsUserAccessible,
    svsNoWrapLineStart);
  TScintVirtualSpaceOptions = set of TScintVirtualSpaceOption;
  PScintRangeToFormat = ^TScintRangeToFormat;
  TScintRangeToFormat = record
    hdc, hdcTarget: UINT_PTR;
    rc, rcPage: TScintRectangle;
    chrg: TScintRange;
  end;

  TScintEditStrings = class;
  TScintCustomStyler = class;

  EScintEditError = class(Exception);

  TScintEdit = class(TWinControl)
  private
    FAcceptDroppedFiles: Boolean;
    FAutoCompleteFontName: String;
    FAutoCompleteFontSize: Integer;
    FAutoCompleteStyle: Integer;
    FChangeHistory: TScintChangeHistory;
    FCodePage: Word;
    FDirectPtr: Pointer;
    FDirectStatusFunction: SciFnDirectStatus;
    FEffectiveCodePage: Word;
    FEffectiveCodePageDBCS: Boolean;
    FFillSelectionToEdge: Boolean;
    FFoldLevelNumbersOrLineState: Boolean;
    FForceModified: Boolean;
    FIndentationGuides: TScintIndentationGuides;
    FLeadBytes: TScintRawCharSet;
    FLineNumbers: Boolean;
    FLines: TScintEditStrings;
    FOnAutoCompleteSelection: TScintEditAutoCompleteSelectionEvent;
    FOnCallTipArrowClick: TScintEditCallTipArrowClick;
    FOnChange: TScintEditChangeEvent;
    FOnCharAdded: TScintEditCharAddedEvent;
    FOnDropFiles: TScintEditDropFilesEvent;
    FOnHintShow: TScintEditHintShowEvent;
    FOnMarginClick: TScintEditMarginClickEvent;
    FOnMarginRightClick: TScintEditMarginClickEvent;
    FOnModifiedChange: TNotifyEvent;
    FOnUpdateUI: TScintEditUpdateUIEvent;
    FOnZoom: TNotifyEvent;
    FReportCaretPositionToStyler: Boolean;
    FStyler: TScintCustomStyler;
    FTabWidth: Integer;
    FUseStyleAttributes: Boolean;
    FUseTabCharacter: Boolean;
    FVirtualSpaceOptions: TScintVirtualSpaceOptions;
    FWordChars: AnsiString;
    FWordCharsAsSet: TSysCharSet;
    FWordWrap: Boolean;
    procedure ApplyOptions;
    procedure ForwardMessage(const Message: TMessage);
    function GetAnchorPosition: Integer;
    function GetAutoCompleteActive: Boolean;
    function GetCallTipActive: Boolean;
    function GetCaretColumn: Integer;
    function GetCaretColumnExpandedForTabs: Integer;
    function GetCaretLine: Integer;
    function GetCaretLineText: String;
    function GetCaretPosition: Integer;
    function GetCaretPositionInLine: Integer;
    function GetCaretVirtualSpace: Integer;
    function GetInsertMode: Boolean;
    function GetLineEndings: TScintLineEndings;
    function GetLineEndingString: TScintRawString;
    function GetLineHeight: Integer;
    function GetLinesInWindow: Integer;
    function GetMainSelText: String;
    function GetModified: Boolean;
    function GetRawCaretLineText: TScintRawString;
    function GetRawMainSelText: TScintRawString;
    function GetRawSelText: TScintRawString;
    function GetRawText: TScintRawString;
    function GetReadOnly: Boolean;
    class function GetReplaceTargetMessage(const ReplaceMode: TScintReplaceMode): Cardinal; static;
    class function GetSearchFlags(const Options: TScintFindOptions): Integer; static;
    function GetSelection: TScintRange;
    function GetSelectionAnchorPosition(Selection: Integer): Integer;
    function GetSelectionAnchorVirtualSpace(Selection: Integer): Integer;
    function GetSelectionCaretPosition(Selection: Integer): Integer;
    function GetSelectionCaretVirtualSpace(Selection: Integer): Integer;
    function GetSelectionEndPosition(Selection: Integer): Integer;
    function GetSelectionCount: Integer;
    function GetSelectionMode: TScintSelectionMode;
    function GetSelectionStartPosition(Selection: Integer): Integer;
    function GetSelText: String;
    function GetTopLine: Integer;
    function GetZoom: Integer;
    procedure SetAcceptDroppedFiles(const Value: Boolean);
    procedure SetAutoCompleteFontName(const Value: String);
    procedure SetAutoCompleteFontSize(const Value: Integer);
    procedure SetCodePage(const Value: Word);
    procedure SetCaretColumn(const Value: Integer);
    procedure SetCaretLine(const Value: Integer);
    procedure SetCaretPosition(const Value: Integer);
    procedure SetCaretPositionWithSelectFromAnchor(const Value: Integer);
    procedure SetCaretVirtualSpace(const Value: Integer);
    procedure SetChangeHistory(const Value: TScintChangeHistory);
    procedure SetFillSelectionToEdge(const Value: Boolean);
    procedure SetFoldFlags(const Value: TScintFoldFlags);
    procedure SetIndentationGuides(const Value: TScintIndentationGuides);
    procedure SetLineNumbers(const Value: Boolean);
    procedure SetMainSelection(const Value: Integer);
    procedure SetMainSelText(const Value: String);
    procedure SetRawMainSelText(const Value: TScintRawString);
    procedure SetRawSelText(const Value: TScintRawString);
    procedure SetRawText(const Value: TScintRawString);
    procedure SetReadOnly(const Value: Boolean);
    procedure SetSelection(const Value: TScintRange);
    procedure SetSelectionAnchorPosition(Selection: Integer; const Value: Integer);
    procedure SetSelectionAnchorVirtualSpace(Selection: Integer;
      const Value: Integer);
    procedure SetSelectionCaretPosition(Selection: Integer; const Value: Integer);
    procedure SetSelectionCaretVirtualSpace(Selection: Integer;
      const Value: Integer);
    procedure SetSelectionMode(const Value: TScintSelectionMode);
    procedure SetSelText(const Value: String);
    procedure SetStyler(const Value: TScintCustomStyler);
    procedure SetTabWidth(const Value: Integer);
    procedure SetTopLine(const Value: Integer);
    procedure SetUseStyleAttributes(const Value: Boolean);
    procedure SetUseTabCharacter(const Value: Boolean);
    procedure SetVirtualSpaceOptions(const Value: TScintVirtualSpaceOptions);
    procedure SetWordWrap(const Value: Boolean);
    procedure SetZoom(const Value: Integer);
    procedure UpdateCodePage;
    procedure UpdateLineNumbersWidth;
    procedure CMColorChanged(var Message: TMessage); message CM_COLORCHANGED;
    procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED;
    procedure CMHintShow(var Message: TCMHintShow); message CM_HINTSHOW;
    procedure CMSysColorChange(var Message: TMessage); message CM_SYSCOLORCHANGE;
    procedure CNNotify(var Message: TWMNotify); message CN_NOTIFY;
    procedure WMDestroy(var Message: TWMDestroy); message WM_DESTROY;
    procedure WMDropFiles(var Message: TWMDropFiles); message WM_DROPFILES;
    procedure WMEraseBkgnd(var Message: TMessage); message WM_ERASEBKGND;
    procedure WMGetDlgCode(var Message: TWMGetDlgCode); message WM_GETDLGCODE;
    procedure WMMouseWheel(var Message: TMessage); message WM_MOUSEWHEEL;
  protected
    procedure Change(const AInserting: Boolean; const AStartPos, ALength,
      ALinesDelta: Integer); virtual;
    procedure CheckPosRange(const StartPos, EndPos: Integer);
    procedure CreateParams(var Params: TCreateParams); override;
    procedure CreateWnd; override;
    class function GetErrorException(const S: String): EScintEditError; static;
    class procedure Error(const S: String); static;
    class procedure ErrorFmt(const S: String; const Args: array of const); static;
    function GetMainSelection: Integer;
    function GetTarget: TScintRange;
    procedure InitRawString(var S: TScintRawString; const Len: Integer);
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
    procedure Notify(const N: TSCNotification); virtual;
    procedure SetTarget(const StartPos, EndPos: Integer);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure AddMarker(const Line: Integer; const Marker: TScintMarkerNumber);
    procedure AddSelection(const CaretPos, AnchorPos: Integer);
    procedure AssignCmdKey(const Key: AnsiChar; const Shift: TShiftState;
      const Command: TScintCommand); overload;
    procedure AssignCmdKey(const KeyCode: TScintKeyCode; const Shift: TShiftState;
      const Command: TScintCommand); overload;
    procedure BeginUndoAction;
    procedure BraceMatch;
    function Call(Msg: Cardinal; WParam: NativeInt; LParam: LPARAM): Integer; overload;
    function Call(Msg: Cardinal; WParam: WPARAM; LParam: LPARAM): Integer; overload;
    function Call(Msg: Cardinal; WParam: NativeInt; LParam: LPARAM; out WarnStatus: Integer): Integer; overload;
    function Call(Msg: Cardinal; WParam: WPARAM; LParam: LPARAM; out WarnStatus: Integer): Integer; overload;
    function Call(Msg: Cardinal; WParam: NativeInt; const LParamStr: TScintRawString): Integer; overload;
    function Call(Msg: Cardinal; WParam: WPARAM; const LParamStr: TScintRawString): Integer; overload;
    function Call(Msg: Cardinal; WParam: NativeInt; const LParamStr: TScintRawString; out WarnStatus: Integer): Integer; overload;
    function Call(Msg: Cardinal; WParam: WPARAM; const LParamStr: TScintRawString; out WarnStatus: Integer): Integer; overload;
    procedure CancelAutoComplete;
    procedure CancelAutoCompleteAndCallTip;
    procedure CancelCallTip;
    function CanPaste: Boolean;
    function CanRedo: Boolean;
    function CanUndo: Boolean;
    procedure ChooseCaretX;
    procedure ClearAll;
    procedure ClearCmdKey(const Key: AnsiChar; const Shift: TShiftState); overload;
    procedure ClearCmdKey(const KeyCode: TScintKeyCode; const Shift: TShiftState); overload;
    procedure ClearIndicators(const IndicatorNumber: TScintIndicatorNumber);
    procedure ClearSelection;
    procedure ClearUndo(const ClearChangeHistory: Boolean = True);
    function ConvertRawStringToString(const S: TScintRawString): String;
    function ConvertPCharToRawString(const Text: PChar;
      const TextLen: Integer): TScintRawString;
    function ConvertStringToRawString(const S: String): TScintRawString;
    procedure CopyToClipboard;
    procedure CutToClipboard;
    procedure DeleteAllMarkersOnLine(const Line: Integer);
    procedure DeleteMarker(const Line: Integer; const Marker: TScintMarkerNumber);
    procedure DPIChanged(const Message: TMessage);
    procedure EndUndoAction;
    procedure EnsureLineVisible(const Line: Integer);
    function FindRawText(const StartPos, EndPos: Integer; const S: TScintRawString;
      const Options: TScintFindOptions; out MatchRange: TScintRange): Boolean;
    function FindText(const StartPos, EndPos: Integer; const S: String;
      const Options: TScintFindOptions; out MatchRange: TScintRange): Boolean;
    procedure FoldLine(const Line: Integer; const Fold: Boolean);
    function FormatRange(const Draw: Boolean;
      const RangeToFormat: PScintRangeToFormat): Integer;
    procedure ForceModifiedState;
    function GetByteAtPosition(const Pos: Integer): AnsiChar;
    function GetCharacterCount(const StartPos, EndPos: Integer): Integer;
    function GetColumnFromPosition(const Pos: Integer): Integer;
    function GetDefaultWordChars: AnsiString;
    function GetDocLineFromVisibleLine(const VisibleLine: Integer): Integer;
    function GetIndicatorAtPosition(const IndicatorNumber: TScintIndicatorNumber;
      const Pos: Integer): Boolean;
    function GetLineEndPosition(const Line: Integer): Integer;
    function GetLineFromPosition(const Pos: Integer): Integer;
    function GetLineIndentation(const Line: Integer): Integer;
    function GetLineIndentPosition(const Line: Integer): Integer;
    function GetMarkers(const Line: Integer): TScintMarkerNumbers;
    function GetPointFromPosition(const Pos: Integer): TPoint;
    function GetPositionAfter(const Pos: Integer): Integer;
    function GetPositionBefore(const Pos: Integer): Integer;
    function GetPositionFromLine(const Line: Integer): Integer;
    function GetPositionFromLineColumn(const Line, Column: Integer): Integer;
    function GetPositionFromLineExpandedColumn(const Line, ExpandedColumn: Integer): Integer;
    function GetPositionFromPoint(const P: TPoint;
      const CharPosition, CloseOnly: Boolean): Integer;
    function GetPositionOfMatchingBrace(const Pos: Integer): Integer;
    function GetPositionRelative(const Pos, CharacterCount: Integer): Integer;
    function GetRawTextLength: Integer;
    function GetRawTextRange(const StartPos, EndPos: Integer): TScintRawString;
    procedure GetSelections(const RangeList: TScintRangeList); overload;
    procedure GetSelections(const CaretAndAnchorList: TScintCaretAndAnchorList); overload;
    procedure GetSelections(const CaretAndAnchorList, VirtualSpacesList: TScintCaretAndAnchorList); overload;
    function GetStyleAtPosition(const Pos: Integer): TScintStyleNumber;
    function GetTextRange(const StartPos, EndPos: Integer): String;
    function GetVisibleLineFromDocLine(const DocLine: Integer): Integer;
    function GetWordEndPosition(const Pos: Integer; const OnlyWordChars: Boolean): Integer;
    function GetWordStartPosition(const Pos: Integer; const OnlyWordChars: Boolean): Integer;
    function IsPositionInViewVertically(const Pos: Integer): Boolean;
    class function KeyCodeAndShiftToKeyDefinition(const KeyCode: TScintKeyCode;
      Shift: TShiftState): TScintKeyDefinition; static;
    function MainSelTextEquals(const S: String;
      const Options: TScintFindOptions): Boolean;
    class function KeyToKeyCode(const Key: AnsiChar): TScintKeyCode; static;
    procedure PasteFromClipboard;
    function RawMainSelTextEquals(const S: TScintRawString;
      const Options: TScintFindOptions): Boolean;
    class function RawStringIsBlank(const S: TScintRawString): Boolean; static;
    procedure Redo;
    procedure RemoveAdditionalSelections;
    function ReplaceMainSelText(const S: String;
      const ReplaceMode: TScintReplaceMode = srmNormal): TScintRange;
    function ReplaceRawMainSelText(const S: TScintRawString;
      const ReplaceMode: TScintReplaceMode = srmNormal): TScintRange;
    function ReplaceRawTextRange(const StartPos, EndPos: Integer;
      const S: TScintRawString; const ReplaceMode: TScintReplaceMode = srmNormal): TScintRange;
    function ReplaceTextRange(const StartPos, EndPos: Integer; const S: String;
      const ReplaceMode: TScintReplaceMode = srmNormal): TScintRange;
    procedure RestyleLine(const Line: Integer);
    procedure ScrollCaretIntoView;
    procedure SelectAll;
    procedure SelectAllOccurrences(const Options: TScintFindOptions);
    procedure SelectAndEnsureVisible(const Range: TScintRange);
    procedure SelectNextOccurrence(const Options: TScintFindOptions);
    function SelEmpty: Boolean;
    function SelNotEmpty(out Sel: TScintRange): Boolean;
    procedure SetAutoCompleteFillupChars(const FillupChars: AnsiString);
    procedure SetAutoCompleteSeparators(const Separator, TypeSeparator: AnsiChar);
    procedure SetAutoCompleteSelectedItem(const S: TScintRawString);
    procedure SetAutoCompleteStopChars(const StopChars: AnsiString);
    procedure SetBraceBadHighlighting(const Pos: Integer);
    procedure SetBraceHighlighting(const Pos1, Pos2: Integer);
    procedure SetCursorID(const CursorID: Integer);
    procedure SetCallTipHighlight(HighlightStart, HighlightEnd: Integer);
    procedure SetDefaultWordChars;
    procedure SetEmptySelection;
    procedure SetEmptySelections;
    procedure SetIndicators(const StartPos, EndPos: Integer;
      const IndicatorNumber: TScintIndicatorNumber; const Value: Boolean);
    procedure SetLineIndentation(const Line, Indentation: Integer);
    procedure SetSavePoint;
    procedure SetSingleSelection(const CaretPos, AnchorPos: Integer);
    procedure SettingChange(const Message: TMessage);
    procedure SetWordChars(const S: AnsiString);
    procedure ShowAutoComplete(const CharsEntered: Integer; const WordList: AnsiString);
    procedure ShowCallTip(const Pos: Integer; const Definition: AnsiString);
    procedure StyleNeeded(const EndPos: Integer);
    procedure SysColorChange(const Message: TMessage);
    function TestRegularExpression(const S: String): Boolean;
    function TestRawRegularExpression(const S: TScintRawString): Boolean;
    procedure Undo;
    procedure UpdateStyleAttributes;
    function WordAtCaret: String;
    function WordAtCaretRange: TScintRange;
    procedure ZoomIn;
    procedure ZoomOut;
    property AnchorPosition: Integer read GetAnchorPosition;
    property AutoCompleteActive: Boolean read GetAutoCompleteActive;
    property CallTipActive: Boolean read GetCallTipActive;
    property CaretColumn: Integer read GetCaretColumn write SetCaretColumn;
    property CaretColumnExpandedForTabs: Integer read GetCaretColumnExpandedForTabs;
    property CaretLine: Integer read GetCaretLine write SetCaretLine;
    property CaretLineText: String read GetCaretLineText;
    property CaretPosition: Integer read GetCaretPosition write SetCaretPosition;
    property CaretPositionInLine: Integer read GetCaretPositionInLine;
    property CaretPositionWithSelectFromAnchor: Integer write SetCaretPositionWithSelectFromAnchor;
    property CaretVirtualSpace: Integer read GetCaretVirtualSpace write SetCaretVirtualSpace;
    property EffectiveCodePage: Word read FEffectiveCodePage;
    property FoldFlags: TScintFoldFlags write SetFoldFlags;
    property InsertMode: Boolean read GetInsertMode;
    property LineEndings: TScintLineEndings read GetLineEndings;
    property LineEndingString: TScintRawString read GetLineEndingString;
    property LineHeight: Integer read GetLineHeight;
    property Lines: TScintEditStrings read FLines;
    property LinesInWindow: Integer read GetLinesInWindow;
    property MainSelection: Integer read GetMainSelection write SetMainSelection;
    property MainSelText: String read GetMainSelText write SetMainSelText;
    property Modified: Boolean read GetModified;
    property RawCaretLineText: TScintRawString read GetRawCaretLineText;
    property RawMainSelText: TScintRawString read GetRawMainSelText write SetRawMainSelText;
    property RawSelText: TScintRawString read GetRawSelText write SetRawSelText;
    property RawText: TScintRawString read GetRawText write SetRawText;
    property RawTextLength: Integer read GetRawTextLength;
    property ReadOnly: Boolean read GetReadOnly write SetReadOnly;
    property Selection: TScintRange read GetSelection write SetSelection;
    property SelectionAnchorPosition[Selection: Integer]: Integer read GetSelectionAnchorPosition write SetSelectionAnchorPosition;
    property SelectionAnchorVirtualSpace[Selection: Integer]: Integer read GetSelectionAnchorVirtualSpace write SetSelectionAnchorVirtualSpace;
    property SelectionCaretPosition[Selection: Integer]: Integer read GetSelectionCaretPosition write SetSelectionCaretPosition;
    property SelectionCaretVirtualSpace[Selection: Integer]: Integer read GetSelectionCaretVirtualSpace write SetSelectionCaretVirtualSpace;
    property SelectionCount: Integer read GetSelectionCount;
    property SelectionEndPosition[Selection: Integer]: Integer read GetSelectionEndPosition;
    property SelectionMode: TScintSelectionMode read GetSelectionMode write SetSelectionMode;
    property SelectionStartPosition[Selection: Integer]: Integer read GetSelectionStartPosition;
    property SelText: String read GetSelText write SetSelText;
    property Styler: TScintCustomStyler read FStyler write SetStyler;
    property Target: TScintRange read GetTarget;
    property TopLine: Integer read GetTopLine write SetTopLine;
    property WordChars: AnsiString read FWordChars;
    property WordCharsAsSet: TSysCharSet read FWordCharsAsSet;
  published
    property AcceptDroppedFiles: Boolean read FAcceptDroppedFiles write SetAcceptDroppedFiles
      default False;
    property AutoCompleteFontName: String read FAutoCompleteFontName
      write SetAutoCompleteFontName;
    property AutoCompleteFontSize: Integer read FAutoCompleteFontSize
      write SetAutoCompleteFontSize default 0;
    property ChangeHistory: TScintChangeHistory read FChangeHistory write SetChangeHistory default schDisabled;
    property CodePage: Word read FCodePage write SetCodePage default CP_UTF8;
    property Color;
    property FillSelectionToEdge: Boolean read FFillSelectionToEdge write SetFillSelectionToEdge
      default False;
    property Font;
    property IndentationGuides: TScintIndentationGuides read FIndentationGuides
      write SetIndentationGuides default sigNone;
    property LineNumbers: Boolean read FLineNumbers write SetLineNumbers default False;
    property ParentFont;
    property PopupMenu;
    property ReportCaretPositionToStyler: Boolean read FReportCaretPositionToStyler
      write FReportCaretPositionToStyler;
    property TabStop default True;
    property TabWidth: Integer read FTabWidth write SetTabWidth default 8;
    property UseStyleAttributes: Boolean read FUseStyleAttributes write SetUseStyleAttributes
      default True;
    property UseTabCharacter: Boolean read FUseTabCharacter write SetUseTabCharacter
      default True;
    property VirtualSpaceOptions: TScintVirtualSpaceOptions read FVirtualSpaceOptions
      write SetVirtualSpaceOptions default [];
    property WordWrap: Boolean read FWordWrap write SetWordWrap default False;
    property Zoom: Integer read GetZoom write SetZoom default 0;
    property OnAutoCompleteSelection: TScintEditAutoCompleteSelectionEvent read FOnAutoCompleteSelection write FOnAutoCompleteSelection;
    property OnCallTipArrowClick: TScintEditCallTipArrowClick read FOnCallTipArrowClick write FOnCallTipArrowClick;
    property OnChange: TScintEditChangeEvent read FOnChange write FOnChange;
    property OnCharAdded: TScintEditCharAddedEvent read FOnCharAdded write FOnCharAdded;
    property OnDropFiles: TScintEditDropFilesEvent read FOnDropFiles write FOnDropFiles;
    property OnHintShow: TScintEditHintShowEvent read FOnHintShow write FOnHintShow;
    property OnKeyDown;
    property OnKeyPress;
    property OnKeyUp;
    property OnMarginClick: TScintEditMarginClickEvent read FOnMarginClick write FOnMarginClick;
    property OnMarginRightClick: TScintEditMarginClickEvent read FOnMarginRightClick write FOnMarginRightClick;
    property OnModifiedChange: TNotifyEvent read FOnModifiedChange write FOnModifiedChange;
    property OnMouseDown;
    property OnMouseMove;
    property OnMouseUp;
    property OnUpdateUI: TScintEditUpdateUIEvent read FOnUpdateUI write FOnUpdateUI;
    property OnZoom: TNotifyEvent read FOnZoom write FOnZoom;
  end;

  TScintEditStrings = class(TStrings)
  private
    FEdit: TScintEdit;
    function GetLineEndingLength(const Index: Integer): Integer;
    function GetRawLine(Index: Integer): TScintRawString;
    function GetRawLineWithEnding(Index: Integer): TScintRawString;
    function GetRawLineLength(Index: Integer): Integer;
    function GetRawLineLengthWithEnding(Index: Integer): Integer;
    function GetState(Index: Integer): TScintLineState;
    procedure PutRawLine(Index: Integer; const S: TScintRawString);
  protected
    procedure CheckIndexRange(const Index: Integer);
    procedure CheckIndexRangePlusOne(const Index: Integer);
    function Get(Index: Integer): String; override;
    function GetCount: Integer; override;
    function GetTextStr: String; override;
    procedure Put(Index: Integer; const S: String); override;
    procedure SetTextStr(const Value: String); override;
  public
    procedure Clear; override;
    procedure Delete(Index: Integer); override;
    procedure Insert(Index: Integer; const S: String); override;
    procedure InsertRawLine(Index: Integer; const S: TScintRawString);
    procedure SetText(Text: PChar); override;
    property RawLineLengths[Index: Integer]: Integer read GetRawLineLength;
    property RawLineLengthsWithEnding[Index: Integer]: Integer read GetRawLineLengthWithEnding;
    property RawLines[Index: Integer]: TScintRawString read GetRawLine write PutRawLine;
    property RawLinesWithEnding[Index: Integer]: TScintRawString read GetRawLineWithEnding;
    property State[Index: Integer]: TScintLineState read GetState;
  end;

  TScintStyleAttributes = record
    FontName: String;
    FontSize: Integer;
    FontStyle: TFontStyles;
    FontCharset: TFontCharset;
    ForeColor: TColor;
    BackColor: TColor;
  end;

  TScintCustomStyler = class(TComponent)
  private
    FCaretIndex: Integer;
    FCurIndex: Integer;
    FLineState: TScintLineState;
    FStyleStartIndex: Integer;
    FStyleStr: AnsiString;
    FText: TScintRawString;
    FTextLen: Integer;
    function GetCurChar: AnsiChar;
    function GetEndOfLine: Boolean;
  protected
    procedure ApplyStyleByteIndicators(const Indicators: TScintStyleByteIndicatorNumbers;
      StartIndex, EndIndex: Integer);
    procedure ApplyStyle(const Style: TScintStyleNumber;
      StartIndex, EndIndex: Integer);
    procedure CommitStyle(const Style: TScintStyleNumber);
    function ConsumeAllRemaining: Boolean;
    function ConsumeChar(const C: AnsiChar): Boolean;
    function ConsumeCharIn(const Chars: TScintRawCharSet): Boolean;
    function ConsumeChars(const Chars: TScintRawCharSet): Boolean;
    function ConsumeCharsNot(const Chars: TScintRawCharSet): Boolean;
    function ConsumeString(const Chars: TScintRawCharSet): TScintRawString;
    function CurCharIn(const Chars: TScintRawCharSet): Boolean;
    function CurCharIs(const C: AnsiChar): Boolean;
    procedure GetFoldLevel(const LineState, PreviousLineState: TScintLineState;
      var Level: Integer; var Header, EnableHeaderOnPrevious: Boolean); virtual; abstract;
    procedure GetStyleAttributes(const Style: Integer;
      var Attributes: TScintStyleAttributes); virtual; abstract;
    function LineTextSpans(const S: TScintRawString): Boolean; virtual;
    function NextCharIs(const C: AnsiChar): Boolean;
    function PreviousCharIn(const Chars: TScintRawCharSet): Boolean;
    procedure ResetCurIndexTo(Index: Integer);
    procedure ReplaceText(StartIndex, EndIndex: Integer; const C: AnsiChar);
    procedure StyleNeeded; virtual; abstract;
    property CaretIndex: Integer read FCaretIndex;
    property CurChar: AnsiChar read GetCurChar;
    property CurIndex: Integer read FCurIndex;
    property EndOfLine: Boolean read GetEndOfLine;
    property LineState: TScintLineState read FLineState write FLineState;
    property StyleStartIndex: Integer read FStyleStartIndex;
    property Text: TScintRawString read FText;
    property TextLength: Integer read FTextLen;
  end;

  TScintPixmap = class
  private
    type
      TPixmap = array of AnsiString;
    class var
      ColorCodes: String;
    var
      FPixmap: TPixmap;
    class constructor Create;
    function GetPixmap: Pointer;
  public
    procedure InitializeFromBitmap(const ABitmap: TBitmap; const TransparentColor: TColorRef);
    property Pixmap: Pointer read GetPixmap;
  end;

implementation

uses
  ShellAPI, RTLConsts, UITypes, GraphUtil;

{ TScintEdit }

const
  AUTOCSETSEPARATOR = #9;

constructor TScintEdit.Create(AOwner: TComponent);
begin
  inherited;
  FCodePage := CP_UTF8;
  FLines := TScintEditStrings.Create;
  FLines.FEdit := Self;
  FTabWidth := 8;
  FUseStyleAttributes := True;
  FUseTabCharacter := True;
  SetBounds(0, 0, 257, 193);
  ParentColor := False;
  TabStop := True;
end;

destructor TScintEdit.Destroy;
begin
  SetStyler(nil);
  FLines.Free;
  FLines := nil;
  inherited;
end;

procedure TScintEdit.AddMarker(const Line: Integer;
  const Marker: TScintMarkerNumber);
begin
  FLines.CheckIndexRange(Line);
  Call(SCI_MARKERADD, Line, Marker);
end;

procedure TScintEdit.AddSelection(const CaretPos, AnchorPos: Integer);
{ Adds a new selection as the main selection retaining all other selections as
  additional selections without scrolling the caret into view. The first
  selection should be added with SetSingleSelection. }
begin
  Call(SCI_ADDSELECTION, CaretPos, AnchorPos);
end;

procedure TScintEdit.ApplyOptions;
const
  IndentationGuides: array [TScintIndentationGuides] of Integer = (SC_IV_NONE, SC_IV_REAL,
    SC_IV_LOOKFORWARD, SC_IV_LOOKBOTH);
var
  Flags: Integer;
begin
  if not HandleAllocated then
    Exit;
  Call(SCI_SETSELEOLFILLED, Ord(FFillSelectionToEdge), 0);
  Call(SCI_SETTABWIDTH, FTabWidth, 0);
  Call(SCI_SETUSETABS, Ord(FUseTabCharacter), 0);
  Flags := 0;
  if svsRectangularSelection in VirtualSpaceOptions then
    Flags := Flags or SCVS_RECTANGULARSELECTION;
  if svsUserAccessible in VirtualSpaceOptions then
    Flags := Flags or SCVS_USERACCESSIBLE;
  if svsNoWrapLineStart in VirtualSpaceOptions then
    Flags := Flags or SCVS_NOWRAPLINESTART;
  Call(SCI_SETVIRTUALSPACEOPTIONS, Flags, 0);
  Call(SCI_SETWRAPMODE, Ord(FWordWrap), 0);
  Call(SCI_SETINDENTATIONGUIDES, IndentationGuides[FIndentationGuides], 0);
  { If FChangeHistory is not schDisabled then next call to ClearUndo will enable
    change history and else we should disable it now }
  if FChangeHistory = schDisabled then
    Call(SCI_SETCHANGEHISTORY, SC_CHANGE_HISTORY_DISABLED, 0);
end;

procedure TScintEdit.AssignCmdKey(const Key: AnsiChar; const Shift: TShiftState;
  const Command: TScintCommand);
begin
  AssignCmdKey(KeyToKeyCode(Key), Shift, Command);
end;

procedure TScintEdit.AssignCmdKey(const KeyCode: TScintKeyCode;
  const Shift: TShiftState; const Command: TScintCommand);
begin
  Call(SCI_ASSIGNCMDKEY, KeyCodeAndShiftToKeyDefinition(KeyCode, Shift), Command);
end;

procedure TScintEdit.BeginUndoAction;
begin
  Call(SCI_BEGINUNDOACTION, 0, 0);
end;

procedure TScintEdit.BraceMatch;
begin
  var Selections: TScintCaretAndAnchorList := nil;
  var VirtualSpaces: TScintCaretAndAnchorList := nil;
  try
    Selections := TScintCaretAndAnchorList.Create;
    VirtualSpaces := TScintCaretAndAnchorList.Create;
    GetSelections(Selections, VirtualSpaces);
    for var I := 0 to Selections.Count-1 do begin
      if VirtualSpaces[I].CaretPos = 0 then begin
        var Pos := Selections[I].CaretPos;
        var MatchPos := GetPositionOfMatchingBrace(Pos);
        if MatchPos = -1 then begin
          Pos := GetPositionBefore(Pos);
          MatchPos := GetPositionOfMatchingBrace(Pos)
        end;
        if MatchPos <> -1 then begin
          SelectionCaretPosition[I] := MatchPos;
          SelectionAnchorPosition[I] := MatchPos;
          if I = 0 then
            ScrollCaretIntoView;
        end;
      end;
    end;
  finally
    VirtualSpaces.Free;
    Selections.Free;
  end;
end;

function TScintEdit.Call(Msg: Cardinal; WParam: NativeInt; LParam: LPARAM): Integer;
begin
  var Dummy: Integer;
  Result := Call(Msg, NativeUInt(WParam), LParam, Dummy);
end;

function TScintEdit.Call(Msg: Cardinal; WParam: WPARAM; LParam: LPARAM): Integer;
begin
  var Dummy: Integer;
  Result := Call(Msg, WParam, LParam, Dummy);
end;

function TScintEdit.Call(Msg: Cardinal; WParam: NativeInt; LParam: LPARAM;
  out WarnStatus: Integer): Integer;
begin
  Result := Call(Msg, NativeUInt(WParam), LParam, WarnStatus);
end;

function TScintEdit.Call(Msg: Cardinal; WParam: WPARAM; LParam: LPARAM;
  out WarnStatus: Integer): Integer;

  {$IFDEF DEBUG}
  function MsgReturnsPointer: Boolean;
  begin
    Result :=
      (Msg = SCI_GETDIRECTFUNCTION) or (Msg = SCI_GETDIRECTSTATUSFUNCTION) or (Msg = SCI_GETDIRECTPOINTER) or
      (Msg = SCI_GETCHARACTERPOINTER) or (Msg = SCI_GETRANGEPOINTER) or (Msg = SCI_GETDOCPOINTER) or
      (Msg = SCI_CREATEDOCUMENT) or (Msg = SCI_CREATELOADER) or (Msg = SCI_PRIVATELEXERCALL);
  end;
  {$ENDIF}

begin
  HandleNeeded;
  if FDirectPtr = nil then
    Error('Call: FDirectPtr is nil');
  if not Assigned(FDirectStatusFunction) then
    Error('Call: FDirectStatusFunction is nil');
  {$IFDEF DEBUG}
  if MsgReturnsPointer then
    Error('Call: Use SendMessage');
  {$ENDIF}
  var ErrorStatus: Integer;
  Result := Integer(FDirectStatusFunction(FDirectPtr, Msg, WParam, LParam, ErrorStatus));

  if ErrorStatus <> 0 then begin
    var Dummy: Integer;
    FDirectStatusFunction(FDirectPtr, SCI_SETSTATUS, 0, 0, Dummy);
    if ErrorStatus < SC_STATUS_WARN_START then
      ErrorFmt('Error status %d returned after Call(%u, %d, %d) = %d',
        [ErrorStatus, Msg, WParam, LParam, Result]);
  end;

  WarnStatus := ErrorStatus;
end;

function TScintEdit.Call(Msg: Cardinal; WParam: NativeInt;
  const LParamStr: TScintRawString): Integer;
begin
  var Dummy: Integer;
  Result := Call(Msg, NativeUInt(WParam), LParamStr, Dummy);
end;

function TScintEdit.Call(Msg: Cardinal; WParam: WPARAM;
  const LParamStr: TScintRawString): Integer;
begin
  var Dummy: Integer;
  Result := Call(Msg, WParam, LParamStr, Dummy);
end;

function TScintEdit.Call(Msg: Cardinal; WParam: NativeInt;
  const LParamStr: TScintRawString; out WarnStatus: Integer): Integer;
begin
  Result := Call(Msg, NativeUInt(WParam), LPARAM(PAnsiChar(LParamStr)), WarnStatus);
end;

function TScintEdit.Call(Msg: Cardinal; WParam: WPARAM;
  const LParamStr: TScintRawString; out WarnStatus: Integer): Integer;
begin
  Result := Call(Msg, WParam, LPARAM(PAnsiChar(LParamStr)), WarnStatus);
end;

procedure TScintEdit.CancelAutoComplete;
begin
  Call(SCI_AUTOCCANCEL, 0, 0);
end;

procedure TScintEdit.CancelAutoCompleteAndCallTip;
begin
  CancelAutoComplete;
  CancelCallTip;
end;

procedure TScintEdit.CancelCallTip;
begin
  Call(SCI_CALLTIPCANCEL, 0, 0);
end;

function TScintEdit.CanPaste: Boolean;
begin
  Result := Call(SCI_CANPASTE, 0, 0) <> 0;
end;

function TScintEdit.CanRedo: Boolean;
begin
  Result := Call(SCI_CANREDO, 0, 0) <> 0;
end;

function TScintEdit.CanUndo: Boolean;
begin
  Result := Call(SCI_CANUNDO, 0, 0) <> 0;
end;

procedure TScintEdit.Change(const AInserting: Boolean;
  const AStartPos, ALength, ALinesDelta: Integer);
var
  Info: TScintEditChangeInfo;
begin
  inherited Changed;
  if Assigned(FOnChange) then begin
    Info.Inserting := AInserting;
    Info.StartPos := AStartPos;
    Info.Length := ALength;
    Info.LinesDelta := ALinesDelta;
    FOnChange(Self, Info);
  end;
end;

procedure TScintEdit.CheckPosRange(const StartPos, EndPos: Integer);
begin
  if (StartPos < 0) or (StartPos > EndPos) or (EndPos > GetRawTextLength) then
    ErrorFmt('CheckPosRange: Invalid range (%d, %d)', [StartPos, EndPos]);
end;

procedure TScintEdit.ChooseCaretX;
begin
  Call(SCI_CHOOSECARETX, 0, 0);
end;

procedure TScintEdit.ClearAll;
begin
  Call(SCI_CLEARALL, 0, 0);
  ChooseCaretX;
end;

procedure TScintEdit.ClearCmdKey(const Key: AnsiChar; const Shift: TShiftState);
begin
  ClearCmdKey(KeyToKeyCode(Key), Shift);
end;

procedure TScintEdit.ClearCmdKey(const KeyCode: TScintKeyCode; const Shift: TShiftState);
begin
  Call(SCI_CLEARCMDKEY, KeyCodeAndShiftToKeyDefinition(KeyCode, Shift), 0);
end;

procedure TScintEdit.ClearIndicators(
  const IndicatorNumber: TScintIndicatorNumber);
begin
  Call(SCI_SETINDICATORCURRENT, IndicatorNumber, 0);
  Call(SCI_INDICATORCLEARRANGE, 0, RawTextLength);
end;

procedure TScintEdit.ClearSelection;
begin
  Call(SCI_CLEAR, 0, 0);
end;

procedure TScintEdit.ClearUndo(const ClearChangeHistory: Boolean);
begin
  { SCI_EMPTYUNDOBUFFER resets the save point but doesn't send a
    SCN_SAVEPOINTREACHED notification. Call SetSavePoint manually to get
    that. SetSavePoint additionally resets FForceModified. }
  SetSavePoint;
  Call(SCI_EMPTYUNDOBUFFER, 0, 0);

  { Clearing change history requires one to disable and re-enable it. But
    also, from Scintilla docs: "Change history depends on the undo history
    and can only be enabled when undo history is enabled and empty." This
    is why the following code is here. }
  if ClearChangeHistory and (FChangeHistory <> schDisabled) then begin
    Call(SCI_SETCHANGEHISTORY, SC_CHANGE_HISTORY_DISABLED, 0);
    var Flags := SC_CHANGE_HISTORY_ENABLED;
    if FChangeHistory = schMarkers then
      Flags := Flags or SC_CHANGE_HISTORY_MARKERS
    else
      Flags := Flags or SC_CHANGE_HISTORY_INDICATORS;
    Call(SCI_SETCHANGEHISTORY, Flags, 0);
  end;
end;

function TScintEdit.ConvertRawStringToString(const S: TScintRawString): String;
var
  SrcLen, DestLen: Integer;
  DestStr: UnicodeString;
begin
  SrcLen := Length(S);
  if SrcLen > 0 then begin
    DestLen := MultiByteToWideChar(FCodePage, 0, PAnsiChar(S), SrcLen, nil, 0);
    if DestLen <= 0 then
      Error('MultiByteToWideChar failed');
    SetString(DestStr, nil, DestLen);
    if MultiByteToWideChar(FCodePage, 0, PAnsiChar(S), SrcLen, @DestStr[1],
       Length(DestStr)) <> DestLen then
      Error('Unexpected result from MultiByteToWideChar');
  end;
  Result := DestStr;
end;

function TScintEdit.ConvertPCharToRawString(const Text: PChar;
  const TextLen: Integer): TScintRawString;
var
  DestLen: Integer;
  DestStr: TScintRawString;
begin
  if TextLen > 0 then begin
    DestLen := WideCharToMultiByte(FCodePage, 0, Text, TextLen, nil, 0, nil, nil);
    if DestLen <= 0 then
      Error('WideCharToMultiByte failed');
    InitRawString(DestStr, DestLen);
    if WideCharToMultiByte(FCodePage, 0, Text, TextLen, @DestStr[1], Length(DestStr),
       nil, nil) <> DestLen then
      Error('Unexpected result from WideCharToMultiByte');
  end;
  Result := DestStr;
end;

function TScintEdit.ConvertStringToRawString(const S: String): TScintRawString;
begin
  Result := ConvertPCharToRawString(PChar(S), Length(S));
end;

procedure TScintEdit.CopyToClipboard;
begin
  Call(SCI_COPY, 0, 0);
end;

procedure TScintEdit.CreateParams(var Params: TCreateParams);
begin
  inherited;
  CreateSubClass(Params, 'Scintilla');
  //Params.ExStyle := Params.ExStyle or WS_EX_CLIENTEDGE;
  Params.WindowClass.style := Params.WindowClass.style and
    not (CS_HREDRAW or CS_VREDRAW);
end;

procedure TScintEdit.CreateWnd;
begin
  if IsscintLibrary = 0 then
    Error('CreateWnd: IsscintLibrary is 0');
  inherited;
  FDirectPtr := Pointer(SendMessage(Handle, SCI_GETDIRECTPOINTER, 0, 0));
  if FDirectPtr = nil then
    Error('CreateWnd: FDirectPtr is nil');
  FDirectStatusFunction := SciFnDirectStatus(SendMessage(Handle, SCI_GETDIRECTSTATUSFUNCTION, 0, 0));
  if not Assigned(FDirectStatusFunction) then
    Error('CreateWnd: FDirectStatusFunction is nil');
  UpdateCodePage;
  Call(SCI_SETCOMMANDEVENTS, 0, 0);
  Call(SCI_SETMODEVENTMASK, SC_MOD_INSERTTEXT or SC_MOD_DELETETEXT, 0);
  Call(SCI_SETCARETPERIOD, GetCaretBlinkTime, 0);
  Call(SCI_SETSCROLLWIDTHTRACKING, 1, 0);
  { The default popup menu conflicts with the VCL's PopupMenu }
  Call(SCI_USEPOPUP, 0, 0);
  SetDefaultWordChars;
  ApplyOptions;
  UpdateStyleAttributes;
  if FAcceptDroppedFiles then
    DragAcceptFiles(Handle, True);
end;

procedure TScintEdit.CutToClipboard;
begin
  Call(SCI_CUT, 0, 0);
end;

procedure TScintEdit.DeleteAllMarkersOnLine(const Line: Integer);
begin
  FLines.CheckIndexRange(Line);
  Call(SCI_MARKERDELETE, Line, -1);
end;

procedure TScintEdit.DeleteMarker(const Line: Integer;
  const Marker: TScintMarkerNumber);
begin
  FLines.CheckIndexRange(Line);
  Call(SCI_MARKERDELETE, Line, Marker);
end;

procedure TScintEdit.EndUndoAction;
begin
  Call(SCI_ENDUNDOACTION, 0, 0);
end;

procedure TScintEdit.EnsureLineVisible(const Line: Integer);
begin
  FLines.CheckIndexRange(Line);
  Call(SCI_ENSUREVISIBLE, Line, 0);
end;

class function TScintEdit.GetErrorException(const S: String): EScintEditError;
 { Can be used when just calling Error would cause a compiler warning because it doesn't realize Error always raises }
begin
  Result := EScintEditError.Create('TScintEdit error: ' + S);
end;

class procedure TScintEdit.Error(const S: String);
begin
  raise GetErrorException(S);
end;

class procedure TScintEdit.ErrorFmt(const S: String; const Args: array of const);
begin
  Error(Format(S, Args));
end;

function TScintEdit.FindRawText(const StartPos, EndPos: Integer;
  const S: TScintRawString; const Options: TScintFindOptions;
  out MatchRange: TScintRange): Boolean;
begin
  SetTarget(StartPos, EndPos);
  Call(SCI_SETSEARCHFLAGS, GetSearchFlags(Options), 0);
  Result := Call(SCI_SEARCHINTARGET, Length(S), S) >= 0;
  if Result then
    MatchRange := GetTarget;
end;

function TScintEdit.FindText(const StartPos, EndPos: Integer; const S: String;
  const Options: TScintFindOptions; out MatchRange: TScintRange): Boolean;
begin
  Result := FindRawText(StartPos, EndPos, ConvertStringToRawString(S),
    Options, MatchRange);
end;

procedure TScintEdit.FoldLine(const Line: Integer; const Fold: Boolean);
begin
  FLines.CheckIndexRange(Line);
  { If the line is not part of a fold the following will return False }
  var Folded := Call(SCI_GETFOLDEXPANDED, Line, 0) = 0;
  if Fold <> Folded then begin
    { If the line is not part of a fold the following will do nothing
      and else if the line is not the header Scintilla will lookup the
      header for us }
    Call(SCI_TOGGLEFOLD, Line, 0);
  end;
end;

procedure TScintEdit.ForceModifiedState;
begin
  if not FForceModified then begin
    FForceModified := True;
    if Assigned(FOnModifiedChange) then
      FOnModifiedChange(Self);
  end;
end;

function TScintEdit.FormatRange(const Draw: Boolean;
  const RangeToFormat: PScintRangeToFormat): Integer;
begin
  Result := Call(SCI_FORMATRANGE, Ord(Draw), LPARAM(RangeToFormat));
end;

procedure TScintEdit.ForwardMessage(const Message: TMessage);
begin
  if HandleAllocated then
    CallWindowProc(DefWndProc, Handle, Message.Msg, Message.WParam, Message.LParam);
end;

function TScintEdit.GetAnchorPosition: Integer;
begin
  Result := Call(SCI_GETANCHOR, 0, 0);
end;

function TScintEdit.GetAutoCompleteActive: Boolean;
begin
  Result := Call(SCI_AUTOCACTIVE, 0, 0) <> 0;
end;

function TScintEdit.GetByteAtPosition(const Pos: Integer): AnsiChar;
begin
  Result := AnsiChar(Call(SCI_GETCHARAT, Pos, 0));
end;

function TScintEdit.GetCallTipActive: Boolean;
begin
  Result := Call(SCI_CALLTIPACTIVE, 0, 0) <> 0;
end;

function TScintEdit.GetCaretColumn: Integer;
begin
  Result := GetColumnFromPosition(GetCaretPosition);
end;

function TScintEdit.GetCaretColumnExpandedForTabs: Integer;
begin
  Result := Call(SCI_GETCOLUMN, GetCaretPosition, 0);
  Inc(Result, GetCaretVirtualSpace);
end;

function TScintEdit.GetCaretLine: Integer;
begin
  Result := GetLineFromPosition(GetCaretPosition);
end;

function TScintEdit.GetCaretLineText: String;
begin
  Result := ConvertRawStringToString(GetRawCaretLineText);
end;

function TScintEdit.GetCaretPosition: Integer;
begin
  Result := Call(SCI_GETCURRENTPOS, 0, 0);
end;

function TScintEdit.GetCaretPositionInLine: Integer;
begin
  var Caret := CaretPosition;
  var LineStart := GetPositionFromLine(GetLineFromPosition(Caret));
  Result := Caret - LineStart;
end;

function TScintEdit.GetCaretVirtualSpace: Integer;
begin
  Result := GetSelectionCaretVirtualSpace(GetMainSelection);
end;

function TScintEdit.GetCharacterCount(const StartPos, EndPos: Integer): Integer;
begin
  CheckPosRange(StartPos, EndPos);
  Result := Call(SCI_COUNTCHARACTERS, StartPos, EndPos);
end;

function TScintEdit.GetColumnFromPosition(const Pos: Integer): Integer;
var
  Line: Integer;
begin
  Line := GetLineFromPosition(Pos);
  Result := Pos - GetPositionFromLine(Line);
end;

function TScintEdit.GetDefaultWordChars: AnsiString;
begin
  Result := 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_';
end;

function TScintEdit.GetDocLineFromVisibleLine(const VisibleLine: Integer): Integer;
begin
  Result := Call(SCI_DOCLINEFROMVISIBLE, VisibleLine, 0);
end;

function TScintEdit.GetIndicatorAtPosition(
  const IndicatorNumber: TScintIndicatorNumber; const Pos: Integer): Boolean;
begin
  Result := Call(SCI_INDICATORVALUEAT, IndicatorNumber, Pos) <> 0;
end;

function TScintEdit.GetInsertMode: Boolean;
begin
  Result := Call(SCI_GETOVERTYPE, 0, 0) = 0;
end;

function TScintEdit.GetLineEndings: TScintLineEndings;
begin
  case Call(SCI_GETEOLMODE, 0, 0) of
    SC_EOL_CR: Result := sleCR;
    SC_EOL_LF: Result := sleLF;
    SC_EOL_CRLF: Result := sleCRLF;
  else
    raise GetErrorException('Unexpected SCI_GETEOLMODE result');
  end;
end;

function TScintEdit.GetLineEndingString: TScintRawString;
const
  EndingStrs: array[TScintLineEndings] of TScintRawString =
    (#13#10, #13, #10);
begin
  Result := EndingStrs[LineEndings];
end;

function TScintEdit.GetLineEndPosition(const Line: Integer): Integer;
{ Returns the position at the end of the line, before any line end characters. }
begin
  FLines.CheckIndexRange(Line);
  Result := Call(SCI_GETLINEENDPOSITION, Line, 0);
end;

function TScintEdit.GetLineFromPosition(const Pos: Integer): Integer;
begin
  Result := Call(SCI_LINEFROMPOSITION, Pos, 0);
end;

function TScintEdit.GetLineHeight: Integer;
begin
  Result := Call(SCI_TEXTHEIGHT, 0, 0);
end;

function TScintEdit.GetLineIndentation(const Line: Integer): Integer;
begin
  FLines.CheckIndexRange(Line);
  Result := Call(SCI_GETLINEINDENTATION, Line, 0);
end;

function TScintEdit.GetLineIndentPosition(const Line: Integer): Integer;
begin
  FLines.CheckIndexRange(Line);
  Result := Call(SCI_GETLINEINDENTPOSITION, Line, 0);
end;

function TScintEdit.GetLinesInWindow: Integer;
begin
  Result := Call(SCI_LINESONSCREEN, 0, 0);
end;

function TScintEdit.GetMainSelection: Integer;
begin
  Result := Call(SCI_GETMAINSELECTION, 0, 0);
end;

function TScintEdit.GetMainSelText: String;
begin
  Result := ConvertRawStringToString(GetRawMainSelText);
end;

function TScintEdit.GetMarkers(const Line: Integer): TScintMarkerNumbers;
begin
  FLines.CheckIndexRange(Line);
  Integer(Result) := Call(SCI_MARKERGET, Line, 0);
end;

function TScintEdit.GetModified: Boolean;
begin
  Result := FForceModified or (Call(SCI_GETMODIFY, 0, 0) <> 0);
end;

function TScintEdit.GetPointFromPosition(const Pos: Integer): TPoint;
begin
  Result.X := Call(SCI_POINTXFROMPOSITION, 0, Pos);
  Result.Y := Call(SCI_POINTYFROMPOSITION, 0, Pos);
end;

function TScintEdit.GetPositionAfter(const Pos: Integer): Integer;
begin
  Result := Call(SCI_POSITIONAFTER, Pos, 0);
end;

function TScintEdit.GetPositionBefore(const Pos: Integer): Integer;
begin
  Result := Call(SCI_POSITIONBEFORE, Pos, 0);
end;

function TScintEdit.GetPositionFromLine(const Line: Integer): Integer;
begin
  FLines.CheckIndexRangePlusOne(Line);
  Result := Call(SCI_POSITIONFROMLINE, Line, 0);
end;

function TScintEdit.GetPositionFromLineColumn(const Line, Column: Integer): Integer;
var
  Col, Len: Integer;
begin
  Col := Column;
  Result := GetPositionFromLine(Line);
  Len := GetLineEndPosition(Line) - Result;
  if Col > Len then
    Col := Len;
  if Col > 0 then
    Inc(Result, Col);
end;

function TScintEdit.GetPositionFromLineExpandedColumn(const Line,
  ExpandedColumn: Integer): Integer;
begin
  FLines.CheckIndexRange(Line);
  Result := Call(SCI_FINDCOLUMN, Line, ExpandedColumn);
end;

function TScintEdit.GetPositionFromPoint(const P: TPoint;
  const CharPosition, CloseOnly: Boolean): Integer;
begin
  if CharPosition then begin
    if CloseOnly then
      Result := Call(SCI_CHARPOSITIONFROMPOINTCLOSE, P.X, P.Y)
    else
      Result := Call(SCI_CHARPOSITIONFROMPOINT, P.X, P.Y);
  end
  else begin
    if CloseOnly then
      Result := Call(SCI_POSITIONFROMPOINTCLOSE, P.X, P.Y)
    else
      Result := Call(SCI_POSITIONFROMPOINT, P.X, P.Y);
  end;
end;

function TScintEdit.GetPositionOfMatchingBrace(const Pos: Integer): Integer;
begin
  Result := Call(SCI_BRACEMATCH, Pos, 0);
end;

function TScintEdit.GetPositionRelative(const Pos,
  CharacterCount: Integer): Integer;
begin
  Result := Call(SCI_POSITIONRELATIVE, Pos, CharacterCount);
end;

function TScintEdit.GetRawCaretLineText: TScintRawString;
begin
  var Line := CaretLine;
  Result := GetRawTextRange(GetPositionFromLine(Line), GetPositionFromLine(Line+1));
end;

function TScintEdit.GetRawMainSelText: TScintRawString;
begin
  var MainSel := MainSelection;
  var CaretPos := SelectionCaretPosition[MainSel];
  var AnchorPos := SelectionAnchorPosition[MainSel];
  if AnchorPos < CaretPos then
    Result := GetRawTextRange(AnchorPos, CaretPos)
  else
    Result := GetRawTextRange(CaretPos, AnchorPos);
end;

function TScintEdit.GetRawSelText: TScintRawString;
{ Gets the combined text of *all* selections }
var
  Len: Integer;
  S: TScintRawString;
begin
  Len := Call(SCI_GETSELTEXT, 0, 0);
  if Len > 0 then begin
    InitRawString(S, Len);
    Call(SCI_GETSELTEXT, 0, LPARAM(PAnsiChar(@S[1])));
  end;
  Result := S;
end;

function TScintEdit.GetRawText: TScintRawString;
begin
  Result := GetRawTextRange(0, GetRawTextLength);
end;

function TScintEdit.GetRawTextLength: Integer;
begin
  Result := Call(SCI_GETLENGTH, 0, 0);
end;

function TScintEdit.GetRawTextRange(const StartPos, EndPos: Integer): TScintRawString;
var
  S: TScintRawString;
  Range: TSci_TextRange;
begin
  CheckPosRange(StartPos, EndPos);
  if EndPos > StartPos then begin
    InitRawString(S, EndPos - StartPos);
    Range.chrg.cpMin := StartPos;
    Range.chrg.cpMax := EndPos;
    Range.lpstrText := @S[1];
    if Call(SCI_GETTEXTRANGE, 0, LPARAM(@Range)) <> EndPos - StartPos then
      Error('Unexpected result from SCI_GETTEXTRANGE');
  end;
  Result := S;
end;

function TScintEdit.GetReadOnly: Boolean;
begin
  Result := Call(SCI_GETREADONLY, 0, 0) <> 0;
end;

class function TScintEdit.GetReplaceTargetMessage(
  const ReplaceMode: TScintReplaceMode): Cardinal;
begin
  case ReplaceMode of
    srmNormal: Result := SCI_REPLACETARGET;
    srmMinimal: Result := SCI_REPLACETARGETMINIMAL;
    srmRegEx: Result := SCI_REPLACETARGETRE;
  else
    raise GetErrorException('Unknown ReplaceMode');
  end;
end;

class function TScintEdit.GetSearchFlags(const Options: TScintFindOptions): Integer;
begin
  { Note: Scintilla ignores SCFIND_WHOLEWORD when SCFIND_REGEXP is set }
  Result := 0;
  if sfoMatchCase in Options then
    Result := Result or SCFIND_MATCHCASE;
  if sfoWholeWord in Options then
    Result := Result or SCFIND_WHOLEWORD;
  if sfoRegEx in Options then
    Result := Result or (SCFIND_REGEXP or SCFIND_CXX11REGEX);
end;

function TScintEdit.GetSelection: TScintRange;
begin
  Result.StartPos := Call(SCI_GETSELECTIONSTART, 0, 0);
  Result.EndPos := Call(SCI_GETSELECTIONEND, 0, 0);
end;

procedure TScintEdit.GetSelections(const RangeList: TScintRangeList);
begin
  RangeList.Clear;
  for var I := 0 to SelectionCount-1 do begin
    var StartPos := GetSelectionStartPosition(I);
    var EndPos := GetSelectionEndPosition(I);
    RangeList.Add(TScintRange.Create(StartPos, EndPos));
  end;
end;

procedure TScintEdit.GetSelections(const CaretAndAnchorList: TScintCaretAndAnchorList);
begin
  CaretAndAnchorList.Clear;
  for var I := 0 to SelectionCount-1 do begin
    var CaretPos := GetSelectionCaretPosition(I);
    var AnchorPos := GetSelectionAnchorPosition(I);
    CaretAndAnchorList.Add(TScintCaretAndAnchor.Create(CaretPos, AnchorPos));
  end;
end;

procedure TScintEdit.GetSelections(const CaretAndAnchorList, VirtualSpacesList: TScintCaretAndAnchorList);
begin
  GetSelections(CaretAndAnchorList);
  VirtualSpacesList.Clear;
  for var I := 0 to SelectionCount-1 do begin
    var CaretPos := GetSelectionCaretVirtualSpace(I);
    var AnchorPos := GetSelectionAnchorVirtualSpace(I);
    VirtualSpacesList.Add(TScintCaretAndAnchor.Create(CaretPos, AnchorPos));
  end;
end;

function TScintEdit.GetSelectionAnchorPosition(Selection: Integer): Integer;
begin
  Result := Call(SCI_GETSELECTIONNANCHOR, Selection, 0);
end;

function TScintEdit.GetSelectionAnchorVirtualSpace(Selection: Integer): Integer;
begin
  Result := Call(SCI_GETSELECTIONNANCHORVIRTUALSPACE, Selection, 0);
end;

function TScintEdit.GetSelectionCaretPosition(Selection: Integer): Integer;
begin
  Result := Call(SCI_GETSELECTIONNCARET, Selection, 0);
end;

function TScintEdit.GetSelectionCaretVirtualSpace(Selection: Integer): Integer;
begin
  Result := Call(SCI_GETSELECTIONNCARETVIRTUALSPACE, Selection, 0);
end;

function TScintEdit.GetSelectionCount: Integer;
{ Returns the number of selections currently active. Rectangular selections are
  handled (and returned) as multiple selections, one for each line. }
begin
  Result := Call(SCI_GETSELECTIONS, 0, 0);
end;

function TScintEdit.GetSelectionEndPosition(Selection: Integer): Integer;
begin
  Result := Call(SCI_GETSELECTIONNEND, Selection, 0)
end;

function TScintEdit.GetSelectionMode: TScintSelectionMode;
begin
  case Call(SCI_GETSELECTIONMODE, 0, 0) of
    SC_SEL_STREAM: Result := ssmStream;
    SC_SEL_RECTANGLE: Result := ssmRectangular;
    SC_SEL_LINES: Result := ssmLines;
    SC_SEL_THIN: Result := ssmThinRectangular;
  else
    raise GetErrorException('Unexpected SCI_GETSELECTIONMODE result');
  end;
end;

function TScintEdit.GetSelectionStartPosition(Selection: Integer): Integer;
begin
  Result := Call(SCI_GETSELECTIONNSTART, Selection, 0);
end;

function TScintEdit.GetSelText: String;
begin
  Result := ConvertRawStringToString(GetRawSelText);
end;

function TScintEdit.GetStyleAtPosition(const Pos: Integer): TScintStyleNumber;
begin
  Result := TScintStyleNumber(Call(SCI_GETSTYLEAT, Pos, 0));
end;

function TScintEdit.GetTarget: TScintRange;
begin
  Result.StartPos := Call(SCI_GETTARGETSTART, 0, 0);
  Result.EndPos := Call(SCI_GETTARGETEND, 0, 0);
end;

function TScintEdit.GetTextRange(const StartPos, EndPos: Integer): String;
begin
  Result := ConvertRawStringToString(GetRawTextRange(StartPos, EndPos));
end;

function TScintEdit.GetTopLine: Integer;
begin
  Result := Call(SCI_GETFIRSTVISIBLELINE, 0, 0);
end;

function TScintEdit.GetVisibleLineFromDocLine(const DocLine: Integer): Integer;
begin
  FLines.CheckIndexRange(DocLine);
  Result := Call(SCI_VISIBLEFROMDOCLINE, DocLine, 0);
end;

function TScintEdit.GetWordEndPosition(const Pos: Integer;
  const OnlyWordChars: Boolean): Integer;
begin
  Result := Call(SCI_WORDENDPOSITION, Pos, Ord(OnlyWordChars));
end;

function TScintEdit.GetWordStartPosition(const Pos: Integer;
  const OnlyWordChars: Boolean): Integer;
begin
  Result := Call(SCI_WORDSTARTPOSITION, Pos, Ord(OnlyWordChars));
end;

function TScintEdit.GetZoom: Integer;
begin
  Result := Call(SCI_GETZOOM, 0, 0);
end;

procedure TScintEdit.InitRawString(var S: TScintRawString; const Len: Integer);
begin
  SetString(S, nil, Len);
  //experimental, dont need this ATM:
  if FCodePage <> 0 then
    System.SetCodePage(RawByteString(S), FCodePage, False);
end;

function TScintEdit.IsPositionInViewVertically(const Pos: Integer): Boolean;
var
  P: TPoint;
begin
  P := GetPointFromPosition(Pos);
  Result := (P.Y >= 0) and (P.Y + GetLineHeight <= ClientHeight);
end;

class function TScintEdit.KeyCodeAndShiftToKeyDefinition(
  const KeyCode: TScintKeyCode; Shift: TShiftState): TScintKeyDefinition;
begin
  Result := KeyCode;
  if ssShift in Shift then
    Result := Result or (SCMOD_SHIFT shl 16);
  if ssAlt in Shift then
    Result := Result or (SCMOD_ALT shl 16);
  if ssCtrl in Shift then
    Result := Result or (SCMOD_CTRL shl 16);
end;

class function TScintEdit.KeyToKeyCode(const Key: AnsiChar): TScintKeyCode;
begin
  Result := Ord(UpCase(Key));
end;

function TScintEdit.MainSelTextEquals(const S: String;
  const Options: TScintFindOptions): Boolean;
begin
  Result := RawMainSelTextEquals(ConvertStringToRawString(S), Options);
end;

procedure TScintEdit.Notification(AComponent: TComponent; Operation: TOperation);
begin
  inherited;
  if Operation = opRemove then
    if AComponent = FStyler then
      SetStyler(nil);
end;

procedure TScintEdit.Notify(const N: TSCNotification);
begin
  case N.nmhdr.code of
    SCN_AUTOCSELECTION:
      begin
        if Assigned(FOnAutoCompleteSelection) then
          FOnAutoCompleteSelection(Self);
      end;
    SCN_CALLTIPCLICK:
      begin
        if (N.position in [1, 2]) and Assigned(FOnCallTipArrowClick) then
          FOnCallTipArrowClick(Self, N.position = 1);
      end;
    SCN_CHARADDED:
      begin
        if Assigned(FOnCharAdded) then
          FOnCharAdded(Self, AnsiChar(N.ch));
      end;
    SCN_MARGINCLICK:
      begin
        if Assigned(FOnMarginClick) then
          FOnMarginClick(Self, N.margin, GetLineFromPosition(Integer(N.position)));
      end;
    SCN_MARGINRIGHTCLICK:
      begin
        if Assigned(FOnMarginRightClick) then
          FOnMarginRightClick(Self, N.margin, GetLineFromPosition(Integer(N.position)));
      end;
    SCN_MODIFIED:
      begin
        { CreateWnd limits SCN_MODIFIED to INSERTTEXT and DELETETEXT }
        if N.modificationType and SC_MOD_INSERTTEXT <> 0 then
          Change(True, Integer(N.position), Integer(N.length), Integer(N.linesAdded))
        else if N.modificationType and SC_MOD_DELETETEXT <> 0 then
          Change(False, Integer(N.position), Integer(N.length), Integer(N.linesAdded));

        if (N.linesAdded > 0) and FLineNumbers then
          UpdateLineNumbersWidth;
      end;
    SCN_SAVEPOINTLEFT,
    SCN_SAVEPOINTREACHED:
      begin
        if Assigned(FOnModifiedChange) then
          FOnModifiedChange(Self);
      end;
    SCN_STYLENEEDED: StyleNeeded(Integer(N.position));
    SCN_UPDATEUI:
      begin
        if Assigned(FOnUpdateUI) then
          FOnUpdateUI(Self, TScintEditUpdates(Byte(N.updated)));
      end;
    SCN_ZOOM:
      begin
        if Assigned(FOnZoom) then
          FOnZoom(Self);
        if FLineNumbers then
          UpdateLineNumbersWidth;
      end;
  end;
end;

procedure TScintEdit.PasteFromClipboard;
begin
  Call(SCI_PASTE, 0, 0);
end;

function TScintEdit.RawMainSelTextEquals(const S: TScintRawString;
  const Options: TScintFindOptions): Boolean;
begin
  Call(SCI_TARGETFROMSELECTION, 0, 0);
  Call(SCI_SETSEARCHFLAGS, GetSearchFlags(Options), 0);
  Result := False;
  if Call(SCI_SEARCHINTARGET, Length(S), S) >= 0 then begin
    var Target := GetTarget;
    var Sel := GetSelection;
    if (Target.StartPos = Sel.StartPos) and (Target.EndPos = Sel.EndPos) then
      Result := True;
  end;
end;

class function TScintEdit.RawStringIsBlank(const S: TScintRawString): Boolean;
begin
  for var I := 1 to Length(S) do
    if not(S[I] in [#9, ' ']) then
      Exit(False);
  Result := True;
end;

procedure TScintEdit.Redo;
begin
  Call(SCI_REDO, 0, 0);
end;

procedure TScintEdit.RemoveAdditionalSelections;
{ Removes additional selections without scrolling the caret into view }
begin
  var MainSel := MainSelection;
  var CaretPos := SelectionCaretPosition[MainSel];
  var AnchorPos := SelectionAnchorPosition[MainSel];
  SetSingleSelection(CaretPos, AnchorPos);
end;

function TScintEdit.ReplaceMainSelText(const S: String;
  const ReplaceMode: TScintReplaceMode): TScintRange;
begin
  ReplaceRawMainSelText(ConvertStringToRawString(S), ReplaceMode);
end;

function TScintEdit.ReplaceRawMainSelText(const S: TScintRawString;
  const ReplaceMode: TScintReplaceMode): TScintRange;
{ Replaces the main selection just like SetRawSelText/SCI_REPLACESEL but
  without removing additional selections }
begin
  { First replace the selection }
  Call(SCI_TARGETFROMSELECTION, 0, 0);
  Call(GetReplaceTargetMessage(ReplaceMode), Length(S), S);
  { Then make the main selection an empty selection at the end of the inserted
    text, just like SCI_REPLACESEL }
  var Pos := GetTarget.EndPos; { SCI_REPLACETARGET* updates the target }
  var MainSel := MainSelection;
  SetSelectionCaretPosition(MainSel, Pos);
  SetSelectionAnchorPosition(MainSel, Pos);
  { Finally call Editor::SetLastXChosen and scroll caret into view, also just
    like SCI_REPLACESEL }
  ChooseCaretX;
  ScrollCaretIntoView;
end;

function TScintEdit.ReplaceRawTextRange(const StartPos, EndPos: Integer;
  const S: TScintRawString; const ReplaceMode: TScintReplaceMode): TScintRange;
begin
  CheckPosRange(StartPos, EndPos);
  SetTarget(StartPos, EndPos);
  Call(GetReplaceTargetMessage(ReplaceMode), Length(S), S);
  Result := GetTarget;
end;

function TScintEdit.ReplaceTextRange(const StartPos, EndPos: Integer;
  const S: String; const ReplaceMode: TScintReplaceMode): TScintRange;
begin
  Result := ReplaceRawTextRange(StartPos, EndPos, ConvertStringToRawString(S), ReplaceMode);
end;

procedure TScintEdit.RestyleLine(const Line: Integer);
begin
  var StartPos := GetPositionFromLine(Line);
  var EndPos := GetPositionFromLine(Line + 1);
  { Back up the 'last styled position' if necessary using SCI_STARTSTYLINE
    (SCI_SETENDSTYLED would have been a clearer name because setting the
    'last styled position' is all it does) }
  if StartPos < Call(SCI_GETENDSTYLED, 0, 0) then
    Call(SCI_STARTSTYLING, StartPos, 0);
  StyleNeeded(EndPos);
end;

procedure TScintEdit.ScrollCaretIntoView;
begin
  Call(SCI_SCROLLCARET, 0, 0);
end;

procedure TScintEdit.SelectAllOccurrences(const Options: TScintFindOptions);
{ At the moment this does not automatically expand folds, unlike VSCode. Also
  see SelectNextOccurrence. }
begin
  Call(SCI_TARGETWHOLEDOCUMENT, 0, 0);
  Call(SCI_SETSEARCHFLAGS, GetSearchFlags(Options), 0);
  Call(SCI_MULTIPLESELECTADDEACH, 0, 0);
end;

procedure TScintEdit.SelectAndEnsureVisible(const Range: TScintRange);
begin
  CheckPosRange(Range.StartPos, Range.EndPos);

  { If the range is in a contracted section, expand it }
  var StartLine := GetLineFromPosition(Range.StartPos);
  var EndLine := GetLineFromPosition(Range.EndPos);
  for var Line := StartLine to EndLine do
    EnsureLineVisible(Line);

  { Select }
  Selection := Range;
end;

procedure TScintEdit.SelectNextOccurrence(const Options: TScintFindOptions);
{ At the moment this does not automatically expand folds, unlike VSCode. Also
  see SelectAllOccurrences. }
begin
  Call(SCI_TARGETWHOLEDOCUMENT, 0, 0);
  Call(SCI_SETSEARCHFLAGS, GetSearchFlags(Options), 0);
  Call(SCI_MULTIPLESELECTADDNEXT, 0, 0);
end;

function TScintEdit.SelEmpty: Boolean;
{ Returns True if the main selection is empty even if there are additional
  selections. }
begin
  var Sel: TScintRange;
  Result := not SelNotEmpty(Sel);
end;

function TScintEdit.SelNotEmpty(out Sel: TScintRange): Boolean;
begin
  Sel := GetSelection;
  Result := Sel.EndPos > Sel.StartPos;
end;

procedure TScintEdit.SelectAll;
begin
  Call(SCI_SELECTALL, 0, 0);
end;

procedure TScintEdit.SetAcceptDroppedFiles(const Value: Boolean);
begin
  if FAcceptDroppedFiles <> Value then begin
    FAcceptDroppedFiles := Value;
    if HandleAllocated then
      DragAcceptFiles(Handle, Value);
  end;
end;

procedure TScintEdit.SetAutoCompleteFillupChars(const FillupChars: AnsiString);
begin
  Call(SCI_AUTOCSETFILLUPS, 0, FillupChars);
end;

procedure TScintEdit.SetAutoCompleteFontName(const Value: String);
begin
  if FAutoCompleteFontName <> Value then begin
    FAutoCompleteFontName := Value;
    UpdateStyleAttributes;
  end;
end;

procedure TScintEdit.SetAutoCompleteFontSize(const Value: Integer);
begin
  if FAutoCompleteFontSize <> Value then begin
    FAutoCompleteFontSize := Value;
    UpdateStyleAttributes;
  end;
end;

procedure TScintEdit.SetAutoCompleteSelectedItem(const S: TScintRawString);
begin
  Call(SCI_AUTOCSELECT, 0, S);
end;

procedure TScintEdit.SetAutoCompleteSeparators(const Separator, TypeSeparator: AnsiChar);
begin
  Call(SCI_AUTOCSETSEPARATOR, WParam(Separator), 0);
  Call(SCI_AUTOCSETTYPESEPARATOR, WParam(TypeSeparator), 0);
end;

procedure TScintEdit.SetAutoCompleteStopChars(const StopChars: AnsiString);
begin
  Call(SCI_AUTOCSTOPS, 0, StopChars);
end;

procedure TScintEdit.SetBraceBadHighlighting(const Pos: Integer);
begin
  Call(SCI_BRACEBADLIGHT, Pos, 0);
end;

procedure TScintEdit.SetBraceHighlighting(const Pos1, Pos2: Integer);
begin
  Call(SCI_BRACEHIGHLIGHT, Pos1, Pos2);
end;

procedure TScintEdit.SetCallTipHighlight(HighlightStart, HighlightEnd: Integer);
begin
  Call(SCI_CALLTIPSETHLT, HighlightStart, HighlightEnd);
end;

procedure TScintEdit.SetCaretColumn(const Value: Integer);
begin
  SetCaretPosition(GetPositionFromLineColumn(GetCaretLine, Value));
end;

procedure TScintEdit.SetCaretLine(const Value: Integer);
begin
  Call(SCI_GOTOLINE, Value, 0);
  ChooseCaretX;
end;

procedure TScintEdit.SetCaretPosition(const Value: Integer);
begin
  Call(SCI_GOTOPOS, Value, 0);
  ChooseCaretX;
end;

procedure TScintEdit.SetCaretPositionWithSelectFromAnchor(const Value: Integer);
{ Sets the caret position and creates a selection between the anchor and the
  caret position without scrolling the caret into view. }
begin
  Call(SCI_SETCURRENTPOS, Value, 0);
end;

procedure TScintEdit.SetCaretVirtualSpace(const Value: Integer);
{ Also sets the anchor's virtual space! }
var
  Pos, LineEndPos, MainSel: Integer;
begin
  { Weird things happen if a non-zero virtual space is set when the caret
    isn't at the end of a line, so don't allow it }
  Pos := GetCaretPosition;
  LineEndPos := GetLineEndPosition(GetLineFromPosition(Pos));
  if (Pos = LineEndPos) or (Value = 0) then begin
    MainSel := GetMainSelection;
    SetSelectionAnchorVirtualSpace(MainSel, Value);
    SetSelectionCaretVirtualSpace(MainSel, Value);
    ChooseCaretX;
  end;
end;

procedure TScintEdit.SetChangeHistory(const Value: TScintChangeHistory);
begin
  if FChangeHistory <> Value then begin
    FChangeHistory := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetCodePage(const Value: Word);
begin
  if FCodePage <> Value then begin
    FCodePage := Value;
    UpdateCodePage;
  end;
end;

procedure TScintEdit.SetCursorID(const CursorID: Integer);
begin
  Call(SCI_SETCURSOR, CursorID, 0);
end;

procedure TScintEdit.SetDefaultWordChars;
begin
  SetWordChars(GetDefaultWordChars);
end;

procedure TScintEdit.SetEmptySelection;
{ Make the main selection empty and removes additional selections without
  scrolling the caret into view }
begin
  Call(SCI_SETEMPTYSELECTION, GetCaretPosition, 0);
end;

procedure TScintEdit.SetEmptySelections;
{ Makes all selections empty without scrolling the caret into view }
begin
  for var Selection := 0 to SelectionCount-1 do begin
    var Pos := SelectionCaretPosition[Selection];
    SelectionAnchorPosition[Selection] := Pos;
  end;
end;

procedure TScintEdit.SetFillSelectionToEdge(const Value: Boolean);
begin
  if FFillSelectionToEdge <> Value then begin
    FFillSelectionToEdge := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetFoldFlags(const Value: TScintFoldFlags);
begin
  var Flags := 0;
  if sffLineBeforeExpanded in Value then
    Flags := Flags or SC_FOLDFLAG_LINEBEFORE_EXPANDED;
  if sffLineBeforeContracted in Value then
    Flags := Flags or SC_FOLDFLAG_LINEBEFORE_CONTRACTED;
  if sffLineAfterExpanded in Value then
    Flags := Flags or SC_FOLDFLAG_LINEAFTER_EXPANDED;
  if sffLineAfterContracted in Value then
    Flags := Flags or SC_FOLDFLAG_LINEAFTER_CONTRACTED;

  if sffLevelNumbers in Value then
    Flags := Flags or SC_FOLDFLAG_LEVELNUMBERS
  else if sffLineState in Value then
    Flags := Flags or SC_FOLDFLAG_LINESTATE;

  Call(SCI_SETFOLDFLAGS, Flags, 0);

  var FoldLevelNumbersOrLineState := Value * [sffLevelNumbers, sffLineState] <> [];
  if FoldLevelNumbersOrLineState <> FFoldLevelNumbersOrLineState then begin
    FFoldLevelNumbersOrLineState := FoldLevelNumbersOrLineState;
    UpdateLineNumbersWidth;
  end;
end;

procedure TScintEdit.SetIndicators(const StartPos, EndPos: Integer;
  const IndicatorNumber: TScintIndicatorNumber; const Value: Boolean);
begin
  CheckPosRange(StartPos, EndPos);
  Call(SCI_SETINDICATORCURRENT, IndicatorNumber, 0);
  if Value then begin
    Call(SCI_SETINDICATORVALUE, IndicatorNumber, 1);
    Call(SCI_INDICATORFILLRANGE, StartPos, EndPos - StartPos);
  end else
    Call(SCI_INDICATORCLEARRANGE, StartPos, EndPos - StartPos);
end;

procedure TScintEdit.SetLineIndentation(const Line, Indentation: Integer);
begin
  FLines.CheckIndexRange(Line);
  Call(SCI_SETLINEINDENTATION, Line, Indentation);
end;

procedure TScintEdit.SetIndentationGuides(const Value: TScintIndentationGuides);
begin
  if FIndentationGuides <> Value then begin
    FIndentationGuides := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetLineNumbers(const Value: Boolean);
begin
  if FLineNumbers <> Value then begin
    FLineNumbers := Value;
    UpdateLineNumbersWidth;
  end;
end;

procedure TScintEdit.SetMainSelection(const Value: Integer);
begin
  Call(SCI_SETMAINSELECTION, Value, 0);
end;

procedure TScintEdit.SetMainSelText(const Value: String);
begin
  SetRawMainSelText(ConvertStringToRawString(Value));
end;

procedure TScintEdit.SetRawMainSelText(const Value: TScintRawString);
begin
  ReplaceRawMainSelText(Value, srmMinimal);
end;

procedure TScintEdit.SetRawSelText(const Value: TScintRawString);
{ Replaces the main selection's text and *clears* additional selections }
begin
  Call(SCI_REPLACESEL, 0, Value);
end;

procedure TScintEdit.SetRawText(const Value: TScintRawString);
begin
  { Workaround: Without this call, if the caret is on line 0 and out in
    virtual space, it'll remain in virtual space after the replacement }
  Call(SCI_CLEARSELECTIONS, 0, 0);
  { Using ReplaceRawTextRange instead of SCI_SETTEXT for embedded null support }
  ReplaceRawTextRange(0, GetRawTextLength, Value);
  ChooseCaretX;
end;

procedure TScintEdit.SetReadOnly(const Value: Boolean);
begin
  Call(SCI_SETREADONLY, Ord(Value), 0);
end;

procedure TScintEdit.SetSavePoint;
begin
  if FForceModified then begin
    FForceModified := False;
    if Assigned(FOnModifiedChange) then
      FOnModifiedChange(Self);
  end;
  Call(SCI_SETSAVEPOINT, 0, 0);
end;

procedure TScintEdit.SetSelection(const Value: TScintRange);
{ Sets the main selection and removes additional selections. Very similar
  to SetSingleSelection, not sure why both messages exist and are slightly
  different }
begin
  Call(SCI_SETSEL, Value.StartPos, Value.EndPos);
end;

procedure TScintEdit.SetSelectionAnchorPosition(Selection: Integer;
  const Value: Integer);
{ Also sets anchors's virtual space to 0 }
begin
  Call(SCI_SETSELECTIONNANCHOR, Selection, Value);
end;

procedure TScintEdit.SetSelectionAnchorVirtualSpace(Selection: Integer;
  const Value: Integer);
begin
  Call(SCI_SETSELECTIONNANCHORVIRTUALSPACE, Selection, Value);
end;

procedure TScintEdit.SetSelectionCaretPosition(Selection: Integer;
  const Value: Integer);
{ Also sets caret's virtual space to 0 }
begin
  Call(SCI_SETSELECTIONNCARET, Selection, Value);
end;

procedure TScintEdit.SetSelectionCaretVirtualSpace(Selection: Integer;
  const Value: Integer);
begin
  Call(SCI_SETSELECTIONNCARETVIRTUALSPACE, Selection, Value);
end;

procedure TScintEdit.SetSelectionMode(const Value: TScintSelectionMode);
begin
  var Mode: Integer;
  if Value = ssmStream then
    Mode := SC_SEL_STREAM
  else if Value = ssmRectangular then
    Mode := SC_SEL_RECTANGLE
  else if Value = ssmLines then
    Mode := SC_SEL_LINES
  else
    Mode := SC_SEL_THIN;
  { Note this uses *CHANGE* and not *SET* }
  Call(SCI_CHANGESELECTIONMODE, Mode, 0);
end;

procedure TScintEdit.SetSelText(const Value: String);
begin
  SetRawSelText(ConvertStringToRawString(Value));
end;

procedure TScintEdit.SetSingleSelection(const CaretPos, AnchorPos: Integer);
{ Sets the main selection and removes additional selections without scrolling
  the caret into view }
begin
  Call(SCI_SETSELECTION, CaretPos, AnchorPos);
end;

procedure TScintEdit.SetStyler(const Value: TScintCustomStyler);
begin
  if FStyler <> Value then begin
    if Assigned(Value) then
      Value.FreeNotification(Self);
    FStyler := Value;
    if HandleAllocated then begin
      Call(SCI_CLEARDOCUMENTSTYLE, 0, 0);
      Call(SCI_STARTSTYLING, 0, 0);
      UpdateStyleAttributes;
    end;
  end;
end;

procedure TScintEdit.SetTabWidth(const Value: Integer);
begin
  if (FTabWidth <> Value) and (Value > 0) and (Value < 100) then begin
    FTabWidth := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetTarget(const StartPos, EndPos: Integer);
begin
  Call(SCI_SETTARGETSTART, StartPos, 0);
  Call(SCI_SETTARGETEND, EndPos, 0);
end;

procedure TScintEdit.SetTopLine(const Value: Integer);
begin
  Call(SCI_SETFIRSTVISIBLELINE, Value, 0);
end;

procedure TScintEdit.SetUseStyleAttributes(const Value: Boolean);
begin
  if FUseStyleAttributes <> Value then begin
    FUseStyleAttributes := Value;
    UpdateStyleAttributes;
  end;
end;

procedure TScintEdit.SetUseTabCharacter(const Value: Boolean);
begin
  if FUseTabCharacter <> Value then begin
    FUseTabCharacter := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetVirtualSpaceOptions(const Value: TScintVirtualSpaceOptions);
begin
  if FVirtualSpaceOptions <> Value then begin
    FVirtualSpaceOptions := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetWordChars(const S: AnsiString);
begin
  FWordChars := S;
  FWordCharsAsSet := [];
  for var C in S do
    Include(FWordCharsAsSet, C);
  Call(SCI_SETWORDCHARS, 0, S);
end;

procedure TScintEdit.SetWordWrap(const Value: Boolean);
begin
  if FWordWrap <> Value then begin
    FWordWrap := Value;
    ApplyOptions;
  end;
end;

procedure TScintEdit.SetZoom(const Value: Integer);
begin
  Call(SCI_SETZOOM, Value, 0);
end;

procedure TScintEdit.ShowAutoComplete(const CharsEntered: Integer;
  const WordList: AnsiString);
begin
  Call(SCI_AUTOCSHOW, CharsEntered, WordList);
end;

procedure TScintEdit.ShowCallTip(const Pos: Integer;
  const Definition: AnsiString);
begin
  Call(SCI_CALLTIPSHOW, Pos, Definition);
end;

procedure TScintEdit.StyleNeeded(const EndPos: Integer);

  function CalcCaretIndex(const FirstLine, LastLine: Integer): Integer;
  var
    CaretPos, StartPos, EndPos: Integer;
  begin
    Result := 0;
    if FReportCaretPositionToStyler then begin
      CaretPos := GetCaretPosition;
      StartPos := GetPositionFromLine(FirstLine);
      EndPos := GetLineEndPosition(LastLine);
      if (CaretPos >= StartPos) and (CaretPos <= EndPos) then
        Result := CaretPos - StartPos + 1;
    end;
  end;

  procedure MaskDoubleByteCharacters(var S: TScintRawString);
  var
    Len, I: Integer;
  begin
    { This replaces all lead and trail bytes in S with #$80 and #$81 to
      ensure that stylers do not mistake trail bytes for single-byte ASCII
      characters (e.g. #131'A' is a valid combination on CP 932). }
    if not FEffectiveCodePageDBCS then
      Exit;
    Len := Length(S);
    I := 1;
    while I <= Len do begin
      if S[I] in FLeadBytes then begin
        S[I] := #$80;
        if I < Len then begin
          Inc(I);
          S[I] := #$81;
        end;
      end;
      Inc(I);
    end;
  end;

  function LineSpans(const Line: Integer): Boolean;
  var
    S: TScintRawString;
  begin
    S := FLines.RawLines[Line];
    MaskDoubleByteCharacters(S);
    Result := FStyler.LineTextSpans(S);
  end;

  function StyleLine(const FirstLine: Integer; const StartStylingPos: Integer): Integer;
  begin
    { Find final line in series of spanned lines }
    var LastLine := FirstLine;
    while (LastLine < Lines.Count - 1) and LineSpans(LastLine) do
      Inc(LastLine);

    { We don't pass line endings to the styler, because when the style of a
      line ending changes, Scintilla assumes it must be a 'hanging' style and
      immediately repaints all subsequent lines. (To see this in the IS IDE,
      insert and remove a ';' character before a [Setup] directive, i.e.
      toggle comment styling.) }

    FStyler.FCaretIndex := CalcCaretIndex(FirstLine, LastLine);
    FStyler.FCurIndex := 1;
    FStyler.FStyleStartIndex := 1;
    FStyler.FLineState := 0;
    if FirstLine > 0 then
      FStyler.FLineState := FLines.GetState(FirstLine-1);
    FStyler.FText := GetRawTextRange(GetPositionFromLine(FirstLine),
      GetLineEndPosition(LastLine));
    MaskDoubleByteCharacters(FStyler.FText);
    FStyler.FTextLen := Length(FStyler.FText);
    FStyler.FStyleStr := StringOfChar(AnsiChar(0), FStyler.FTextLen +
      FLines.GetLineEndingLength(LastLine));

    var PreviousLineState := FStyler.LineState;

    FStyler.StyleNeeded;

    var N := Length(FStyler.FStyleStr);
    if N > 0 then begin
      var HadStyleByteIndicators := False;

      { Apply style byte indicators. Add first as INDICATOR_CONTAINER and so on. }
      for var Indicator := 0 to High(TScintStyleByteIndicatorNumber) do begin
        var PrevI := 1;
        var PrevValue := Indicator in TScintStyleByteIndicatorNumbers(Byte(Ord(FStyler.FStyleStr[1]) shr StyleNumberBits));
        for var CurI := 2 to N do begin
          var CurValue := Indicator in TScintStyleByteIndicatorNumbers(Byte(Ord(FStyler.FStyleStr[CurI]) shr StyleNumberBits));
          if CurValue <> PrevValue then begin
            SetIndicators(StartStylingPos+PrevI-1, StartStylingPos+CurI-1, TScintIndicatorNumber(Ord(Indicator)+INDICATOR_CONTAINER), PrevValue);
            HadStyleByteIndicators := HadStyleByteIndicators or PrevValue;
            PrevI := CurI;
            PrevValue := CurValue;
          end;
        end;
        SetIndicators(StartStylingPos+PrevI-1, StartStylingPos+N, TScintIndicatorNumber(Ord(Indicator)+INDICATOR_CONTAINER), PrevValue);
        HadStyleByteIndicators := HadStyleByteIndicators or PrevValue;
      end;

      { Apply styles after removing any style byte indicators }
      if HadStyleByteIndicators then
        for var I := 1 to N do
          FStyler.FStyleStr[I] := AnsiChar(Ord(FStyler.FStyleStr[I]) and StyleNumberMask);
      Call(SCI_SETSTYLINGEX, Length(FStyler.FStyleStr), FStyler.FStyleStr);

      FStyler.FStyleStr := '';
      FStyler.FText := '';
    end;

    { Get fold level }

    var LineState := FStyler.LineState;
    var FoldLevel: Integer;
    var FoldHeader, EnableFoldHeaderOnPrevious: Boolean;

    FStyler.GetFoldLevel(LineState, PreviousLineState, FoldLevel, FoldHeader, EnableFoldHeaderOnPrevious);

    Inc(FoldLevel, SC_FOLDLEVELBASE);
    if FoldHeader then
      FoldLevel := FoldLevel or SC_FOLDLEVELHEADERFLAG;

    { Apply line state and fold level }

    for var I := FirstLine to LastLine do begin
      var OldState := FLines.GetState(I);
      if FStyler.FLineState <> OldState then
        Call(SCI_SETLINESTATE, I, FStyler.FLineState);
      var OldLevel := Call(SCI_GETFOLDLEVEL, I, 0);
      var NewLevel := FoldLevel;
      { Setting SC_FOLDLEVELWHITEFLAG on empty lines causes a problem: when
        Scintilla auto expands a contracted section (for example after removing ']'
        from a section header) all the empty lines stay invisible, even any which
        are in the middle of the section. See https://sourceforge.net/p/scintilla/bugs/2442/ }
      //if FLines.GetRawLineLength(I) = 0 then
      //  NewLevel := NewLevel or SC_FOLDLEVELWHITEFLAG;
      if NewLevel <> OldLevel then
        Call(SCI_SETFOLDLEVEL, I, NewLevel);
    end;

    { Retroactively set header on previous line if requested to do so. Must be
      *after* the loop above. Not sure why. Problem reproduction: move code above
      the loop, run it, open Debug.iss, change [Setup] to [Set up] and notice
      styling of the [Languages] section below it is now broken. If you turn on
      sffLevelNumbers you will also see that the first entry in that section got
      a header flag. }

    if (FirstLine > 0) and EnableFoldHeaderOnPrevious then begin
      var PreviousLine := FirstLine-1;
      var OldLevel := Call(SCI_GETFOLDLEVEL, PreviousLine, 0);
      var NewLevel := OldLevel or SC_FOLDLEVELHEADERFLAG;
      if NewLevel <> OldLevel then
        Call(SCI_SETFOLDLEVEL, PreviousLine, NewLevel);
    end;

    Result := LastLine;
  end;

  procedure DefaultStyleLine(const Line: Integer);
  var
    StyleStr: AnsiString;
  begin
    { Note: Using SCI_SETSTYLINGEX because it only redraws the part of the
      range that changed, whereas SCI_SETSTYLING redraws the entire range. }
    StyleStr := StringOfChar(AnsiChar(0), FLines.GetRawLineLengthWithEnding(Line));
    Call(SCI_SETSTYLINGEX, Length(StyleStr), StyleStr);
  end;

var
  StartPos, StartLine, EndLine, Line: Integer;
begin
  StartPos := Call(SCI_GETENDSTYLED, 0, 0);
  StartLine := GetLineFromPosition(StartPos);
  { EndPos (always?) points to the position *after* the last character of the
    last line needing styling (usually an LF), so subtract 1 to avoid
    restyling one extra line unnecessarily.
    But don't do this if we're being asked to style all the way to the end.
    When the document's last line is empty, 'EndPos - 1' will point to the
    line preceding the last line, so StyleLine() will never be called on the
    last line, and it will never be assigned a LINESTATE. This causes IS's
    autocompletion to think the last line's section is scNone. }
  if EndPos < GetRawTextLength then
    EndLine := GetLineFromPosition(EndPos - 1)
  else
    EndLine := GetLineFromPosition(EndPos);

  //outputdebugstring('-----');
  //outputdebugstring(pchar(format('StyleNeeded poses: %d, %d', [StartPos, EndPos])));
  //outputdebugstring(pchar(format('StyleNeeded lines: %d, %d', [StartLine, EndLine])));

  { If StartLine is within a series of spanned lines, back up }
  if Assigned(FStyler) then
    while (StartLine > 0) and (LineSpans(StartLine - 1)) do
      Dec(StartLine);

  Line := StartLine;
  while Line <= EndLine do begin
    var StartStylingPos := GetPositionFromLine(Line);
    Call(SCI_STARTSTYLING, StartStylingPos, 0);
    if Assigned(FStyler) then
      Line := StyleLine(Line, StartStylingPos)
    else
      DefaultStyleLine(Line);
    Inc(Line);
  end;
end;

procedure TScintEdit.SysColorChange(const Message: TMessage);
begin
  ForwardMessage(Message);
end;

function TScintEdit.TestRawRegularExpression(const S: TScintRawString): Boolean;
{ Example invalid regular expression: ( }
begin
  Call(SCI_SETTARGETRANGE, 0, 0);
  Call(SCI_SETSEARCHFLAGS, GetSearchFlags([sfoRegEx]), 0);
  var WarnStatus: Integer;
  var Res := Call(SCI_SEARCHINTARGET, Length(S), S, WarnStatus);
  Result := not ((Res = -1) and (WarnStatus = SC_STATUS_WARN_REGEX));
end;

function TScintEdit.TestRegularExpression(const S: String): Boolean;
begin
  Result := TestRawRegularExpression(ConvertStringToRawString(S));
end;

procedure TScintEdit.Undo;
begin
  Call(SCI_UNDO, 0, 0);
end;

procedure TScintEdit.UpdateCodePage;

  procedure InitLeadBytes;
  var
    Info: TCPInfo;
    I: Integer;
    J: Byte;
  begin
    FLeadBytes := [];
    if FEffectiveCodePageDBCS and GetCPInfo(FEffectiveCodePage, Info) then begin
      I := 0;
      while (I < MAX_LEADBYTES) and ((Info.LeadByte[I] or Info.LeadByte[I+1]) <> 0) do begin
        for J := Info.LeadByte[I] to Info.LeadByte[I+1] do
          Include(FLeadBytes, AnsiChar(J));
        Inc(I, 2);
      end;
    end;
  end;

begin
  if HandleAllocated then begin
    { To Scintilla, code page 0 does not mean the current ANSI code page, but
      an unspecified single byte code page. So that DBCS support is properly
      enabled when running on a DBCS ANSI code page, replace 0 with GetACP. }
    var CP := FCodePage;
    if CP = 0 then
      CP := Word(GetACP);
    Call(SCI_SETCODEPAGE, CP, 0);

    { Scintilla ignores attempts to set a code page it has no special support
      for. But the editor could currently be set for UTF-8 or DBCS, so get it
      out of that mode by setting the code page to 0 (a value it does
      recognize). }
    if Call(SCI_GETCODEPAGE, 0, 0) <> CP then
      Call(SCI_SETCODEPAGE, 0, 0);

    FEffectiveCodePage := Word(Call(SCI_GETCODEPAGE, 0, 0));
    FEffectiveCodePageDBCS := (FEffectiveCodePage <> 0) and
      (FEffectiveCodePage <> SC_CP_UTF8);
    InitLeadBytes;
  end;
end;

procedure TScintEdit.UpdateLineNumbersWidth;
var
  LineCount, PixelWidth: Integer;
  Nines: String;
begin
  if FLineNumbers or FFoldLevelNumbersOrLineState then begin
    { Note: Based on SciTE's SciTEBase::SetLineNumberWidth. }

    if FFoldLevelNumbersOrLineState then
      Nines := StringOfChar('9', 12)
    else begin
      LineCount := Call(SCI_GETLINECOUNT, 0, 0);

      Nines := '9';
      while LineCount >= 10 do begin
        LineCount := LineCount div 10;
        Nines := Nines + '9';
      end;
    end;

    PixelWidth := 4 + Call(SCI_TEXTWIDTH, STYLE_LINENUMBER, AnsiString(Nines));
  end else
    PixelWidth := 0;
  
  Call(SCI_SETMARGINWIDTHN, 0, PixelWidth);
end;

procedure TScintEdit.UpdateStyleAttributes;
var
  DefaultAttr: TScintStyleAttributes; 

  procedure SetStyleAttr(const StyleNumber: Integer;
    const Attr: TScintStyleAttributes; const Force: Boolean);
  begin
    if Force or (Attr.FontName <> DefaultAttr.FontName) then
      Call(SCI_STYLESETFONT, StyleNumber, AnsiString(Attr.FontName));
    if Force or (Attr.FontSize <> DefaultAttr.FontSize) then
      { Note: Scintilla doesn't support negative point sizes like the VCL }
      Call(SCI_STYLESETSIZE, StyleNumber, Abs(Attr.FontSize));
    if Force or (Attr.FontCharset <> DefaultAttr.FontCharset) then
      Call(SCI_STYLESETCHARACTERSET, StyleNumber, Attr.FontCharset);
    if Force or (Attr.FontStyle <> DefaultAttr.FontStyle) then begin
      Call(SCI_STYLESETBOLD, StyleNumber, Ord(fsBold in Attr.FontStyle));
      Call(SCI_STYLESETITALIC, StyleNumber, Ord(fsItalic in Attr.FontStyle));
      Call(SCI_STYLESETUNDERLINE, StyleNumber, Ord(fsUnderline in Attr.FontStyle));
    end;
    if Force or (Attr.ForeColor <> DefaultAttr.ForeColor) then
      Call(SCI_STYLESETFORE, StyleNumber, ColorToRGB(Attr.ForeColor));
    if Force or (Attr.BackColor <> DefaultAttr.BackColor) then
      Call(SCI_STYLESETBACK, StyleNumber, ColorToRGB(Attr.BackColor));
  end;

  procedure SetStyleAttrFromStyler(const StyleNumber: Integer);
  var
    Attr: TScintStyleAttributes;
  begin
    Attr := DefaultAttr;
    FStyler.GetStyleAttributes(StyleNumber, Attr);
    SetStyleAttr(StyleNumber, Attr, False);
  end;

var
  I: Integer;
begin
  if not HandleAllocated then
    Exit;

  Call(SCI_SETCARETFORE, ColorToRGB(Font.Color), 0);

  DefaultAttr.FontName := Font.Name;
  DefaultAttr.FontSize := Font.Size;
  DefaultAttr.FontStyle := Font.Style;
  DefaultAttr.FontCharset := Font.Charset;
  DefaultAttr.ForeColor := Font.Color;
  DefaultAttr.BackColor := Color;

  Call(SCI_STYLERESETDEFAULT, 0, 0);
  SetStyleAttr(STYLE_DEFAULT, DefaultAttr, True);
  Call(SCI_STYLECLEARALL, 0, 0);

  if Assigned(FStyler) then begin
    if FUseStyleAttributes then begin
      for I := 0 to StyleNumbers-1 do
        SetStyleAttrFromStyler(I);
      SetStyleAttrFromStyler(STYLE_BRACEBAD);
      SetStyleAttrFromStyler(STYLE_BRACELIGHT);
      SetStyleAttrFromStyler(STYLE_INDENTGUIDE);
    end;
    SetStyleAttrFromStyler(STYLE_LINENUMBER);
  end;

  if (AutoCompleteFontName <> '') or (AutoCompleteFontSize > 0) then begin
    if AutoCompleteFontName <> '' then
      DefaultAttr.FontName := AutoCompleteFontName;
    if AutoCompleteFontSize > 0 then
    DefaultAttr.FontSize := AutoCompleteFontSize;
    DefaultAttr.FontStyle := [];
    { Note: Scintilla doesn't actually use the colors set here }
    DefaultAttr.ForeColor := clWindowText;
    DefaultAttr.BackColor := clWindow;
    if FAutoCompleteStyle = 0 then
      FAutoCompleteStyle := Call(SCI_ALLOCATEEXTENDEDSTYLES, 1, 0);
    SetStyleAttr(FAutoCompleteStyle, DefaultAttr, True);
    Call(SCI_AUTOCSETSTYLE, FAutoCompleteStyle, 0);
  end else
    Call(SCI_AUTOCSETSTYLE, 0, 0);
end;

function TScintEdit.WordAtCaret: String;
begin
  var Range := WordAtCaretRange;
  Result := GetTextRange(Range.StartPos, Range.EndPos);
end;

function TScintEdit.WordAtCaretRange: TScintRange;
begin
  var Pos := GetCaretPosition;
  Result.StartPos := GetWordStartPosition(Pos, True);
  Result.EndPos := GetWordEndPosition(Pos, True);
end;

procedure TScintEdit.ZoomIn;
begin
  Call(SCI_ZOOMIN, 0, 0);
end;

procedure TScintEdit.ZoomOut;
begin
  Call(SCI_ZOOMOUT, 0, 0);
end;

procedure TScintEdit.CMColorChanged(var Message: TMessage);
begin
  inherited;
  UpdateStyleAttributes;
end;

procedure TScintEdit.CMFontChanged(var Message: TMessage);
begin
  inherited;
  UpdateStyleAttributes;
end;

procedure TScintEdit.CMHintShow(var Message: TCMHintShow);
begin
  inherited;
  if Assigned(FOnHintShow) then
    FOnHintShow(Self, Message.HintInfo^);
end;

procedure TScintEdit.CMSysColorChange(var Message: TMessage);
begin
  inherited;
  UpdateStyleAttributes;
end;

procedure TScintEdit.CNNotify(var Message: TWMNotify);
begin
  Notify(PSCNotification(Message.NMHdr)^);
end;

procedure TScintEdit.WMDestroy(var Message: TWMDestroy);
begin
  FDirectPtr := nil;
  FDirectStatusFunction := nil;
  inherited;
end;

procedure TScintEdit.DpiChanged(const Message: TMessage);
begin
  ForwardMessage(Message);
end;

procedure TScintEdit.WMDropFiles(var Message: TWMDropFiles);
var
  FileList: TStringList;
  Filename: array[0..MAX_PATH-1] of Char;
  P: TPoint;
begin
  FileList := nil;
  try
    if FAcceptDroppedFiles and Assigned(FOnDropFiles) then begin
      FileList := TStringList.Create;
      const NumFiles = DragQueryFile(Message.Drop, UINT(-1), nil, 0);
      if NumFiles > 0 then
        for var I := 0 to NumFiles-1 do
          if DragQueryFile(Message.Drop, I, Filename,
             SizeOf(Filename) div SizeOf(Filename[0])) > 0 then
            FileList.Add(Filename);

      if FileList.Count > 0 then begin
        if not DragQueryPoint(Message.Drop, P) then begin
          P.X := -1;
          P.Y := -1;
        end;
        FOnDropFiles(Self, P.X, P.Y, FileList);
      end;
    end;
  finally
    FileList.Free;
    DragFinish(Message.Drop);
    Message.Drop := 0;
  end;
end;

procedure TScintEdit.WMEraseBkgnd(var Message: TMessage);
begin
  { Bypass the VCL's WM_ERASEBKGND handler; it causes flicker when selecting +
    scrolling downward using the mouse }
  Message.Result := CallWindowProc(DefWndProc, Handle, Message.Msg,
    Message.WParam, Message.LParam);
end;

procedure TScintEdit.WMGetDlgCode(var Message: TWMGetDlgCode);
begin
  inherited;
  Message.Result := Message.Result or (DLGC_WANTARROWS or DLGC_WANTTAB);
end;

procedure TScintEdit.WMMouseWheel(var Message: TMessage);
begin
  { Bypass TControl's broken WM_MOUSEWHEEL handler: it translates WParamLo
    from a combination of MK_* values to a TShiftState -- which is only
    meaningful to the VCL -- but it doesn't restore the original value before
    passing an unhandled WM_MOUSEWHEEL message up to DefWndProc. This causes
    Scintilla to see Ctrl+wheel as Shift+wheel, breaking zoom. (Observed on
    Delphi 2009 and still needed in Delphi 11.3.) }
  Message.Result := CallWindowProc(DefWndProc, Handle, Message.Msg,
    Message.WParam, Message.LParam);
end;

procedure TScintEdit.SettingChange(const Message: TMessage);
begin
  ForwardMessage(Message);
end;

{ TScintEditStrings }

procedure TScintEditStrings.CheckIndexRange(const Index: Integer);
begin
  if (Index < 0) or (Index >= GetCount) then
    Error(SListIndexError, Index);
end;

procedure TScintEditStrings.CheckIndexRangePlusOne(const Index: Integer);
begin
  if (Index < 0) or (Index > GetCount) then
    Error(SListIndexError, Index);
end;

procedure TScintEditStrings.Clear;
begin
  FEdit.SetRawText('');
end;

procedure TScintEditStrings.Delete(Index: Integer);
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetPositionFromLine(Index);
  EndPos := FEdit.GetPositionFromLine(Index + 1);
  FEdit.ReplaceRawTextRange(StartPos, EndPos, '');
end;

function TScintEditStrings.Get(Index: Integer): String;
begin
  Result := FEdit.ConvertRawStringToString(GetRawLine(Index));
end;

function TScintEditStrings.GetCount: Integer;
begin
  Result := FEdit.Call(SCI_GETLINECOUNT, 0, 0);
end;

function TScintEditStrings.GetLineEndingLength(const Index: Integer): Integer;
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetLineEndPosition(Index);
  EndPos := FEdit.GetPositionFromLine(Index + 1);
  Result := EndPos - StartPos;
end;

function TScintEditStrings.GetRawLine(Index: Integer): TScintRawString;
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetPositionFromLine(Index);
  EndPos := FEdit.GetLineEndPosition(Index);
  Result := FEdit.GetRawTextRange(StartPos, EndPos);
end;

function TScintEditStrings.GetRawLineLength(Index: Integer): Integer;
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetPositionFromLine(Index);
  EndPos := FEdit.GetLineEndPosition(Index);
  Result := EndPos - StartPos;
end;

function TScintEditStrings.GetRawLineLengthWithEnding(Index: Integer): Integer;
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetPositionFromLine(Index);
  EndPos := FEdit.GetPositionFromLine(Index + 1);
  Result := EndPos - StartPos;
end;

function TScintEditStrings.GetRawLineWithEnding(Index: Integer): TScintRawString;
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetPositionFromLine(Index);
  EndPos := FEdit.GetPositionFromLine(Index + 1);
  Result := FEdit.GetRawTextRange(StartPos, EndPos);
end;

function TScintEditStrings.GetState(Index: Integer): TScintLineState;
begin
  CheckIndexRange(Index);
  Result := FEdit.Call(SCI_GETLINESTATE, Index, 0);
end;

function TScintEditStrings.GetTextStr: String;
begin
  Result := FEdit.ConvertRawStringToString(FEdit.GetRawText);
end;

procedure TScintEditStrings.Insert(Index: Integer; const S: String);
begin
  InsertRawLine(Index, FEdit.ConvertStringToRawString(S));
end;

procedure TScintEditStrings.InsertRawLine(Index: Integer; const S: TScintRawString);
var
  Pos: Integer;
  EndingStr, InsertStr: TScintRawString;
begin
  CheckIndexRangePlusOne(Index);
  EndingStr := FEdit.GetLineEndingString;
  Pos := FEdit.GetPositionFromLine(Index);
  if (Index = GetCount) and (Pos <> FEdit.GetPositionFromLine(Index - 1)) then
    InsertStr := EndingStr + S + EndingStr
  else
    InsertStr := S + EndingStr;
  { Using ReplaceRawTextRange instead of SCI_INSERTTEXT for embedded null support }
  FEdit.ReplaceRawTextRange(Pos, Pos, InsertStr);
end;

procedure TScintEditStrings.Put(Index: Integer; const S: String);
begin
  PutRawLine(Index, FEdit.ConvertStringToRawString(S));
end;

procedure TScintEditStrings.PutRawLine(Index: Integer; const S: TScintRawString);
var
  StartPos, EndPos: Integer;
begin
  CheckIndexRange(Index);
  StartPos := FEdit.GetPositionFromLine(Index);
  EndPos := FEdit.GetLineEndPosition(Index);
  FEdit.ReplaceRawTextRange(StartPos, EndPos, S, srmMinimal);
end;

procedure TScintEditStrings.SetText(Text: PChar);
begin
  FEdit.SetRawText(FEdit.ConvertPCharToRawString(Text, Integer(StrLen(Text))));
end;

procedure TScintEditStrings.SetTextStr(const Value: String);
begin
  FEdit.SetRawText(FEdit.ConvertStringToRawString(Value));
end;

{ TScintCustomStyler }

procedure TScintCustomStyler.ApplyStyleByteIndicators(const Indicators: TScintStyleByteIndicatorNumbers;
  StartIndex, EndIndex: Integer);
begin
  var IndByte := Byte(Indicators) shl StyleNumberBits;
  if IndByte <> 0 then begin
    if StartIndex < 1 then
      StartIndex := 1;
    if EndIndex > FTextLen then
      EndIndex := FTextLen;
    for var I := StartIndex to EndIndex do
      FStyleStr[I] := AnsiChar(Ord(FStyleStr[I]) or IndByte);
  end;
end;

procedure TScintCustomStyler.ApplyStyle(const Style: TScintStyleNumber;
  StartIndex, EndIndex: Integer);
begin
  if StartIndex < 1 then
    StartIndex := 1;
  if EndIndex > FTextLen then
    EndIndex := FTextLen;
  for var I := StartIndex to EndIndex do
    if Ord(FStyleStr[I]) and StyleNumberMask = 0 then
      FStyleStr[I] := AnsiChar(Style or (Ord(FStyleStr[I]) and not StyleNumberMask));
end;

procedure TScintCustomStyler.CommitStyle(const Style: TScintStyleNumber);
begin
  ApplyStyle(Style, FStyleStartIndex, FCurIndex - 1);
  FStyleStartIndex := FCurIndex;
end;

function TScintCustomStyler.ConsumeAllRemaining: Boolean;
begin
  Result := FCurIndex <= FTextLen;
  if Result then
    FCurIndex := FTextLen + 1;
end;

function TScintCustomStyler.ConsumeChar(const C: AnsiChar): Boolean;
begin
  Result := (FCurIndex <= FTextLen) and (FText[FCurIndex] = C);
  if Result then
    Inc(FCurIndex);
end;

function TScintCustomStyler.ConsumeCharIn(const Chars: TScintRawCharSet): Boolean;
begin
  Result := (FCurIndex <= FTextLen) and (FText[FCurIndex] in Chars);
  if Result then
    Inc(FCurIndex);
end;

function TScintCustomStyler.ConsumeChars(const Chars: TScintRawCharSet): Boolean;
begin
  Result := False;
  while FCurIndex <= FTextLen do begin
    if not(FText[FCurIndex] in Chars) then
      Break;
    Result := True;
    Inc(FCurIndex);
  end;
end;

function TScintCustomStyler.ConsumeCharsNot(const Chars: TScintRawCharSet): Boolean;
begin
  Result := False;
  while FCurIndex <= FTextLen do begin
    if FText[FCurIndex] in Chars then
      Break;
    Result := True;
    Inc(FCurIndex);
  end;
end;

function TScintCustomStyler.ConsumeString(const Chars: TScintRawCharSet): TScintRawString;
var
  StartIndex: Integer;
begin
  StartIndex := FCurIndex;
  ConsumeChars(Chars);
  Result := Copy(FText, StartIndex, FCurIndex - StartIndex);
end;

function TScintCustomStyler.CurCharIn(const Chars: TScintRawCharSet): Boolean;
begin
  Result := (FCurIndex <= FTextLen) and (FText[FCurIndex] in Chars);
end;

function TScintCustomStyler.CurCharIs(const C: AnsiChar): Boolean;
begin
  Result := (FCurIndex <= FTextLen) and (FText[FCurIndex] = C);
end;

function TScintCustomStyler.GetCurChar: AnsiChar;
begin
  Result := #0;
  if FCurIndex <= FTextLen then
    Result := FText[FCurIndex];
end;

function TScintCustomStyler.GetEndOfLine: Boolean;
begin
  Result := FCurIndex > FTextLen;
end;

function TScintCustomStyler.LineTextSpans(const S: TScintRawString): Boolean;
begin
  Result := False;
end;

function TScintCustomStyler.NextCharIs(const C: AnsiChar): Boolean;
begin
  Result := (FCurIndex < FTextLen) and (FText[FCurIndex+1] = C);
end;

function TScintCustomStyler.PreviousCharIn(const Chars: TScintRawCharSet): Boolean;
begin
  Result := (FCurIndex > 1) and (FCurIndex-1 <= FTextLen) and
    (FText[FCurIndex-1] in Chars);
end;

procedure TScintCustomStyler.ReplaceText(StartIndex, EndIndex: Integer;
  const C: AnsiChar);
var
  P: PAnsiChar;
  I: Integer;
begin
  if StartIndex < 1 then
    StartIndex := 1;
  if EndIndex > FTextLen then
    EndIndex := FTextLen;
  P := @FText[1];
  for I := StartIndex to EndIndex do
    P[I-1] := C;
end;

procedure TScintCustomStyler.ResetCurIndexTo(Index: Integer);
begin
  FCurIndex := Index;
  FStyleStartIndex := Index;
end;

{ TScintPixmap }

const
  XPMTransparentChar = ' ';
  XPMTerminatorChar = '"';

class constructor TScintPixmap.Create;
begin
  { Chars 128-255 are supported below but don't work in Scintilla }
  for var C := #1 to #127 do
    if (C <> XPMTransparentChar) and (C <> XPMTerminatorChar) then
      ColorCodes := ColorCodes + C;
end;

function TScintPixmap.GetPixmap: Pointer;
begin
  Result := FPixmap;
end;

type
  TRGBTripleArray = array[0..MaxInt div SizeOf(TRGBTriple) - 1] of TRGBTriple;
  PRGBTripleArray = ^TRGBTripleArray;

procedure TScintPixmap.InitializeFromBitmap(const ABitmap: TBitmap;
  const TransparentColor: TColorRef);

  procedure SetNextPixmapLine(const Pixmap: TPixmap; var Index: Integer; const Line: String);
  begin
    if Index > High(Pixmap) then
      TScintEdit.Error('SetNextPixmapLine: Index out of range');

    { Convert Line to an AnsiString, but copy the exact ordinal values;
      i.e. don't do any translation of 128-255 }
    var AnsiLine: AnsiString;
    SetLength(AnsiLine, Length(Line));
    for var I := 1 to Length(AnsiLine) do
      AnsiLine[I] := AnsiChar(Ord(Line[I]));
    Pixmap[Index] := AnsiLine;
    Inc(Index);
  end;

begin
  if ABitmap.PixelFormat <> pf24bit then
    TScintEdit.Error('Invalid PixelFormat');

  var Colors := TDictionary<TColorRef, TPair<Char, String>>.Create; { RGB -> Code & WebColor }
  try
    { Build colors list }
    for var Y := 0 to ABitmap.Height-1 do begin
      var Pixels: PRGBTripleArray := ABitmap.ScanLine[Y];
      for var X := 0 to ABitmap.Width-1 do begin
        var Color := RGB(Pixels[X].rgbtRed, Pixels[X].rgbtGreen, Pixels[X].rgbtBlue);
        if (Color <> TransparentColor) and not Colors.ContainsKey(Color) then begin
          var ColorCodeIndex := Colors.Count+1;
          if ColorCodeIndex > Length(ColorCodes) then
            TScintEdit.Error('Too many colors');
          Colors.Add(Color, TPair<Char, String>.Create(ColorCodes[ColorCodeIndex], RGBToWebColorStr(Integer(Color))))
        end;
      end;
    end;

    { Build pixmap }
    var Line: String;
    SetLength(FPixmap, 0); { Not really needed but makes things clearer while debugging }
    SetLength(FPixmap, 1 + Colors.Count + ABitmap.Height + 1);
    Line := Format('%d %d %d 1', [ABitmap.Width, ABitmap.Height, Colors.Count]);
    var Index := 0;
    SetNextPixmapLine(FPixmap, Index, Line);
    for var Color in Colors do begin
      Line := Format('%s c %s', [Color.Value.Key, Color.Value.Value]);
      SetNextPixmapLine(FPixmap, Index, Line);
    end;
    for var Y := 0 to ABitmap.Height-1 do begin
      Line := '';
      var Pixels: PRGBTripleArray := ABitmap.ScanLine[Y];
      for var X := 0 to ABitmap.Width-1 do begin
        var Color := RGB(Pixels[X].rgbtRed, Pixels[X].rgbtGreen, Pixels[X].rgbtBlue);
        if Color = TransparentColor then
          Line := Line + XPMTransparentChar
        else
          Line := Line + Colors[Color].Key;
      end;
      SetNextPixmapLine(FPixmap, Index, Line);
    end;

    { Add terminating nil pointer - Scintilla doesnt really need it but setting it anyway }
    SetNextPixmapLine(FPixmap, Index, '');
  finally
    Colors.Free;
  end;
end;

{ TScintRange }

constructor TScintRange.Create(const AStartPos, AEndPos: Integer);
begin
  StartPos := AStartPos;
  EndPos := AEndPos;
end;

function TScintRange.Overlaps(const ARange: TScintRange): Boolean;
begin
  Result := not ARange.Empty and (StartPos <= ARange.EndPos) and (EndPos >= ARange.StartPos);
end;

function TScintRange.Empty: Boolean;
begin
  Result := StartPos = EndPos;
end;

function TScintRange.Within(const ARange: TScintRange): Boolean;
begin
  Result := (StartPos >= ARange.StartPos) and (EndPos <= ARange.EndPos);
end;

{ TScintRangeList }

function TScintRangeList.Count: Integer;
begin
  Result := Integer(inherited Count);
end;

function TScintRangeList.Overlaps(const ARange: TScintRange;
  var AOverlappingRange: TScintRange): Boolean;
begin
  for var Item in Self do begin
    if Item.Overlaps(ARange) then begin
      AOverlappingRange := Item;
      Exit(True);
    end;
  end;
  Result := False;
end;

{ TScintCaretAndAnchor }

constructor TScintCaretAndAnchor.Create(const ACaretPos, AAnchorPos: Integer);
begin
  CaretPos := ACaretPos;
  AnchorPos := AAnchorPos;
end;

function TScintCaretAndAnchor.Range: TScintRange;
begin
  if CaretPos <= AnchorPos then begin
    Result.StartPos := CaretPos;
    Result.EndPos := AnchorPos;
  end else begin
    Result.StartPos := AnchorPos;
    Result.EndPos := CaretPos;
  end;
end;

{ TScintCaretAndAnchorList }

function TScintCaretAndAnchorList.Count: Integer;
begin
  Result := Integer(inherited Count);
end;

end.