Implementing User Defined Objects With LEADTOOLS Annotations in Windows Forms

Implementing User-Defined Objects With LEADTOOLS Annotations in Windows Forms

• Start with the project created in Working with Automated Annotations in Windows Forms.

• The object being created is a simple object, a triangle. This object will have three points for the end points of the triangle and it will use a stroke for the triangle edges and a fill for the interior.

  Add a new C# class to your project and add the following code:

  C#
  // The Triangle annotation object 
  public class AnnTriangleObject : AnnPolylineObject 
  { 
     // The object ID, let us select a user defined value 
     public const int MyId = AnnObject.UserObjectId; 
                    
     public AnnTriangleObject() : 
        base() 
     { 
        // Set an ID 
        SetId(MyId); 
                    
        // We are a closed-figure 
        IsClosed = true; 
     } 
                    
     // Our friendly name 
     public override string FriendlyName 
     { 
        get 
        { 
           return "Triangle"; 
        } 
     } 
  } 
                    
       

• Since there are is no existing draw designer that can be used with our AnnTriangleObject class, we need to create our own:

  C#
  // Our draw designer 
  public class AnnTriangleDrawDesigner : AnnDrawDesigner 
  { 
     public AnnTriangleDrawDesigner(IAnnAutomationControl automationControl, AnnContainer container, AnnObject annObject) : 
        base(automationControl, container, annObject) 
     { 
     } 
                    
     // Override the Pointer Down event and add 3 points for our triangle 
     public override bool OnPointerDown(AnnContainer sender, AnnPointerEventArgs e) 
     { 
        // See if the base class wants to handle the event 
        bool handled = base.OnPointerDown(sender, e); 
        if (handled) 
           return true; 
                    
        // We will work on left button only 
        if (e.Button != AnnMouseButton.Left) 
           return false; 
                    
        // Get the current number of points in the object 
        AnnObject annObject = this.TargetObject; 
        int pointCount = annObject.Points.Count; 
                    
        if (pointCount < 3) 
        { 
           // Add the current point 
           annObject.Points.Add(e.Location); 
                   
          // If we had 0 points, then add another one. When we move the pointer, we will 
          // move the last point (second in this case) 
          if (pointCount == 0) 
             annObject.Points.Add(e.Location); 
                   
          if (pointCount == 0) 
          { 
             if (!this.StartWorking()) 
                return true; 
          } 
       } 
       else 
       { 
          // We have 3 points, we are finished 
          this.EndWorking(); 
       } 
                   
       return true; 
    } 
                   
    // Override the Pointer Move event 
    public override bool OnPointerMove(AnnContainer sender, AnnPointerEventArgs e) 
    { 
       bool handled = base.OnPointerMove(sender, e); 
                   
       // See if we are have points 
       // Yes, move the last point in the object to this new location 
       AnnObject annObject = this.TargetObject; 
                   
       if (annObject.Points.Count > 0) 
       { 
          annObject.Points[annObject.Points.Count - 1] = e.Location; 
          Working(); 
          return true; 
       } 
                   
       return false; 
    } 
                   
    public override bool OnPointerUp(AnnContainer sender, AnnPointerEventArgs e) 
    { 
       base.OnPointerUp(sender, e); 
       return true; 
    } 
  } 
                    
       

• Next, we need to add the automation object for the Triangle:

  C#
  private static void InitializeTriangleObject(AnnAutomationManagerHelper annotations) 
  { 
     // Create a new automation object 
     AnnAutomationObject automationObj = new AnnAutomationObject(); 
                    
     // Set the object ID 
     automationObj.Id = AnnTriangleObject.MyId; 
     automationObj.Name = "Triangle"; 
     // Set its designers 
     automationObj.DrawDesignerType = typeof(AnnTriangleDrawDesigner); 
     automationObj.EditDesignerType = typeof(AnnPolylineEditDesigner); 
     automationObj.RunDesignerType = typeof(AnnRunDesigner); 
                    
     // Set the template 
     AnnTriangleObject annObj = new AnnTriangleObject(); 
     // Set our default stroke 
     annObj.Stroke = AnnStroke.Create(AnnSolidColorBrush.Create("red"), LeadLengthD.Create(2)); 
     annObj.Fill = AnnSolidColorBrush.Create("yellow"); 
     automationObj.ObjectTemplate = annObj; 
                    
     // Set our renderer, same as the AnnPolylineObject 
     IAnnObjectRenderer polylineRenderer = annotations.AutomationManager.RenderingEngine.Renderers[AnnObject.PolylineObjectId]; 
                    
     IAnnObjectRenderer renderer = new AnnPolylineObjectRenderer(); 
     renderer.LabelRenderer = polylineRenderer.LabelRenderer; 
     renderer.LocationsThumbStyle = polylineRenderer.LocationsThumbStyle; 
     renderer.RotateGripperThumbStyle = polylineRenderer.RotateGripperThumbStyle; 
     renderer.RotateCenterThumbStyle = polylineRenderer.RotateCenterThumbStyle; 
     annotations.AutomationManager.RenderingEngine.Renderers[AnnTriangleObject.MyId] = renderer; 
                    
     // Set its context menu and toolbar image 
                    
     AnnAutomationObjectExtData extData = new AnnAutomationObjectExtData(); 
     extData.ContextMenu = new Leadtools.Annotations.WinForms.ObjectContextMenu(); 
     extData.DrawCursor = Cursors.Cross; 
                    
     Bitmap bitmap = new Bitmap(24, 24, System.Drawing.Imaging.PixelFormat.Format32bppArgb); 
     using (Graphics g = Graphics.FromImage(bitmap)) 
     { 
        g.Clear(Color.Transparent); 
        g.DrawLine(Pens.Black, 12, 2, 22, 22); 
        g.DrawLine(Pens.Black, 22, 22, 2, 22); 
        g.DrawLine(Pens.Black, 2, 22, 12, 2); 
     } 
                    
     extData.ToolBarImage = bitmap; 
     extData.ToolBarToolTipText = "Triangle"; 
                    
     automationObj.UserData = extData; 
                    
     annotations.AutomationManager.Objects.Add(automationObj); 
  } 
                    
       

• And finally, modify the original code like this:

  C#
  // Create the helper 
  _annotations = new AnnAutomationManagerHelper(automationManager); 
                    
  // -------------------------- 
  // Create our triangle automation object 
  InitializeTriangleObject(_annotations); 
  // -------------------------- 
                    
  // Create the toolbar and add it to our form 
  _annotations.CreateToolBar(); 
  ToolBar toolBar = _annotations.ToolBar; 
                    
       

• Build and run the demo. Now you can click the triangle toolbar icon and draw instance of the new object.