-
-
Notifications
You must be signed in to change notification settings - Fork 0
/
DeleteLeft.cs
102 lines (98 loc) · 4.87 KB
/
DeleteLeft.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
using MathKeyboardEngine._Helpers;
namespace MathKeyboardEngine;
public static class _DeleteLeft
{
public static void DeleteLeft(this KeyboardMemory k)
{
if (k.Current is Placeholder)
{
var current = (Placeholder)k.Current;
if (current.ParentNode == null || current.Nodes.Count > 0)
{
return;
}
else
{
var nonEmptyPlaceholderOnLeft = current.ParentNode.Placeholders.GetFirstNonEmptyOnLeftOf(current);
if (nonEmptyPlaceholderOnLeft != null)
{
if (current.ParentNode.Placeholders.Count == 2 && current == current.ParentNode.Placeholders[1] && current.Nodes.Count == 0)
{
nonEmptyPlaceholderOnLeft.DeleteOuterBranchingNodeButNotItsContents();
k.Current = nonEmptyPlaceholderOnLeft.Nodes.Last();
}
else
{
nonEmptyPlaceholderOnLeft.Nodes.RemoveAt(nonEmptyPlaceholderOnLeft.Nodes.Count - 1);
k.Current = nonEmptyPlaceholderOnLeft.Nodes.LastOrDefault() ?? (SyntaxTreeComponent)nonEmptyPlaceholderOnLeft;
}
}
else if (current.ParentNode.Placeholders.All(x => x.Nodes.Count == 0))
{
var ancestorPlaceholder = current.ParentNode.ParentPlaceholder;
var previousNode = ancestorPlaceholder.Nodes.FirstBeforeOrDefault(current.ParentNode);
ancestorPlaceholder.Nodes.Remove(current.ParentNode);
k.Current = previousNode ?? (SyntaxTreeComponent)ancestorPlaceholder;
}
else if (current.ParentNode.Placeholders[0] == current && current.Nodes.Count == 0 && current.ParentNode.Placeholders.Any(x => x.Nodes.Count > 0))
{
var previousNode = current.ParentNode!.ParentPlaceholder.Nodes.FirstBeforeOrDefault(current.ParentNode);
if (previousNode != null)
{
EncapsulatePreviousInto(previousNode, current);
k.Current = current.Nodes.Last();
}
else
{
var nonEmptySiblingPlaceholders = current.ParentNode.Placeholders.Where(x => x.Nodes.Count != 0).ToArray();
if (nonEmptySiblingPlaceholders.Length == 1)
{
var nodes = nonEmptySiblingPlaceholders[0].Nodes;
var ancestorPlaceholder = current.ParentNode.ParentPlaceholder;
var indexOfParentNode = ancestorPlaceholder.Nodes.IndexOf(current.ParentNode);
foreach (var node in nodes)
{
node.ParentPlaceholder = ancestorPlaceholder;
}
ancestorPlaceholder.Nodes.RemoveAt(indexOfParentNode);
ancestorPlaceholder.Nodes.InsertRange(indexOfParentNode, nodes);
k.Current = nodes.Last();
}
}
}
}
}
else
{
var current = ((TreeNode)k.Current);
if (current is BranchingNode b && b.Placeholders[0].Nodes.Count > 0 && b.Placeholders.Skip(1).All(x => x.Nodes.Count == 0))
{
var nonEmptyPlaceholder = b.Placeholders[0];
nonEmptyPlaceholder.DeleteOuterBranchingNodeButNotItsContents();
k.Current = nonEmptyPlaceholder.Nodes.Last();
}
else if (current is BranchingNode b2 && b2.Placeholders.Any(x => x.Nodes.Count > 0))
{
k.Current = b2.Placeholders.SelectMany(x => x.Nodes).Last();
k.DeleteLeft();
}
else
{
var previousNode = current.ParentPlaceholder.Nodes.FirstBeforeOrDefault(current);
current.ParentPlaceholder.Nodes.Remove(current);
k.Current = previousNode ?? (SyntaxTreeComponent)current.ParentPlaceholder;
}
}
}
public static void EncapsulatePreviousInto(TreeNode previousNode, Placeholder targetPlaceholder)
{
targetPlaceholder.ParentNode!.ParentPlaceholder.Nodes.Remove(previousNode);
targetPlaceholder.Nodes.Add(previousNode);
var previousNodeOldParentPlaceholder = previousNode.ParentPlaceholder;
previousNode.ParentPlaceholder = targetPlaceholder;
if (previousNode is PartOfNumberWithDigits)
{
targetPlaceholder.EncapsulateAllPartsOfNumberWithDigitsLeftOfIndex(previousNodeOldParentPlaceholder.Nodes.Count - 1, previousNodeOldParentPlaceholder.Nodes);
}
}
}