ProGuide Editing tool - Esri/arcgis-pro-sdk GitHub Wiki

// select the type of tool feedback you wish to implement.  
SketchType = SketchGeometryType.Line;
// a sketch feedback is needed
IsSketchTool = true;
// the geometry is needed in map coordinates
SketchOutputMode = ArcGIS.Desktop.Mapping.SketchOutputMode.Map;

protected override Task<bool> OnSketchCompleteAsync(Geometry geometry)
{
  return QueuedTask.Run(() => ExecuteCut(geometry));
}

protected Task<bool> ExecuteCut(Geometry geometry)
{
  return Task.FromResult(true);
}

  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)
  {
    // get the feature class associated with the layer
    var fc = editableFeatureLayer.GetTable();

    // find the field index for the 'Description' attribute
    int descriptionIndex = -1;
    descriptionIndex = fc.GetDefinition().FindField("Description");

    // find the features crossed by the sketch geometry
    //   use the featureClass to search. We need to be able to search with a recycling cursor
    //     seeing we want to Modify the row results
    // define a spatial query filter
    var spatialQueryFilter = new SpatialQueryFilter
    {
      // passing the search geometry to the spatial filter
      FilterGeometry = geometry,
      // define the spatial relationship between search geometry and feature class
      SpatialRelationship = SpatialRelationship.Crosses
    };

    using (var rowCursor = fc.Search(spatialQueryFilter, false))
    {
    }
  }

    using (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*****"))
        {
          var oid = feature.GetObjectID();

          // add the current feature to the overall list of features to cut
          cutOIDs.Add(oid);
        }
      }
    }

          // adjust the attribute before the cut
          if (descriptionIndex != -1)
          {
            var atts = new Dictionary<string, object>();
            atts.Add("Description", "Pro Sample");
            foreach (var oid in cutOIDs)
              cutOperation.Modify(editableFeatureLayer, oid, atts);
          }

          // add the elements to cut into the edit operation
          cutOperation.Split(editableFeatureLayer, cutOIDs, geometry);

  //execute the operation
  var operationResult = cutOperation.Execute();
  return Task.FromResult(operationResult);

  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)
    {
      // get the feature class associated with the layer
      var fc = editableFeatureLayer.GetTable();

      // find the field index for the 'Description' attribute
      int descriptionIndex = -1;
      descriptionIndex = fc.GetDefinition().FindField("Description");

      // find the features crossed by the sketch geometry
      //   use the featureClass to search. We need to be able to search with a recycling cursor
      //     seeing we want to Modify the row results
      // define a spatial query filter
      var spatialQueryFilter = new SpatialQueryFilter
      {
        // passing the search geometry to the spatial filter
        FilterGeometry = geometry,
        // define the spatial relationship between search geometry and feature class
        SpatialRelationship = SpatialRelationship.Crosses
      };

      using (var rowCursor = fc.Search(spatialQueryFilter, false))
      {
        // add the feature IDs into our prepared list
        while (rowCursor.MoveNext())
        {
          using (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*****"))
              {
                var oid = feature.GetObjectID();

                // add the current feature to the overall list of features to cut
                cutOIDs.Add(oid);
              }
            }
          }
        }

        // adjust the attribute before the cut
        if (descriptionIndex != -1)
        {
          var atts = new Dictionary<string, object>();
          atts.Add("Description", "Pro Sample");
          foreach (var oid in cutOIDs)
            cutOperation.Modify(editableFeatureLayer, oid, atts);
        }

        // add the elements to cut into the edit operation
        cutOperation.Split(editableFeatureLayer, cutOIDs, geometry);
      }

    }
    // execute the operation
    var operationResult = cutOperation.Execute();
    return Task.FromResult(operationResult);

  }

  protected override async Task<bool> OnSketchModifiedAsync()
  {
    // retrieve the current sketch geometry
    Polyline cutGeometry = await base.GetCurrentSketchAsync() as Polyline;

    await QueuedTask.Run(() =>
    {
      // if there are more than 2 vertices in the geometry
      if (cutGeometry.PointCount > 2)
      {
        // adjust the sketch symbol
        var symbolReference = base.SketchSymbol;
        if (symbolReference == null)
        {
          var cimLineSymbol = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.RedRGB, 
                    3, SimpleLineStyle.DashDotDot);
          base.SketchSymbol = cimLineSymbol.MakeSymbolReference();
        }
        else
        {
          symbolReference.Symbol.SetColor(ColorFactory.Instance.RedRGB);
          base.SketchSymbol = symbolReference;
        }
      }
    });

    return true;
  }

protected override bool Initialize()
{
  // subscribe to the completed edit operation event
  EditCompletedEvent.Subscribe(ReportNumberOfRowsChanged);

  return true;
}

  /// <summary>
  /// Method containing actions as the result of the EditCompleted (the operation) event.
  /// This method reports the total number of changed rows/features.
  /// </summary>
  /// <param name="editArgs">Argument containing the layers where edits occurred and what 
  /// types of changes.</param>
  /// <returns></returns>
  private Task<bool> ReportNumberOfRowsChanged(EditCompletedEventArgs editArgs)
  { 
     if (editArgs.CompletedType != EditCompletedType.Operation)
      return Task.FromResult(true); 

    // get the dictionary containing the modifies on the current feature 
    // operation 
    var editChanges = editArgs.Modifies;

    // use this variable to store the total number of modifies
    int countOfModifies = editChanges.Count;

    if (countOfModifies > 0)
      MessageBox.Show($"{countOfModifies.ToString()} features changed");
    else
      MessageBox.Show("The current edit operation did not contain any row/feature 
                         modification.");

    return Task.FromResult(true);
}