{-------------------------------------------------------------------------------
The contents of this file are subject to the Mozilla Public License
Version 1.1 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
the specific language governing rights and limitations under the License.

Alternatively, the contents of this file may be used under the terms of the
GNU General Public License Version 2 or later (the "GPL"), in which case
the provisions of the GPL are applicable instead of those above.
If you wish to allow use of your version of this file only under the terms
of the GPL and not to allow others to use your version of this file
under the MPL, indicate your decision by deleting the provisions above and
replace them with the notice and other provisions required by the GPL.
If you do not delete the provisions above, a recipient may use your version
of this file under either the MPL or the GPL.

-------------------------------------------------------------------------------}
unit LazSynEditText;

{$I synedit.inc}
{$IFOPT C+}
  {$DEFINE AssertSynMemIndex}
  {$DEFINE SynAssert}
{$ENDIF}
{$IFDEF SynAssert}
  {$DEFINE AssertSynMemIndex}
{$ENDIF}

interface

uses
  Classes, SysUtils, Graphics, LCLProc, SynEditTypes, SynEditMiscProcs,
  SynEditHighlighter, SynEditKeyCmds, SynEditTextBase;

type
  TSynEditStrings = class;

  TStringListLinesModifiedEvent = procedure(Sender: TSynEditStrings;
                                        aIndex, aNewCount, aOldCount: Integer) of object;
  TStringListLineCountEvent = procedure(Sender: TSynEditStrings;
                                        aIndex, aCount: Integer) of object;
  TStringListLineEditEvent = procedure(Sender: TSynEditStrings;
                                       aLinePos, aBytePos, aCount, aLineBrkCnt: Integer;
                                       aText: String) of object;

  TSynEditNotifyReason = ( // TStringListLineCountEvent
                           senrLineCount,        // Lines Inserted or Deleted (if not empty, they will trigger senrLineChange too)
                           senrLineChange,       // Lines modified (also triggered by senrEditAction)
                           senrLinesModified, //TStringListLinesModifiedEvent: Send once in "EndUpdate". Modified, inserted or deleted
                           senrHighlightChanged, // used by Highlighter (invalidate and fold checks needed)
                                                 // SynEdit.SetHighlighter sends the special (-1,-1) notification
                           senrLineMappingChanged, // folds added/removed - virtual X/Y changed. (ACount is not used)
                           // TStringListLineEditEvent
                           senrEditAction,       // EditInsert, EditDelete, EditLineBreak, ...
                           // TNotifyEvent
                           senrCleared,
                           senrUndoRedoAdded,
                           senrModifiedChanged,  // The modified flag was changed
                           // Paintlocks are managed by SynEdit, but need distribution to shared edits
                           senrIncOwnedPaintLock, // Inform other SynEdits (ForeignPaintLock)
                           senrDecOwnedPaintLock,
                           senrIncPaintLock,      // Actual PaintLock
                           senrDecPaintLock,
                           senrBeforeIncPaintLock, // For plugins, etc...
                           senrAfterIncPaintLock,
                           senrBeforeDecPaintLock,
                           senrAfterDecPaintLock,
                           senrTextBufferChanging, // About to change
                           senrTextBufferChanged,
                           senrBeginUndoRedo,
                           senrEndUndoRedo
                          );

  TPhysicalCharWidth = Byte;
  TPhysicalCharWidths = Array of TPhysicalCharWidth;
  PPhysicalCharWidth = ^TPhysicalCharWidth;
const
  PCWMask    = TPhysicalCharWidth($7f);  // bits for widths
  PCWFlagRTL = TPhysicalCharWidth($80); // RTL char

  { TSynLogicalPhysicalConvertor }
const
  SYN_LP_MIN_ALLOC = 1024; // Keep at least n*SizeOf(TPhysicalCharWidths) allocated

type

  TSynLogCharSide  = (cslBefore, cslAfter,  cslFollowLtr, cslFollowRtl);
  TSynPhysCharSide = (cspLeft,  cspRight, cspFollowLtr, cspFollowRtl);
  TSynLogPhysFlag  = (lpfAdjustToCharBegin, lpfAdjustToNextChar);
  TSynLogPhysFlags = set of TSynLogPhysFlag;

const
  cspDefault = cspFollowLtr;
  cslDefault = cslFollowLtr;

(** LRL    // L=Ltr-Char / R=RTl-Char

   * LogToPhys
   Log pos 1, is the pos between BOL and the first L.
   cslBefore binds it to BOL / cslAfter binds it to "L"

   cslBefore, cslAfter can not be mapped back, because the map 2 logical positions into the same phys pos

   (1, cslBefore) => 1 // behind the BOL     = Phys 2
   (2, cslBefore) => 2 // behind the first L = Phys 2
   (3, cslBefore) => 2 // behind the R       = Phys 2 (logical behind the R, on screen that is to the left of R, because R is RTL)
   (4, cslBefore) => 4 // behind the 2nd L   = Phys 4

   (1, cslAfter) => 1 // before the first L = Phys 1
   (2, cslAfter) => 3 // before the R       = Phys 3
   (3, cslAfter) => 3 // before the 2nd L   = Phys 3
   (4, cslAfter) => 4 // before the EOL     = Phys 4

   (1, cslFollowLtr) => 1 // between BOL ant the 1st L     = Phys 1
   (2, cslFollowLtr) => 2 // follows Ltr, after the 1st L  = Phys 2
   (3, cslFollowLtr) => 3 // follows Ltr, before the 2nd L = Phys 3
   (4, cslFollowLtr) => 4 // between the 2nd L and EOL     = Phys 4

   (1, cslFollowRtl) => 1 // between BOL ant the 1st L     = Phys 1
   (2, cslFollowRtl) => 3 // follows Rtl, before the R     = Phys 3
   (3, cslFollowRtl) => 2 // follows Rtl, after the R      = Phys 2
   (4, cslFollowRtl) => 4 // between the 2nd L and EOL     = Phys 4

   * PhysToLog
   Phys pos 1, is the pos between BOL and the first L.
   cspLeft binds it to BOL / cspRight binds it to "L"

   (2, cspLeft)  => 2 // looking to the left, using the first L = Log 2
   (3, cspLeft)  => 2 // looking to the left, using the R       = Log 2 (Pysh 3 is logical before the R / between 1st L and R)

   (2, cspRight) => 3 // looking to the right, using R       = Log 3 (Pysh 2 is logical after the R / between R and 2nd L)
   (3, cspRight) => 3 // looking to the right, using 2nd L   = Log 3
*)

type

  TSynLogicalPhysicalConvertor = class
  private
    FAdjustedLogToPhysOrigin: Integer;
    FAdjustedPhysToLogOrigin: Integer;
    FLines: TSynEditStrings;
    FCurrentWidths: TPhysicalCharWidths;
    FCurrentWidthsLen, FCurrentWidthsAlloc, FCurrentWidthsShrinkCnt: Integer;
    FCurrentLine: Integer;
    FTextChangeStamp, FViewChangeStamp: Int64;
    FUnAdjustedPhysToLogColOffs: Integer;
    FUnAdjustedPhysToLogResult: Integer;
    // TODOtab-width
    function GetCurrentLine: Integer;
    function GetCurrentWidths: PPhysicalCharWidth;
    procedure PrepareWidthsForLine(AIndex: Integer; AForce: Boolean = False);
    procedure SetCurrentLine(AValue: Integer);
  protected
    procedure SetWidthsForLine(AIndex: Integer; ANewWidths: TPhysicalCharWidths);
  public
    constructor Create(ALines: TSynEditStrings);
    destructor Destroy; override;

    property CurrentLine: Integer read GetCurrentLine write SetCurrentLine;
    property CurrentWidths: PPhysicalCharWidth read GetCurrentWidths;
    property CurrentWidthsDirect: TPhysicalCharWidths read FCurrentWidths; // may be longer than needed
    property CurrentWidthsCount: Integer read FCurrentWidthsLen;
  public
    // Line is 0-based // Column is 1-based
    function PhysicalToLogical(AIndex, AColumn: Integer): Integer;
    function PhysicalToLogical(AIndex, AColumn: Integer; out AColOffset: Integer;
                               ACharSide: TSynPhysCharSide= cspDefault;
                               AFlags: TSynLogPhysFlags = []): Integer;
    // ACharPos 1=before 1st char
    function LogicalToPhysical(AIndex, ABytePos: Integer): Integer;
    function LogicalToPhysical(AIndex, ABytePos: Integer; var AColOffset: Integer;
                               ACharSide: TSynLogCharSide = cslDefault;
                               AFlags: TSynLogPhysFlags = []): Integer;
    // properties set, if lpfAdjustTo... is used
    //  By LogToPhys
    property AdjustedLogToPhysOrigin: Integer read FAdjustedLogToPhysOrigin;
    //  By PhysToLog
    property AdjustedPhysToLogOrigin: Integer read FAdjustedPhysToLogOrigin;
    property UnAdjustedPhysToLogResult: Integer read FUnAdjustedPhysToLogResult;
    property UnAdjustedPhysToLogColOffs: Integer read FUnAdjustedPhysToLogColOffs;
  end;

  (*
  TLazSynDisplayView:
    - Represents the visible text
      e.g. excludes folds, maps wrapped lines, ...

  TSynEditStrings:
    - Represents the entire text,
      inluding temporary chars or text that may not be displayed.
      Temporary chars (e.g. trailing spaces) may not be accesibl via SynEdit.Lines
    - Can be Edited
  *)

  TLazSynDisplayTokenInfo = record
    TokenStart: PChar;
    TokenLength: integer;
    TokenAttr: TSynHighlighterAttributes;
  end;

  TLineRange = record
    Top, Bottom: TLineIdx;
  end;

  { TLazSynDisplayView }

  TLazSynDisplayView = class
  private
    FNextView: TLazSynDisplayView;
  public
    constructor Create;
    property NextView: TLazSynDisplayView read FNextView write FNextView;
  public
    procedure InitHighlighterTokens(AHighlighter: TSynCustomHighlighter); virtual;
    procedure SetHighlighterTokensLine(ALine: TLineIdx; out ARealLine: TLineIdx; out AStartBytePos, ALineByteLen: Integer); virtual;
    procedure FinishHighlighterTokens; virtual;
    function  GetNextHighlighterToken(out ATokenInfo: TLazSynDisplayTokenInfo): Boolean; virtual;
    function GetLinesCount: Integer; virtual;
    function GetDrawDividerInfo: TSynDividerDrawConfigSetting; virtual;

    function TextToViewIndex(ATextIndex: TLineIdx): TLineRange; virtual;
    function ViewToTextIndex(AViewIndex: TLineIdx): TLineIdx; virtual;
    function ViewToTextIndexEx(AViewIndex: TLineIdx; out AViewRange: TLineRange): TLineIdx; virtual;
  end;

  { TLazSynDisplayViewEx }

  TLazSynDisplayViewEx = class(TLazSynDisplayView)
  private
    FInitialized: boolean;
    FCurrentTokenHighlighter: TSynCustomHighlighter;
    FCurrentTokenLine: TLineIdx;
    procedure SetCurrentTokenLine(AValue: TLineIdx);
  protected
    property Initialized: boolean read FInitialized;
    property CurrentTokenHighlighter: TSynCustomHighlighter read FCurrentTokenHighlighter;
    property CurrentTokenLine: TLineIdx read FCurrentTokenLine write SetCurrentTokenLine;
  public
    constructor Create;
    procedure InitHighlighterTokens(AHighlighter: TSynCustomHighlighter); override;
    procedure FinishHighlighterTokens; override;
  end;

  LPosFlag = (lpAllowPastEol, lpAdjustToNext, lpStopAtCodePoint);
  LPosFlags = set of LPosFlag;

  TViewedXYInfoFlag = (
    vifAdjustLogXYToNextChar, // If PhysPos is not at a char bound, the bound to the  NextChar will be used. (Otherwise no adjustment)
    vifReturnPhysXY,
    vifReturnLogXY,      // return alternative coordinates
    vifReturnLogEOL,     // Return the logXPos of the EOL / -1 on a wrapped line
    vifReturnPhysOffset  // Physical distance of returned-ViewedPos.X from begin of LogPos
  );
  TViewedXYInfoFlags = set of TViewedXYInfoFlag;

  TViewedXYInfo = record
    CorrectedViewedXY: TPhysPoint; // Moved inside the wrapping bounds
    PhysXY: TPhysPoint;
    LogicalXY: TLogCaretPoint;
    PhysBoundOffset: Integer;
    LogEOLPos: Integer;
    FirstViewedX: IntPos;
  end;

  { TSynEditStrings }

  TSynEditStrings = class(TSynEditStringsBase)
  private
    FSenderUpdateCount: Integer;
    FLogPhysConvertor :TSynLogicalPhysicalConvertor;
    FLogPhysConvertorTmp :TSynLogicalPhysicalConvertor; // used by none buffered lines
  protected
    function  GetIsUtf8 : Boolean; virtual; abstract;
    procedure SetIsUtf8(const AValue : Boolean); virtual; abstract;

    function GetExpandedString(Index: integer): string; virtual; abstract;
    function GetLengthOfLongestLine: integer; virtual; abstract;
    procedure SetTextStr(const Value: string); override;
    function GetTextChangeStamp: int64; virtual; abstract;
    function GetViewChangeStamp: int64; virtual;

    function GetViewedCount: Integer; virtual;
    function GetViewedLines(Index: integer): string; virtual;

    function GetIsInEditAction: Boolean; virtual; abstract;
    procedure IncIsInEditAction; virtual; abstract;
    procedure DecIsInEditAction; virtual; abstract;
    function GetUndoList: TSynEditUndoList; virtual; abstract;
    function GetRedoList: TSynEditUndoList; virtual; abstract;
    function GetCurUndoList: TSynEditUndoList; virtual; abstract;
    procedure SetIsUndoing(const AValue: Boolean); virtual; abstract;
    function  GetIsUndoing: Boolean; virtual; abstract;
    procedure SetIsRedoing(const AValue: Boolean); virtual; abstract;
    function  GetIsRedoing: Boolean; virtual; abstract;
    procedure IgnoreSendNotification(AReason: TSynEditNotifyReason;
                                     ReEnable: Boolean); virtual; abstract;

    procedure SetUpdateState(Updating: Boolean); override;
    procedure SetUpdateState(Updating: Boolean; Sender: TObject); virtual; abstract;

    procedure DoGetPhysicalCharWidths(Line: PChar; LineLen, Index: Integer; PWidths: PPhysicalCharWidth); virtual; abstract;

    procedure InternalGetInfoForViewedXY(AViewedXY: TPhysPoint; AFlags: TViewedXYInfoFlags;
      out AViewedXYInfo: TViewedXYInfo; ALogPhysConvertor :TSynLogicalPhysicalConvertor); virtual;

    function GetDisplayView: TLazSynDisplayView; virtual;
  public
    constructor Create;
    destructor Destroy; override;
    procedure BeginUpdate(Sender: TObject); overload;
    procedure EndUpdate(Sender: TObject); overload;
    function  IsUpdating: Boolean;

    // Currently Lines are physical
    procedure DeleteLines(Index, NumLines: integer); virtual; abstract;
    procedure InsertLines(Index, NumLines: integer); virtual; abstract;
    procedure InsertStrings(Index: integer; NewStrings: TStrings); virtual; abstract;

    procedure SendHighlightChanged(aIndex, aCount: Integer); override;
    procedure SendNotification(AReason: TSynEditNotifyReason;
                ASender: TSynEditStrings; aIndex, aCount: Integer); virtual; abstract; overload;
    procedure SendNotification(AReason: TSynEditNotifyReason;
                ASender: TSynEditStrings; aIndex, aCount: Integer;
                aBytePos: Integer; aLen: Integer; aTxt: String); virtual; abstract; overload;
    procedure SendNotification(AReason: TSynEditNotifyReason;
                ASender: TObject); virtual; abstract; overload;
   procedure FlushNotificationCache; virtual; abstract;
  public
    // Char bounds // 1 based (1 is the 1st char in the line)
    function LogicPosAddChars(const ALine: String; ALogicalPos, ACount: integer;
                              AFlags: LPosFlags = []): Integer; virtual; abstract; overload;
    function LogicPosIsAtChar(const ALine: String; ALogicalPos: integer;
                              AFlags: LPosFlags = []): Boolean; virtual; abstract;
    function LogicPosAdjustToChar(const ALine: String; ALogicalPos: integer;
                                  AFlags: LPosFlags = []): Integer; virtual; abstract; overload;

    function LogicPosAddChars(const ALine: String; ALogicalPos, ACount: integer;
                              AllowPastEOL: Boolean): Integer; overload; // deprecated;
    function LogicPosAdjustToChar(const ALine: String; ALogicalPos: integer;
                                  ANext: Boolean; AllowPastEOL: Boolean = False): Integer; overload; // deprecated;
    // CharWidths
    function GetPhysicalCharWidths(Index: Integer): TPhysicalCharWidths;
    function GetPhysicalCharWidths(Line: PChar; LineLen, Index: Integer): TPhysicalCharWidths;
    procedure GetPhysicalCharWidths(Index: Integer; var AResult: TPhysicalCharWidths; out ALen: Integer);
    // Byte to Char
    function LogicalToPhysicalPos(const p: TPoint): TPoint;
    function LogicalToPhysicalCol(const Line: String;
                                  Index, LogicalPos: integer): integer; virtual; //deprecated;
    // Char to Byte
    function PhysicalToLogicalPos(const p: TPoint): TPoint;
    function PhysicalToLogicalCol(const Line: string;
                                  Index, PhysicalPos: integer): integer; virtual; //deprecated;
    property LogPhysConvertor :TSynLogicalPhysicalConvertor read FLogPhysConvertor write FLogPhysConvertor;

    function TextToViewIndex(aTextIndex : TLineIdx) : TLineIdx; virtual;
    function ViewToTextIndex(aViewIndex : TLineIdx) : TLineIdx; virtual;

    function AddVisibleOffsetToTextIndex(aTextIndex: TLineIdx; LineOffset : Integer) : TLineIdx; virtual;
    function IsTextIdxVisible(aTextIndex: TLineIdx): Boolean; virtual;
    procedure GetInfoForViewedXY(AViewedXY: TPhysPoint; AFlags: TViewedXYInfoFlags; out AViewedXYInfo: TViewedXYInfo);
    // ViewedToPhysAndLog
    (* Convert between TextBuffer and ViewedText
       X/Y are all 1-based
    *)
    function ViewXYToTextXY(APhysViewXY: TPhysPoint): TPhysPoint; virtual;
    function TextXYToViewXY(APhysTextXY: TPhysPoint): TPhysPoint; virtual;
  public
    // Currently Lines are physical
    procedure EditInsert(LogX, LogY: Integer; AText: String); virtual; abstract;
    function  EditDelete(LogX, LogY, ByteLen: Integer): String; virtual; abstract;
    function  EditReplace(LogX, LogY, ByteLen: Integer; AText: String): String; virtual; abstract;
    procedure EditLineBreak(LogX, LogY: Integer); virtual; abstract;
    procedure EditLineJoin(LogY: Integer; FillText: String = ''); virtual; abstract;
    procedure EditLinesInsert(LogY, ACount: Integer; AText: String = ''); virtual; abstract;
    procedure EditLinesDelete(LogY, ACount: Integer); virtual; abstract;
    procedure EditUndo(Item: TSynEditUndoItem); virtual; abstract;
    procedure EditRedo(Item: TSynEditUndoItem); virtual; abstract;
    (* IsInEditAction
       While in EditAction a "senrEditAction" event is triggerred, that contains
       more detailed line-count change info.
       Yet senrLineCount is also sent.
       IsInEditAction allows one to skip senrLineCount, that are sent as senrEditAction
       Currently used by FoldView
    *)
    property IsInEditAction: Boolean read GetIsInEditAction; // Todo: have individual event types instead
    property UndoList: TSynEditUndoList read GetUndoList;
    property RedoList: TSynEditUndoList read GetRedoList;
    property CurUndoList: TSynEditUndoList read GetCurUndoList; // Re or Undo (Redo while undoing)
    property IsUndoing: Boolean read GetIsUndoing write SetIsUndoing;
    property IsRedoing: Boolean read GetIsRedoing write SetIsRedoing;
  public
    property TextChangeStamp: int64 read GetTextChangeStamp;
    property ViewChangeStamp: int64 read GetViewChangeStamp; // tabs-size, trailing-spaces, ...
    property ExpandedStrings[Index: integer]: string read GetExpandedString; deprecated;
    property LengthOfLongestLine: integer read GetLengthOfLongestLine;
    property ViewedLines[Index: integer]: string read GetViewedLines;
    property ViewedCount: Integer read GetViewedCount;
    property IsUtf8: Boolean read GetIsUtf8 write SetIsUtf8;
  public
    property DisplayView: TLazSynDisplayView read GetDisplayView;
  end;

  TSynTextViewsManager = class;

  { TSynEditStringsLinked }

  TSynEditStringsLinked = class(TSynEditStrings)
  private
    FManager: TSynTextViewsManager;
    fSynStrings: TSynEditStrings;
    fSynStringsEditing,
    fSynStringsState,
    fSynStringsLogPos,
    fSynStringsPhys,
    fSynStringsXYMap,
    fSynStringsNotify: TSynEditStrings;
  protected
    procedure SetSynStrings(AValue: TSynEditStrings); virtual;

    function  GetIsUtf8 : Boolean;  override;
    procedure SetIsUtf8(const AValue : Boolean);  override;
    function GetTextChangeStamp: int64; override;
    function GetViewChangeStamp: int64; override;

    function GetRange(Index: Pointer): TSynManagedStorageMem; override;
    procedure PutRange(Index: Pointer; const ARange: TSynManagedStorageMem); override;

    function GetViewedCount: Integer; override;
    function GetViewedLines(Index: integer): string; override;

    function GetExpandedString(Index: integer): string; override;
    function GetLengthOfLongestLine: integer; override;

    procedure IgnoreSendNotification(AReason: TSynEditNotifyReason;
                                     IncIgnore: Boolean); override;
    function GetIsInEditAction: Boolean; override;
    procedure IncIsInEditAction; override;
    procedure DecIsInEditAction; override;
    function GetUndoList: TSynEditUndoList; override;
    function GetRedoList: TSynEditUndoList; override;
    function GetCurUndoList: TSynEditUndoList; override;
    procedure SetIsUndoing(const AValue: Boolean); override;
    function  GetIsUndoing: Boolean; override;
    procedure SetIsRedoing(const AValue: Boolean); override;
    function  GetIsRedoing: Boolean; override;
  protected
    function GetCount: integer; override;
    function GetCapacity: integer; override;
    procedure SetCapacity(NewCapacity: integer); override;
    function  Get(Index: integer): string; override;
    function  GetObject(Index: integer): TObject; override;
    procedure Put(Index: integer; const S: string); override;
    procedure PutObject(Index: integer; AObject: TObject); override;

    procedure SetUpdateState(Updating: Boolean; Sender: TObject); override;
    procedure DoGetPhysicalCharWidths(Line: PChar; LineLen, Index: Integer; PWidths: PPhysicalCharWidth); override;

    procedure InternalGetInfoForViewedXY(AViewedXY: TPhysPoint;
      AFlags: TViewedXYInfoFlags; out AViewedXYInfo: TViewedXYInfo;
      ALogPhysConvertor: TSynLogicalPhysicalConvertor); override;

    function GetDisplayView: TLazSynDisplayView; override;

    procedure AddGenericHandler(AReason: TSynEditNotifyReason; AHandler: TMethod);
    procedure RemoveGenericHandler(AReason: TSynEditNotifyReason; AHandler: TMethod);

    procedure SetManager(AManager: TSynTextViewsManager); virtual;
    property Manager: TSynTextViewsManager read FManager;
  public
    function Add(const S: string): integer; override;
    procedure AddStrings(AStrings: TStrings); override;
    procedure Clear; override;
    procedure Delete(Index: integer); override;
    procedure DeleteLines(Index, NumLines: integer);  override;
    procedure Insert(Index: integer; const S: string); override;
    procedure InsertLines(Index, NumLines: integer); override;
    procedure InsertStrings(Index: integer; NewStrings: TStrings); override;
    function  GetPChar(ALineIndex: Integer; out ALen: Integer): PChar; override; // experimental

    procedure SendNotification(AReason: TSynEditNotifyReason;
                ASender: TSynEditStrings; aIndex, aCount: Integer); override; overload;
    procedure SendNotification(AReason: TSynEditNotifyReason;
                ASender: TSynEditStrings; aIndex, aCount: Integer;
                aBytePos: Integer; aLen: Integer; aTxt: String); override; overload;
    procedure SendNotification(AReason: TSynEditNotifyReason;
                ASender: TObject); override; overload;
   procedure FlushNotificationCache; override;

    procedure AddModifiedHandler(AReason: TSynEditNotifyReason;
                AHandler: TStringListLinesModifiedEvent);
    procedure AddChangeHandler(AReason: TSynEditNotifyReason;
                AHandler: TStringListLineCountEvent);
    procedure AddNotifyHandler(AReason: TSynEditNotifyReason;
                AHandler: TNotifyEvent);

    procedure RemoveModifiedHandler(AReason: TSynEditNotifyReason;
                AHandler: TStringListLinesModifiedEvent);
    procedure RemoveChangeHandler(AReason: TSynEditNotifyReason;
                AHandler: TStringListLineCountEvent);
    procedure RemoveNotifyHandler(AReason: TSynEditNotifyReason;
                AHandler: TNotifyEvent);

    procedure AddEditHandler(AHandler: TStringListLineEditEvent);
    procedure RemoveEditHandler(AHandler: TStringListLineEditEvent);

    procedure RemoveHanlders(AOwner: TObject); deprecated 'Use "RemoveHandlers" / Will be removed in 4.99';
    procedure RemoveHandlers(AOwner: TObject);

    //function GetPhysicalCharWidths(Line: PChar; LineLen, Index: Integer): TPhysicalCharWidths; override;
    property NextLines: TSynEditStrings read fSynStrings write SetSynStrings;
  public
    // Char bounds // 1 based (1 is the 1st char in the line)
    function LogicPosAddChars(const ALine: String; ALogicalPos, ACount: integer;
                              AFlags: LPosFlags = []): Integer; override; overload;
    function LogicPosIsAtChar(const ALine: String; ALogicalPos: integer;
                              AFlags: LPosFlags = []): Boolean; override;
    function LogicPosAdjustToChar(const ALine: String; ALogicalPos: integer;
                                  AFlags: LPosFlags = []): Integer; override; overload;

    function TextToViewIndex(aTextIndex : TLineIdx) : TLineIdx; override;
    function ViewToTextIndex(aViewIndex : TLineIdx) : TLineIdx; override;

    function AddVisibleOffsetToTextIndex(aTextIndex: TLineIdx; LineOffset: Integer): TLineIdx; override;
    function IsTextIdxVisible(aTextIndex: TLineIdx): Boolean; override;
    // ViewedToPhysAndLog
    (* Convert between TextBuffer and ViewedText
       X/Y are all 1-based
    *)
    function ViewXYToTextXY(APhysViewXY: TPhysPoint): TPhysPoint; override;
    function TextXYToViewXY(APhysTextXY: TPhysPoint): TPhysPoint; override;
  public
    // LogX, LogY are 1-based
    procedure EditInsert(LogX, LogY: Integer; AText: String); override;
    function  EditDelete(LogX, LogY, ByteLen: Integer): String; override;
    function  EditReplace(LogX, LogY, ByteLen: Integer; AText: String): String; override;
    procedure EditLineBreak(LogX, LogY: Integer); override;
    procedure EditLineJoin(LogY: Integer; FillText: String = ''); override;
    procedure EditLinesInsert(LogY, ACount: Integer; AText: String = ''); override;
    procedure EditLinesDelete(LogY, ACount: Integer); override;
    procedure EditUndo(Item: TSynEditUndoItem); override;
    procedure EditRedo(Item: TSynEditUndoItem); override;
  end;

  TSynEditStringListBase = class(TSynEditStrings)
  protected
    procedure AddManagedHandler(AReason: TSynEditNotifyReason; AHandler: TMethod); virtual; abstract;
    procedure RemoveManagedHandler(AReason: TSynEditNotifyReason; AHandler: TMethod); virtual; abstract;
    procedure RemoveManagedHandlers(AOwner: TObject); virtual; abstract;
  end;

  { TSynTextViewsManager }

  TSynEditStringsLinkedClass = class of TSynEditStringsLinked;

  TSynTextViewsManager = class
  private
    FTextViewsList : TList;
    FTextBuffer: TSynEditStringListBase;
    FTopViewChangedCallback: TNotifyEvent;
    FNotifyLists: Array [TSynEditNotifyReason] of TMethodList;
    function GetSynTextView(Index: integer): TSynEditStringsLinked;
    function GetSynTextViewByClass(Index: TSynEditStringsLinkedClass): TSynEditStringsLinked;
    procedure SetTextBuffer(AValue: TSynEditStringListBase);
  protected
    procedure AddGenericHandler(AReason: TSynEditNotifyReason; AHandler: TMethod);
    procedure RemoveGenericHandler(AReason: TSynEditNotifyReason; AHandler: TMethod);
    procedure RemoveHandlers(AOwner: TObject);
    property TextBuffer: TSynEditStringListBase read FTextBuffer write SetTextBuffer;
  public
    constructor Create(ATextBuffer: TSynEditStringListBase; ATopViewChangedCallback: TNotifyEvent);
    destructor Destroy; override;
    procedure ReconnectViews;

    Procedure AddTextView(aTextView : TSynEditStringsLinked; AsFirst: Boolean = False);
    Procedure AddTextView(aTextView : TSynEditStringsLinked; AIndex: Integer);
    Procedure AddTextView(aTextView : TSynEditStringsLinked; AnAfter: TSynEditStringsLinked);
    Procedure RemoveSynTextView(aTextView : TSynEditStringsLinked; aDestroy: Boolean = False);
    function IndexOf(aTextView : TSynEditStringsLinked): integer;
    function Count: Integer;
    property SynTextView[Index: integer]: TSynEditStringsLinked read GetSynTextView;
    property SynTextViewByClass[Index: TSynEditStringsLinkedClass]: TSynEditStringsLinked read GetSynTextViewByClass;
  end;

implementation

{ TLazSynDisplayViewEx }

procedure TLazSynDisplayViewEx.SetCurrentTokenLine(AValue: TLineIdx);
begin
  {$IFDEF SynAssert}
  if  not Initialized then
    raise Exception.Create('uninitialized SetCurrentTokenLine');
  {$ENDIF}
  FCurrentTokenLine := AValue;
end;

constructor TLazSynDisplayViewEx.Create;
begin
  inherited Create;
  FInitialized := False;
end;

procedure TLazSynDisplayViewEx.InitHighlighterTokens(AHighlighter: TSynCustomHighlighter);
begin
  {$IFDEF SynAssert}
  if FInitialized then
    raise Exception.Create('Nested InitHighlighterTokensForLine');
  {$ENDIF}
  FCurrentTokenHighlighter := AHighlighter;
  FCurrentTokenLine := -1;
  FInitialized := True;
  inherited;
end;

procedure TLazSynDisplayViewEx.FinishHighlighterTokens;
begin
  FCurrentTokenHighlighter := nil;
  FInitialized := False;
  inherited;
end;

{ TLazSynDisplayView }

constructor TLazSynDisplayView.Create;
begin
  FNextView := nil;
end;

procedure TLazSynDisplayView.InitHighlighterTokens(AHighlighter: TSynCustomHighlighter);
begin
  if assigned(FNextView) then
    FNextView.InitHighlighterTokens(AHighlighter);
end;

procedure TLazSynDisplayView.SetHighlighterTokensLine(ALine: TLineIdx; out
  ARealLine: TLineIdx; out AStartBytePos, ALineByteLen: Integer);
begin
  //AStartBytePos := 1;
  if assigned(FNextView) then
    FNextView.SetHighlighterTokensLine(ALine, ARealLine, AStartBytePos, ALineByteLen);
end;

procedure TLazSynDisplayView.FinishHighlighterTokens;
begin
  if assigned(FNextView) then
    FNextView.FinishHighlighterTokens;
end;

function TLazSynDisplayView.GetNextHighlighterToken(out ATokenInfo: TLazSynDisplayTokenInfo): Boolean;
begin
  if assigned(FNextView) then
    Result := FNextView.GetNextHighlighterToken(ATokenInfo)
  else
    Result := False;
end;

function TLazSynDisplayView.GetLinesCount: Integer;
begin
  if assigned(FNextView) then
    Result := FNextView.GetLinesCount
  else
    Result := 0;
end;

function TLazSynDisplayView.GetDrawDividerInfo: TSynDividerDrawConfigSetting;
begin
  if assigned(FNextView) then
    Result := FNextView.GetDrawDividerInfo
  else
    Result.Color := clNone;
end;

function TLazSynDisplayView.TextToViewIndex(ATextIndex: TLineIdx): TLineRange;
begin
  Result := NextView.TextToViewIndex(ATextIndex);
end;

function TLazSynDisplayView.ViewToTextIndex(AViewIndex: TLineIdx): TLineIdx;
begin
  Result := NextView.ViewToTextIndex(AViewIndex);
end;

function TLazSynDisplayView.ViewToTextIndexEx(AViewIndex: TLineIdx; out
  AViewRange: TLineRange): TLineIdx;
begin
  Result := NextView.ViewToTextIndexEx(AViewIndex, AViewRange);
end;

{ TSynLogicalPhysicalConvertor }

procedure TSynLogicalPhysicalConvertor.PrepareWidthsForLine(AIndex: Integer;
  AForce: Boolean);
var
  LineLen: Integer;
  Line: PChar;
//const dbg_cnt: integer = 0;
begin
  if (not AForce) and (FCurrentLine = AIndex) and
     (FLines.TextChangeStamp = FTextChangeStamp) and (FLines.ViewChangeStamp = FViewChangeStamp)
  then begin
    //debugln(['**************** RE-USING widths: ', AIndex,' (',dbgs(Pointer(self)),')']);
    //dbg_cnt := dbg_cnt + 1;
    exit;
  end;

  if (AIndex < 0) or (AIndex >= FLines.Count) then begin
    FCurrentLine := -1;
    FCurrentWidthsLen := 0;
    FViewChangeStamp := FLines.ViewChangeStamp;
    FTextChangeStamp := FLines.TextChangeStamp;
    exit;
  end;

  Line := FLines.GetPChar(AIndex, LineLen);
  if LineLen > FCurrentWidthsAlloc then begin
    //debugln(['**************** COMPUTING widths (grow): ', AIndex,' (',dbgs(Pointer(self)),') old-alloc=', FCurrentWidthsAlloc, '  new-len=',LineLen]);
    SetLength(FCurrentWidths, LineLen);
    FCurrentWidthsAlloc := LineLen;
    FCurrentWidthsShrinkCnt := 0;
  end
  else if FCurrentWidthsAlloc > Max(Max(LineLen, FCurrentWidthsLen)*4, SYN_LP_MIN_ALLOC) then begin
    //debugln(['**************** COMPUTING widths (shrink): ', AIndex,' (',dbgs(Pointer(self)),') old-alloc=', FCurrentWidthsAlloc, '  new-len=',LineLen]);
    inc(FCurrentWidthsShrinkCnt);
    if FCurrentWidthsShrinkCnt > 20 then begin
      FCurrentWidthsAlloc := Max(Max(LineLen, FCurrentWidthsLen), SYN_LP_MIN_ALLOC) ;
      SetLength(FCurrentWidths, FCurrentWidthsAlloc);
    end;
  //end
  //else begin
  //  debugln(['**************** COMPUTING widths: ', AIndex,' (',dbgs(Pointer(self)),') alloc=',FCurrentWidthsAlloc]);
  end;
  //debugln(['**************** NEW for index:: ', AIndex,' (',dbgs(Pointer(self)),') after index: ', FCurrentLine, ' used ', dbg_cnt,' times // old-alloc=', FCurrentWidthsAlloc, '  new-len=',LineLen, '  viewchg:',dbgs(not(FViewChangeStamp=FLines.ViewChangeStamp)),' txtchg:',dbgs(not(FTextChangeStamp=FLines.TextChangeStamp))]); dbg_cnt := 0;

  FCurrentWidthsLen := LineLen;
  if LineLen > 0 then
    FLines.DoGetPhysicalCharWidths(Line, LineLen, AIndex, @FCurrentWidths[0]);
  FViewChangeStamp := FLines.ViewChangeStamp;
  FTextChangeStamp := FLines.TextChangeStamp;
  FCurrentLine := AIndex;
end;

procedure TSynLogicalPhysicalConvertor.SetCurrentLine(AValue: Integer);
begin
  PrepareWidthsForLine(AValue);
end;

function TSynLogicalPhysicalConvertor.GetCurrentWidths: PPhysicalCharWidth;
begin
  if FCurrentWidthsLen > 0
  then Result := @FCurrentWidths[0]
  else Result := nil;
end;

function TSynLogicalPhysicalConvertor.GetCurrentLine: Integer;
begin
  if (FLines.TextChangeStamp = FTextChangeStamp) and (FLines.ViewChangeStamp = FViewChangeStamp)
  then Result := FCurrentLine
  else Result := -1;
end;

procedure TSynLogicalPhysicalConvertor.SetWidthsForLine(AIndex: Integer;
  ANewWidths: TPhysicalCharWidths);
begin
  FCurrentWidths := ANewWidths;
  FCurrentWidthsLen := length(ANewWidths);
  FCurrentWidthsAlloc := FCurrentWidthsLen;
  FCurrentLine := AIndex;

  FViewChangeStamp := FLines.ViewChangeStamp;
  FTextChangeStamp := FLines.TextChangeStamp;
end;

constructor TSynLogicalPhysicalConvertor.Create(ALines: TSynEditStrings);
begin
  FLines := ALines;
  FCurrentLine := -1;
  FCurrentWidths := nil;
  FCurrentWidthsLen := 0;
  FCurrentWidthsAlloc := 0;
end;

destructor TSynLogicalPhysicalConvertor.Destroy;
begin
  SetLength(FCurrentWidths, 0);
  inherited Destroy;
end;

function TSynLogicalPhysicalConvertor.PhysicalToLogical(AIndex,
  AColumn: Integer): Integer;
var
  ColOffs: Integer;
begin
  Result := PhysicalToLogical(AIndex, AColumn, ColOffs);
end;

function TSynLogicalPhysicalConvertor.PhysicalToLogical(AIndex, AColumn: Integer; out
  AColOffset: Integer; ACharSide: TSynPhysCharSide; AFlags: TSynLogPhysFlags): Integer;
var
  BytePos, ScreenPos, ScreenPosOld: integer;
  RtlPos, RtlScreen: Integer;
begin
  FAdjustedPhysToLogOrigin    := AColumn;
  FUnAdjustedPhysToLogResult  := AColumn;
  FUnAdjustedPhysToLogColOffs := 0;
  AColOffset := 0;

  {$IFnDEF WithOutSynBiDi}
  if (AColumn = 0) or ((AColumn = 1) and (ACharSide in [cspLeft, cspFollowLtr])) then
    exit(AColumn);
  {$ELSE}
  if (AColumn = 0) or (AColumn = 1) then
    exit(AColumn);
  {$ENDIF}

  PrepareWidthsForLine(AIndex);

  ScreenPos := 1;
  BytePos := 0;
  {$IFnDEF WithOutSynBiDi }
  while BytePos < FCurrentWidthsLen do begin
    if ((FCurrentWidths[BytePos] and PCWMask) = 0) then begin
      inc(BytePos);
      continue;
    end;

    // currently Ltr
    if (ScreenPos = AColumn) and (ACharSide in [cspLeft, cspFollowLtr]) then begin
      AColOffset := 0;
      FUnAdjustedPhysToLogResult := BytePos+1;
      exit(BytePos+1);
    end;

    (* Inner RTL Loop *)
    If ((FCurrentWidths[BytePos] and PCWFlagRTL) <> 0) then begin
      RtlPos := BytePos;
      RtlScreen := 0;
      while (RtlPos < FCurrentWidthsLen) do begin
        if ((FCurrentWidths[RtlPos] and PCWMask) = 0) then begin
          inc(RtlPos);
          continue;
        end;
        If ((FCurrentWidths[RtlPos] and PCWFlagRTL) = 0) then
          break;

        RtlScreen := RtlScreen + (FCurrentWidths[RtlPos] and PCWMask);
        inc(RtlPos);
      end;

      // RtlScreen is now the screen width of the RTL run
      ScreenPos := ScreenPos + RtlScreen;
      if (ScreenPos = AColumn) and (ACharSide in [cspLeft, cspFollowRtl]) then begin
        AColOffset := 0;
        FUnAdjustedPhysToLogResult := BytePos+1;
        exit(BytePos+1);
      end
      else
      if ScreenPos > AColumn then begin
        // Search in RTL
        while BytePos < FCurrentWidthsLen do begin
          if ((FCurrentWidths[BytePos] and PCWMask) = 0) then begin
            inc(BytePos);
            continue;
          end;

          ScreenPosOld := ScreenPos;
          ScreenPos := ScreenPos - (FCurrentWidths[BytePos] and PCWMask);
          inc(BytePos);

          if (ScreenPos < AColumn) then begin
            AColOffset := ScreenPosOld - AColumn;
            FUnAdjustedPhysToLogResult := BytePos;
            FUnAdjustedPhysToLogColOffs := AColOffset;
            if (AColOffset <> 0) then begin
              if lpfAdjustToCharBegin in AFlags then begin
                FAdjustedPhysToLogOrigin := ScreenPosOld;
                AColOffset := 0;
              end
              else if lpfAdjustToNextChar in AFlags then begin
                FAdjustedPhysToLogOrigin := ScreenPos;
                AColOffset := 0;
                while (BytePos < FCurrentWidthsLen) and ((FCurrentWidths[BytePos] and PCWMask) = 0) do
                  inc(BytePos);
                inc(BytePos);
              end;
            end;
            exit(BytePos);
          end;

        end;

        if (ScreenPos = AColumn) then begin
          AColOffset := 0;
          FUnAdjustedPhysToLogResult := BytePos+1;
          exit(BytePos+1);
        end;

        // past EOL, line ends with RTL
        break; // Leave the outer loop
      end;

      // Cuntinue in LTR
      BytePos := RtlPos;
      assert(BytePos <= FCurrentWidthsLen, 'BytePos <= FCurrentWidthsLen');
      if BytePos >= FCurrentWidthsLen then
        break;  // Leave the outer loop
    end;
    (* Inner RTL Loop END *)

    ScreenPosOld := ScreenPos;
    ScreenPos := ScreenPos + (FCurrentWidths[BytePos] and PCWMask);
    inc(BytePos);

    if ScreenPos > AColumn then begin
      AColOffset := AColumn - ScreenPosOld;
      FUnAdjustedPhysToLogResult := BytePos;
      FUnAdjustedPhysToLogColOffs := AColOffset;
      if (AColOffset <> 0) then begin
        if lpfAdjustToCharBegin in AFlags then begin
          FAdjustedPhysToLogOrigin := ScreenPosOld;
          AColOffset := 0;
        end
        else if lpfAdjustToNextChar in AFlags then begin
          FAdjustedPhysToLogOrigin := ScreenPos;
          AColOffset := 0;
          while (BytePos < FCurrentWidthsLen) and ((FCurrentWidths[BytePos] and PCWMask) = 0) do
            inc(BytePos);
          inc(BytePos);
        end;
      end;
      exit(BytePos);
    end;
  end;
  {$ELSE}
  while BytePos < FCurrentWidthsLen do begin
    ScreenPosOld := ScreenPos;
    ScreenPos := ScreenPos + (FCurrentWidths[BytePos] and PCWMask);
    inc(BytePos);
    if ScreenPos > AColumn then begin
      AColOffset := AColumn - ScreenPosOld;
      FUnAdjustedPhysToLogResult := BytePos;
      FUnAdjustedPhysToLogColOffs := AColOffset;
      if (AColOffset <> 0) then begin
        if lpfAdjustToCharBegin in AFlags then begin
          FAdjustedPhysToLogOrigin := ScreenPosOld;
          AColOffset := 0;
        end
        else if lpfAdjustToNextChar in AFlags then begin
          FAdjustedPhysToLogOrigin := ScreenPos;
          AColOffset := 0;
          while (BytePos < FCurrentWidthsLen) and ((FCurrentWidths[BytePos] and PCWMask) = 0) do
            inc(BytePos);
          inc(BytePos);
        end;
      end;
      exit(BytePos);
    end;
  end;
  {$ENDIF}

  // Column at/past end of line
  AColOffset := 0;
  Result := BytePos + 1 + AColumn - ScreenPos;
  FUnAdjustedPhysToLogResult := Result;
end;

function TSynLogicalPhysicalConvertor.LogicalToPhysical(AIndex,
  ABytePos: Integer): Integer;
var
  ColOffs: Integer;
begin
  ColOffs := 0;
  Result := LogicalToPhysical(AIndex, ABytePos, ColOffs);
end;

function TSynLogicalPhysicalConvertor.LogicalToPhysical(AIndex, ABytePos: Integer;
  var AColOffset: Integer; ACharSide: TSynLogCharSide; AFlags: TSynLogPhysFlags): Integer;
var
  i: integer;
  RtlLen: Integer;
begin
  Result := 0;
  FAdjustedLogToPhysOrigin := ABytePos;
  {$IFDEF AssertSynMemIndex}
  if (ABytePos <= 0) then
    raise Exception.Create(Format('Bad Bytpos for PhystoLogical BytePos=%d ColOffs= %d idx= %d',[ABytePos, AColOffset, AIndex]));
  {$ENDIF}

  assert(ABytePos > 0, 'What uses abytepos = 0 ?');
  {$IFnDEF WithOutSynBiDi}
  if (ABytePos = 0) or ((ABytePos = 1) and (AColOffset=0) and (ACharSide in [cslBefore, cslFollowLtr])) then
    exit(ABytePos);
  {$ELSE}
  if (ABytePos = 0) or ((ABytePos = 1) and (AColOffset=0)) then
    exit(ABytePos);
  {$ENDIF}
  PrepareWidthsForLine(AIndex);

  dec(ABytePos);
  if ABytePos < FCurrentWidthsLen then begin
    if (FCurrentWidths[ABytePos] and PCWMask) = 0 then begin
      if lpfAdjustToCharBegin in AFlags then begin
        while (ABytePos > 0) and ((FCurrentWidths[ABytePos] and PCWMask) = 0) do
          dec(ABytePos);
      end
      else
      if lpfAdjustToNextChar in AFlags then begin
        while (ABytePos < FCurrentWidthsLen) and ((FCurrentWidths[ABytePos] and PCWMask) = 0) do
          inc(ABytePos);
      end;
      FAdjustedLogToPhysOrigin := ABytePos+1;
      assert((FCurrentWidths[ABytePos] and PCWMask) <> 0, 'LogicalToPhysical at char');
    end;
    if ABytePos < FCurrentWidthsLen then
      AColOffset := Min(AColOffset, (FCurrentWidths[ABytePos] and PCWMask)-1);
    Result := 1 + AColOffset;
  end;

  if ABytePos >= FCurrentWidthsLen then
  begin
    Result := 1 + ABytePos - FCurrentWidthsLen;
    if Result > 1 then
      ACharSide := cslAfter;
    ABytePos := FCurrentWidthsLen;
    AColOffset := 0;
  end;

  RtlLen := 0;
  for i := 0 to ABytePos - 1 do begin
    if ((FCurrentWidths[i] and PCWMask) = 0) then
      continue;
    {$IFnDEF WithOutSynBiDi}
    If ((FCurrentWidths[i] and PCWFlagRTL) <> 0) then
      RtlLen := RtlLen + (FCurrentWidths[i] and PCWMask)
    else begin
      Result := Result + RtlLen + (FCurrentWidths[i] and PCWMask);
      RtlLen := 0;
    end;
    {$ELSE}
    Result := Result + (FCurrentWidths[i] and PCWMask);
    {$ENDIF}
  end;
  {$IFnDEF WithOutSynBiDi}

  if (ABytePos < FCurrentWidthsLen) and
     ((FCurrentWidths[ABytePos] and PCWFlagRTL) <> 0) and // Next Char is Rtl
     ( (RtlLen > 0) or                           // char is in the middle of the RTL run
       (ACharSide in [cslAfter, cslFollowRtl])   // may be before rtl run, but want to include entire run (1st log rtl-char is phys at other end)
     )
  then begin
    i := ABytePos;
    // Add the remaining RTL chars
    while (i < FCurrentWidthsLen) and
          ( ((FCurrentWidths[i] and PCWFlagRTL) <> 0) or ((FCurrentWidths[i] and PCWMask) = 0) )
    do begin
      Result := Result + (FCurrentWidths[i] and PCWMask);
      inc(i);
    end;
  end
  else
  if   (ABytePos > FCurrentWidthsLen) or
    (ACharSide in [cslAfter, cslFollowLtr]) and
    (  (ABytePos = FCurrentWidthsLen) or
     ( (ABytePos < FCurrentWidthsLen) and ((FCurrentWidths[ABytePos] and PCWFlagRTL) = 0) )
    ) // next char is LTR
  then
    Result := Result + RtlLen;
  {$ENDIF}
end;

{ TSynEditStrings }

constructor TSynEditStrings.Create;
begin
  FLogPhysConvertor := TSynLogicalPhysicalConvertor.Create(self);
  FLogPhysConvertorTmp := TSynLogicalPhysicalConvertor.Create(self);
  inherited Create;
  IsUtf8 := True;
end;

destructor TSynEditStrings.Destroy;
begin
  FreeAndNil(FLogPhysConvertor);
  FreeAndNil(FLogPhysConvertorTmp);
  inherited Destroy;
end;

procedure TSynEditStrings.BeginUpdate(Sender: TObject);
begin
  if FSenderUpdateCount = 0 then
    SetUpdateState(true, Sender);
  inc(FSenderUpdateCount);
end;

procedure TSynEditStrings.EndUpdate(Sender: TObject);
begin
  If FSenderUpdateCount>0 then
    Dec(FSenderUpdateCount);
  if FSenderUpdateCount=0 then
    SetUpdateState(False, Sender);
end;

function TSynEditStrings.IsUpdating: Boolean;
begin
  Result := (FSenderUpdateCount > 0) or (UpdateCount > 0);
end;

procedure TSynEditStrings.SendHighlightChanged(aIndex, aCount: Integer);
begin
  SendNotification(senrHighlightChanged, Self, aIndex, aCount);
end;

function TSynEditStrings.LogicPosAddChars(const ALine: String; ALogicalPos, ACount: integer;
  AllowPastEOL: Boolean): Integer;
begin
  if AllowPastEOL
  then Result := LogicPosAddChars(ALine, ALogicalPos, ACount, [lpAllowPastEol])
  else Result := LogicPosAddChars(ALine, ALogicalPos, ACount, []);
end;

function TSynEditStrings.LogicPosAdjustToChar(const ALine: String; ALogicalPos: integer;
  ANext: Boolean; AllowPastEOL: Boolean): Integer;
var
  f: LPosFlags;
begin
  if AllowPastEOL
  then f := [lpAllowPastEol]
  else f := [];
  if ANext
  then f := f + [lpAdjustToNext];
  Result := LogicPosAdjustToChar(ALine, ALogicalPos, f);
end;

function TSynEditStrings.GetPhysicalCharWidths(Index: Integer): TPhysicalCharWidths;
var
  s: PChar;
  ALen: Integer;
begin
  s := GetPChar(Index, ALen);
  Result := GetPhysicalCharWidths(s, ALen, Index);
end;

function TSynEditStrings.GetPhysicalCharWidths(Line: PChar; LineLen,
  Index: Integer): TPhysicalCharWidths;
begin
  Result := nil;
  if LineLen = 0 then
    exit;
  SetLength(Result{%H-}, LineLen);
  DoGetPhysicalCharWidths(Line, LineLen, Index, @Result[0]);
end;

procedure TSynEditStrings.GetPhysicalCharWidths(Index: Integer;
  var AResult: TPhysicalCharWidths; out ALen: Integer);
var
  s: PChar;
begin
  s := GetPChar(Index, ALen);
  if ALen = 0 then
    exit;
  if Length(AResult) < ALen then
    SetLength(AResult, ALen);
  DoGetPhysicalCharWidths(s, ALen, Index, @AResult[0]);
end;

function TSynEditStrings.GetDisplayView: TLazSynDisplayView;
begin
  Result := nil;
end;

function TSynEditStrings.GetViewedCount: Integer;
begin
  Result := Count;
end;

function TSynEditStrings.GetViewedLines(Index: integer): string;
begin
  Result := Strings[Index];
end;

procedure TSynEditStrings.SetTextStr(const Value : string);
var
  StartPos: PChar;
  p: PChar;
  Last: PChar;
  sl: TStringList;
  s: string;
begin
  if Value='' then begin
    Clear;
    exit;
  end;
  BeginUpdate;
  sl:=TStringList.Create;
  try
    Clear;
    p:=PChar(Value);
    StartPos:=p;
    Last:=p+length(Value);
    while p<Last do begin
      if not (p^ in [#10,#13]) then begin
        inc(p);
      end else begin
        SetLength(s{%H-},p-StartPos);
        if s<>'' then
          System.Move(StartPos^,s[1],length(s));
        sl.Add(s);
        if (p[1] in [#10,#13]) and (p[1]<>p^) then
          inc(p);
        inc(p);
        StartPos:=p;
      end;
    end;
    if StartPos<Last then begin
      SetLength(s,Last-StartPos);
      if s<>'' then
        System.Move(StartPos^,s[1],length(s));
      sl.Add(s);
    end;
    AddStrings(sl);
  finally
    sl.Free;
    EndUpdate;
  end;
end;

function TSynEditStrings.GetViewChangeStamp: int64;
begin
  Result := 0;
end;

procedure TSynEditStrings.SetUpdateState(Updating: Boolean);
begin
  // Update/check "FSenderUpdateCount", to avoid extra locking/unlocking
  if Updating then
    BeginUpdate(nil)
  else
    EndUpdate(nil);
end;

procedure TSynEditStrings.InternalGetInfoForViewedXY(AViewedXY: TPhysPoint;
  AFlags: TViewedXYInfoFlags; out AViewedXYInfo: TViewedXYInfo;
  ALogPhysConvertor: TSynLogicalPhysicalConvertor);
var
  Offs: Integer;
begin
  AViewedXYInfo.CorrectedViewedXY := AViewedXY;
  AViewedXYInfo.FirstViewedX := 1;

  if AFlags * [vifReturnPhysXY, vifReturnLogEOL] <> [] then begin
    AViewedXYInfo.PhysXY := AViewedXYInfo.CorrectedViewedXY;
  end;

  if AFlags * [vifReturnLogXY, vifReturnPhysOffset] <> [] then begin
    AViewedXYInfo.LogicalXY.y := AViewedXYInfo.PhysXY.y;
    if vifAdjustLogXYToNextChar in AFlags then
      AViewedXYInfo.LogicalXY.x := ALogPhysConvertor.PhysicalToLogical(ToIdx(AViewedXYInfo.PhysXY.y), AViewedXYInfo.PhysXY.x, Offs, cspDefault, [lpfAdjustToNextChar])
    else
      AViewedXYInfo.LogicalXY.x := ALogPhysConvertor.PhysicalToLogical(ToIdx(AViewedXYInfo.PhysXY.y), AViewedXYInfo.PhysXY.x, Offs, cspDefault, [lpfAdjustToCharBegin]);
    AViewedXYInfo.LogicalXY.Offs := ALogPhysConvertor.UnAdjustedPhysToLogColOffs;
    AViewedXYInfo.PhysBoundOffset := AViewedXYInfo.PhysXY.x - ALogPhysConvertor.AdjustedPhysToLogOrigin;
  end;

  if AFlags * [vifReturnLogEOL] <> [] then
    AViewedXYInfo.LogEOLPos := ALogPhysConvertor.CurrentWidthsCount + 1;

// TODO wrap subline bounds
end;

function TSynEditStrings.LogicalToPhysicalPos(const p : TPoint) : TPoint;
begin
  Result := p;
  Result.X := FLogPhysConvertor.LogicalToPhysical(p.y - 1, p.x);
//  if Result.Y - 1 < Count then
//    Result.X:=LogicalToPhysicalCol(self[Result.Y - 1], Result.Y, Result.X);
end;

function TSynEditStrings.LogicalToPhysicalCol(const Line : String;
  Index, LogicalPos: integer) : integer;
var
  CharWidths: TPhysicalCharWidths;
begin
  CharWidths := GetPhysicalCharWidths(Pchar(Line), length(Line), Index);

  FLogPhysConvertorTmp.SetWidthsForLine(-9, CharWidths);
  Result := FLogPhysConvertorTmp.LogicalToPhysical(-9 , LogicalPos);
end;

function TSynEditStrings.PhysicalToLogicalPos(const p : TPoint) : TPoint;
begin
  Result := p;
  Result.X := FLogPhysConvertor.PhysicalToLogical(p.y - 1, p.x);
//  if (Result.Y>=1) and (Result.Y <= Count) then
//    Result.X:=PhysicalToLogicalCol(self[Result.Y - 1], Result.Y - 1, Result.X);
end;

function TSynEditStrings.PhysicalToLogicalCol(const Line : string;
  Index, PhysicalPos : integer) : integer;
var
  CharWidths: TPhysicalCharWidths;
begin
  CharWidths := GetPhysicalCharWidths(PChar(Line), length(Line), Index);

  FLogPhysConvertorTmp.SetWidthsForLine(-9, CharWidths);
  Result := FLogPhysConvertorTmp.PhysicalToLogical(-9 , PhysicalPos);
end;

function TSynEditStrings.TextToViewIndex(aTextIndex: TLineIdx): TLineIdx;
begin
  Result := aTextIndex;
end;

function TSynEditStrings.ViewToTextIndex(aViewIndex: TLineIdx): TLineIdx;
begin
  Result := aViewIndex;
end;

function TSynEditStrings.AddVisibleOffsetToTextIndex(aTextIndex: TLineIdx;
  LineOffset: Integer): TLineIdx;
begin
  Result := aTextIndex + LineOffset;
end;

function TSynEditStrings.IsTextIdxVisible(aTextIndex: TLineIdx): Boolean;
begin
  Result := True;
end;

procedure TSynEditStrings.GetInfoForViewedXY(AViewedXY: TPhysPoint;
  AFlags: TViewedXYInfoFlags; out AViewedXYInfo: TViewedXYInfo);
begin
  InternalGetInfoForViewedXY(AViewedXY, AFlags, AViewedXYInfo,
    LogPhysConvertor);
end;

function TSynEditStrings.ViewXYToTextXY(APhysViewXY: TPhysPoint): TPhysPoint;
begin
  Result := APhysViewXY;
end;

function TSynEditStrings.TextXYToViewXY(APhysTextXY: TPhysPoint): TPhysPoint;
begin
  Result := APhysTextXY;
end;

{ TSynEditStringsLinked }

function TSynEditStringsLinked.Add(const S: string): integer;
begin
  Result := fSynStrings.Add(S);
end;

procedure TSynEditStringsLinked.AddStrings(AStrings: TStrings);
begin
  fSynStrings.AddStrings(AStrings);
end;

procedure TSynEditStringsLinked.Clear;
begin
  fSynStrings.Clear;
end;

procedure TSynEditStringsLinked.Delete(Index: integer);
begin
  fSynStrings.Delete(Index);
end;

procedure TSynEditStringsLinked.DeleteLines(Index, NumLines: integer);
begin
  fSynStrings.DeleteLines(Index, NumLines);
end;

procedure TSynEditStringsLinked.Insert(Index: integer; const S: string);
begin
  fSynStrings.Insert(Index, S);
end;

procedure TSynEditStringsLinked.InsertLines(Index, NumLines: integer);
begin
  fSynStrings.InsertLines(Index, NumLines);
end;

procedure TSynEditStringsLinked.InsertStrings(Index: integer; NewStrings: TStrings);
begin
  fSynStrings.InsertStrings(Index, NewStrings);
end;

function TSynEditStringsLinked.GetPChar(ALineIndex: Integer; out ALen: Integer): PChar;
begin
  Result := fSynStrings.GetPChar(ALineIndex, ALen);
end;

procedure TSynEditStringsLinked.SetIsUndoing(const AValue: Boolean);
begin
  fSynStringsState.IsUndoing := AValue;
end;

function TSynEditStringsLinked.GetIsUndoing: Boolean;
begin
  Result := fSynStringsState.IsUndoing;
end;

procedure TSynEditStringsLinked.SetIsRedoing(const AValue: Boolean);
begin
  fSynStringsState.IsRedoing := AValue;
end;

function TSynEditStringsLinked.GetIsRedoing: Boolean;
begin
  Result := fSynStringsState.IsRedoing;
end;

procedure TSynEditStringsLinked.SetSynStrings(AValue: TSynEditStrings);
begin
  fSynStrings := AValue;

  if fSynStrings = nil then begin
    fSynStringsEditing := fSynStrings;
    fSynStringsState := fSynStrings;
    fSynStringsLogPos := fSynStrings;
    fSynStringsXYMap := fSynStrings;
    fSynStringsNotify := fSynStrings;

    exit;
  end;

  // Fast forward some methods
  if (TMethod(@fSynStrings.EditInsert).Code      = Pointer(@TSynEditStringsLinked.EditInsert)) and
     (TMethod(@fSynStrings.EditDelete).Code      = Pointer(@TSynEditStringsLinked.EditDelete)) and
     (TMethod(@fSynStrings.EditReplace).Code     = Pointer(@TSynEditStringsLinked.EditReplace)) and
     (TMethod(@fSynStrings.EditLineBreak).Code   = Pointer(@TSynEditStringsLinked.EditLineBreak)) and
     (TMethod(@fSynStrings.EditLineJoin).Code    = Pointer(@TSynEditStringsLinked.EditLineJoin)) and
     (TMethod(@fSynStrings.EditLinesInsert).Code = Pointer(@TSynEditStringsLinked.EditLinesInsert)) and
     (TMethod(@fSynStrings.EditLinesDelete).Code = Pointer(@TSynEditStringsLinked.EditLinesDelete)) and
     (TMethod(@fSynStrings.EditUndo).Code        = Pointer(@TSynEditStringsLinked.EditUndo)) and
     (TMethod(@fSynStrings.EditRedo).Code        = Pointer(@TSynEditStringsLinked.EditRedo))
  then
    fSynStringsEditing := TSynEditStringsLinked(fSynStrings).fSynStringsEditing // forward directly to next view with edit actions
  else
    fSynStringsEditing := fSynStrings;

  // Methods that are usually only implemented by the real text-buffer
  if (TMethod(@fSynStrings.GetIsInEditAction).Code  = Pointer(@TSynEditStringsLinked.GetIsInEditAction)) and
     (TMethod(@fSynStrings.IncIsInEditAction).Code  = Pointer(@TSynEditStringsLinked.IncIsInEditAction)) and
     (TMethod(@fSynStrings.DecIsInEditAction).Code  = Pointer(@TSynEditStringsLinked.DecIsInEditAction)) and
     (TMethod(@fSynStrings.GetTextChangeStamp).Code = Pointer(@TSynEditStringsLinked.GetTextChangeStamp)) and
     (TMethod(@fSynStrings.GetUndoList).Code        = Pointer(@TSynEditStringsLinked.GetUndoList)) and
     (TMethod(@fSynStrings.GetRedoList).Code        = Pointer(@TSynEditStringsLinked.GetRedoList)) and
     (TMethod(@fSynStrings.GetCurUndoList).Code     = Pointer(@TSynEditStringsLinked.GetCurUndoList)) and
     (TMethod(@fSynStrings.SetIsUndoing).Code       = Pointer(@TSynEditStringsLinked.SetIsUndoing)) and
     (TMethod(@fSynStrings.GetIsUndoing).Code       = Pointer(@TSynEditStringsLinked.GetIsUndoing)) and
     (TMethod(@fSynStrings.SetIsRedoing).Code       = Pointer(@TSynEditStringsLinked.SetIsRedoing)) and
     (TMethod(@fSynStrings.GetIsRedoing).Code       = Pointer(@TSynEditStringsLinked.GetIsRedoing)) and
     (TMethod(@fSynStrings.SetUpdateState).Code     = Pointer(@TSynEditStringsLinked.SetUpdateState)) and
     // ...Range / GetCount => may get groups of their own
     (TMethod(@fSynStrings.GetRange).Code           = Pointer(@TSynEditStringsLinked.GetRange)) and
     (TMethod(@fSynStrings.PutRange).Code           = Pointer(@TSynEditStringsLinked.PutRange)) and
     (TMethod(@fSynStrings.GetCount).Code           = Pointer(@TSynEditStringsLinked.GetCount))
  then
    fSynStringsState := TSynEditStringsLinked(fSynStrings).fSynStringsState
  else
    fSynStringsState := fSynStrings;

//    GetCount

  if (TMethod(@fSynStrings.LogicPosAddChars).Code     = Pointer(@TSynEditStringsLinked.LogicPosAddChars)) and
     (TMethod(@fSynStrings.LogicPosIsAtChar).Code     = Pointer(@TSynEditStringsLinked.LogicPosIsAtChar)) and
     (TMethod(@fSynStrings.LogicPosAdjustToChar).Code = Pointer(@TSynEditStringsLinked.LogicPosAdjustToChar))
  then
    fSynStringsLogPos := TSynEditStringsLinked(fSynStrings).fSynStringsLogPos
  else
    fSynStringsLogPos := fSynStrings;

  if (TMethod(@fSynStrings.DoGetPhysicalCharWidths).Code      = Pointer(@TSynEditStringsLinked.DoGetPhysicalCharWidths))
  then
    fSynStringsPhys := TSynEditStringsLinked(fSynStrings).fSynStringsPhys
  else
    fSynStringsPhys := fSynStrings;


  if (TMethod(@fSynStrings.ViewToTextIndex).Code      = Pointer(@TSynEditStringsLinked.ViewToTextIndex)) and
     (TMethod(@fSynStrings.TextToViewIndex).Code      = Pointer(@TSynEditStringsLinked.TextToViewIndex)) and
     (TMethod(@fSynStrings.ViewXYToTextXY).Code       = Pointer(@TSynEditStringsLinked.ViewXYToTextXY)) and
     (TMethod(@fSynStrings.TextXYToViewXY).Code       = Pointer(@TSynEditStringsLinked.TextXYToViewXY))
  then
    fSynStringsXYMap := TSynEditStringsLinked(fSynStrings).fSynStringsXYMap
  else
    fSynStringsXYMap := fSynStrings;

//    GetCapacity
//    SetCapacity
//    Get
//    GetObject
//    Put
//    PutObject

  if (TMethod(@fSynStrings.IgnoreSendNotification).Code = Pointer(@TSynEditStringsLinked.IgnoreSendNotification)) and
     (TMethod(@fSynStrings.SendNotification).Code       = Pointer(@TSynEditStringsLinked.SendNotification)) and
     (TMethod(@fSynStrings.SendNotification).Code       = Pointer(@TSynEditStringsLinked.SendNotification)) and
     (TMethod(@fSynStrings.SendNotification).Code       = Pointer(@TSynEditStringsLinked.SendNotification)) and
     (TMethod(@fSynStrings.FlushNotificationCache).Code = Pointer(@TSynEditStringsLinked.FlushNotificationCache))
  then
    fSynStringsNotify := TSynEditStringsLinked(fSynStrings).fSynStringsNotify
  else
    fSynStringsNotify := fSynStrings;
end;

function TSynEditStringsLinked.GetIsUtf8: Boolean;
begin
  Result := FSynStrings.IsUtf8;
end;

procedure TSynEditStringsLinked.SetIsUtf8(const AValue: Boolean);
begin
  if FSynStrings <> nil then
    FSynStrings.IsUtf8 := AValue;
end;

function TSynEditStringsLinked.GetTextChangeStamp: int64;
begin
  Result := fSynStringsState.GetTextChangeStamp;
end;

function TSynEditStringsLinked.GetViewChangeStamp: int64;
begin
  Result := fSynStrings.GetViewChangeStamp;
end;

//Ranges
function TSynEditStringsLinked.GetRange(Index: Pointer): TSynManagedStorageMem;
begin
  Result:= fSynStringsState.Ranges[Index];
end;

procedure TSynEditStringsLinked.PutRange(Index: Pointer; const ARange: TSynManagedStorageMem);
begin
  fSynStringsState.Ranges[Index] := ARange;
end;

function TSynEditStringsLinked.GetViewedCount: Integer;
begin
  Result := fSynStrings.ViewedCount;
end;

function TSynEditStringsLinked.GetViewedLines(Index: integer): string;
begin
  Result := fSynStrings.ViewedLines[Index];
end;

function TSynEditStringsLinked.GetExpandedString(Index: integer): string;
begin
  Result:= fSynStrings.GetExpandedString(Index);
end;

function TSynEditStringsLinked.GetLengthOfLongestLine: integer;
begin
  Result:= fSynStrings.GetLengthOfLongestLine;
end;

function TSynEditStringsLinked.GetRedoList: TSynEditUndoList;
begin
  Result := fSynStringsState.GetRedoList;
end;

function TSynEditStringsLinked.GetUndoList: TSynEditUndoList;
begin
  Result := fSynStringsState.GetUndoList;
end;

function TSynEditStringsLinked.GetCurUndoList: TSynEditUndoList;
begin
  Result := fSynStringsState.GetCurUndoList;
end;

// Count
function TSynEditStringsLinked.GetCount: integer;
begin
  Result:= fSynStrings.Count;
end;

function TSynEditStringsLinked.GetCapacity: integer;
begin
  Result:= fSynStrings.Capacity;
end;

procedure TSynEditStringsLinked.SetCapacity(NewCapacity: integer);
begin
  fSynStrings.Capacity := NewCapacity;
end;

function TSynEditStringsLinked.Get(Index: integer): string;
begin
  Result:= fSynStrings.Get(Index);
end;

function TSynEditStringsLinked.GetObject(Index: integer): TObject;
begin
  Result:= fSynStrings.GetObject(Index);
end;

procedure TSynEditStringsLinked.Put(Index: integer; const S: string);
begin
  fSynStrings.Put(Index, S);
end;

procedure TSynEditStringsLinked.PutObject(Index: integer; AObject: TObject);
begin
  fSynStrings.PutObject(Index, AObject);
end;

//function TSynEditStringsLinked.GetPhysicalCharWidths(Line: PChar; LineLen, Index: Integer): TPhysicalCharWidths;
//begin
//  Result := fSynStrings.GetPhysicalCharWidths(Line, LineLen, Index);
//end;

procedure TSynEditStringsLinked.SetUpdateState(Updating: Boolean; Sender: TObject);
begin
  // Update/check "FSenderUpdateCount" in linked lists too (avoid extra locking/unlocking)
  if Updating then
    fSynStringsState.BeginUpdate(Sender)
  else
    fSynStringsState.EndUpdate(Sender);
end;

procedure TSynEditStringsLinked.DoGetPhysicalCharWidths(Line: PChar;
  LineLen, Index: Integer; PWidths: PPhysicalCharWidth);
begin
  fSynStringsPhys.DoGetPhysicalCharWidths(Line, LineLen, Index, PWidths);
end;

procedure TSynEditStringsLinked.InternalGetInfoForViewedXY(
  AViewedXY: TPhysPoint; AFlags: TViewedXYInfoFlags; out
  AViewedXYInfo: TViewedXYInfo; ALogPhysConvertor: TSynLogicalPhysicalConvertor
  );
begin
  fSynStrings.InternalGetInfoForViewedXY(AViewedXY, AFlags, AViewedXYInfo, ALogPhysConvertor);
end;

function TSynEditStringsLinked.GetDisplayView: TLazSynDisplayView;
begin
  Result := fSynStrings.GetDisplayView;
end;

procedure TSynEditStringsLinked.AddGenericHandler(
  AReason: TSynEditNotifyReason; AHandler: TMethod);
begin
  Manager.AddGenericHandler(AReason, AHandler);
end;

procedure TSynEditStringsLinked.RemoveGenericHandler(
  AReason: TSynEditNotifyReason; AHandler: TMethod);
begin
  Manager.RemoveGenericHandler(AReason, AHandler);
end;

procedure TSynEditStringsLinked.SetManager(AManager: TSynTextViewsManager);
begin
  FManager := AManager;
end;

procedure TSynEditStringsLinked.EditInsert(LogX, LogY: Integer; AText: String);
begin
  fSynStringsEditing.EditInsert(LogX, LogY, AText);
end;

function TSynEditStringsLinked.EditDelete(LogX, LogY, ByteLen: Integer): String;
begin
  Result := fSynStringsEditing.EditDelete(LogX, LogY, ByteLen);
end;

function TSynEditStringsLinked.EditReplace(LogX, LogY, ByteLen: Integer;
  AText: String): String;
begin
  Result:=fSynStringsEditing.EditReplace(LogX, LogY, ByteLen, AText);
end;

procedure TSynEditStringsLinked.EditLineBreak(LogX, LogY: Integer);
begin
  fSynStringsEditing.EditLineBreak(LogX, LogY);
end;

procedure TSynEditStringsLinked.EditLineJoin(LogY: Integer;
  FillText: String = '');
begin
  fSynStringsEditing.EditLineJoin(LogY, FillText);
end;

procedure TSynEditStringsLinked.EditLinesInsert(LogY, ACount: Integer; AText: String = '');
begin
  fSynStringsEditing.EditLinesInsert(LogY, ACount, AText);
end;

procedure TSynEditStringsLinked.EditLinesDelete(LogY, ACount: Integer);
begin
  fSynStringsEditing.EditLinesDelete(LogY, ACount);
end;

procedure TSynEditStringsLinked.EditUndo(Item: TSynEditUndoItem);
begin
  fSynStringsEditing.EditUndo(Item);
end;

procedure TSynEditStringsLinked.EditRedo(Item: TSynEditUndoItem);
begin
  fSynStringsEditing.EditRedo(Item);
end;

procedure TSynEditStringsLinked.SendNotification(AReason: TSynEditNotifyReason;
  ASender: TSynEditStrings; aIndex, aCount: Integer);
begin
  fSynStringsNotify.SendNotification(AReason, ASender, aIndex, aCount);
end;

procedure TSynEditStringsLinked.SendNotification(AReason: TSynEditNotifyReason;
  ASender: TSynEditStrings; aIndex, aCount: Integer;
  aBytePos: Integer; aLen: Integer; aTxt: String);
begin
  fSynStringsNotify.SendNotification(AReason, ASender, aIndex, aCount, aBytePos, aLen, aTxt);
end;

procedure TSynEditStringsLinked.SendNotification(AReason: TSynEditNotifyReason;
  ASender: TObject);
begin
  fSynStringsNotify.SendNotification(AReason, ASender);
end;

procedure TSynEditStringsLinked.FlushNotificationCache;
begin
  fSynStringsNotify.FlushNotificationCache;
end;

procedure TSynEditStringsLinked.AddModifiedHandler(
  AReason: TSynEditNotifyReason; AHandler: TStringListLinesModifiedEvent);
begin
  assert(AReason in [senrLinesModified], 'AddModifiedHandler');
  AddGenericHandler(AReason, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.AddChangeHandler(AReason: TSynEditNotifyReason;
  AHandler: TStringListLineCountEvent);
begin
  assert(AReason in [senrLineCount, senrLineChange, senrHighlightChanged, senrLineMappingChanged], 'AddChangeHandler');
  AddGenericHandler(AReason, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.AddNotifyHandler(AReason: TSynEditNotifyReason;
  AHandler: TNotifyEvent);
begin
  assert(AReason in [senrCleared..senrEndUndoRedo], 'AddNotifyHandler');
  AddGenericHandler(AReason, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.RemoveModifiedHandler(
  AReason: TSynEditNotifyReason; AHandler: TStringListLinesModifiedEvent);
begin
  assert(AReason in [senrLinesModified], 'RemoveModifiedHandler');
  RemoveGenericHandler(AReason, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.RemoveChangeHandler(
  AReason: TSynEditNotifyReason; AHandler: TStringListLineCountEvent);
begin
  assert(AReason in [senrLineCount, senrLineChange, senrHighlightChanged, senrLineMappingChanged], 'RemoveChangeHandler');
  RemoveGenericHandler(AReason, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.RemoveNotifyHandler(
  AReason: TSynEditNotifyReason; AHandler: TNotifyEvent);
begin
  assert(AReason in [senrCleared..senrEndUndoRedo], 'RemoveNotifyHandler');
  RemoveGenericHandler(AReason, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.AddEditHandler(
  AHandler: TStringListLineEditEvent);
begin
  AddGenericHandler(senrEditAction, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.RemoveEditHandler(
  AHandler: TStringListLineEditEvent);
begin
  RemoveGenericHandler(senrEditAction, TMethod(AHandler));
end;

procedure TSynEditStringsLinked.RemoveHanlders(AOwner: TObject);
begin
  RemoveHandlers(AOwner);
end;

procedure TSynEditStringsLinked.RemoveHandlers(AOwner: TObject);
begin
  Manager.RemoveHandlers(AOwner);
end;

function TSynEditStringsLinked.LogicPosAddChars(const ALine: String; ALogicalPos,
  ACount: integer; AFlags: LPosFlags): Integer;
begin
  Result := fSynStringsLogPos.LogicPosAddChars(ALine, ALogicalPos, ACount, AFlags);
end;

function TSynEditStringsLinked.LogicPosIsAtChar(const ALine: String; ALogicalPos: integer;
  AFlags: LPosFlags): Boolean;
begin
  Result := fSynStringsLogPos.LogicPosIsAtChar(ALine, ALogicalPos, AFlags);
end;

function TSynEditStringsLinked.LogicPosAdjustToChar(const ALine: String; ALogicalPos: integer;
  AFlags: LPosFlags): Integer;
begin
  Result := fSynStringsLogPos.LogicPosAdjustToChar(ALine, ALogicalPos, AFlags);
end;

function TSynEditStringsLinked.TextToViewIndex(aTextIndex: TLineIdx): TLineIdx;
begin
  Result := fSynStringsXYMap.TextToViewIndex(aTextIndex);
end;

function TSynEditStringsLinked.ViewToTextIndex(aViewIndex: TLineIdx): TLineIdx;
begin
  Result := fSynStringsXYMap.ViewToTextIndex(aViewIndex);
end;

function TSynEditStringsLinked.AddVisibleOffsetToTextIndex(
  aTextIndex: TLineIdx; LineOffset: Integer): TLineIdx;
begin
  Result := fSynStrings.AddVisibleOffsetToTextIndex(aTextIndex, LineOffset);
end;

function TSynEditStringsLinked.IsTextIdxVisible(aTextIndex: TLineIdx): Boolean;
begin
  Result := fSynStrings.IsTextIdxVisible(aTextIndex);
end;

function TSynEditStringsLinked.ViewXYToTextXY(APhysViewXY: TPhysPoint
  ): TPhysPoint;
begin
  Result := fSynStringsXYMap.ViewXYToTextXY(APhysViewXY);
end;

function TSynEditStringsLinked.TextXYToViewXY(APhysTextXY: TPhysPoint
  ): TPhysPoint;
begin
  Result := fSynStringsXYMap.TextXYToViewXY(APhysTextXY);
end;

procedure TSynEditStringsLinked.IgnoreSendNotification(AReason: TSynEditNotifyReason;
  IncIgnore: Boolean);
begin
  fSynStringsNotify.IgnoreSendNotification(AReason, IncIgnore);
end;

function TSynEditStringsLinked.GetIsInEditAction: Boolean;
begin
  Result := fSynStringsState.GetIsInEditAction;
end;

procedure TSynEditStringsLinked.IncIsInEditAction;
begin
  fSynStringsState.IncIsInEditAction;
end;

procedure TSynEditStringsLinked.DecIsInEditAction;
begin
  fSynStringsState.DecIsInEditAction;
end;

{ TSynTextViewsManager }

function TSynTextViewsManager.GetSynTextView(Index: integer): TSynEditStringsLinked;
begin
  Result := TSynEditStringsLinked(FTextViewsList[Index]);
end;

function TSynTextViewsManager.GetSynTextViewByClass(
  Index: TSynEditStringsLinkedClass): TSynEditStringsLinked;
var
  i: Integer;
begin
  Result := nil;
  for i := 0 to FTextViewsList.Count-1 do
    if TSynEditStringsLinked(FTextViewsList[i]).ClassType = Index then
      exit(TSynEditStringsLinked(FTextViewsList[i]));
end;

procedure TSynTextViewsManager.ReconnectViews;
var
  i: Integer;
  dsp: TLazSynDisplayView;
begin
  if FTextViewsList.Count = 0 then
    exit;
  SynTextView[0].NextLines := FTextBuffer;
  dsp := FTextBuffer.DisplayView;

  if SynTextView[0].DisplayView <> dsp then begin
    SynTextView[0].DisplayView.NextView := dsp;
    dsp := SynTextView[0].DisplayView;
  end;

  for i := 1 to FTextViewsList.Count-1 do begin
    SynTextView[i].NextLines := SynTextView[i-1];

    if (SynTextView[i].DisplayView <> dsp) then begin
      SynTextView[i].DisplayView.NextView := dsp;
      dsp := SynTextView[i].DisplayView;
    end;
  end;
  FTopViewChangedCallback(SynTextView[Count-1]);
end;

procedure TSynTextViewsManager.SetTextBuffer(AValue: TSynEditStringListBase);
var
  r: TSynEditNotifyReason;
  i: Integer;
begin
  if FTextBuffer <> nil then begin
    for r in TSynEditNotifyReason do
      for i := 0 to FNotifyLists[r].Count - 1 do
        FTextBuffer.RemoveManagedHandler(r, FNotifyLists[r][i]);
  end;
  if FTextBuffer = AValue then Exit;
  FTextBuffer := AValue;
  if FTextBuffer <> nil then begin
    for r in TSynEditNotifyReason do
      for i := 0 to FNotifyLists[r].Count - 1 do
        FTextBuffer.AddManagedHandler(r, FNotifyLists[r][i]);
    ReconnectViews;
  end;
end;

procedure TSynTextViewsManager.AddGenericHandler(AReason: TSynEditNotifyReason;
  AHandler: TMethod);
begin
  FNotifyLists[AReason].Add(AHandler);
  if FTextBuffer <> nil then
    FTextBuffer.AddManagedHandler(AReason, AHandler);
end;

procedure TSynTextViewsManager.RemoveGenericHandler(
  AReason: TSynEditNotifyReason; AHandler: TMethod);
begin
  FNotifyLists[AReason].Remove(AHandler);
  if FTextBuffer <> nil then
    FTextBuffer.RemoveManagedHandler(AReason, AHandler);
end;

procedure TSynTextViewsManager.RemoveHandlers(AOwner: TObject);
var
  i: TSynEditNotifyReason;
begin
  for i := low(TSynEditNotifyReason) to high(TSynEditNotifyReason) do
    FNotifyLists[i].RemoveAllMethodsOfObject(AOwner);
  if FTextBuffer <> nil then
    FTextBuffer.RemoveManagedHandlers(AOwner);
end;

constructor TSynTextViewsManager.Create(ATextBuffer: TSynEditStringListBase;
  ATopViewChangedCallback: TNotifyEvent);
var
  r: TSynEditNotifyReason;
begin
  for r := low(TSynEditNotifyReason) to high(TSynEditNotifyReason) do
    FNotifyLists[r] := TMethodList.Create;
  FTopViewChangedCallback := ATopViewChangedCallback;
  FTextViewsList := TList.Create;
  TextBuffer := ATextBuffer;
end;

destructor TSynTextViewsManager.Destroy;
var
  i: Integer;
  r: TSynEditNotifyReason;
begin
  // Destroy in reverse order / keep NextLines valid for each inner
  TextBuffer := nil;
  i := Count - 1;
  while i >= 0 do begin
    TSynEditStringsLinked(FTextViewsList[i]).Free;
    FTextViewsList.Delete(i);
    i := Count - 1;
  end;
  FTextViewsList.Free;
  for r := low(TSynEditNotifyReason) to high(TSynEditNotifyReason) do
    FNotifyLists[r].Destroy;
  inherited Destroy;
end;

procedure TSynTextViewsManager.AddTextView(aTextView: TSynEditStringsLinked;
  AsFirst: Boolean);
begin
  assert(aTextView.Manager=nil, 'TSynTextViewsManager.AddTextView: aTextView.Manager=nil');
  aTextView.SetManager(Self);
  if AsFirst then
    FTextViewsList.Insert(0, aTextView)
  else
    FTextViewsList.Add(aTextView);
  ReconnectViews;
end;

procedure TSynTextViewsManager.AddTextView(aTextView: TSynEditStringsLinked;
  AIndex: Integer);
begin
  assert(aTextView.Manager=nil, 'TSynTextViewsManager.AddTextView: aTextView.Manager=nil');
  aTextView.SetManager(Self);
  FTextViewsList.Insert(AIndex, aTextView);
  ReconnectViews;
end;

procedure TSynTextViewsManager.AddTextView(
  aTextView: TSynEditStringsLinked; AnAfter: TSynEditStringsLinked);
var
  i: Integer;
begin
  assert(aTextView.Manager=nil, 'TSynTextViewsManager.AddTextView: aTextView.Manager=nil');
  aTextView.SetManager(Self);
  i := FTextViewsList.IndexOf(AnAfter);
  if i >= 0 then
    FTextViewsList.Insert(i + 1, aTextView)
  else
    FTextViewsList.Add(aTextView);
  ReconnectViews;
end;

procedure TSynTextViewsManager.RemoveSynTextView(aTextView: TSynEditStringsLinked;
  aDestroy: Boolean);
var
  i: Integer;
begin
  i := FTextViewsList.IndexOf(aTextView);
  if i >= 0 then begin
    aTextView.SetManager(nil);
    if aDestroy then
      TSynEditStringsLinked(FTextViewsList[i]).Free;
    FTextViewsList.Delete(i);
    ReconnectViews
  end;
end;

function TSynTextViewsManager.IndexOf(aTextView: TSynEditStringsLinked
  ): integer;
begin
  Result := Count - 1;
  while (Result >= 0) and (aTextView <> TSynEditStringsLinked(FTextViewsList[Result])) do
    dec(Result);
end;

function TSynTextViewsManager.Count: Integer;
begin
  Result := FTextViewsList.Count;
end;

end.