aboutsummaryrefslogtreecommitdiffstatsci
path: root/Samples/CrowIDE/src/Editors/CodeBuffer/TextBuffer.cs
diff options
context:
space:
mode:
Diffstat (limited to 'Samples/CrowIDE/src/Editors/CodeBuffer/TextBuffer.cs')
-rw-r--r--Samples/CrowIDE/src/Editors/CodeBuffer/TextBuffer.cs527
1 files changed, 527 insertions, 0 deletions
diff --git a/Samples/CrowIDE/src/Editors/CodeBuffer/TextBuffer.cs b/Samples/CrowIDE/src/Editors/CodeBuffer/TextBuffer.cs
new file mode 100644
index 00000000..e8c87182
--- /dev/null
+++ b/Samples/CrowIDE/src/Editors/CodeBuffer/TextBuffer.cs
@@ -0,0 +1,527 @@
+//
+// CodeTextBuffer.cs
+//
+// Author:
+// Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
+//
+// Copyright (c) 2017 jp
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Diagnostics;
+using System.Threading;
+using System.Text;
+
+namespace Crow.Text
+{
+ /// <summary>
+ /// Code buffer, lines are arranged in a List<string>, new line chars are removed during string.split on '\n...',
+ /// </summary>
+ public class TextBuffer
+ {
+ public ReaderWriterLockSlim editMutex = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+ static Regex slb = new Regex ("\\n");//single char line break used internaly
+ Regex reghexLineBrk = new Regex(@"\r\n|\r|\n|\\\n");//original text line break regex
+
+ #region Events
+ public event EventHandler<TextBufferEventArgs> LineUpadateEvent;
+ public event EventHandler<TextBufferEventArgs> LineRemoveEvent;
+ public event EventHandler<TextBufferEventArgs> LineAdditionEvent;
+ public event EventHandler BufferCleared;
+ public event EventHandler SelectionChanged;
+ public event EventHandler PositionChanged;
+ #endregion
+
+ StringBuilder buffer = new StringBuilder();
+ string lineBreak = Interface.LineBreak;//detected linebreak kind in original source
+ List<int> lineLength = new List<int>();//line length table
+ /// <summary>
+ /// real position in char arrays, tab = 1 char
+ /// </summary>
+ int _currentLine = 0;
+ int _currentCol = 0;
+
+ /// <summary>
+ /// Gets the total line count.
+ /// </summary>
+ public int LineCount { get { return lineLength.Count;}}
+
+ /// <summary>
+ /// get a substring in the buffer
+ /// </summary>
+ /// <returns>a new string</returns>
+ /// <param name="idx">absolute index in the buffer</param>
+ /// <param name="length">length of the substring</param>
+ public string GetSubString (int idx, int length){
+ return buffer.ToString (idx, length);
+ }
+ /// <summary>
+ /// Gets length of a line.
+ /// </summary>
+ /// <returns>length of line</returns>
+ /// <param name="lineIdx">line nuber</param>
+ public int GetLineLength (int lineIdx) {
+ return lineLength [lineIdx];
+ }
+ /// <summary>
+ /// get a single charactere in the buffer
+ /// </summary>
+ /// <returns>a single char</returns>
+ /// <param name="idx">absolute index in the buffer</param>
+ public char GetCharAt (int idx){
+ return buffer [idx];
+ }
+ /// <summary>
+ /// return full text with original line breaks
+ /// </summary>
+ /// <value>a string containing the full text</value>
+ public string FullText {
+ get { return buffer.Replace("\n", lineBreak).ToString (); }
+ set {
+ Load (value);
+ }
+ }
+ /// <summary>
+ /// Gets the buffer pointer of a line
+ /// </summary>
+ /// <returns>absolute index of the line in the buffer</returns>
+ /// <param name="i">line number</param>
+ public int GetBufferIndexOfLine (int i) {
+ int ptr = 0;
+ editMutex.EnterReadLock ();
+ for (int j = 0; j < i; j++) {
+ ptr += lineLength [j];
+ }
+ editMutex.ExitReadLock ();
+ return ptr;
+ }
+ /// <summary>
+ /// Gets the buffer pointer for the current position
+ /// </summary>
+ /// <value>absolute index in the buffer of current position</value>
+ public int BufferIndexOfCurrentPosition {
+ get {return GetBufferIndexOfLine (_currentLine) + _currentCol;}
+ }
+ public int this[int i]
+ {
+ get {
+ int ptr = 0;
+ editMutex.EnterReadLock ();
+ for (int j = 0; j < i; j++) {
+ ptr += lineLength [j];
+ }
+ editMutex.ExitReadLock ();
+ return ptr;
+ }
+ }
+ /// <summary>
+ /// remove line number i
+ /// </summary>
+ /// <param name="i">index of the line</param>
+ public void RemoveLine(int i){
+ editMutex.EnterWriteLock ();
+ buffer.Remove (GetBufferIndexOfLine (i), lineLength [i]);
+ lineLength.RemoveAt (i);
+ editMutex.ExitWriteLock ();
+ LineRemoveEvent.Raise (this, new TextBufferEventArgs (i));
+ }
+ /// <summary>
+ /// insert string without linebreaks at position i in buff
+ /// </summary>
+ /// <param name="i">absolute index in the buffer</param>
+ /// <param name="str">linebreak free string</param>
+ public void InsertAt(int i, string str){
+ editMutex.EnterWriteLock ();
+ buffer.Insert (this [i], str);
+ lineLength.Insert (i, str.Length);
+ editMutex.ExitWriteLock ();
+ LineAdditionEvent.Raise (this, new TextBufferEventArgs (i));
+ }
+ public void AddLine(string str){
+ editMutex.EnterWriteLock ();
+ if (lineLength.LastOrDefault() == 0) {
+ buffer.Append (str);
+ lineLength [lineLength.Count - 1] = str.Length;
+ lineLength.Add (0);
+ }
+ editMutex.ExitWriteLock ();
+ LineAdditionEvent.Raise (this, new TextBufferEventArgs (lineLength.Count - 1));
+ }
+ public void AddRange (string[] items){
+ int start = lineLength.Count;
+ editMutex.EnterWriteLock ();
+ for (int i = 0; i < items.Length; i++)
+ AddLine (items [i]);
+ editMutex.ExitWriteLock ();
+ LineAdditionEvent.Raise (this, new TextBufferEventArgs (start, items.Length));
+ }
+ public void Clear () {
+ editMutex.EnterWriteLock ();
+ lineLength.Clear ();
+ buffer.Clear ();
+ editMutex.ExitWriteLock ();
+ BufferCleared.Raise (this, null);
+ }
+ public void UpdateLine(int i, string newContent){
+ editMutex.EnterWriteLock ();
+ int ptrL = this [i];
+ buffer.Remove (ptrL, lineLength [i]);
+ buffer.Insert (ptrL, newContent);
+ lineLength [i] = newContent.Length;
+ editMutex.ExitWriteLock ();
+ LineUpadateEvent.Raise (this, new TextBufferEventArgs (i));
+ }
+ public void AppenedLine(int i, string newContent){
+ editMutex.EnterWriteLock ();
+ int ptr = this [i] + lineLength [i];
+ if (i < LineCount - 1)
+ ptr--;
+ buffer.Insert(ptr, newContent);
+ lineLength [i] += newContent.Length;
+ editMutex.ExitWriteLock ();
+ LineUpadateEvent.Raise (this, new TextBufferEventArgs (i));
+ }
+ /// <summary>
+ /// Insert new string at caret position, should be sure no line break is inside.
+ /// </summary>
+ /// <param name="str">String.</param>
+ public void InsertAt(string str)
+ {
+ if (!SelectionIsEmpty)
+ this.Delete ();
+
+ editMutex.EnterWriteLock ();
+
+ string tmp = reghexLineBrk.Replace (str, "\n");//use single char line break in buffer
+ int buffPtr = this [CurrentLine] + CurrentColumn;
+ buffer.Insert (buffPtr, tmp);
+
+ int lPtr = CurrentLine, strPtr = 0;
+ int remainingLength = lineLength [lPtr] - CurrentColumn;
+ lineLength [lPtr] = CurrentColumn;
+ foreach (Match match in slb.Matches(tmp))
+ {
+ lineLength [lPtr] += match.Index + 1 - strPtr;
+ lPtr++;
+ lineLength.Insert (lPtr, 0);
+ strPtr = match.Index + 1;
+ //CurrentLine++;
+ }
+ remainingLength += tmp.Length - strPtr;
+ lineLength [lPtr] += remainingLength;
+
+ CurrentLine = lPtr;
+ if (strPtr == 0)
+ CurrentColumn += tmp.Length;
+ else
+ CurrentColumn = tmp.Length - strPtr;
+
+ editMutex.ExitWriteLock ();
+ if (strPtr>0)
+ LineAdditionEvent.Raise (this, null);
+ else
+ LineUpadateEvent.Raise (this, null);
+ }
+ /// <summary>
+ /// Insert a line break.
+ /// </summary>
+ public void InsertLineBreak()
+ {
+ editMutex.EnterWriteLock ();
+ buffer.Insert (this [CurrentLine] + CurrentColumn, '\n');
+ int lgdiff = lineLength [CurrentLine] - CurrentColumn;
+ lineLength.Insert (CurrentLine + 1, lineLength [CurrentLine] - CurrentColumn);
+ lineLength [CurrentLine] = CurrentColumn + 1;
+ editMutex.ExitWriteLock ();
+ LineAdditionEvent.Raise (this, null);
+ CurrentColumn = 0;
+ CurrentLine++;
+ }
+ public void Delete()
+ {
+ editMutex.EnterWriteLock ();
+ if (SelectionIsEmpty) {
+ if (CurrentColumn == 0) {
+ if (CurrentLine == 0) {
+ editMutex.ExitWriteLock ();
+ return;
+ }
+
+ buffer.Remove (this [CurrentLine] - 1, 1);
+
+ int col = lineLength [CurrentLine - 1] - 1;
+ lineLength [CurrentLine - 1] += lineLength [CurrentLine] - 1;
+ lineLength.RemoveAt (CurrentLine);
+
+ CurrentLine--;
+ CurrentColumn = col;
+
+ editMutex.ExitWriteLock ();
+ LineRemoveEvent.Raise (this, null);
+ return;
+ }
+ CurrentColumn--;
+ buffer.Remove (this [CurrentLine] + CurrentColumn, 1);
+ lineLength [CurrentLine]--;
+ } else {
+ int linesToRemove = SelectionEnd.Y - SelectionStart.Y;
+ int ptr = this [SelectionStart.Y] + SelectionStart.X;
+ int length = lineLength [SelectionStart.Y] - SelectionStart.X;
+ int l = 1;
+ while (l <= linesToRemove ) {
+ length += lineLength [SelectionStart.Y + l];
+ l++;
+ }
+ length -= lineLength [SelectionEnd.Y] - SelectionEnd.X;
+ buffer.Remove (ptr, length);
+ lineLength [SelectionStart.Y] = SelectionStart.X + lineLength [SelectionEnd.Y] - SelectionEnd.X;
+ lineLength.RemoveRange (SelectionStart.Y + 1, linesToRemove);
+
+ CurrentLine = SelectionStart.Y;
+ CurrentColumn = SelectionStart.X;
+ ResetSelection ();
+
+ if (linesToRemove > 0)
+ LineRemoveEvent.Raise (this, null);
+ else
+ LineUpadateEvent.Raise (this, null);
+ }
+ editMutex.ExitWriteLock ();
+ }
+ public void Load(string rawSource) {
+ this.Clear();
+
+ if (string.IsNullOrEmpty (rawSource))
+ return;
+
+ lineBreak = reghexLineBrk.Match (rawSource).Value;//store original line break
+ string tmp = reghexLineBrk.Replace (rawSource, "\n");//use single char line break in buffer
+ int ptr = 0;
+ foreach (Match match in slb.Matches(tmp))
+ {
+ int l = match.Index + 1;
+ int lg = l - ptr;
+ lineLength.Add (lg);
+ ptr = l;
+ }
+ lineLength.Add (0);
+
+ buffer = new StringBuilder (tmp);
+ }
+
+// public int CurrentTabulatedColumn {
+// get {
+//// return lines [_currentLine].Content.Substring (0, _currentCol).
+//// Replace ("\t", new String (' ', Interface.TabSize)).Length;
+// }
+// }
+
+ #region moving cursor an selection
+ Point selStartPos = -1; //selection start (row,column)
+ Point selEndPos = -1; //selection end (row,column)
+
+ public bool SelectionInProgress { get { return selStartPos >= 0; }}
+ public void SetSelStartPos () {
+ selStartPos = selEndPos = CurrentPosition;
+ SelectionChanged.Raise (this, null);
+ }
+ public void SetSelEndPos () {
+ selEndPos = CurrentPosition;
+ SelectionChanged.Raise (this, null);
+ }
+ /// <summary>
+ /// Set selection in buffer to -1, empty selection
+ /// </summary>
+ public void ResetSelection () {
+ selStartPos = selEndPos = -1;
+ SelectionChanged.Raise (this, null);
+ }
+ /// <summary>
+ /// ordered selection start and end positions in char units
+ /// </summary>
+ public Point SelectionStart {
+ get { return selEndPos < 0 || selStartPos.Y < selEndPos.Y ? selStartPos :
+ selStartPos.Y > selEndPos.Y ? selEndPos :
+ selStartPos.X < selEndPos.X ? selStartPos : selEndPos; }
+ }
+ public Point SelectionEnd {
+ get { return selEndPos < 0 || selStartPos.Y > selEndPos.Y ? selStartPos :
+ selStartPos.Y < selEndPos.Y ? selEndPos :
+ selStartPos.X > selEndPos.X ? selStartPos : selEndPos; }
+ }
+ public bool SelectionIsEmpty
+ { get { return selEndPos == selStartPos; } }
+ /// <summary>
+ /// Current column in buffer coordinate, tabulation = 1 char
+ /// </summary>
+ public int CurrentColumn{
+ get { return _currentCol; }
+ set {
+ if (value == _currentCol)
+ return;
+
+ editMutex.EnterWriteLock ();
+
+ if (value < 0)
+ _currentCol = 0;
+ else if (value >= lineLength [_currentLine]) {
+ if (_currentLine < LineCount -1 && value > lineLength [_currentLine] - 1)
+ _currentCol = lineLength [_currentLine] - 1;
+ else
+ _currentCol = lineLength [_currentLine];
+ }else
+ _currentCol = value;
+
+ editMutex.ExitWriteLock ();
+
+ PositionChanged.Raise (this, null);
+ }
+ }
+ /// <summary>
+ /// Current row in buffer coordinate, tabulation = 1 char
+ /// </summary>
+ public int CurrentLine{
+ get { return _currentLine; }
+ set {
+ if (value == _currentLine)
+ return;
+
+ editMutex.EnterWriteLock ();
+
+ if (value >= lineLength.Count)
+ _currentLine = lineLength.Count-1;
+ else if (value < 0)
+ _currentLine = 0;
+ else
+ _currentLine = value;
+
+ int c = _currentCol;
+ _currentCol = 0;
+ CurrentColumn = c;
+
+ editMutex.ExitWriteLock();
+
+ PositionChanged.Raise (this, null);
+ }
+ }
+ /// <summary>
+ /// Current position in buffer coordinate, tabulation = 1 char
+ /// </summary>
+ public Point CurrentPosition {
+ get { return new Point(CurrentColumn, CurrentLine); }
+ }
+ /// <summary>
+ /// get char at current position in buffer
+ /// </summary>
+ protected Char CurrentChar { get { return buffer[this [CurrentLine]]; } }
+ public string SelectedText {
+ get {
+ if (SelectionIsEmpty)
+ return "";
+ Point selStart = SelectionStart;
+ Point selEnd = SelectionEnd;
+
+ int ptr = this [selStart.Y] + selStart.X;
+ int length = lineLength[selStart.Y] - selStart.X;
+ for (int i = selStart.Y+1; i <= selEnd.Y; i++)
+ length += lineLength [i];
+ length -= lineLength[selEnd.Y] - selEnd.X;
+
+ return buffer.ToString (ptr, length);
+ }
+ }
+
+ public void GotoWordStart(){
+ if (_currentCol == 0)
+ MoveLeft ();
+ if (_currentCol == 0)
+ return;
+ int ptrStart = BufferIndexOfCurrentPosition;
+ int ptr = ptrStart;
+ char c;
+ //skip white spaces
+ do {
+ ptr--;
+ c = this.GetCharAt (ptr);
+ } while (!char.IsLetterOrDigit (c) && c != '\n' && ptr > 1);
+
+ do {
+ ptr--;
+ c = this.GetCharAt (ptr);
+ } while (char.IsLetterOrDigit (c) && c != '\n' && ptr > 1);
+
+ if (ptr == 0)
+ CurrentColumn = 0;
+ else
+ CurrentColumn -= ptrStart - ptr - 1;
+ }
+ public void GotoWordEnd(){
+ int limx = GetLineLength (_currentLine);
+ if (_currentLine < lineLength.Count - 1)
+ limx--;
+
+ if (_currentCol == limx) {
+ MoveRight ();
+ limx = GetLineLength (_currentLine);
+ if (_currentLine < lineLength.Count - 1)
+ limx--;
+ }
+
+ int ptrLine = GetBufferIndexOfLine(_currentLine);
+ int ptrCol = _currentCol;
+
+ char c;
+ //skip white spaces
+ do {
+ c = GetCharAt (ptrLine+ptrCol);
+ ptrCol++;
+ } while (!char.IsLetterOrDigit (c) && ptrCol < limx);
+
+ do {
+ c = GetCharAt (ptrLine + ptrCol);
+ ptrCol++;
+ } while (char.IsLetterOrDigit (c) && ptrCol < limx);
+ CurrentColumn = ptrCol - 1;
+ }
+ /// <summary>
+ /// Moves cursor one char to the left, move up if cursor reaches start of line
+ /// </summary>
+ public void MoveLeft(){
+ if (CurrentColumn == 0) {
+ CurrentLine--;
+ CurrentColumn = int.MaxValue;
+ } else
+ CurrentColumn--;
+ }
+ /// <summary>
+ /// Moves cursor one char to the right, move down if cursor reaches end of line
+ /// </summary>
+ public void MoveRight(){
+ if (_currentLine < LineCount -1){
+ if (CurrentColumn >= lineLength [CurrentLine] - 1) {
+ CurrentColumn = 0;
+ CurrentLine++;
+ return;
+ }
+ }
+ CurrentColumn++;
+ }
+
+ #endregion
+ }
+}
+
generated by cgit v1.3.1-4-g156e (git 2.54.0) at 2026-11-12 20:20:17 +0000