protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
#region Boudary Adjustment
//UpdateArguments(interactionArguments);
if (isShiftKeyDown && Vertices.Count == 0)
{
TrackShapeLayer.Open();
TrackShapeLayer.Clear();
}
#endregion
InteractiveResult interactiveResult = base.MouseDownCore(interactionArguments);
if (interactionArguments.MouseButton == MapMouseButton.Right && TrackMode != TrackMode.None)
{
interactiveResult.DrawThisOverlay = InteractiveOverlayDrawType.DoNotDraw;
interactiveResult = MouseClickCore(interactionArguments);
interactiveResult.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
}
return(interactiveResult);
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
var arguments = base.MouseMoveCore(interactionArguments);
if (TrackMode == TrackMode.Custom &&
measureCustomeMode == MeasureCustomeMode.Move &&
selectedMeasure != null &&
selectPoint != null)
{
var pointShape = selectPoint.GetShape() as PointShape;
var drageFeature = DragFeature(selectedMeasure, pointShape, new PointShape(interactionArguments.WorldX, interactionArguments.WorldY));
TrackShapeLayer.InternalFeatures.Clear();
TrackShapeLayer.InternalFeatures.Add(drageFeature);
arguments.DrawThisOverlay = InteractiveOverlayDrawType.Draw;
arguments.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
}
if (Vertices.Count == 0)
{
textBlock.Visibility = Visibility.Collapsed;
}
else
{
Canvas.SetLeft(textBlock, interactionArguments.ScreenX);
Canvas.SetTop(textBlock, interactionArguments.ScreenY);
}
return(arguments);
}
private void SelectAFeature(InteractionArguments interactionArguments)
{
Feature foundFeature = FindFeatureByPoint(interactionArguments.WorldX, interactionArguments.WorldY);
if (foundFeature != null)
{
var result = IsFoundFeatureMeasured(foundFeature);
if (!result.Item1)
{
MeasureOneFeature(foundFeature);
foundFeature.Id = NewMeasurementName(foundFeature.ColumnValues["Result"]);
foundFeature.ColumnValues["DisplayName"] = foundFeature.Id;
var mapShape = GetMapShape(foundFeature);
ShapeLayer.MapShapes.Add(foundFeature.Id, mapShape);
TakeSnapshot();
MeasureLastFeatureInLayer();
Refresh();
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.MouseClickCoreDescription));
}
else if (ShapeLayer.MapShapes.ContainsKey(result.Item2.Id))
{
ShapeLayer.MapShapes.Remove(result.Item2.Id);
Refresh();
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.MouseClickCoreDescription));
}
}
else
{
System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("MeasureTrackInteractiveOverlayNoFeaturesText"), GisEditor.LanguageManager.GetStringResource("GeneralMessageBoxInfoCaption"), System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Information);
}
}
protected override InteractiveResult MouseClickCore(InteractionArguments interactionArguments)
{
UpdateArguments(interactionArguments);
InteractiveResult result = base.MouseClickCore(interactionArguments);
return(result);
}
private void UpdateArguments(InteractionArguments interactionArguments)
{
if (TrackMode != TrackMode.None)
{
PointShape point = new PointShape(interactionArguments.WorldX, interactionArguments.WorldY);
if (searchingVertices.Count < 1)
{
return;
}
try
{
Vertex vertex = GetClosestVertex(searchingVertices, point);
interactionArguments.WorldX = vertex.X;
interactionArguments.WorldY = vertex.Y;
ScreenPointF screen = ExtentHelper.ToScreenCoordinate(interactionArguments.CurrentExtent, new PointShape(vertex), interactionArguments.MapWidth, interactionArguments.MapHeight);
interactionArguments.ScreenX = screen.X;
interactionArguments.ScreenY = screen.Y;
}
catch
{ }
}
}
protected override InteractiveResult MouseUpCore(InteractionArguments interactionArguments)
{
if (IsShiftKeyDown == true)
{
PolygonShape newPolygonShape = (PolygonShape)EditShapesLayer.InternalFeatures[0].GetShape();
RingShape ringShape = new RingShape();
foreach (Feature feature in controlPoints)
{
PointShape controlPointShape = (PointShape)feature.GetShape();
if (feature.ColumnValues["nodetype"] == "special")
{
BaseShape baseShape = snappingFeature.GetShape();
PointShape pointShape = baseShape.GetClosestPointTo(controlPointShape, GeographyUnit.DecimalDegree);
ringShape.Vertices.Add(new Vertex(pointShape.X, pointShape.Y));
}
else
{
ringShape.Vertices.Add(new Vertex(controlPointShape.X, controlPointShape.Y));
}
}
newPolygonShape.OuterRing = ringShape;
Feature newFeature = new Feature(newPolygonShape, EditShapesLayer.InternalFeatures[0].ColumnValues);
EditShapesLayer.Open();
EditShapesLayer.EditTools.BeginTransaction();
EditShapesLayer.InternalFeatures.Clear();
EditShapesLayer.InternalFeatures.Add(newFeature);
EditShapesLayer.EditTools.CommitTransaction();
EditShapesLayer.Close();
}
return(base.MouseUpCore(interactionArguments));
}
//At the Mouse Up event, the features of ExistingControlPointsLayer will be cleared and new one will
//be generated for better performance. So it is necessary to reupdate the column values of "IsSelected" to the new
//ExistingControlPointsLayer.
protected override InteractiveResult MouseUpCore(InteractionArguments interactionArguments)
{
Collection <int> draggedPointsIndex = new Collection <int>();
//Before the actual MouseUp event, we get the indexes of the features with value "true" of column "IsSelected".
this.ExistingControlPointsLayer.Open();
Collection <Feature> draggedPoints = this.ExistingControlPointsLayer.QueryTools.GetAllFeatures(new string[] { "IsSelected" });
this.ExistingControlPointsLayer.Close();
for (int index = 0; index < draggedPoints.Count; index++)
{
if (draggedPoints[index].ColumnValues["IsSelected"] == "true")
{
draggedPointsIndex.Add(index);
}
}
//The MouseUp is called clearing ExistingControlPointsLayer. (We do that for better performance)
InteractiveResult interactiveResult = base.MouseUpCore(interactionArguments);
//Now, we need to reset the column values of "IsSelected" for the relevant features.
foreach (int index in draggedPointsIndex)
{
this.ExistingControlPointsLayer.InternalFeatures[index].ColumnValues["IsSelected"] = "true";
}
this.ExistingControlPointsLayer.Close();
return(interactiveResult);
}
protected override InteractiveResult MouseUpCore(InteractionArguments interactionArguments)
{
Collection <int> draggedPointsIndex = new Collection <int>();
this.ExistingControlPointsLayer.Open();
Collection <Feature> draggedPoints = this.ExistingControlPointsLayer.QueryTools.GetAllFeatures(new string[] { "IsSelected" });
this.ExistingControlPointsLayer.Close();
for (int index = 0; index < draggedPoints.Count; index++)
{
if (draggedPoints[index].ColumnValues["IsSelected"] == "true")
{
draggedPointsIndex.Add(index);
}
}
InteractiveResult interactiveResult = base.MouseUpCore(interactionArguments);
foreach (int index in draggedPointsIndex)
{
this.ExistingControlPointsLayer.InternalFeatures[index].ColumnValues["IsSelected"] = "true";
}
this.ExistingControlPointsLayer.Close();
if (startPoint != null)
{
startPoint = null;
ControlPointType = ControlPointType.None;
}
ids = new Collection <int>();
return(interactiveResult);
}
private void StopDrawingMenuItem_Click(object sender, MouseButtonEventArgs e)
{
InteractionArguments interactionArguments = new InteractionArguments();
interactionArguments.WorldX = cursorWorldPoint.X;
interactionArguments.WorldY = cursorWorldPoint.Y;
GisEditor.ActiveMap.TrackOverlay.MouseDoubleClick(interactionArguments);
}
protected override InteractiveResult MouseClickCore(InteractionArguments interactionArguments)
{
if (TrackMode == TrackMode.Custom &&
measureCustomeMode != MeasureCustomeMode.Move)
{
SelectAFeature(interactionArguments);
}
return(base.MouseClickCore(interactionArguments));
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
if (!_contextMenuJustClosed)
{
return(base.MouseDownCore(interactionArguments));
}
_contextMenuJustClosed = false;
return(new InteractiveResult());
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
if (TrackMode == TrackMode.Circle)
{
circleCenterVertex = new Vertex(interactionArguments.WorldX, interactionArguments.WorldY);
TrackShapeLayer.InternalFeatures.Add(Resources.CenterFeatureKey, new Feature(circleCenterVertex));
}
return base.MouseDownCore(interactionArguments);
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
if (TrackMode == TrackMode.Circle)
{
circleCenterVertex = new Vertex(interactionArguments.WorldX, interactionArguments.WorldY);
TrackShapeLayer.InternalFeatures.Add(Resources.CenterFeatureKey, new Feature(circleCenterVertex));
}
return(base.MouseDownCore(interactionArguments));
}
protected override InteractiveResult MouseDoubleClickCore(InteractionArguments interactionArguments)
{
if (isShiftKeyDown)
{
AddSnapedVertex(interactionArguments.CurrentExtent, true);
}
var interactionResult = base.MouseDoubleClickCore(interactionArguments);
return(interactionResult);
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
InteractiveResult result = base.MouseDownCore(interactionArguments);
if (IsInModifyMode && Keyboard.Modifiers == ModifierKeys.Shift)
{
result.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
trackStartPointShape = new PointShape(interactionArguments.WorldX, interactionArguments.WorldY);
}
return(result);
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
if (interactionArguments.MouseButton != MapMouseButton.Right)
{
return(base.MouseDownCore(interactionArguments));
}
else
{
RemoveLastVertexAdded();
}
return(new InteractiveResult());
}
private void CollectionVertices(InteractionArguments interactionArguments)
{
searchingVertices = new List <Vertex>();
var snappingLayer = snappingLayers.FirstOrDefault();
if (snappingLayer != null)
{
snappingLayer.Open();
Collection <Feature> features = snappingLayer.QueryTools.GetFeaturesInsideBoundingBox(interactionArguments.CurrentExtent, ReturningColumnsType.NoColumns);
foreach (var item in features)
{
BaseShape shape = item.GetShape();
if (shape is PointShape)
{
searchingVertices.Add(new Vertex((PointShape)shape));
}
else if (shape is MultipointShape)
{
searchingVertices.AddRange(((MultipointShape)shape).Points.Select(p => new Vertex(p)));
}
else if (shape is PolygonShape)
{
searchingVertices.AddRange((shape as PolygonShape).OuterRing.Vertices);
}
else if (shape is MultipolygonShape)
{
foreach (var polygon in (shape as MultipolygonShape).Polygons)
{
searchingVertices.AddRange(polygon.OuterRing.Vertices);
}
}
else if (shape is LineShape)
{
searchingVertices.AddRange(((LineShape)shape).Vertices);
}
else if (shape is MultilineShape)
{
foreach (var line in (shape as MultilineShape).Lines)
{
searchingVertices.AddRange(line.Vertices);
}
}
}
isDirty = false;
}
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
if (TrackMode == TrackMode.Custom &&
measureCustomeMode == MeasureCustomeMode.Move)
{
selectedMeasure = GetDragFeatureByPoint(interactionArguments);
if (selectedMeasure != null)
{
TrackShapeLayer.InternalFeatures.Add(selectedMeasure);
shapeLayer.MapShapes.Remove(selectedMeasure.Id);
}
}
return(base.MouseDownCore(interactionArguments));
}
protected override InteractiveResult MouseUpCore(InteractionArguments interactionArguments)
{
InteractiveResult result = base.MouseUpCore(interactionArguments);
if (selectionLayer.InternalFeatures.Count > 0)
{
result.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
result.DrawThisOverlay = InteractiveOverlayDrawType.Draw;
OnSelectionFinished(selectionLayer.InternalFeatures.First().GetBoundingBox());
selectionLayer.InternalFeatures.Clear();
trackStartPointShape = null;
}
return(result);
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
if (UnsafeHelper.IsKeyPressed(Keys.ControlKey))
{
this.selectionMode = SelectionMode.Subtract;
}
else if (UnsafeHelper.IsKeyPressed(Keys.ShiftKey))
{
this.selectionMode = SelectionMode.Added;
}
else
{
this.selectionMode = SelectionMode.None;
}
return(base.MouseMoveCore(interactionArguments));;
}
private Feature GetDragFeatureByPoint(InteractionArguments interactionArguments)
{
Feature result = null;
var point = new Feature(interactionArguments.WorldX, interactionArguments.WorldY);
foreach (var shape in ShapeLayer.MapShapes.Reverse())
{
if (shape.Value.Feature.Intersects(point.Buffer(10, GisEditor.ActiveMap.MapUnit, DistanceUnit.Meter)))
{
result = shape.Value.Feature;
selectPoint = point;
break;
}
}
return(result);
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
InteractiveResult result = base.MouseDownCore(interactionArguments);
startPoint = null;
if (interactionArguments.MouseButton == MapMouseButton.Left)
{
if (EditShapesLayer.InternalFeatures.Count > 0)
{
if (SetSelectedControlPoint(new PointShape(interactionArguments.WorldX, interactionArguments.WorldY), interactionArguments.SearchingTolerance))
{
startPoint = new PointShape(interactionArguments.WorldX, interactionArguments.WorldY);
}
}
}
return(result);
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
InteractiveResult arguments = base.MouseMoveCore(interactionArguments);
if (Vertices.Count == 0)
{
radiusValueString = string.Empty;
}
else if (TrackMode == TrackMode.Circle)
{
Vertex currentVertex = new Vertex(interactionArguments.WorldX, interactionArguments.WorldY);
radiusLine = new LineShape(new[] { circleCenterVertex, currentVertex });
TrackShapeLayer.InternalFeatures["radius"] = new Feature(radiusLine);
mouseScreenPointF = new ScreenPointF(interactionArguments.ScreenX + 10, interactionArguments.ScreenY - 10);
}
return(arguments);
}
protected override InteractiveResult MouseDownCore(InteractionArguments interactionArguments)
{
System.Diagnostics.Debug.WriteLine(this.Vertices.Count);
if (interactionArguments.MouseButton != MapMouseButton.Right)
{
return(base.MouseDownCore(interactionArguments));
}
else
{
if (this.Vertices.Count >= 5)
{
RemoveLastVertexAdded();
MouseDownCount = MouseDownCount - 1;
}
return(new InteractiveResult());
}
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
InteractiveResult arguments = base.MouseMoveCore(interactionArguments);
if (Vertices.Count == 0)
{
textBlock.Visibility = Visibility.Collapsed;
}
else if (TrackMode == TrackMode.Circle && interactionArguments.MouseButton == MapMouseButton.Left)
{
Vertex currentVertex = new Vertex(interactionArguments.WorldX, interactionArguments.WorldY);
radiusLine = new LineShape(new[] { circleCenterVertex, currentVertex });
TrackShapeLayer.InternalFeatures[Resources.RadiusFeatureKey] = new Feature(radiusLine);
Canvas.SetLeft(textBlock, interactionArguments.ScreenX + 10);
Canvas.SetTop(textBlock, interactionArguments.ScreenY + 10);
}
return arguments;
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
InteractiveResult result = base.MouseMoveCore(interactionArguments);
SetDefaultColumnValue();
if (trackStartPointShape != null)
{
result.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
result.DrawThisOverlay = InteractiveOverlayDrawType.Draw;
double left = trackStartPointShape.X < interactionArguments.WorldX ? trackStartPointShape.X : interactionArguments.WorldX;
double right = trackStartPointShape.X > interactionArguments.WorldX ? trackStartPointShape.X : interactionArguments.WorldX;
double top = trackStartPointShape.Y > interactionArguments.WorldY ? trackStartPointShape.Y : interactionArguments.WorldY;
double bottom = trackStartPointShape.Y < interactionArguments.WorldY ? trackStartPointShape.Y : interactionArguments.WorldY;
RectangleShape selectionArea = new RectangleShape(left, top, right, bottom);
selectionLayer.InternalFeatures.Clear();
selectionLayer.InternalFeatures.Add(new Feature(selectionArea));
}
return(result);
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
InteractiveResult arguments = base.MouseMoveCore(interactionArguments);
if (Vertices.Count == 0)
{
textBlock.Visibility = Visibility.Collapsed;
}
else if (TrackMode == TrackMode.Circle && interactionArguments.MouseButton == MapMouseButton.Left)
{
Vertex currentVertex = new Vertex(interactionArguments.WorldX, interactionArguments.WorldY);
radiusLine = new LineShape(new[] { circleCenterVertex, currentVertex });
TrackShapeLayer.InternalFeatures[Resources.RadiusFeatureKey] = new Feature(radiusLine);
Canvas.SetLeft(textBlock, interactionArguments.ScreenX + 10);
Canvas.SetTop(textBlock, interactionArguments.ScreenY + 10);
}
return(arguments);
}
protected override InteractiveResult MouseUpCore(InteractionArguments interactionArguments)
{
if (selectedMeasure != null)
{
Canvas.SetLeft(textBlock, interactionArguments.ScreenX);
Canvas.SetTop(textBlock, interactionArguments.ScreenY);
textBlock.Visibility = Visibility.Visible;
MeasureLastFeatureInLayer();
var feature = TrackShapeLayer.InternalFeatures.LastOrDefault();
shapeLayer.MapShapes.Add(selectedMeasure.Id, GetMapShape(feature));
TrackShapeLayer.InternalFeatures.Clear();
selectedMeasure = null;
selectPoint = null;
TakeSnapshot();
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(this, RefreshArgsDescription.OnTrackEndedDescription));
}
return(base.MouseUpCore(interactionArguments));
}
protected override InteractiveResult MouseClickCore(InteractionArguments interactionArguments)
{
InteractiveResult result = base.MouseClickCore(interactionArguments);
if (result.DrawThisOverlay != InteractiveOverlayDrawType.Draw)
{
RectangleShape searchingArea = new RectangleShape(interactionArguments.WorldX - interactionArguments.SearchingTolerance, interactionArguments.WorldY + interactionArguments.SearchingTolerance, interactionArguments.WorldX + interactionArguments.SearchingTolerance, interactionArguments.WorldY - interactionArguments.SearchingTolerance);
foreach (Feature feature in ExistingControlPointsLayer.InternalFeatures)
{
BaseShape shape = feature.GetShape();
if (shape.IsWithin(searchingArea))
{
if (feature.ColumnValues.ContainsKey("IsSelected") && (feature.ColumnValues["IsSelected"] == "true"))
{
feature.ColumnValues["IsSelected"] = string.Empty;
result.DrawThisOverlay = InteractiveOverlayDrawType.Draw;
result.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
Lock.IsDirty = true;
break;
}
else
{
feature.ColumnValues["IsSelected"] = "true";
result.DrawThisOverlay = InteractiveOverlayDrawType.Draw;
result.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
Lock.IsDirty = true;
break;
}
}
}
}
return(result);
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
if (isShiftKeyDown)
{
var circle = OverlayCanvas.Children.OfType <System.Windows.Shapes.Ellipse>().FirstOrDefault();
if (circle != null)
{
OverlayCanvas.Children.Remove(circle);
}
}
if (IsDirty && TrackMode != TrackMode.None)
{
CollectionVertices(interactionArguments);
}
UpdateArguments(interactionArguments);
if (TrackMode != TrackMode.None &&
MouseDownCount < 1 &&
SnappingLayers.Count > 0)
{
lock (OverlayCanvas.Children)
{
Vertex currentPosition = new Vertex(interactionArguments.WorldX, interactionArguments.WorldY);
var snappingCircle = OverlayCanvas.Children.OfType <System.Windows.Shapes.Ellipse>().FirstOrDefault();
if (snappingCircle == null)
{
snappingCircle = new System.Windows.Shapes.Ellipse();
snappingCircle.IsHitTestVisible = false;
snappingCircle.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
snappingCircle.VerticalAlignment = System.Windows.VerticalAlignment.Top;
snappingCircle.Stroke = new SolidColorBrush(Colors.Black);
snappingCircle.StrokeThickness = 1;
OverlayCanvas.Children.Add(snappingCircle);
}
var snappingDistance = SnappingDistance;
var snappingDistanceUnit = SnappingDistanceUnit;
var snappingScreenPoint = ExtentHelper.ToScreenCoordinate(MapArguments.CurrentExtent, currentPosition.X, currentPosition.Y, (float)MapArguments.ActualWidth, (float)MapArguments.ActualHeight);
try
{
SnappingAdapter calc = SnappingAdapter.Convert(snappingDistance, snappingDistanceUnit, MapArguments, currentPosition);
var snappingArea = new PointShape(currentPosition.X, currentPosition.Y)
.Buffer(calc.Distance, MapArguments.MapUnit, calc.DistanceUnit)
.GetBoundingBox();
var snappingScreenSize = Math.Max(snappingArea.Width, snappingArea.Height) / MapArguments.CurrentResolution;
snappingCircle.Width = snappingScreenSize;
snappingCircle.Height = snappingScreenSize;
snappingCircle.Margin = new System.Windows.Thickness(snappingScreenPoint.X - snappingScreenSize * .5, snappingScreenPoint.Y - snappingScreenSize * .5, 0, 0);
}
catch
{ }
}
}
else
{
lock (OverlayCanvas.Children)
{
var circle = OverlayCanvas.Children.OfType <System.Windows.Shapes.Ellipse>().FirstOrDefault();
if (circle != null)
{
OverlayCanvas.Children.Remove(circle);
}
}
}
var interactiveResult = base.MouseMoveCore(interactionArguments);
return(interactiveResult);
}
protected override InteractiveResult MouseMoveCore(InteractionArguments interactionArguments)
{
InteractiveResult result = new InteractiveResult();
if (ControlPointType != ControlPointType.None)
{
if (startPoint == null)
{
return(result);
}
else
{
PointShape currentPoint = new PointShape(interactionArguments.WorldX, interactionArguments.WorldY);
double xOffset = currentPoint.X - startPoint.X;
double yOffset = currentPoint.Y - startPoint.Y;
Collection <Feature> features = new Collection <Feature>();
int index = 0;
System.Diagnostics.Debug.WriteLine("ids count");
foreach (int id in ids)
{
System.Diagnostics.Debug.WriteLine(id.ToString());
}
if (ids.Count == 0)
{
foreach (Feature feature in ExistingControlPointsLayer.InternalFeatures)
{
if (feature.ColumnValues.ContainsKey("IsSelected") && feature.ColumnValues["IsSelected"] == "true")
{
features.Add(feature);
ids.Add(index);
}
index++;
}
}
else
{
foreach (int id in ids)
{
features.Add(ExistingControlPointsLayer.InternalFeatures[id]);
}
}
foreach (Feature feature in features)
{
PointShape oldPoint = feature.GetShape() as PointShape;
PointShape targetPoint = new PointShape(oldPoint.X + xOffset, oldPoint.Y + yOffset);
EditShapesLayer.InternalFeatures[0] = MoveVertex(EditShapesLayer.InternalFeatures[0], oldPoint, targetPoint);
}
CalculateAllControlPoints();
startPoint = currentPoint.CloneDeep() as PointShape;
bool existingNode = false;
foreach (string key in EditShapesLayer.InternalFeatures.GetKeys())
{
if (string.Equals(EditShapesLayer.InternalFeatures[key].Id, OriginalEditingFeature.Id, StringComparison.OrdinalIgnoreCase))
{
Lock.EnterWriteLock();
try
{
EditShapesLayer.InternalFeatures[key] = EditShapesLayer.InternalFeatures[0];
}
finally
{
Lock.ExitWriteLock();
}
foreach (string featureKey in ExistingControlPointsLayer.InternalFeatures.GetKeys())
{
Feature feature = ExistingControlPointsLayer.InternalFeatures[featureKey];
if (feature.ColumnValues != null)
{
if (feature.ColumnValues["state"] == "selected")
{
existingNode = true;
}
}
}
ShowAllControlPointLayers(false, existingNode);
break;
}
}
result.DrawThisOverlay = InteractiveOverlayDrawType.Draw;
result.ProcessOtherOverlaysMode = ProcessOtherOverlaysMode.DoNotProcessOtherOverlays;
}
}
return(result);
}
