/// <summary>
/// This is a basic FinishSketch method which illustrates the process of using the sketch geometry for a cut.
/// 1. look at all layers in the active map
/// for each layer:
/// 2. Use the sketch geometry to perform a spatial query (Crosses)
/// 3. Use the found features and use them to set up a cut operation
/// 4. Create edit operation
/// 5. Execute the edit operation
/// ! edits are not saved !
///
/// </summary>
/// <returns>Task of bool</returns>
protected override async Task <bool> OnFinishSketch(Geometry geometry, Dictionary <string, object> attributes)
{
// use all layers of the active map to perform the cut
foreach (var layer in ActiveMap.Layers)
{
// intialize a list of ObjectIDs that need to be cut
List <long> cutOiDs = new List <long>();
Table fc = await layer.getFeatureClass();
// on a separate thread
await QueuingTaskFactory.StartNew(() =>
{
// find the features crossed by the sketch geometry
RowCursor rc = fc.Search(geometry, SpatialRelationship.Crosses);
// add the feature IDs into our prepared list
while (rc.MoveNext())
{
cutOiDs.Add(rc.Current.ObjectID);
}
});
// no features 'crossed' by the sketched line
if (!cutOiDs.Any())
{
continue;
}
// create an edit operation for the cut
EditOperation op = EditingModule.CreateEditOperation();
op.Name = string.Format("Cut {0}", layer.Name);
op.ProgressMessage = "Working...";
op.CancelMessage = "Operation canceled";
op.ErrorMessage = "Error cutting features";
op.SelectModifiedFeatures = false;
op.SelectNewFeatures = false;
// for each of the found features set up a cut method inside our edit operation
// for multiple ObjectIDs the cuts with will be stacked into one operation
foreach (var oid in cutOiDs)
{
op.Cut(layer, oid, geometry);
}
await op.ExecuteAsync();
}
//execute the operation
return(true);
}
protected Task <bool> ExecuteCut(Geometry geometry)
{
if (geometry == null)
{
return(Task.FromResult(false));
}
// create an edit operation
EditOperation op = new EditOperation();
op.Name = "Cut Elements";
op.ProgressMessage = "Working...";
op.CancelMessage = "Operation canceled.";
op.ErrorMessage = "Error cutting polygons";
op.SelectModifiedFeatures = false;
op.SelectNewFeatures = false;
// create a collection of feature layers that can be edited
var editableLayers = ActiveMapView.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>()
.Where(lyr => lyr.CanEditData() == true).Where(lyr => lyr.ShapeType == ArcGIS.Core.CIM.esriGeometryType.esriGeometryPolygon);
// for each of the layers
foreach (FeatureLayer editableFeatureLayer in editableLayers)
{
// get the feature class associated with the layer
Table fc = editableFeatureLayer.GetTable();
// initialize a list of ObjectIDs that need to be cut
var cutOIDs = new List <long>();
// find the features crossed by the sketch geometry
var rowCursor = fc.Search(geometry, SpatialRelationship.Crosses);
// add the feature IDs into our prepared list
while (rowCursor.MoveNext())
{
var feature = rowCursor.Current as Feature;
if (feature == null)
{
break;
}
if (feature.GetShape() != null)
{
// we are interested in the intersection points
// in case there is only one intersection then the sketch geometry doesn't enter and leave the
// base geometry and the cut operation won't work.
Geometry intersectionGeometry = GeometryEngine.Intersection(feature.GetShape(), geometry, GeometryDimension.esriGeometry0Dimension);
if (intersectionGeometry is Multipoint)
{
var intersectionPoints = intersectionGeometry as Multipoint;
// we are only interested in feature IDs where the count of intersection points is larger than 1
// i.e., at least one entry and one exit
if (intersectionPoints.Points.Count > 1)
{
// add the current feature to the overall list of features to cut
cutOIDs.Add(rowCursor.Current.GetObjectID());
}
}
}
}
// add the elements to cut into the edit operation
op.Cut(editableFeatureLayer, cutOIDs, geometry);
}
//execute the operation
return(op.ExecuteAsync());
}
public void EditOperations()
{
var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList()[0] as FeatureLayer;
var polygon = new PolygonBuilder().ToGeometry();
var clipPoly = new PolygonBuilder().ToGeometry();
var cutLine = new PolylineBuilder().ToGeometry();
var modifyLine = cutLine;
var oid = 1;
#region Edit Operation Create Features
var createFeatures = new EditOperation();
createFeatures.Name = "Create Features";
//Create a feature with a polygon
createFeatures.Create(featureLayer, polygon);
//with a callback
createFeatures.Create(featureLayer, polygon, (object_id) => {
//TODO - use the oid of the created feature
//in your callback
});
//Do a create features and set attributes
var attributes = new Dictionary <string, object>();
attributes.Add("SHAPE", polygon);
attributes.Add("NAME", "Corner Market");
attributes.Add("SIZE", 1200.5);
attributes.Add("DESCRIPTION", "Corner Market");
createFeatures.Create(featureLayer, attributes);
//Create features using the current template
//Must be within a MapTool
createFeatures.Create(this.CurrentTemplate, polygon);
//Execute to execute the operation
//Must be called within QueuedTask.Run
createFeatures.Execute();
//or use async flavor
//await createFeatures.ExecuteAsync();
#endregion
#region Edit Operation Clip Features
var clipFeatures = new EditOperation();
clipFeatures.Name = "Clip Features";
clipFeatures.Clip(featureLayer, oid, clipPoly, ClipMode.PreserveArea);
//Execute to execute the operation
//Must be called within QueuedTask.Run
clipFeatures.Execute();
//or use async flavor
//await clipFeatures.ExecuteAsync();
#endregion
#region Edit Operation Cut Features
var select = MapView.Active.SelectFeatures(clipPoly);
var cutFeatures = new EditOperation();
cutFeatures.Name = "Cut Features";
cutFeatures.Cut(featureLayer, oid, cutLine);
//Cut all the selected features in the active view
//Select using a polygon (for example)
var kvps = MapView.Active.SelectFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
cutFeatures.Cut(kvps, cutLine);
//Execute to execute the operation
//Must be called within QueuedTask.Run
cutFeatures.Execute();
//or use async flavor
//await cutFeatures.ExecuteAsync();
#endregion
#region Edit Operation Delete Features
var deleteFeatures = new EditOperation();
deleteFeatures.Name = "Delete Features";
var table = MapView.Active.Map.StandaloneTables[0];
//Delete a row in a standalone table
deleteFeatures.Delete(table, oid);
//Delete all the selected features in the active view
//Select using a polygon (for example)
var selection = MapView.Active.SelectFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
deleteFeatures.Delete(selection);
//Execute to execute the operation
//Must be called within QueuedTask.Run
deleteFeatures.Execute();
//or use async flavor
//await deleteFeatures.ExecuteAsync();
#endregion
#region Edit Operation Duplicate Features
var duplicateFeatures = new EditOperation();
duplicateFeatures.Name = "Duplicate Features";
//Duplicate with an X and Y offset of 500 map units
duplicateFeatures.Duplicate(featureLayer, oid, 500.0, 500.0, 0.0);
//Execute to execute the operation
//Must be called within QueuedTask.Run
duplicateFeatures.Execute();
//or use async flavor
//await duplicateFeatures.ExecuteAsync();
#endregion
#region Edit Operation Explode Features
var explodeFeatures = new EditOperation();
explodeFeatures.Name = "Explode Features";
//Take a multipart and convert it into one feature per part
//Provide a list of ids to convert multiple
explodeFeatures.Explode(featureLayer, new List <long>()
{
oid
}, true);
//Execute to execute the operation
//Must be called within QueuedTask.Run
explodeFeatures.Execute();
//or use async flavor
//await explodeFeatures.ExecuteAsync();
#endregion
var destinationLayer = featureLayer;
#region Edit Operation Merge Features
var mergeFeatures = new EditOperation();
mergeFeatures.Name = "Merge Features";
//Merge three features into a new feature using defaults
//defined in the current template
mergeFeatures.Merge(this.CurrentTemplate as EditingFeatureTemplate, featureLayer, new List <long>()
{
10, 96, 12
});
//Merge three features into a new feature in the destination layer
mergeFeatures.Merge(destinationLayer, featureLayer, new List <long>()
{
10, 96, 12
});
//Use an inspector to set the new attributes of the merged feature
var inspector = new Inspector();
inspector.Load(featureLayer, oid);//base attributes on an existing feature
//change attributes for the new feature
inspector["NAME"] = "New name";
inspector["DESCRIPTION"] = "New description";
//Merge features into a new feature in the same layer using the
//defaults set in the inspector
mergeFeatures.Merge(featureLayer, new List <long>()
{
10, 96, 12
}, inspector);
//Execute to execute the operation
//Must be called within QueuedTask.Run
mergeFeatures.Execute();
//or use async flavor
//await mergeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Modify single feature
var modifyFeature = new EditOperation();
modifyFeature.Name = "Modify a feature";
//use an inspector
var modifyInspector = new Inspector();
modifyInspector.Load(featureLayer, oid);//base attributes on an existing feature
//change attributes for the new feature
modifyInspector["SHAPE"] = polygon; //Update the geometry
modifyInspector["NAME"] = "Updated name"; //Update attribute(s)
modifyFeature.Modify(modifyInspector);
//update geometry and attributes using overload
var featureAttributes = new Dictionary <string, object>();
featureAttributes["NAME"] = "Updated name";//Update attribute(s)
modifyFeature.Modify(featureLayer, oid, polygon, featureAttributes);
//Execute to execute the operation
//Must be called within QueuedTask.Run
modifyFeature.Execute();
//or use async flavor
//await modifyFeatures.ExecuteAsync();
#endregion
#region Edit Operation Modify multiple features
//Search by attribute
var queryFilter = new QueryFilter();
queryFilter.WhereClause = "OBJECTID < 1000000";
//Create list of oids to update
var oidSet = new List <long>();
using (var rc = featureLayer.Search(queryFilter))
{
while (rc.MoveNext())
{
oidSet.Add(rc.Current.GetObjectID());
}
}
//create and execute the edit operation
var modifyFeatures = new EditOperation();
modifyFeatures.Name = "Modify features";
modifyFeatures.ShowProgressor = true;
var insp = new Inspector();
insp.Load(featureLayer, oidSet);
insp["MOMC"] = 24;
modifyFeatures.Modify(insp);
modifyFeatures.ExecuteAsync();
#endregion
#region Move features
//Get all of the selected ObjectIDs from the layer.
var firstLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault();
var selectionfromMap = firstLayer.GetSelection();
// set up a dictionary to store the layer and the object IDs of the selected features
var selectionDictionary = new Dictionary <MapMember, List <long> >();
selectionDictionary.Add(firstLayer as MapMember, selectionfromMap.GetObjectIDs().ToList());
var moveFeature = new EditOperation();
moveFeature.Name = "Move features";
moveFeature.Move(selectionDictionary, 10, 10); //specify your units along axis to move the geometry
moveFeature.Execute();
#endregion
#region Move feature to a specific coordinate
//Get all of the selected ObjectIDs from the layer.
var abLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault();
var mySelection = abLayer.GetSelection();
var selOid = mySelection.GetObjectIDs().FirstOrDefault();
var moveToPoint = new MapPointBuilder(1.0, 2.0, 3.0, 4.0, MapView.Active.Map.SpatialReference); //can pass in coordinates.
var modifyFeatureCoord = new EditOperation();
modifyFeatureCoord.Name = "Move features";
modifyFeatureCoord.Modify(abLayer, selOid, moveToPoint.ToGeometry()); //Modify the feature to the new geometry
modifyFeatureCoord.Execute();
#endregion
#region Edit Operation Planarize Features
var planarizeFeatures = new EditOperation();
planarizeFeatures.Name = "Planarize Features";
//Planarize one or more features
planarizeFeatures.Planarize(featureLayer, new List <long>()
{
oid
});
//Execute to execute the operation
//Must be called within QueuedTask.Run
planarizeFeatures.Execute();
//or use async flavor
//await planarizeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Reshape Features
var reshapeFeatures = new EditOperation();
reshapeFeatures.Name = "Reshape Features";
reshapeFeatures.Reshape(featureLayer, oid, modifyLine);
//Reshape a set of features that intersect some geometry....
var selFeatures = MapView.Active.GetFeatures(modifyLine).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
reshapeFeatures.Reshape(selFeatures, modifyLine);
//Execute to execute the operation
//Must be called within QueuedTask.Run
reshapeFeatures.Execute();
//or use async flavor
//await reshapeFeatures.ExecuteAsync();
#endregion
var origin = MapPointBuilder.CreateMapPoint(0, 0, null);
#region Edit Operation Rotate Features
var rotateFeatures = new EditOperation();
rotateFeatures.Name = "Rotate Features";
//Rotate works on a selected set of features
//Get all features that intersect a polygon
var rotateSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
//Rotate selected features 90 deg about "origin"
rotateFeatures.Rotate(rotateSelection, origin, Math.PI / 2);
//Execute to execute the operation
//Must be called within QueuedTask.Run
rotateFeatures.Execute();
//or use async flavor
//await rotateFeatures.ExecuteAsync();
#endregion
#region Edit Operation Scale Features
var scaleFeatures = new EditOperation();
scaleFeatures.Name = "Scale Features";
//Rotate works on a selected set of features
var scaleSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
//Scale the selected features by 2.0 in the X and Y direction
scaleFeatures.Scale(scaleSelection, origin, 2.0, 2.0, 0.0);
//Execute to execute the operation
//Must be called within QueuedTask.Run
scaleFeatures.Execute();
//or use async flavor
//await scaleFeatures.ExecuteAsync();
#endregion
var mp1 = MapPointBuilder.CreateMapPoint(0, 0, null);
var mp2 = mp1;
var mp3 = mp1;
#region Edit Operation Split Features
var splitFeatures = new EditOperation();
splitFeatures.Name = "Split Features";
var splitPoints = new List <MapPoint>()
{
mp1, mp2, mp3
};
//Split the feature at 3 points
splitFeatures.Split(featureLayer, oid, splitPoints);
// split using percentage
var splitByPercentage = new SplitByPercentage()
{
Percentage = 33, SplitFromStartPoint = true
};
splitFeatures.Split(featureLayer, oid, splitByPercentage);
// split using equal parts
var splitByEqualParts = new SplitByEqualParts()
{
NumParts = 3
};
splitFeatures.Split(featureLayer, oid, splitByEqualParts);
// split using single distance
var splitByDistance = new SplitByDistance()
{
Distance = 27.3, SplitFromStartPoint = false
};
splitFeatures.Split(featureLayer, oid, splitByDistance);
// split using varying distance
var distances = new List <double>()
{
12.5, 38.2, 89.99
};
var splitByVaryingDistance = new SplitByVaryingDistance()
{
Distances = distances, SplitFromStartPoint = true, ProportionRemainder = true
};
splitFeatures.Split(featureLayer, oid, splitByVaryingDistance);
//Execute to execute the operation
//Must be called within QueuedTask.Run
splitFeatures.Execute();
//or use async flavor
//await splitAtPointsFeatures.ExecuteAsync();
#endregion
var linkLayer = featureLayer;
#region Edit Operation Transform Features
var transformFeatures = new EditOperation();
transformFeatures.Name = "Transform Features";
//Transform a selected set of features
var transformSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
transformFeatures.Transform(transformSelection, linkLayer);
//Transform just a layer
transformFeatures.Transform(featureLayer, linkLayer);
//Perform an affine transformation
transformFeatures.TransformAffine(featureLayer, linkLayer);
//Execute to execute the operation
//Must be called within QueuedTask.Run
transformFeatures.Execute();
//or use async flavor
//await transformFeatures.ExecuteAsync();
#endregion
#region Edit Operation Perform a Clip, Cut, and Planarize
//Multiple operations can be performed by a single
//edit operation.
var clipCutPlanarizeFeatures = new EditOperation();
clipCutPlanarizeFeatures.Name = "Clip, Cut, and Planarize Features";
clipCutPlanarizeFeatures.Clip(featureLayer, oid, clipPoly);
clipCutPlanarizeFeatures.Cut(featureLayer, oid, cutLine);
clipCutPlanarizeFeatures.Planarize(featureLayer, new List <long>()
{
oid
});
//Note: An edit operation is a single transaction.
//Execute the operations (in the order they were declared)
clipCutPlanarizeFeatures.Execute();
//or use async flavor
//await clipCutPlanarizeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Chain Edit Operations
//Chaining operations is a special case. Use "Chained Operations" when you require multiple transactions
//to be undo-able with a single "Undo".
//The most common use case for operation chaining is creating a feature with an attachement.
//Adding an attachment requires the object id (of a new feature) has already been created.
var editOperation1 = new EditOperation();
editOperation1.Name = string.Format("Create point in '{0}'", CurrentTemplate.Layer.Name);
long newFeatureID = -1;
//The Create operation has to execute so we can get an object_id
editOperation1.Create(this.CurrentTemplate, polygon, (object_id) => newFeatureID = object_id);
//Must be within a QueuedTask
editOperation1.Execute();
//or use async flavor
//await editOperation1.ExecuteAsync();
//Now, because we have the object id, we can add the attachment. As we are chaining it, adding the attachment
//can be undone as part of the "Undo Create" operation. In other words, only one undo operation will show on the
//Pro UI and not two.
var editOperation2 = editOperation1.CreateChainedOperation();
//Add the attachement using the new feature id
editOperation2.AddAttachment(this.CurrentTemplate.Layer, newFeatureID, @"C:\data\images\Hydrant.jpg");
//editOperation1 and editOperation2 show up as a single Undo operation on the UI even though
//we had two transactions
//Must be within a QueuedTask
editOperation2.Execute();
//or use async flavor
//await editOperation2.ExecuteAsync();
#endregion
#region SetOnUndone, SetOnRedone, SetOnComitted
// SetOnUndone, SetOnRedone and SetOnComittedManage can be used to manage
// external actions(such as writing to a log table) that are associated with
// each edit operation.
//get selected feature and update attribute
var selectedFeatures = MapView.Active.Map.GetSelection();
var testInspector = new Inspector();
testInspector.Load(selectedFeatures.Keys.First(), selectedFeatures.Values.First());
testInspector["Name"] = "test";
//create and execute the edit operation
var updateTestField = new EditOperation();
updateTestField.Name = "Update test field";
updateTestField.Modify(insp);
//actions for SetOn...
updateTestField.SetOnUndone(() =>
{
//Sets an action that will be called when this operation is undone.
Debug.WriteLine("Operation is undone");
});
updateTestField.SetOnRedone(() =>
{
//Sets an action that will be called when this editoperation is redone.
Debug.WriteLine("Operation is redone");
});
updateTestField.SetOnComitted((bool b) => //called on edit session save(true)/discard(false).
{
// Sets an action that will be called when this editoperation is committed.
Debug.WriteLine("Operation is committed");
});
updateTestField.Execute();
#endregion
}
protected async Task <bool> ExecuteCut(EditingTemplate template, Geometry geometry, Dictionary <string, object> attributes)
{
if (template == null)
{
return(false);
}
if (geometry == null)
{
return(false);
}
// create an edit operation
EditOperation op = EditingModule.CreateEditOperation();
op.Name = "Cut Elements";
op.ProgressMessage = "Working...";
op.CancelMessage = "Operation canceled.";
op.ErrorMessage = "Error cutting polygons";
op.SelectModifiedFeatures = false;
op.SelectNewFeatures = false;
// get the feature class associated with the layer
Table fc = await template.Layer.GetTableAsync();
// initialize a list of ObjectIDs that need to be cut
var cutOIDs = new List <long>();
// on a separate thread
await QueuingTaskFactory.StartNew(async() =>
{
// TODO
// find the features crossed by the sketch geometry
RowCursor rc = await fc.SearchAsync(geometry, SpatialRelationship.Crosses);
// add the feature IDs into our prepared list
while (rc.MoveNext())
{
var feature = rc.Current as Feature;
if (feature == null)
{
break;
}
if (feature.Shape != null)
{
// we are interested in the intersection points
// in case there is only one intersection then the sketch geometry doesn't enter and leave the
// base geometry and the cut operation won't work.
Geometry intersectionGeometry = GeometryEngine.Intersection(feature.Shape, geometry, GeometryDimension.esriGeometry0Dimension);
if (intersectionGeometry is MultiPoint)
{
//var intersectionPoints = intersectionGeometry as MultiPoint;
//// we are only interested in feature IDs where the count of intersection points is larger than 1
//// i.e., at least one entry and one exit
//if (intersectionPoints.Coordinates.Count > 1)
//{
// // add the current feature to the overall list of features to cut
// cutOIDs.Add(rc.Current.ObjectID);
//}
}
}
}
});
// add the elements to cut into the edit operation
op.Cut(template.Layer, cutOIDs, geometry);
//execute the operation
bool operationResult = await op.ExecuteAsync();
return(operationResult);
}
/// <summary>
/// Method to perform the cut operation on the geometry and change attributes
/// </summary>
/// <param name="geometry">Line geometry used to perform the cut against in the polygon features
/// in the active map view.</param>
/// <returns>If the cut operation was successful.</returns>
protected Task <bool> ExecuteCut(Geometry geometry)
{
if (geometry == null)
{
return(Task.FromResult(false));
}
// create a collection of feature layers that can be edited
var editableLayers = ActiveMapView.Map.GetLayersAsFlattenedList()
.OfType <FeatureLayer>()
.Where(lyr => lyr.CanEditData() == true).Where(lyr =>
lyr.ShapeType == esriGeometryType.esriGeometryPolygon);
// ensure that there are target layers
if (editableLayers.Count() == 0)
{
return(Task.FromResult(false));
}
// create an edit operation
EditOperation cutOperation = new EditOperation()
{
Name = "Cut Elements",
ProgressMessage = "Working...",
CancelMessage = "Operation canceled.",
ErrorMessage = "Error cutting polygons",
SelectModifiedFeatures = false,
SelectNewFeatures = false
};
// initialize a list of ObjectIDs that need to be cut
var cutOIDs = new List <long>();
// for each of the layers
foreach (FeatureLayer editableFeatureLayer in editableLayers)
{
// find the features crossed by the sketch geometry
var rowCursor = editableFeatureLayer.Search(geometry, SpatialRelationship.Crosses);
// get the feature class associated with the layer
Table fc = editableFeatureLayer.GetTable();
// find the field index for the 'Description' attribute
int descriptionIndex = -1;
descriptionIndex = fc.GetDefinition().FindField("Description");
// add the feature IDs into our prepared list
while (rowCursor.MoveNext())
{
var feature = rowCursor.Current as Feature;
var geomTest = feature.GetShape();
if (geomTest != null)
{
// make sure we have the same projection for geomProjected and geomTest
var geomProjected = GeometryEngine.Instance.Project(geometry, geomTest.SpatialReference);
// we are looking for polygons are completely intersected by the cut line
if (GeometryEngine.Instance.Relate(geomProjected, geomTest, "TT*F*****"))
{
// add the current feature to the overall list of features to cut
cutOIDs.Add(rowCursor.Current.GetObjectID());
// adjust the attribute before the cut
if (descriptionIndex != -1)
{
cutOperation.Modify(rowCursor.Current, descriptionIndex, "Pro Sample");
}
}
}
}
// add the elements to cut into the edit operation
cutOperation.Cut(editableFeatureLayer, cutOIDs, geometry);
}
//execute the operation
var operationResult = cutOperation.Execute();
return(Task.FromResult(operationResult));
}
/// <summary>
/// Method to perform the cut operation on the geometry and change attributes
/// </summary>
/// <param name="geometry">Line geometry used to perform the cut against in the polygon features
/// in the active map view.</param>
/// <returns>If the cut operation was successful.</returns>
protected Task<bool> ExecuteCut(Geometry geometry)
{
if (geometry == null)
return Task.FromResult(false);
// create an edit operation
EditOperation cutOperation = new EditOperation();
cutOperation.Name = "Cut Elements";
cutOperation.ProgressMessage = "Working...";
cutOperation.CancelMessage = "Operation canceled.";
cutOperation.ErrorMessage = "Error cutting polygons";
cutOperation.SelectModifiedFeatures = false;
cutOperation.SelectNewFeatures = false;
// create a collection of feature layers that can be edited
var editableLayers = ActiveMapView.Map.GetLayersAsFlattenedList()
.OfType<FeatureLayer>()
.Where(lyr => lyr.CanEditData() == true).Where(lyr =>
lyr.ShapeType == esriGeometryType.esriGeometryPolygon);
// ensure that there are target layers
if (editableLayers.Count() == 0)
return Task.FromResult(false);
// initialize a list of ObjectIDs that need to be cut
var cutOIDs = new List<long>();
// for each of the layers
foreach (FeatureLayer editableFeatureLayer in editableLayers)
{
// find the features crossed by the sketch geometry
var rowCursor = editableFeatureLayer.Search(geometry, SpatialRelationship.Crosses);
// get the feature class associated with the layer
Table fc = editableFeatureLayer.GetTable();
// find the field index for the 'Description' attribute
int descriptionIndex = -1;
descriptionIndex = fc.GetDefinition().FindField("Description");
// add the feature IDs into our prepared list
while (rowCursor.MoveNext())
{
var feature = rowCursor.Current as Feature;
if (feature.GetShape() != null)
{
// we are looking for polygons are completely intersected by the cut line
if (GeometryEngine.Relate(geometry, feature.GetShape(), "TT*F*****"))
{
// add the current feature to the overall list of features to cut
cutOIDs.Add(rowCursor.Current.GetObjectID());
// adjust the attribute before the cut
if (descriptionIndex != -1)
cutOperation.Modify(rowCursor.Current, descriptionIndex, "Pro Sample");
}
}
}
// add the elements to cut into the edit operation
cutOperation.Cut(editableFeatureLayer, cutOIDs, geometry);
}
//execute the operation
var operationResult = cutOperation.Execute();
return Task.FromResult(operationResult);
}