PageRenderTime 70ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

/components/synedit/syneditpointclasses.pas

http://github.com/graemeg/lazarus
Pascal | 3487 lines | 2900 code | 399 blank | 188 comment | 379 complexity | c58c656596b082f0b7a7d16f58d7d30c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. {-------------------------------------------------------------------------------
    2. 

  2. The contents of this file are subject to the Mozilla Public License
    3. 

  3. Version 1.1 (the "License"); you may not use this file except in compliance
    4. 

  4. with the License. You may obtain a copy of the License at
    5. 

  5. http://www.mozilla.org/MPL/
    6. 

  6. 

  7. Software distributed under the License is distributed on an "AS IS" basis,
    8. 

  8. WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
    9. 

  9. the specific language governing rights and limitations under the License.
    10. 

  10. 

  11. Alternatively, the contents of this file may be used under the terms of the
    12. 

  12. GNU General Public License Version 2 or later (the "GPL"), in which case
    13. 

  13. the provisions of the GPL are applicable instead of those above.
    14. 

  14. If you wish to allow use of your version of this file only under the terms
    15. 

  15. of the GPL and not to allow others to use your version of this file
    16. 

  16. under the MPL, indicate your decision by deleting the provisions above and
    17. 

  17. replace them with the notice and other provisions required by the GPL.
    18. 

  18. If you do not delete the provisions above, a recipient may use your version
    19. 

  19. of this file under either the MPL or the GPL.
    20. 

  20. 

  21. -------------------------------------------------------------------------------}
    22. 

  22. 

  23. (* Naming Conventions:
    24. 

  24.   Byte = Logical: Refers to the location any TextToken has in the String.
    25. 

  25.          In Utf8String some TextToken can have more than one byte
    26. 

  26.   Char = Physical: Refers to the (x-)location on the screen matrix.
    27. 

  27.          Some TextToken (like tab) can spawn multiply char locations
    28. 

  28. *)
    29. 

  29. 

  30. unit SynEditPointClasses;
    31. 

  31. 

  32. {$I synedit.inc}
    33. 

  33. 

  34. {off $DEFINE SynCaretDebug}
    35. 

  35. 

  36. interface
    37. 

  37. 

  38. uses
    39. 

  39.   Classes, SysUtils, Controls, LCLProc, LCLType, LCLIntf, ExtCtrls, Graphics, Forms,
    40. 

  40.   {$IFDEF SYN_MBCSSUPPORT}
    41. 

  41.   Imm,
    42. 

  42.   {$ENDIF}
    43. 

  43.   LazSynEditText, SynEditTypes, SynEditMiscProcs;//, SynEditTextBuffer;
    44. 

  44. 

  45. type
    46. 

  46. 

  47.   TInvalidateLines = procedure(FirstLine, LastLine: integer) of Object;
    48. 

  48.   TLinesCountChanged = procedure(FirstLine, Count: integer) of Object;
    49. 

  49.   TMaxLeftCharFunc = function: Integer of object;
    50. 

  50. 

  51.   { TSynEditPointBase }
    52. 

  52. 

  53.   TSynEditPointBase = class
    54. 

  54.   private
    55. 

  55.     function GetLocked: Boolean;
    56. 

  56.   protected
    57. 

  57.     FLines: TSynEditStrings;
    58. 

  58.     FOnChangeList: TMethodList;
    59. 

  59.     FLockCount: Integer;
    60. 

  60.     procedure SetLines(const AValue: TSynEditStrings); virtual;
    61. 

  61.     procedure DoLock; virtual;
    62. 

  62.     Procedure DoUnlock; virtual;
    63. 

  63.   public
    64. 

  64.     constructor Create;
    65. 

  65.     constructor Create(Lines: TSynEditStrings);
    66. 

  66.     destructor Destroy; override;
    67. 

  67.     procedure AddChangeHandler(AHandler: TNotifyEvent);
    68. 

  68.     procedure RemoveChangeHandler(AHandler: TNotifyEvent);
    69. 

  69.     procedure Lock;
    70. 

  70.     Procedure Unlock;
    71. 

  71.     property  Lines: TSynEditStrings read FLines write SetLines;
    72. 

  72.     property Locked: Boolean read GetLocked;
    73. 

  73.   end;
    74. 

  74. 

  75.   TSynEditBaseCaret = class;
    76. 

  76.   TSynEditCaret = class;
    77. 

  77. 

  78.   TSynBlockPersistMode = (
    79. 

  79.     sbpDefault,
    80. 

  80.     sbpWeak,     // selstart/end are treated as outside the block
    81. 

  81.     sbpStrong    // selstart/end are treated as inside the block
    82. 

  82.   );
    83. 

  83. 

  84.   TSynBeforeSetSelTextEvent = procedure(Sender: TObject; AMode: TSynSelectionMode; ANewText: PChar) of object;
    85. 

  85. 

  86.   { TSynBeforeSetSelTextList }
    87. 

  87. 

  88.   TSynBeforeSetSelTextList = Class(TMethodList)
    89. 

  89.   public
    90. 

  90.     procedure CallBeforeSetSelTextHandlers(Sender: TObject; AMode: TSynSelectionMode; ANewText: PChar);
    91. 

  91.   end;
    92. 

  92. 

  93.   { TSynEditSelection }
    94. 

  94. 

  95.   TSynEditSelection = class(TSynEditPointBase)
    96. 

  96.   private
    97. 

  97.     FOnBeforeSetSelText: TSynBeforeSetSelTextList;
    98. 

  98.     FAutoExtend: Boolean;
    99. 

  99.     FCaret: TSynEditCaret;
    100. 

  100.     FHide: Boolean;
    101. 

  101.     FInternalCaret: TSynEditBaseCaret;
    102. 

  102.     FInvalidateLinesMethod: TInvalidateLines;
    103. 

  103.     FEnabled: Boolean;
    104. 

  104.     FHookedLines: Boolean;
    105. 

  105.     FIsSettingText: Boolean;
    106. 

  106.     FForceSingleLineSelected: Boolean;
    107. 

  107.     FActiveSelectionMode: TSynSelectionMode;
    108. 

  108.     FSelectionMode:       TSynSelectionMode;
    109. 

  109.     FStartLinePos: Integer; // 1 based
    110. 

  110.     FStartBytePos: Integer; // 1 based
    111. 

  111.     FAltStartLinePos, FAltStartBytePos: Integer; // 1 based // Alternate, for min selection
    112. 

  112.     FEndLinePos: Integer; // 1 based
    113. 

  113.     FEndBytePos: Integer; // 1 based
    114. 

  114.     FPersistent: Boolean;
    115. 

  115.     FPersistentLock, FWeakPersistentIdx, FStrongPersistentIdx: Integer;
    116. 

  116.     FIgnoreNextCaretMove: Boolean;
    117. 

  117.     (* On any modification, remember the position of the caret.
    118. 

  118.        If it gets moved from there to either end of the block, this should be ignored
    119. 

  119.        This happens, if Block and caret are adjusted directly
    120. 

  120.     *)
    121. 

  121.     FLastCarePos: TPoint;
    122. 

  122.     FStickyAutoExtend: Boolean;
    123. 

  123.     function  AdjustBytePosToCharacterStart(Line: integer; BytePos: integer): integer;
    124. 

  124.     function  GetFirstLineBytePos: TPoint;
    125. 

  125.     function  GetLastLineBytePos: TPoint;
    126. 

  126.     function GetLastLineHasSelection: Boolean;
    127. 

  127.     procedure SetAutoExtend(AValue: Boolean);
    128. 

  128.     procedure SetCaret(const AValue: TSynEditCaret);
    129. 

  129.     procedure SetEnabled(const Value : Boolean);
    130. 

  130.     procedure SetActiveSelectionMode(const Value: TSynSelectionMode);
    131. 

  131.     procedure SetForceSingleLineSelected(AValue: Boolean);
    132. 

  132.     procedure SetHide(const AValue: Boolean);
    133. 

  133.     procedure SetPersistent(const AValue: Boolean);
    134. 

  134.     procedure SetSelectionMode      (const AValue: TSynSelectionMode);
    135. 

  135.     function  GetStartLineBytePos: TPoint;
    136. 

  136.     procedure ConstrainStartLineBytePos(var Value: TPoint);
    137. 

  137.     procedure SetStartLineBytePos(Value: TPoint);
    138. 

  138.     procedure AdjustStartLineBytePos(Value: TPoint);
    139. 

  139.     function  GetEndLineBytePos: TPoint;
    140. 

  140.     procedure SetEndLineBytePos(Value: TPoint);
    141. 

  141.     function  GetSelText: string;
    142. 

  142.     procedure SetSelText(const Value: string);
    143. 

  143.     procedure DoCaretChanged(Sender: TObject);
    144. 

  144.     procedure AdjustAfterTrimming; // TODO: Move into TrimView?
    145. 

  145.   protected
    146. 

  146.     procedure DoLock; override;
    147. 

  147.     procedure DoUnlock; override;
    148. 

  148.     Procedure LineChanged(Sender: TSynEditStrings; AIndex, ACount : Integer);
    149. 

  149.     procedure DoLinesEdited(Sender: TSynEditStrings; aLinePos, aBytePos, aCount,
    150. 

  150.                             aLineBrkCnt: Integer; aText: String);
    151. 

  151.   public
    152. 

  152.     constructor Create(ALines: TSynEditStrings; aActOnLineChanges: Boolean);
    153. 

  153.     destructor Destroy; override;
    154. 

  154.     procedure AssignFrom(Src: TSynEditSelection);
    155. 

  155.     procedure SetSelTextPrimitive(PasteMode: TSynSelectionMode; Value: PChar; AReplace: Boolean = False);
    156. 

  156.     function  SelAvail: Boolean;
    157. 

  157.     function  SelCanContinue(ACaret: TSynEditCaret): Boolean;
    158. 

  158.     function  IsBackwardSel: Boolean; // SelStart < SelEnd ?
    159. 

  159.     procedure BeginMinimumSelection; // current selection will be minimum while follow caret (autoExtend) // until next setSelStart or end of follow
    160. 

  160.     procedure SortSelectionPoints;
    161. 

  161.     procedure IgnoreNextCaretMove;
    162. 

  162.     // Mode can NOT be changed in nested calls
    163. 

  163.     procedure IncPersistentLock(AMode: TSynBlockPersistMode = sbpDefault); // Weak: Do not extend (but rather move) block, if at start/end
    164. 

  164.     procedure DecPersistentLock;
    165. 

  165.     procedure Clear;
    166. 

  166.     procedure AddBeforeSetSelTextHandler(AHandler: TSynBeforeSetSelTextEvent);
    167. 

  167.     procedure RemoveBeforeSetSelTextHandler(AHandler: TSynBeforeSetSelTextEvent);
    168. 

  168.     property  Enabled: Boolean read FEnabled write SetEnabled;
    169. 

  169.     property  ForceSingleLineSelected: Boolean read FForceSingleLineSelected write SetForceSingleLineSelected;
    170. 

  170.     property  ActiveSelectionMode: TSynSelectionMode
    171. 

  171.                 read FActiveSelectionMode write SetActiveSelectionMode;
    172. 

  172.     property  SelectionMode: TSynSelectionMode
    173. 

  173.                 read FSelectionMode write SetSelectionMode;
    174. 

  174.     property  SelText: String read GetSelText write SetSelText;
    175. 

  175.     // Start and End positions are in the order they where defined
    176. 

  176.     // This may mean Startpos is behind EndPos in the text
    177. 

  177.     property  StartLineBytePos: TPoint
    178. 

  178.                 read GetStartLineBytePos write SetStartLineBytePos;
    179. 

  179.     property  StartLineBytePosAdjusted: TPoint
    180. 

  180.                  write AdjustStartLineBytePos;
    181. 

  181.     property  EndLineBytePos: TPoint
    182. 

  182.                 read GetEndLineBytePos write SetEndLineBytePos;
    183. 

  183.     property  StartLinePos: Integer read FStartLinePos;
    184. 

  184.     property  EndLinePos: Integer read FEndLinePos;
    185. 

  185.     property  StartBytePos: Integer read FStartBytePos;
    186. 

  186.     property  EndBytePos: Integer read FEndBytePos;
    187. 

  187.     // First and Last Pos are ordered according to the text flow (LTR)
    188. 

  188.     property  FirstLineBytePos: TPoint read GetFirstLineBytePos;
    189. 

  189.     property  LastLineBytePos: TPoint read GetLastLineBytePos;
    190. 

  190.     property  LastLineHasSelection: Boolean read GetLastLineHasSelection;
    191. 

  191.     property  InvalidateLinesMethod : TInvalidateLines write FInvalidateLinesMethod;
    192. 

  192.     property  Caret: TSynEditCaret read FCaret write SetCaret;
    193. 

  193.     property  Persistent: Boolean read FPersistent write SetPersistent;
    194. 

  194.     // automatically Start/Extend selection if caret moves
    195. 

  195.     // (depends if caret was at block border or not)
    196. 

  196.     property  AutoExtend: Boolean read FAutoExtend write SetAutoExtend;
    197. 

  197.     property  StickyAutoExtend: Boolean read FStickyAutoExtend write FStickyAutoExtend;
    198. 

  198.     property  Hide: Boolean read FHide write SetHide;
    199. 

  199.   end;
    200. 

  200. 

  201.   { TSynEditCaret }
    202. 

  202. 

  203.   TSynEditCaretFlag = (
    204. 

  204.       scCharPosValid, scBytePosValid
    205. 

  205.     );
    206. 

  206.   TSynEditCaretFlags = set of TSynEditCaretFlag;
    207. 

  207. 

  208.   TSynEditCaretUpdateFlag = (
    209. 

  209.       scuForceSet,                // Change even if equal to old
    210. 

  210.       scuChangedX, scuChangedY,   //
    211. 

  211.       scuNoInvalidate             // Keep the Char/Byte ValidFlags
    212. 

  212.     );
    213. 

  213.   TSynEditCaretUpdateFlags = set of TSynEditCaretUpdateFlag;
    214. 

  214. 

  215. 

  216.   { TSynEditBaseCaret
    217. 

  217.     No Checks at all.
    218. 

  218.     Caller MUST ensure at least not to set x to invalid pos (middle of char) (incl update x, after SetLine)
    219. 

  219.   }
    220. 

  220. 

  221.   TSynEditBaseCaret = class(TSynEditPointBase)
    222. 

  222.   private
    223. 

  223.     FFlags: TSynEditCaretFlags;
    224. 

  224.     FLinePos: Integer;     // 1 based
    225. 

  225.     FCharPos: Integer;     // 1 based
    226. 

  226.     FBytePos, FBytePosOffset: Integer;     // 1 based
    227. 

  227. 

  228.     function  GetBytePos: Integer;
    229. 

  229.     function  GetBytePosOffset: Integer;
    230. 

  230.     function  GetCharPos: Integer;
    231. 

  231.     function GetFullLogicalPos: TLogCaretPoint;
    232. 

  232.     function  GetLineBytePos: TPoint;
    233. 

  233.     function  GetLineCharPos: TPoint;
    234. 

  234.     procedure SetBytePos(AValue: Integer);
    235. 

  235.     procedure SetBytePosOffset(AValue: Integer);
    236. 

  236.     procedure SetCharPos(AValue: Integer);
    237. 

  237.     procedure SetFullLogicalPos(AValue: TLogCaretPoint);
    238. 

  238.     procedure SetLineBytePos(AValue: TPoint);
    239. 

  239.     procedure SetLineCharPos(AValue: TPoint);
    240. 

  240.     procedure SetLinePos(AValue: Integer);
    241. 

  241. 

  242.     function  GetLineText: string;
    243. 

  243.     procedure SetLineText(AValue: string);
    244. 

  244.   protected
    245. 

  245.     procedure ValidateBytePos;
    246. 

  246.     procedure ValidateCharPos;
    247. 

  247. 

  248.     procedure InternalSetLineCharPos(NewLine, NewCharPos: Integer;
    249. 

  249.                                      UpdFlags: TSynEditCaretUpdateFlags); virtual;
    250. 

  250.     procedure InternalSetLineByterPos(NewLine, NewBytePos, NewByteOffs: Integer;
    251. 

  251.                                      UpdFlags: TSynEditCaretUpdateFlags); virtual;
    252. 

  252.   public
    253. 

  253.     constructor Create;
    254. 

  254.     procedure AssignFrom(Src: TSynEditBaseCaret);
    255. 

  255.     procedure Invalidate; // force to 1,1
    256. 

  256.     procedure InvalidateBytePos; // 1,1 IF no validCharPos
    257. 

  257.     procedure InvalidateCharPos;
    258. 

  258. 

  259.     function IsAtLineChar(aPoint: TPoint): Boolean;
    260. 

  260.     function IsAtLineByte(aPoint: TPoint; aByteOffset: Integer = -1): Boolean;
    261. 

  261.     function IsAtPos(aCaret: TSynEditCaret): Boolean;
    262. 

  262. 

  263.     property LinePos: Integer read FLinePos write SetLinePos;
    264. 

  264.     property CharPos: Integer read GetCharPos write SetCharPos;
    265. 

  265.     property LineCharPos: TPoint read GetLineCharPos write SetLineCharPos;
    266. 

  266.     property BytePos: Integer read GetBytePos write SetBytePos;
    267. 

  267.     property BytePosOffset: Integer read GetBytePosOffset write SetBytePosOffset;
    268. 

  268.     property LineBytePos: TPoint read GetLineBytePos write SetLineBytePos;
    269. 

  269.     property FullLogicalPos: TLogCaretPoint read GetFullLogicalPos write SetFullLogicalPos;
    270. 

  270. 

  271.     property LineText: string read GetLineText write SetLineText;
    272. 

  272.   end;
    273. 

  273. 

  274.   { TSynEditCaret }
    275. 

  275. 

  276.   TSynEditCaret = class(TSynEditBaseCaret)
    277. 

  277.   private
    278. 

  278.     FLinesEditedRegistered: Boolean;
    279. 

  279.     FAllowPastEOL: Boolean;
    280. 

  280.     FAutoMoveOnEdit: Integer;
    281. 

  281.     FForcePastEOL: Integer;
    282. 

  282.     FForceAdjustToNextChar: Integer;
    283. 

  283.     FKeepCaretX: Boolean;
    284. 

  284.     FLastCharPos: Integer; // used by KeepCaretX
    285. 

  285. 

  286.     FOldLinePos: Integer; // 1 based
    287. 

  287.     FOldCharPos: Integer; // 1 based
    288. 

  288. 

  289.     FAdjustToNextChar: Boolean;
    290. 

  290.     FMaxLeftChar: TMaxLeftCharFunc;
    291. 

  291.     FChangeOnTouch: Boolean;
    292. 

  292.     FSkipTabs: Boolean;
    293. 

  293.     FTouched: Boolean;
    294. 

  294. 

  295.     procedure AdjustToChar;
    296. 

  296.     function GetMaxLeftPastEOL: Integer;
    297. 

  297. 

  298.     function  GetOldLineCharPos: TPoint;
    299. 

  299.     function  GetOldLineBytePos: TPoint;
    300. 

  300.     function  GetOldFullLogicalPos: TLogCaretPoint;
    301. 

  301. 

  302.     procedure SetAllowPastEOL(const AValue: Boolean);
    303. 

  303.     procedure SetSkipTabs(const AValue: Boolean);
    304. 

  304.     procedure SetKeepCaretX(const AValue: Boolean);
    305. 

  305. 

  306.     procedure RegisterLinesEditedHandler;
    307. 

  307.   protected
    308. 

  308.     procedure InternalSetLineCharPos(NewLine, NewCharPos: Integer;
    309. 

  309.                                      UpdFlags: TSynEditCaretUpdateFlags); override;
    310. 

  310.     procedure InternalSetLineByterPos(NewLine, NewBytePos, NewByteOffs: Integer;
    311. 

  311.                                      UpdFlags: TSynEditCaretUpdateFlags); override;
    312. 

  312. 

  313.     procedure DoLock; override;
    314. 

  314.     Procedure DoUnlock; override;
    315. 

  315.     procedure SetLines(const AValue: TSynEditStrings); override;
    316. 

  316.     procedure DoLinesEdited(Sender: TSynEditStrings; aLinePos, aBytePos, aCount,
    317. 

  317.                             aLineBrkCnt: Integer; aText: String);
    318. 

  318.   public
    319. 

  319.     constructor Create;
    320. 

  320.     destructor Destroy; override;
    321. 

  321.     procedure AssignFrom(Src: TSynEditBaseCaret);
    322. 

  322. 

  323.     procedure IncForcePastEOL;
    324. 

  324.     procedure DecForcePastEOL;
    325. 

  325.     procedure IncForceAdjustToNextChar;
    326. 

  326.     procedure DecForceAdjustToNextChar;
    327. 

  327.     procedure IncAutoMoveOnEdit;
    328. 

  328.     procedure DecAutoMoveOnEdit;
    329. 

  329.     procedure ChangeOnTouch;
    330. 

  330.     procedure Touch(aChangeOnTouch: Boolean = False);
    331. 

  331. 

  332.     function WasAtLineChar(aPoint: TPoint): Boolean;
    333. 

  333.     function WasAtLineByte(aPoint: TPoint): Boolean;
    334. 

  334.     function MoveHoriz(ACount: Integer): Boolean; // Logical // False, if past EOL (not mowed)/BOl
    335. 

  335. 

  336.     property OldLinePos: Integer read FOldLinePos;
    337. 

  337.     property OldCharPos: Integer read FOldCharPos;
    338. 

  338.     property OldLineCharPos: TPoint read GetOldLineCharPos;
    339. 

  339.     property OldLineBytePos: TPoint read GetOldLineBytePos;
    340. 

  340.     property OldFullLogicalPos: TLogCaretPoint read GetOldFullLogicalPos;
    341. 

  341. 

  342.     property AdjustToNextChar: Boolean read FAdjustToNextChar write FAdjustToNextChar; deprecated;
    343. 

  343.     property SkipTabs: Boolean read FSkipTabs write SetSkipTabs;
    344. 

  344.     property AllowPastEOL: Boolean read FAllowPastEOL write SetAllowPastEOL;
    345. 

  345.     property KeepCaretX: Boolean read FKeepCaretX write SetKeepCaretX;
    346. 

  346.     property KeepCaretXPos: Integer read FLastCharPos write FLastCharPos;
    347. 

  347.     property MaxLeftChar: TMaxLeftCharFunc read FMaxLeftChar write FMaxLeftChar;
    348. 

  348.   end;
    349. 

  349. 

  350.   TSynCaretType = (ctVerticalLine, ctHorizontalLine, ctHalfBlock, ctBlock, ctCostum);
    351. 

  351.   TSynCaretLockFlags = set of (sclfUpdateDisplay, sclfUpdateDisplayType);
    352. 

  352. 

  353.   { TSynEditScreenCaretTimer
    354. 

  354.     Allow sync between carets which use an internal painter
    355. 

  355.   }
    356. 

  356. 

  357.   TSynEditScreenCaretTimer = class
    358. 

  358.   private
    359. 

  359.     FDisplayCycle: Boolean;
    360. 

  360.     FTimer: TTimer;
    361. 

  361.     FTimerList: TMethodList;
    362. 

  362.     FAfterPaintList: TMethodList;
    363. 

  363.     FLocCount: Integer;
    364. 

  364.     FLocFlags: set of (lfTimer, lfRestart);
    365. 

  365.     procedure DoTimer(Sender: TObject);
    366. 

  366.     procedure DoAfterPaint(Data: PtrInt);
    367. 

  367.   public
    368. 

  368.     constructor Create;
    369. 

  369.     destructor Destroy; override;
    370. 

  370.     procedure AddAfterPaintHandler(AHandler: TNotifyEvent); // called once
    371. 

  371.     procedure AddHandler(AHandler: TNotifyEvent);
    372. 

  372.     procedure RemoveHandler(AHandler: TNotifyEvent);
    373. 

  373.     procedure RemoveHandler(AHandlerOwner: TObject);
    374. 

  374.     procedure IncLock;
    375. 

  375.     procedure DecLock;
    376. 

  376.     procedure AfterPaintEvent;
    377. 

  377. 

  378.     procedure RestartCycle;
    379. 

  379.     property DisplayCycle: Boolean read FDisplayCycle;
    380. 

  380.   end;
    381. 

  381. 

  382.   TSynEditScreenCaret = class;
    383. 

  383. 

  384.   { TSynEditScreenCaretPainter }
    385. 

  385. 

  386.   TSynEditScreenCaretPainter = class
    387. 

  387.   private
    388. 

  388.     FLeft, FTop, FHeight, FWidth: Integer;
    389. 

  389.     FCreated, FShowing: Boolean;
    390. 

  390.     FInPaint, FInScroll: Boolean;
    391. 

  391.     FPaintClip: TRect;
    392. 

  392.     FScrollX, FScrollY: Integer;
    393. 

  393.     FScrollRect, FScrollClip: TRect;
    394. 

  394. 

  395.     function GetHandle: HWND;
    396. 

  396.     function GetHandleAllocated: Boolean;
    397. 

  397.   protected
    398. 

  398.     FHandleOwner: TWinControl;
    399. 

  399.     FOwner: TSynEditScreenCaret;
    400. 

  400.     FNeedPositionConfirmed: boolean;
    401. 

  401.     procedure Init; virtual;
    402. 

  402.     property Handle: HWND read GetHandle;
    403. 

  403.     property HandleAllocated: Boolean read GetHandleAllocated;
    404. 

  404. 

  405.     procedure BeginScroll(dx, dy: Integer; const rcScroll, rcClip: TRect); virtual;
    406. 

  406.     procedure FinishScroll(dx, dy: Integer; const rcScroll, rcClip: TRect; Success: Boolean); virtual;
    407. 

  407.     procedure BeginPaint(rcClip: TRect); virtual;
    408. 

  408.     procedure FinishPaint(rcClip: TRect); virtual;
    409. 

  409.   public
    410. 

  410.     constructor Create(AHandleOwner: TWinControl; AOwner: TSynEditScreenCaret);
    411. 

  411.     function CreateCaret(w, h: Integer): Boolean; virtual;
    412. 

  412.     function DestroyCaret: Boolean; virtual;
    413. 

  413.     function HideCaret: Boolean; virtual;
    414. 

  414.     function ShowCaret: Boolean; virtual;
    415. 

  415.     function SetCaretPosEx(x, y: Integer): Boolean; virtual;
    416. 

  416. 

  417.     property Left: Integer read FLeft;
    418. 

  418.     property Top: Integer read FTop;
    419. 

  419.     property Width: Integer read FWidth;
    420. 

  420.     property Height: Integer read FHeight;
    421. 

  421.     property Created: Boolean read FCreated;
    422. 

  422.     property Showing: Boolean read FShowing;
    423. 

  423.     property InPaint: Boolean read FInPaint;
    424. 

  424.     property InScroll: Boolean read FInScroll;
    425. 

  425.     property NeedPositionConfirmed: boolean read FNeedPositionConfirmed;
    426. 

  426.   end;
    427. 

  427. 

  428.   TSynEditScreenCaretPainterClass = class of TSynEditScreenCaretPainter;
    429. 

  429. 

  430.   { TSynEditScreenCaretPainterSystem }
    431. 

  431. 

  432.   TSynEditScreenCaretPainterSystem = class(TSynEditScreenCaretPainter)
    433. 

  433.   protected
    434. 

  434.     //procedure BeginScroll(dx, dy: Integer; const rcScroll, rcClip: TRect); override;
    435. 

  435.     procedure FinishScroll(dx, dy: Integer; const rcScroll, rcClip: TRect; Success: Boolean); override;
    436. 

  436.     procedure BeginPaint(rcClip: TRect); override;
    437. 

  437.     //procedure FinishPaint(rcClip: TRect); override; // unhide, currently done by editor
    438. 

  438.   public
    439. 

  439.     function CreateCaret(w, h: Integer): Boolean; override;
    440. 

  440.     function DestroyCaret: Boolean; override;
    441. 

  441.     function HideCaret: Boolean; override;
    442. 

  442.     function ShowCaret: Boolean; override;
    443. 

  443.     function SetCaretPosEx(x, y: Integer): Boolean; override;
    444. 

  444.   end;
    445. 

  445. 

  446.   { TSynEditScreenCaretPainterInternal }
    447. 

  447. 

  448.   TSynEditScreenCaretPainterInternal = class(TSynEditScreenCaretPainter)
    449. 

  449.   private type
    450. 

  450.     TIsInRectState = (irInside, irPartInside, irOutside);
    451. 

  451.     TPainterState = (psAfterPaintAdded, psCleanOld, psRemoveTimer);
    452. 

  452.     TPainterStates = set of TPainterState;
    453. 

  453.   private
    454. 

  454.     FColor: TColor;
    455. 

  455.     FForcePaintEvents: Boolean;
    456. 

  456.     FIsDrawn: Boolean;
    457. 

  457.     FSavePen: TPen;
    458. 

  458.     FOldX, FOldY, FOldW, FOldH: Integer;
    459. 

  459.     FState: TPainterStates;
    460. 

  460.     FCanPaint: Boolean;
    461. 

  461. 

  462.     procedure DoTimer(Sender: TObject);
    463. 

  463.     procedure DoPaint(ACanvas: TCanvas; X, Y, H, W: Integer);
    464. 

  464.     procedure Paint;
    465. 

  465.     procedure Invalidate;
    466. 

  466.     procedure AddAfterPaint(AStates: TPainterStates = []);
    467. 

  467.     procedure DoAfterPaint(Sender: TObject);
    468. 

  468.     procedure ExecAfterPaint;
    469. 

  469.     function CurrentCanvas: TCanvas;
    470. 

  470.     procedure SetColor(AValue: TColor);
    471. 

  471.     function IsInRect(ARect: TRect): TIsInRectState;
    472. 

  472.     function IsInRect(ARect: TRect; X, Y, W, H: Integer): TIsInRectState;
    473. 

  473.   protected
    474. 

  474.     procedure Init; override;
    475. 

  475. 

  476.     procedure BeginScroll(dx, dy: Integer; const rcScroll, rcClip: TRect); override;
    477. 

  477.     procedure FinishScroll(dx, dy: Integer; const rcScroll, rcClip: TRect; Success: Boolean); override;
    478. 

  478.     procedure BeginPaint(rcClip: TRect); override;
    479. 

  479.     procedure FinishPaint(rcClip: TRect); override;
    480. 

  480.   public
    481. 

  481.     destructor Destroy; override;
    482. 

  482.     function CreateCaret(w, h: Integer): Boolean; override;
    483. 

  483.     function DestroyCaret: Boolean; override;
    484. 

  484.     function HideCaret: Boolean; override;
    485. 

  485.     function ShowCaret: Boolean; override;
    486. 

  486.     function SetCaretPosEx(x, y: Integer): Boolean; override;
    487. 

  487.     property Color: TColor read FColor write SetColor;
    488. 

  488.     property ForcePaintEvents: Boolean read FForcePaintEvents write FForcePaintEvents;
    489. 

  489.   end;
    490. 

  490. 

  491.   // relative dimensions in percent from 0 to 1024 (=100%)
    492. 

  492.   TSynCustomCaretSizeFlag = (ccsRelativeLeft, ccsRelativeTop, ccsRelativeWidth, ccsRelativeHeight);
    493. 

  493.   TSynCustomCaretSizeFlags = set of TSynCustomCaretSizeFlag;
    494. 

  494. 

  495.   { TSynEditScreenCaret }
    496. 

  496. 

  497.   TSynEditScreenCaret = class
    498. 

  498.   private
    499. 

  499.     FCharHeight: Integer;
    500. 

  500.     FCharWidth: Integer;
    501. 

  501.     FClipRight: Integer;
    502. 

  502.     FClipBottom: Integer;
    503. 

  503.     FClipLeft: Integer;
    504. 

  504.     FClipTop: Integer;
    505. 

  505.     FDisplayPos: TPoint;
    506. 

  506.     FDisplayType: TSynCaretType;
    507. 

  507.     FExtraLinePixel, FExtraLineChars: Integer;
    508. 

  508.     FOnExtraLineCharsChanged: TNotifyEvent;
    509. 

  509.     FVisible: Boolean;
    510. 

  510.     FHandleOwner: TWinControl;
    511. 

  511.     FCaretPainter: TSynEditScreenCaretPainter;
    512. 

  512.     FPaintTimer: TSynEditScreenCaretTimer;
    513. 

  513.     FPaintTimerOwned: Boolean;
    514. 

  514.     function GetHandle: HWND;
    515. 

  515.     function GetHandleAllocated: Boolean;
    516. 

  516.     procedure SetCharHeight(const AValue: Integer);
    517. 

  517.     procedure SetCharWidth(const AValue: Integer);
    518. 

  518.     procedure SetClipRight(const AValue: Integer);
    519. 

  519.     procedure SetDisplayPos(const AValue: TPoint);
    520. 

  520.     procedure SetDisplayType(const AType: TSynCaretType);
    521. 

  521.     procedure SetVisible(const AValue: Boolean);
    522. 

  522.   private
    523. 

  523.     FClipExtraPixel: Integer;
    524. 

  524.     {$IFDeF SynCaretDebug}
    525. 

  525.     FDebugShowCount: Integer;
    526. 

  526.     {$ENDIF}
    527. 

  527.     FPixelWidth, FPixelHeight: Integer;
    528. 

  528.     FOffsetX, FOffsetY: Integer;
    529. 

  529.     FCustomPixelWidth, FCustomPixelHeight: Array [TSynCaretType] of Integer;
    530. 

  530.     FCustomOffsetX, FCustomOffsetY: Array [TSynCaretType] of Integer;
    531. 

  531.     FCustomFlags: Array [TSynCaretType] of TSynCustomCaretSizeFlags;
    532. 

  532.     FLockCount: Integer;
    533. 

  533.     FLockFlags: TSynCaretLockFlags;
    534. 

  534.     function GetHasPaintTimer: Boolean;
    535. 

  535.     function GetPaintTimer: TSynEditScreenCaretTimer;
    536. 

  536.     procedure SetClipBottom(const AValue: Integer);
    537. 

  537.     procedure SetClipExtraPixel(AValue: Integer);
    538. 

  538.     procedure SetClipLeft(const AValue: Integer);
    539. 

  539.     procedure SetClipRect(const AValue: TRect);
    540. 

  540.     procedure SetClipTop(const AValue: Integer);
    541. 

  541.     procedure CalcExtraLineChars;
    542. 

  542.     procedure SetPaintTimer(AValue: TSynEditScreenCaretTimer);
    543. 

  543.     procedure UpdateDisplayType;
    544. 

  544.     procedure UpdateDisplay;
    545. 

  545.     procedure ShowCaret;
    546. 

  546.     procedure HideCaret;
    547. 

  547.     property HandleAllocated: Boolean read GetHandleAllocated;
    548. 

  548.   protected
    549. 

  549.     property Handle: HWND read GetHandle;
    550. 

  550.   public
    551. 

  551.     constructor Create(AHandleOwner: TWinControl);
    552. 

  552.     constructor Create(AHandleOwner: TWinControl; APainterClass: TSynEditScreenCaretPainterClass);
    553. 

  553.     procedure ChangePainter(APainterClass: TSynEditScreenCaretPainterClass);
    554. 

  554.     destructor Destroy; override;
    555. 

  555. 

  556.     procedure BeginScroll(dx, dy: Integer; const rcScroll, rcClip: TRect);
    557. 

  557.     procedure FinishScroll(dx, dy: Integer; const rcScroll, rcClip: TRect; Success: Boolean);
    558. 

  558.     procedure BeginPaint(rcClip: TRect);
    559. 

  559.     procedure FinishPaint(rcClip: TRect);
    560. 

  560.     procedure Lock;
    561. 

  561.     procedure UnLock;
    562. 

  562.     procedure AfterPaintEvent;  // next async
    563. 

  563. 

  564.     procedure  Hide; // Keep visible = true
    565. 

  565.     procedure  DestroyCaret(SkipHide: boolean = False);
    566. 

  566.     procedure ResetCaretTypeSizes;
    567. 

  567.     procedure SetCaretTypeSize(AType: TSynCaretType; AWidth, AHeight, AXOffs, AYOffs: Integer;
    568. 

  568.                                AFlags: TSynCustomCaretSizeFlags = []);
    569. 

  569.     property HandleOwner: TWinControl read FHandleOwner;
    570. 

  570.     property PaintTimer: TSynEditScreenCaretTimer read GetPaintTimer write SetPaintTimer;
    571. 

  571.     property HasPaintTimer: Boolean read GetHasPaintTimer;
    572. 

  572.     property Painter: TSynEditScreenCaretPainter read FCaretPainter;
    573. 

  573.     property CharWidth:   Integer read FCharWidth write SetCharWidth;
    574. 

  574.     property CharHeight:  Integer read FCharHeight write SetCharHeight;
    575. 

  575.     property ClipLeft:    Integer read FClipLeft write SetClipLeft;
    576. 

  576.     property ClipRight:   Integer read FClipRight write SetClipRight;           // First pixel outside the allowed area
    577. 

  577.     property ClipTop:     Integer read FClipTop write SetClipTop;
    578. 

  578.     property ClipRect:    TRect write SetClipRect;
    579. 

  579.     property ClipBottom:  Integer read FClipBottom write SetClipBottom;
    580. 

  580.     property ClipExtraPixel: Integer read FClipExtraPixel write SetClipExtraPixel; // Amount of pixels, after  the last full char (half visible char width)
    581. 

  581.     property Visible:     Boolean read FVisible write SetVisible;
    582. 

  582.     property DisplayType: TSynCaretType read FDisplayType write SetDisplayType;
    583. 

  583.     property DisplayPos:  TPoint  read FDisplayPos write SetDisplayPos;
    584. 

  584.     property ExtraLineChars: Integer read FExtraLineChars; // Extend the longest line by x chars
    585. 

  585.     property OnExtraLineCharsChanged: TNotifyEvent
    586. 

  586.              read FOnExtraLineCharsChanged write FOnExtraLineCharsChanged;
    587. 

  587.   end;
    588. 

  588. 

  589. implementation
    590. 

  590. 

  591. { TSynBeforeSetSelTextList }
    592. 

  592. 

  593. procedure TSynBeforeSetSelTextList.CallBeforeSetSelTextHandlers(Sender: TObject;
    594. 

  594.   AMode: TSynSelectionMode; ANewText: PChar);
    595. 

  595. var
    596. 

  596.   i: Integer;
    597. 

  597. begin
    598. 

  598.   i:=Count;
    599. 

  599.   while NextDownIndex(i) do
    600. 

  600.     TSynBeforeSetSelTextEvent(Items[i])(Sender, AMode, ANewText);
    601. 

  601. end;
    602. 

  602. 

  603. { TSynEditBaseCaret }
    604. 

  604. 

  605. function TSynEditBaseCaret.GetBytePos: Integer;
    606. 

  606. begin
    607. 

  607.   ValidateBytePos;
    608. 

  608.   Result := FBytePos;
    609. 

  609. end;
    610. 

  610. 

  611. function TSynEditBaseCaret.GetBytePosOffset: Integer;
    612. 

  612. begin
    613. 

  613.   ValidateBytePos;
    614. 

  614.   Result := FBytePosOffset;
    615. 

  615. end;
    616. 

  616. 

  617. function TSynEditBaseCaret.GetCharPos: Integer;
    618. 

  618. begin
    619. 

  619.   ValidateCharPos;
    620. 

  620.   Result := FCharPos;
    621. 

  621. end;
    622. 

  622. 

  623. function TSynEditBaseCaret.GetFullLogicalPos: TLogCaretPoint;
    624. 

  624. begin
    625. 

  625.   ValidateBytePos;
    626. 

  626.   Result.Y := FLinePos;
    627. 

  627.   Result.X := FBytePos;
    628. 

  628.   Result.Offs := FBytePosOffset;
    629. 

  629. end;
    630. 

  630. 

  631. function TSynEditBaseCaret.GetLineBytePos: TPoint;
    632. 

  632. begin
    633. 

  633.   ValidateBytePos;
    634. 

  634.   Result := Point(FBytePos, FLinePos);
    635. 

  635. end;
    636. 

  636. 

  637. function TSynEditBaseCaret.GetLineCharPos: TPoint;
    638. 

  638. begin
    639. 

  639.   ValidateCharPos;
    640. 

  640.   Result := Point(FCharPos, FLinePos);
    641. 

  641. end;
    642. 

  642. 

  643. procedure TSynEditBaseCaret.SetBytePos(AValue: Integer);
    644. 

  644. begin
    645. 

  645.   InternalSetLineByterPos(FLinePos, AValue, 0, [scuChangedX]);
    646. 

  646. end;
    647. 

  647. 

  648. procedure TSynEditBaseCaret.SetBytePosOffset(AValue: Integer);
    649. 

  649. begin
    650. 

  650.   ValidateBytePos;
    651. 

  651.   InternalSetLineByterPos(FLinePos, FBytePos, AValue, [scuChangedX]);
    652. 

  652. end;
    653. 

  653. 

  654. procedure TSynEditBaseCaret.SetCharPos(AValue: Integer);
    655. 

  655. begin
    656. 

  656.   InternalSetLineCharPos(FLinePos, AValue, [scuChangedX]);
    657. 

  657. end;
    658. 

  658. 

  659. procedure TSynEditBaseCaret.SetFullLogicalPos(AValue: TLogCaretPoint);
    660. 

  660. begin
    661. 

  661.   InternalSetLineByterPos(AValue.y, AValue.x, AValue.Offs, [scuChangedX, scuChangedY]);
    662. 

  662. end;
    663. 

  663. 

  664. procedure TSynEditBaseCaret.SetLineBytePos(AValue: TPoint);
    665. 

  665. begin
    666. 

  666.   InternalSetLineByterPos(AValue.y, AValue.x, 0, [scuChangedX, scuChangedY]);
    667. 

  667. end;
    668. 

  668. 

  669. procedure TSynEditBaseCaret.SetLineCharPos(AValue: TPoint);
    670. 

  670. begin
    671. 

  671.   InternalSetLineCharPos(AValue.y, AValue.X, [scuChangedX, scuChangedY]);
    672. 

  672. end;
    673. 

  673. 

  674. procedure TSynEditBaseCaret.SetLinePos(AValue: Integer);
    675. 

  675. begin
    676. 

  676.   // TODO: may temporary lead to invalid x bytepos. Must be adjusted *before* calculating char
    677. 

  677.   //if scBytePosValid in FFlags then
    678. 

  678.   //  InternalSetLineByterPos(AValue, FBytePos, FBytePosOffset, [scuChangedY])
    679. 

  679.   //else
    680. 

  680.     ValidateCharPos;
    681. 

  681.     InternalSetLineCharPos(AValue, FCharPos, [scuChangedY]);
    682. 

  682. end;
    683. 

  683. 

  684. function TSynEditBaseCaret.GetLineText: string;
    685. 

  685. begin
    686. 

  686.   if (LinePos >= 1) and (LinePos <= FLines.Count) then
    687. 

  687.     Result := FLines[LinePos - 1]
    688. 

  688.   else
    689. 

  689.     Result := '';
    690. 

  690. end;
    691. 

  691. 

  692. procedure TSynEditBaseCaret.SetLineText(AValue: string);
    693. 

  693. begin
    694. 

  694.   if (LinePos >= 1) and (LinePos <= Max(1, FLines.Count)) then
    695. 

  695.     FLines[LinePos - 1] := AValue;
    696. 

  696. end;
    697. 

  697. 

  698. procedure TSynEditBaseCaret.ValidateBytePos;
    699. 

  699. begin
    700. 

  700.   if scBytePosValid in FFlags then
    701. 

  701.     exit;
    702. 

  702.   assert(scCharPosValid in FFlags, 'ValidateBytePos: no charpos set');
    703. 

  703.   Include(FFlags, scBytePosValid);
    704. 

  704.   FBytePos := FLines.LogPhysConvertor.PhysicalToLogical(FLinePos-1, FCharPos, FBytePosOffset);
    705. 

  705. end;
    706. 

  706. 

  707. procedure TSynEditBaseCaret.ValidateCharPos;
    708. 

  708. begin
    709. 

  709.   if scCharPosValid in FFlags then
    710. 

  710.     exit;
    711. 

  711.   assert(scBytePosValid in FFlags, 'ValidateCharPos: no bytepos set');
    712. 

  712.   Include(FFlags, scCharPosValid);
    713. 

  713.   FCharPos := FLines.LogPhysConvertor.LogicalToPhysical(FLinePos-1, FBytePos, FBytePosOffset);
    714. 

  714. end;
    715. 

  715. 

  716. procedure TSynEditBaseCaret.InternalSetLineCharPos(NewLine, NewCharPos: Integer;
    717. 

  717.   UpdFlags: TSynEditCaretUpdateFlags);
    718. 

  718. begin
    719. 

  719.   if (fCharPos = NewCharPos) and (fLinePos = NewLine) and
    720. 

  720.      (scCharPosValid in FFlags) and not (scuForceSet in UpdFlags)
    721. 

  721.   then
    722. 

  722.     exit;
    723. 

  723. 

  724.   if not (scuNoInvalidate in UpdFlags) then
    725. 

  725.     Exclude(FFlags, scBytePosValid);
    726. 

  726.   Include(FFlags, scCharPosValid);
    727. 

  727. 

  728.   if NewLine < 1 then begin
    729. 

  729.     NewLine := 1;
    730. 

  730.     Exclude(FFlags, scBytePosValid);
    731. 

  731.   end;
    732. 

  732. 

  733.   if NewCharPos < 1 then begin
    734. 

  734.     NewCharPos := 1;
    735. 

  735.     Exclude(FFlags, scBytePosValid);
    736. 

  736.   end;
    737. 

  737. 

  738.   FCharPos := NewCharPos;
    739. 

  739.   FLinePos := NewLine;
    740. 

  740. end;
    741. 

  741. 

  742. procedure TSynEditBaseCaret.InternalSetLineByterPos(NewLine, NewBytePos, NewByteOffs: Integer;
    743. 

  743.   UpdFlags: TSynEditCaretUpdateFlags);
    744. 

  744. begin
    745. 

  745.   if (FBytePos = NewBytePos) and (FBytePosOffset = NewByteOffs) and
    746. 

  746.      (FLinePos = NewLine) and (scBytePosValid in FFlags) and not (scuForceSet in UpdFlags)
    747. 

  747.   then
    748. 

  748.     exit;
    749. 

  749. 

  750.   if not (scuNoInvalidate in UpdFlags) then
    751. 

  751.     Exclude(FFlags, scCharPosValid);
    752. 

  752.   Include(FFlags, scBytePosValid);
    753. 

  753. 

  754.   if NewLine < 1 then begin
    755. 

  755.     NewLine := 1;
    756. 

  756.     Exclude(FFlags, scCharPosValid);
    757. 

  757.   end;
    758. 

  758. 

  759.   if NewBytePos < 1 then begin
    760. 

  760.     NewBytePos := 1;
    761. 

  761.     Exclude(FFlags, scCharPosValid);
    762. 

  762.   end;
    763. 

  763. 

  764.   FBytePos       := NewBytePos;
    765. 

  765.   FBytePosOffset := NewByteOffs;
    766. 

  766.   FLinePos       := NewLine;
    767. 

  767. end;
    768. 

  768. 

  769. constructor TSynEditBaseCaret.Create;
    770. 

  770. begin
    771. 

  771.   inherited Create;
    772. 

  772.   fLinePos       := 1;
    773. 

  773.   fCharPos       := 1;
    774. 

  774.   FBytePos       := 1;
    775. 

  775.   FBytePosOffset := 0;
    776. 

  776.   FFlags := [scCharPosValid, scBytePosValid];
    777. 

  777. end;
    778. 

  778. 

  779. procedure TSynEditBaseCaret.AssignFrom(Src: TSynEditBaseCaret);
    780. 

  780. begin
    781. 

  781.   FLinePos       := Src.FLinePos;
    782. 

  782.   FCharPos       := Src.FCharPos;
    783. 

  783.   FBytePos       := Src.FBytePos;
    784. 

  784.   FBytePosOffset := Src.FBytePosOffset;
    785. 

  785.   FFlags         := Src.FFlags;
    786. 

  786.   SetLines(Src.FLines);
    787. 

  787. end;
    788. 

  788. 

  789. procedure TSynEditBaseCaret.Invalidate;
    790. 

  790. begin
    791. 

  791.   FLinePos := 1;
    792. 

  792.   FCharPos := 1;
    793. 

  793.   FBytePos := 1;
    794. 

  794.   FFlags := [];
    795. 

  795. end;
    796. 

  796. 

  797. procedure TSynEditBaseCaret.InvalidateBytePos;
    798. 

  798. begin
    799. 

  799.   if not (scCharPosValid in FFlags) then
    800. 

  800.     Invalidate
    801. 

  801.   else
    802. 

  802.     Exclude(FFlags, scBytePosValid);
    803. 

  803. end;
    804. 

  804. 

  805. procedure TSynEditBaseCaret.InvalidateCharPos;
    806. 

  806. begin
    807. 

  807.   if not (scBytePosValid in FFlags) then
    808. 

  808.     Invalidate
    809. 

  809.   else
    810. 

  810.     Exclude(FFlags, scCharPosValid);
    811. 

  811. end;
    812. 

  812. 

  813. function TSynEditBaseCaret.IsAtLineChar(aPoint: TPoint): Boolean;
    814. 

  814. begin
    815. 

  815.   ValidateCharPos;
    816. 

  816.   Result := (FLinePos = aPoint.y) and (FCharPos = aPoint.x);
    817. 

  817. end;
    818. 

  818. 

  819. function TSynEditBaseCaret.IsAtLineByte(aPoint: TPoint; aByteOffset: Integer): Boolean;
    820. 

  820. begin
    821. 

  821.   ValidateBytePos;
    822. 

  822.   Result := (FLinePos = aPoint.y) and (BytePos = aPoint.x) and
    823. 

  823.             ( (aByteOffset < 0) or (FBytePosOffset = aByteOffset) );
    824. 

  824. end;
    825. 

  825. 

  826. function TSynEditBaseCaret.IsAtPos(aCaret: TSynEditCaret): Boolean;
    827. 

  827. begin
    828. 

  828.   if (scBytePosValid in FFlags) or (scBytePosValid in aCaret.FFlags) then
    829. 

  829.     Result := IsAtLineByte(aCaret.LineBytePos, aCaret.BytePosOffset)
    830. 

  830.   else
    831. 

  831.     Result := IsAtLineChar(aCaret.LineCharPos);
    832. 

  832. end;
    833. 

  833. 

  834. { TSynEditPointBase }
    835. 

  835. 

  836. function TSynEditPointBase.GetLocked: Boolean;
    837. 

  837. begin
    838. 

  838.   Result := FLockCount > 0;
    839. 

  839. end;
    840. 

  840. 

  841. procedure TSynEditPointBase.SetLines(const AValue: TSynEditStrings);
    842. 

  842. begin
    843. 

  843.   FLines := AValue;
    844. 

  844. end;
    845. 

  845. 

  846. procedure TSynEditPointBase.DoLock;
    847. 

  847. begin
    848. 

  848. end;
    849. 

  849. 

  850. procedure TSynEditPointBase.DoUnlock;
    851. 

  851. begin
    852. 

  852. end;
    853. 

  853. 

  854. constructor TSynEditPointBase.Create;
    855. 

  855. begin
    856. 

  856.   FOnChangeList := TMethodList.Create;
    857. 

  857. end;
    858. 

  858. 

  859. constructor TSynEditPointBase.Create(Lines : TSynEditStrings);
    860. 

  860. begin
    861. 

  861.   Create;
    862. 

  862.   FLines := Lines;
    863. 

  863. end;
    864. 

  864. 

  865. destructor TSynEditPointBase.Destroy;
    866. 

  866. begin
    867. 

  867.   FreeAndNil(FOnChangeList);
    868. 

  868.   inherited Destroy;
    869. 

  869. end;
    870. 

  870. 

  871. procedure TSynEditPointBase.AddChangeHandler(AHandler : TNotifyEvent);
    872. 

  872. begin
    873. 

  873.   FOnChangeList.Add(TMethod(AHandler));
    874. 

  874. end;
    875. 

  875. 

  876. procedure TSynEditPointBase.RemoveChangeHandler(AHandler : TNotifyEvent);
    877. 

  877. begin
    878. 

  878.   FOnChangeList.Remove(TMethod(AHandler));
    879. 

  879. end;
    880. 

  880. 

  881. procedure TSynEditPointBase.Lock;
    882. 

  882. begin
    883. 

  883.   if FLockCount = 0 then
    884. 

  884.     DoLock;
    885. 

  885.   inc(FLockCount);
    886. 

  886. end;
    887. 

  887. 

  888. procedure TSynEditPointBase.Unlock;
    889. 

  889. begin
    890. 

  890.   dec(FLockCount);
    891. 

  891.   if FLockCount = 0 then
    892. 

  892.     DoUnLock;
    893. 

  893. end;
    894. 

  894. 

  895. { TSynEditCaret }
    896. 

  896. 

  897. constructor TSynEditCaret.Create;
    898. 

  898. begin
    899. 

  899.   inherited Create;
    900. 

  900.   FMaxLeftChar := nil;
    901. 

  901.   FAllowPastEOL := True;
    902. 

  902.   FForcePastEOL := 0;
    903. 

  903.   FAutoMoveOnEdit := 0;
    904. 

  904.   if FLines <> nil then
    905. 

  905.     FLines.AddEditHandler(@DoLinesEdited);
    906. 

  906. end;
    907. 

  907. 

  908. destructor TSynEditCaret.Destroy;
    909. 

  909. begin
    910. 

  910.   if FLines <> nil then
    911. 

  911.     FLines.RemoveEditHandler(@DoLinesEdited);
    912. 

  912.   inherited Destroy;
    913. 

  913. end;
    914. 

  914. 

  915. procedure TSynEditCaret.AssignFrom(Src: TSynEditBaseCaret);
    916. 

  916. begin
    917. 

  917.   FOldCharPos := FCharPos;
    918. 

  918.   FOldLinePos := FLinePos;
    919. 

  919. 

  920.   inherited AssignFrom(Src);
    921. 

  921. 

  922.   if Src is TSynEditCaret then begin
    923. 

  923.     FMaxLeftChar   := TSynEditCaret(Src).FMaxLeftChar;
    924. 

  924.     FAllowPastEOL  := TSynEditCaret(Src).FAllowPastEOL;
    925. 

  925.     FKeepCaretX    := TSynEditCaret(Src).FKeepCaretX;
    926. 

  926.     FLastCharPos   := TSynEditCaret(Src).FLastCharPos;
    927. 

  927.   end
    928. 

  928.   else begin
    929. 

  929.     AdjustToChar;
    930. 

  930.     FLastCharPos   := FCharPos;
    931. 

  931.   end;
    932. 

  932. end;
    933. 

  933. 

  934. procedure TSynEditCaret.DoLock;
    935. 

  935. begin
    936. 

  936.   FTouched := False;
    937. 

  937.   ValidateCharPos;
    938. 

  938.   //ValidateBytePos;
    939. 

  939.   FOldCharPos := FCharPos;
    940. 

  940.   FOldLinePos := FLinePos;
    941. 

  941. end;
    942. 

  942. 

  943. procedure TSynEditCaret.DoUnlock;
    944. 

  944. begin
    945. 

  945.   if not FChangeOnTouch then
    946. 

  946.     FTouched := False;
    947. 

  947.   FChangeOnTouch := False;
    948. 

  948.   ValidateCharPos;
    949. 

  949.   //ValidateBytePos;
    950. 

  950.   if (FOldCharPos <> FCharPos) or (FOldLinePos <> FLinePos) or FTouched then
    951. 

  951.     fOnChangeList.CallNotifyEvents(self);
    952. 

  952.   // All notifications called, reset oldpos
    953. 

  953.   FTouched := False;
    954. 

  954.   FOldCharPos := FCharPos;
    955. 

  955.   FOldLinePos := FLinePos;
    956. 

  956. end;
    957. 

  957. 

  958. procedure TSynEditCaret.SetLines(const AValue: TSynEditStrings);
    959. 

  959. begin
    960. 

  960.   if FLines = AValue then exit;
    961. 

  961.   // Do not check flag. It will be cleared in Assign
    962. 

  962.   if (FLines <> nil) then
    963. 

  963.     FLines.RemoveEditHandler(@DoLinesEdited);
    964. 

  964.   FLinesEditedRegistered := False;
    965. 

  965.   inherited SetLines(AValue);
    966. 

  966.   if FAutoMoveOnEdit > 0 then
    967. 

  967.     RegisterLinesEditedHandler;
    968. 

  968. end;
    969. 

  969. 

  970. procedure TSynEditCaret.RegisterLinesEditedHandler;
    971. 

  971. begin
    972. 

  972.   if FLinesEditedRegistered or (FLines = nil) then
    973. 

  973.     exit;
    974. 

  974.   FLinesEditedRegistered := True;
    975. 

  975.   FLines.AddEditHandler(@DoLinesEdited);
    976. 

  976. end;
    977. 

  977. 

  978. procedure TSynEditCaret.DoLinesEdited(Sender: TSynEditStrings; aLinePos, aBytePos, aCount,
    979. 

  979.   aLineBrkCnt: Integer; aText: String);
    980. 

  980.   // Todo: refactor / this is a copy from selection
    981. 

  981.   function AdjustPoint(aPoint: Tpoint): TPoint; inline;
    982. 

  982.   begin
    983. 

  983.     Result := aPoint;
    984. 

  984.     if aLineBrkCnt < 0 then begin
    985. 

  985.       (* Lines Deleted *)
    986. 

  986.       if aPoint.y > aLinePos then begin
    987. 

  987.         Result.y := Max(aLinePos, Result.y + aLineBrkCnt);
    988. 

  988.         if Result.y = aLinePos then
    989. 

  989.           Result.x := Result.x + aBytePos - 1;
    990. 

  990.       end;
    991. 

  991.     end
    992. 

  992.     else
    993. 

  993.     if aLineBrkCnt > 0 then begin
    994. 

  994.       (* Lines Inserted *)
    995. 

  995.       if (aPoint.y = aLinePos) and (aPoint.x >= aBytePos) then begin
    996. 

  996.         Result.x := Result.x - aBytePos + 1;
    997. 

  997.         Result.y := Result.y + aLineBrkCnt;
    998. 

  998.       end;
    999. 

  999.       if aPoint.y > aLinePos then begin
    1000. 

  1000.         Result.y := Result.y + aLineBrkCnt;
    1001. 

  1001.       end;
    1002. 

  1002.     end
    1003. 

  1003.     else
    1004. 

  1004.     if aCount <> 0 then begin
    1005. 

  1005.       (* Chars Insert/Deleted *)
    1006. 

  1006.       if (aPoint.y = aLinePos) and (aPoint.x >= aBytePos) then
    1007. 

  1007.         Result.x := Max(aBytePos, Result.x + aCount);
    1008. 

  1008.     end;
    1009. 

  1009.   end;
    1010. 

  1010. 

  1011. var
    1012. 

  1012.   p: TPoint;
    1013. 

  1013. begin
    1014. 

  1014.   if (FAutoMoveOnEdit > 0) and
    1015. 

  1015.      ( (aLineBrkCnt <> 0) or (aLinePos = FLinePos) )
    1016. 

  1016.   then begin
    1017. 

  1017.     IncForcePastEOL;
    1018. 

  1018.     ValidateBytePos;
    1019. 

  1019.     p :=  AdjustPoint(Point(FBytePos, FLinePos));
    1020. 

  1020.     InternalSetLineByterPos(p.y, p.x, FBytePosOffset, [scuChangedX, scuChangedY, scuForceSet]);
    1021. 

  1021.     DecForcePastEOL;
    1022. 

  1022.   end;
    1023. 

  1023. end;
    1024. 

  1024. 

  1025. procedure TSynEditCaret.AdjustToChar;
    1026. 

  1026. var
    1027. 

  1027.   CharWidthsArr: TPhysicalCharWidths;
    1028. 

  1028.   CharWidths: PPhysicalCharWidth;
    1029. 

  1029.   i, LogLen: Integer;
    1030. 

  1030.   ScreenPos: Integer;
    1031. 

  1031.   LogPos: Integer;
    1032. 

  1032.   L: String;
    1033. 

  1033. begin
    1034. 

  1034.   ValidateCharPos;
    1035. 

  1035.   L := LineText;
    1036. 

  1036.   if FLines.LogPhysConvertor.CurrentLine = FLinePos then begin
    1037. 

  1037.     CharWidths := FLines.LogPhysConvertor.CurrentWidths;
    1038. 

  1038.     LogLen     := FLines.LogPhysConvertor.CurrentWidthsCount;
    1039. 

  1039.   end
    1040. 

  1040.   else begin
    1041. 

  1041.     CharWidthsArr := FLines.GetPhysicalCharWidths(Pchar(L), length(L), FLinePos-1);
    1042. 

  1042.     LogLen        := Length(CharWidthsArr);
    1043. 

  1043.     if LogLen > 0 then
    1044. 

  1044.       CharWidths := @CharWidthsArr[0];
    1045. 

  1045.   end;
    1046. 

  1046. 

  1047.   ScreenPos := 1;
    1048. 

  1048.   LogPos := 0;
    1049. 

  1049. 

  1050.   while LogPos < LogLen do begin
    1051. 

  1051.     if ScreenPos = FCharPos then exit;
    1052. 

  1052.     if ScreenPos + (CharWidths[LogPos] and PCWMask) > FCharPos then begin
    1053. 

  1053.       if (L[LogPos+1] = #9) and (not FSkipTabs) then exit;
    1054. 

  1054.       i := FCharPos;
    1055. 

  1055.       if FAdjustToNextChar or (FForceAdjustToNextChar > 0) then
    1056. 

  1056.         FCharPos := ScreenPos + (CharWidths[LogPos] and PCWMask)
    1057. 

  1057.       else
    1058. 

  1058.         FCharPos := ScreenPos;
    1059. 

  1059.       if FCharPos <> i then
    1060. 

  1060.         Exclude(FFlags, scBytePosValid);
    1061. 

  1061.       exit;
    1062. 

  1062.     end;
    1063. 

  1063.     ScreenPos := ScreenPos + (CharWidths[LogPos] and PCWMask);
    1064. 

  1064.     inc(LogPos);
    1065. 

  1065.   end;
    1066. 

  1066. end;
    1067. 

  1067. 

  1068. function TSynEditCaret.GetMaxLeftPastEOL: Integer;
    1069. 

  1069. begin
    1070. 

  1070.   if FMaxLeftChar <> nil then
    1071. 

  1071.     Result := FMaxLeftChar()
    1072. 

  1072.   else
    1073. 

  1073.     Result := MaxInt;
    1074. 

  1074. end;
    1075. 

  1075. 

  1076. procedure TSynEditCaret.InternalSetLineCharPos(NewLine, NewCharPos: Integer;
    1077. 

  1077.   UpdFlags: TSynEditCaretUpdateFlags);
    1078. 

  1078. var
    1079. 

  1079.   LogEolPos, MaxPhysX, NewLogCharPos, Offs: Integer;
    1080. 

  1080.   L: String;
    1081. 

  1081. begin
    1082. 

  1082.   if not (scuChangedX in UpdFlags) and FKeepCaretX then
    1083. 

  1083.     NewCharPos := FLastCharPos;
    1084. 

  1084. 

  1085.   Lock;
    1086. 

  1086.   FTouched := True;
    1087. 

  1087.   try
    1088. 

  1088.     if (fCharPos = NewCharPos) and (fLinePos = NewLine) and
    1089. 

  1089.        (scCharPosValid in FFlags) and not (scuForceSet in UpdFlags)
    1090. 

  1090.     then begin
    1091. 

  1091.       // Lines may have changed, so the other pos can be invalid
    1092. 

  1092.       if not (scuNoInvalidate in UpdFlags) then
    1093. 

  1093.         Exclude(FFlags, scBytePosValid);
    1094. 

  1094.       exit;
    1095. 

  1095.     end;
    1096. 

  1096. 

  1097.     if NewLine > FLines.Count then begin
    1098. 

  1098.       NewLine := FLines.Count;
    1099. 

  1099.       Exclude(UpdFlags, scuNoInvalidate);
    1100. 

  1100.     end;
    1101. 

  1101. 

  1102.     if NewLine < 1 then begin // Only allowed, if Lines.Count = 0
    1103. 

  1103.       NewLine := 1;
    1104. 

  1104.       if (NewCharPos > 1) and (FAllowPastEOL or (FForcePastEOL > 0))
    1105. 

  1105.       then MaxPhysX := GetMaxLeftPastEOL
    1106. 

  1106.       else MaxPhysX := 1;
    1107. 

  1107. 

  1108.       if NewCharPos > MaxPhysX then
    1109. 

  1109.         NewCharPos := MaxPhysX;
    1110. 

  1110. 

  1111.       NewLogCharPos := NewCharPos;
    1112. 

  1112.       Offs := 0;
    1113. 

  1113.       Exclude(UpdFlags, scuNoInvalidate);
    1114. 

  1114.     end else begin
    1115. 

  1115.       if FAdjustToNextChar or (FForceAdjustToNextChar > 0) then
    1116. 

  1116.         NewLogCharPos := Lines.LogPhysConvertor.PhysicalToLogical(NewLine-1, NewCharPos, Offs, cspDefault, [lpfAdjustToNextChar])
    1117. 

  1117.       else
    1118. 

  1118.         NewLogCharPos := Lines.LogPhysConvertor.PhysicalToLogical(NewLine-1, NewCharPos, Offs, cspDefault, [lpfAdjustToCharBegin]);
    1119. 

  1119.       Offs := Lines.LogPhysConvertor.UnAdjustedPhysToLogColOffs;
    1120. 

  1120.       L := Lines[NewLine - 1];
    1121. 

  1121. 

  1122.       if (Offs > 0) and (not FSkipTabs) and (L[NewLogCharPos] = #9) then begin
    1123. 

  1123.         // get the unadjusted result
    1124. 

  1124.         NewLogCharPos  := Lines.LogPhysConvertor.UnAdjustedPhysToLogResult
    1125. 

  1125.       end
    1126. 

  1126.       else begin
    1127. 

  1127.         // get adjusted Result
    1128. 

  1128.         NewCharPos := Lines.LogPhysConvertor.AdjustedPhysToLogOrigin;
    1129. 

  1129.         Offs := 0;
    1130. 

  1130.       end;
    1131. 

  1131. 

  1132.       LogEolPos := length(L)+1;
    1133. 

  1133.       if NewLogCharPos > LogEolPos then begin
    1134. 

  1134.         if FAllowPastEOL or (FForcePastEOL > 0) then begin
    1135. 

  1135.           MaxPhysX := GetMaxLeftPastEOL;
    1136. 

  1136.           if NewCharPos > MaxPhysX then begin
    1137. 

  1137.             NewLogCharPos := NewLogCharPos - (NewCharPos - MaxPhysX);
    1138. 

  1138.             NewCharPos := MaxPhysX;
    1139. 

  1139.             Exclude(UpdFlags, scuNoInvalidate);
    1140. 

  1140.           end;
    1141. 

  1141.         end
    1142. 

  1142.         else begin
    1143. 

  1143.           NewCharPos := NewCharPos - (NewLogCharPos - LogEolPos);
    1144. 

  1144.           NewLogCharPos := LogEolPos;
    1145. 

  1145.           Exclude(UpdFlags, scuNoInvalidate);
    1146. 

  1146.         end;
    1147. 

  1147.       end;
    1148. 

  1148. 

  1149.     end;
    1150. 

  1150. 

  1151.     if NewCharPos < 1 then begin
    1152. 

  1152.       NewCharPos := 1;
    1153. 

  1153.       Exclude(UpdFlags, scuNoInvalidate);
    1154. 

  1154.     end;
    1155. 

  1155. 

  1156.     inherited InternalSetLineCharPos(NewLine, NewCharPos, UpdFlags);
    1157. 

  1157.     inherited InternalSetLineByterPos(NewLine, NewLogCharPos, Offs, [scuNoInvalidate, scuChangedX]);
    1158. 

  1158. 

  1159.     if (scuChangedX in UpdFlags) or (not FKeepCaretX) then
    1160. 

  1160.       FLastCharPos := FCharPos;
    1161. 

  1161.   finally
    1162. 

  1162.     Unlock;
    1163. 

  1163.   end;
    1164. 

  1164. end;
    1165. 

  1165. 

  1166. procedure TSynEditCaret.InternalSetLineByterPos(NewLine, NewBytePos, NewByteOffs: Integer;
    1167. 

  1167.   UpdFlags: TSynEditCaretUpdateFlags);
    1168. 

  1168. var
    1169. 

  1169.   MaxPhysX, NewCharPos, LogEolPos: Integer;
    1170. 

  1170.   L: String;
    1171. 

  1171. begin
    1172. 

  1172.   if not (scuChangedX in UpdFlags) and FKeepCaretX then begin
    1173. 

  1173.     Exclude(UpdFlags, scuNoInvalidate);
    1174. 

  1174.     InternalSetLineCharPos(NewLine, FLastCharPos, UpdFlags);
    1175. 

  1175.     exit;
    1176. 

  1176.   end;
    1177. 

  1177. 

  1178.   Lock;
    1179. 

  1179.   FTouched := True;
    1180. 

  1180.   try
    1181. 

  1181.     if (FBytePos = NewBytePos) and (FBytePosOffset = NewByteOffs) and
    1182. 

  1182.        (FLinePos = NewLine) and (scBytePosValid in FFlags) and not (scuForceSet in UpdFlags)
    1183. 

  1183.     then begin
    1184. 

  1184.       // Lines may have changed, so the other pos can be invalid
    1185. 

  1185.       if not (scuNoInvalidate in UpdFlags) then
    1186. 

  1186.         Exclude(FFlags, scCharPosValid);
    1187. 

  1187.       exit;
    1188. 

  1188.     end;
    1189. 

  1189. 

  1190.     if NewLine > FLines.Count then begin
    1191. 

  1191.       NewLine := FLines.Count;
    1192. 

  1192.       Exclude(UpdFlags, scuNoInvalidate);
    1193. 

  1193.     end;
    1194. 

  1194. 

  1195.     if NewLine < 1 then begin // Only allowed, if Lines.Count = 0
    1196. 

  1196.       L := '';
    1197. 

  1197.       NewLine := 1;
    1198. 

  1198.       LogEolPos := 1;
    1199. 

  1199.       if (NewBytePos > 1) and (FAllowPastEOL or (FForcePastEOL > 0))
    1200. 

  1200.       then MaxPhysX := GetMaxLeftPastEOL
    1201. 

  1201.       else MaxPhysX := 1;
    1202. 

  1202.       if NewBytePos > MaxPhysX then
    1203. 

  1203.         NewBytePos := MaxPhysX;
    1204. 

  1204.       NewByteOffs := 0;
    1205. 

  1205.       NewCharPos := NewBytePos;
    1206. 

  1206.       Exclude(UpdFlags, scuNoInvalidate);
    1207. 

  1207.     end else begin
    1208. 

  1208.       L := Lines[NewLine - 1];
    1209. 

  1209.       LogEolPos := length(L)+1;
    1210. 

  1210. 

  1211.       if (NewBytePos > LogEolPos) then begin
    1212. 

  1212.         if not(FAllowPastEOL or (FForcePastEOL > 0)) then
    1213. 

  1213.           NewBytePos := LogEolPos;
    1214. 

  1214.         NewByteOffs := 0;
    1215. 

  1215.       end
    1216. 

  1216.       else
    1217. 

  1217.       if (NewByteOffs > 0) and ( (FSkipTabs) or (L[NewBytePos] <> #9) ) then
    1218. 

  1218.         NewByteOffs := 0;
    1219. 

  1219. 

  1220. 

  1221.       if FAdjustToNextChar or (FForceAdjustToNextChar > 0) then
    1222. 

  1222.         NewCharPos := Lines.LogPhysConvertor.LogicalToPhysical(NewLine-1, NewBytePos, NewByteOffs, cslDefault, [lpfAdjustToNextChar])
    1223. 

  1223.       else
    1224. 

  1224.         NewCharPos := Lines.LogPhysConvertor.LogicalToPhysical(NewLine-1, NewBytePos, NewByteOffs, cslDefault, [lpfAdjustToCharBegin]);
    1225. 

  1225.       NewBytePos := Lines.LogPhysConvertor.AdjustedLogToPhysOrigin;
    1226. 

  1226. 

  1227.       if (NewBytePos > LogEolPos) then begin
    1228. 

  1228.         MaxPhysX := GetMaxLeftPastEOL;
    1229. 

  1229.         if NewCharPos > MaxPhysX then begin
    1230. 

  1230.           NewBytePos := NewBytePos - (NewCharPos - MaxPhysX);
    1231. 

  1231.           NewCharPos := MaxPhysX;
    1232. 

  1232.           Exclude(UpdFlags, scuNoInvalidate);
    1233. 

  1233.         end;
    1234. 

  1234.       end;
    1235. 

  1235. 

  1236.     end;
    1237. 

  1237. 

  1238.     if NewBytePos < 1 then begin
    1239. 

  1239.       NewBytePos := 1;
    1240. 

  1240.       Exclude(UpdFlags, scuNoInvalidate);
    1241. 

  1241.     end;
    1242. 

  1242. 

  1243.     inherited InternalSetLineByterPos(NewLine, NewBytePos, NewByteOffs, UpdFlags);
    1244. 

  1244.     inherited InternalSetLineCharPos(NewLine, NewCharPos, [scuNoInvalidate, scuChangedX]);
    1245. 

  1245. 

  1246.     if (scuChangedX in UpdFlags) and FKeepCaretX then
    1247. 

  1247.       FLastCharPos := FCharPos;
    1248. 

  1248.   finally
    1249. 

  1249.     Unlock;
    1250. 

  1250.   end;
    1251. 

  1251. end;
    1252. 

  1252. 

  1253. function TSynEditCaret.GetOldLineCharPos: TPoint;
    1254. 

  1254. begin
    1255. 

  1255.   Result := Point(FOldCharPos, FOldLinePos);
    1256. 

  1256. end;
    1257. 

  1257. 

  1258. function TSynEditCaret.GetOldLineBytePos: TPoint;
    1259. 

  1259. begin
    1260. 

  1260.   Result := FLines.PhysicalToLogicalPos(OldLineCharPos);
    1261. 

  1261. end;
    1262. 

  1262. 

  1263. function TSynEditCaret.GetOldFullLogicalPos: TLogCaretPoint;
    1264. 

  1264. begin
    1265. 

  1265.   Result.Y := FOldLinePos;
    1266. 

  1266.   Result.X := FLines.LogPhysConvertor.PhysicalToLogical(ToIdx(FOldLinePos), FOldCharPos, Result.Offs);
    1267. 

  1267. end;
    1268. 

  1268. 

  1269. procedure TSynEditCaret.SetAllowPastEOL(const AValue: Boolean);
    1270. 

  1270. begin
    1271. 

  1271.   if FAllowPastEOL = AValue then exit;
    1272. 

  1272.   FAllowPastEOL := AValue;
    1273. 

  1273.   if not FAllowPastEOL then begin
    1274. 

  1274.     // TODO: this would set x=LastX
    1275. 

  1275.     //if scBytePosValid in FFlags then
    1276. 

  1276.     //  InternalSetLineByterPos(FLinePos, FBytePos, FBytePosOffset, [scuForceSet]); // NO scuChangedX => FLastCharPos is kept
    1277. 

  1277.     //else
    1278. 

  1278.     ValidateCharPos;
    1279. 

  1279.     InternalSetLineCharPos(FLinePos, FCharPos, [scuForceSet]); // NO scuChangedX => FLastCharPos is kept
    1280. 

  1280.   end;
    1281. 

  1281. end;
    1282. 

  1282. 

  1283. procedure TSynEditCaret.SetKeepCaretX(const AValue: Boolean);
    1284. 

  1284. begin
    1285. 

  1285.   if FKeepCaretX = AValue then exit;
    1286. 

  1286.   FKeepCaretX := AValue;
    1287. 

  1287.   if FKeepCaretX then begin
    1288. 

  1288.     ValidateCharPos;
    1289. 

  1289.     FLastCharPos := FCharPos;
    1290. 

  1290.   end;
    1291. 

  1291. end;
    1292. 

  1292. 

  1293. procedure TSynEditCaret.SetSkipTabs(const AValue: Boolean);
    1294. 

  1294. begin
    1295. 

  1295.   if FSkipTabs = AValue then exit;
    1296. 

  1296.   FSkipTabs := AValue;
    1297. 

  1297.   if FSkipTabs then begin
    1298. 

  1298.     Lock;
    1299. 

  1299.     AdjustToChar;
    1300. 

  1300.     Unlock;
    1301. 

  1301.   end;
    1302. 

  1302. end;
    1303. 

  1303. 

  1304. procedure TSynEditCaret.IncForcePastEOL;
    1305. 

  1305. begin
    1306. 

  1306.   inc(FForcePastEOL);
    1307. 

  1307. end;
    1308. 

  1308. 

  1309. procedure TSynEditCaret.DecForcePastEOL;
    1310. 

  1310. begin
    1311. 

  1311.   dec(FForcePastEOL);
    1312. 

  1312. end;
    1313. 

  1313. 

  1314. procedure TSynEditCaret.IncForceAdjustToNextChar;
    1315. 

  1315. begin
    1316. 

  1316.   Inc(FForceAdjustToNextChar);
    1317. 

  1317. end;
    1318. 

  1318. 

  1319. procedure TSynEditCaret.DecForceAdjustToNextChar;
    1320. 

  1320. begin
    1321. 

  1321.   Dec(FForceAdjustToNextChar);
    1322. 

  1322. end;
    1323. 

  1323. 

  1324. procedure TSynEditCaret.IncAutoMoveOnEdit;
    1325. 

  1325. begin
    1326. 

  1326.   if FAutoMoveOnEdit = 0 then begin
    1327. 

  1327.     RegisterLinesEditedHandler;
    1328. 

  1328.     ValidateBytePos;
    1329. 

  1329.   end;
    1330. 

  1330.   inc(FAutoMoveOnEdit);
    1331. 

  1331. end;
    1332. 

  1332. 

  1333. procedure TSynEditCaret.DecAutoMoveOnEdit;
    1334. 

  1334. begin
    1335. 

  1335.   dec(FAutoMoveOnEdit);
    1336. 

  1336. end;
    1337. 

  1337. 

  1338. procedure TSynEditCaret.ChangeOnTouch;
    1339. 

  1339. begin
    1340. 

  1340.   FChangeOnTouch := True;
    1341. 

  1341.   if not Locked then
    1342. 

  1342.     FTouched := False;
    1343. 

  1343. end;
    1344. 

  1344. 

  1345. procedure TSynEditCaret.Touch(aChangeOnTouch: Boolean);
    1346. 

  1346. begin
    1347. 

  1347.   if aChangeOnTouch then
    1348. 

  1348.     ChangeOnTouch;
    1349. 

  1349.   FTouched := True;
    1350. 

  1350. end;
    1351. 

  1351. 

  1352. 

  1353. function TSynEditCaret.WasAtLineChar(aPoint: TPoint): Boolean;
    1354. 

  1354. begin
    1355. 

  1355.   Result := (FOldLinePos = aPoint.y) and (FOldCharPos = aPoint.x);
    1356. 

  1356. end;
    1357. 

  1357. 

  1358. function TSynEditCaret.WasAtLineByte(aPoint: TPoint): Boolean;
    1359. 

  1359. begin
    1360. 

  1360.   Result := (FOldLinePos = aPoint.y) and
    1361. 

  1361.             (FLines.PhysicalToLogicalPos(Point(FOldCharPos, FOldLinePos)).X = aPoint.x);
    1362. 

  1362. end;
    1363. 

  1363. 

  1364. function TSynEditCaret.MoveHoriz(ACount: Integer): Boolean;
    1365. 

  1365. var
    1366. 

  1366.   L: String;
    1367. 

  1367.   CharWidths: TPhysicalCharWidths;
    1368. 

  1368.   GotCharWidths: Boolean;
    1369. 

  1369.   MaxOffs: Integer;
    1370. 

  1370.   p: Integer;
    1371. 

  1371.   NC: Boolean;
    1372. 

  1372.   NF: Integer;
    1373. 

  1373. 

  1374.   function GetMaxOffs(AlogPos: Integer): Integer;
    1375. 

  1375.   begin
    1376. 

  1376.     if not GotCharWidths then
    1377. 

  1377.       CharWidths := FLines.GetPhysicalCharWidths(Pchar(L), length(L), FLinePos-1);
    1378. 

  1378.     GotCharWidths := True;
    1379. 

  1379.     Result := CharWidths[AlogPos-1];
    1380. 

  1380.   end;
    1381. 

  1381. 

  1382. begin
    1383. 

  1383.   GotCharWidths := False;
    1384. 

  1384.   L := LineText;
    1385. 

  1385.   ValidateBytePos;
    1386. 

  1386. 

  1387.   If ACount > 0 then begin
    1388. 

  1388.     if (FBytePos <= length(L)) and (L[FBytePos] = #9) and (not FSkipTabs) then
    1389. 

  1389.       MaxOffs := GetMaxOffs(FBytePos) - 1
    1390. 

  1390.     else
    1391. 

  1391.       MaxOffs := 0;
    1392. 

  1392. 

  1393.     while ACount > 0 do begin
    1394. 

  1394.       if FBytePosOffset < MaxOffs then
    1395. 

  1395.         inc(FBytePosOffset)
    1396. 

  1396.       else begin
    1397. 

  1397.         if (FBytePos > length(L)) and not (FAllowPastEOL or (FForcePastEOL > 0)) then
    1398. 

  1398.           break;
    1399. 

  1399.         FBytePos := FLines.LogicPosAddChars(L, FBytePos, 1, True);
    1400. 

  1400.         FBytePosOffset := 0;
    1401. 

  1401.         if (FBytePos <= length(L)) and (L[FBytePos] = #9) and (not FSkipTabs) then
    1402. 

  1402.           MaxOffs := GetMaxOffs(FBytePos) - 1
    1403. 

  1403.         else
    1404. 

  1404.           MaxOffs := 0;
    1405. 

  1405.       end;
    1406. 

  1406.       dec(ACount);
    1407. 

  1407.     end;
    1408. 

  1408.     Result := ACount = 0;
    1409. 

  1409. 

  1410.     p := FBytePos;
    1411. 

  1411.     IncForceAdjustToNextChar;
    1412. 

  1412.     InternalSetLineByterPos(FLinePos, FBytePos, FBytePosOffset, [scuChangedX, scuForceSet]);
    1413. 

  1413.     DecForceAdjustToNextChar;
    1414. 

  1414.     if p > FBytePos then
    1415. 

  1415.       Result := False; // MaxLeftChar
    1416. 

  1416.   end
    1417. 

  1417.   else begin
    1418. 

  1418.     while ACount < 0 do begin
    1419. 

  1419.       if FBytePosOffset > 0 then
    1420. 

  1420.         dec(FBytePosOffset)
    1421. 

  1421.       else begin
    1422. 

  1422.         if FBytePos = 1 then
    1423. 

  1423.           break;
    1424. 

  1424.         FBytePos := FLines.LogicPosAddChars(L, FBytePos, -1, True);
    1425. 

  1425.         if (FBytePos <= length(L)) and (L[FBytePos] = #9) and (not FSkipTabs) then
    1426. 

  1426.           FBytePosOffset := GetMaxOffs(FBytePos) - 1
    1427. 

  1427.         else
    1428. 

  1428.           FBytePosOffset := 0;
    1429. 

  1429.       end;
    1430. 

  1430.       inc(ACount);
    1431. 

  1431.     end;
    1432. 

  1432.     Result := ACount = 0;
    1433. 

  1433. 

  1434.     NC := FAdjustToNextChar;
    1435. 

  1435.     NF := FForceAdjustToNextChar;
    1436. 

  1436.     FAdjustToNextChar      := False;
    1437. 

  1437.     FForceAdjustToNextChar := 0;
    1438. 

  1438.     InternalSetLineByterPos(FLinePos, FBytePos, FBytePosOffset, [scuChangedX, scuForceSet]);
    1439. 

  1439.     FAdjustToNextChar      := NC;
    1440. 

  1440.     FForceAdjustToNextChar := NF;
    1441. 

  1441.   end;
    1442. 

  1442. end;
    1443. 

  1443. 

  1444. { TSynEditSelection }
    1445. 

  1445. 

  1446. constructor TSynEditSelection.Create(ALines : TSynEditStrings; aActOnLineChanges: Boolean);
    1447. 

  1447. begin
    1448. 

  1448.   Inherited Create(ALines);
    1449. 

  1449.   FOnBeforeSetSelText := TSynBeforeSetSelTextList.Create;
    1450. 

  1450.   FInternalCaret := TSynEditBaseCaret.Create;
    1451. 

  1451.   FInternalCaret.Lines := FLines;
    1452. 

  1452. 

  1453.   FActiveSelectionMode := smNormal;
    1454. 

  1454.   FStartLinePos := 1;
    1455. 

  1455.   FStartBytePos := 1;
    1456. 

  1456.   FAltStartLinePos := -1;
    1457. 

  1457.   FAltStartBytePos := -1;
    1458. 

  1458.   FEndLinePos := 1;
    1459. 

  1459.   FEndBytePos := 1;
    1460. 

  1460.   FEnabled := True;
    1461. 

  1461.   FHookedLines := aActOnLineChanges;
    1462. 

  1462.   FIsSettingText := False;
    1463. 

  1463.   if FHookedLines then begin
    1464. 

  1464.     FLines.AddEditHandler(@DoLinesEdited);
    1465. 

  1465.     FLines.AddChangeHandler(senrLineChange, @LineChanged);
    1466. 

  1466.   end;
    1467. 

  1467. end;
    1468. 

  1468. 

  1469. destructor TSynEditSelection.Destroy;
    1470. 

  1470. begin
    1471. 

  1471.   FreeAndNil(FOnBeforeSetSelText);
    1472. 

  1472.   FreeAndNil(FInternalCaret);
    1473. 

  1473.   if FHookedLines then begin
    1474. 

  1474.     FLines.RemoveEditHandler(@DoLinesEdited);
    1475. 

  1475.     FLines.RemoveChangeHandler(senrLineChange, @LineChanged);
    1476. 

  1476.   end;
    1477. 

  1477.   inherited Destroy;
    1478. 

  1478. end;
    1479. 

  1479. 

  1480. procedure TSynEditSelection.AssignFrom(Src: TSynEditSelection);
    1481. 

  1481. begin
    1482. 

  1482.   //FEnabled             := src.FEnabled;
    1483. 

  1483.   FHide                := src.FHide;
    1484. 

  1484.   FActiveSelectionMode := src.FActiveSelectionMode;
    1485. 

  1485.   FSelectionMode       := src.FSelectionMode;
    1486. 

  1486.   FStartLinePos        := src.FStartLinePos; // 1 based
    1487. 

  1487.   FStartBytePos        := src.FStartBytePos; // 1 based
    1488. 

  1488.   FEndLinePos          := src.FEndLinePos; // 1 based
    1489. 

  1489.   FEndBytePos          := src.FEndBytePos; // 1 based
    1490. 

  1490.   FPersistent          := src.FPersistent;
    1491. 

  1491. end;
    1492. 

  1492. 

  1493. procedure TSynEditSelection.AdjustAfterTrimming;
    1494. 

  1494. begin
    1495. 

  1495.   if FStartBytePos > Length(FLines[FStartLinePos-1]) + 1 then
    1496. 

  1496.     FStartBytePos := Length(FLines[FStartLinePos-1]) + 1;
    1497. 

  1497.   if FEndBytePos > Length(FLines[FEndLinePos-1]) + 1 then
    1498. 

  1498.     FEndBytePos := Length(FLines[FEndLinePos-1]) + 1;
    1499. 

  1499.   // Todo: Call ChangeNotification
    1500. 

  1500. end;
    1501. 

  1501. 

  1502. procedure TSynEditSelection.DoLock;
    1503. 

  1503. begin
    1504. 

  1504.   inherited DoLock;
    1505. 

  1505.   FLastCarePos := Point(-1, -1);
    1506. 

  1506. end;
    1507. 

  1507. 

  1508. procedure TSynEditSelection.DoUnlock;
    1509. 

  1509. begin
    1510. 

  1510.   inherited DoUnlock;
    1511. 

  1511.   FLastCarePos := Point(-1, -1);
    1512. 

  1512. end;
    1513. 

  1513. 

  1514. function TSynEditSelection.GetSelText : string;
    1515. 

  1515. 

  1516.   function CopyPadded(const S: string; Index, Count: integer): string;
    1517. 

  1517.   var
    1518. 

  1518.     SrcLen: Integer;
    1519. 

  1519.     DstLen: integer;
    1520. 

  1520.     P: PChar;
    1521. 

  1521.   begin
    1522. 

  1522.     SrcLen := Length(S);
    1523. 

  1523.     DstLen := Index + Count;
    1524. 

  1524.     if SrcLen >= DstLen then
    1525. 

  1525.       Result := Copy(S, Index, Count)
    1526. 

  1526.     else begin
    1527. 

  1527.       SetLength(Result, DstLen);
    1528. 

  1528.       P := PChar(Pointer(Result));
    1529. 

  1529.       StrPCopy(P, Copy(S, Index, Count));
    1530. 

  1530.       Inc(P, SrcLen);
    1531. 

  1531.       FillChar(P^, DstLen - Srclen, $20);
    1532. 

  1532.     end;
    1533. 

  1533.   end;
    1534. 

  1534. 

  1535.   procedure CopyAndForward(const S: string; Index, Count: Integer; var P:
    1536. 

  1536.     PChar);
    1537. 

  1537.   var
    1538. 

  1538.     pSrc: PChar;
    1539. 

  1539.     SrcLen: Integer;
    1540. 

  1540.     DstLen: Integer;
    1541. 

  1541.   begin
    1542. 

  1542.     SrcLen := Length(S);
    1543. 

  1543.     if (Index <= SrcLen) and (Count > 0) then begin
    1544. 

  1544.       Dec(Index);
    1545. 

  1545.       pSrc := PChar(Pointer(S)) + Index;
    1546. 

  1546.       DstLen := Min(SrcLen - Index, Count);
    1547. 

  1547.       Move(pSrc^, P^, DstLen);
    1548. 

  1548.       Inc(P, DstLen);
    1549. 

  1549.       P^ := #0;
    1550. 

  1550.     end;
    1551. 

  1551.   end;
    1552. 

  1552. 

  1553.   procedure CopyPaddedAndForward(const S: string; Index, Count: Integer;
    1554. 

  1554.     var P: PChar);
    1555. 

  1555.   var
    1556. 

  1556.     OldP: PChar;
    1557. 

  1557.     Len: Integer;
    1558. 

  1558.   begin
    1559. 

  1559.     OldP := P;
    1560. 

  1560.     CopyAndForward(S, Index, Count, P);
    1561. 

  1561.     Len := Count - (P - OldP);
    1562. 

  1562.     FillChar(P^, Len, #$20);
    1563. 

  1563.     Inc(P, Len);
    1564. 

  1564.   end;
    1565. 

  1565. 

  1566. 

  1567. var
    1568. 

  1568.   First, Last, TotalLen: Integer;
    1569. 

  1569.   ColFrom, ColTo: Integer;
    1570. 

  1570.   I: Integer;
    1571. 

  1571.   P: PChar;
    1572. 

  1572.   C1, C2: Integer;
    1573. 

  1573.   Col, Len: array of Integer;
    1574. 

  1574. 

  1575. begin
    1576. 

  1576.   if not SelAvail then
    1577. 

  1577.     Result := ''
    1578. 

  1578.   else begin
    1579. 

  1579.     if IsBackwardSel then begin
    1580. 

  1580.       ColFrom := FEndBytePos;
    1581. 

  1581.       First := FEndLinePos - 1;
    1582. 

  1582.       ColTo := FStartBytePos;
    1583. 

  1583.       Last := FStartLinePos - 1;
    1584. 

  1584.     end else begin
    1585. 

  1585.       ColFrom := FStartBytePos;
    1586. 

  1586.       First := FStartLinePos - 1;
    1587. 

  1587.       ColTo := FEndBytePos;
    1588. 

  1588.       Last := FEndLinePos - 1;
    1589. 

  1589.     end;
    1590. 

  1590.     TotalLen := 0;
    1591. 

  1591.     case ActiveSelectionMode of
    1592. 

  1592.       smNormal:
    1593. 

  1593.         if (First = Last) then begin
    1594. 

  1594.           Result := Copy(FLines[First], ColFrom, ColTo - ColFrom);
    1595. 

  1595.           I := (ColTo - ColFrom) - length(Result);
    1596. 

  1596.           if I > 0 then
    1597. 

  1597.             Result := Result + StringOfChar(' ', I);
    1598. 

  1598.         end else begin
    1599. 

  1599.           // step1: calculate total length of result string
    1600. 

  1600.           TotalLen := Max(0, Length(FLines[First]) - ColFrom + 1);
    1601. 

  1601.           for i := First + 1 to Last - 1 do
    1602. 

  1602.             Inc(TotalLen, Length(FLines[i]));
    1603. 

  1603.           Inc(TotalLen, ColTo - 1);
    1604. 

  1604.           Inc(TotalLen, Length(sLineBreak) * (Last - First));
    1605. 

  1605.           // step2: build up result string
    1606. 

  1606.           SetLength(Result, TotalLen);
    1607. 

  1607.           P := PChar(Pointer(Result));
    1608. 

  1608.           CopyAndForward(FLines[First], ColFrom, MaxInt, P);
    1609. 

  1609.           CopyAndForward(sLineBreak, 1, MaxInt, P);
    1610. 

  1610.           for i := First + 1 to Last - 1 do begin
    1611. 

  1611.             CopyAndForward(FLines[i], 1, MaxInt, P);
    1612. 

  1612.             CopyAndForward(sLineBreak, 1, MaxInt, P);
    1613. 

  1613.           end;
    1614. 

  1614.           CopyPaddedAndForward(FLines[Last], 1, ColTo - 1, P);
    1615. 

  1615.         end;
    1616. 

  1616.       smColumn:
    1617. 

  1617.         begin
    1618. 

  1618.           // Calculate the byte positions for each line
    1619. 

  1619.           SetLength(Col, Last - First + 1);
    1620. 

  1620.           SetLength(Len, Last - First + 1);
    1621. 

  1621.           FInternalCaret.Invalidate;
    1622. 

  1622.           FInternalCaret.LineBytePos := FirstLineBytePos;
    1623. 

  1623.           C1 := FInternalCaret.CharPos;
    1624. 

  1624.           FInternalCaret.LineBytePos := LastLineBytePos;
    1625. 

  1625.           C2 := FInternalCaret.CharPos;
    1626. 

  1626.           if C1 > C2 then
    1627. 

  1627.             SwapInt(C1, C2);
    1628. 

  1628. 

  1629.           TotalLen := 0;
    1630. 

  1630.           for i := First to Last do begin
    1631. 

  1631.             FInternalCaret.LineCharPos := Point(C1, i + 1);
    1632. 

  1632.             Col[i - First] := FInternalCaret.BytePos;
    1633. 

  1633.             FInternalCaret.LineCharPos := Point(C2, i + 1);
    1634. 

  1634.             Len[i - First] := Max(0, FInternalCaret.BytePos - Col[i - First]);
    1635. 

  1635.             Inc(TotalLen, Len[i - First]);
    1636. 

  1636.           end;
    1637. 

  1637.           Inc(TotalLen, Length(LineEnding) * (Last - First));
    1638. 

  1638.           // build up result string
    1639. 

  1639.           SetLength(Result, TotalLen);
    1640. 

  1640.           P := PChar(Pointer(Result));
    1641. 

  1641.           for i := First to Last do begin
    1642. 

  1642.             CopyPaddedAndForward(FLines[i], Col[i-First], Len[i-First], P);
    1643. 

  1643.             if i < Last then
    1644. 

  1644.               CopyAndForward(LineEnding, 1, MaxInt, P);
    1645. 

  1645.           end;
    1646. 

  1646.         end;
    1647. 

  1647.       smLine:
    1648. 

  1648.         begin
    1649. 

  1649.           // If block selection includes LastLine,
    1650. 

  1650.           // line break code(s) of the last line will not be added.
    1651. 

  1651.           // step1: calclate total length of result string
    1652. 

  1652.           for i := First to Last do
    1653. 

  1653.             Inc(TotalLen, Length(FLines[i]) + Length(LineEnding));
    1654. 

  1654.           if Last = FLines.Count - 1 then
    1655. 

  1655.             Dec(TotalLen, Length(LineEnding));
    1656. 

  1656.           // step2: build up result string
    1657. 

  1657.           SetLength(Result, TotalLen);
    1658. 

  1658.           P := PChar(Pointer(Result));
    1659. 

  1659.           for i := First to Last - 1 do begin
    1660. 

  1660.             CopyAndForward(FLines[i], 1, MaxInt, P);
    1661. 

  1661.             CopyAndForward(LineEnding, 1, MaxInt, P);
    1662. 

  1662.           end;
    1663. 

  1663.           CopyAndForward(FLines[Last], 1, MaxInt, P);
    1664. 

  1664.           if Last < FLines.Count - 1 then
    1665. 

  1665.             CopyAndForward(LineEnding, 1, MaxInt, P);
    1666. 

  1666.         end;
    1667. 

  1667.     end;
    1668. 

  1668.   end;
    1669. 

  1669. end;
    1670. 

  1670. 

  1671. procedure TSynEditSelection.SetSelText(const Value : string);
    1672. 

  1672. begin
    1673. 

  1673.   SetSelTextPrimitive(FActiveSelectionMode, PChar(Value));
    1674. 

  1674. end;
    1675. 

  1675. 

  1676. procedure TSynEditSelection.DoCaretChanged(Sender: TObject);
    1677. 

  1677. 

  1678.   procedure SwapAltStart;
    1679. 

  1679.   var
    1680. 

  1680.     x, y: Integer;
    1681. 

  1681.   begin
    1682. 

  1682.     if FAltStartLinePos < FStartLinePos then
    1683. 

  1683.       FInvalidateLinesMethod(FAltStartLinePos, FStartLinePos)
    1684. 

  1684.     else
    1685. 

  1685.       FInvalidateLinesMethod(FStartLinePos, FAltStartLinePos);
    1686. 

  1686.     y := FAltStartLinePos;
    1687. 

  1687.     x := FAltStartBytePos;
    1688. 

  1688.     FAltStartLinePos := FStartLinePos;
    1689. 

  1689.     FAltStartBytePos := FStartBytePos;
    1690. 

  1690.     FStartLinePos := y;
    1691. 

  1691.     FStartBytePos := x;
    1692. 

  1692.   end;
    1693. 

  1693. 

  1694.   procedure FixMinimumSelection;
    1695. 

  1695.   begin
    1696. 

  1696.     if FAltStartLinePos < 0 then exit;
    1697. 

  1697.     case ComparePoints(Point(FAltStartBytePos, FAltStartLinePos), StartLineBytePos) of
    1698. 

  1698.       -1: begin // alt is before start
    1699. 

  1699.           if ComparePoints(StartLineBytePos, EndLineBytePos) <= 0 then
    1700. 

  1700.             SwapAltStart;
    1701. 

  1701.         end;
    1702. 

  1702.       1: begin // start is before alt
    1703. 

  1703.           if ComparePoints(StartLineBytePos, EndLineBytePos) >= 0 then
    1704. 

  1704.             SwapAltStart;
    1705. 

  1705.         end;
    1706. 

  1706.     end;
    1707. 

  1707.   end;
    1708. 

  1708. 

  1709. var
    1710. 

  1710.   f: Boolean;
    1711. 

  1711. begin
    1712. 

  1712.   // FIgnoreNextCaretMove => caret skip selection
    1713. 

  1713.   if FIgnoreNextCaretMove then begin
    1714. 

  1714.     FIgnoreNextCaretMove := False;
    1715. 

  1715.     FLastCarePos := Point(-1, -1);
    1716. 

  1716.     exit;
    1717. 

  1717.   end;
    1718. 

  1718. 

  1719.   if (FCaret.IsAtLineByte(StartLineBytePos) or
    1720. 

  1720.       FCaret.IsAtLineByte(EndLineBytePos)) and
    1721. 

  1721.      FCaret.WasAtLineChar(FLastCarePos)
    1722. 

  1722.   then
    1723. 

  1723.     exit;
    1724. 

  1724.   FLastCarePos := Point(-1, -1);
    1725. 

  1725. 

  1726.   if FAutoExtend or FStickyAutoExtend then begin
    1727. 

  1727.     f := FStickyAutoExtend;
    1728. 

  1728.     if (not FHide) and (FCaret.WasAtLineByte(EndLineBytePos)) then begin
    1729. 

  1729.       SetEndLineBytePos(FCaret.LineBytePos);
    1730. 

  1730.       FixMinimumSelection;
    1731. 

  1731.     end
    1732. 

  1732.     else
    1733. 

  1733.     if (not FHide) and (FCaret.WasAtLineByte(StartLineBytePos)) then begin
    1734. 

  1734.       AdjustStartLineBytePos(FCaret.LineBytePos);
    1735. 

  1735.       FAltStartLinePos := -1;
    1736. 

  1736.       FAltStartBytePos := -1;
    1737. 

  1737.     end
    1738. 

  1738.     else begin
    1739. 

  1739.       StartLineBytePos := Point(FCaret.OldCharPos, FCaret.OldLinePos);
    1740. 

  1740.       EndLineBytePos := FCaret.LineBytePos;
    1741. 

  1741.       if Persistent and IsBackwardSel then
    1742. 

  1742.         SortSelectionPoints;
    1743. 

  1743.     end;
    1744. 

  1744.     FStickyAutoExtend := f;
    1745. 

  1745.     exit;
    1746. 

  1746.   end;
    1747. 

  1747. 

  1748.   if FPersistent or (FPersistentLock > 0) then
    1749. 

  1749.     exit;
    1750. 

  1750. 

  1751.   StartLineBytePos := FCaret.LineBytePos;
    1752. 

  1752. end;
    1753. 

  1753. 

  1754. procedure TSynEditSelection.LineChanged(Sender: TSynEditStrings; AIndex, ACount: Integer);
    1755. 

  1755. var
    1756. 

  1756.   i, i2: Integer;
    1757. 

  1757. begin
    1758. 

  1758.   if (FCaret <> nil) and (not FCaret.AllowPastEOL) and (not FIsSettingText) then begin
    1759. 

  1759.     i := ToPos(AIndex);
    1760. 

  1760.     i2 := i + ACount - 1;
    1761. 

  1761. 

  1762.     //AdjustAfterTrimming;
    1763. 

  1763.     if (FStartLinePos >= i) and (FStartLinePos <= i2) then
    1764. 

  1764.       if FStartBytePos > Length(FLines[FStartLinePos-1]) + 1 then
    1765. 

  1765.         FStartBytePos := Length(FLines[FStartLinePos-1]) + 1;
    1766. 

  1766.     if (FEndLinePos >= i) and (FEndLinePos <= i2) then
    1767. 

  1767.       if FEndBytePos > Length(FLines[FEndLinePos-1]) + 1 then
    1768. 

  1768.         FEndBytePos := Length(FLines[FEndLinePos-1]) + 1;
    1769. 

  1769.   end;
    1770. 

  1770. end;
    1771. 

  1771. 

  1772. procedure TSynEditSelection.DoLinesEdited(Sender: TSynEditStrings; aLinePos, aBytePos, aCount,
    1773. 

  1773.   aLineBrkCnt: Integer; aText: String);
    1774. 

  1774. 

  1775.   function AdjustPoint(aPoint: Tpoint; AIsStart: Boolean): TPoint; inline;
    1776. 

  1776.   begin
    1777. 

  1777.     Result := aPoint;
    1778. 

  1778.     if aLineBrkCnt < 0 then begin
    1779. 

  1779.       (* Lines Deleted *)
    1780. 

  1780.       if aPoint.y > aLinePos then begin
    1781. 

  1781.         Result.y := Max(aLinePos, Result.y + aLineBrkCnt);
    1782. 

  1782.         if Result.y = aLinePos then
    1783. 

  1783.           Result.x := Result.x + aBytePos - 1;
    1784. 

  1784.       end;
    1785. 

  1785.     end
    1786. 

  1786.     else
    1787. 

  1787.     if aLineBrkCnt > 0 then begin
    1788. 

  1788.       (* Lines Inserted *)
    1789. 

  1789.       if (aPoint.y = aLinePos) and (aPoint.x >= aBytePos) then begin
    1790. 

  1790.         Result.x := Result.x - aBytePos + 1;
    1791. 

  1791.         Result.y := Result.y + aLineBrkCnt;
    1792. 

  1792.       end;
    1793. 

  1793.       if aPoint.y > aLinePos then begin
    1794. 

  1794.         Result.y := Result.y + aLineBrkCnt;
    1795. 

  1795.       end;
    1796. 

  1796.     end
    1797. 

  1797.     else
    1798. 

  1798.     if aCount <> 0 then begin
    1799. 

  1799.       (* Chars Insert/Deleted *)
    1800. 

  1800.       if (aPoint.y = aLinePos) then begin
    1801. 

  1801.         if (FWeakPersistentIdx > 0) and (FWeakPersistentIdx > FStrongPersistentIdx) then begin
    1802. 

  1802.           if (AIsStart and (aPoint.x >= aBytePos)) or
    1803. 

  1803.              (not AIsStart and (aPoint.x > aBytePos))
    1804. 

  1804.           then
    1805. 

  1805.             Result.x := Max(aBytePos, Result.x + aCount);
    1806. 

  1806.         end
    1807. 

  1807.         else
    1808. 

  1808.         if (FStrongPersistentIdx > 0) then begin
    1809. 

  1809.           if (AIsStart and (aPoint.x > aBytePos)) or
    1810. 

  1810.              (not AIsStart and (aPoint.x >= aBytePos))
    1811. 

  1811.           then
    1812. 

  1812.             Result.x := Max(aBytePos, Result.x + aCount);
    1813. 

  1813.         end
    1814. 

  1814.         else begin
    1815. 

  1815.           if (aPoint.x >= aBytePos) then
    1816. 

  1816.             Result.x := Max(aBytePos, Result.x + aCount);
    1817. 

  1817.         end;
    1818. 

  1818.       end;
    1819. 

  1819.     end;
    1820. 

  1820.   end;
    1821. 

  1821. 

  1822. begin
    1823. 

  1823.   if FIsSettingText then exit;
    1824. 

  1824.   if FPersistent or (FPersistentLock > 0) or
    1825. 

  1825.      ((FCaret <> nil) and (not FCaret.Locked))
    1826. 

  1826.   then begin
    1827. 

  1827.     if FActiveSelectionMode <> smColumn then begin // TODO: adjust ypos, height in smColumn mode
    1828. 

  1828.       AdjustStartLineBytePos(AdjustPoint(StartLineBytePos, True));
    1829. 

  1829.       EndLineBytePos := AdjustPoint(EndLineBytePos, False);
    1830. 

  1830.     end;
    1831. 

  1831.     // Todo: Change Lines in smColumn
    1832. 

  1832.   end
    1833. 

  1833.   else begin
    1834. 

  1834.     // Change the Selection, if change was made by owning SynEdit (Caret.Locked)
    1835. 

  1835.     // (InternalSelection has no Caret)
    1836. 

  1836.     if (FCaret <> nil) and (FCaret.Locked) then
    1837. 

  1837.       StartLineBytePos := FCaret.LineBytePos;
    1838. 

  1838.   end;
    1839. 

  1839. end;
    1840. 

  1840. 

  1841. procedure TSynEditSelection.SetSelTextPrimitive(PasteMode : TSynSelectionMode;
    1842. 

  1842.   Value : PChar; AReplace: Boolean = False);
    1843. 

  1843. var
    1844. 

  1844.   BB, BE: TPoint;
    1845. 

  1845. 

  1846.   procedure DeleteSelection;
    1847. 

  1847.   var
    1848. 

  1848.     y, l, r, xb, xe: Integer;
    1849. 

  1849.     Str: string;
    1850. 

  1850.     Start, P: PChar;
    1851. 

  1851.     //LogCaretXY: TPoint;
    1852. 

  1852.   begin
    1853. 

  1853.     case ActiveSelectionMode of
    1854. 

  1854.       smNormal, smLine:
    1855. 

  1855.         begin
    1856. 

  1856.           if FLines.Count > 0 then begin
    1857. 

  1857. 

  1858.             if AReplace and (Value <> nil) then begin
    1859. 

  1859.               // AReplace = True
    1860. 

  1860.               while Value^ <> #0 do begin
    1861. 

  1861.                 Start := PChar(Value);
    1862. 

  1862.                 P := GetEOL(Start);
    1863. 

  1863.                 Value := P;
    1864. 

  1864. 

  1865.                 if Value^ = #13 then Inc(Value);
    1866. 

  1866.                 if Value^ = #10 then Inc(Value);
    1867. 

  1867. 

  1868.                 SetString(Str, Start, P - Start);
    1869. 

  1869. 

  1870.                 if BE.y > BB.y then begin
    1871. 

  1871. //                  FLines.EditDelete(BB.x, BB.Y, 1+Length(FLines[BB.y-1]) - BB.x);
    1872. 

  1872. ////                  if Str <> '' then
    1873. 

  1873. //                  FLines.EditInsert(BB.x, BB.Y, Str);
    1874. 

  1874.                   FLines.EditReplace(BB.x, BB.Y, 1+Length(FLines[BB.y-1]) - BB.x, Str);
    1875. 

  1875.                   if (PasteMode = smLine) or (Value > P) then begin
    1876. 

  1876.                     inc(BB.y);
    1877. 

  1877.                     BB.x := 1;
    1878. 

  1878.                   end
    1879. 

  1879.                   else
    1880. 

  1880.                     BB.X := BB.X + length(Str);
    1881. 

  1881.                 end
    1882. 

  1882.                 else begin
    1883. 

  1883.                   // BE will be block-.nd, also used by SynEdit to set caret
    1884. 

  1884.                   if (ActiveSelectionMode = smLine) or (Value > P) then begin
    1885. 

  1885.                     FLines.EditReplace(BB.x, BB.Y, BE.x - BB.x, Str);
    1886. 

  1886.                     FLines.EditLineBreak(BB.x+length(Str), BB.Y);
    1887. 

  1887.                     //FLines.EditDelete(BB.x, BB.Y, BE.x - BB.x);
    1888. 

  1888.                     //FLines.EditLineBreak(BB.x, BB.Y);
    1889. 

  1889.                     //FLines.EditInsert(BB.x, BB.Y, Str);
    1890. 

  1890.                     inc(BE.y);
    1891. 

  1891.                     BE.x := 1;
    1892. 

  1892.                   end
    1893. 

  1893.                   else begin
    1894. 

  1894.                     //FLines.EditDelete(BB.x, BB.Y, BE.x - BB.x);
    1895. 

  1895. //                  if Str <> '' then
    1896. 

  1896.                     //FLines.EditInsert(BB.x, BB.Y, Str);
    1897. 

  1897.                     FLines.EditReplace(BB.x, BB.Y, BE.x - BB.x, Str);
    1898. 

  1898.                     BE.X := BB.X + length(Str);
    1899. 

  1899.                   end;
    1900. 

  1900.                   BB := BE; // end of selection
    1901. 

  1901.                 end;
    1902. 

  1902. 

  1903.                 if (BB.Y = BE.Y) and (BB.X = BE.X) then begin
    1904. 

  1904.                   FInternalCaret.LineBytePos := BB;
    1905. 

  1905.                   exit;
    1906. 

  1906.                 end;
    1907. 

  1907. 

  1908.               end;
    1909. 

  1909.             end;
    1910. 

  1910. 

  1911.             // AReplace = False
    1912. 

  1912.             if BE.Y > BB.Y + 1 then begin
    1913. 

  1913.               FLines.EditLinesDelete(BB.Y + 1, BE.Y - BB.Y - 1);
    1914. 

  1914.               BE.Y := BB.Y + 1;
    1915. 

  1915.             end;
    1916. 

  1916.             if BE.Y > BB.Y then begin
    1917. 

  1917.               l := length(FLines[BB.Y - 1]);
    1918. 

  1918.               BE.X := BE.X + Max(l, BB.X - 1);
    1919. 

  1919.               FLines.EditLineJoin(BB.Y, StringOfChar(' ', Max(0, BB.X - (l+1))));
    1920. 

  1920.               BE.Y := BB.Y;
    1921. 

  1921.             end;
    1922. 

  1922.             if BE.X <> BB.X then
    1923. 

  1923.               FLines.EditDelete(BB.X, BB.Y, BE.X - BB.X);
    1924. 

  1924.           end;
    1925. 

  1925.           FInternalCaret.LineBytePos := BB;
    1926. 

  1926.         end;
    1927. 

  1927.       smColumn:
    1928. 

  1928.         begin
    1929. 

  1929.           // AReplace has no effect
    1930. 

  1930.           FInternalCaret.LineBytePos := BB;
    1931. 

  1931.           l := FInternalCaret.CharPos;
    1932. 

  1932.           FInternalCaret.LineBytePos := BE;
    1933. 

  1933.           r := FInternalCaret.CharPos;
    1934. 

  1934.           // swap l, r if needed
    1935. 

  1935.           if l > r then
    1936. 

  1936.             SwapInt(l, r);
    1937. 

  1937.           for y := BB.Y to BE.Y do begin
    1938. 

  1938.             FInternalCaret.LineCharPos := Point(l, y);
    1939. 

  1939.             xb := FInternalCaret.BytePos;
    1940. 

  1940.             FInternalCaret.LineCharPos := Point(r, y);
    1941. 

  1941.             xe := Min(FInternalCaret.BytePos, 1 + length(FInternalCaret.LineText));
    1942. 

  1942.             if xe > xb then
    1943. 

  1943.               FLines.EditDelete(xb, y, xe - xb);
    1944. 

  1944.           end;
    1945. 

  1945.           FInternalCaret.LineCharPos := Point(l, BB.Y);
    1946. 

  1946.           BB := FInternalCaret.LineBytePos;
    1947. 

  1947.           // Column deletion never removes a line entirely,
    1948. 

  1948.           // so no (vertical) mark updating is needed here.
    1949. 

  1949.         end;
    1950. 

  1950.     end;
    1951. 

  1951.   end;
    1952. 

  1952. 

  1953.   procedure InsertText;
    1954. 

  1954. 

  1955.     function CountLines(p: PChar): integer;
    1956. 

  1956.     begin
    1957. 

  1957.       Result := 0;
    1958. 

  1958.       while p^ <> #0 do begin
    1959. 

  1959.         if p^ = #13 then
    1960. 

  1960.           Inc(p);
    1961. 

  1961.         if p^ = #10 then
    1962. 

  1962.           Inc(p);
    1963. 

  1963.         Inc(Result);
    1964. 

  1964.         p := GetEOL(p);
    1965. 

  1965.       end;
    1966. 

  1966.     end;
    1967. 

  1967. 

  1968.     function InsertNormal: Integer;
    1969. 

  1969.     var
    1970. 

  1970.       Str: string;
    1971. 

  1971.       Start: PChar;
    1972. 

  1972.       P: PChar;
    1973. 

  1973.       LogCaretXY: TPoint;
    1974. 

  1974.     begin
    1975. 

  1975.       Result := 0;
    1976. 

  1976.       LogCaretXY := FInternalCaret.LineBytePos;
    1977. 

  1977. 

  1978.       Start := PChar(Value);
    1979. 

  1979.       P := GetEOL(Start);
    1980. 

  1980.       if P^ = #0 then begin
    1981. 

  1981.         FLines.EditInsert(LogCaretXY.X, LogCaretXY.Y, Value);
    1982. 

  1982.         FInternalCaret.BytePos := FInternalCaret.BytePos + Length(Value);
    1983. 

  1983.       end else begin
    1984. 

  1984.         FLines.EditLineBreak(LogCaretXY.X, LogCaretXY.Y);
    1985. 

  1985.         if (P <> Start) or (LogCaretXY.X > 1 + length(FLines[ToIdx(LogCaretXY.Y)])) then begin
    1986. 

  1986.           SetString(Str, Value, P - Start);
    1987. 

  1987.           FLines.EditInsert(LogCaretXY.X, LogCaretXY.Y, Str);
    1988. 

  1988.         end
    1989. 

  1989.         else
    1990. 

  1990.           Str := '';
    1991. 

  1991.         Result :=  CountLines(P);
    1992. 

  1992.         if Result > 1 then
    1993. 

  1993.           FLines.EditLinesInsert(LogCaretXY.Y + 1, Result - 1);
    1994. 

  1994.         while P^ <> #0 do begin
    1995. 

  1995.           if P^ = #13 then
    1996. 

  1996.             Inc(P);
    1997. 

  1997.           if P^ = #10 then
    1998. 

  1998.             Inc(P);
    1999. 

  1999.           LogCaretXY.Y := LogCaretXY.Y + 1;
    2000. 

  2000.           Start := P;
    2001. 

  2001.           P := GetEOL(Start);
    2002. 

  2002.           if P <> Start then begin
    2003. 

  2003.             SetString(Str, Start, P - Start);
    2004. 

  2004.             FLines.EditInsert(1, LogCaretXY.Y, Str);
    2005. 

  2005.           end
    2006. 

  2006.           else
    2007. 

  2007.             Str := '';
    2008. 

  2008.         end;
    2009. 

  2009.         FInternalCaret.LinePos := LogCaretXY.Y;
    2010. 

  2010.         FInternalCaret.BytePos := 1 + Length(Str);
    2011. 

  2011.       end;
    2012. 

  2012.     end;
    2013. 

  2013. 

  2014.     function InsertColumn: Integer;
    2015. 

  2015.     var
    2016. 

  2016.       Str: string;
    2017. 

  2017.       Start: PChar;
    2018. 

  2018.       P: PChar;
    2019. 

  2019.     begin
    2020. 

  2020.       // Insert string at current position
    2021. 

  2021.       Result := 0;
    2022. 

  2022.       Start := PChar(Value);
    2023. 

  2023.       repeat
    2024. 

  2024.         P := GetEOL(Start);
    2025. 

  2025.         if P <> Start then begin
    2026. 

  2026.           SetLength(Str, P - Start);
    2027. 

  2027.           Move(Start^, Str[1], P - Start);
    2028. 

  2028.           FLines.EditInsert(FInternalCaret.BytePos, FInternalCaret.LinePos, Str);
    2029. 

  2029.         end;
    2030. 

  2030.         if p^ in [#10,#13] then begin
    2031. 

  2031.           if (p[1] in [#10,#13]) and (p[1]<>p^) then
    2032. 

  2032.             inc(p,2)
    2033. 

  2033.           else
    2034. 

  2034.             Inc(P);
    2035. 

  2035.           if FInternalCaret.LinePos = FLines.Count then
    2036. 

  2036.             FLines.EditLinesInsert(FInternalCaret.LinePos + 1, 1);
    2037. 

  2037.             // No need to inc result => adding at EOF
    2038. 

  2038.           FInternalCaret.LinePos := FInternalCaret.LinePos + 1;
    2039. 

  2039.         end;
    2040. 

  2040.         Start := P;
    2041. 

  2041.       until P^ = #0;
    2042. 

  2042.       FInternalCaret.BytePos:= FInternalCaret.BytePos + Length(Str);
    2043. 

  2043.     end;
    2044. 

  2044. 

  2045.     function InsertLine: Integer;
    2046. 

  2046.     var
    2047. 

  2047.       Start: PChar;
    2048. 

  2048.       P: PChar;
    2049. 

  2049.       Str: string;
    2050. 

  2050.     begin
    2051. 

  2051.       Result := 0;
    2052. 

  2052.       FInternalCaret.CharPos := 1;
    2053. 

  2053.       // Insert string before current line
    2054. 

  2054.       Start := PChar(Value);
    2055. 

  2055.       repeat
    2056. 

  2056.         P := GetEOL(Start);
    2057. 

  2057.         if P <> Start then begin
    2058. 

  2058.           SetLength(Str, P - Start);
    2059. 

  2059.           Move(Start^, Str[1], P - Start);
    2060. 

  2060.         end else
    2061. 

  2061.           Str := '';
    2062. 

  2062.         if (P^ = #0) then begin  // Not a full line?
    2063. 

  2063.           FLines.EditInsert(1, FInternalCaret.LinePos, Str);
    2064. 

  2064.           FInternalCaret.BytePos := 1 + Length(Str);
    2065. 

  2065.         end else begin
    2066. 

  2066.           FLines.EditLinesInsert(FInternalCaret.LinePos, 1, Str);
    2067. 

  2067.           FInternalCaret.LinePos := FInternalCaret.LinePos + 1;
    2068. 

  2068.           Inc(Result);
    2069. 

  2069.           if P^ = #13 then
    2070. 

  2070.             Inc(P);
    2071. 

  2071.           if P^ = #10 then
    2072. 

  2072.             Inc(P);
    2073. 

  2073.           Start := P;
    2074. 

  2074.         end;
    2075. 

  2075.       until P^ = #0;
    2076. 

  2076.     end;
    2077. 

  2077. 

  2078.   begin
    2079. 

  2079.     if Value = '' then
    2080. 

  2080.       Exit;
    2081. 

  2081.     if FLines.Count = 0 then
    2082. 

  2082.       FLines.Add('');
    2083. 

  2083. 

  2084.     // Using a TStringList to do this would be easier, but if we're dealing
    2085. 

  2085.     // with a large block of text, it would be very inefficient.  Consider:
    2086. 

  2086.     // Assign Value parameter to TStringList.Text: that parses through it and
    2087. 

  2087.     // creates a copy of the string for each line it finds.  That copy is passed
    2088. 

  2088.     // to the Add method, which in turn creates a copy.  Then, when you actually
    2089. 

  2089.     // use an item in the list, that creates a copy to return to you.  That's
    2090. 

  2090.     // 3 copies of every string vs. our one copy below.  I'd prefer no copies,
    2091. 

  2091.     // but we aren't set up to work with PChars that well.
    2092. 

  2092. 

  2093.     case PasteMode of
    2094. 

  2094.       smNormal:
    2095. 

  2095.         InsertNormal;
    2096. 

  2096.       smColumn:
    2097. 

  2097.         InsertColumn;
    2098. 

  2098.       smLine:
    2099. 

  2099.         InsertLine;
    2100. 

  2100.     end;
    2101. 

  2101.   end;
    2102. 

  2102. 

  2103. begin
    2104. 

  2104.   FOnBeforeSetSelText.CallBeforeSetSelTextHandlers(Self, PasteMode, Value);
    2105. 

  2105.   FIsSettingText := True;
    2106. 

  2106.   FStickyAutoExtend := False;
    2107. 

  2107.   FLines.BeginUpdate; // Todo: can we get here, without paintlock?
    2108. 

  2108.   try
    2109. 

  2109.     // BB is lower than BE
    2110. 

  2110.     BB := FirstLineBytePos;
    2111. 

  2111.     BE := LastLineBytePos;
    2112. 

  2112.     FInternalCaret.Invalidate;
    2113. 

  2113.     if SelAvail then begin
    2114. 

  2114.       if FActiveSelectionMode = smLine then begin
    2115. 

  2115.         BB.X := 1;
    2116. 

  2116.         if BE.Y = FLines.Count then begin
    2117. 

  2117.           // Keep the (CrLf of) last line, since no Line exists to replace it
    2118. 

  2118.           BE.x := 1 + length(FLines[BE.Y - 1]);
    2119. 

  2119.         end else begin
    2120. 

  2120.           inc(BE.Y);
    2121. 

  2121.           BE.x := 1;
    2122. 

  2122.         end;
    2123. 

  2123.       end;
    2124. 

  2124.       DeleteSelection;
    2125. 

  2125.       StartLineBytePos := BB; // deletes selection // calls selection changed
    2126. 

  2126.       // Need to update caret (syncro edit follows on every edit)
    2127. 

  2127.       if FCaret <> nil then
    2128. 

  2128.         FCaret.LineCharPos := FInternalCaret.LineCharPos; // must equal BB
    2129. 

  2129.     end
    2130. 

  2130.     else
    2131. 

  2131.     if FCaret <> nil then
    2132. 

  2132.       StartLineBytePos := FCaret.LineBytePos;
    2133. 

  2133. 

  2134.     FInternalCaret.LineBytePos := StartLineBytePos;
    2135. 

  2135.     if (Value <> nil) and (Value[0] <> #0) then begin
    2136. 

  2136.       InsertText;
    2137. 

  2137.       StartLineBytePos := FInternalCaret.LineBytePos; // reset selection
    2138. 

  2138.     end;
    2139. 

  2139.     if FCaret <> nil then
    2140. 

  2140.       FCaret.LineCharPos := FInternalCaret.LineCharPos;
    2141. 

  2141.   finally
    2142. 

  2142.     FLines.EndUpdate;
    2143. 

  2143.     FIsSettingText := False;
    2144. 

  2144.   end;
    2145. 

  2145. end;
    2146. 

  2146. 

  2147. function TSynEditSelection.GetStartLineBytePos : TPoint;
    2148. 

  2148. begin
    2149. 

  2149.   Result.y := FStartLinePos;
    2150. 

  2150.   Result.x := FStartBytePos;
    2151. 

  2151. end;
    2152. 

  2152. 

  2153. procedure TSynEditSelection.SetEnabled(const Value : Boolean);
    2154. 

  2154. begin
    2155. 

  2155.   if FEnabled = Value then exit;
    2156. 

  2156.   FEnabled := Value;
    2157. 

  2157.   if not Enabled then SetStartLineBytePos(StartLineBytePos);
    2158. 

  2158. end;
    2159. 

  2159. 

  2160. procedure TSynEditSelection.ConstrainStartLineBytePos(var Value: TPoint);
    2161. 

  2161. begin
    2162. 

  2162.   Value.y := MinMax(Value.y, 1, fLines.Count);
    2163. 

  2163. 

  2164.   if (FCaret = nil) or FCaret.AllowPastEOL then
    2165. 

  2165.     Value.x := Max(Value.x, 1)
    2166. 

  2166.   else
    2167. 

  2167.     Value.x := MinMax(Value.x, 1, length(Lines[Value.y - 1])+1);
    2168. 

  2168. 

  2169.   if (ActiveSelectionMode = smNormal) then begin
    2170. 

  2170.     if (Value.y >= 1) and (Value.y <= FLines.Count) then
    2171. 

  2171.       Value.x := AdjustBytePosToCharacterStart(Value.y,Value.x)
    2172. 

  2172.     else
    2173. 

  2173.       Value.x := 1;
    2174. 

  2174.   end;
    2175. 

  2175. end;
    2176. 

  2176. 

  2177. procedure TSynEditSelection.SetStartLineBytePos(Value : TPoint);
    2178. 

  2178. // logical position (byte)
    2179. 

  2179. var
    2180. 

  2180.   nInval1, nInval2: integer;
    2181. 

  2181.   WasAvail: boolean;
    2182. 

  2182. begin
    2183. 

  2183.   FStickyAutoExtend := False;
    2184. 

  2184.   FAltStartLinePos := -1;
    2185. 

  2185.   FAltStartBytePos := -1;
    2186. 

  2186.   WasAvail := SelAvail;
    2187. 

  2187. 

  2188.   ConstrainStartLineBytePos(Value);
    2189. 

  2189. 

  2190.   if WasAvail then begin
    2191. 

  2191.     if FStartLinePos < FEndLinePos then begin
    2192. 

  2192.       nInval1 := Min(Value.Y, FStartLinePos);
    2193. 

  2193.       nInval2 := Max(Value.Y, FEndLinePos);
    2194. 

  2194.     end else begin
    2195. 

  2195.       nInval1 := Min(Value.Y, FEndLinePos);
    2196. 

  2196.       nInval2 := Max(Value.Y, FStartLinePos);
    2197. 

  2197.     end;
    2198. 

  2198.     FInvalidateLinesMethod(nInval1, nInval2);
    2199. 

  2199.   end;
    2200. 

  2200.   FActiveSelectionMode := FSelectionMode;
    2201. 

  2201.   FForceSingleLineSelected := False;
    2202. 

  2202.   FHide := False;
    2203. 

  2203.   FStartLinePos := Value.Y;
    2204. 

  2204.   FStartBytePos := Value.X;
    2205. 

  2205. 

  2206.   FEndLinePos := Value.Y;
    2207. 

  2207.   FEndBytePos := Value.X;
    2208. 

  2208.   if FCaret <> nil then
    2209. 

  2209.     FLastCarePos := Point(FCaret.OldCharPos, FCaret.OldLinePos);
    2210. 

  2210.   if WasAvail then
    2211. 

  2211.     fOnChangeList.CallNotifyEvents(self);
    2212. 

  2212. end;
    2213. 

  2213. 

  2214. procedure TSynEditSelection.AdjustStartLineBytePos(Value: TPoint);
    2215. 

  2215. begin
    2216. 

  2216.   if FEnabled then begin
    2217. 

  2217.     ConstrainStartLineBytePos(Value);
    2218. 

  2218. 

  2219.     if (Value.X <> FStartBytePos) or (Value.Y <> FStartLinePos) then begin
    2220. 

  2220.       if (ActiveSelectionMode = smColumn) and (Value.X <> FStartBytePos) then
    2221. 

  2221.         FInvalidateLinesMethod(Min(FStartLinePos, Min(FEndLinePos, Value.Y)),
    2222. 

  2222.                                Max(FStartLinePos, Max(FEndLinePos, Value.Y)))
    2223. 

  2223.       else
    2224. 

  2224.       if (ActiveSelectionMode <> smColumn) or (FStartBytePos <> FEndBytePos) then
    2225. 

  2225.         FInvalidateLinesMethod(FStartLinePos, Value.Y);
    2226. 

  2226. 

  2227.       FStartLinePos := Value.Y;
    2228. 

  2228.       FStartBytePos := Value.X;
    2229. 

  2229.       if FCaret <> nil then
    2230. 

  2230.         FLastCarePos := Point(FCaret.OldCharPos, FCaret.OldLinePos);
    2231. 

  2231.       FOnChangeList.CallNotifyEvents(self);
    2232. 

  2232.     end;
    2233. 

  2233.   end;
    2234. 

  2234. end;
    2235. 

  2235. 

  2236. function TSynEditSelection.GetEndLineBytePos : TPoint;
    2237. 

  2237. begin
    2238. 

  2238.   Result.y := FEndLinePos;
    2239. 

  2239.   Result.x := FEndBytePos;
    2240. 

  2240. end;
    2241. 

  2241. 

  2242. procedure TSynEditSelection.SetEndLineBytePos(Value : TPoint);
    2243. 

  2243. {$IFDEF SYN_MBCSSUPPORT}
    2244. 

  2244. var
    2245. 

  2245.   s: string;
    2246. 

  2246. {$ENDIF}
    2247. 

  2247. begin
    2248. 

  2248.   if FEnabled then begin
    2249. 

  2249.     FStickyAutoExtend := False;
    2250. 

  2250.     Value.y := MinMax(Value.y, 1, fLines.Count);
    2251. 

  2251.     if (FCaret = nil) or FCaret.AllowPastEOL then
    2252. 

  2252.       Value.x := Max(Value.x, 1)
    2253. 

  2253.     else
    2254. 

  2254.       Value.x := MinMax(Value.x, 1, length(Lines[Value.y - 1])+1);
    2255. 

  2255.     if (ActiveSelectionMode = smNormal) then
    2256. 

  2256.       if (Value.y >= 1) and (Value.y <= fLines.Count) then
    2257. 

  2257.         Value.x := AdjustBytePosToCharacterStart(Value.y,Value.x)
    2258. 

  2258.       else
    2259. 

  2259.         Value.x := 1;
    2260. 

  2260.     if (Value.X <> FEndBytePos) or (Value.Y <> FEndLinePos) then begin
    2261. 

  2261.       {$IFDEF SYN_MBCSSUPPORT}
    2262. 

  2262.       if Value.Y <= fLines.Count then begin
    2263. 

  2263.         s := fLines[Value.Y - 1];
    2264. 

  2264.         if (Length(s) >= Value.X) and (mbTrailByte = ByteType(s, Value.X)) then
    2265. 

  2265.           Dec(Value.X);
    2266. 

  2266.       end;
    2267. 

  2267.       {$ENDIF}
    2268. 

  2268. 

  2269.       if (Value.X <> FEndBytePos) or (Value.Y <> FEndLinePos) then begin
    2270. 

  2270.         if (ActiveSelectionMode = smColumn) and (Value.X <> FEndBytePos) then
    2271. 

  2271.           FInvalidateLinesMethod(Min(FStartLinePos, Min(FEndLinePos, Value.Y)),
    2272. 

  2272.                                  Max(FStartLinePos, Max(FEndLinePos, Value.Y)))
    2273. 

  2273.         else
    2274. 

  2274.         if (ActiveSelectionMode <> smColumn) or (FStartBytePos <> FEndBytePos) then
    2275. 

  2275.           FInvalidateLinesMethod(FEndLinePos, Value.Y);
    2276. 

  2276.         FEndLinePos := Value.Y;
    2277. 

  2277.         FEndBytePos := Value.X;
    2278. 

  2278.         if FCaret <> nil then
    2279. 

  2279.           FLastCarePos := Point(FCaret.OldCharPos, FCaret.OldLinePos);
    2280. 

  2280.         FOnChangeList.CallNotifyEvents(self);
    2281. 

  2281.       end;
    2282. 

  2282.     end;
    2283. 

  2283.   end;
    2284. 

  2284. end;
    2285. 

  2285. 

  2286. procedure TSynEditSelection.SetSelectionMode(const AValue: TSynSelectionMode);
    2287. 

  2287. begin
    2288. 

  2288.   FSelectionMode := AValue;
    2289. 

  2289.   SetActiveSelectionMode(AValue);
    2290. 

  2290.   fOnChangeList.CallNotifyEvents(self);
    2291. 

  2291. end;
    2292. 

  2292. 

  2293. procedure TSynEditSelection.SetActiveSelectionMode(const Value: TSynSelectionMode);
    2294. 

  2294. begin
    2295. 

  2295.   FStickyAutoExtend := False;
    2296. 

  2296.   if FActiveSelectionMode <> Value then begin
    2297. 

  2297.     FActiveSelectionMode := Value;
    2298. 

  2298.     if SelAvail then
    2299. 

  2299.       FInvalidateLinesMethod(-1, -1);
    2300. 

  2300.     FOnChangeList.CallNotifyEvents(self);
    2301. 

  2301.   end;
    2302. 

  2302. end;
    2303. 

  2303. 

  2304. procedure TSynEditSelection.SetForceSingleLineSelected(AValue: Boolean);
    2305. 

  2305. var
    2306. 

  2306.   WasAvail: Boolean;
    2307. 

  2307. begin
    2308. 

  2308.   if FForceSingleLineSelected = AValue then Exit;
    2309. 

  2309.   WasAvail := SelAvail;
    2310. 

  2310.   FForceSingleLineSelected := AValue;
    2311. 

  2311. 

  2312.   if WasAvail <> SelAvail then begin
    2313. 

  2313.     FInvalidateLinesMethod(Min(FStartLinePos, FEndLinePos),
    2314. 

  2314.                            Max(FStartLinePos, FEndLinePos) );
    2315. 

  2315.     fOnChangeList.CallNotifyEvents(self);
    2316. 

  2316.   end;
    2317. 

  2317. end;
    2318. 

  2318. 

  2319. procedure TSynEditSelection.SetHide(const AValue: Boolean);
    2320. 

  2320. begin
    2321. 

  2321.   if FHide = AValue then exit;
    2322. 

  2322.   FHide := AValue;
    2323. 

  2323.   FInvalidateLinesMethod(Min(FStartLinePos, FEndLinePos),
    2324. 

  2324.                          Max(FStartLinePos, FEndLinePos) );
    2325. 

  2325.   FOnChangeList.CallNotifyEvents(self);
    2326. 

  2326. end;
    2327. 

  2327. 

  2328. procedure TSynEditSelection.SetPersistent(const AValue: Boolean);
    2329. 

  2329. begin
    2330. 

  2330.   if FPersistent = AValue then exit;
    2331. 

  2331.   FPersistent := AValue;
    2332. 

  2332.   if (not FPersistent) and (FCaret <> nil) and
    2333. 

  2333.      not ( FCaret.IsAtLineByte(StartLineBytePos) or
    2334. 

  2334.            FCaret.IsAtLineByte(EndLineBytePos) )
    2335. 

  2335.   then
    2336. 

  2336.     Clear;
    2337. 

  2337. end;
    2338. 

  2338. 

  2339. // Only needed if the Selection is set from External
    2340. 

  2340. function TSynEditSelection.AdjustBytePosToCharacterStart(Line : integer; BytePos : integer) : integer;
    2341. 

  2341. begin
    2342. 

  2342.   Result := BytePos;
    2343. 

  2343.   if Result < 1 then
    2344. 

  2344.     Result := 1
    2345. 

  2345.   else if (Line >= 1) and (Line <= FLines.Count) then begin
    2346. 

  2346.     Result := FLines.LogicPosAdjustToChar(FLines[Line-1], Result, False);
    2347. 

  2347.   end;
    2348. 

  2348.   if Result <> BytePos then debugln(['Selection needed byte adjustment  Line=', Line, ' BytePos=', BytePos, ' Result=', Result]);
    2349. 

  2349. end;
    2350. 

  2350. 

  2351. function TSynEditSelection.GetFirstLineBytePos: TPoint;
    2352. 

  2352. begin
    2353. 

  2353.   if IsBackwardSel then
    2354. 

  2354.     Result := EndLineBytePos
    2355. 

  2355.   else
    2356. 

  2356.     Result := StartLineBytePos;
    2357. 

  2357. end;
    2358. 

  2358. 

  2359. function TSynEditSelection.GetLastLineBytePos: TPoint;
    2360. 

  2360. begin
    2361. 

  2361.   if IsBackwardSel then
    2362. 

  2362.     Result := StartLineBytePos
    2363. 

  2363.   else
    2364. 

  2364.     Result := EndLineBytePos;
    2365. 

  2365. end;
    2366. 

  2366. 

  2367. function TSynEditSelection.GetLastLineHasSelection: Boolean;
    2368. 

  2368. begin
    2369. 

  2369.   Result := (LastLineBytePos.x > 1) or ((FActiveSelectionMode = smLine) and FForceSingleLineSelected);
    2370. 

  2370. end;
    2371. 

  2371. 

  2372. procedure TSynEditSelection.SetAutoExtend(AValue: Boolean);
    2373. 

  2373. begin
    2374. 

  2374.   if FAutoExtend = AValue then Exit;
    2375. 

  2375.   FAutoExtend := AValue;
    2376. 

  2376. end;
    2377. 

  2377. 

  2378. procedure TSynEditSelection.SetCaret(const AValue: TSynEditCaret);
    2379. 

  2379. begin
    2380. 

  2380.   if FCaret = AValue then exit;
    2381. 

  2381.   if FCaret <> nil then
    2382. 

  2382.     Caret.RemoveChangeHandler(@DoCaretChanged);
    2383. 

  2383.   FCaret := AValue;
    2384. 

  2384.   if FCaret <> nil then
    2385. 

  2385.     Caret.AddChangeHandler(@DoCaretChanged);
    2386. 

  2386. end;
    2387. 

  2387. 

  2388. function TSynEditSelection.SelAvail : Boolean;
    2389. 

  2389. begin
    2390. 

  2390.   if FHide then exit(False);
    2391. 

  2391.   if (FActiveSelectionMode = smColumn) then begin
    2392. 

  2392.     Result := (FStartBytePos <> FEndBytePos) and (FStartLinePos = FEndLinePos);
    2393. 

  2393.     if (not Result) and (FStartLinePos <> FEndLinePos) then begin
    2394. 

  2394.       // Todo: Cache values, but we need notification, if ines are modified (even only by change of tabwidth...)
    2395. 

  2395.       Result := Lines.LogicalToPhysicalPos(StartLineBytePos).X <>
    2396. 

  2396.                 Lines.LogicalToPhysicalPos(EndLineBytePos).X;
    2397. 

  2397.     end;
    2398. 

  2398.   end
    2399. 

  2399.   else
    2400. 

  2400.     Result := (FStartBytePos <> FEndBytePos) or (FStartLinePos <> FEndLinePos)
    2401. 

  2401.       or ( (FActiveSelectionMode = smLine) and FForceSingleLineSelected);
    2402. 

  2402. end;
    2403. 

  2403. 

  2404. function TSynEditSelection.SelCanContinue(ACaret: TSynEditCaret): Boolean;
    2405. 

  2405. begin
    2406. 

  2406.   if SelAvail then exit(True);
    2407. 

  2407.   Result := (not FHide) and
    2408. 

  2408.             (FActiveSelectionMode = smColumn) and (FEndLinePos = ACaret.LinePos) and
    2409. 

  2409.             (FEndBytePos = ACaret.BytePos);
    2410. 

  2410. end;
    2411. 

  2411. 

  2412. function TSynEditSelection.IsBackwardSel: Boolean;
    2413. 

  2413. begin
    2414. 

  2414.   Result := (FStartLinePos > FEndLinePos)
    2415. 

  2415.     or ((FStartLinePos = FEndLinePos) and (FStartBytePos > FEndBytePos));
    2416. 

  2416. end;
    2417. 

  2417. 

  2418. procedure TSynEditSelection.BeginMinimumSelection;
    2419. 

  2419. begin
    2420. 

  2420.   if SelAvail then begin
    2421. 

  2421.     FAltStartLinePos := FEndLinePos;
    2422. 

  2422.     FAltStartBytePos := FEndBytePos;
    2423. 

  2423.   end
    2424. 

  2424.   else begin
    2425. 

  2425.     FAltStartLinePos := -1;
    2426. 

  2426.     FAltStartBytePos := -1;
    2427. 

  2427.   end;
    2428. 

  2428. end;
    2429. 

  2429. 

  2430. procedure TSynEditSelection.SortSelectionPoints;
    2431. 

  2431. begin
    2432. 

  2432.   if IsBackwardSel then begin
    2433. 

  2433.     SwapInt(FStartLinePos, FEndLinePos);
    2434. 

  2434.     SwapInt(FStartBytePos, FEndBytePos);
    2435. 

  2435.   end;
    2436. 

  2436. end;
    2437. 

  2437. 

  2438. procedure TSynEditSelection.IgnoreNextCaretMove;
    2439. 

  2439. begin
    2440. 

  2440.   FIgnoreNextCaretMove := True;
    2441. 

  2441. end;
    2442. 

  2442. 

  2443. procedure TSynEditSelection.IncPersistentLock(AMode: TSynBlockPersistMode);
    2444. 

  2444. begin
    2445. 

  2445.   inc(FPersistentLock);
    2446. 

  2446.   if (sbpWeak = AMode) and (FWeakPersistentIdx = 0) then
    2447. 

  2447.     FWeakPersistentIdx := FPersistentLock;
    2448. 

  2448.   if (sbpStrong = AMode) and (FStrongPersistentIdx = 0) then
    2449. 

  2449.     FStrongPersistentIdx := FPersistentLock;
    2450. 

  2450. end;
    2451. 

  2451. 

  2452. procedure TSynEditSelection.DecPersistentLock;
    2453. 

  2453. begin
    2454. 

  2454.   dec(FPersistentLock);
    2455. 

  2455.   if FWeakPersistentIdx > FPersistentLock then
    2456. 

  2456.     FWeakPersistentIdx := 0;
    2457. 

  2457.   if FStrongPersistentIdx > FPersistentLock then
    2458. 

  2458.     FStrongPersistentIdx := 0;
    2459. 

  2459.   if (FPersistentLock = 0) and (FCaret <> nil) and FCaret.Locked then
    2460. 

  2460.     FLastCarePos := Point(FCaret.OldCharPos, FCaret.OldLinePos);
    2461. 

  2461. end;
    2462. 

  2462. 

  2463. procedure TSynEditSelection.Clear;
    2464. 

  2464. begin
    2465. 

  2465.   if Caret <> nil then
    2466. 

  2466.     StartLineBytePos := Caret.LineBytePos
    2467. 

  2467.   else
    2468. 

  2468.     StartLineBytePos := StartLineBytePos;
    2469. 

  2469. end;
    2470. 

  2470. 

  2471. procedure TSynEditSelection.AddBeforeSetSelTextHandler(AHandler: TSynBeforeSetSelTextEvent);
    2472. 

  2472. begin
    2473. 

  2473.   FOnBeforeSetSelText.Add(TMethod(AHandler));
    2474. 

  2474. end;
    2475. 

  2475. 

  2476. procedure TSynEditSelection.RemoveBeforeSetSelTextHandler(AHandler: TSynBeforeSetSelTextEvent);
    2477. 

  2477. begin
    2478. 

  2478.   FOnBeforeSetSelText.Remove(TMethod(AHandler));
    2479. 

  2479. end;
    2480. 

  2480. 

  2481. { TSynEditScreenCaretTimer }
    2482. 

  2482. 

  2483. procedure TSynEditScreenCaretTimer.DoAfterPaint(Data: PtrInt);
    2484. 

  2484. begin
    2485. 

  2485.   FAfterPaintList.CallNotifyEvents(Self);
    2486. 

  2486.   while FAfterPaintList.Count > 0 do
    2487. 

  2487.     FAfterPaintList.Delete(FAfterPaintList.Count - 1);
    2488. 

  2488. end;
    2489. 

  2489. 

  2490. procedure TSynEditScreenCaretTimer.DoTimer(Sender: TObject);
    2491. 

  2491. begin
    2492. 

  2492.   if FLocCount > 0 then begin
    2493. 

  2493.     include(FLocFlags, lfTimer);
    2494. 

  2494.     exit;
    2495. 

  2495.   end;
    2496. 

  2496.   FDisplayCycle := not FDisplayCycle;
    2497. 

  2497.   FTimerList.CallNotifyEvents(Self);
    2498. 

  2498. end;
    2499. 

  2499. 

  2500. constructor TSynEditScreenCaretTimer.Create;
    2501. 

  2501. begin
    2502. 

  2502.   FTimerList := TMethodList.Create;
    2503. 

  2503.   FAfterPaintList := TMethodList.Create;
    2504. 

  2504.   FTimer := TTimer.Create(nil);
    2505. 

  2505.   FTimer.Enabled := False;
    2506. 

  2506.   FTimer.Interval := 500;
    2507. 

  2507.   FTimer.OnTimer := @DoTimer;
    2508. 

  2508. end;
    2509. 

  2509. 

  2510. destructor TSynEditScreenCaretTimer.Destroy;
    2511. 

  2511. begin
    2512. 

  2512.   Application.RemoveAsyncCalls(Self);
    2513. 

  2513.   FreeAndNil(FTimer);
    2514. 

  2514.   FreeAndNil(FTimerList);
    2515. 

  2515.   FreeAndNil(FAfterPaintList);
    2516. 

  2516.   inherited Destroy;
    2517. 

  2517. end;
    2518. 

  2518. 

  2519. procedure TSynEditScreenCaretTimer.AddAfterPaintHandler(AHandler: TNotifyEvent);
    2520. 

  2520. begin
    2521. 

  2521.   if FAfterPaintList.Count = 0 then
    2522. 

  2522.     Application.QueueAsyncCall(@DoAfterPaint, 0);
    2523. 

  2523.   FAfterPaintList.Add(TMethod(AHandler));
    2524. 

  2524. end;
    2525. 

  2525. 

  2526. procedure TSynEditScreenCaretTimer.AddHandler(AHandler: TNotifyEvent);
    2527. 

  2527. begin
    2528. 

  2528.   FTimerList.Add(TMethod(AHandler));
    2529. 

  2529.   if not FTimer.Enabled then
    2530. 

  2530.     RestartCycle;
    2531. 

  2531. end;
    2532. 

  2532. 

  2533. procedure TSynEditScreenCaretTimer.RemoveHandler(AHandler: TNotifyEvent);
    2534. 

  2534. begin
    2535. 

  2535.   FTimerList.Remove(TMethod(AHandler));
    2536. 

  2536.   if FTimerList.Count = 0 then
    2537. 

  2537.     FTimer.Enabled := False;
    2538. 

  2538. end;
    2539. 

  2539. 

  2540. procedure TSynEditScreenCaretTimer.RemoveHandler(AHandlerOwner: TObject);
    2541. 

  2541. begin
    2542. 

  2542.   FTimerList.RemoveAllMethodsOfObject(AHandlerOwner);
    2543. 

  2543.   FAfterPaintList.RemoveAllMethodsOfObject(AHandlerOwner);
    2544. 

  2544.   if FTimerList.Count = 0 then FTimer.Enabled := False;
    2545. 

  2545. end;
    2546. 

  2546. 

  2547. procedure TSynEditScreenCaretTimer.IncLock;
    2548. 

  2548. begin
    2549. 

  2549.   inc(FLocCount);
    2550. 

  2550. end;
    2551. 

  2551. 

  2552. procedure TSynEditScreenCaretTimer.DecLock;
    2553. 

  2553. begin
    2554. 

  2554.   if FLocCount > 0 then
    2555. 

  2555.     dec(FLocCount);
    2556. 

  2556.   if FLocCount > 0 then
    2557. 

  2557.     exit;
    2558. 

  2558. 

  2559.   if lfRestart in FLocFlags then
    2560. 

  2560.     RestartCycle
    2561. 

  2561.   else;
    2562. 

  2562.   if lfTimer in FLocFlags then
    2563. 

  2563.     DoTimer(nil);
    2564. 

  2564. 

  2565.   FLocFlags := [];
    2566. 

  2566. end;
    2567. 

  2567. 

  2568. procedure TSynEditScreenCaretTimer.AfterPaintEvent;
    2569. 

  2569. begin
    2570. 

  2570.   Application.RemoveAsyncCalls(Self);
    2571. 

  2571.   DoAfterPaint(0);
    2572. 

  2572. end;
    2573. 

  2573. 

  2574. procedure TSynEditScreenCaretTimer.RestartCycle;
    2575. 

  2575. begin
    2576. 

  2576.   if FLocCount > 0 then begin
    2577. 

  2577.     include(FLocFlags, lfRestart);
    2578. 

  2578.     exit;
    2579. 

  2579.   end;
    2580. 

  2580.   if FTimerList.Count = 0 then exit;
    2581. 

  2581.   FTimer.Enabled := False;
    2582. 

  2582.   FDisplayCycle := False;
    2583. 

  2583.   DoTimer(nil);
    2584. 

  2584.   FTimer.Enabled := True;
    2585. 

  2585. end;
    2586. 

  2586. 

  2587. { TSynEditScreenCaretPainter }
    2588. 

  2588. 

  2589. function TSynEditScreenCaretPainter.GetHandle: HWND;
    2590. 

  2590. begin
    2591. 

  2591.   Result := FHandleOwner.Handle;
    2592. 

  2592. end;
    2593. 

  2593. 

  2594. function TSynEditScreenCaretPainter.GetHandleAllocated: Boolean;
    2595. 

  2595. begin
    2596. 

  2596.   Result := FHandleOwner.HandleAllocated;
    2597. 

  2597. end;
    2598. 

  2598. 

  2599. procedure TSynEditScreenCaretPainter.Init;
    2600. 

  2600. begin
    2601. 

  2601.   //
    2602. 

  2602. end;
    2603. 

  2603. 

  2604. constructor TSynEditScreenCaretPainter.Create(AHandleOwner: TWinControl;
    2605. 

  2605.   AOwner: TSynEditScreenCaret);
    2606. 

  2606. begin
    2607. 

  2607.   FLeft := -1;
    2608. 

  2608.   FTop := -1;
    2609. 

  2609.   inherited Create;
    2610. 

  2610.   FHandleOwner := AHandleOwner;
    2611. 

  2611.   FOwner := AOwner;
    2612. 

  2612.   Init;
    2613. 

  2613. end;
    2614. 

  2614. 

  2615. function TSynEditScreenCaretPainter.CreateCaret(w, h: Integer): Boolean;
    2616. 

  2616. begin
    2617. 

  2617.   FLeft := -1;
    2618. 

  2618.   FTop := -1;
    2619. 

  2619.   FWidth := w;
    2620. 

  2620.   FHeight := h;
    2621. 

  2621.   FCreated := True;
    2622. 

  2622.   FShowing := False;
    2623. 

  2623.   Result := True;
    2624. 

  2624. end;
    2625. 

  2625. 

  2626. function TSynEditScreenCaretPainter.DestroyCaret: Boolean;
    2627. 

  2627. begin
    2628. 

  2628.   FCreated := False;
    2629. 

  2629.   FShowing := False;
    2630. 

  2630.   Result := True;
    2631. 

  2631. end;
    2632. 

  2632. 

  2633. function TSynEditScreenCaretPainter.HideCaret: Boolean;
    2634. 

  2634. begin
    2635. 

  2635.   FShowing := False;
    2636. 

  2636.   Result := True;
    2637. 

  2637. end;
    2638. 

  2638. 

  2639. function TSynEditScreenCaretPainter.ShowCaret: Boolean;
    2640. 

  2640. begin
    2641. 

  2641.   FShowing := True;
    2642. 

  2642.   Result := True;
    2643. 

  2643. end;
    2644. 

  2644. 

  2645. function TSynEditScreenCaretPainter.SetCaretPosEx(x, y: Integer): Boolean;
    2646. 

  2646. begin
    2647. 

  2647.   FLeft := x;
    2648. 

  2648.   FTop := y;
    2649. 

  2649.   FNeedPositionConfirmed := False;
    2650. 

  2650.   Result := True;
    2651. 

  2651. end;
    2652. 

  2652. 

  2653. procedure TSynEditScreenCaretPainter.BeginScroll(dx, dy: Integer; const rcScroll,
    2654. 

  2654.   rcClip: TRect);
    2655. 

  2655. begin
    2656. 

  2656.   FInScroll := True;
    2657. 

  2657.   FScrollX := dx;
    2658. 

  2658.   FScrollY := dy;
    2659. 

  2659.   FScrollRect := rcScroll;
    2660. 

  2660.   FScrollClip := rcClip;
    2661. 

  2661. end;
    2662. 

  2662. 

  2663. procedure TSynEditScreenCaretPainter.FinishScroll(dx, dy: Integer; const rcScroll,
    2664. 

  2664.   rcClip: TRect; Success: Boolean);
    2665. 

  2665. begin
    2666. 

  2666.   FInScroll := False;
    2667. 

  2667. end;
    2668. 

  2668. 

  2669. procedure TSynEditScreenCaretPainter.BeginPaint(rcClip: TRect);
    2670. 

  2670. begin
    2671. 

  2671.   FInPaint := True;
    2672. 

  2672.   FPaintClip := rcClip;
    2673. 

  2673. end;
    2674. 

  2674. 

  2675. procedure TSynEditScreenCaretPainter.FinishPaint(rcClip: TRect);
    2676. 

  2676. begin
    2677. 

  2677.   FInPaint := False;
    2678. 

  2678. end;
    2679. 

  2679. 

  2680. { TSynEditScreenCaretPainterSystem }
    2681. 

  2681. 

  2682. procedure TSynEditScreenCaretPainterSystem.FinishScroll(dx, dy: Integer; const rcScroll,
    2683. 

  2683.   rcClip: TRect; Success: Boolean);
    2684. 

  2684. begin
    2685. 

  2685.   inherited FinishScroll(dx, dy, rcScroll, rcClip, Success);
    2686. 

  2686.   if Success then
    2687. 

  2687.     inherited SetCaretPosEx(-1, -1);
    2688. 

  2688.   FNeedPositionConfirmed := True;
    2689. 

  2689. end;
    2690. 

  2690. 

  2691. procedure TSynEditScreenCaretPainterSystem.BeginPaint(rcClip: TRect);
    2692. 

  2692. begin
    2693. 

  2693.   inherited BeginPaint(rcClip);
    2694. 

  2694.   if Showing then
    2695. 

  2695.     if not HideCaret then
    2696. 

  2696.       DestroyCaret; // only if was Showing
    2697. 

  2697. end;
    2698. 

  2698. 

  2699. function TSynEditScreenCaretPainterSystem.CreateCaret(w, h: Integer): Boolean;
    2700. 

  2700. begin
    2701. 

  2701.   // do not create caret during paint / Issue 0021924
    2702. 

  2702.   Result := HandleAllocated and not InPaint;
    2703. 

  2703.   if not Result then
    2704. 

  2704.     exit;
    2705. 

  2705.   inherited CreateCaret(w, h);
    2706. 

  2706.   inherited SetCaretPosEx(-1, -1);
    2707. 

  2707.   Result := LCLIntf.CreateCaret(Handle, 0, w, h);
    2708. 

  2708.   SetCaretRespondToFocus(Handle, False); // Only for GTK
    2709. 

  2709.   if not Result then inherited DestroyCaret;
    2710. 

  2710. end;
    2711. 

  2711. 

  2712. function TSynEditScreenCaretPainterSystem.DestroyCaret: Boolean;
    2713. 

  2713. begin
    2714. 

  2714.   Result := inherited DestroyCaret;
    2715. 

  2715.   if HandleAllocated then
    2716. 

  2716.     Result := LCLIntf.DestroyCaret(Handle);
    2717. 

  2717. end;
    2718. 

  2718. 

  2719. function TSynEditScreenCaretPainterSystem.HideCaret: Boolean;
    2720. 

  2720. begin
    2721. 

  2721.   inherited HideCaret;
    2722. 

  2722.   if HandleAllocated then
    2723. 

  2723.     Result := LCLIntf.HideCaret(Handle)
    2724. 

  2724.   else
    2725. 

  2725.     Result := False;
    2726. 

  2726. end;
    2727. 

  2727. 

  2728. function TSynEditScreenCaretPainterSystem.ShowCaret: Boolean;
    2729. 

  2729. begin
    2730. 

  2730.   Result := HandleAllocated;
    2731. 

  2731.   if not Result then
    2732. 

  2732.     exit;
    2733. 

  2733.   inherited ShowCaret;
    2734. 

  2734.   Result := LCLIntf.ShowCaret(Handle);
    2735. 

  2735. end;
    2736. 

  2736. 

  2737. function TSynEditScreenCaretPainterSystem.SetCaretPosEx(x, y: Integer): Boolean;
    2738. 

  2738. begin
    2739. 

  2739.   Result := HandleAllocated;
    2740. 

  2740.   if not Result then
    2741. 

  2741.     exit;
    2742. 

  2742.   inherited SetCaretPosEx(x, y);
    2743. 

  2743.   Result := LCLIntf.SetCaretPosEx(Handle, x, y);
    2744. 

  2744. end;
    2745. 

  2745. 

  2746. { TSynEditScreenCaretPainterInternal }
    2747. 

  2747. 

  2748. procedure TSynEditScreenCaretPainterInternal.DoTimer(Sender: TObject);
    2749. 

  2749. begin
    2750. 

  2750.   assert(not((not Showing) and FIsDrawn), 'TSynEditScreenCaretPainterInternal.DoTimer: not((not Showing) and FIsDrawn)');
    2751. 

  2751.   if (FState <> []) then
    2752. 

  2752.     ExecAfterPaint;
    2753. 

  2753. 

  2754.   if (not Showing) or NeedPositionConfirmed then exit;
    2755. 

  2755.   if FIsDrawn <> FOwner.PaintTimer.DisplayCycle then
    2756. 

  2756.     Paint;
    2757. 

  2757. end;
    2758. 

  2758. 

  2759. procedure TSynEditScreenCaretPainterInternal.DoPaint(ACanvas: TCanvas; X, Y, H, W: Integer);
    2760. 

  2760. var
    2761. 

  2761.   l: Integer;
    2762. 

  2762.   am: TAntialiasingMode;
    2763. 

  2763. begin
    2764. 

  2764.   if ForcePaintEvents and (not FInPaint) then begin
    2765. 

  2765.    Invalidate;
    2766. 

  2766.    exit;
    2767. 

  2767.   end;
    2768. 

  2768. 

  2769.   am := ACanvas.AntialiasingMode;
    2770. 

  2770.   FSavePen.Assign(ACanvas.Pen);
    2771. 

  2771. 

  2772.   l := X + W div 2;
    2773. 

  2773.   ACanvas.MoveTo(l, Y);
    2774. 

  2774.   ACanvas.Pen.Mode := pmNotXOR;
    2775. 

  2775.   ACanvas.Pen.Style := psSolid;
    2776. 

  2776.   ACanvas.Pen.Color := FColor;
    2777. 

  2777.   ACanvas.AntialiasingMode := amOff;
    2778. 

  2778.   ACanvas.pen.EndCap := pecFlat;
    2779. 

  2779.   ACanvas.pen.Width := Width;
    2780. 

  2780.   ACanvas.LineTo(l, Y+H);
    2781. 

  2781. 

  2782.   ACanvas.Pen.Assign(FSavePen);
    2783. 

  2783.   ACanvas.AntialiasingMode := am;
    2784. 

  2784. end;
    2785. 

  2785. 

  2786. procedure TSynEditScreenCaretPainterInternal.Paint;
    2787. 

  2787. begin
    2788. 

  2788.   if not HandleAllocated then begin
    2789. 

  2789.     FIsDrawn := False;
    2790. 

  2790.     exit;
    2791. 

  2791.   end;
    2792. 

  2792. 

  2793.   if FInPaint or FInScroll then begin
    2794. 

  2794.     if FCanPaint then
    2795. 

  2795.       FIsDrawn := not FIsDrawn; //change the state, that is applied at the end of paint
    2796. 

  2796.     exit;
    2797. 

  2797.   end;
    2798. 

  2798. 

  2799.   if (FState <> []) then
    2800. 

  2800.     ExecAfterPaint;
    2801. 

  2801. 

  2802.   FIsDrawn := not FIsDrawn;
    2803. 

  2803.   DoPaint(CurrentCanvas, FLeft, FTop, FHeight, FWidth);
    2804. 

  2804. end;
    2805. 

  2805. 

  2806. procedure TSynEditScreenCaretPainterInternal.Invalidate;
    2807. 

  2807. var
    2808. 

  2808.   r: TRect;
    2809. 

  2809. begin
    2810. 

  2810.   r.Left := Left;
    2811. 

  2811.   r.Top := Top;
    2812. 

  2812.   r.Right := Left+Width+1;
    2813. 

  2813.   r.Bottom := Top+Height+1;
    2814. 

  2814.   InvalidateRect(Handle, @r, False);
    2815. 

  2815. end;
    2816. 

  2816. 

  2817. procedure TSynEditScreenCaretPainterInternal.AddAfterPaint(AStates: TPainterStates);
    2818. 

  2818. begin
    2819. 

  2819.   if not(psAfterPaintAdded in FState) then
    2820. 

  2820.     FOwner.PaintTimer.AddAfterPaintHandler(@DoAfterPaint);
    2821. 

  2821.   FState := FState + [psAfterPaintAdded] + AStates;
    2822. 

  2822. end;
    2823. 

  2823. 

  2824. procedure TSynEditScreenCaretPainterInternal.DoAfterPaint(Sender: TObject);
    2825. 

  2825. begin
    2826. 

  2826.   Exclude(FState, psAfterPaintAdded);
    2827. 

  2827.   DoTimer(nil);
    2828. 

  2828. end;
    2829. 

  2829. 

  2830. procedure TSynEditScreenCaretPainterInternal.ExecAfterPaint;
    2831. 

  2831. begin
    2832. 

  2832.   if FInPaint or FInScroll then
    2833. 

  2833.     exit;
    2834. 

  2834. 

  2835.   if (psCleanOld in FState) then begin
    2836. 

  2836.     DoPaint(CurrentCanvas, FOldX, FOldY, FOldH, FOldW);
    2837. 

  2837.     Exclude(FState, psCleanOld);
    2838. 

  2838.   end;
    2839. 

  2839. 

  2840.   if (psRemoveTimer in FState) and not(FInPaint or FInScroll) then begin
    2841. 

  2841.     FOwner.PaintTimer.RemoveHandler(@DoTimer);
    2842. 

  2842.     Exclude(FState, psRemoveTimer);
    2843. 

  2843.   end;
    2844. 

  2844. 

  2845. end;
    2846. 

  2846. 

  2847. function TSynEditScreenCaretPainterInternal.CurrentCanvas: TCanvas;
    2848. 

  2848. begin
    2849. 

  2849.   Result := TCustomControl(FHandleOwner).Canvas;
    2850. 

  2850. end;
    2851. 

  2851. 

  2852. procedure TSynEditScreenCaretPainterInternal.SetColor(AValue: TColor);
    2853. 

  2853. var
    2854. 

  2854.   d: Boolean;
    2855. 

  2855. begin
    2856. 

  2856.   if FColor = AValue then Exit;
    2857. 

  2857. 

  2858.   d := FIsDrawn;
    2859. 

  2859.   if FIsDrawn then Paint;
    2860. 

  2860.   FColor := AValue;
    2861. 

  2861.   if d then Paint;
    2862. 

  2862. end;
    2863. 

  2863. 

  2864. function TSynEditScreenCaretPainterInternal.IsInRect(ARect: TRect): TIsInRectState;
    2865. 

  2865. begin
    2866. 

  2866.   Result := IsInRect(ARect, Left, Top, Width, Height);
    2867. 

  2867. end;
    2868. 

  2868. 

  2869. function TSynEditScreenCaretPainterInternal.IsInRect(ARect: TRect; X, Y, W,
    2870. 

  2870.   H: Integer): TIsInRectState;
    2871. 

  2871. begin
    2872. 

  2872.   if (Y >= ARect.Bottom) or (X >= ARect.Right) or (Y+H < ARect.Top) or (X+W < ARect.Left)
    2873. 

  2873.   then
    2874. 

  2874.     Result := irOutside
    2875. 

  2875.   else
    2876. 

  2876.   if (Y >= ARect.Top) and (X >= ARect.Left) and (Y+H < ARect.Bottom) and (X+W < ARect.Right)
    2877. 

  2877.   then
    2878. 

  2878.     Result := irInside
    2879. 

  2879.   else
    2880. 

  2880.     Result := irPartInside;
    2881. 

  2881. end;
    2882. 

  2882. 

  2883. procedure TSynEditScreenCaretPainterInternal.Init;
    2884. 

  2884. begin
    2885. 

  2885.   {$IFDEF LCLCarbon}
    2886. 

  2886.     FForcePaintEvents := True;
    2887. 

  2887.   {$ELSE}
    2888. 

  2888.   {$IFDEF LCLQt}
    2889. 

  2889.     FForcePaintEvents := True;
    2890. 

  2890.   {$ELSE}
    2891. 

  2891.     FForcePaintEvents := False;
    2892. 

  2892.   {$ENDIF}
    2893. 

  2893.   {$ENDIF}
    2894. 

  2894.   FSavePen := TPen.Create;
    2895. 

  2895.   FColor := clBlack;
    2896. 

  2896.   FOldY := -1;
    2897. 

  2897.   FCanPaint := True;
    2898. 

  2898.   inherited Init;
    2899. 

  2899. end;
    2900. 

  2900. 

  2901. procedure TSynEditScreenCaretPainterInternal.BeginScroll(dx, dy: Integer; const rcScroll,
    2902. 

  2902.   rcClip: TRect);
    2903. 

  2903. {$IFDEF SynCaretNoHideInSroll}
    2904. 

  2904. var
    2905. 

  2905.   rs: TIsInRectState;
    2906. 

  2906. {$ENDIF}
    2907. 

  2907. begin
    2908. 

  2908.   assert(not((FInPaint or FInScroll)), 'TSynEditScreenCaretPainterInternal.BeginScroll: not((FInPaint or FInScroll))');
    2909. 

  2909.   if (FState <> []) then
    2910. 

  2910.     ExecAfterPaint;
    2911. 

  2911. 

  2912.   {$IFnDEF SynCaretNoHideInSroll}
    2913. 

  2913.   if not ((IsInRect(rcClip) = irOutside) and (IsInRect(rcScroll) = irOutside)) then begin
    2914. 

  2914.     HideCaret;
    2915. 

  2915.     inherited SetCaretPosEx(-1,-1);
    2916. 

  2916.   end;
    2917. 

  2917.   {$ELSE}
    2918. 

  2918.   rs := IsInRect(rcScroll);
    2919. 

  2919.   if not( ((IsInRect(rcClip) = irOutside) and (rs = irOutside)) or
    2920. 

  2920.           ((IsInRect(rcClip, Left+dx, Top+dy, Width, Height) = irInside) and (rs = irInside))
    2921. 

  2921.         )
    2922. 

  2922.   then begin
    2923. 

  2923.     HideCaret;
    2924. 

  2924.     inherited SetCaretPosEx(-1,-1);
    2925. 

  2925.   end;
    2926. 

  2926.   {$ENDIF}
    2927. 

  2927. 

  2928.   FCanPaint := False;
    2929. 

  2929. 

  2930.   inherited BeginScroll(dx, dy, rcScroll, rcClip);
    2931. 

  2931. end;
    2932. 

  2932. 

  2933. procedure TSynEditScreenCaretPainterInternal.FinishScroll(dx, dy: Integer; const rcScroll,
    2934. 

  2934.   rcClip: TRect; Success: Boolean);
    2935. 

  2935. begin
    2936. 

  2936.   assert(FInScroll, 'TSynEditScreenCaretPainterInternal.FinishScroll: FInScroll');
    2937. 

  2937.   assert((FState-[psAfterPaintAdded]) = [], 'TSynEditScreenCaretPainterInternal.FinishScroll: FState = []');
    2938. 

  2938.   inherited FinishScroll(dx, dy, rcScroll, rcClip, Success);
    2939. 

  2939.   FCanPaint := True;
    2940. 

  2940.   {$IFDEF SynCaretNoHideInSroll}
    2941. 

  2941.   if Success and ((IsInRect(rcClip) = irInside) or (IsInRect(rcScroll) = irInside)) then begin
    2942. 

  2942.     inherited SetCaretPosEx(Left+dx, Top+dy);
    2943. 

  2943.     FNeedPositionConfirmed := True;
    2944. 

  2944.   end;
    2945. 

  2945.   {$ENDIF}
    2946. 

  2946. end;
    2947. 

  2947. 

  2948. procedure TSynEditScreenCaretPainterInternal.BeginPaint(rcClip: TRect);
    2949. 

  2949. begin
    2950. 

  2950.   assert(not (FInPaint or FInScroll), 'TSynEditScreenCaretPainterInternal.BeginPaint: not (FInPaint or FInScroll)');
    2951. 

  2951. 

  2952.   FCanPaint := IsInRect(rcClip)= irInside;
    2953. 

  2953. 

  2954.   if (psCleanOld in FState) and not FCanPaint then begin
    2955. 

  2955.     if IsInRect(rcClip, FOldX, FOldY, FOldW, FOldH) <> irInside then begin
    2956. 

  2956.       debugln(['TSynEditScreenCaretPainterInternal.BeginPaint Invalidate for psCleanOld']);
    2957. 

  2957.       Invalidate;
    2958. 

  2958.     end;
    2959. 

  2959.     Exclude(FState, psCleanOld);
    2960. 

  2960.   end;
    2961. 

  2961. 

  2962.   if not(psCleanOld in FState) then begin
    2963. 

  2963.     FOldX := Left;
    2964. 

  2964.     FOldY := Top;
    2965. 

  2965.     FOldW := Width;
    2966. 

  2966.     FOldH := Height;
    2967. 

  2967.   end;
    2968. 

  2968. 

  2969.   inherited BeginPaint(rcClip);
    2970. 

  2970. end;
    2971. 

  2971. 

  2972. procedure TSynEditScreenCaretPainterInternal.FinishPaint(rcClip: TRect);
    2973. 

  2973. begin
    2974. 

  2974.   assert(FInPaint, 'TSynEditScreenCaretPainterInternal.FinishPaint: FInPaint');
    2975. 

  2975.   assert(FCanPaint = (IsInRect(rcClip)= irInside), 'TSynEditScreenCaretPainterInternal.FinishPaint: FCanPaint = (IsInRect(rcClip)= irInside)');
    2976. 

  2976.   assert(FCanPaint = (IsInRect(FPaintClip)= irInside), 'TSynEditScreenCaretPainterInternal.FinishPaint: FCanPaint = (IsInRect(rcClip)= irInside)');
    2977. 

  2977. 

  2978.   // partly restore IF irPartInside;
    2979. 

  2979.   // Better recalc size to remainder outside cliprect
    2980. 

  2980.   if (psCleanOld in FState) and (not ForcePaintEvents) then
    2981. 

  2981.     DoPaint(CurrentCanvas, FOldX, FOldY, FOldH, FOldW);
    2982. 

  2982. 

  2983.   // if changes where made, then FIsDrawn is alvays false
    2984. 

  2984.   if FIsDrawn then
    2985. 

  2985.     DoPaint(CurrentCanvas, FLeft, FTop, FHeight, FWidth); // restore any part that is in the cliprect
    2986. 

  2986. 

  2987.   inherited FinishPaint(rcClip);
    2988. 

  2988.   FCanPaint := True;
    2989. 

  2989. end;
    2990. 

  2990. 

  2991. destructor TSynEditScreenCaretPainterInternal.Destroy;
    2992. 

  2992. begin
    2993. 

  2993.   assert(not(FInPaint or FInScroll), 'TSynEditScreenCaretPainterInternal.Destroy: not(FInPaint or FInScroll)');
    2994. 

  2994.   if FOwner.HasPaintTimer then
    2995. 

  2995.     FOwner.PaintTimer.RemoveHandler(Self);
    2996. 

  2996.   HideCaret;
    2997. 

  2997.   FreeAndNil(FSavePen);
    2998. 

  2998.   inherited Destroy;
    2999. 

  2999. end;
    3000. 

  3000. 

  3001. function TSynEditScreenCaretPainterInternal.CreateCaret(w, h: Integer): Boolean;
    3002. 

  3002. begin
    3003. 

  3003.   DestroyCaret;
    3004. 

  3004.   Result := inherited CreateCaret(w, h);
    3005. 

  3005.   if InPaint then  // InScroll ??
    3006. 

  3006.     FCanPaint := IsInRect(FPaintClip) = irInside;
    3007. 

  3007.   Result := True;
    3008. 

  3008. end;
    3009. 

  3009. 

  3010. function TSynEditScreenCaretPainterInternal.DestroyCaret: Boolean;
    3011. 

  3011. begin
    3012. 

  3012.   HideCaret;
    3013. 

  3013.   inherited DestroyCaret;
    3014. 

  3014.   Result := True;
    3015. 

  3015. end;
    3016. 

  3016. 

  3017. function TSynEditScreenCaretPainterInternal.HideCaret: Boolean;
    3018. 

  3018. begin
    3019. 

  3019.   inherited HideCaret;
    3020. 

  3020. 

  3021.   if (not FCanPaint) and FIsDrawn then begin
    3022. 

  3022.     AddAfterPaint([psCleanOld, psRemoveTimer]);
    3023. 

  3023.     FIsDrawn := False;
    3024. 

  3024.     exit(True);
    3025. 

  3025.   end;
    3026. 

  3026. 

  3027.   FOwner.PaintTimer.RemoveHandler(@DoTimer);
    3028. 

  3028.   if FIsDrawn then Paint;
    3029. 

  3029.   assert(not FIsDrawn, 'TSynEditScreenCaretPainterInternal.HideCaret: not FIsDrawn');
    3030. 

  3030.   Result := True;
    3031. 

  3031. end;
    3032. 

  3032. 

  3033. function TSynEditScreenCaretPainterInternal.ShowCaret: Boolean;
    3034. 

  3034. begin
    3035. 

  3035.   if Showing then exit(True);
    3036. 

  3036.   inherited ShowCaret;
    3037. 

  3037.   Exclude(FState, psRemoveTimer);
    3038. 

  3038. //  Exclude(FState, psCleanOld); // only if not moved
    3039. 

  3039. 

  3040.   FOwner.PaintTimer.RemoveHandler(@DoTimer);
    3041. 

  3041.   FOwner.PaintTimer.AddHandler(@DoTimer);
    3042. 

  3042.   FOwner.PaintTimer.RestartCycle;
    3043. 

  3043.   Result := True;
    3044. 

  3044. end;
    3045. 

  3045. 

  3046. function TSynEditScreenCaretPainterInternal.SetCaretPosEx(x, y: Integer): Boolean;
    3047. 

  3047. var
    3048. 

  3048.   d: Boolean;
    3049. 

  3049. begin
    3050. 

  3050.   if (not FCanPaint) and FIsDrawn then begin
    3051. 

  3051.     AddAfterPaint([psCleanOld]);
    3052. 

  3052.     FIsDrawn := False;
    3053. 

  3053.   end;
    3054. 

  3054. 

  3055.   d := FIsDrawn;
    3056. 

  3056.   if d then Paint;
    3057. 

  3057.   inherited SetCaretPosEx(x, y);
    3058. 

  3058. 

  3059.   if InPaint then  // InScroll ??
    3060. 

  3060.     FCanPaint := IsInRect(FPaintClip) = irInside;
    3061. 

  3061. 

  3062.   if d then Paint;
    3063. 

  3063.   // else aftecpaint needs show
    3064. 

  3064.   FOwner.PaintTimer.RestartCycle;  // if not d ??
    3065. 

  3065.   Result := True;
    3066. 

  3066. end;
    3067. 

  3067. 

  3068. { TSynEditScreenCaret }
    3069. 

  3069. 

  3070. constructor TSynEditScreenCaret.Create(AHandleOwner: TWinControl);
    3071. 

  3071. begin
    3072. 

  3072.   Create(AHandleOwner, TSynEditScreenCaretPainterSystem);
    3073. 

  3073.   //Create(AHandleOwner, TSynEditScreenCaretPainterInternal);
    3074. 

  3074. end;
    3075. 

  3075. 

  3076. constructor TSynEditScreenCaret.Create(AHandleOwner: TWinControl;
    3077. 

  3077.   APainterClass: TSynEditScreenCaretPainterClass);
    3078. 

  3078. begin
    3079. 

  3079.   inherited Create;
    3080. 

  3080.   FCaretPainter := APainterClass.Create(AHandleOwner, Self);
    3081. 

  3081.   FLockCount := -1;
    3082. 

  3082.   ResetCaretTypeSizes;
    3083. 

  3083.   FHandleOwner := AHandleOwner;
    3084. 

  3084.   FVisible := False;
    3085. 

  3085.   FClipExtraPixel := 0;
    3086. 

  3086.   FLockCount := 0;
    3087. 

  3087. end;
    3088. 

  3088. 

  3089. procedure TSynEditScreenCaret.ChangePainter(APainterClass: TSynEditScreenCaretPainterClass);
    3090. 

  3090. begin
    3091. 

  3091.   DestroyCaret;
    3092. 

  3092.   FreeAndNil(FCaretPainter);
    3093. 

  3093.   FCaretPainter := APainterClass.Create(FHandleOwner, Self);
    3094. 

  3094.   UpdateDisplay;
    3095. 

  3095. end;
    3096. 

  3096. 

  3097. destructor TSynEditScreenCaret.Destroy;
    3098. 

  3098. begin
    3099. 

  3099.   DestroyCaret;
    3100. 

  3100.   FreeAndNil(FCaretPainter);
    3101. 

  3101.   if FPaintTimerOwned then
    3102. 

  3102.     FreeAndNil(FPaintTimer);
    3103. 

  3103.   inherited Destroy;
    3104. 

  3104. end;
    3105. 

  3105. 

  3106. procedure TSynEditScreenCaret.BeginScroll(dx, dy: Integer; const rcScroll, rcClip: TRect);
    3107. 

  3107. begin
    3108. 

  3108.   Painter.BeginScroll(dx, dy, rcScroll, rcClip);
    3109. 

  3109. end;
    3110. 

  3110. 

  3111. procedure TSynEditScreenCaret.FinishScroll(dx, dy: Integer; const rcScroll, rcClip: TRect;
    3112. 

  3112.   Success: Boolean);
    3113. 

  3113. begin
    3114. 

  3114.   Painter.FinishScroll(dx, dy, rcScroll, rcClip, Success);
    3115. 

  3115. end;
    3116. 

  3116. 

  3117. procedure TSynEditScreenCaret.BeginPaint(rcClip: TRect);
    3118. 

  3118. begin
    3119. 

  3119.   Painter.BeginPaint(rcClip);
    3120. 

  3120. end;
    3121. 

  3121. 

  3122. procedure TSynEditScreenCaret.FinishPaint(rcClip: TRect);
    3123. 

  3123. begin
    3124. 

  3124.   Painter.FinishPaint(rcClip);
    3125. 

  3125. end;
    3126. 

  3126. 

  3127. procedure TSynEditScreenCaret.Hide;
    3128. 

  3128. begin
    3129. 

  3129.   HideCaret;
    3130. 

  3130. end;
    3131. 

  3131. 

  3132. procedure TSynEditScreenCaret.DestroyCaret(SkipHide: boolean = False);
    3133. 

  3133. begin
    3134. 

  3134.   if Painter.Created then begin
    3135. 

  3135.     {$IFDeF SynCaretDebug}
    3136. 

  3136.     debugln(['SynEditCaret DestroyCaret for HandleOwner=',FHandleOwner, ' DebugShowCount=', FDebugShowCount, ' FVisible=', FVisible, ' FCurrentVisible=', Painter.Showing]);
    3137. 

  3137.     {$ENDIF}
    3138. 

  3138.     FCaretPainter.DestroyCaret;
    3139. 

  3139.   end;
    3140. 

  3140.   if not SkipHide then
    3141. 

  3141.     FVisible := False;
    3142. 

  3142. end;
    3143. 

  3143. 

  3144. procedure TSynEditScreenCaret.Lock;
    3145. 

  3145. begin
    3146. 

  3146.   inc(FLockCount);
    3147. 

  3147.   if FPaintTimer <> nil then
    3148. 

  3148.     FPaintTimer.IncLock;
    3149. 

  3149. end;
    3150. 

  3150. 

  3151. procedure TSynEditScreenCaret.UnLock;
    3152. 

  3152. begin
    3153. 

  3153.   dec(FLockCount);
    3154. 

  3154.   if (FLockCount=0) then begin
    3155. 

  3155.     if (sclfUpdateDisplayType in FLockFlags) then UpdateDisplayType;
    3156. 

  3156.     if (sclfUpdateDisplay in FLockFlags)     then UpdateDisplay;
    3157. 

  3157.   end;
    3158. 

  3158.   if FPaintTimer <> nil then
    3159. 

  3159.     FPaintTimer.DecLock;
    3160. 

  3160. end;
    3161. 

  3161. 

  3162. procedure TSynEditScreenCaret.AfterPaintEvent;
    3163. 

  3163. begin
    3164. 

  3164.   if FPaintTimer <> nil then
    3165. 

  3165.     FPaintTimer.AfterPaintEvent;
    3166. 

  3166. 

  3167. end;
    3168. 

  3168. 

  3169. procedure TSynEditScreenCaret.ResetCaretTypeSizes;
    3170. 

  3170. var
    3171. 

  3171.   i: TSynCaretType;
    3172. 

  3172. begin
    3173. 

  3173.   for i := low(TSynCaretType) to high(TSynCaretType) do begin
    3174. 

  3174.     FCustomPixelWidth[i] := 0;
    3175. 

  3175.   end;
    3176. 

  3176.   if FLockCount >= 0 then UpdateDisplayType;
    3177. 

  3177. end;
    3178. 

  3178. 

  3179. procedure TSynEditScreenCaret.SetCaretTypeSize(AType: TSynCaretType; AWidth, AHeight, AXOffs,
    3180. 

  3180.   AYOffs: Integer; AFlags: TSynCustomCaretSizeFlags);
    3181. 

  3181. begin
    3182. 

  3182.   FCustomPixelWidth[AType] := AWidth;
    3183. 

  3183.   FCustomPixelHeight[AType] := AHeight;
    3184. 

  3184.   FCustomOffsetX[AType] := AXOffs;
    3185. 

  3185.   FCustomOffsetY[AType] := AYOffs;
    3186. 

  3186.   FCustomFlags[AType] := AFlags;
    3187. 

  3187.   if FDisplayType = AType then UpdateDisplayType;
    3188. 

  3188. end;
    3189. 

  3189. 

  3190. procedure TSynEditScreenCaret.SetClipRight(const AValue: Integer);
    3191. 

  3191. begin
    3192. 

  3192.   if FClipRight = AValue then exit;
    3193. 

  3193.   FClipRight := AValue;
    3194. 

  3194.   UpdateDisplay;
    3195. 

  3195. end;
    3196. 

  3196. 

  3197. procedure TSynEditScreenCaret.SetCharHeight(const AValue: Integer);
    3198. 

  3198. begin
    3199. 

  3199.   if FCharHeight = AValue then exit;
    3200. 

  3200.   FCharHeight := AValue;
    3201. 

  3201.   UpdateDisplayType;
    3202. 

  3202. end;
    3203. 

  3203. 

  3204. function TSynEditScreenCaret.GetHandle: HWND;
    3205. 

  3205. begin
    3206. 

  3206.   Result :=FHandleOwner.Handle;
    3207. 

  3207. end;
    3208. 

  3208. 

  3209. function TSynEditScreenCaret.GetHandleAllocated: Boolean;
    3210. 

  3210. begin
    3211. 

  3211.   Result :=FHandleOwner.HandleAllocated;
    3212. 

  3212. end;
    3213. 

  3213. 

  3214. procedure TSynEditScreenCaret.SetCharWidth(const AValue: Integer);
    3215. 

  3215. begin
    3216. 

  3216.   if FCharWidth = AValue then exit;
    3217. 

  3217.   FCharWidth := AValue;
    3218. 

  3218.   UpdateDisplayType;
    3219. 

  3219. end;
    3220. 

  3220. 

  3221. procedure TSynEditScreenCaret.SetDisplayPos(const AValue: TPoint);
    3222. 

  3222. begin
    3223. 

  3223.   if (FDisplayPos.x = AValue.x) and (FDisplayPos.y = AValue.y) and
    3224. 

  3224.      (FVisible = Painter.Showing) and (not Painter.NeedPositionConfirmed)
    3225. 

  3225.   then
    3226. 

  3226.     exit;
    3227. 

  3227.   FDisplayPos := AValue;
    3228. 

  3228.   UpdateDisplay;
    3229. 

  3229. end;
    3230. 

  3230. 

  3231. procedure TSynEditScreenCaret.SetDisplayType(const AType: TSynCaretType);
    3232. 

  3232. begin
    3233. 

  3233.   if FDisplayType = AType then exit;
    3234. 

  3234.   FDisplayType := AType;
    3235. 

  3235.   UpdateDisplayType;
    3236. 

  3236. end;
    3237. 

  3237. 

  3238. procedure TSynEditScreenCaret.SetVisible(const AValue: Boolean);
    3239. 

  3239. begin
    3240. 

  3240.   if FVisible = AValue then exit;
    3241. 

  3241.   FVisible := AValue;
    3242. 

  3242.   UpdateDisplay;
    3243. 

  3243. end;
    3244. 

  3244. 

  3245. procedure TSynEditScreenCaret.UpdateDisplayType;
    3246. 

  3246. begin
    3247. 

  3247.   if FLockCount > 0 then begin
    3248. 

  3248.     Include(FLockFlags, sclfUpdateDisplayType);
    3249. 

  3249.     exit;
    3250. 

  3250.   end;
    3251. 

  3251.   Exclude(FLockFlags, sclfUpdateDisplayType);
    3252. 

  3252. 

  3253.   case FDisplayType of
    3254. 

  3254.     ctVerticalLine, ctCostum:
    3255. 

  3255.       begin
    3256. 

  3256.         FPixelWidth     := 2;
    3257. 

  3257.         FPixelHeight    := FCharHeight - 2;
    3258. 

  3258.         FOffsetX        := -1;
    3259. 

  3259.         FOffsetY        :=  1;
    3260. 

  3260.         FExtraLinePixel :=  1;
    3261. 

  3261.       end;
    3262. 

  3262.     ctBlock:
    3263. 

  3263.       begin
    3264. 

  3264.         FPixelWidth     := FCharWidth;
    3265. 

  3265.         FPixelHeight    := FCharHeight - 2;
    3266. 

  3266.         FOffsetX        := 0;
    3267. 

  3267.         FOffsetY        := 1;
    3268. 

  3268.         FExtraLinePixel := FCharWidth;
    3269. 

  3269.       end;
    3270. 

  3270.     ctHalfBlock:
    3271. 

  3271.       begin
    3272. 

  3272.         FPixelWidth     := FCharWidth;
    3273. 

  3273.         FPixelHeight    := (FCharHeight - 2) div 2;
    3274. 

  3274.         FOffsetX        := 0;
    3275. 

  3275.         FOffsetY        := FPixelHeight + 1;
    3276. 

  3276.         FExtraLinePixel := FCharWidth;
    3277. 

  3277.       end;
    3278. 

  3278.     ctHorizontalLine:
    3279. 

  3279.       begin
    3280. 

  3280.         FPixelWidth     := FCharWidth;
    3281. 

  3281.         FPixelHeight    := 2;
    3282. 

  3282.         FOffsetX        := 0;
    3283. 

  3283.         FOffsetY        := FCharHeight - 1;
    3284. 

  3284.         FExtraLinePixel := FCharWidth;
    3285. 

  3285.       end;
    3286. 

  3286.   end;
    3287. 

  3287. 

  3288.   if (FCustomPixelWidth[FDisplayType] <> 0) then begin
    3289. 

  3289.     if ccsRelativeWidth in FCustomFlags[FDisplayType]
    3290. 

  3290.     then FPixelWidth     := FCharWidth * FCustomPixelWidth[FDisplayType] div 1024
    3291. 

  3291.     else FPixelWidth     := FCustomPixelWidth[FDisplayType];
    3292. 

  3292.     if ccsRelativeLeft in FCustomFlags[FDisplayType]
    3293. 

  3293.     then FOffsetX        := FCharWidth * FCustomOffsetX[FDisplayType] div 1024
    3294. 

  3294.     else FOffsetX        := FCustomOffsetX[FDisplayType];
    3295. 

  3295.     FExtraLinePixel := Max(0, FPixelWidth + FOffsetX);
    3296. 

  3296.   end;
    3297. 

  3297.   if (FCustomPixelHeight[FDisplayType] <> 0) then begin
    3298. 

  3298.     if ccsRelativeHeight in FCustomFlags[FDisplayType]
    3299. 

  3299.     then FPixelHeight    := FCharHeight * FCustomPixelHeight[FDisplayType] div 1024
    3300. 

  3300.     else FPixelHeight    := FCustomPixelHeight[FDisplayType];
    3301. 

  3301.     if ccsRelativeTop in FCustomFlags[FDisplayType]
    3302. 

  3302.     then FOffsetY        := FCharHeight * FCustomOffsetY[FDisplayType] div 1024
    3303. 

  3303.     else FOffsetY        := FCustomOffsetY[FDisplayType];
    3304. 

  3304.   end;
    3305. 

  3305. 

  3306.   CalcExtraLineChars;
    3307. 

  3307.   DestroyCaret(True);
    3308. 

  3308.   UpdateDisplay;
    3309. 

  3309. end;
    3310. 

  3310. 

  3311. procedure TSynEditScreenCaret.SetClipBottom(const AValue: Integer);
    3312. 

  3312. begin
    3313. 

  3313.   if FClipBottom = AValue then exit;
    3314. 

  3314.   FClipBottom := AValue;
    3315. 

  3315.   UpdateDisplay;
    3316. 

  3316. end;
    3317. 

  3317. 

  3318. function TSynEditScreenCaret.GetPaintTimer: TSynEditScreenCaretTimer;
    3319. 

  3319. begin
    3320. 

  3320.   if FPaintTimer = nil then begin
    3321. 

  3321.     FPaintTimer := TSynEditScreenCaretTimer.Create;
    3322. 

  3322.     FPaintTimerOwned := True;
    3323. 

  3323.     FPaintTimer.FLocCount := FLockCount;
    3324. 

  3324.   end;
    3325. 

  3325.   Result := FPaintTimer;
    3326. 

  3326. end;
    3327. 

  3327. 

  3328. function TSynEditScreenCaret.GetHasPaintTimer: Boolean;
    3329. 

  3329. begin
    3330. 

  3330.   Result := FPaintTimer <> nil;
    3331. 

  3331. end;
    3332. 

  3332. 

  3333. procedure TSynEditScreenCaret.SetClipExtraPixel(AValue: Integer);
    3334. 

  3334. begin
    3335. 

  3335.   if FClipExtraPixel = AValue then Exit;
    3336. 

  3336.   {$IFDeF SynCaretDebug}
    3337. 

  3337.   debugln(['SynEditCaret ClipRect for HandleOwner=',FHandleOwner, ' ExtraPixel=', dbgs(AValue)]);
    3338. 

  3338.   debugln(['TSynEditScreenCaret.SetClipExtraPixel ',FHandleOwner,' Focus=',FindControl(GetFocus)]);
    3339. 

  3339.   {$ENDIF}
    3340. 

  3340.   FClipExtraPixel := AValue;
    3341. 

  3341.   CalcExtraLineChars;
    3342. 

  3342.   UpdateDisplay;
    3343. 

  3343. end;
    3344. 

  3344. 

  3345. procedure TSynEditScreenCaret.SetClipLeft(const AValue: Integer);
    3346. 

  3346. begin
    3347. 

  3347.   if FClipLeft = AValue then exit;
    3348. 

  3348.   FClipLeft := AValue;
    3349. 

  3349.   UpdateDisplay;
    3350. 

  3350. end;
    3351. 

  3351. 

  3352. procedure TSynEditScreenCaret.SetClipRect(const AValue: TRect);
    3353. 

  3353. begin
    3354. 

  3354.   if (FClipLeft = AValue.Left) and (FClipRight = AValue.Right) and
    3355. 

  3355.      (FClipTop = AValue.Top) and (FClipBottom = AValue.Bottom)
    3356. 

  3356.   then
    3357. 

  3357.     exit;
    3358. 

  3358.   {$IFDeF SynCaretDebug}
    3359. 

  3359.   debugln(['SynEditCaret ClipRect for HandleOwner=',FHandleOwner, ' Rect=', dbgs(AValue)]);
    3360. 

  3360.   {$ENDIF}
    3361. 

  3361.   FClipLeft   := AValue.Left;
    3362. 

  3362.   FClipRight  := AValue.Right;
    3363. 

  3363.   FClipTop    := AValue.Top;
    3364. 

  3364.   FClipBottom := AValue.Bottom;
    3365. 

  3365.   UpdateDisplay;
    3366. 

  3366. end;
    3367. 

  3367. 

  3368. procedure TSynEditScreenCaret.SetClipTop(const AValue: Integer);
    3369. 

  3369. begin
    3370. 

  3370.   if FClipTop = AValue then exit;
    3371. 

  3371.   FClipTop := AValue;
    3372. 

  3372.   UpdateDisplay;
    3373. 

  3373. end;
    3374. 

  3374. 

  3375. procedure TSynEditScreenCaret.CalcExtraLineChars;
    3376. 

  3376. var
    3377. 

  3377.   OldExtraChars: Integer;
    3378. 

  3378. begin
    3379. 

  3379.   if FCharWidth = 0 then exit;
    3380. 

  3380.   OldExtraChars := FExtraLineChars;
    3381. 

  3381.   FExtraLineChars := Max(0, FExtraLinePixel - FClipExtraPixel + FCharWidth - 1)
    3382. 

  3382.                      div FCharWidth;
    3383. 

  3383.   if (FExtraLineChars <> OldExtraChars) and assigned(FOnExtraLineCharsChanged) then
    3384. 

  3384.     FOnExtraLineCharsChanged(Self);
    3385. 

  3385. end;
    3386. 

  3386. 

  3387. procedure TSynEditScreenCaret.SetPaintTimer(AValue: TSynEditScreenCaretTimer);
    3388. 

  3388. begin
    3389. 

  3389.   assert(FPaintTimer = nil, 'TSynEditScreenCaret.SetPaintTimer: FPaintTimer = nil');
    3390. 

  3390.   if FPaintTimer = nil then
    3391. 

  3391.     FPaintTimer := AValue;
    3392. 

  3392. end;
    3393. 

  3393. 

  3394. procedure TSynEditScreenCaret.UpdateDisplay;
    3395. 

  3395. begin
    3396. 

  3396.   if FLockCount > 0 then begin
    3397. 

  3397.     Include(FLockFlags, sclfUpdateDisplay);
    3398. 

  3398.     exit;
    3399. 

  3399.   end;
    3400. 

  3400.   Exclude(FLockFlags, sclfUpdateDisplay);
    3401. 

  3401. 

  3402.   if FVisible then
    3403. 

  3403.     ShowCaret
    3404. 

  3404.   else
    3405. 

  3405.     HideCaret;
    3406. 

  3406. end;
    3407. 

  3407. 

  3408. procedure TSynEditScreenCaret.ShowCaret;
    3409. 

  3409. var
    3410. 

  3410.   x, y, w, h: Integer;
    3411. 

  3411. begin
    3412. 

  3412.   if not HandleAllocated then
    3413. 

  3413.     exit;
    3414. 

  3414.   x := FDisplayPos.x + FOffsetX;
    3415. 

  3415.   y := FDisplayPos.y + FOffsetY;
    3416. 

  3416.   w := FPixelWidth;
    3417. 

  3417.   h := FPixelHeight;
    3418. 

  3418.   if x + w >= FClipRight then
    3419. 

  3419.     w := FClipRight - x - 1;
    3420. 

  3420.   if x < FClipLeft then begin
    3421. 

  3421.     w := w - (FClipLeft - w);
    3422. 

  3422.     x := FClipLeft;
    3423. 

  3423.   end;
    3424. 

  3424.   if y + h >= FClipBottom then
    3425. 

  3425.     h := FClipBottom - y - 1;
    3426. 

  3426.   if y < FClipTop then begin
    3427. 

  3427.     h := h - (FClipTop - y);
    3428. 

  3428.     y := FClipTop;
    3429. 

  3429.   end;
    3430. 

  3430.   if (w <= 0) or (h < 0) or
    3431. 

  3431.      (x < FClipLeft) or (x >= FClipRight) or
    3432. 

  3432.      (y < FClipTop) or (y >= FClipBottom)
    3433. 

  3433.   then begin
    3434. 

  3434.     HideCaret;
    3435. 

  3435.     exit;
    3436. 

  3436.   end;
    3437. 

  3437. 

  3438.   if (not Painter.Created) or (FCaretPainter.Width <> w) or (FCaretPainter.Height <> h) then begin
    3439. 

  3439.     {$IFDeF SynCaretDebug}
    3440. 

  3440.     debugln(['SynEditCaret CreateCaret for HandleOwner=',FHandleOwner, ' DebugShowCount=', FDebugShowCount, ' Width=', w, ' pref-width=', FPixelWidth, ' Height=', FPixelHeight, '  FCurrentCreated=',Painter.Created,  ' FCurrentVisible=',Painter.Showing]);
    3441. 

  3441.     FDebugShowCount := 0;
    3442. 

  3442.     {$ENDIF}
    3443. 

  3443.     // // Create caret includes destroy
    3444. 

  3444.     FCaretPainter.CreateCaret(w, h);
    3445. 

  3445.   end;
    3446. 

  3446.   if (x <> Painter.Left) or (y <> Painter.Top) or (Painter.NeedPositionConfirmed) then begin
    3447. 

  3447.     {$IFDeF SynCaretDebug}
    3448. 

  3448.     debugln(['SynEditCaret SetPos for HandleOwner=',FHandleOwner, ' x=', x, ' y=',y]);
    3449. 

  3449.     {$ENDIF}
    3450. 

  3450.     FCaretPainter.SetCaretPosEx(x, y);
    3451. 

  3451.   end;
    3452. 

  3452.   if (not Painter.Showing) then begin
    3453. 

  3453.     {$IFDeF SynCaretDebug}
    3454. 

  3454.     debugln(['SynEditCaret ShowCaret for HandleOwner=',FHandleOwner, ' FDebugShowCount=',FDebugShowCount, ' FVisible=', FVisible, ' FCurrentVisible=', Painter.Showing]);
    3455. 

  3455.     inc(FDebugShowCount);
    3456. 

  3456.     {$ENDIF}
    3457. 

  3457.     if not FCaretPainter.ShowCaret then begin
    3458. 

  3458.       {$IFDeF SynCaretDebug}
    3459. 

  3459.       debugln(['SynEditCaret ShowCaret FAILED for HandleOwner=',FHandleOwner, ' FDebugShowCount=',FDebugShowCount]);
    3460. 

  3460.       {$ENDIF}
    3461. 

  3461.       DestroyCaret(True);
    3462. 

  3462.     end;
    3463. 

  3463.   end;
    3464. 

  3464. end;
    3465. 

  3465. 

  3466. procedure TSynEditScreenCaret.HideCaret;
    3467. 

  3467. begin
    3468. 

  3468.   if not HandleAllocated then
    3469. 

  3469.     exit;
    3470. 

  3470.   if not Painter.Created then exit;
    3471. 

  3471.   if Painter.Showing then begin
    3472. 

  3472.     {$IFDeF SynCaretDebug}
    3473. 

  3473.     debugln(['SynEditCaret HideCaret for HandleOwner=',FHandleOwner, ' FDebugShowCount=',FDebugShowCount, ' FVisible=', FVisible, ' FCurrentVisible=', Painter.Showing]);
    3474. 

  3474.     dec(FDebugShowCount);
    3475. 

  3475.     {$ENDIF}
    3476. 

  3476.     if FCaretPainter.HideCaret then
    3477. 

  3477.     else begin
    3478. 

  3478.       {$IFDeF SynCaretDebug}
    3479. 

  3479.       debugln(['SynEditCaret HideCaret FAILED for HandleOwner=',FHandleOwner, ' FDebugShowCount=',FDebugShowCount]);
    3480. 

  3480.       {$ENDIF}
    3481. 

  3481.       DestroyCaret(True);
    3482. 

  3482.     end;
    3483. 

  3483.   end;
    3484. 

  3484. end;
    3485. 

  3485. 

  3486. end.
    3487. 

  3487. 

  3488.