ProGuide Annotation Construction Tools - Esri/arcgis-pro-sdk GitHub Wiki

public AnnoSimpleConstructionTool()
{
  IsSketchTool = true;
  UseSnapping = true;
  // set the sketch type to point
  SketchType = SketchGeometryType.Point;
  //Gets or sets whether the sketch is for creating a feature and should use the CurrentTemplate.
  UsesCurrentTemplate = true;
  //Gets or sets whether the tool supports firing sketch events when the map sketch changes. 
  //Default value is false.
  FireSketchEvents = true;
}

/// <summary>
/// Called when the sketch finishes. This is where we will create the edit  operation and 
/// then execute it.</summary>
/// <param name="geometry">The geometry created by the sketch.</param>
/// <returns>A Task returning a Boolean indicating if the sketch complete event was 
/// successfully handled.</returns>
protected override Task<bool> OnSketchCompleteAsync(Geometry geometry)
{
  if (CurrentTemplate == null || geometry == null)
    return Task.FromResult(false); 

  // Create an edit operation
  var createOperation = new EditOperation();
  createOperation.Name = string.Format("Create {0}", CurrentTemplate.Layer.Name);
  createOperation.SelectNewFeatures = true;

  // pass the point geometry to the Create method
  createOperation.Create(CurrentTemplate, geometry);

  // Execute the operation
  return createOperation.ExecuteAsync();
}

    public AnnoAdvancedConstructionTool()
    {
      IsSketchTool = true;
      UseSnapping = true;
      // set the sketch type to line
      SketchType = SketchGeometryType.Line;
      UsesCurrentTemplate = true;
      FireSketchEvents = true;
    }

protected override async Task<bool> OnSketchModifiedAsync()
{
   // restrict the sketch to a 2 point line
   bool finish = await QueuedTask.Run(async () =>
   {
     // get the current sketch
     var geometry = await base.GetCurrentSketchAsync();
     // cast to a polyline
     var geom = geometry as ArcGIS.Core.Geometry.Polyline;
     // check the point count
     return geom?.PointCount >= 2;
   });

   // call FinishSketchAsync if we have 2 points
   if (finish)
     finish = await base.FinishSketchAsync();

   return finish;
}

   bool result = await QueuedTask.Run(() =>
   {
     // get the anno layer
     AnnotationLayer annoLayer = CurrentTemplate.Layer as AnnotationLayer;
     if (annoLayer == null)
       return false;

     // get the anno feature class
     var fc = annoLayer.GetFeatureClass() as 
                       ArcGIS.Core.Data.Mapping.AnnotationFeatureClass;
     if (fc == null)
       return false;

     // get the featureclass CIM definition which contains the labels, symbols
     var cimDefinition = fc.GetDefinition() as 
                        ArcGIS.Core.Data.Mapping.AnnotationFeatureClassDefinition;
     var labels = cimDefinition.GetLabelClassCollection();
     var symbols = cimDefinition.GetSymbolCollection();

     // make sure there are labels, symbols
     if ((labels.Count == 0) || (symbols.Count == 0))
       return false;
   });

   bool result = await QueuedTask.Run(() =>
   {
       ....

     // find the label class required
     //   typically you would use a subtype name or some other characteristic

     // use the first label class
     var label = labels[0];
     if (labels.Count > 1)
     {
       // find a label class based on template name 
       foreach (var LabelClass in labels)
       {
         if (LabelClass.Name == CurrentTemplate.Name)
         {
           label = LabelClass;
           break;
         }
       }
     }

     // each label has a textSymbol
     // the symbolName *should* be the symbolID to be used
     var symbolName = label.TextSymbol.SymbolName;
     int symbolID = -1;
     if (!int.TryParse(symbolName, out symbolID))
     {
       // int.TryParse fails - attempt to find the symbolName in the symbol collection
       foreach (var symbol in symbols)
       {
         if (symbol.Name == symbolName)
         {
           symbolID = symbol.ID;
           break;
         }
       }
     }
     // no symbol?
     if (symbolID == -1)
       return false;

   });

   // use the template's inspector object
   var inspector = CurrentTemplate.Inspector;

   // AnnotationClassID, SymbolID and Shape are the bare minimum for an annotation 
   // feature

   // use the inspector[fieldName] to set the annotationClassid
   // this is allowed since annotationClassID is a guaranteed field in the 
   // annotation schema
   inspector["AnnotationClassID"] = label.ID;
   // set the symbolID too
   inspector["SymbolID"] = symbolID;

   // get the annotation properties
   var annoProperties = inspector.GetAnnotationProperties();
                                               
   // use the annotation properties to set the other attributes
   annoProperties.TextString = "My annotation feature";
   annoProperties.Color = ColorFactory.Instance.GreenRGB;
   annoProperties.VerticalAlignment = ArcGIS.Core.CIM.VerticalAlignment.Top;
   annoProperties.Underline = true;

   // set the geometry to be the sketched line
   // when creating annotation features the shape to be passed 
   //    in the create operation is the CIMTextGraphic shape
   annoProperties.Shape = geometry;

   // set the annotation properties back on the inspector
   inspector.SetAnnotationProperties(annoProperties);

   // Create an edit operation
   var createOperation = new EditOperation();
   createOperation.Name = string.Format("Create {0}", CurrentTemplate.Layer.Name);
   createOperation.SelectNewFeatures = true;

   // create and execute using the inspector
   createOperation.Create(CurrentTemplate.Layer, inspector);
   return createOperation.Execute();

/// <summary>
/// Called when the sketch finishes. This is where we will create the edit operation and 
/// then execute it.</summary>
/// <param name="geometry">The geometry created by the sketch.</param>
/// <returns>A Task returning a Boolean indicating if the sketch complete event was 
/// successfully handled.</returns>
protected override async Task<bool> OnSketchCompleteAsync(Geometry geometry)
{
  if (CurrentTemplate == null || geometry == null)
    return false;

  bool result = await QueuedTask.Run(() =>
  {
    // get the anno layer
    AnnotationLayer annoLayer = CurrentTemplate.Layer as AnnotationLayer;
    if (annoLayer == null)
      return false;

    // get the anno feature class
    var fc = annoLayer.GetFeatureClass() 
                as ArcGIS.Core.Data.Mapping.AnnotationFeatureClass;
    if (fc == null)
      return false;

    // get the featureclass CIM definition which contains the labels, symbols
    var cimDefinition = fc.GetDefinition() as 
                  ArcGIS.Core.Data.Mapping.AnnotationFeatureClassDefinition;
    var labels = cimDefinition.GetLabelClassCollection();
    var symbols = cimDefinition.GetSymbolCollection();

   // make sure there are labels, symbols
   if ((labels.Count == 0) || (symbols.Count == 0))
     return false;

   // find the label class required
   //   typically you would use a subtype name or some other characteristic

   // use the first label class
   var label = labels[0];
   if (labels.Count > 1)
   {
     // find a label class based on template name 
     foreach (var LabelClass in labels)
     {
       if (LabelClass.Name == CurrentTemplate.Name)
       {
         label = LabelClass;
         break;
       }
     }
   }

   // each label has a textSymbol
   // the symbolName *should* be the symbolID to be used
   var symbolName = label.TextSymbol.SymbolName;
   int symbolID = -1;
   if (!int.TryParse(symbolName, out symbolID))
   {
     // int.TryParse fails - attempt to find the symbolName in the symbol collection
     foreach (var symbol in symbols)
     {
       if (symbol.Name == symbolName)
       {
         symbolID = symbol.ID;
         break;
       }
     }
   }
   // no symbol?
   if (symbolID == -1)
     return false;

   // use the template's inspector object
   var inspector = CurrentTemplate.Inspector;

   // AnnotationClassID, SymbolID and Shape are the bare minimum for an 
   // annotation feature

   // use the inspector[fieldName] to set the annotationClassid
   //   this is allowed since annotationClassID is a guaranteed field in the 
   //   annotation schema
   inspector["AnnotationClassID"] = label.ID;
   // set the symbolID too
   inspector["SymbolID"] = symbolID;

   // get the annotation properties
   var annoProperties = inspector.GetAnnotationProperties();

   // use the annotation properties to set the other attributes
   annoProperties.TextString = "My annotation feature";
   annoProperties.Color = ColorFactory.Instance.GreenRGB;
   annoProperties.VerticalAlignment = ArcGIS.Core.CIM.VerticalAlignment.Top;
   annoProperties.Underline = true;

   // set the geometry to be the sketched line
   // when creating annotation features the shape to be passed 
   //    in the create operation is the CIMTextGraphic shape
   annoProperties.Shape = geometry;

   // set the annotation properties back on the inspector
   inspector.SetAnnotationProperties(annoProperties);

   // Create an edit operation
   var createOperation = new EditOperation();
   createOperation.Name = string.Format("Create {0}", CurrentTemplate.Layer.Name);
   createOperation.SelectNewFeatures = true;

   // create and execute using the inspector
   createOperation.Create(CurrentTemplate.Layer, inspector);
   return createOperation.Execute();
  });

  return result;
}