aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Synchronization/Views/DirectSynchronizationView.xaml
blob: 39c21e3f5b2adc79cb813ff25f03f396b6fbc63f (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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
<UserControl x:Class="Tango.MachineStudio.Synchronization.Views.DirectSynchronizationView"
             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:mahapps="http://metro.mahapps.com/winfx/xaml/controls"
             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
             xmlns:fa="http://schemas.fontawesome.io/icons/"
             xmlns:synchronization="clr-namespace:Tango.Synchronization;assembly=Tango.Synchronization"
             xmlns:providers="clr-namespace:Tango.MachineStudio.Synchronization.AutoComplete"
             xmlns:autoComplete="clr-namespace:Tango.AutoComplete.Editors;assembly=Tango.AutoComplete"
             xmlns:global="clr-namespace:Tango.MachineStudio.Synchronization"
             xmlns:converters="clr-namespace:Tango.SharedUI.Converters;assembly=Tango.SharedUI"
             xmlns:local="clr-namespace:Tango.MachineStudio.Synchronization.Views"
             mc:Ignorable="d" 
             d:DesignHeight="720" d:DesignWidth="1280" DataContext="{x:Static global:ViewModelLocator.DirectSynchronizationViewVM}">

    <UserControl.Resources>
        <converters:BooleanToVisibilityInverseConverter x:Key="BooleanToVisibilityInverseConverter"></converters:BooleanToVisibilityInverseConverter>
        <converters:BooleanInverseConverter x:Key="BooleanInverseConverter"></converters:BooleanInverseConverter>

        <providers:MachinesProvider x:Key="MachinesProvider"></providers:MachinesProvider>

        <VisualBrush x:Key="badgeBackground">
            <VisualBrush.Visual>
                <Border>
                    <Path Stretch="Fill" RenderTransformOrigin="0.5,0.5">
                        <Path.RenderTransform>
                            <ScaleTransform ScaleX="-1"></ScaleTransform>
                        </Path.RenderTransform>
                        <Path.Fill>
                            <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
                                <GradientStop Color="#EEEEEE" Offset="0.4" />
                                <GradientStop Color="White" Offset="1"/>
                            </LinearGradientBrush>
                        </Path.Fill>
                        <Path.Data>
                            <PathGeometry Figures="M 53.868 43.913 H 19.511 c -0.444 0 -0.875 -0.151 -1.221 -0.428 L 0.734 29.439 c -0.978 -0.783 -0.978 -2.271 0 -3.053 L 18.29 12.341 c 0.347 -0.277 0.777 -0.428 1.221 -0.428 h 34.356 c 1.081 0 1.958 0.877 1.958 1.958 v 28.084 c 0 1.081 -0.876 1.958 -1.957 1.958 z" FillRule="NonZero"/>
                        </Path.Data>
                    </Path>
                </Border>
            </VisualBrush.Visual>
        </VisualBrush>
    </UserControl.Resources>

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="100" />
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <Grid>
            <StackPanel Orientation="Horizontal" Margin="20">
                <Button Style="{StaticResource MaterialDesignFlatButton}" Padding="0" Margin="0 5 0 0" VerticalAlignment="Center" Command="{Binding BackCommand}">
                    <materialDesign:PackIcon Kind="ArrowLeft" Foreground="#303030" ToolTip="Back" VerticalAlignment="Center" Width="40" Height="40"></materialDesign:PackIcon>
                </Button>
                <TextBlock VerticalAlignment="Center" Margin="10 0 0 0" FontSize="30">Direct Database Synchronization</TextBlock>
            </StackPanel>
        </Grid>

        <Grid Margin="20" Grid.Row="1">
            <GroupBox Header="Compare &amp; Synchronize">
                <Grid>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="57*"/>
                        <RowDefinition Height="Auto"/>
                    </Grid.RowDefinitions>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition MaxWidth="250" />
                        <ColumnDefinition/>
                    </Grid.ColumnDefinitions>

                    <Grid>
                        <Grid.RowDefinitions>
                            <RowDefinition Height="1*"/>
                            <RowDefinition Height="1*"/>
                        </Grid.RowDefinitions>

                        <StackPanel HorizontalAlignment="Left" VerticalAlignment="Center" Margin="20 0 0 0">
                            <Image Source="../Images/remote-db.png"  Width="100" Margin="10" Opacity="0.8" HorizontalAlignment="Left" RenderOptions.BitmapScalingMode="Fant"></Image>
                            <TextBlock Background="{StaticResource badgeBackground}" Padding="5" Width="200" FontSize="14" HorizontalAlignment="Left">Remote Database</TextBlock>
                            <StackPanel Orientation="Horizontal" Margin="0 5 0 0">
                                <fa:ImageAwesome Icon="Key" Width="16" Height="16"></fa:ImageAwesome>
                                <autoComplete:AutoCompleteTextBox Margin="5 0 0 0" IsEnabled="{Binding IsWorking,Converter={StaticResource BooleanInverseConverter}}" Width="170" materialDesign:HintAssist.Hint="Enter machine serial number" DisplayMember="SerialNumber" Provider="{StaticResource ResourceKey=MachinesProvider}" SelectedItem="{Binding SelectedMachine,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}">
                                    <autoComplete:AutoCompleteTextBox.ItemTemplate>
                                        <DataTemplate>
                                            <TextBlock Text="{Binding SerialNumber}"></TextBlock>
                                        </DataTemplate>
                                    </autoComplete:AutoCompleteTextBox.ItemTemplate>
                                    <autoComplete:AutoCompleteTextBox.LoadingContent>
                                        <TextBlock Text="Loading..." Margin="5" FontSize="14" />
                                    </autoComplete:AutoCompleteTextBox.LoadingContent>
                                </autoComplete:AutoCompleteTextBox>
                            </StackPanel>
                        </StackPanel>

                        <StackPanel Margin="20 0 0 0" VerticalAlignment="Center" HorizontalAlignment="Left" Grid.Row="1" >
                            <Image Source="../Images/machine-trans.png" RenderOptions.BitmapScalingMode="Fant" Width="110"></Image>
                            <TextBlock Margin="0 20 0 0">
                    <Run FontWeight="Bold">IP Address:</Run>
                    <Run Text="{Binding ApplicationManager.ConnectedMachine.IPAddress,Mode=OneWay}"></Run>
                            </TextBlock>
                            <TextBlock Margin="0 5 0 0">
                    <Run FontWeight="Bold">Serial Number:</Run>
                    <Run Text="{Binding ApplicationManager.ConnectedMachine.SerialNumber,Mode=OneWay}"></Run>
                            </TextBlock>
                            <TextBlock Margin="0 5 0 0">
                    <Run FontWeight="Bold">Organization:</Run>
                    <Run Text="{Binding ApplicationManager.ConnectedMachine.Organization,Mode=OneWay}"></Run>
                            </TextBlock>
                        </StackPanel>

                    </Grid>

                    <Button Margin="20 10" Grid.Row="1" Width="200" Height="40" HorizontalAlignment="Left" Command="{Binding CompareCommand}">
                        <StackPanel Orientation="Horizontal">
                            <TextBlock VerticalAlignment="Center" Margin="10 0 10 0">COMPARE</TextBlock>
                            <fa:ImageAwesome Icon="LongArrowRight" VerticalAlignment="Center" Foreground="{Binding RelativeSource={RelativeSource AncestorType=Button},Path=Foreground}" Width="16"></fa:ImageAwesome>
                        </StackPanel>
                    </Button>

                    <Grid Grid.Column="1">
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="625*"/>
                            <ColumnDefinition Width="347*"/>
                        </Grid.ColumnDefinitions>
                        <Grid.RowDefinitions>
                            <RowDefinition Height="20"/>
                            <RowDefinition Height="205*"/>
                        </Grid.RowDefinitions>
                        <TextBlock Margin="10 5 0 0" FontSize="14">Differences</TextBlock>
                        <ListBox Margin="10" Background="#F1F1F1" Grid.Row="1" ItemsSource="{Binding Differences}" SelectedItem="{Binding SelectedDifference,Mode=TwoWay}">
                            <ListBox.ItemTemplate>
                                <DataTemplate>
                                    <Border Padding="10">
                                        <StackPanel Orientation="Horizontal">
                                            <fa:ImageAwesome Icon="Cog" Width="20" Height="20" Foreground="Gray"></fa:ImageAwesome>
                                            <TextBlock VerticalAlignment="Center" Margin="10 0 0 0" Text="{Binding Description}">
                                                <TextBlock.Style>
                                                    <Style TargetType="TextBlock">
                                                        <Setter Property="Foreground" Value="Red"></Setter>
                                                        <Style.Triggers>
                                                            <DataTrigger Binding="{Binding Action}" Value="ReplaceTableDataInSlave">
                                                                <Setter Property="Foreground" Value="#404040"></Setter>
                                                            </DataTrigger>
                                                        </Style.Triggers>
                                                    </Style>
                                                </TextBlock.Style>
                                            </TextBlock>
                                        </StackPanel>
                                    </Border>
                                </DataTemplate>
                            </ListBox.ItemTemplate>
                        </ListBox>

                        <TextBlock Margin="10 0 0 0" VerticalAlignment="Bottom" Grid.Column="1">SQL Command</TextBlock>
                        <TextBox Grid.Column="1" Margin="10" Style="{x:Null}" BorderThickness="0" Foreground="Gray" FontSize="14" Text="{Binding SelectedDifference.Command,Mode=OneWay}" IsReadOnly="True" Background="#F1F1F1" Padding="5" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto" AcceptsReturn="True" Grid.Row="1"></TextBox>
                    </Grid>

                    <Grid Grid.Row="1" Grid.Column="1">
                        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right">
                            <StackPanel VerticalAlignment="Center" Orientation="Horizontal" Margin="0 0 20 0">
                                <TextBlock>Clear Machine Before Synchronization</TextBlock>
                                <ToggleButton Margin="10 0 0 0" IsChecked="{Binding IsClearMachine}" Foreground="Red" Style="{StaticResource MaterialDesignSwitchToggleButton}" ></ToggleButton>
                            </StackPanel>
                            <Button Margin="10 10" Grid.Row="1" Width="160" Height="40" HorizontalAlignment="Right" Command="{Binding CommitAllCommand}">
                                <StackPanel Orientation="Horizontal">
                                    <TextBlock VerticalAlignment="Center" Margin="10 0 10 0">SYNCHRONIZE</TextBlock>
                                    <fa:ImageAwesome Icon="SortAmountAsc" VerticalAlignment="Center" Foreground="{Binding RelativeSource={RelativeSource AncestorType=Button},Path=Foreground}" Width="16"></fa:ImageAwesome>
                                </StackPanel>
                            </Button>
                        </StackPanel>
                    </Grid>
                </Grid>
            </GroupBox>
        </Grid>

        <Grid Grid.Row="1" Visibility="{Binding ApplicationManager.IsMachineConnectedViaTCP,Converter={StaticResource BooleanToVisibilityInverseConverter}}">
            <Grid.Background>
                <SolidColorBrush Color="White" Opacity="0.8"></SolidColorBrush>
            </Grid.Background>

            <TextBlock Foreground="Silver" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="40">
                <TextBlock.Style>
                    <Style TargetType="TextBlock">
                        <Style.Triggers>
                            <EventTrigger RoutedEvent="Loaded">
                                <BeginStoryboard>
                                    <Storyboard>
                                        <DoubleAnimationUsingKeyFrames Storyboard.TargetProperty="Opacity" Duration="00:00:01" RepeatBehavior="Forever">
                                            <LinearDoubleKeyFrame Value="0" KeyTime="00:00:00"></LinearDoubleKeyFrame>
                                            <LinearDoubleKeyFrame Value="1" KeyTime="00:00:0.5"></LinearDoubleKeyFrame>
                                        </DoubleAnimationUsingKeyFrames>
                                    </Storyboard>
                                </BeginStoryboard>
                            </EventTrigger>
                        </Style.Triggers>
                    </Style>
                </TextBlock.Style>
                No Machine Connection
            </TextBlock>
        </Grid>
    </Grid>
</UserControl>
namespace Tango.Scripting.Editors.Document { using LineNode = DocumentLine; /// <summary> /// Data structure for efficient management of the document lines (most operations are O(lg n)). /// This implements an augmented red-black tree. /// See <see cref="LineNode"/> for the augmented data. /// /// NOTE: The tree is never empty, initially it contains an empty line. /// </summary> sealed class DocumentLineTree : IList<DocumentLine> { #region Constructor readonly TextDocument document; LineNode root; public DocumentLineTree(TextDocument document) { this.document = document; DocumentLine emptyLine = new DocumentLine(document); root = emptyLine.InitLineNode(); } #endregion #region Rotation callbacks internal static void UpdateAfterChildrenChange(LineNode node) { int totalCount = 1; int totalLength = node.TotalLength; if (node.left != null) { totalCount += node.left.nodeTotalCount; totalLength += node.left.nodeTotalLength; } if (node.right != null) { totalCount += node.right.nodeTotalCount; totalLength += node.right.nodeTotalLength; } if (totalCount != node.nodeTotalCount || totalLength != node.nodeTotalLength) { node.nodeTotalCount = totalCount; node.nodeTotalLength = totalLength; if (node.parent != null) UpdateAfterChildrenChange(node.parent); } } static void UpdateAfterRotateLeft(LineNode node) { UpdateAfterChildrenChange(node); // not required: rotations only happen on insertions/deletions // -> totalCount changes -> the parent is always updated //UpdateAfterChildrenChange(node.parent); } static void UpdateAfterRotateRight(LineNode node) { UpdateAfterChildrenChange(node); // not required: rotations only happen on insertions/deletions // -> totalCount changes -> the parent is always updated //UpdateAfterChildrenChange(node.parent); } #endregion #region RebuildDocument /// <summary> /// Rebuild the tree, in O(n). /// </summary> public void RebuildTree(List<DocumentLine> documentLines) { LineNode[] nodes = new LineNode[documentLines.Count]; for (int i = 0; i < documentLines.Count; i++) { DocumentLine ls = documentLines[i]; LineNode node = ls.InitLineNode(); nodes[i] = node; } Debug.Assert(nodes.Length > 0); // now build the corresponding balanced tree int height = GetTreeHeight(nodes.Length); Debug.WriteLine("DocumentLineTree will have height: " + height); root = BuildTree(nodes, 0, nodes.Length, height); root.color = BLACK; #if DEBUG CheckProperties(); #endif } internal static int GetTreeHeight(int size) { if (size == 0) return 0; else return GetTreeHeight(size / 2) + 1; } /// <summary> /// build a tree from a list of nodes /// </summary> LineNode BuildTree(LineNode[] nodes, int start, int end, int subtreeHeight) { Debug.Assert(start <= end); if (start == end) { return null; } int middle = (start + end) / 2; LineNode node = nodes[middle]; node.left = BuildTree(nodes, start, middle, subtreeHeight - 1); node.right = BuildTree(nodes, middle + 1, end, subtreeHeight - 1); if (node.left != null) node.left.parent = node; if (node.right != null) node.right.parent = node; if (subtreeHeight == 1) node.color = RED; UpdateAfterChildrenChange(node); return node; } #endregion #region GetNodeBy... / Get...FromNode LineNode GetNodeByIndex(int index) { Debug.Assert(index >= 0); Debug.Assert(index < root.nodeTotalCount); LineNode node = root; while (true) { if (node.left != null && index < node.left.nodeTotalCount) { node = node.left; } else { if (node.left != null) { index -= node.left.nodeTotalCount; } if (index == 0) return node; index--; node = node.right; } } } internal static int GetIndexFromNode(LineNode node) { int index = (node.left != null) ? node.left.nodeTotalCount : 0; while (node.parent != null) { if (node == node.parent.right) { if (node.parent.left != null) index += node.parent.left.nodeTotalCount; index++; } node = node.parent; } return index; } LineNode GetNodeByOffset(int offset) { Debug.Assert(offset >= 0); Debug.Assert(offset <= root.nodeTotalLength); if (offset == root.nodeTotalLength) { return root.RightMost; } LineNode node = root; while (true) { if (node.left != null && offset < node.left.nodeTotalLength) { node = node.left; } else { if (node.left != null) { offset -= node.left.nodeTotalLength; } offset -= node.TotalLength; if (offset < 0) return node; node = node.right; } } } internal static int GetOffsetFromNode(LineNode node) { int offset = (node.left != null) ? node.left.nodeTotalLength : 0; while (node.parent != null) { if (node == node.parent.right) { if (node.parent.left != null) offset += node.parent.left.nodeTotalLength; offset += node.parent.TotalLength; } node = node.parent; } return offset; } #endregion #region GetLineBy public DocumentLine GetByNumber(int number) { return GetNodeByIndex(number - 1); } public DocumentLine GetByOffset(int offset) { return GetNodeByOffset(offset); } #endregion #region LineCount public int LineCount { get { return root.nodeTotalCount; } } #endregion #region CheckProperties #if DEBUG [Conditional("DATACONSISTENCYTEST")] internal void CheckProperties() { Debug.Assert(root.nodeTotalLength == document.TextLength); CheckProperties(root); // check red-black property: int blackCount = -1; CheckNodeProperties(root, null, RED, 0, ref blackCount); } void CheckProperties(LineNode node) { int totalCount = 1; int totalLength = node.TotalLength; if (node.left != null) { CheckProperties(node.left); totalCount += node.left.nodeTotalCount; totalLength += node.left.nodeTotalLength; } if (node.right != null) { CheckProperties(node.right); totalCount += node.right.nodeTotalCount; totalLength += node.right.nodeTotalLength; } Debug.Assert(node.nodeTotalCount == totalCount); Debug.Assert(node.nodeTotalLength == totalLength); } /* 1. A node is either red or black. 2. The root is black. 3. All leaves are black. (The leaves are the NIL children.) 4. Both children of every red node are black. (So every red node must have a black parent.) 5. Every simple path from a node to a descendant leaf contains the same number of black nodes. (Not counting the leaf node.) */ void CheckNodeProperties(LineNode node, LineNode parentNode, bool parentColor, int blackCount, ref int expectedBlackCount) { if (node == null) return; Debug.Assert(node.parent == parentNode); if (parentColor == RED) { Debug.Assert(node.color == BLACK); } if (node.color == BLACK) { blackCount++; } if (node.left == null && node.right == null) { // node is a leaf node: if (expectedBlackCount == -1) expectedBlackCount = blackCount; else Debug.Assert(expectedBlackCount == blackCount); } CheckNodeProperties(node.left, node, node.color, blackCount, ref expectedBlackCount); CheckNodeProperties(node.right, node, node.color, blackCount, ref expectedBlackCount); } [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] public string GetTreeAsString() { StringBuilder b = new StringBuilder(); AppendTreeToString(root, b, 0); return b.ToString(); } static void AppendTreeToString(LineNode node, StringBuilder b, int indent) { if (node.color == RED) b.Append("RED "); else b.Append("BLACK "); b.AppendLine(node.ToString()); indent += 2; if (node.left != null) { b.Append(' ', indent); b.Append("L: "); AppendTreeToString(node.left, b, indent); } if (node.right != null) { b.Append(' ', indent); b.Append("R: "); AppendTreeToString(node.right, b, indent); } } #endif #endregion #region Insert/Remove lines public void RemoveLine(DocumentLine line) { RemoveNode(line); line.isDeleted = true; } public DocumentLine InsertLineAfter(DocumentLine line, int totalLength) { DocumentLine newLine = new DocumentLine(document); newLine.TotalLength = totalLength; InsertAfter(line, newLine); return newLine; } void InsertAfter(LineNode node, DocumentLine newLine) { LineNode newNode = newLine.InitLineNode(); if (node.right == null) { InsertAsRight(node, newNode); } else { InsertAsLeft(node.right.LeftMost, newNode); } } #endregion #region Red/Black Tree internal const bool RED = true; internal const bool BLACK = false; void InsertAsLeft(LineNode parentNode, LineNode newNode) { Debug.Assert(parentNode.left == null); parentNode.left = newNode; newNode.parent = parentNode; newNode.color = RED; UpdateAfterChildrenChange(parentNode); FixTreeOnInsert(newNode); } void InsertAsRight(LineNode parentNode, LineNode newNode) { Debug.Assert(parentNode.right == null); parentNode.right = newNode; newNode.parent = parentNode; newNode.color = RED; UpdateAfterChildrenChange(parentNode); FixTreeOnInsert(newNode); } void FixTreeOnInsert(LineNode node) { Debug.Assert(node != null); Debug.Assert(node.color == RED); Debug.Assert(node.left == null || node.left.color == BLACK); Debug.Assert(node.right == null || node.right.color == BLACK); LineNode parentNode = node.parent; if (parentNode == null) { // we inserted in the root -> the node must be black // since this is a root node, making the node black increments the number of black nodes // on all paths by one, so it is still the same for all paths. node.color = BLACK; return; } if (parentNode.color == BLACK) { // if the parent node where we inserted was black, our red node is placed correctly. // since we inserted a red node, the number of black nodes on each path is unchanged // -> the tree is still balanced return; } // parentNode is red, so there is a conflict here! // because the root is black, parentNode is not the root -> there is a grandparent node LineNode grandparentNode = parentNode.parent; LineNode uncleNode = Sibling(parentNode); if (uncleNode != null && uncleNode.color == RED) { parentNode.color = BLACK; uncleNode.color = BLACK; grandparentNode.color = RED; FixTreeOnInsert(grandparentNode); return; } // now we know: parent is red but uncle is black // First rotation: if (node == parentNode.right && parentNode == grandparentNode.left) { RotateLeft(parentNode); node = node.left; } else if (node == parentNode.left && parentNode == grandparentNode.right) { RotateRight(parentNode); node = node.right; } // because node might have changed, reassign variables: parentNode = node.parent; grandparentNode = parentNode.parent; // Now recolor a bit: parentNode.color = BLACK; grandparentNode.color = RED; // Second rotation: if (node == parentNode.left && parentNode == grandparentNode.left) { RotateRight(grandparentNode); } else { // because of the first rotation, this is guaranteed: Debug.Assert(node == parentNode.right && parentNode == grandparentNode.right); RotateLeft(grandparentNode); } } void RemoveNode(LineNode removedNode) { if (removedNode.left != null && removedNode.right != null) { // replace removedNode with it's in-order successor LineNode leftMost = removedNode.right.LeftMost; RemoveNode(leftMost); // remove leftMost from its current location // and overwrite the removedNode with it ReplaceNode(removedNode, leftMost); leftMost.left = removedNode.left; if (leftMost.left != null) leftMost.left.parent = leftMost; leftMost.right = removedNode.right; if (leftMost.right != null) leftMost.right.parent = leftMost; leftMost.color = removedNode.color; UpdateAfterChildrenChange(leftMost); if (leftMost.parent != null) UpdateAfterChildrenChange(leftMost.parent); return; } // now either removedNode.left or removedNode.right is null // get the remaining child LineNode parentNode = removedNode.parent; LineNode childNode = removedNode.left ?? removedNode.right; ReplaceNode(removedNode, childNode); if (parentNode != null) UpdateAfterChildrenChange(parentNode); if (removedNode.color == BLACK) { if (childNode != null && childNode.color == RED) { childNode.color = BLACK; } else { FixTreeOnDelete(childNode, parentNode); } } } void FixTreeOnDelete(LineNode node, LineNode parentNode) { Debug.Assert(node == null || node.parent == parentNode); if (parentNode == null) return; // warning: node may be null LineNode sibling = Sibling(node, parentNode); if (sibling.color == RED) { parentNode.color = RED; sibling.color = BLACK; if (node == parentNode.left) { RotateLeft(parentNode); } else { RotateRight(parentNode); } sibling = Sibling(node, parentNode); // update value of sibling after rotation } if (parentNode.color == BLACK && sibling.color == BLACK && GetColor(sibling.left) == BLACK && GetColor(sibling.right) == BLACK) { sibling.color = RED; FixTreeOnDelete(parentNode, parentNode.parent); return; } if (parentNode.color == RED && sibling.color == BLACK && GetColor(sibling.left) == BLACK && GetColor(sibling.right) == BLACK) { sibling.color = RED; parentNode.color = BLACK; return; } if (node == parentNode.left && sibling.color == BLACK && GetColor(sibling.left) == RED && GetColor(sibling.right) == BLACK) { sibling.color = RED; sibling.left.color = BLACK; RotateRight(sibling); } else if (node == parentNode.right && sibling.color == BLACK && GetColor(sibling.right) == RED && GetColor(sibling.left) == BLACK) { sibling.color = RED; sibling.right.color = BLACK; RotateLeft(sibling); } sibling = Sibling(node, parentNode); // update value of sibling after rotation sibling.color = parentNode.color; parentNode.color = BLACK; if (node == parentNode.left) { if (sibling.right != null) { Debug.Assert(sibling.right.color == RED); sibling.right.color = BLACK; } RotateLeft(parentNode); } else { if (sibling.left != null) { Debug.Assert(sibling.left.color == RED); sibling.left.color = BLACK; } RotateRight(parentNode); } } void ReplaceNode(LineNode replacedNode, LineNode newNode) { if (replacedNode.parent == null) { Debug.Assert(replacedNode == root); root = newNode; } else { if (replacedNode.parent.left == replacedNode) replacedNode.parent.left = newNode; else replacedNode.parent.right = newNode; } if (newNode != null) { newNode.parent = replacedNode.parent; } replacedNode.parent = null; } void RotateLeft(LineNode p) { // let q be p's right child LineNode q = p.right; Debug.Assert(q != null); Debug.Assert(q.parent == p); // set q to be the new root ReplaceNode(p, q); // set p's right child to be q's left child p.right = q.left; if (p.right != null) p.right.parent = p; // set q's left child to be p q.left = p; p.parent = q; UpdateAfterRotateLeft(p); } void RotateRight(LineNode p) { // let q be p's left child LineNode q = p.left; Debug.Assert(q != null); Debug.Assert(q.parent == p); // set q to be the new root ReplaceNode(p, q); // set p's left child to be q's right child p.left = q.right; if (p.left != null) p.left.parent = p; // set q's right child to be p q.right = p; p.parent = q; UpdateAfterRotateRight(p); } static LineNode Sibling(LineNode node) { if (node == node.parent.left) return node.parent.right; else return node.parent.left; } static LineNode Sibling(LineNode node, LineNode parentNode) { Debug.Assert(node == null || node.parent == parentNode); if (node == parentNode.left) return parentNode.right; else return parentNode.left; } static bool GetColor(LineNode node) { return node != null ? node.color : BLACK; } #endregion #region IList implementation DocumentLine IList<DocumentLine>.this[int index] { get { document.VerifyAccess(); return GetByNumber(1 + index); } set { throw new NotSupportedException(); } } int ICollection<DocumentLine>.Count { get { document.VerifyAccess(); return LineCount; } } bool ICollection<DocumentLine>.IsReadOnly { get { return true; } } int IList<DocumentLine>.IndexOf(DocumentLine item) { document.VerifyAccess(); if (item == null || item.IsDeleted) return -1; int index = item.LineNumber - 1; if (index < LineCount && GetNodeByIndex(index) == item) return index; else return -1; } void IList<DocumentLine>.Insert(int index, DocumentLine item) { throw new NotSupportedException(); } void IList<DocumentLine>.RemoveAt(int index) { throw new NotSupportedException(); } void ICollection<DocumentLine>.Add(DocumentLine item) { throw new NotSupportedException(); } void ICollection<DocumentLine>.Clear() { throw new NotSupportedException(); } bool ICollection<DocumentLine>.Contains(DocumentLine item) { IList<DocumentLine> self = this; return self.IndexOf(item) >= 0; } void ICollection<DocumentLine>.CopyTo(DocumentLine[] array, int arrayIndex) { if (array == null) throw new ArgumentNullException("array"); if (array.Length < LineCount) throw new ArgumentException("The array is too small", "array"); if (arrayIndex < 0 || arrayIndex + LineCount > array.Length) throw new ArgumentOutOfRangeException("arrayIndex", arrayIndex, "Value must be between 0 and " + (array.Length - LineCount)); foreach (DocumentLine ls in this) { array[arrayIndex++] = ls; } } bool ICollection<DocumentLine>.Remove(DocumentLine item) { throw new NotSupportedException(); } public IEnumerator<DocumentLine> GetEnumerator() { document.VerifyAccess(); return Enumerate(); } IEnumerator<DocumentLine> Enumerate() { document.VerifyAccess(); DocumentLine line = root.LeftMost; while (line != null) { yield return line; line = line.NextLine; } } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return this.GetEnumerator(); } #endregion } }