ProGuide Construction Tools with Options - kataya/arcgis-pro-sdk GitHub Wiki

   public BufferedLineTool()
   {
     IsSketchTool = true;
     UseSnapping = true;
     // Select the type of construction tool you wish to implement.  
     // Make sure that the tool is correctly registered with the 
     // correct component category type in the daml 
     SketchType = SketchGeometryType.Line;
   }

   private double BufferDistance = 25.0;

   /// <summary>
   /// Called when the sketch finishes. This is where we will create the sketch 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 the buffered geometry
     Geometry bufferedGeometry = GeometryEngine.Instance.Buffer(geometry, BufferDistance);

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

     // Queue feature creation
     createOperation.Create(CurrentTemplate, bufferedGeometry);

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

internal class BufferedLineToolOptionsViewModel : EmbeddableControl, IEditingCreateToolControl
{
  ....

   #region IEditingCreateToolControl

   /// <summary>
   /// Gets the optional icon that will appear in the active template pane as a button selector.  
   /// If returning null then the Tool's small image that is defined in DAML will be used. 
   /// </summary>
   ImageSource IEditingCreateToolControl.ActiveTemplateSelectorIcon => null;

   private bool _isValid;
   /// <summary>
   /// Set this flag to indicate if too options are valid and ready for saving.
   /// </summary>
   /// <remarks>
   /// When this IEditingCreateToolControl is being displayed in the Template Properties
   /// dialog, calling code will use this property to determine if the current Template
   /// Properties may be saved.
   /// </remarks>
   bool IEditingCreateToolControl.IsValid => _isValid;

   private bool _isDirty;
   /// <summary>
   /// Set this flag when any tool options have been changed.
   /// </summary>
   /// <remaarks>
   /// When this IEditingCreateToolControl is being displayed in the Template Properties
   /// dialog, the calling code will use this property to determine if any changes have
   /// been made.  
   /// </remaarks>
   bool IEditingCreateToolControl.IsDirty => _isDirty;

   /// <summary>
   /// Gets if the contents of this control is auto-Opened in the Active Template Pane when the 
   /// tool is activated.
   /// </summary>
   /// <param name="toolID">the ID of the current tool</param>
   /// <returns>True the active template pane will be opened to the tool's options view.
   /// False, nothing in the active template pane changes when the tool is selected.</returns>
   bool IEditingCreateToolControl.AutoOpenActiveTemplatePane(string toolID)
   {
     return true;
   }

   /// <summary>
   /// Called just before ArcGIS.Desktop.Framework.Controls.EmbeddableControl.OpenAsync
   /// when this IEditingCreateToolControl is being used within the ActiveTemplate pane.
   /// </summary>
   /// <param name="options">tool options obtained from the template for the given toolID</param>
   /// <returns>true if the control is to be displayed in the ActiveTemplate pane.. False otherwise</returns>
   bool IEditingCreateToolControl.InitializeForActiveTemplate(ToolOptions options)
   {
     return true;
   }

   /// <summary>
   /// Called just before ArcGIS.Desktop.Framework.Controls.EmbeddableControl.OpenAsync
   /// when this IEditingCreateToolControl is being used within the Template Properties
   /// dialog
   /// </summary>
   /// <param name="options">tool options obtained from the template for the given toolID</param>
   /// <returns>true if the control is to be displayed in Template Properties. False otherwise</returns>
   bool IEditingCreateToolControl.InitializeForTemplateProperties(ToolOptions options)
   {
     return false;     // don't show the options in template properties
   }

   #endregion
}

   bool IEditingCreateToolControl.InitializeForActiveTemplate(ToolOptions options)
   {
     // assign the current options
     ToolOptions = options;
     // initialize the view
     InitializeOptions();
     return true;    // true <==> do show me in ActiveTemplate;   false <==> don't show me
   }

   internal const string BufferOptionName = "Buffer";
   internal const double DefaultBuffer = 25.0;

   private ToolOptions ToolOptions { get; set; }
   private void InitializeOptions()
   {
     // no options
     if (ToolOptions == null)
       return;

     // if buffer exists in options, retrieve it
     if (ToolOptions.ContainsKey(BufferOptionName))
       _buffer = (double)ToolOptions[BufferOptionName];
     else
     {
       // otherwise assign the default value and add to the ToolOptions dictionary
       _buffer = DefaultBuffer;
       ToolOptions.Add(BufferOptionName, _buffer);
       // ensure options are notified that changes have been made
       NotifyPropertyChanged(BufferOptionName);
     }
   }

   // binds in xaml
   private double _buffer;
   public double Buffer
   {
     get { return _buffer; }
     set
     {
       if (SetProperty(ref _buffer, value))
       {
         _isDirty = true;
         _isValid = true;
         // add/update the buffer value to the tool options
         if (!ToolOptions.ContainsKey(BufferOptionName))
           ToolOptions.Add(BufferOptionName, value);
         else
           ToolOptions[BufferOptionName] = value;
         // ensure options are notified
         NotifyPropertyChanged(BufferOptionName);
       }
     }
   }

    private ReadOnlyToolOptions ToolOptions => CurrentTemplate?.GetToolOptions(ID);

    private double BufferDistance
    {
      get
      {
        if (ToolOptions == null)
          return BufferedLineToolOptionsViewModel.DefaultBuffer;

        return ToolOptions.GetProperty(BufferedLineToolOptionsViewModel.BufferOptionName, BufferedLineToolOptionsViewModel.DefaultBuffer);
      }
    }