aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Logging/Views/TimelineView.xaml
blob: 664f2489c02a6cd0f0e9600f98047d504f9657ec (plain)
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
<UserControl x:Class="Tango.MachineStudio.Logging.Views.TimelineView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:converters="clr-namespace:Tango.SharedUI.Converters;assembly=Tango.SharedUI"
             xmlns:global="clr-namespace:Tango.MachineStudio.Logging"
             xmlns:localConverters="clr-namespace:Tango.MachineStudio.Logging.Converters"
             xmlns:entities="clr-namespace:Tango.BL.Entities;assembly=Tango.BL"
             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
             xmlns:vm="clr-namespace:Tango.MachineStudio.Logging.ViewModels"
             xmlns:localControls="clr-namespace:Tango.MachineStudio.Logging.Controls"
             xmlns:local="clr-namespace:Tango.MachineStudio.Logging.Views"
             mc:Ignorable="d" 
             d:DesignHeight="1080" d:DesignWidth="1920" Background="White" d:DataContext="{d:DesignInstance Type=vm:TimelineViewVM, IsDesignTimeCreatable=False}" MouseWheel="UserControl_MouseWheel">

    <UserControl.Resources>
        <localConverters:TimeSpanToXConverter x:Key="TimeSpanToXConverter" />
        <localConverters:MachineEventToXConverter x:Key="MachineEventToXConverter" />
        <localConverters:SecondsToWidthConverter x:Key="SecondsToWidthConverter" />
        <converters:BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
        <localConverters:StringToFirstLineConverter x:Key="StringToFirstLineConverter" />

        <LinearGradientBrush x:Key="infoBrush" StartPoint="0.5,0" EndPoint="0.5,1">
            <GradientStop Color="White"/>
            <GradientStop Color="#FFBFBFBF" Offset="1"/>
        </LinearGradientBrush>

        <LinearGradientBrush x:Key="warningBrush" StartPoint="0.5,0" EndPoint="0.5,1">
            <GradientStop Color="#FFFF8C57"/>
            <GradientStop Color="White" Offset="1"/>
        </LinearGradientBrush>

        <LinearGradientBrush x:Key="errorBrush" StartPoint="0.5,0" EndPoint="0.5,1">
            <GradientStop Color="#FFFF6A6A"/>
            <GradientStop Color="#FFD9D9" Offset="1"/>
        </LinearGradientBrush>

        <LinearGradientBrush x:Key="criticalBrush" StartPoint="0.5,0" EndPoint="0.5,1">
            <GradientStop Color="Red"/>
            <GradientStop Color="White" Offset="1"/>
        </LinearGradientBrush>

        <LinearGradientBrush x:Key="hoverBrush" StartPoint="0.5,0" EndPoint="0.5,1">
            <GradientStop Color="#9D9D9D"/>
            <GradientStop Color="#F9F9F9" Offset="1"/>
        </LinearGradientBrush>
    </UserControl.Resources>

    <Grid>
        <Grid>
            <Grid Grid.Row="1">
                <Grid.RowDefinitions>
                    <RowDefinition Height="30"/>
                    <RowDefinition Height="1*"/>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="300"/>
                    <ColumnDefinition Width="1*"/>
                </Grid.ColumnDefinitions>

                <Grid Grid.Column="1" ClipToBounds="True">
                    <localControls:TimeRuler HorizontalAlignment="Left" FontSize="14" HorizontalOffset="{Binding ElementName=scrollViewer,Path=HorizontalOffset}" Background="White" BorderBrush="{StaticResource AccentColorBrush}" BorderThickness="1" Foreground="{StaticResource AccentColorBrush}" Height="30" x:Name="ruler" Width="{Binding RelativeSource={RelativeSource AncestorType=Grid},Path=ActualWidth}" RenderWidth="{Binding RelativeSource={RelativeSource AncestorType=Grid},Path=ActualWidth}" Zoom="{Binding TimelineScaleFactor}"></localControls:TimeRuler>
                </Grid>

                <Grid Background="White">

                </Grid>

                <ScrollViewer x:Name="scroll_channels" Grid.Column="0" Grid.Row="1" HorizontalScrollBarVisibility="Hidden" VerticalScrollBarVisibility="Hidden">
                    <ItemsControl ItemsSource="{Binding TimelineEventGroups}" Margin="0 0 0 0" Background="#FCFCFC"  VerticalAlignment="Top">
                        <ItemsControl.ItemsPanel>
                            <ItemsPanelTemplate>
                                <StackPanel />
                            </ItemsPanelTemplate>
                        </ItemsControl.ItemsPanel>
                        <ItemsControl.ItemTemplate>
                            <DataTemplate DataType="{x:Type vm:TimelineEventGroup}">
                                <Border BorderThickness="1 0.5 1 0.5" BorderBrush="{StaticResource AccentColorBrush}" Margin="2 0 0 0" Padding="5" Height="{Binding Height,Mode=OneWay}">
                                    <TextBlock Text="{Binding Name}" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="22" TextWrapping="Wrap" TextAlignment="Center" FontWeight="SemiBold" Foreground="{StaticResource AccentColorBrush}"></TextBlock>
                                </Border>
                            </DataTemplate>
                        </ItemsControl.ItemTemplate>
                    </ItemsControl>
                </ScrollViewer>

                <localControls:TimelineScrollViewer x:Name="scrollViewer" Grid.Column="1" Grid.Row="1" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto" ScrollChanged="scrollViewer_ScrollChanged">
                    <Grid HorizontalAlignment="Left">
                        <ItemsControl ItemsSource="{Binding TimelineEventGroups}" HorizontalAlignment="Left" MinWidth="{Binding RelativeSource={RelativeSource AncestorType=localControls:TimelineScrollViewer},Path=ActualWidth}">
                            <ItemsControl.Width>
                                <MultiBinding Converter="{StaticResource TimeSpanToXConverter}" ConverterParameter="300">
                                    <Binding Path="TimelineMaxTime" />
                                    <Binding Path="TimelineScaleFactor" />
                                </MultiBinding>
                            </ItemsControl.Width>
                            <ItemsControl.ItemsPanel>
                                <ItemsPanelTemplate>
                                    <UniformGrid Columns="1" />
                                </ItemsPanelTemplate>
                            </ItemsControl.ItemsPanel>
                            <ItemsControl.ItemTemplate>
                                <DataTemplate DataType="{x:Type vm:TimelineEventGroup}">
                                    <Border BorderThickness="0 0 0 1" BorderBrush="#98DEFF" Margin="0 0 0 0">
                                        <ItemsControl ItemsSource="{Binding Events}" SizeChanged="ItemsControl_SizeChanged">
                                            <ItemsControl.ItemsPanel>
                                                <ItemsPanelTemplate>
                                                    <StackPanel IsItemsHost="True"></StackPanel>
                                                </ItemsPanelTemplate>
                                            </ItemsControl.ItemsPanel>
                                            <ItemsControl.ItemTemplate>
                                                <DataTemplate DataType="{x:Type entities:MachinesEvent}">
                                                    <Canvas Margin="0 0 0 0" MinHeight="20">
                                                        <Grid Height="{Binding RelativeSource={RelativeSource AncestorType=Canvas},Path=ActualHeight}">
                                                            <Canvas.Left>
                                                                <MultiBinding Converter="{StaticResource MachineEventToXConverter}">
                                                                    <Binding Path="." />
                                                                    <Binding RelativeSource="{RelativeSource AncestorType=UserControl}" Path="DataContext.TimelineEventGroups" />
                                                                    <Binding RelativeSource="{RelativeSource AncestorType=UserControl}" Path="DataContext.TimelineScaleFactor" />
                                                                </MultiBinding>
                                                            </Canvas.Left>
                                                            <Border BorderBrush="#4E4E4E" BorderThickness="1" Padding="2" MinWidth="50" Cursor="Hand">
                                                                <i:Interaction.Triggers>
                                                                    <i:EventTrigger EventName="PreviewMouseUp">
                                                                        <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource AncestorType=UserControl},Path=DataContext.EventSelectedCommand}" CommandParameter="{Binding}" />
                                                                    </i:EventTrigger>
                                                                </i:Interaction.Triggers>
                                                                <Border.Style>
                                                                    <Style TargetType="Border">
                                                                        <Style.Triggers>
                                                                            <DataTrigger Binding="{Binding Category}" Value="Info">
                                                                                <Setter Property="Background" Value="{StaticResource infoBrush}"></Setter>
                                                                            </DataTrigger>
                                                                            <DataTrigger Binding="{Binding Category}" Value="Warning">
                                                                                <Setter Property="Background" Value="{StaticResource warningBrush}"></Setter>
                                                                            </DataTrigger>
                                                                            <DataTrigger Binding="{Binding Category}" Value="Error">
                                                                                <Setter Property="Background" Value="{StaticResource errorBrush}"></Setter>
                                                                            </DataTrigger>
                                                                            <DataTrigger Binding="{Binding Category}" Value="Crtitical">
                                                                                <Setter Property="Background" Value="{StaticResource criticalBrush}"></Setter>
                                                                            </DataTrigger>
                                                                            <Trigger Property="IsMouseOver" Value="True">
                                                                                <Setter Property="Opacity" Value="0.7"></Setter>
                                                                            </Trigger>
                                                                        </Style.Triggers>
                                                                    </Style>
                                                                </Border.Style>
                                                                <StackPanel Orientation="Horizontal">
                                                                    <TextBlock FontWeight="SemiBold" Text="{Binding EventType.Name}" Height="14" FontSize="11"></TextBlock>
                                                                    <TextBlock Margin="10 0 0 0" Text="{Binding Description,Converter={StaticResource StringToFirstLineConverter}}" Height="14" FontSize="11"></TextBlock>
                                                                </StackPanel>
                                                            </Border>
                                                        </Grid>
                                                    </Canvas>
                                                </DataTemplate>
                                            </ItemsControl.ItemTemplate>
                                        </ItemsControl>
                                    </Border>
                                </DataTemplate>
                            </ItemsControl.ItemTemplate>
                        </ItemsControl>

                        <Canvas Visibility="{Binding EnableTimeMarker,Converter={StaticResource BooleanToVisibilityConverter}}" MinWidth="{Binding RelativeSource={RelativeSource AncestorType=localControls:TimelineScrollViewer},Path=ActualWidth}" ClipToBounds="False" IsHitTestVisible="False">
                            <Grid Height="{Binding RelativeSource={RelativeSource AncestorType=Canvas},Path=ActualHeight}" ClipToBounds="False">
                                <Canvas.Left>
                                    <MultiBinding Converter="{StaticResource TimeSpanToXConverter}">
                                        <Binding Path="CurrentPosition" />
                                        <Binding Path="TimelineScaleFactor" />
                                    </MultiBinding>
                                </Canvas.Left>

                                <Rectangle Stroke="DodgerBlue" StrokeThickness="1" HorizontalAlignment="Left" VerticalAlignment="Stretch" />
                                <Polygon Fill="DodgerBlue" Points="0,0 16,0 8,15 0,0" Margin="-8 -5 0 0" VerticalAlignment="Top" />
                            </Grid>
                        </Canvas>
                    </Grid>
                </localControls:TimelineScrollViewer>

                <Border Grid.Row="1" Grid.Column="1"  HorizontalAlignment="Right" VerticalAlignment="Bottom" Margin="20" Padding="10" Background="#7ECECECE" CornerRadius="5">
                    <Grid>
                        <materialDesign:PackIcon Kind="MagnifyPlus" Margin="0 -35 0 0" Width="20" Height="20" Foreground="Gray" />
                        <Slider Minimum="0.5" Maximum="100" Value="{Binding TimelineScaleFactor}" Orientation="Vertical" Height="120"/>
                    </Grid>
                </Border>
            </Grid>
        </Grid>
    </Grid>
</UserControl>
class="k">internal int length; // the height of this subtree: 0 for leaf nodes; 1+max(left.height,right.height) for concat nodes internal byte height; // The character data. Only non-null for leaf nodes (height=0) that aren't function nodes. internal T[] contents; internal int Balance { get { return right.height - left.height; } } [Conditional("DATACONSISTENCYTEST")] internal void CheckInvariants() { if (height == 0) { Debug.Assert(left == null && right == null); if (contents == null) { Debug.Assert(this is FunctionNode<T>); Debug.Assert(length > 0); Debug.Assert(isShared); } else { Debug.Assert(contents != null && contents.Length == NodeSize); Debug.Assert(length >= 0 && length <= NodeSize); } } else { Debug.Assert(left != null && right != null); Debug.Assert(contents == null); Debug.Assert(length == left.length + right.length); Debug.Assert(height == 1 + Math.Max(left.height, right.height)); Debug.Assert(Math.Abs(this.Balance) <= 1); // this is an additional invariant that forces the tree to combine small leafs to prevent excessive memory usage: Debug.Assert(length > NodeSize); // note that this invariant ensures that all nodes except for the empty rope's single node have at least length 1 if (isShared) Debug.Assert(left.isShared && right.isShared); left.CheckInvariants(); right.CheckInvariants(); } } internal RopeNode<T> Clone() { if (height == 0) { // If a function node needs cloning, we'll evaluate it. if (contents == null) return GetContentNode().Clone(); T[] newContents = new T[NodeSize]; contents.CopyTo(newContents, 0); return new RopeNode<T> { length = this.length, contents = newContents }; } else { return new RopeNode<T> { left = this.left, right = this.right, length = this.length, height = this.height }; } } internal RopeNode<T> CloneIfShared() { if (isShared) return Clone(); else return this; } internal void Publish() { if (!isShared) { if (left != null) left.Publish(); if (right != null) right.Publish(); // it's important that isShared=true is set at the end: // Publish() must not return until the whole subtree is marked as shared, even when // Publish() is called concurrently. isShared = true; } } internal static RopeNode<T> CreateFromArray(T[] arr, int index, int length) { if (length == 0) { return emptyRopeNode; } RopeNode<T> node = CreateNodes(length); return node.StoreElements(0, arr, index, length); } internal static RopeNode<T> CreateNodes(int totalLength) { int leafCount = (totalLength + NodeSize - 1) / NodeSize; return CreateNodes(leafCount, totalLength); } static RopeNode<T> CreateNodes(int leafCount, int totalLength) { Debug.Assert(leafCount > 0); Debug.Assert(totalLength > 0); RopeNode<T> result = new RopeNode<T>(); result.length = totalLength; if (leafCount == 1) { result.contents = new T[NodeSize]; } else { int rightSide = leafCount / 2; int leftSide = leafCount - rightSide; int leftLength = leftSide * NodeSize; result.left = CreateNodes(leftSide, leftLength); result.right = CreateNodes(rightSide, totalLength - leftLength); result.height = (byte)(1 + Math.Max(result.left.height, result.right.height)); } return result; } /// <summary> /// Balances this node and recomputes the 'height' field. /// This method assumes that the children of this node are already balanced and have an up-to-date 'height' value. /// </summary> internal void Rebalance() { // Rebalance() shouldn't be called on shared nodes - it's only called after modifications! Debug.Assert(!isShared); // leaf nodes are always balanced (we don't use 'height' to detect leaf nodes here // because Balance is supposed to recompute the height). if (left == null) return; // ensure we didn't miss a MergeIfPossible step Debug.Assert(this.length > NodeSize); // We need to loop until it's balanced. Rotations might cause two small leaves to combine to a larger one, // which changes the height and might mean we need additional balancing steps. while (Math.Abs(this.Balance) > 1) { // AVL balancing // note: because we don't care about the identity of concat nodes, this works a little different than usual // tree rotations: in our implementation, the "this" node will stay at the top, only its children are rearranged if (this.Balance > 1) { if (right.Balance < 0) { right = right.CloneIfShared(); right.RotateRight(); } this.RotateLeft(); // If 'this' was unbalanced by more than 2, we've shifted some of the inbalance to the left node; so rebalance that. this.left.Rebalance(); } else if (this.Balance < -1) { if (left.Balance > 0) { left = left.CloneIfShared(); left.RotateLeft(); } this.RotateRight(); // If 'this' was unbalanced by more than 2, we've shifted some of the inbalance to the right node; so rebalance that. this.right.Rebalance(); } } Debug.Assert(Math.Abs(this.Balance) <= 1); this.height = (byte)(1 + Math.Max(left.height, right.height)); } void RotateLeft() { Debug.Assert(!isShared); /* Rotate tree to the left * * this this * / \ / \ * A right ===> left C * / \ / \ * B C A B */ RopeNode<T> a = left; RopeNode<T> b = right.left; RopeNode<T> c = right.right; // reuse right concat node, if possible this.left = right.isShared ? new RopeNode<T>() : right; this.left.left = a; this.left.right = b; this.left.length = a.length + b.length; this.left.height = (byte)(1 + Math.Max(a.height, b.height)); this.right = c; this.left.MergeIfPossible(); } void RotateRight() { Debug.Assert(!isShared); /* Rotate tree to the right * * this this * / \ / \ * left C ===> A right * / \ / \ * A B B C */ RopeNode<T> a = left.left; RopeNode<T> b = left.right; RopeNode<T> c = right; // reuse left concat node, if possible this.right = left.isShared ? new RopeNode<T>() : left; this.right.left = b; this.right.right = c; this.right.length = b.length + c.length; this.right.height = (byte)(1 + Math.Max(b.height, c.height)); this.left = a; this.right.MergeIfPossible(); } void MergeIfPossible() { Debug.Assert(!isShared); if (this.length <= NodeSize) { // Convert this concat node to leaf node. // We know left and right cannot be concat nodes (they would have merged already), // but they could be function nodes. this.height = 0; int lengthOnLeftSide = this.left.length; if (this.left.isShared) { this.contents = new T[NodeSize]; left.CopyTo(0, this.contents, 0, lengthOnLeftSide); } else { // must be a leaf node: function nodes are always marked shared Debug.Assert(this.left.contents != null); // steal buffer from left side this.contents = this.left.contents; #if DEBUG // In debug builds, explicitly mark left node as 'damaged' - but no one else should be using it // because it's not shared. this.left.contents = Empty<T>.Array; #endif } this.left = null; right.CopyTo(0, this.contents, lengthOnLeftSide, this.right.length); this.right = null; } } /// <summary> /// Copies from the array to this node. /// </summary> internal RopeNode<T> StoreElements(int index, T[] array, int arrayIndex, int count) { RopeNode<T> result = this.CloneIfShared(); // result cannot be function node after a call to Clone() if (result.height == 0) { // leaf node: Array.Copy(array, arrayIndex, result.contents, index, count); } else { // concat node: if (index + count <= result.left.length) { result.left = result.left.StoreElements(index, array, arrayIndex, count); } else if (index >= this.left.length) { result.right = result.right.StoreElements(index - result.left.length, array, arrayIndex, count); } else { int amountInLeft = result.left.length - index; result.left = result.left.StoreElements(index, array, arrayIndex, amountInLeft); result.right = result.right.StoreElements(0, array, arrayIndex + amountInLeft, count - amountInLeft); } result.Rebalance(); // tree layout might have changed if function nodes were replaced with their content } return result; } /// <summary> /// Copies from this node to the array. /// </summary> internal void CopyTo(int index, T[] array, int arrayIndex, int count) { if (height == 0) { if (this.contents == null) { // function node this.GetContentNode().CopyTo(index, array, arrayIndex, count); } else { // leaf node Array.Copy(this.contents, index, array, arrayIndex, count); } } else { // concat node if (index + count <= this.left.length) { this.left.CopyTo(index, array, arrayIndex, count); } else if (index >= this.left.length) { this.right.CopyTo(index - this.left.length, array, arrayIndex, count); } else { int amountInLeft = this.left.length - index; this.left.CopyTo(index, array, arrayIndex, amountInLeft); this.right.CopyTo(0, array, arrayIndex + amountInLeft, count - amountInLeft); } } } internal RopeNode<T> SetElement(int offset, T value) { RopeNode<T> result = CloneIfShared(); // result of CloneIfShared() is leaf or concat node if (result.height == 0) { result.contents[offset] = value; } else { if (offset < result.left.length) { result.left = result.left.SetElement(offset, value); } else { result.right = result.right.SetElement(offset - result.left.length, value); } result.Rebalance(); // tree layout might have changed if function nodes were replaced with their content } return result; } internal static RopeNode<T> Concat(RopeNode<T> left, RopeNode<T> right) { if (left.length == 0) return right; if (right.length == 0) return left; if (left.length + right.length <= NodeSize) { left = left.CloneIfShared(); // left is guaranteed to be leaf node after cloning: // - it cannot be function node (due to clone) // - it cannot be concat node (too short) right.CopyTo(0, left.contents, left.length, right.length); left.length += right.length; return left; } else { RopeNode<T> concatNode = new RopeNode<T>(); concatNode.left = left; concatNode.right = right; concatNode.length = left.length + right.length; concatNode.Rebalance(); return concatNode; } } /// <summary> /// Splits this leaf node at offset and returns a new node with the part of the text after offset. /// </summary> RopeNode<T> SplitAfter(int offset) { Debug.Assert(!isShared && height == 0 && contents != null); RopeNode<T> newPart = new RopeNode<T>(); newPart.contents = new T[NodeSize]; newPart.length = this.length - offset; Array.Copy(this.contents, offset, newPart.contents, 0, newPart.length); this.length = offset; return newPart; } internal RopeNode<T> Insert(int offset, RopeNode<T> newElements) { if (offset == 0) { return Concat(newElements, this); } else if (offset == this.length) { return Concat(this, newElements); } // first clone this node (converts function nodes to leaf or concat nodes) RopeNode<T> result = CloneIfShared(); if (result.height == 0) { // leaf node: we'll need to split this node RopeNode<T> left = result; RopeNode<T> right = left.SplitAfter(offset); return Concat(Concat(left, newElements), right); } else { // concat node if (offset < result.left.length) { result.left = result.left.Insert(offset, newElements); } else { result.right = result.right.Insert(offset - result.left.length, newElements); } result.length += newElements.length; result.Rebalance(); return result; } } internal RopeNode<T> Insert(int offset, T[] array, int arrayIndex, int count) { Debug.Assert(count > 0); if (this.length + count < RopeNode<char>.NodeSize) { RopeNode<T> result = CloneIfShared(); // result must be leaf node (Clone never returns function nodes, too short for concat node) int lengthAfterOffset = result.length - offset; T[] resultContents = result.contents; for (int i = lengthAfterOffset; i >= 0; i--) { resultContents[i + offset + count] = resultContents[i + offset]; } Array.Copy(array, arrayIndex, resultContents, offset, count); result.length += count; return result; } else if (height == 0) { // TODO: implement this more efficiently? return Insert(offset, CreateFromArray(array, arrayIndex, count)); } else { // this is a concat node (both leafs and function nodes are handled by the case above) RopeNode<T> result = CloneIfShared(); if (offset < result.left.length) { result.left = result.left.Insert(offset, array, arrayIndex, count); } else { result.right = result.right.Insert(offset - result.left.length, array, arrayIndex, count); } result.length += count; result.Rebalance(); return result; } } internal RopeNode<T> RemoveRange(int index, int count) { Debug.Assert(count > 0); // produce empty node when one node is deleted completely if (index == 0 && count == this.length) return emptyRopeNode; int endIndex = index + count; RopeNode<T> result = CloneIfShared(); // convert function node to concat/leaf if (result.height == 0) { int remainingAfterEnd = result.length - endIndex; for (int i = 0; i < remainingAfterEnd; i++) { result.contents[index + i] = result.contents[endIndex + i]; } result.length -= count; } else { if (endIndex <= result.left.length) { // deletion is only within the left part result.left = result.left.RemoveRange(index, count); } else if (index >= result.left.length) { // deletion is only within the right part result.right = result.right.RemoveRange(index - result.left.length, count); } else { // deletion overlaps both parts int deletionAmountOnLeftSide = result.left.length - index; result.left = result.left.RemoveRange(index, deletionAmountOnLeftSide); result.right = result.right.RemoveRange(0, count - deletionAmountOnLeftSide); } // The deletion might have introduced empty nodes. Those must be removed. if (result.left.length == 0) return result.right; if (result.right.length == 0) return result.left; result.length -= count; result.MergeIfPossible(); result.Rebalance(); } return result; } #region Debug Output #if DEBUG internal virtual void AppendTreeToString(StringBuilder b, int indent) { b.AppendLine(ToString()); indent += 2; if (left != null) { b.Append(' ', indent); b.Append("L: "); left.AppendTreeToString(b, indent); } if (right != null) { b.Append(' ', indent); b.Append("R: "); right.AppendTreeToString(b, indent); } } public override string ToString() { if (contents != null) { char[] charContents = contents as char[]; if (charContents != null) return "[Leaf length=" + length + ", isShared=" + isShared + ", text=\"" + new string(charContents, 0, length) + "\"]"; else return "[Leaf length=" + length + ", isShared=" + isShared + "\"]"; } else { return "[Concat length=" + length + ", isShared=" + isShared + ", height=" + height + ", Balance=" + this.Balance + "]"; } } internal string GetTreeAsString() { StringBuilder b = new StringBuilder(); AppendTreeToString(b, 0); return b.ToString(); } #endif #endregion /// <summary> /// Gets the root node of the subtree from a lazily evaluated function node. /// Such nodes are always marked as shared. /// GetContentNode() will return either a Concat or Leaf node, never another FunctionNode. /// </summary> internal virtual RopeNode<T> GetContentNode() { throw new InvalidOperationException("Called GetContentNode() on non-FunctionNode."); } } sealed class FunctionNode<T> : RopeNode<T> { Func<Rope<T>> initializer; RopeNode<T> cachedResults; public FunctionNode(int length, Func<Rope<T>> initializer) { Debug.Assert(length > 0); Debug.Assert(initializer != null); this.length = length; this.initializer = initializer; // Function nodes are immediately shared, but cannot be cloned. // This ensures we evaluate every initializer only once. this.isShared = true; } internal override RopeNode<T> GetContentNode() { lock (this) { if (this.cachedResults == null) { if (this.initializer == null) throw new InvalidOperationException("Trying to load this node recursively; or: a previous call to a rope initializer failed."); Func<Rope<T>> initializerCopy = this.initializer; this.initializer = null; Rope<T> resultRope = initializerCopy(); if (resultRope == null) throw new InvalidOperationException("Rope initializer returned null."); RopeNode<T> resultNode = resultRope.root; resultNode.Publish(); // result is shared between returned rope and the rope containing this function node if (resultNode.length != this.length) throw new InvalidOperationException("Rope initializer returned rope with incorrect length."); if (resultNode.height == 0 && resultNode.contents == null) { // ResultNode is another function node. // We want to guarantee that GetContentNode() never returns function nodes, so we have to // go down further in the tree. this.cachedResults = resultNode.GetContentNode(); } else { this.cachedResults = resultNode; } } return this.cachedResults; } } #if DEBUG internal override void AppendTreeToString(StringBuilder b, int indent) { RopeNode<T> resultNode; lock (this) { b.AppendLine(ToString()); resultNode = cachedResults; } indent += 2; if (resultNode != null) { b.Append(' ', indent); b.Append("C: "); resultNode.AppendTreeToString(b, indent); } } public override string ToString() { return "[FunctionNode length=" + length + " initializerRan=" + (initializer == null) + "]"; } #endif } }