internal void AddDiff(RenderTreeDiff diff)
{
var componentId = diff.ComponentId;
if (!DiffsByComponentId.ContainsKey(componentId))
{
DiffsByComponentId.Add(componentId, new List <RenderTreeDiff>());
}
DiffsByComponentId[componentId].Add(diff);
}
internal void AddDiff(RenderTreeDiff diff)
{
var componentId = diff.ComponentId;
if (!DiffsByComponentId.ContainsKey(componentId))
{
DiffsByComponentId.Add(componentId, new List <RenderTreeDiff>());
}
// Clone the diff, because its underlying storage will get reused in subsequent batches
DiffsByComponentId[componentId].Add(new RenderTreeDiff(
diff.ComponentId,
new ArraySegment <RenderTreeEdit>(diff.Edits.ToArray())));
}
internal void AddDiff(RenderTreeDiff diff)
{
var componentId = diff.ComponentId;
if (!DiffsByComponentId.ContainsKey(componentId))
{
DiffsByComponentId.Add(componentId, new List <CapturedRenderTreeDiff>());
}
var renderTreeEdits = diff.Edits.ToArray();
var capturedTreeDiff = new CapturedRenderTreeDiff(diff.ComponentId, renderTreeEdits);
DiffsByComponentId[componentId].Add(capturedTreeDiff);
DiffsInOrder.Add(capturedTreeDiff);
}
public static RenderTreeDiff ComputeDiff(
Renderer renderer,
RenderBatchBuilder batchBuilder,
int componentId,
ArrayRange <RenderTreeFrame> oldTree,
ArrayRange <RenderTreeFrame> newTree)
{
var editsBuffer = batchBuilder.EditsBuffer;
var editsBufferStartLength = editsBuffer.Count;
var diffContext = new DiffContext(renderer, batchBuilder, componentId, oldTree.Array, newTree.Array);
AppendDiffEntriesForRange(ref diffContext, 0, oldTree.Count, 0, newTree.Count);
var editsSegment = editsBuffer.ToSegment(editsBufferStartLength, editsBuffer.Count);
var result = new RenderTreeDiff(componentId, editsSegment);
return(result);
}
internal void AddDiff(RenderTreeDiff diff)
{
var componentId = diff.ComponentId;
if (!DiffsByComponentId.ContainsKey(componentId))
{
DiffsByComponentId.Add(componentId, new List <RenderTreeDiff>());
}
// Clone the diff, because its underlying storage will get reused in subsequent batches
var cloneBuilder = new ArrayBuilder <RenderTreeEdit>();
cloneBuilder.Append(diff.Edits.ToArray(), 0, diff.Edits.Count);
var diffClone = new RenderTreeDiff(
diff.ComponentId,
cloneBuilder.ToSegment(0, diff.Edits.Count));
DiffsByComponentId[componentId].Add(diffClone);
DiffsInOrder.Add(diffClone);
}
private static ArrayRange <RenderTreeDiff> ReadUpdatedComponents(ReadOnlySpan <byte> data, ReadOnlySpan <byte> indexes, string[] strings)
{
var result = new RenderTreeDiff[indexes.Length / 4];
for (var i = 0; i < indexes.Length; i += 4)
{
var index = BitConverter.ToInt32(indexes.Slice(i, 4));
var componentId = BitConverter.ToInt32(data.Slice(index, 4));
var editCount = BitConverter.ToInt32(data.Slice(index + 4, 4));
var editData = data.Slice(index + 8);
var edits = new RenderTreeEdit[editCount];
for (var j = 0; j < editCount; j++)
{
var type = (RenderTreeEditType)BitConverter.ToInt32(editData.Slice(0, 4));
var siblingIndex = BitConverter.ToInt32(editData.Slice(4, 4));
// ReferenceFrameIndex and MoveToSiblingIndex share a slot, so this reads
// whichever one applies to the edit type
var referenceFrameIndex = BitConverter.ToInt32(editData.Slice(8, 4));
var removedAttributeName = ReadString(editData.Slice(12, 4), strings);
editData = editData.Slice(16);
switch (type)
{
case RenderTreeEditType.UpdateText:
edits[j] = RenderTreeEdit.UpdateText(siblingIndex, referenceFrameIndex);
break;
case RenderTreeEditType.UpdateMarkup:
edits[j] = RenderTreeEdit.UpdateMarkup(siblingIndex, referenceFrameIndex);
break;
case RenderTreeEditType.SetAttribute:
edits[j] = RenderTreeEdit.SetAttribute(siblingIndex, referenceFrameIndex);
break;
case RenderTreeEditType.RemoveAttribute:
edits[j] = RenderTreeEdit.RemoveAttribute(siblingIndex, removedAttributeName);
break;
case RenderTreeEditType.PrependFrame:
edits[j] = RenderTreeEdit.PrependFrame(siblingIndex, referenceFrameIndex);
break;
case RenderTreeEditType.RemoveFrame:
edits[j] = RenderTreeEdit.RemoveFrame(siblingIndex);
break;
case RenderTreeEditType.StepIn:
edits[j] = RenderTreeEdit.StepIn(siblingIndex);
break;
case RenderTreeEditType.StepOut:
edits[j] = RenderTreeEdit.StepOut();
break;
case RenderTreeEditType.PermutationListEntry:
edits[j] = RenderTreeEdit.PermutationListEntry(siblingIndex, referenceFrameIndex);
break;
case RenderTreeEditType.PermutationListEnd:
edits[j] = RenderTreeEdit.PermutationListEnd();
break;
default:
throw new InvalidOperationException("Unknown edit type:" + type);
}
}
result[i / 4] = new RenderTreeDiff(componentId, ToArrayBuilderSegment(edits));
}
return(new ArrayRange <RenderTreeDiff>(result, result.Length));
}
public void Apply(RenderTreeDiff tree, RenderBatch batch)
{
//List<int> removedIndex = new List<int>();
//List<View>
//List<StyleSheet> deferedStyleSheet = new List<StyleSheet>();
CurrentNode = InitialNode;
foreach (var edit in tree.Edits)
{
var frame = batch.ReferenceFrames.Array[edit.ReferenceFrameIndex];
ProcessTree(edit, batch, edit.ReferenceFrameIndex, edit.Type == RenderTreeEditType.PrependFrame ? (frame.ElementSubtreeLength == 0 ? 1 : frame.ElementSubtreeLength) :1);
//ProcessTree(edit, batch, edit.ReferenceFrameIndex, frame.ElementSubtreeLength == 0 ? 1 : frame.ElementSubtreeLength);
//int subtreeIndex = 0;
//do
//{
// switch (edit.Type)
// {
// case RenderTreeEditType.PrependFrame:
// {
// switch (frame.FrameType)
// {
// case RenderTreeFrameType.Component:
// {
// var childRenderer = new ComponentRenderer(frame.Component, WebViewRenderer, this);
// WebViewRenderer.Renderers[frame.ComponentId] = childRenderer;
// }
// break;
// case RenderTreeFrameType.Element:
// {
// WebViewRenderer.DOMManager.CreateElement(Sequences.ToArray(), frame.Sequence, frame.ElementName);
// Sequences.Push(frame.Sequence);
// }
// break;
// case RenderTreeFrameType.Attribute:
// {
// WebViewRenderer.DOMManager.SetAttribute(Sequences.ToArray(), frame.AttributeName, frame.AttributeValue);
// }
// break;
// case RenderTreeFrameType.Text:
// WebViewRenderer.DOMManager.InsertText(Sequences.ToArray(), frame.Sequence, frame.TextContent);
// break;
// case RenderTreeFrameType.Markup:
// WebViewRenderer.DOMManager.InsertMarkup(Sequences.ToArray(), frame.Sequence, frame.MarkupContent);
// break;
// case RenderTreeFrameType.Region:
// Sequences.Push(frame.Sequence);
// int sequenceSubTrees = frame.RegionSubtreeLength;
// break;
// default:
// throw new NotImplementedException($"Invalid Frame type: {frame.FrameType}");
// }
// }
// break;
// case RenderTreeEditType.UpdateText:
// {
// WebViewRenderer.DOMManager.InsertText(Sequences.ToArray(), frame.Sequence, frame.TextContent);
// }
// break;
// case RenderTreeEditType.RemoveFrame:
// {
// WebViewRenderer.DOMManager.RemoveAt(Sequences.ToArray(), edit.SiblingIndex);
// }
// break;
// case RenderTreeEditType.UpdateMarkup:
// {
// WebViewRenderer.DOMManager.InsertText(Sequences.ToArray(), frame.Sequence, frame.TextContent);
// }
// break;
// case RenderTreeEditType.SetAttribute:
// {
// WebViewRenderer.DOMManager.SetAttribute(Sequences.ToArray(), frame.AttributeName, frame.AttributeValue);
// }
// break;
// case RenderTreeEditType.RemoveAttribute:
// {
// WebViewRenderer.DOMManager.RemoveAttribute(Sequences.ToArray(), frame.AttributeName);
// }
// break;
// case RenderTreeEditType.StepIn:
// break;
// case RenderTreeEditType.StepOut:
// break;
// case RenderTreeEditType.PermutationListEntry:
// case RenderTreeEditType.PermutationListEnd:
// default:
// throw new NotImplementedException($"Invalid edit type: {edit.Type}");
// }
// subtreeIndex++;
// if (batch.ReferenceFrames.Array[edit.ReferenceFrameIndex].ElementSubtreeLength > subtreeIndex)
// continue;
// break;
//} while (true);
}
}
