public int GetPrevLength()
{
ITextItem previtem = item;
int count = 0;
if (previtem is ITextTrim)
{
string leftpart = LeftPart;
int enterid = leftpart.LastIndexOf('\n');
if (enterid >= 0)
{
return(leftpart.Length - enterid - 1);
}
}
count += itemindex;
while (previtem?.Parent != null)
{
ITextZone zone = previtem.Parent;
if (GetPrevLength(zone, previtem.ID - 1, ref count))
{
return(count);
}
previtem = previtem.Parent;
}
return(count);
}
public ITextPosition NextLine()
{
ITextItem nextitem = item;
if (nextitem is ITextTrim)
{
string rightpart = RightPart;
int enterid = rightpart.IndexOf('\n');
if (enterid >= 0)
{
return new TextPosition()
{
Item = nextitem, ItemIndex = this.itemindex + enterid + 1, Line = this.line + 1, Column = 1
}
}
;
}
while (nextitem?.Parent != null)
{
ITextZone zone = nextitem.Parent;
ITextPosition result = GetNextLine(zone, nextitem.ID + 1, line + 1);
if (result != null)
{
return(result);
}
nextitem = zone;
}
return(null);
}
public int GetByteSpaceCount()
{
ITextItem previtem = item;
int count = 0;
if (previtem is ITextTrim)
{
string leftpart = LeftPart;
int enterid = leftpart.LastIndexOf('\n');
if (enterid >= 0)
{
for (int i = enterid + 1; i < leftpart.Length; i++)
{
count += TextChar.GetByteSpaceCount(leftpart[i]);
}
return(count);
}
}
foreach (char ch in LeftPart)
{
count += TextChar.GetByteSpaceCount(ch);
}
while (previtem?.Parent != null)
{
ITextZone zone = previtem.Parent;
if (GetByteSpaceCount(zone, previtem.ID - 1, ref count))
{
return(count);
}
previtem = previtem.Parent;
}
return(count);
}
public int GetNextLength()
{
ITextItem nextitem = item;
int count = 0;
if (nextitem is ITextTrim)
{
string rightpart = RightPart;
int enterid = rightpart.IndexOf('\n');
if (enterid >= 0)
{
return(enterid);
}
}
count += item.ToString().Length - itemindex;
while (nextitem?.Parent != null)
{
ITextZone zone = nextitem.Parent;
if (GetNextLength(zone, nextitem.ID + 1, ref count))
{
return(count);
}
nextitem = nextitem.Parent;
}
return(count);
}
public ITextPosition PrevSeek()
{
if (itemindex > 0)
{
return(Clone());
}
ITextItem previtem = item;
while (previtem?.Parent != null && previtem.ID <= 0)
{
previtem = previtem.Parent;
}
if (previtem?.Parent == null)
{
return(Clone());
}
previtem = previtem.Parent.Items[previtem.ID - 1];
while (previtem is ITextZone)
{
ITextZone zone = (ITextZone)(previtem);
previtem = zone.Items.LastOrDefault();
}
return(new TextPosition()
{
Item = previtem, ItemIndex = previtem.ToString().Length, Line = this.line, Column = this.column
});
}
public void Replace(int start, int count, IEnumerable <ITextItem> _additems)
{
AncestorRelease();
items.RemoveRange(start, count);
items.InsertRange(start, _additems);
this.linecount = 1;
this.skipcount = isskip ? 1 : 0;
for (int i = 0; i < items.Count(); i++)
{
items[i].Parent = this;
items[i].ID = i;
items[i].Level = Level + 1;
if (items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)items[i];
linecount += trim.GetEnterCount();
}
if (items[i] is ITextZone)
{
ITextZone zone = (ITextZone)items[i];
linecount += zone.LineCount - 1;
skipcount += zone.SkipCount;
}
}
AncestorCapture();
}
public static ITextPosition GetPrevOffset(ITextZone zone, int start, ref int offset, ref int line, ref int column)
{
for (int i = start; i >= 0; i--)
{
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
ITextPosition result = GetPrevOffset(_zone, _zone.Items.Count - 1, ref offset, ref line, ref column);
if (result != null)
{
return(result);
}
}
else
{
string text = zone.Items[i].ToString();
if (offset < text.Length)
{
text = text.Substring(text.Length - offset);
}
RefPrevLineColumn(text, ref line, ref column);
offset -= text.Length;
if (offset <= 0)
{
return new TextPosition()
{
Item = zone.Items[i], ItemIndex = zone.Items[i].ToString().Length - text.Length, Line = line, Column = column
}
}
;
}
}
return(null);
}
public ITextPosition NextSeek()
{
if (itemindex < item.ToString().Length)
{
return(Clone());
}
ITextItem nextitem = item;
while (nextitem?.Parent != null && nextitem.ID + 1 >= nextitem.Parent.Items.Count)
{
nextitem = nextitem.Parent;
}
if (nextitem?.Parent == null)
{
return(Clone());
}
nextitem = nextitem.Parent.Items[nextitem.ID + 1];
while (nextitem is ITextZone)
{
ITextZone zone = (ITextZone)(nextitem);
nextitem = zone.Items.FirstOrDefault();
}
return(new TextPosition()
{
Item = nextitem, ItemIndex = 0, Line = this.line, Column = this.column
});
}
public static bool GetPrevLength(ITextZone zone, int start, ref int count)
{
for (int i = start; i >= 0; i--)
{
if (zone.Items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)(zone.Items[i]);
int enterid = trim.ToString().LastIndexOf('\n');
if (enterid >= 0)
{
count += trim.ToString().Length - enterid - 1; return(true);
}
}
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
if (GetPrevLength(_zone, _zone.Items.Count - 1, ref count))
{
return(true);
}
continue;
}
count += zone.Items[i].ToString().Length;
}
return(false);
}
public static bool GetByteSpaceCount(ITextZone zone, int start, ref int count)
{
for (int i = start; i >= 0; i--)
{
if (zone.Items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)(zone.Items[i]);
int enterid = trim.ToString().LastIndexOf('\n');
if (enterid >= 0)
{
string text = trim.ToString().Substring(enterid + 1);
foreach (char ch in text)
{
count += TextChar.GetByteSpaceCount(ch);
}
return(true);
}
}
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
if (GetByteSpaceCount(_zone, 0, ref count))
{
return(true);
}
continue;
}
foreach (char ch in zone.Items[i].ToString())
{
count += TextChar.GetByteSpaceCount(ch);
}
}
return(false);
}
public static bool GetNextLength(ITextZone zone, int start, ref int count)
{
for (int i = start; i < zone.Items.Count; i++)
{
if (zone.Items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)(zone.Items[i]);
int enterid = trim.ToString().IndexOf('\n');
if (enterid >= 0)
{
count += enterid; return(true);
}
}
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
if (GetNextLength(_zone, 0, ref count))
{
return(true);
}
continue;
}
count += zone.Items[i].ToString().Length;
}
return(false);
}
public static ITextPosition MovePrevLine(ITextZone zone, int start, ref int lineoffset, ref int line, ref int column)
{
for (int i = start; i >= 0; i--)
{
if (zone.Items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)(zone.Items[i]);
int previndex = RefPrevLine(trim.ToString(), ref lineoffset, ref line, ref column);
if (previndex >= 0)
{
return new TextPosition()
{
Item = trim, ItemIndex = previndex, Line = line, Column = column
}
}
;
}
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
if (_zone.LineCount <= lineoffset)
{
lineoffset -= _zone.LineCount - 1;
line -= _zone.LineCount - 1; column = -100000;
}
else
{
return(MovePrevLine(_zone, _zone.Items.Count - 1, ref lineoffset, ref line, ref column));
}
}
}
return(null);
}
public static ITextPosition MoveNextLine(ITextZone zone, int start, ref int lineoffset, ref int line, ref int column)
{
for (int i = start; i < zone.Items.Count; i++)
{
if (zone.Items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)(zone.Items[i]);
int nextindex = RefNextLine(trim.ToString(), ref lineoffset, ref line, ref column);
if (nextindex >= 0)
{
return new TextPosition()
{
Item = trim, ItemIndex = nextindex + 1, Line = line, Column = column
}
}
;
}
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
if (_zone.LineCount <= lineoffset)
{
lineoffset -= _zone.LineCount - 1;
line += _zone.LineCount - 1; column = -100000;
}
else
{
return(MoveNextLine(_zone, 0, ref lineoffset, ref line, ref column));
}
}
}
return(null);
}
public static ITextPosition GetPrevLine(ITextZone zone, int start, int line)
{
for (int i = start; i >= 0; i--)
{
if (zone.Items[i] is ITextTrim)
{
ITextTrim trim = (ITextTrim)(zone.Items[i]);
int enterid = trim.ToString().LastIndexOf('\n');
if (enterid >= 0)
{
return new TextPosition()
{
Item = trim, ItemIndex = enterid, Line = line, Column = -1
}
}
;
}
if (zone.Items[i] is ITextZone)
{
ITextZone _zone = (ITextZone)(zone.Items[i]);
ITextPosition result = GetPrevLine(_zone, _zone.Items.Count - 1, line);
if (result != null)
{
return(result);
}
}
}
return(null);
}
public ITextPosition PrevLine()
{
ITextItem previtem = item;
if (previtem is ITextTrim)
{
string leftpart = LeftPart;
int enterid = leftpart.LastIndexOf('\n');
if (enterid >= 0)
{
return new TextPosition()
{
Item = previtem, ItemIndex = enterid, Line = this.line - 1, Column = -1
}
}
;
}
while (previtem?.Parent != null)
{
ITextZone zone = previtem.Parent;
ITextPosition result = GetPrevLine(zone, previtem.ID - 1, line - 1);
if (result != null)
{
return(result);
}
previtem = zone;
}
return(null);
}
protected void RenderBracket(DrawingContext ctx, ITextPosition pos)
{
ITextItem item = pos.Item;
ITextZone zone = item.Parent;
if (!(item is ITextKey))
{
return;
}
ITextKey key = (ITextKey)item;
if ((key.KeyCore.Feature & (TextKeyFeatures.ZoneLeft | TextKeyFeatures.ZoneRight)) == TextKeyFeatures.None)
{
return;
}
Brush brush = null;
ViewParent.TextCore.DictBrush.TryGetValue("background_rawtext_bracket", out brush);
if (Core.ContainLine(pos.Line))
{
ITextPosition start = pos.LeftPart.Length > 0 ? pos.PrevItem() : pos;
ITextPosition end = pos.RightPart.Length > 0 ? pos.NextItem() : pos;
DrawTextRectangle(ctx, brush, null, start.Column - 1, end.Column - start.Column);
}
if (item.ID == 0)
{
ITextItem rightkey = zone.Items.LastOrDefault();
if (Core.ContainLine(pos.Line + zone.LineCount - 1))
{
ITextPosition rstart = new TextPosition()
{
Item = rightkey, ItemIndex = 0, Line = pos.Line + zone.LineCount - 1, Column = -1
};
ITextPosition rend = rstart?.NextItem();
if (rstart != null && rend != null)
{
DrawTextRectangle(ctx, brush, null, rstart, rend);
}
}
}
else
{
ITextItem leftkey = zone.Items.FirstOrDefault();
if (Core.ContainLine(pos.Line - zone.LineCount + 1))
{
ITextPosition lstart = new TextPosition()
{
Item = leftkey, ItemIndex = 0, Line = pos.Line - zone.LineCount + 1, Column = -1
};
ITextPosition lend = lstart?.NextItem();
if (lstart != null && lend != null)
{
DrawTextRectangle(ctx, brush, null, lstart, lend);
}
}
}
}
protected void AncestorRelease()
{
ITextZone _parent = Parent;
while (_parent != null)
{
_parent.LineCount -= linecount - 1;
_parent.SkipCount -= skipcount;
_parent = _parent.Parent;
}
}
public ITextPosition Next()
{
ITextItem nextitem = item;
char nextchar = default(char);
int nextindex = -1;
int nextline = line;
int nextcolumn = column + 1;
if (itemindex >= item.ToString().Length)
{
while (nextitem?.Parent != null && nextitem.ID + 1 >= nextitem.Parent.Items.Count)
{
nextitem = nextitem.Parent;
}
if (nextitem?.Parent == null)
{
return(null);
}
nextitem = nextitem.Parent.Items[nextitem.ID + 1];
while (nextitem is ITextZone)
{
ITextZone zone = (ITextZone)(nextitem);
nextitem = zone.Items.FirstOrDefault();
}
nextchar = nextitem.ToString()[0];
nextindex = 1;
}
else
{
nextchar = item.ToString()[itemindex];
nextindex = itemindex + 1;
}
if (nextchar == '\n')
{
nextline = line + 1;
nextcolumn = 1;
}
return(new TextPosition()
{
Item = nextitem, ItemIndex = nextindex, Line = nextline, Column = nextcolumn
});
}
public ITextPosition Prev()
{
ITextItem previtem = item;
char prevchar = default(char);
int previndex = itemindex - 1;
int prevline = line;
int prevcolumn = column - 1;
if (itemindex <= 0)
{
while (previtem?.Parent != null && previtem.ID <= 0)
{
previtem = previtem.Parent;
}
if (previtem?.Parent == null)
{
return(null);
}
previtem = previtem.Parent.Items[previtem.ID - 1];
while (previtem is ITextZone)
{
ITextZone zone = (ITextZone)(previtem);
previtem = zone.Items.LastOrDefault();
}
prevchar = previtem.ToString().LastOrDefault();
previndex = previtem.ToString().Length - 1;
}
else
{
prevchar = previtem.ToString()[itemindex - 1];
previndex = itemindex - 1;
}
if (prevchar == '\n')
{
prevline = line - 1;
prevcolumn = -1;
}
return(new TextPosition()
{
Item = previtem, ItemIndex = previndex, Line = prevline, Column = prevcolumn
});
}
public void Add(ITextItem item)
{
AncestorRelease();
item.Parent = this;
item.ID = items.Count();
item.Level = Level + 1;
items.Add(item);
if (item is ITextTrim)
{
ITextTrim trim = (ITextTrim)item;
linecount += trim.GetEnterCount();
}
if (item is ITextZone)
{
ITextZone zone = (ITextZone)item;
linecount += zone.LineCount - 1;
skipcount += zone.SkipCount;
}
AncestorCapture();
}
public ITextPosition NextItem()
{
ITextItem nextitem = item;
string nexttext = null;
int nextindex = itemindex;
int nextline = line;
int nextcolumn = column;
if (itemindex >= item.ToString().Length)
{
while (nextitem?.Parent != null && nextitem.ID + 1 >= nextitem.Parent.Items.Count)
{
nextitem = nextitem.Parent;
}
if (nextitem?.Parent == null)
{
return(null);
}
nextitem = nextitem.Parent.Items[nextitem.ID + 1];
while (nextitem is ITextZone)
{
ITextZone zone = (ITextZone)(nextitem);
nextitem = zone.Items.FirstOrDefault();
}
nexttext = nextitem.ToString();
nextindex = nexttext.Length;
}
else
{
nexttext = RightPart;
nextindex += nexttext.Length;
}
RefNextLineColumn(nexttext, ref nextline, ref nextcolumn);
return(new TextPosition()
{
Item = nextitem, ItemIndex = nextindex, Line = nextline, Column = nextcolumn
});
}
public ITextPosition PrevItem()
{
ITextItem previtem = item;
string prevtext = null;
int previndex = itemindex;
int prevline = line;
int prevcolumn = column;
if (itemindex <= 0)
{
while (previtem?.Parent != null && previtem.ID <= 0)
{
previtem = previtem.Parent;
}
if (previtem?.Parent == null)
{
return(null);
}
previtem = previtem.Parent.Items[previtem.ID - 1];
while (previtem is ITextZone)
{
ITextZone zone = (ITextZone)(previtem);
previtem = zone.Items.LastOrDefault();
}
prevtext = previtem.ToString();
previndex = 0;
}
else
{
prevtext = LeftPart;
previndex = 0;
}
RefPrevLineColumn(prevtext, ref prevline, ref prevcolumn);
return(new TextPosition()
{
Item = previtem, ItemIndex = previndex, Line = prevline, Column = prevcolumn
});
}
public void Remove(ITextItem item)
{
AncestorRelease();
for (int i = item.ID + 1; i < items.Count(); i++)
{
items[i].ID--;
}
items.Remove(item);
item.Parent = null;
item.ID = -1;
item.Level = -1;
if (item is ITextTrim)
{
ITextTrim trim = (ITextTrim)item;
linecount -= trim.GetEnterCount();
}
if (item is ITextZone)
{
ITextZone zone = (ITextZone)item;
linecount -= zone.LineCount - 1;
skipcount -= zone.SkipCount;
}
AncestorCapture();
}
public void Insert(int id, ITextItem item)
{
AncestorRelease();
item.Parent = this;
item.ID = id;
item.Level = Level + 1;
for (int i = id; i < items.Count(); i++)
{
items[i].ID++;
}
items.Insert(id, item);
if (item is ITextTrim)
{
ITextTrim trim = (ITextTrim)item;
linecount += trim.GetEnterCount();
}
if (item is ITextZone)
{
ITextZone zone = (ITextZone)item;
linecount += zone.LineCount - 1;
skipcount += zone.SkipCount;
}
AncestorCapture();
}
/// <summary> 一（文档）对多（实例） </summary>
/// <param name="textitem">实例文本</param>
/// <param name="docitem">文档元素</param>
/// <param name="nextindex">下一个文本元素的索引</param>
/// <returns>匹配结果</returns>
protected static MRADocMatchCollection _DocMatchGroup(ITextItem textitem, IDocsItem docitem, ref int nextindex)
{
bool textiszone = textitem is ITextZone;
bool dociszone = docitem is IDocsCollection;
if (textiszone)
{
return(null);
}
if (!dociszone)
{
return(null);
}
ITextZone textzone = textitem.Parent;
List <MRADocMatchItem> matchs = new List <MRADocMatchItem>();
if (docitem is IDocsGroup)
{
IDocsGroup docgroup = (IDocsGroup)docitem;
MRADocMatchCollection matchcolle = new MRADocMatchCollection(docgroup.Name, textzone);
int i = textitem.ID, j = 0;
for ( ; i < textzone.Items.Count && j < docgroup.Items.Count; i++)
{
ITextItem sub = textzone.Items[i];
if (sub is ITextTrim)
{
continue;
}
{
MRADocMatchItem match = _DocMatch(sub, docgroup.Items[j]);
if (match != null)
{
matchcolle.Items.Add(match); j++; continue;
}
}
if (docgroup.Items[j] is IDocsCollection)
{
int ni = i + 1;
MRADocMatchCollection match = _DocMatchGroup(sub, docgroup.Items[j], ref ni);
if (match != null)
{
matchcolle.Items.Add(match); j++; i = ni - 1; continue;
}
}
return(null);
}
if (matchcolle.Items.Count() != docgroup.Items.Count())
{
return(null);
}
nextindex = i;
return(matchcolle);
}
if (docitem is IDocsCycle)
{
IDocsCycle doccycle = (IDocsCycle)docitem;
MRADocMatchCollection matchcolle = new MRADocMatchCollection(doccycle.Name, textzone);
int i = textitem.ID, j = doccycle.IgnoreStart;
for (; i < textzone.Items.Count; i++)
{
ITextItem sub = textzone.Items[i];
if (sub is ITextTrim)
{
continue;
}
if (j == doccycle.Items.Count - doccycle.IgnoreEnd)
{
nextindex = i;
}
if (j >= doccycle.Items.Count)
{
j = 0;
}
{
MRADocMatchItem match = _DocMatch(sub, doccycle.Items[j]);
if (match != null)
{
matchcolle.Items.Add(match); j++; continue;
}
}
if (doccycle.Items[j] is IDocsCollection)
{
int ni = i + 1;
MRADocMatchCollection match = _DocMatchGroup(sub, doccycle.Items[j], ref ni);
if (match != null)
{
matchcolle.Items.Add(match); j++; i = ni - 1; continue;
}
}
return(null);
}
if (j == doccycle.Items.Count - doccycle.IgnoreEnd)
{
nextindex = i;
}
if (matchcolle.Items.Count < doccycle.Items.Count - doccycle.IgnoreStart - doccycle.IgnoreEnd)
{
return(null);
}
int count = matchcolle.Items.Count;
count -= doccycle.Items.Count - doccycle.IgnoreStart - doccycle.IgnoreEnd;
count -= count % doccycle.Items.Count;
count += doccycle.Items.Count - doccycle.IgnoreStart - doccycle.IgnoreEnd;
matchcolle.Items.RemoveRange(count, matchcolle.Items.Count() - count);
return(matchcolle);
}
return(null);
}
/// <summary> 构造函数 </summary>
/// <param name="_zone">当前正在编辑的区域</param>
/// <param name="_itemindex">正在编辑单词的第几个字符</param>
/// <param name="_wordindex">正在编辑当前区域的第几个单词</param>
public MRATextInputContext(ITextZone _zone, int _itemindex, int _wordindex)
{
this.zone = _zone;
this.itemindex = _itemindex;
this.wordindex = _wordindex;
}
/// <summary> 一（文档）对一（实例） </summary>
/// <param name="textitem">实例文本</param>
/// <param name="docitem">文档元素</param>
/// <returns>匹配结果</returns>
protected static MRADocMatchItem _DocMatch(ITextItem textitem, IDocsItem docitem)
{
// 实例是否具有区域性
bool textiszone = textitem is ITextZone;
// 文档是否具有区域性
bool dociszone = docitem is IDocsCollection;
// 单词一对一
if (!textiszone && !dociszone)
{
if (docitem is IDocsWord)
{
IDocsWord docword = (IDocsWord)docitem;
Match match = docword.Regex.Match(textitem.ToString());
if (match.Success)
{
return(new MRADocMatchWord(docword.Name, textitem));
}
return(null);
}
if (docitem is IDocsKeyWord)
{
IDocsKeyWord dockeyword = (IDocsKeyWord)docitem;
if (dockeyword.Key.Keyword.Equals(textitem.ToString()))
{
return(new MRADocMatchWord(dockeyword.Name, textitem));
}
return(null);
}
return(null);
}
// 实例区域性
if (textiszone)
{
ITextZone textzone = (ITextZone)textitem;
// 文档为单个区域块
if (docitem is IDocsZone)
{
IDocsZone doczone = (IDocsZone)docitem;
// 匹配左右括号
if (doczone.Left == null || doczone.Right == null)
{
return(null);
}
ITextItem textleft = textzone.Items.FirstOrDefault();
ITextItem textright = textzone.Items.LastOrDefault();
if (!(textleft is ITextKey))
{
return(null);
}
if (!(textright is ITextKey))
{
return(null);
}
ITextKey keyleft = (ITextKey)textleft;
ITextKey keyright = (ITextKey)textright;
if (keyleft.KeyCore != doczone.Left.Key)
{
return(null);
}
if (keyright.KeyCore != doczone.Right.Key)
{
return(null);
}
// 内部匹配
MRADocMatchCollection matchcolle = new MRADocMatchCollection(doczone.Name, textzone);
for (int i = 1, j = 0; i < textzone.Items.Count - 1; i++)
{
ITextItem sub = textzone.Items[i];
if (sub is ITextTrim)
{
continue;
}
// 内部一（文档）对一（实例）匹配
{
MRADocMatchItem match = _DocMatch(sub, doczone.Items[j]);
if (match != null)
{
matchcolle.Items.Add(match); j++; continue;
}
}
// 内部一（文档）对多（实例）匹配
if (doczone.Items[j] is IDocsCollection)
{
int ni = i + 1;
MRADocMatchCollection match = _DocMatchGroup(sub, doczone.Items[j], ref ni);
if (match != null)
{
matchcolle.Items.Add(match); j++; i = ni - 1; continue;
}
}
}
if (matchcolle.Items.Count() != doczone.Items.Count())
{
return(null);
}
return(matchcolle);
}
// 文档为单个区域行
if (docitem is IDocsLine)
{
IDocsLine docline = (IDocsLine)docitem;
if (docline.Left == null)
{
return(null);
}
ITextItem textleft = textzone.Items.FirstOrDefault();
if (!(textleft is ITextKey))
{
return(null);
}
ITextKey keyleft = (ITextKey)textleft;
if (keyleft.KeyCore != docline.Left.Key)
{
return(null);
}
MRADocMatchCollection matchcolle = new MRADocMatchCollection(docline.Name, textzone);
for (int i = 1, j = 0; i < textzone.Items.Count; i++)
{
ITextItem sub = textzone.Items[i];
if (sub is ITextTrim)
{
continue;
}
MRADocMatchItem match = _DocMatch(sub, docline.Items[j++]);
if (match == null)
{
return(null);
}
matchcolle.Items.Add(match);
}
if (matchcolle.Items.Count() != docline.Items.Count())
{
return(null);
}
return(matchcolle);
}
// 文档为序列组
if (docitem is IDocsGroup)
{
IDocsGroup docgroup = (IDocsGroup)docitem;
MRADocMatchCollection matchcolle = new MRADocMatchCollection(docgroup.Name, textzone);
for (int i = 0, j = 0; i < textzone.Items.Count; i++)
{
ITextItem sub = textzone.Items[i];
if (sub is ITextTrim)
{
continue;
}
{
MRADocMatchItem match = _DocMatch(sub, docgroup.Items[j]);
if (match != null)
{
matchcolle.Items.Add(match); j++; continue;
}
}
if (docgroup.Items[j] is IDocsCollection)
{
int ni = i + 1;
MRADocMatchCollection match = _DocMatchGroup(sub, docgroup.Items[j], ref ni);
if (match != null)
{
matchcolle.Items.Add(match); j++; i = ni - 1; continue;
}
}
return(null);
}
if (matchcolle.Items.Count() != docgroup.Items.Count())
{
return(null);
}
return(matchcolle);
}
// 文档为循环组
if (docitem is IDocsCycle)
{
IDocsCycle doccycle = (IDocsCycle)docitem;
MRADocMatchCollection matchcolle = new MRADocMatchCollection(doccycle.Name, textzone);
int i = 0, j = doccycle.IgnoreStart;
for (; i < textzone.Items.Count; i++)
{
ITextItem sub = textzone.Items[i];
if (sub is ITextTrim)
{
continue;
}
if (j >= doccycle.Items.Count)
{
j = 0;
}
{
MRADocMatchItem match = _DocMatch(sub, doccycle.Items[j]);
if (match != null)
{
matchcolle.Items.Add(match); j++; continue;
}
}
if (doccycle.Items[j] is IDocsCollection)
{
int ni = i + 1;
MRADocMatchCollection match = _DocMatchGroup(sub, doccycle.Items[j], ref ni);
if (match != null)
{
matchcolle.Items.Add(match); j++; i = ni - 1; continue;
}
}
return(null);
}
if (j != doccycle.Items.Count - doccycle.IgnoreEnd)
{
return(null);
}
return(matchcolle);
}
return(null);
}
return(null);
}
public MRAZoneSkipInfo(ITextBoxCore _core, int _id, int _linestart, int _lineend, ITextZone _skipzone)
{
this.core = _core;
this.id = _id;
this.linestart = _linestart;
this.lineend = _lineend;
this.skipzone = _skipzone;
this.openzonefocus = false;
this.closezonefocus = false;
this.intozonefocus = false;
}
protected void InvalidateText()
{
if (Core == null || Core.IsDisposed)
{
return;
}
ITextZone zonebackground = null;
ITextZone zoneforeground = null;
ITextZone zonefontweight = null;
ITextZone zonefontfamily = null;
ITextZone zonefontstyle = null;
ITextZone zonefontstretch = null;
ITextZone zonefontsize = null;
ITextItem item = Core.Start.Item;
textbuilder.Clear();
fontindics.Clear();
this.skipzone = null;
this.skipzonestart = -1;
this.openzone = null;
this.closezone = null;
this.intozone = null;
void _FindAllZone(ITextItem startitem)
{
for (ITextZone zone = startitem.Parent; zone != null; zone = zone.Parent)
{
if (!(zone.Doc is IDocsFill))
{
continue;
}
IDocsFill doc = (IDocsFill)(zone.Doc);
if (doc.Fill == null)
{
continue;
}
if (zonebackground == null && doc.Fill.Background != null)
{
zonebackground = zone;
}
if (zoneforeground == null && doc.Fill.Foreground != null)
{
zoneforeground = zone;
}
if (zonefontweight == null && doc.Fill.FontWeight != null)
{
zonefontweight = zone;
}
if (zonefontfamily == null && doc.Fill.FontFamily != null)
{
zonefontfamily = zone;
}
if (zonefontstyle == null && doc.Fill.FontStyle != null)
{
zonefontstyle = zone;
}
if (zonefontstretch == null && doc.Fill.FontStretch != null)
{
zonefontstretch = zone;
}
if (zonefontsize == null && doc.Fill.FontSize != null)
{
zonefontsize = zone;
}
if (zonebackground == null)
{
continue;
}
if (zoneforeground == null)
{
continue;
}
if (zonefontweight == null)
{
continue;
}
if (zonefontfamily == null)
{
continue;
}
if (zonefontstyle == null)
{
continue;
}
if (zonefontsize == null)
{
continue;
}
if (zonefontstretch == null)
{
continue;
}
break;
}
}
void _RefindAllZone(ITextItem startitem)
{
zonebackground = null;
zoneforeground = null;
zonefontweight = null;
zonefontfamily = null;
zonefontstyle = null;
zonefontsize = null;
zonefontstretch = null;
_FindAllZone(startitem);
}
void _AppendText(ITextItem additem, string addtext)
{
FontFamily fontfamily = TextCore.FontFamily;
FontStyle fontstyle = TextCore.FontStyle;
FontStretch fontstretch = TextCore.FontStretch;
FontWeight fontweight = TextCore.FontWeight;
double fontsize = TextCore.FontSize;
Brush background = null;
Brush foreground = TextCore.Foreground;
if (additem.Doc is IDocsFill)
{
IDocsFill doc = (IDocsFill)(additem.Doc);
if (doc.Fill != null)
{
if (doc.Fill.FontFamily != null)
{
fontfamily = doc.Fill.FontFamily;
}
if (doc.Fill.FontStyle != null)
{
fontstyle = doc.Fill.FontStyle.Value;
}
if (doc.Fill.FontWeight != null)
{
fontweight = doc.Fill.FontWeight.Value;
}
if (doc.Fill.FontStretch != null)
{
fontstretch = doc.Fill.FontStretch.Value;
}
if (doc.Fill.FontSize != null)
{
fontsize = doc.Fill.FontSize.Value;
}
if (doc.Fill.Background != null)
{
background = new SolidColorBrush(doc.Fill.Background.Value);
}
if (doc.Fill.Foreground != null)
{
foreground = new SolidColorBrush(doc.Fill.Foreground.Value);
}
}
}
if (zonefontfamily?.Doc is IDocsFill)
{
fontfamily = ((IDocsFill)(zonefontfamily.Doc)).Fill.FontFamily;
}
if (zonefontstyle?.Doc is IDocsFill)
{
fontstyle = ((IDocsFill)(zonefontstyle.Doc)).Fill.FontStyle.Value;
}
if (zonefontweight?.Doc is IDocsFill)
{
fontweight = ((IDocsFill)(zonefontweight.Doc)).Fill.FontWeight.Value;
}
if (zonefontstretch?.Doc is IDocsFill)
{
fontstretch = ((IDocsFill)(zonefontstretch.Doc)).Fill.FontStretch.Value;
}
if (zonefontsize?.Doc is IDocsFill)
{
fontsize = ((IDocsFill)(zonefontsize.Doc)).Fill.FontSize.Value;
}
if (zonebackground?.Doc is IDocsFill)
{
background = new SolidColorBrush(((IDocsFill)(zonebackground.Doc)).Fill.Background.Value);
}
if (zoneforeground?.Doc is IDocsFill)
{
foreground = new SolidColorBrush(((IDocsFill)(zoneforeground.Doc)).Fill.Foreground.Value);
}
fontindics.Add(new TextFontIndex(new TextFontCore(fontstyle, fontstretch, fontfamily, fontweight, fontsize, background, foreground), textbuilder.Length));
textbuilder.Append(addtext);
}
void _AppendSkipZone(ITextZone skipzone)
{
FontFamily fontfamily = TextCore.FontFamily;
FontStyle fontstyle = TextCore.FontStyle;
FontStretch fontstretch = TextCore.FontStretch;
FontWeight fontweight = TextCore.FontWeight;
double fontsize = TextCore.FontSize;
Brush background = null;
Brush foreground = Brushes.Gray;
TextCore.DictBrush.TryGetValue("foreground_skipzone", out foreground);
skipzonestart = textbuilder.Length;
skipzonecount = 3;
fontindics.Add(new TextFontIndex(new TextFontCore(fontstyle, fontstretch, fontfamily, fontweight, fontsize, background, foreground), textbuilder.Length));
int showstart = 0;
int showend = 0;
if (TextCore.View.Counselor != null)
{
string zonename = skipzone?.Doc?.Name ?? "{zone_deault}";
MRATextInputContext ictx = new MRATextInputContext(skipzone, 0, 0);
MRAZoneContext zctx = new MRAZoneContext(zonename, ictx, MRAZoneAction.Skip);
IMRAZoneResult zret = TextCore.View.Counselor.ZoneAction(zctx);
if (zret is IMRAZoneSkipResult)
{
IMRAZoneSkipResult zsret = (IMRAZoneSkipResult)zret;
showstart = zsret.ShowStart;
showend = zsret.ShowEnd;
}
}
for (int i = 0; i < Math.Min(showstart, skipzone.Items.Count); i++)
{
textbuilder.Append(skipzone.Items[i].ToString());
}
textbuilder.Append("...");
for (int i = Math.Max(0, skipzone.Items.Count - showend); i < skipzone.Items.Count; i++)
{
textbuilder.Append(skipzone.Items[i].ToString());
}
}
void _RemoveZone(ITextItem zone)
{
if (item == zonebackground)
{
zonebackground = null;
}
if (item == zoneforeground)
{
zoneforeground = null;
}
if (item == zonefontweight)
{
zonefontweight = null;
}
if (item == zonefontfamily)
{
zonefontfamily = null;
}
if (item == zonefontstyle)
{
zonefontstyle = null;
}
if (item == zonefontstretch)
{
zonefontstretch = null;
}
if (item == zonefontsize)
{
zonefontstretch = null;
}
}
void _AddZone(ITextZone zone)
{
if (zone.Doc is IDocsFill)
{
IDocsFill doc = (IDocsFill)(zone.Doc);
if (doc.Fill != null)
{
if (doc.Fill.Background != null)
{
zonebackground = zone;
}
if (doc.Fill.Foreground != null)
{
zoneforeground = zone;
}
if (doc.Fill.FontWeight != null)
{
zonefontweight = zone;
}
if (doc.Fill.FontFamily != null)
{
zonefontfamily = zone;
}
if (doc.Fill.FontStyle != null)
{
zonefontstyle = zone;
}
if (doc.Fill.FontStretch != null)
{
zonefontstretch = zone;
}
if (doc.Fill.FontSize != null)
{
zonefontsize = zone;
}
}
}
}
_FindAllZone(item);
if (Core.Start != null && Core.End != null)
{
ITextItem startitem = Core.Start.Item;
ITextItem enditem = Core.End.Item;
startitem = startitem.Parent;
enditem = enditem.Parent;
while (startitem.Level > enditem.Level)
{
startitem = startitem.Parent;
}
while (startitem.Level < enditem.Level)
{
enditem = enditem.Parent;
}
while (startitem != enditem)
{
startitem = startitem.Parent; enditem = enditem.Parent;
}
while (startitem?.Parent != null)
{
if (!(startitem is ITextLine) && ((ITextZone)startitem).LineCount > 1)
{
this.intozone = (ITextZone)startitem;
break;
}
startitem = startitem.Parent;
}
}
{
ITextItem startitem = Core.Start.Item;
ITextItem enditem = Core.End.Item;
if (startitem.ID == 0 &&
!(startitem.Parent is ITextLine) && !(startitem.Parent is ITextBoxCore) && startitem.Parent.LineCount > 1)
{
this.openzone = startitem.Parent;
}
if (enditem.ID == enditem.Parent.Items.Count - 1 &&
!(enditem.Parent is ITextLine) && !(enditem.Parent is ITextBoxCore) && enditem.Parent.LineCount > 1)
{
this.closezone = enditem.Parent;
}
}
if (Core.Start.Item == Core.End.Item)
{
string text = Core.Start.RightPart.Substring(0, Core.End.ItemIndex - Core.Start.ItemIndex);
_AppendText(Core.Start.Item, text);
}
else if (Core is IMRAZoneSkipInfo)
{
IMRAZoneSkipInfo zscore = (IMRAZoneSkipInfo)Core;
this.skipzone = zscore.SkipZone;
if (Core.Start.Item.Parent != zscore.SkipZone)
{
_AppendText(Core.Start.Item, Core.Start.RightPart);
while (item != null && item != Core.End.Item)
{
while (item?.Parent != null && item.ID + 1 >= item.Parent.Items.Count)
{
item = item.Parent;
ITextZone zone = (ITextZone)item;
if (!(zone is ITextLine) && zone.LineCount > 1)
{
this.closezone = zone;
}
_RemoveZone(item);
}
if (item?.Parent == null)
{
break;
}
item = item.Parent.Items[item.ID + 1];
_FindAllZone(item);
while (item is ITextZone)
{
ITextZone zone = (ITextZone)item;
if (zone == zscore.SkipZone)
{
break;
}
_AddZone(zone);
item = zone.Items.FirstOrDefault();
}
if (item == zscore.SkipZone)
{
break;
}
_AppendText(item, item.ToString());
}
}
_AppendSkipZone(zscore.SkipZone);
if (Core.End.Item.Parent != zscore.SkipZone)
{
item = zscore.SkipZone;
_RefindAllZone(item);
while (item != null && item != Core.End.Item)
{
while (item?.Parent != null && item.ID + 1 >= item.Parent.Items.Count)
{
item = item.Parent;
_RemoveZone(item);
}
if (item?.Parent == null)
{
break;
}
item = item.Parent.Items[item.ID + 1];
_FindAllZone(item);
while (item is ITextZone)
{
ITextZone zone = (ITextZone)item;
if (!(zone is ITextLine) && zone.LineCount > 1)
{
this.openzone = zone;
}
_AddZone(zone);
item = zone.Items.FirstOrDefault();
}
_AppendText(item, item.ToString());
}
_AppendText(Core.End.Item, Core.End.LeftPart);
}
}
else
{
_AppendText(Core.Start.Item, Core.Start.RightPart);
while (item != null && item != Core.End.Item)
{
while (item?.Parent != null && item.ID + 1 >= item.Parent.Items.Count)
{
item = item.Parent;
ITextZone zone = (ITextZone)item;
if (!(zone is ITextLine) && zone.LineCount > 1)
{
this.closezone = zone;
if (intozone == null || zone.Level < intozone.Level)
{
this.intozone = zone;
}
}
_RemoveZone(item);
}
if (item?.Parent == null)
{
break;
}
item = item.Parent.Items[item.ID + 1];
_FindAllZone(item);
while (item is ITextZone)
{
ITextZone zone = (ITextZone)item;
if (!(zone is ITextLine) && zone.LineCount > 1)
{
this.openzone = zone;
if (intozone == null || zone.Level < intozone.Level)
{
this.intozone = zone;
}
}
_AddZone(zone);
item = zone.Items.FirstOrDefault();
}
if (item == Core.End.Item)
{
break;
}
_AppendText(item, item.ToString());
}
_AppendText(Core.End.Item, Core.End.LeftPart);
}
this.textsource = new MRATextSource(textbuilder.ToString(), fontindics);
this.textline = textfmtr.FormatLine(textsource, 0, 10000.0, new MRATextParagraphProperties(TextCore, textsource), null);
}
public ITextPosition MoveLine(int lineoffset)
{
if (lineoffset == 0)
{
return(Clone());
}
if (lineoffset > 0)
{
ITextItem nextitem = item;
int nextline = line;
int nextcolumn = column;
string rightpart = RightPart;
int nextindex = RefNextLine(rightpart, ref lineoffset, ref nextline, ref nextcolumn);
if (nextindex >= 0)
{
return new TextPosition()
{
Item = nextitem, ItemIndex = itemindex + nextindex + 1, Line = nextline, Column = nextcolumn
}
}
;
while (nextitem?.Parent != null)
{
ITextZone zone = nextitem.Parent;
ITextPosition result = MoveNextLine(zone, nextitem.ID + 1, ref lineoffset, ref nextline, ref nextcolumn);
if (result != null)
{
return(result);
}
nextitem = zone;
}
}
else
{
lineoffset = -lineoffset;
ITextItem previtem = item;
int prevline = line;
int prevcolumn = column;
string leftpart = LeftPart;
int previndex = RefPrevLine(leftpart, ref lineoffset, ref prevline, ref prevcolumn);
if (previndex >= 0)
{
return new TextPosition()
{
Item = previtem, ItemIndex = previndex, Line = prevline, Column = prevcolumn
}
}
;
while (previtem?.Parent != null)
{
ITextZone zone = previtem.Parent;
ITextPosition result = MovePrevLine(zone, previtem.ID - 1, ref lineoffset, ref prevline, ref prevcolumn);
if (result == null)
{
return(result);
}
previtem = zone;
}
}
return(null);
}
