/// <summary>
/// 删除指定位置的一个字符
/// </summary>
/// <param name="pos">开始位置</param>
public void RemoveCharacter(URank pos)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("RemoveCharacter : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col >= mCodeData[pos.Row].Count)
{
throw new Exception("RemoveCharacter : Col Invalid {" + pos.Col.ToString() + "}");
}
if (UHelper.IsChinesePart(mCodeData[pos.Row].ToArray(), pos.Col))
{
mCodeData[pos.Row].RemoveRange(pos.Col - 1, 2);
mCoder.SetCursorPos(new URank(pos.Row, pos.Col - 2));
}
else
{
mCodeData[pos.Row].RemoveAt(pos.Col);
mCoder.SetCursorPos(new URank(pos.Row, pos.Col));
}
mCodeLines[pos.Row] = mParser.ParseLine(pos.Row);
}
public RemoveStringCommand(UCodeManager codeManager, URank pos, int len)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
this.mLength = len;
this.mRemoveString = string.Empty;
}
/// <summary>
/// 删除指定位置的换行符
/// </summary>
/// <param name="pos"></param>
public void RemoveNewlineByte(URank pos)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("RemoveNewLineByte : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col >= mCodeData[pos.Row].Count)
{
throw new Exception("RemoveNewLineByte : Col Invalid {" + pos.Col.ToString() + "}");
}
if (mCodeData[pos.Row][pos.Col] != UConfig.NewLine)
{
return;
}
// 删除当前的的换行符后，如果还有下一行，则合并到当前行
if (pos.Row + 1 < mCodeData.Count)
{
// 如果下一行有可见字符，才合并
// 否则的话，就直接删除下一行就行了
if (mCodeLines[pos.Row + 1].HasVisibleCharacter)
{
mCodeData[pos.Row].RemoveAt(pos.Col);
mCodeData[pos.Row].AddRange(mCodeData[pos.Row + 1]);
mCodeLines[pos.Row] = mParser.ParseLine(pos.Row);
}
mCodeData.RemoveAt(pos.Row + 1);
mCodeLines.RemoveAt(pos.Row + 1);
mCoder.SetCursorPos(new URank(pos.Row, pos.Col));
}
}
public ReplaceCharacterCommand(UCodeManager codeManager, URank pos, byte newCh)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
this.mNewCharacter = newCh;
this.mOldCharacter = 0;
}
/// <summary>
/// 插入换行符到指定位置
/// </summary>
/// <param name="pos"></param>
public void InsertNewLineByte(URank pos)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("InsertNewLineByte : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col >= mCodeData[pos.Row].Count)
{
throw new Exception("InsertNewLineByte : Col Invalid {" + pos.Col.ToString() + "}");
}
List <byte> newLineBytes = new List <byte>();
// 插入回车，然后把后面的字节添加到新的一行
mCodeData[pos.Row].Insert(pos.Col, UConfig.NewLine);
for (int i = pos.Col + 1; i < mCodeData[pos.Row].Count; i++)
{
newLineBytes.Add(mCodeData[pos.Row][i]);
}
// 删除换行的内容，并添加到下一行中
mCodeData[pos.Row].RemoveRange(pos.Col + 1, mCodeData[pos.Row].Count - pos.Col - 1);
mCodeData.Insert(pos.Row + 1, newLineBytes);
// 分析这两行
mCodeLines[pos.Row] = mParser.ParseLine(pos.Row);
mCodeLines.Insert(pos.Row + 1, mParser.ParseLine(pos.Row + 1));
mCoder.SetCursorPos(new URank(pos.Row + 1, mCodeLines[pos.Row + 1].VisibleStartCol));
}
public RemoveRangeStringCommand(UCodeManager codeManager, URank start, URank end)
{
this.mCodeManager = codeManager;
this.mStart = start;
this.mEnd = end;
this.mRemoveString = string.Empty;
}
public void MouseMove(UMouseEvents e)
{
if (mIsBlankWindow)
{
return;
}
if (mMouseLeftDown == true)
{
mCodeRenderer.SetCursorPos(e.X, e.Y);
URank pos = mCodeRenderer.GetCursorPos();
if (mSelection.Start == URank.None)
{
mSelection.SetStart(pos);
mSelection.SetEnd(pos);
}
else
{
if (pos <= mSelection.Start)
{
mSelection.SetStart(pos);
}
else// if (pos > mSelection.End)
{
mSelection.SetEnd(pos);
}
}
}
}
/// <summary>
/// 删除指定范围的字符串
/// </summary>
/// <param name="start">开始位置</param>
/// <param name="end">结束位置</param>
public void RemoveRangeString(URank start, URank end)
{
try
{
int startRow = start.Row;
int startCol = start.Col;
int endRow = end.Row;
int endCol = end.Col;
if (start == end)
{
return;
}
if (startRow == endRow)
{
for (int i = startCol; i < endCol; i++)
{
//RemoveCharacter(new URank(startRow, startCol));
mCodeData[startRow].RemoveAt(startCol);
}
mCodeLines[startRow] = mParser.ParseLine(startRow);
mCoder.SetCursorPos(start);
return;
}
else
{
for (int i = 0; i < endCol; i++)
{
//RemoveCharacter(new URank(endRow, 0));
mCodeData[endRow].RemoveAt(0);
}
mCodeLines[endRow] = mParser.ParseLine(endRow);
for (int i = startRow + 1; i < endRow; i++)
{
mCodeData.RemoveAt(startRow + 1);
mCodeLines.RemoveAt(startRow + 1);
}
int len = GetCodeLength(startRow);
for (int i = startCol; i < len - 1; i++)
{
//RemoveCharacter(new URank(startRow, startCol));
mCodeData[startRow].RemoveAt(startCol);
}
RemoveNewlineByte(new URank(startRow, GetCodeLength(startRow) - 1));
mCodeLines[startRow] = mParser.ParseLine(startRow);
mCoder.SetCursorPos(start);
}
}
catch (Exception ex)
{
throw ex;
}
}
public ReplaceStringCommand(UCodeManager codeManager, URank pos, int len, string newString)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
this.mLength = len;
this.mNewString = newString;
this.mOldString = string.Empty;
}
/// <summary>
/// 返回指定位置所在的CodeCut
/// </summary>
/// <param name="pos"></param>
/// <returns></returns>
public UCodeCut GetCodeCut(URank pos)
{
if (pos.Row < 0 || pos.Row >= mCodeLines.Count)
{
throw new Exception("GetCodeCut : Row Invalid { " + pos.Row.ToString() + "}");
}
return(mCodeLines[pos.Row].GetCutByCol(pos.Col));
}
public override void Reset()
{
this.mRenderOffset = UPoint.Zero;
this.mRenderStartRow = 0;
this.mRenderSize = new URank(
(int)((float)Coder.Renderer.RenderHeight / Coder.Renderer.CharHeight),
(int)((float)Coder.Renderer.RenderWidth / Coder.Renderer.CharWidth));
this.mCursor = URank.Zero;
}
/// <summary>
/// 返回指定位置的一个字符
/// </summary>
/// <param name="pos"></param>
/// <returns></returns>
public byte GetCodeByte(URank pos)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("GetCodeCharacter : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col >= mCodeData[pos.Row].Count)
{
throw new Exception("GetCodeCharacter : Col Invalid {" + pos.Col.ToString() + "}");
}
return(mCodeData[pos.Row][pos.Col]);
}
/// <summary>
/// 返回指定位置指定长度的字符串
/// </summary>
/// <param name="pos"></param>
/// <param name="len"></param>
/// <returns></returns>
public string GetCodeString(URank pos, int len)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("GetCodeString : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col + len >= mCodeData[pos.Row].Count)
{
throw new Exception("GetCodeString : Col Invalid {" + pos.Col.ToString() + "}");
}
return(UHelper.GetStringByBytes(mCodeData[pos.Row].GetRange(pos.Col, len).ToArray()));
}
/// <summary>
/// 返回指定区域的字符串
/// </summary>
/// <param name="start">开始位置</param>
/// <param name="end">结束位置</param>
/// <returns></returns>
public string GetCodeString(URank start, URank end)
{
try
{
StringBuilder sb = new StringBuilder();
List <byte> lineByte = new List <byte>();
int startRow = start.Row;
int startCol = start.Col;
int endRow = end.Row;
int endCol = end.Col;
if (start == end)
{
return(GetCodeString(start, endCol - startCol));
}
// 复制第一行
int len = GetCodeLength(startRow);
for (int i = startCol; i < len; i++)
{
lineByte.Add(GetCodeByte(new URank(startRow, i)));
}
sb.Append(UHelper.GetStringByBytes(lineByte.ToArray()));
// 复制中间部分
for (int i = startRow + 1; i < endRow; i++)
{
sb.Append(UHelper.GetStringByBytes(mCodeData[i].ToArray()));
}
lineByte.Clear();
// 复制最后一行
for (int i = 0; i < endCol; i++)
{
lineByte.Add(GetCodeByte(new URank(endRow, i)));
}
sb.Append(UHelper.GetStringByBytes(lineByte.ToArray()));
return(sb.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 删除指定位置的一个字符串
/// </summary>
/// <param name="pos">开始位置</param>
/// <param name="len">长度</param>
public void RemoveString(URank pos, int len)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("RemoveString : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col + len >= mCodeData[pos.Row].Count)
{
throw new Exception("RemoveString : Col Invalid {" + pos.Col.ToString() + "}");
}
mCodeData[pos.Row].RemoveRange(pos.Col, len);
mCodeLines[pos.Row] = mParser.ParseLine(pos.Row);
mCoder.SetCursorPos(pos);
}
/// <summary>
/// 在指定位置插入一个字符串
/// </summary>
/// <param name="pos">开始位置</param>
/// <param name="text">要插入的字符串</param>
public void InsertString(URank pos, string str)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("InsertString : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col >= mCodeData[pos.Row].Count)
{
throw new Exception("InsertString : Col Invalid {" + pos.Col.ToString() + "}");
}
mCodeData[pos.Row].InsertRange(pos.Col, UHelper.GetBytesByString(str));
mCodeLines[pos.Row] = mParser.ParseLine(pos.Row);
mCoder.SetCursorPos(new URank(pos.Row, pos.Col + UHelper.GetAbsoluteLength(str)));
}
/// <summary>
/// 在指定位置插入一个字符
/// </summary>
/// <param name="pos">开始位置</param>
/// <param name="b">要插入的字符</param>
public void InsertCharacter(URank pos, byte b)
{
if (pos.Row < 0 || pos.Row >= mCodeData.Count)
{
throw new Exception("InsertCharacter : Row Invalid {" + pos.Row.ToString() + "}");
}
if (pos.Col < 0 || pos.Col >= mCodeData[pos.Row].Count)
{
throw new Exception("InsertCharacter : Col Invalid {" + pos.Col.ToString() + "}");
}
mCodeData[pos.Row].Insert(pos.Col, b);
mCodeLines[pos.Row] = mParser.ParseLine(pos.Row);
mCoder.SetCursorPos(new URank(pos.Row, pos.Col + 1));
}
public InsertRangeStringCommand(UCodeManager codeManager, URank start, string insertString)
{
this.mCodeManager = codeManager;
this.mStart = start;
this.mEnd = start;
this.mInsertString = insertString;
byte[] data = UHelper.TanslateString(insertString);
for (int i = 0; i < data.Length; i++)
{
if (data[i] == UConfig.NewLine)
{
this.mEnd.Row++;
this.mEnd.Col = 0;
continue;
}
this.mEnd.Col++;
}
}
/// <summary>
/// 插入多行字符串
/// </summary>
/// <param name="start">开始位置</param>
/// <param name="rangeStr">字符串</param>
public void InsertRangeString(URank start, string rangeStr)
{
int row = start.Row;
int col = start.Col;
byte[] data = UHelper.TanslateString(rangeStr);
for (int i = 0; i < data.Length; i++)
{
mCodeData[row].Insert(col, data[i]);
col++;
if (data[i] == UConfig.NewLine)
{
// 遇到换行符，首先剪切之后的数据到下一行
List <byte> newLine = new List <byte>();
for (int n = col; n < mCodeData[row].Count; n++)
{
newLine.Add(mCodeData[row][n]);
}
mCodeData[row].RemoveRange(col, mCodeData[row].Count - col);
mCodeLines[row] = mParser.ParseLine(row);
row++;
col = 0;
mCodeData.Insert(row, newLine);
mCodeLines.Insert(row, new UCodeLine());
mCodeLines[row] = mParser.ParseLine(row);
continue;
}
}
mCodeLines[row] = mParser.ParseLine(row);
mCoder.SetCursorPos(new URank(row, col));
}
public void KeyDown(UKeyEvents e)
{
if (mIsBlankWindow)
{
return;
}
switch (e.KeyCode)
{
case UKeys.Left:
mCodeRenderer.DecreaseCursorCol();
mIntelligentSence.Reset();
return;
case UKeys.Right:
mCodeRenderer.IncreaseCursorCol();
mIntelligentSence.Reset();
return;
case UKeys.Up:
if (mIntelligentSence.HasMatching)
{
mIntelligentSence.DecreaseIndex();
}
else
{
mCodeRenderer.DecreaseCursorRow();
}
return;
case UKeys.Down:
if (mIntelligentSence.HasMatching)
{
mIntelligentSence.IncreaseIndex();
}
else
{
mCodeRenderer.IncreaseCursorRow();
}
return;
case UKeys.Back:
// 删除键是删除鼠标前一个位置的字符
if (mSelection.HasSelection)
{
RemoveSelection();
return;
}
if (mCodeRenderer.CursorCol == 0) // 在行首删除，合并当上一行
{
if (mCodeRenderer.CursorRow > 0)
{
RemoveNewlineByteCommand rnc = new RemoveNewlineByteCommand(
mCodeManager,
new URank(mCodeRenderer.CursorRow - 1,
mCodeManager.GetCodeLength(mCodeRenderer.CursorRow - 1) - 1));
mCodeManager.Execute(rnc);
}
}
else
{
RemoveCharacterCommand rcc = new RemoveCharacterCommand(
mCodeManager,
new URank(mCodeRenderer.CursorRow, mCodeRenderer.CursorCol - 1));
mCodeManager.Execute(rcc);
}
return;
case UKeys.Space:
{
// 这里不要return，留到下面处理space添加一个空格
if (mIntelligentSence.HasMatching)
{
mIntelligentSence.Selected();
}
else if (mSelection.HasSelection)
{
RemoveSelection();
}
}
break;
case UKeys.Enter:
{
if (mIntelligentSence.HasMatching)
{
mIntelligentSence.Selected();
return;
}
URank pos = mCodeRenderer.GetCursorPos();
InsertNewLineByteCommand inc = new InsertNewLineByteCommand(mCodeManager, pos);
mCodeManager.Execute(inc);
// 缩进处理
// 计算新的一行需要额外填充的空格
// 从上一行的可见字符开始
int padSpaceCount = mCodeManager.GetCodeLine(pos.Row).VisibleStartCol;
// 按回车后，检查是否是在“{”或“}”后按的回车
if (pos.Col - 1 >= 0)
{
byte lastByte = mCodeManager.GetCodeData(pos.Row)[pos.Col - 1]; // 最后一个字符是回车，所以应该减一
// 如果是左括号“{”
if (lastByte == UConfig.LBracket)
{
padSpaceCount += UConfig.TabNumberOfSpace;
}
}
if (padSpaceCount > 0)
{
// 如果只是在一行的空白部分中间按下回车
// 那么padSpaceCount = 上一行的空白部分
// 并且新的一行本身就包含了一部分
// 加起来刚好
byte[] spaceBytes = new byte[padSpaceCount];
for (int i = 0; i < padSpaceCount; i++)
{
spaceBytes[i] = UConfig.Space;
}
InsertStringCommand isc = new InsertStringCommand(mCodeManager, new URank(pos.Row + 1, 0), UHelper.GetStringByBytes(spaceBytes));
mCodeManager.Execute(isc);
}
return;
}
case UKeys.A:
if (e.Ctrl)
{
SelectAll();
return;
}
break;
case UKeys.C:
if (e.Ctrl)
{
Copy();
return;
}
break;
case UKeys.V:
if (e.Ctrl)
{
Paste();
return;
}
break;
case UKeys.X:
if (e.Ctrl)
{
Cut();
return;
}
break;
case UKeys.Y:
if (e.Ctrl)
{
mCodeManager.Redo();
return;
}
break;
case UKeys.Z:
if (e.Ctrl)
{
mCodeManager.Undo();
return;
}
break;
default:
break;
}
char ch = UHelper.ParseKey(e);
if (ch == (char)0)
{
return;
}
if (mSelection.HasSelection)
{
RemoveSelection();
}
InsertCharacterCommand iccd = new InsertCharacterCommand(mCodeManager, mCodeRenderer.GetCursorPos(), (byte)ch);
mCodeManager.Execute(iccd);
// 如果输入的字符是“}”，那么缩进一个Tab
// 处理输入字符“{”，是在按回车处理
if ((byte)ch == UConfig.RBracket)
{
URank pos = mCodeRenderer.GetCursorPos();
int visibleStartCol = mCodeManager.GetCodeLine(pos.Row).VisibleStartCol;
if (visibleStartCol >= UConfig.TabNumberOfSpace)
{
// 缩进一个Tab，先找到最靠近第一个可见字符的空白字符，然后删除往前的空格
RemoveStringCommand rsc = new RemoveStringCommand(
mCodeManager,
new URank(pos.Row, visibleStartCol - UConfig.TabNumberOfSpace),
UConfig.TabNumberOfSpace);
mCodeManager.Execute(rsc);
mCodeRenderer.SetCursorPos(
new URank(
pos.Row,
mCodeManager.GetCodeLength(pos.Row) - 1));
}
}
}
public void SetCursorPos(URank pos)
{
mCursor = pos;
FixCursorPosition(true);
}
public void SetCursorPos(URank pos)
{
mCodeRenderer.SetCursorPos(pos);
}
private void InsertRangeString(URank start, string str)
{
InsertRangeStringCommand irs = new InsertRangeStringCommand(mCodeManager, start, str);
mCodeManager.Execute(irs);
}
public RemoveCharacterCommand(UCodeManager codeManager, URank pos)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
this.mRemovedCharacter = 0;
}
public InsertStringCommand(UCodeManager codeManager, URank pos, string str)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
this.mInsertString = str;
}
public InsertCharacterCommand(UCodeManager codeManager, URank pos, byte ch)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
this.mInsertCharacter = ch;
}
public void SetStart(URank start)
{
this.Start = start;
}
public void SetEnd(URank end)
{
this.End = end;
}
public InsertNewLineByteCommand(UCodeManager codeManager, URank pos)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
}
public RemoveNewlineByteCommand(UCodeManager codeManager, URank pos)
{
this.mCodeManager = codeManager;
this.mPosition = pos;
}
