ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Desktop.Layouts Namespace / ElementFactory Class / Instance Property
Example

In This Topic
    Instance Property (ElementFactory)
    In This Topic
    Provides access to helper functions that create layout elements.
    Syntax
    public static IElementFactory Instance {get;}
    Public Shared ReadOnly Property Instance As IElementFactory
    Example
    Get Graphic Outline from Graphic Element
    {
      //given a graphic, extract its outline geometry
      var graphic_elem = layout.GetElementsAsFlattenedList().OfType<GraphicElement>()?.FirstOrDefault();
      if (graphic_elem != null)//can be point, line, poly, or text
      {
        return;
      }
    
      var outline = GraphicFactory.Instance.GetGraphicOutline(layout, graphic_elem.GetGraphic());
      //create an element using the outline
      var elem = ElementFactory.Instance.CreateGraphicElement(layout, outline);
      //... etc.
    }
    Create Ellipse Graphic Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D center = new Coordinate2D(2, 2.75);
      var eabElp = new EllipticArcBuilderEx(center, 0, 1, 0.45,
                                          ArcOrientation.ArcClockwise);
      var ellipse = eabElp.ToSegment();
    
      //Set symbology, create and add element to layout
      CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
                                      ColorFactory.Instance.GreenRGB, 2.0,
                              SimpleLineStyle.Dot);
      CIMPolygonSymbol ellipseSym = SymbolFactory.Instance.ConstructPolygonSymbol(
                                ColorFactory.Instance.GreyRGB, SimpleFillStyle.Vertical,
                                                        outline);
    
      var poly = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(ellipse, AttributeFlags.AllAttributes));
    
      var elpElm = ElementFactory.Instance.CreateGraphicElement(
        layout, poly, ellipseSym, "New Ellipse");
      });
    }
    Create Lasso Line, Freehand Graphic Element
    {
      await QueuedTask.Run(() =>
      {
      //Build geometry
      List<Coordinate2D> plCoords = new List<Coordinate2D>();
      plCoords.Add(new Coordinate2D(1.5, 10.5));
      plCoords.Add(new Coordinate2D(1.25, 9.5));
      plCoords.Add(new Coordinate2D(1, 10.5));
      plCoords.Add(new Coordinate2D(0.75, 9.5));
      plCoords.Add(new Coordinate2D(0.5, 10.5));
      plCoords.Add(new Coordinate2D(0.5, 1));
      plCoords.Add(new Coordinate2D(0.75, 2));
      plCoords.Add(new Coordinate2D(1, 1));
      Polyline linePl = PolylineBuilderEx.CreatePolyline(plCoords);
    
      //Set symbology, create and add element to layout
      CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(
                ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid);
      //var graphic = GraphicFactory.Instance.CreateShapeGraphic(linePl, lineSym);
    
      var ge = ElementFactory.Instance.CreateGraphicElement(
                              layout, linePl, lineSym, "New Freehand");
      });
    }
    Create Lasso Polygon, Freehand Element
    {
      await QueuedTask.Run(() =>
      {
    
      List<Coordinate2D> plyCoords = new List<Coordinate2D>();
      plyCoords.Add(new Coordinate2D(1, 1));
      plyCoords.Add(new Coordinate2D(1.25, 2));
      plyCoords.Add(new Coordinate2D(1.5, 1.1));
      plyCoords.Add(new Coordinate2D(1.75, 2));
      plyCoords.Add(new Coordinate2D(2, 1.1));
      plyCoords.Add(new Coordinate2D(2.25, 2));
      plyCoords.Add(new Coordinate2D(2.5, 1.1));
      plyCoords.Add(new Coordinate2D(2.75, 2));
      plyCoords.Add(new Coordinate2D(3, 1));
      Polygon poly = PolygonBuilderEx.CreatePolygon(plyCoords);
    
      //Set symbology, create and add element to layout
      CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
                  ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Solid);
      CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
               ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
    
      ElementFactory.Instance.CreateGraphicElement(
        layout, poly, polySym, "New Lasso");
      });
    }
    Create Line Element
    {
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      List<Coordinate2D> plCoords = new List<Coordinate2D>();
      plCoords.Add(new Coordinate2D(1, 8.5));
      plCoords.Add(new Coordinate2D(1.66, 9));
      plCoords.Add(new Coordinate2D(2.33, 8.1));
      plCoords.Add(new Coordinate2D(3, 8.5));
      Polyline linePl = PolylineBuilderEx.CreatePolyline(plCoords);
    
      //Reference a line symbol in a style
      var ProjectStyles = project.GetItems<StyleProjectItem>();
      StyleProjectItem style = ProjectStyles.First(x => x.Name == "ArcGIS 2D");
      var symStyle = style.SearchSymbols(StyleItemType.LineSymbol, "Line with 2 Markers")[0];
      CIMLineSymbol lineSym = symStyle.Symbol as CIMLineSymbol;
      lineSym.SetSize(20);
    
      //Set symbology, create and add element to layout
      //CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(ColorFactory.Instance.BlueRGB, 4.0, SimpleLineStyle.Solid);
      ElementFactory.Instance.CreateGraphicElement(
        layout, linePl, lineSym, "New Line");
      });
    }
    Create Point Element
    {
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D coord2D = new Coordinate2D(2.0, 10.0);
    
      //Reference a point symbol in a style
      StyleProjectItem stylePrjItm = project.GetItems<StyleProjectItem>()
                .FirstOrDefault(item => item.Name == "ArcGIS 2D");
      SymbolStyleItem symStyleItm = stylePrjItm.SearchSymbols(
                            StyleItemType.PointSymbol, "City Hall")[0];
      CIMPointSymbol pointSym = symStyleItm.Symbol as CIMPointSymbol;
      pointSym.SetSize(50);
    
      var elemInfo = new ElementInfo()
      {
        CustomProperties = new List<CIMStringMap>() {
        new CIMStringMap() { Key = "Key1", Value = "Value1"},
        new CIMStringMap() { Key = "Key2", Value = "Value2"}
      },
        Anchor = Anchor.TopRightCorner,
        Rotation = 45.0
      };
    
      var graphic = GraphicFactory.Instance.CreateSimpleGraphic(
                                    coord2D.ToMapPoint(), pointSym);
    
      ElementFactory.Instance.CreateGraphicElement(
        layout, graphic, "New Point", true, elemInfo);
      });
    }
    Create Polygon Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      List<Coordinate2D> plyCoords = new List<Coordinate2D>();
      plyCoords.Add(new Coordinate2D(1, 7));
      plyCoords.Add(new Coordinate2D(2, 7));
      plyCoords.Add(new Coordinate2D(2, 6.7));
      plyCoords.Add(new Coordinate2D(3, 6.7));
      plyCoords.Add(new Coordinate2D(3, 6.1));
      plyCoords.Add(new Coordinate2D(1, 6.1));
      Polygon poly = PolygonBuilderEx.CreatePolygon(plyCoords);
    
      //Set symbology, create and add element to layout
      CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
        ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.DashDotDot);
      CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
        ColorFactory.Instance.RedRGB, SimpleFillStyle.ForwardDiagonal, outline);
    
      ElementFactory.Instance.CreateGraphicElement(
        layout, poly, polySym, "New Polygon", false);
      });
    }
    Create Rectangle Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(1.0, 4.75);
      Coordinate2D ur = new Coordinate2D(3.0, 5.75);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Set symbology, create and add element to layout
      CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
        ColorFactory.Instance.BlackRGB, 5.0, SimpleLineStyle.Solid);
      CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
        ColorFactory.Instance.GreenRGB, SimpleFillStyle.DiagonalCross, outline);
    
      var ge = GraphicFactory.Instance.CreateSimpleGraphic(env, polySym);
      var elemInfo = new ElementInfo()
      {
        Anchor = Anchor.CenterPoint,
        Rotation = 45.0,
        CornerRounding = 5.0
      };
    
      ElementFactory.Instance.CreateGraphicElement(
        layout, env, polySym, "New Rectangle", false, elemInfo);
      });
    }
    Create Bezier Curve Element
    {
      await QueuedTask.Run(() =>
      {
      //Build geometry
      Coordinate2D pt1 = new Coordinate2D(1, 7.5);
      Coordinate2D pt2 = new Coordinate2D(1.66, 8);
      Coordinate2D pt3 = new Coordinate2D(2.33, 7.1);
      Coordinate2D pt4 = new Coordinate2D(3, 7.5);
      var bez = new CubicBezierBuilderEx(pt1, pt2, pt3, pt4);
      var bezSeg = bez.ToSegment();
      Polyline bezPl = PolylineBuilderEx.CreatePolyline(bezSeg, AttributeFlags.AllAttributes);
    
      //Set symbology, create and add element to layout
      CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(
        ColorFactory.Instance.RedRGB, 4.0, SimpleLineStyle.DashDot);
    
      ElementFactory.Instance.CreateGraphicElement(layout, bezPl, lineSym, "New Bezier");
      });
    }
    Create Graphic Elements
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      List<Coordinate2D> plyCoords = new List<Coordinate2D>();
      plyCoords.Add(new Coordinate2D(1, 7));
      plyCoords.Add(new Coordinate2D(2, 7));
      plyCoords.Add(new Coordinate2D(2, 6.7));
      plyCoords.Add(new Coordinate2D(3, 6.7));
      plyCoords.Add(new Coordinate2D(3, 6.1));
      plyCoords.Add(new Coordinate2D(1, 6.1));
      Polygon poly = PolygonBuilderEx.CreatePolygon(plyCoords);
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(1.0, 4.75);
      Coordinate2D ur = new Coordinate2D(3.0, 5.75);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Build geometry
      Coordinate2D coord2D = new Coordinate2D(2.0, 10.0);
    
      var g1 = GraphicFactory.Instance.CreateSimpleGraphic(poly);
      var g2 = GraphicFactory.Instance.CreateSimpleGraphic(env);
      var g3 = GraphicFactory.Instance.CreateSimpleGraphic(coord2D.ToMapPoint());
    
      var ge = ElementFactory.Instance.CreateGraphicElements(
        layout, new List<CIMGraphic>() { g1, g2, g3 },
        new List<string>() { "Poly", "Envelope", "MapPoint" },
        true);
      });
    }
    Create Graphic Element using CIMGraphic
    {
      await QueuedTask.Run(() =>
      {
      //Place symbol on the layout
      MapPoint location = MapPointBuilderEx.CreateMapPoint(new Coordinate2D(9, 1));
    
      //specify a symbol
      var pt_symbol = SymbolFactory.Instance.ConstructPointSymbol(
                            ColorFactory.Instance.GreenRGB);
    
      //create a CIMGraphic
      var graphic = new CIMPointGraphic()
      {
        Symbol = pt_symbol.MakeSymbolReference(),
        Location = location //center of map
      };
      //Or use GraphicFactory
      var graphicFactory = GraphicFactory.Instance.CreateSimpleGraphic(location, pt_symbol);
    
      ElementFactory.Instance.CreateGraphicElement(layout, graphic);
      ElementFactory.Instance.CreateGraphicElement(layout, graphicFactory);
      });
    }
    Create Graphic Element using CIMSymbol
    {
      await QueuedTask.Run(() =>
      {
      //Place symbol on the layout
      MapPoint location = MapPointBuilderEx.CreateMapPoint(new Coordinate2D(9, 1));
    
      //specify a symbol
      var pt_symbol = SymbolFactory.Instance.ConstructPointSymbol(
                            ColorFactory.Instance.GreenRGB);
    
      ElementFactory.Instance.CreateGraphicElement(layout, location, pt_symbol);
      });
    }
    Bulk Element creation
    {
      await QueuedTask.Run(() =>
      {
    
      //List of Point graphics
      var listGraphics = new List<CIMPointGraphic>();
      var listGraphicsFactory = new List<CIMPointGraphic>();
      //Symbol
      var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(
                                          ColorFactory.Instance.BlackRGB);
      //Define size of the array
      int dx = 5;
      int dy = 5;
      MapPoint point = null;
      //Create the List of graphics for the array
      for (int row = 0; row <= dx; ++row)
      {
        for (int col = 0; col <= dy; ++col)
        {
          point = MapPointBuilderEx.CreateMapPoint(col, row);
          //create a CIMGraphic
          var graphic = new CIMPointGraphic()
          {
            Symbol = pointSymbol.MakeSymbolReference(),
            Location = point
          };
          listGraphics.Add(graphic);
          //Or use GraphicFactory
          var graphicFactory = GraphicFactory.Instance.CreateSimpleGraphic(
                                        point, pointSymbol) as CIMPointGraphic;
          listGraphicsFactory.Add(graphicFactory);
        }
      }
      //Draw the array of graphics
    
      var bulkgraphics = ElementFactory.Instance.CreateGraphicElements(
                                                         layout, listGraphics);
      var bulkgraphicsFactory = ElementFactory.Instance.CreateGraphicElements(
                                                         layout, listGraphicsFactory);
      });
    }
    Create Element using a CIMGraphicElement
    {
      await QueuedTask.Run(() =>
      {
    
      //Place symbol on the layout
      MapPoint point = MapPointBuilderEx.CreateMapPoint(new Coordinate2D(9, 1));
    
      //specify a symbol
      var pt_symbol = SymbolFactory.Instance.ConstructPointSymbol(
                            ColorFactory.Instance.GreenRGB);
    
      //create a CIMGraphic
      var graphic = new CIMGraphicElement()
      {
        Graphic = new CIMPointGraphic()
        {
          Symbol = pt_symbol.MakeSymbolReference(),
          Location = point //A point in the layout
        }
      };
      ElementFactory.Instance.CreateElement(layout, graphic);
      });
    }
    Create point graphic with symbology
    {
      //Create a simple 2D point graphic and apply an existing point style item as the symbology.
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
      //Build 2D point geometry
      Coordinate2D coord2D = new Coordinate2D(2.0, 10.0);
    
      //(optionally) Reference a point symbol in a style
      StyleProjectItem ptStylePrjItm = project.GetItems<StyleProjectItem>()
                                    .FirstOrDefault(item => item.Name == "ArcGIS 2D");
      SymbolStyleItem ptSymStyleItm = ptStylePrjItm.SearchSymbols(
                                             StyleItemType.PointSymbol, "City Hall")[0];
      CIMPointSymbol pointSym = ptSymStyleItm.Symbol as CIMPointSymbol;
      pointSym.SetSize(50);
    
      //Set symbology, create and add element to layout
    
      //An alternative simple symbol is also commented out below.
      //This would eliminate the four optional lines of code above that
      //reference a style.
      //CIMPointSymbol pointSym = SymbolFactory.Instance.ConstructPointSymbol(
      //                  ColorFactory.Instance.RedRGB, 25.0, SimpleMarkerStyle.Star);
    
      GraphicElement ptElm = ElementFactory.Instance.CreateGraphicElement(
                                     layout, coord2D.ToMapPoint(), pointSym);
      ptElm.SetName("New Point");
      });
    }
    Create line graphic with symbology
    {
      //Create a simple 2D line graphic and apply an existing line
      //style item as the symbology.
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
      //Build 2d line geometry
      List<Coordinate2D> plCoords = new List<Coordinate2D>();
      plCoords.Add(new Coordinate2D(1, 8.5));
      plCoords.Add(new Coordinate2D(1.66, 9));
      plCoords.Add(new Coordinate2D(2.33, 8.1));
      plCoords.Add(new Coordinate2D(3, 8.5));
    
      Polyline linePl = PolylineBuilderEx.CreatePolyline(plCoords);
    
      //(optionally) Reference a line symbol in a style
      StyleProjectItem lnStylePrjItm = project.GetItems<StyleProjectItem>()
                                    .FirstOrDefault(item => item.Name == "ArcGIS 2D");
      SymbolStyleItem lnSymStyleItm = lnStylePrjItm.SearchSymbols(
                                    StyleItemType.LineSymbol, "Line with 2 Markers")[0];
      CIMLineSymbol lineSym = lnSymStyleItm.Symbol as CIMLineSymbol;
      lineSym.SetSize(20);
    
      //Set symbology, create and add element to layout
    
      //An alternative simple symbol is also commented out below.
      //This would eliminate the four optional lines of code above that
      //reference a style.
      //
      //CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(
      //         ColorFactory.Instance.BlueRGB, 4.0, SimpleLineStyle.Solid);
    
    
      GraphicElement lineElm = ElementFactory.Instance.CreateGraphicElement(
                                                  layout, linePl, lineSym);
      lineElm.SetName("New Line");
      });
    }
    Create rectangle graphic with simple symbology
    {
      //Create a simple 2D rectangle graphic and apply simple fill and
      //outline symbols.
    
      await QueuedTask.Run(() =>
      {
    
      //Build 2D envelope geometry
      Coordinate2D rec_ll = new Coordinate2D(1.0, 4.75);
      Coordinate2D rec_ur = new Coordinate2D(3.0, 5.75);
    
      Envelope rec_env = EnvelopeBuilderEx.CreateEnvelope(rec_ll, rec_ur);
    
      //Set symbology, create and add element to layout
      CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
        ColorFactory.Instance.BlackRGB, 5.0, SimpleLineStyle.Solid);
      CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
        ColorFactory.Instance.GreenRGB, SimpleFillStyle.DiagonalCross, outline);
    
    
      GraphicElement recElm = ElementFactory.Instance.CreateGraphicElement(
        layout, rec_env, polySym, "New Rectangle");
      //Or use Predefined shape
      GraphicElement recElm2 = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
                                layout, PredefinedShape.Rectangle, rec_env, polySym,
                                "New Rectangle2");
      });
    }
    Create Point Text Element 1
    {
      //Create a simple point text element and assign basic symbology and text settings.
    
      await QueuedTask.Run(() =>
      {
      //Build 2D point geometry
      Coordinate2D coord2D = new Coordinate2D(3.5, 10);
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                    ColorFactory.Instance.RedRGB, 32, "Arial", "Regular");
      string textString = "Point text";
    
      //use ElementInfo to set placement properties during create
      var elemInfo = new ElementInfo()
      {
        Anchor = Anchor.CenterPoint,
        Rotation = 45
      };
      var ptTxtElm = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PointText, coord2D.ToMapPoint(), sym, textString,
                           "New Point Text", true, elemInfo);
    
      //Change additional text properties
      ptTxtElm.SetX(4.5);
      ptTxtElm.SetY(9.5);
      });
    }
    Create Rectangle Paragraph Text Element 1
    {
      await QueuedTask.Run(() =>
      {
      //Create rectangle text with background and border symbology.
      //Build 2D polygon geometry
      List<Coordinate2D> plyCoords = new List<Coordinate2D>();
      plyCoords.Add(new Coordinate2D(3.5, 7));
      plyCoords.Add(new Coordinate2D(4.5, 7));
      plyCoords.Add(new Coordinate2D(4.5, 6.7));
      plyCoords.Add(new Coordinate2D(5.5, 6.7));
      plyCoords.Add(new Coordinate2D(5.5, 6.1));
      plyCoords.Add(new Coordinate2D(3.5, 6.1));
      Polygon poly = PolygonBuilderEx.CreatePolygon(plyCoords);
    
      //Set symbology, create and add element to layout
      //Also notice how formatting tags are using within the text string.
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                        ColorFactory.Instance.GreyRGB, 10, "Arial", "Regular");
      string text = "Some Text String that is really long and is " +
                    "<BOL>forced to wrap to other lines</BOL> so that " +
                    "we can see the effects." as String;
    
      GraphicElement polyTxtElm = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.RectangleParagraph, poly, sym, text, "Polygon Paragraph");
    
      //(Optionally) Modify paragraph border
      CIMGraphic polyTxtGra = polyTxtElm.GetGraphic();
      CIMParagraphTextGraphic cimPolyTxtGra = polyTxtGra as CIMParagraphTextGraphic;
      cimPolyTxtGra.Frame.BorderSymbol = new CIMSymbolReference();
      cimPolyTxtGra.Frame.BorderSymbol.Symbol =
                   SymbolFactory.Instance.ConstructLineSymbol(
                              ColorFactory.Instance.GreyRGB, 1.0, SimpleLineStyle.Solid);
      polyTxtElm.SetGraphic(polyTxtGra);
      });
    }
    Create a Dynamic Point Text Element
    {
      //Create a dynamic text element.
    
      //Set the string with tags and the location
      String title = @"<dyn type = ""page"" property = ""name"" />";
      Coordinate2D llTitle = new Coordinate2D(6, 2.5);
      //Create with default text properties
      await QueuedTask.Run(() =>
      {
        TextElement titleGraphics = ElementFactory.Instance.CreateTextGraphicElement(
                        layout, TextType.PointText, llTitle.ToMapPoint(), null, title) as TextElement;
    
        //Modify the text properties
        titleGraphics.SetTextProperties(new TextProperties(title, "Arial", 24, "Bold"));
      });
    }
    Create Point Text Element 2
    {
      await QueuedTask.Run(() =>
      {
      //Build geometry
      Coordinate2D coord2D = new Coordinate2D(3.5, 10);
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
        ColorFactory.Instance.RedRGB, 32, "Arial", "Regular");
      string textString = "Point text";
    
      var elemInfo = new ElementInfo() { Anchor = Anchor.BottomLeftCorner };
      GraphicElement ptTxtElm = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PointText, coord2D.ToMapPoint(), sym, textString,
        "New Point Text", true, elemInfo);
      });
    }
    Create Polygon Paragraph Text Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      List<Coordinate2D> plyCoords = new List<Coordinate2D>();
      plyCoords.Add(new Coordinate2D(3.5, 7));
      plyCoords.Add(new Coordinate2D(4.5, 7));
      plyCoords.Add(new Coordinate2D(4.5, 6.7));
      plyCoords.Add(new Coordinate2D(5.5, 6.7));
      plyCoords.Add(new Coordinate2D(5.5, 6.1));
      plyCoords.Add(new Coordinate2D(3.5, 6.1));
      Polygon poly = PolygonBuilderEx.CreatePolygon(plyCoords);
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
           ColorFactory.Instance.GreyRGB, 10, "Arial", "Regular");
      string text = "Some text string that is really long and " +
                    "<BOL>wraps to other lines</BOL>" +
                    " so that we can see the effects.";
    
      var ge = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PolygonParagraph, poly, sym, text,
              "New Polygon Text", true);
            });
    }
    Create Rectangle Paragraph Text Element 2
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(3.5, 4.75);
      Coordinate2D ur = new Coordinate2D(5.5, 5.75);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                 ColorFactory.Instance.WhiteRGB, 10, "Arial", "Regular");
      string text = "Some text string that is really long and " +
                    "<BOL>wraps to other lines</BOL>" +
                    " so that we can see the effects.";
    
      //(Optionally) Modify border and background with 50% transparency
      //CIMGraphic recTxtGra = recTxtElm.Graphic;
      //CIMParagraphTextGraphic cimRecTxtGra = recTxtGra as CIMParagraphTextGraphic;
      //CIMSymbolReference cimRecTxtBorder = cimRecTxtGra.Frame.BorderSymbol;
      //
      //CIMLineSymbol lineSym = SymbolFactory.Instance.ConstructLineSymbol(
      //                    ColorFactory.Instance.BlackRGB, 1.0, SimpleLineStyle.Solid);
      //cimRecTxtBorder.Symbol = lineSym;
      //
      //CIMSymbolReference cimRecTxtBkgrd = cimRecTxtGra.Frame.BackgroundSymbol;
      //CIMPolygonSymbol polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
      //                            ColorFactory.Instance.GreyRGB, SimpleFillStyle.Solid);
      //
      //CIMColor symCol = polySym.GetColor(IElementContainer container);
      //symCol.SetAlphaValue(50);
      //cimRecTxtBkgrd.Symbol = polySym;
      //recTxtElm.SetGraphic(recTxtGra);
    
      var ge = ElementFactory.Instance.CreateTextGraphicElement(layout,
                  TextType.RectangleParagraph, env, sym, text, "New Rectangle Text");
      });
    }
    Create Circle Text Element
    {
      await QueuedTask.Run(() =>
      {
      //Build geometry
      Coordinate2D center = new Coordinate2D(4.5, 4);
      var eabCir = new EllipticArcBuilderEx(center, 0.5, ArcOrientation.ArcClockwise);
      var cir = eabCir.ToSegment();
    
      var poly = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(cir, AttributeFlags.AllAttributes));
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                      ColorFactory.Instance.GreenRGB, 10, "Arial", "Regular");
      string text = "Circle, circle, circle";
    
      GraphicElement cirTxtElm = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.CircleParagraph, poly, sym, text, "New Circle Text", false);
      });
    }
    Create Bezier Text Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D pt1 = new Coordinate2D(3.5, 7.5);
      Coordinate2D pt2 = new Coordinate2D(4.16, 8);
      Coordinate2D pt3 = new Coordinate2D(4.83, 7.1);
      Coordinate2D pt4 = new Coordinate2D(5.5, 7.5);
      var bez = new CubicBezierBuilderEx(pt1, pt2, pt3, pt4);
      var bezSeg = bez.ToSegment();
      Polyline bezPl = PolylineBuilderEx.CreatePolyline(bezSeg, AttributeFlags.AllAttributes);
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
        ColorFactory.Instance.BlackRGB, 24, "Comic Sans MS", "Regular");
    
      var ge = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.SplinedText, bezPl, sym, "this is the bezier text",
              "New Bezier Text", true, new ElementInfo() { Anchor = Anchor.CenterPoint });
            });
    }
    Create Ellipse Text Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D center = new Coordinate2D(4.5, 2.75);
      var eabElp = new EllipticArcBuilderEx(center, 0, 1, 0.45, ArcOrientation.ArcClockwise);
      var ellipse = eabElp.ToSegment();
    
      var poly = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(ellipse, AttributeFlags.AllAttributes));
    
      //Set symbology, create and add element to layout
      CIMTextSymbol sym = SymbolFactory.Instance.ConstructTextSymbol(
                            ColorFactory.Instance.BlueRGB, 10, "Arial", "Regular");
      string text = "Ellipse, ellipse, ellipse";
    
      GraphicElement ge = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PolygonParagraph, poly, sym, text, "New Ellipse Text", false);
      });
    }
    Create Predefined Shape Graphic Element
    {
      PredefinedShape shapeType = PredefinedShape.Circle;
      await QueuedTask.Run(() =>
      {
    
      //PredefinedShape shapeType =
      //              PredefinedShape.Circle | Cloud | Cross |Circle | Triangle | ... ;
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(4, 2.5);
      Coordinate2D ur = new Coordinate2D(6, 4.5);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      var outline = SymbolFactory.Instance.ConstructStroke(
                      ColorFactory.Instance.BlueRGB, 2);
      var poly_sym = SymbolFactory.Instance.ConstructPolygonSymbol(
                       null, outline);
    
      var ge = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
                             layout, shapeType, env.Center, env.Width, env.Height,
                              poly_sym, shapeType.ToString(), true);
      });
    }
    Create Predefined Shape Graphic Element 2
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(6.5, 7);
      Coordinate2D ur = new Coordinate2D(9, 9);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      var outline = SymbolFactory.Instance.ConstructStroke(
                      ColorFactory.Instance.GreenRGB, 2);
      var poly_sym = SymbolFactory.Instance.ConstructPolygonSymbol(
                       null, outline);
    
      var ge = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
        layout, PredefinedShape.RoundedRectangle, env, poly_sym, "Rounded Rect", true);
      });
    }
    Create Predefined Shape Graphic Element 3
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D center = new Coordinate2D(2, 2.75);
      var eabElp = new EllipticArcBuilderEx(
                               center, 0, 1, 0.45, ArcOrientation.ArcClockwise);
      var ellipse = eabElp.ToSegment();
    
      //Set symbology, create and add element to layout
      CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
                            ColorFactory.Instance.GreenRGB, 2.0, SimpleLineStyle.Dot);
      CIMPolygonSymbol ellipseSym = SymbolFactory.Instance.ConstructPolygonSymbol(
                       ColorFactory.Instance.GreyRGB, SimpleFillStyle.Vertical, outline);
    
      var poly = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(ellipse, AttributeFlags.AllAttributes));
    
      var ge = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
        layout, PredefinedShape.Ellipse, poly.Extent.Center, 0, 0, ellipseSym,
        "New Ellipse2", false, new ElementInfo() { Anchor = Anchor.TopRightCorner });
      });
    }
    Create Line Arrow Element
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      List<Coordinate2D> plCoords = new List<Coordinate2D>();
      plCoords.Add(new Coordinate2D(1, 8.5));
      plCoords.Add(new Coordinate2D(1.66, 9));
      plCoords.Add(new Coordinate2D(2.33, 8.1));
      plCoords.Add(new Coordinate2D(3, 8.5));
      Polyline linePl = PolylineBuilderEx.CreatePolyline(plCoords);
    
      var arrowInfo = new ArrowInfo()
      {
        ArrowHeadKey = ArrowInfo.DefaultArrowHeadKeys[8],
        ArrowOnBothEnds = true,
        ArrowSizePoints = 24,
        LineWidthPoints = 12
      };
    
      //Create and add element to layout
      GraphicElement lineElm = ElementFactory.Instance.CreateArrowGraphicElement(
        layout, linePl, arrowInfo, "Arrow Line", true,
                                  new ElementInfo() { Rotation = 15.0 });
      //lineElm.SetName("New Line");
      });
    }
    Create Picture Graphic Element using CIMSymbol
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(0.5, 1);
      Coordinate2D ur = new Coordinate2D(2.5, 2);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Create and add element to layout
      string picPath = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures),
        "SamplePicture.jpg");
      var pic_gr = ElementFactory.Instance.CreatePictureGraphicElement(
        layout, env.Center, picPath, "New Picture", true, new ElementInfo() { Anchor = Anchor.CenterPoint });
      });
    }
    Create a new picture element with advanced symbol settings
    {
      //Create a picture element and also set background and border symbology.
    
      await QueuedTask.Run(() =>
      {
    
      //Build 2D envelope geometry
      Coordinate2D pic_ll = new Coordinate2D(6, 1);
      Coordinate2D pic_ur = new Coordinate2D(8, 2);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(pic_ll, pic_ur);
    
      //Create and add element to layout
      string picPath = @"C:\Temp\WhitePass.jpg";
    
      GraphicElement picElm = ElementFactory.Instance.CreatePictureGraphicElement(
                                           layout, env, picPath, "New Picture");
    
      //(Optionally) Modify the border and shadow
      CIMGraphic picGra = picElm.GetGraphic();
      CIMPictureGraphic cimPicGra = picGra as CIMPictureGraphic;
      cimPicGra.Frame.BorderSymbol = new CIMSymbolReference();
      cimPicGra.Frame.BorderSymbol.Symbol =
            SymbolFactory.Instance.ConstructLineSymbol(
                   ColorFactory.Instance.BlueRGB, 2.0, SimpleLineStyle.Solid);
    
      cimPicGra.Frame.ShadowSymbol = new CIMSymbolReference();
      cimPicGra.Frame.ShadowSymbol.Symbol =
                  SymbolFactory.Instance.ConstructPolygonSymbol(
                        ColorFactory.Instance.BlackRGB, SimpleFillStyle.Solid);
    
      //Update the element
      picElm.SetGraphic(picGra);
      });
    }
    Create Map Frame and Set Camera
    {
      //Create a map frame and set its camera by zooming to the extent of an existing bookmark.
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
    
      //Build 2D envelope geometry
      Coordinate2D mf_ll = new Coordinate2D(6.0, 8.5);
      Coordinate2D mf_ur = new Coordinate2D(8.0, 10.5);
      Envelope mf_env = EnvelopeBuilderEx.CreateEnvelope(mf_ll, mf_ur);
    
      //Reference map, create MF and add to layout
      MapProjectItem mapPrjItem = project.GetItems<MapProjectItem>()
                           .FirstOrDefault(item => item.Name.Equals("Map"));
      Map mfMap = mapPrjItem.GetMap();
      Bookmark bookmark = mfMap.GetBookmarks().FirstOrDefault(
                            b => b.Name == "Great Lakes");
    
      MapFrame mfElm = ElementFactory.Instance.CreateMapFrameElement(
                           layout, mf_env, mfMap, "New Map Frame");
    
      //Zoom to bookmark
      mfElm.SetCamera(bookmark);
      });
    }
    Create Legend
    {
      //Create a legend for an associated map frame.
      await QueuedTask.Run(() =>
      {
    
      //Build 2D envelope geometry
      Coordinate2D leg_ll = new Coordinate2D(6, 2.5);
      Coordinate2D leg_ur = new Coordinate2D(8, 4.5);
      Envelope leg_env = EnvelopeBuilderEx.CreateEnvelope(leg_ll, leg_ur);
    
      //Reference MF, create legend and add to layout
      mapFrame = layout.FindElement("New Map Frame") as MapFrame;
      if (mapFrame == null)
      {
        //TODO handle null map frame
        return;
      }
      var legendInfo = new LegendInfo()
      {
        MapFrameName = mapFrame.Name
      };
      Legend legendElm = ElementFactory.Instance.CreateMapSurroundElement(
                          layout, leg_env, legendInfo, "New Legend") as Legend;
      });
    }
    Create Scale Bar From StyleItem
    {
      //Create a scale bar using a style.
    
      //Search for a style project item by name
      StyleProjectItem arcgis_2dStyle = Project.Current.GetItems<StyleProjectItem>()
                                  .First(si => si.Name == "ArcGIS 2D");
    
      await QueuedTask.Run(() =>
      {
    
      //Reference the specific scale bar by name
      ScaleBarStyleItem scaleBarItem = arcgis_2dStyle.SearchScaleBars(
                          "Double Alternating Scale Bar").FirstOrDefault();
    
      //Reference the map frame and define the location
      MapFrame myMapFrame = layout.FindElement("Map Frame") as MapFrame;
      Coordinate2D coord2D = new Coordinate2D(10.0, 7.0);
    
      //Construct the scale bar
      var sbarInfo = new ScaleBarInfo()
      {
        MapFrameName = myMapFrame.Name,
        ScaleBarStyleItem = scaleBarItem
      };
      ElementFactory.Instance.CreateMapSurroundElement(
              layout, coord2D.ToMapPoint(), sbarInfo);
            });
    }
    Create North Arrow From StyleItem 1
    {
      //Create a north arrow using a style.
    
      //Search for a style project item by name
      StyleProjectItem arcgis2dStyles = Project.Current.GetItems<StyleProjectItem>()
                        .First(si => si.Name == "ArcGIS 2D");
    
      await QueuedTask.Run(() =>
      {
    
      NorthArrowStyleItem naStyleItem = arcgis2dStyles.SearchNorthArrows(
                    "ArcGIS North 13").FirstOrDefault();
    
      //Reference the map frame and define the location
      MapFrame newFrame = layout.FindElement("New Map Frame") as MapFrame;
      Coordinate2D nArrow = new Coordinate2D(6, 2.5);
    
      //Construct the north arrow
    
      var naInfo = new NorthArrowInfo()
      {
        MapFrameName = newFrame.Name,
        NorthArrowStyleItem = naStyleItem
      };
      var newNorthArrow = ElementFactory.Instance.CreateMapSurroundElement(
                              layout, nArrow.ToMapPoint(), naInfo);
      });
    }
    Create Table Frame
    {
      //Create a table frame.
      await QueuedTask.Run(() =>
      {
    
      //Build 2D envelope geometry
      Coordinate2D rec_ll = new Coordinate2D(1.0, 3.5);
      Coordinate2D rec_ur = new Coordinate2D(7.5, 4.5);
      Envelope rec_env = EnvelopeBuilderEx.CreateEnvelope(rec_ll, rec_ur);
    
      //Reference map frame and layer
      MapFrame mf = layout.FindElement("Map Frame") as MapFrame;
      FeatureLayer lyr = mf.Map.FindLayers("GreatLakes").First() as FeatureLayer;
    
      //Build fields list
      var fields = new[] { "NAME", "Shape_Area", "Shape_Length" };
    
      //Construct the table frame
    
      var tableFrameInfo = new TableFrameInfo()
      {
        FieldNames = fields,
        MapFrameName = mf.Name,
        MapMemberUri = lyr.URI
      };
      var tabFrame = ElementFactory.Instance.CreateMapSurroundElement(
        layout, rec_env, tableFrameInfo) as TableFrame;
      });
    }
    Create Map Frame 1
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(2.0, 4.5);
      Coordinate2D ur = new Coordinate2D(4.0, 6.5);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Reference map, create MF and add to layout
      MapFrame mfElm = ElementFactory.Instance.CreateMapFrameElement(layout, env, map);
      });
    }
    Create Map Frame 2
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(4.0, 2.5);
      Coordinate2D ur = new Coordinate2D(7.0, 5.5);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      MapFrame mfElm = ElementFactory.Instance.CreateMapFrameElement(
      layout, env.Center, map);
      });
    }
    Create Legend 2
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(6, 2.5);
      Coordinate2D ur = new Coordinate2D(8, 4.5);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Reference MF, create legend and add to layout
      MapFrame mf = layout.FindElement("Map Frame") as MapFrame;
      var surroundInfo = new LegendInfo()
      {
        MapFrameName = mf.Name
      };
    
      var legendElm = ElementFactory.Instance.CreateMapSurroundElement(
        layout, env.Center, surroundInfo) as Legend;
      legendElm.SetName("New Legend");
      });
    }
    Create North Arrow From StyleItem 2
    {
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D center = new Coordinate2D(7, 5.5);
    
      //Reference a North Arrow in a style
      StyleProjectItem stylePrjItm = project.GetItems<StyleProjectItem>()
                                     .FirstOrDefault(item => item.Name == "ArcGIS 2D");
      NorthArrowStyleItem naStyleItm = stylePrjItm.SearchNorthArrows(
                                             "ArcGIS North 10")[0];
    
      //Reference MF, create north arrow and add to layout
    
      var mf = layout.FindElement("Map Frame") as MapFrame;
      var narrow_info = new NorthArrowInfo()
      {
        MapFrameName = mf.Name,
        NorthArrowStyleItem = naStyleItm
      };
      var arrowElm = (NorthArrow)ElementFactory.Instance.CreateMapSurroundElement(
        layout, center.ToMapPoint(), narrow_info) as NorthArrow;
      arrowElm.SetName("New North Arrow");
      arrowElm.SetHeight(1.75);
      arrowElm.SetX(7);
      arrowElm.SetY(6);
      });
    }
    Create Table Frame 2
    {
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(1, 1);
      Coordinate2D ur = new Coordinate2D(4, 4);
      Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      var tableFrameInfo = new TableFrameInfo()
      {
        MapFrameName = "Map Frame",
        MapMemberUri = "CIMPATH=USNationalParks/NationalParks.json"
      };
      var attribs = new List<CIMStringMap>();
      for (int i = 1; i < 6; i++)
      {
        attribs.Add(new CIMStringMap
        {
          Key = $"Key {i}",
          Value = $"Value {i}"
        });
      }
      var elemInfo = new ElementInfo()
      {
        CustomProperties = attribs
      };
      var tableFrameElem = ElementFactory.Instance.CreateMapSurroundElement(
                                    layout, env.Center, tableFrameInfo,
                                    "New Table Frame", false, elemInfo) as TableFrame;
      });
    }
    Create Scale Bar
    {
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
    
      //Build geometry
      Coordinate2D ll = new Coordinate2D(5.0, 6);
      Coordinate2D ur = new Coordinate2D(6.0, 7);
      Envelope sbEnv = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Reference a Scale Bar in a style
      StyleProjectItem stylePrjItm = project.GetItems<StyleProjectItem>()
                    .FirstOrDefault(item => item.Name == "ArcGIS 2D");
      ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars(
                   "Alternating Scale Bar 1")[0];
      //ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars(
      //                                   "Double Alternating Scale Bar 1")[0];
      //ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars(
      //                                    "Hollow Scale Bar 1")[0];
    
      //Create Scale Bar
      ScaleBarInfo sbInfo = new ScaleBarInfo()
      {
        MapFrameName = mapFrame.Name,
      };
    
      var sbElm = ElementFactory.Instance.CreateMapSurroundElement(
                                         layout, sbEnv, sbInfo) as ScaleBar;
      });
    }
    Create Scale Line
    {
      var project = Project.Current;
      await QueuedTask.Run(() =>
      {
      //Build geometry
      Coordinate2D ll = new Coordinate2D(5.0, 8);
      Coordinate2D ur = new Coordinate2D(6.0, 9);
      Envelope sbEnv = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
    
      //Reference a Scale Bar in a style
      StyleProjectItem stylePrjItm = project.GetItems<StyleProjectItem>()
                                   .FirstOrDefault(item => item.Name == "ArcGIS 2D");
      ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars(
                                    "Scale Line 1")[0];
      //ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars(
      //                                           "Stepped Scale Line")[0];
      //ScaleBarStyleItem sbStyleItm = stylePrjItm.SearchScaleBars(
      //                                            "Scale Line 2")[0];
    
      //Create Scale Bar
      ScaleBarInfo sbInfo = new ScaleBarInfo()
      {
        MapFrameName = mapFrame.Name,
        ScaleBarStyleItem = sbStyleItm
      };
    
      var sbElm = ElementFactory.Instance.CreateMapSurroundElement(
                        layout, sbEnv, sbInfo, "ScaleBar Line") as ScaleBar;
      });
    }
    Creating empty group elements
    {
      //Create an empty group element at the root level of the contents pane
      await QueuedTask.Run(() =>
      {
    
      //container is IElementContainer - GroupLayer or Layout
      GroupElement grp1 = ElementFactory.Instance.CreateGroupElement(
                            layout, null, "Group");
      // *** or ***
      //Create a group element inside another group element
    
      //Find an existing group element
      //container is IElementContainer - GroupLayer or Layout
      GroupElement existingGroup = layout.FindElement("Group") as GroupElement;
    
      //Create on worker thread
      GroupElement grp2 = ElementFactory.Instance.CreateGroupElement(
          existingGroup, null, "Group in Group");
        });
    }
    Create a group element with elements
    {
      //Create a group with a list of elements at the root level of the contents pane.
    
      //Find an existing elements
      //container is IElementContainer - GroupLayer or Layout
      var elem1 = layout.FindElement("Polygon 1");
      var elem2 = layout.FindElement("Bezier Text");
      var elem3 = layout.FindElement("Cloud Shape 2");
    
      //Construct a list and add the elements
      var elmList = new List<Element>
      {
        elem1,
        elem2,
        elem3
      };
      await QueuedTask.Run(() =>
      {
      GroupElement groupWithListOfElementsAtRoot =
                ElementFactory.Instance.CreateGroupElement(
                         layout, elmList, "Group with list of elements at root");
      // *** or ***
    
      //Create a group using a list of element names at the root level of the contents pane.
    
      //List of element names
      var elmNameList = new[] { "Para Text1", "Line 3" };
    
      var elemToGroup = layout.FindElements(elmNameList);
      GroupElement groupWithListOfElementNamesAtRoot =
            ElementFactory.Instance.CreateGroupElement(
                 layout, elemToGroup, "Group with list of element names at root");
      });
    }
    Translates a point in map coordinates to a point in page coordinates
    {
      var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.BlackRGB, 8);
      var activeMapView = MapView.Active;
      //Convert the clicked point in client coordinates to the corresponding map coordinates.
      //clicked point can be from a Map Tool's HandleMouseDownAsync callback.
      //MapViewMouseButtonEventArgs ClientPoint property.
      Point clickedPoint = new Point();
      await QueuedTask.Run(() =>
      {
        var clickedMapPoint = activeMapView.ClientToMap(clickedPoint);
        //Get the corresponding layout point
        var pointOnLayoutFrame = mapFrame.MapToPage(mapPoint);
    
        //Create a point graphic on the Layout.
        var cimGraphicElement = new CIMPointGraphic
        {
          Location = pointOnLayoutFrame,
          Symbol = pointSymbol.MakeSymbolReference()
        };
        //Or use GraphicFactory
        var cimGraphicElement2 = GraphicFactory.Instance.CreateSimpleGraphic(
                pointOnLayoutFrame, pointSymbol);
    
        ElementFactory.Instance.CreateGraphicElement(layout, cimGraphicElement);
        ElementFactory.Instance.CreateGraphicElement(layout, cimGraphicElement2);
      });
      ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(string.Format("X: {0} Y: {1} Z: {2}",
          mapPoint.X, mapPoint.Y, mapPoint.Z), "Map Coordinates");
    }
    Requirements

    Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

    ArcGIS Pro version: 3.0 or higher.
    See Also