ProConcepts Layouts - Esri/arcgis-pro-sdk GitHub Wiki

public class LayoutFactory : ILayoutFactory {

   //Create a layout specifying width and height in the specified "units".
   public Layout CreateLayout(double width, double height, LinearUnit units, 
           bool showRulers = true, double smallestRulerDivision = 0.5) {
        ...
   //Create a layout using a CIMPage to specify initial page parameters
   public Layout CreateLayout(CIMPage cimPage = null) {
      ...

 QueuedTask.Run(()=> {
    //This is overload1, specifying a 17x11" page, show rulers is true and the minimum
    //dimension shown on the ruler is 1 inch
    var layout = LayoutFactory.Instance.CreateLayout(17, 11, LinearUnit.Inches, true, 1.0);
    layout.SetName("New Layout Name"); 

    //This is overload2 using a CIMPage
    var newPage = new CIMPage();
    newPage.Width = 17;
    newPage.Height = 11;
    newPage.Units = LinearUnit.Inches;
    newPage.ShowRulers = true;
    newPage.SmallestRulerDivision = 1.0;

    //To this point, the CIMPage simply duplicates the same settings we used on
    //overload 1 above...however, with a CIMPage, we can do more - such as defining
    //guides and margins
    var guides = new List<CIMGuide>() {
       new CIMGuide() { Orientation = Orientation.Vertical, Position = newPage.Width / 2},
       new CIMGuide() { Orientation = Orientation.Horizontal, Position = newPage.Height / 2}
    };
    newPage.Guides = guides.ToArray();

    var margin = new CIMMargin();
    margin.Left = margin.Right = margin.Top = margin.Bottom = 1.0;

    var layout2 = LayoutFactory.Instance.CreateLayout(newPage);
    layout2.SetName("New Layout Name2"); 

 //Open a layout
  var layout_sel = await QueuedTask.Run(() => {
    //Create the layout
    var layout = LayoutFactory.Instance.CreateLayout(17, 11, LinearUnit.Inches, true, 1.0);
    //TODO…add element content…
    ...
    return layout;
 });

 //Remember to call CreateLayoutPaneAsync on the UI Thread!
 await FrameworkApplication.Panes.CreateLayoutPaneAsync(layout_sel);

 //Retrieve a layout from the project
 var layout_sel = await QueuedTask.Run(() => {
     //Call GetItems<T>, use LINQ to further refine the selection...
     var layoutItem = Project.Current.GetItems<LayoutProjectItem>().FirstOrDefault(
                                      			item => item.Name == “Layout1”);
     //retrieve the layout from the LayoutProjectItem
     return layoutItem.GetLayout();
 }
 //open the layout...must be on the UI thread
 FrameworkApplication.Panes.CreateLayoutPaneAsync(layout_sel);

 //Reference a layout associated with an active layout view
 var layout = LayoutView.Active.Layout;
 if (lyt != null) {
   //TODO...manipulate layout
 }

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {
  
 //1. Most basic - provide the container and a geometry. A default symbol and name are applied.
 var ge = GraphicFactory.Instance.CreateGraphicElement(layout, point_location);

 //Add a geometry and a symbol and a name
 var center = new Coordinate2D(2, 4);
 var circle_seg = EllipticArcBuilderEx.CreateCircle(
        new Coordinate2D(2, 4), 0.5, ArcOrientation.ArcClockwise, null);

 //2. make a circle graphic - provide the container, a geometry, and symbol. A default name is applied.
 var circle_poly = PolygonBuilderEx.CreatePolygon(PolylineBuilderEx.CreatePolyline(circle_seg));

 //Define a custom symbol
 var outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 2.0, 
                                                                       SimpleLineStyle.Dash);
 var circle_sym = SymbolFactory.Instance.ConstructPolygonSymbol(
                              ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, outline);

 var ge_circle = GraphicFactory.Instance.CreateGraphicElement(layout, circle_poly, circle_sym);

 //3. Make a line graphic - provide the container, a geometry, symbol, and name.
 var 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));
 var poly_line = PolylineBuilderEx.CreatePolyline(plCoords);

 //Reference a line symbol in a style
 var style_item = Project.Current.GetItems<StyleProjectItem>().First(x => x.Name == "ArcGIS 2D");
 var symStyle = style_item.SearchSymbols(StyleItemType.LineSymbol, "Line with 2 Markers")[0];
 var lineSym = symStyle.Symbol as CIMLineSymbol;
 lineSym.SetSize(20);

 var ge_line = ElementFactory.Instance.CreateGraphicElement(
                                         layout, poly_line, lineSym, "New Line");

 //4. Make a text graphic with a placement point. A default symbol, text string, and name will be applied
 var coord2D = new Coordinate2D(3.5, 10);
 var ge_text = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PointText, coord2D.ToMapPoint());

 //5. Make a text graphic with a placement point, symbol, text string, and name.
 var coord2D = new Coordinate2D(3.5, 10);
 var text_sym = SymbolFactory.Instance.ConstructTextSymbol(
                     ColorFactory.Instance.RedRGB, 32, "Arial", "Regular");

 var ge_text = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PointText, coord2D.ToMapPoint(), text_sym, "This is the text", "New Point Text1");

 //6. Make a rectangle paragraph text graphic with a placement envelope, symbol, text string, and name.
 var ll = new Coordinate2D(3.5, 4.75);
 var ur = new Coordinate2D(5.5, 5.75);
 var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 //Create a text symbol
 var text_sym = SymbolFactory.Instance.ConstructTextSymbol(
                          ColorFactory.Instance.WhiteRGB, 10, "Arial", "Regular");
 //Create the graphic
 var ge_text2 = ElementFactory.Instance.CreateTextGraphicElement(
         layout, TextType.RectangleParagraph, env, text_sym, "This is the text", "New Rectangle Text1");

 //7. Make a polygon paragraph text graphic with a polygon, symbol, text string, and name.
 var 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));
 var poly = PolygonBuilderEx.CreatePolygon(plyCoords);

 var text_sym = SymbolFactory.Instance.ConstructTextSymbol(
                   ColorFactory.Instance.GreyRGB, 10, "Arial", "Regular");
 string text = "Some Text String <BOL>forced to wrap to other</BOL>lines.";

 //Create the graphic
 var ge_text3 = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.PolygonParagraph, poly, text_sym, text, "New Polygon Text1");

 //8. Make a splined text graphic with a cubic bezier, symbol, text string, and name.
 var pt1 = new Coordinate2D(3.5, 7.5);
 var pt2 = new Coordinate2D(4.16, 8);
 var pt3 = new Coordinate2D(4.83, 7.1);
 var pt4 = new Coordinate2D(5.5, 7.5);
 var bezier = new CubicBezierBuilderEx(pt1, pt2, pt3, pt4);

 var bezier_line = PolylineBuilderEx.CreatePolyline(
                     bezier.ToSegment(), AttributeFlags.AllAttributes);

 var text_sym = SymbolFactory.Instance.ConstructTextSymbol(
                ColorFactory.Instance.BlackRGB, 24, "Comic Sans MS", "Regular");

 //Create the graphic 
 var ge_text4 = ElementFactory.Instance.CreateTextGraphicElement(
        layout, TextType.SplinedText, bezier_line, text_sym, "This is splined text", "Splined Text1");

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

 //1. Create a circle graphic. Set the anchor to be the center point using an ElementInfo
 var center = new Coordinate2D(2, 4);
 var circle_seg = EllipticArcBuilderEx.CreateCircle(
        center, 0.5, ArcOrientation.ArcClockwise, null);
 var circle_poly = PolygonBuilderEx.CreatePolygon(PolylineBuilderEx.CreatePolyline(circle_seg));

 //Use an element info to specify the anchor
 var elemInfo = new ElementInfo() { Anchor = Anchor.CenterPoint };
 
 //Create the graphic element 
 var ge_circle = ElementFactory.Instance.CreateGraphicElement(
                   layout, circle_poly, null, "New Circle", true, elemInfo);

 //2. Create a point graphic. Specify a top right anchor, a 45.0 degree rotation and add
 // two custom properties
 var coord2D = new Coordinate2D(2.0, 10.0);

 //Reference a point symbol in a style
 var style_item = Project.Current.GetItems<StyleProjectItem>().First(x => x.Name == "ArcGIS 2D");
 var symStyle = style_item.SearchSymbols(StyleItemType.PointSymbol, "City Hall")[0];
 var pointSym = symStyle.Symbol as CIMPointSymbol;
 pointSym.SetSize(50);

 //Create the element info
 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
  };
  //create the graphic element
  var ge_pt = ElementFactory.Instance.CreateGraphicElement(
        layout, coord2D.ToMapPoint(), null, String.Empty, true, elemInfo);

 //3. Create a rectangle with rounded corners, 45.0 rotation and a center point anchor
 var ll = new Coordinate2D(1.0, 4.75);
 var ur = new Coordinate2D(3.0, 5.75);
 var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 //Set symbolology, create and add element to layout
 var outline = SymbolFactory.Instance.ConstructStroke(
                   ColorFactory.Instance.BlackRGB, 5.0, SimpleLineStyle.Solid);
 var polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
                   ColorFactory.Instance.GreenRGB, SimpleFillStyle.DiagonalCross, outline);

 var elemInfo = new ElementInfo() {
      Anchor = Anchor.CenterPoint,
      Rotation = 45.0,
      CornerRounding = 5.0
 };

 //create the graphic element
  var ge_pt = ElementFactory.Instance.CreateGraphicElement(
        layout, env, polySym, "New Rectangle", false, elemInfo);

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

 //1. Create a graphic element using the Cloud predefined shape
 var ll = new Coordinate2D(4, 2.5);
 var ur = new Coordinate2D(6, 4.5);
 var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 var outline = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlueRGB, 2);
 //Hollow fill
 var poly_sym = SymbolFactory.Instance.ConstructPolygonSymbol(null, outline);

 var elemInfo = new ElementInfo() {
        Anchor = Anchor.BottomLeftCorner
 };

 //Create the cloud graphic element
 var ge_cloud = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
        layout, PredefinedShape.Cloud, env, poly_sym, "Cloud1",  true, elemInfo);

 //2. Create a graphic element using the Rounded Rectangle predefined shape
 var ll = new Coordinate2D(6.5, 7);
 var ur = new Coordinate2D(9, 9);
 var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
 
//Create the rounded rect graphic element
 var ge_rrect = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
        layout, PredefinedShape.RoundedRectangle, env, null, "Rounded Rect1", true);

 //3. Create a predefined shape using the Ellipse predefined shape
 Coordinate2D center = new Coordinate2D(2, 2.75);

 var outline = SymbolFactory.Instance.ConstructStroke(
                 ColorFactory.Instance.GreenRGB, 2.0, SimpleLineStyle.Dot);
 var ellipseSym = SymbolFactory.Instance.ConstructPolygonSymbol(
                      ColorFactory.Instance.GreyRGB, SimpleFillStyle.Vertical, outline);

 var ge_ellipse = ElementFactory.Instance.CreatePredefinedShapeGraphicElement(
        layout, PredefinedShape.Ellipse, center.ToMapPoint(), 0, 0, ellipseSym, "Ellipse1", false, 
            new ElementInfo() { Anchor = Anchor.TopRightCorner });

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

 //1. Create a line graphic element with an arrow head on both ends. Use the default style 
 //at index 1 for the arrow heads
 var 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));
 var arrow_line = PolylineBuilderEx.CreatePolyline(plCoords);

 var arrowInfo = new ArrowInfo() {
      ArrowHeadKey = ArrowInfo.DefaultArrowHeadKeys[1],
      ArrowOnBothEnds = true,
      ArrowSizePoints = 30,
      LineWidthPoints = 15
 };

 var ge_line_arrows = ElementFactory.Instance.CreateArrowGraphicElement(
        layout, arrow_line, arrowInfo, "Arrow Line1", false);

 //2. Create a line graphic element with an arrow head on both ends. Use the
 // default style at index 8 for the arrow heads
 var 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));
 var arrow_line = PolylineBuilderEx.CreatePolyline(plCoords);

 var arrowInfo = new ArrowInfo() {
      ArrowHeadKey = ArrowInfo.DefaultArrowHeadKeys[8],
      ArrowOnBothEnds = false,//arrow head on the end only (not beginning)
      ArrowSizePoints = 24,
      LineWidthPoints = 12
 };

 var ge_line_arrow = ElementFactory.Instance.CreateArrowGraphicElement(
        layout, arrow_line, arrowInfo, "Arrow Line2", true);

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {
 
//1. Create "simple" graphics: Point, Line, Polygon
 //Point
 var coord2D = new Coordinate2D(2.0, 10.0);
 //create the graphic
 var graphic = GraphicFactory.Instance.CreateSimpleGraphic(coord2D.ToMapPoint());
 //add to the layout
 var ge_point = ptElm = ElementFactory.Instance.CreateGraphicElement(layout, graphic);

 //Line
 var pt1 = new Coordinate2D(3.5, 7.5);
 var pt2 = new Coordinate2D(4.16, 8);
 var pt3 = new Coordinate2D(4.83, 7.1);
 var pt4 = new Coordinate2D(5.5, 7.5);
 var bez = new CubicBezierBuilderEx(pt1, pt2, pt3, pt4);
 var bezPl = PolylineBuilderEx.CreatePolyline(bez.ToSegment(), AttributeFlags.AllAttributes);

 //create the graphic
 var graphic = GraphicFactory.Instance.CreateSimpleGraphic(bezPl);
 //add to the layout
 var ge_curve = ElementFactory.Instance.CreateGraphicElement(layout, graphic);

 //Poly
 var ll = new Coordinate2D(1.0, 4.75);
 var ur = new Coordinate2D(3.0, 5.75);
 var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 //Set symbolology
 var outline = SymbolFactory.Instance.ConstructStroke(
                   ColorFactory.Instance.BlackRGB, 5.0, SimpleLineStyle.Solid);
 var polySym = SymbolFactory.Instance.ConstructPolygonSymbol(
                   ColorFactory.Instance.GreenRGB, SimpleFillStyle.DiagonalCross, outline);
 //create the graphic
 var ge_poly = GraphicFactory.Instance.CreateSimpleGraphic(env, polySym);
 //add to the layout
 var recElm = ElementFactory.Instance.CreateGraphicElement(layout, env, polySym, "New Rectangle");

 //Multiples...
 //poly
 var 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));
 var poly = PolygonBuilderEx.CreatePolygon(plyCoords);

 //envelope
 var ll = new Coordinate2D(1.0, 4.75);
 var ur = new Coordinate2D(3.0, 5.75);
 var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 //point
 var coord2D = new Coordinate2D(2.0, 10.0);
 //create the graphics
 var g1 = GraphicFactory.Instance.CreateSimpleGraphic(poly);
 var g2 = GraphicFactory.Instance.CreateSimpleGraphic(env);
 var g3 = GraphicFactory.Instance.CreateSimpleGraphic(coord2D.ToMapPoint());

 //add to the layout
 var ge_elems = ElementFactory.Instance.CreateGraphicElements(
   layout, new List<CIMGraphic>() { g1, g2, g3 });
    
 //2. Simple graphics: text
 var graphic = GraphicFactory.Instance.CreateSimpleTextGraphic(
                   TextType.PointText, MapPointBuilderEx.CreateMapPoint(3, 5));
 //add to the layout
 var ge_text = ElementFactory.Instance.CreateGraphicElement(layout, graphic);

 //Paragraph
 var ll = new Coordinate2D(2.0, 1);
 var ur = new Coordinate2D(6.0, 2);
 var rect_env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 //create the graphic
 var graphic = GraphicFactory.Instance.CreateSimpleTextGraphic(TextType.RectangleParagraph, rect_env, 
                                                        null, "Rect Graphic text");
 //add to the layout
 var ge_text_para = ElementFactory.Instance.CreateGraphicElement(layout, graphic, "SDK Rectangle Text");

 //Circle paragraph
  var center = new Coordinate2D(4.5, 4);
  var eabCir = new EllipticArcBuilderEx(center, 0.5, ArcOrientation.ArcClockwise);
  var circle = PolygonBuilderEx.CreatePolygon(
        PolylineBuilderEx.CreatePolyline(eabCir.ToSegment()));

 //create a symbol
 var text_sym = SymbolFactory.Instance.ConstructTextSymbol(
                      ColorFactory.Instance.GreenRGB, 10, "Arial", "Regular");
 string text = "Circle para text";
 //create the graphic
 var graphic = GraphicFactory.Instance.CreateSimpleTextGraphic(
                                 TextType.CircleParagraph, circle, text_sym, text);
 //add to the layout
 var ge_text_circle_para = ElementFactory.Instance.CreateGraphicElement(
                            layout, graphic, "New Circle Text", true);

 //Extract the geometry outline of various graphics...
 //Retrieve the outline for all of the graphic elements in the layout
 layout.SelectElements(geometry, SelectionCombinationMethod.New, false);
 var sel_elems = layout.GetSelectedElements().OfType<GraphicElement>().ToList();

 foreach(var ge in sel_elems) {
    var outline = GraphicFactory.Instance.GetGraphicOutline(layout, ge.GetGraphic());
    //add the outline back to the layout as a new graphic element
    var elem = ElementFactory.Instance.CreateGraphicElement(layout, outline);
 }

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

 //1. Predefined shapes
 var ll = new Coordinate2D(2.0, 1);
 var ur = new Coordinate2D(6.0, 2);
 var rect_env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

 //Construct a symbol
 var outline = SymbolFactory.Instance.ConstructStroke(
       ColorFactory.Instance.BlueRGB, 2);
 var poly_sym = SymbolFactory.Instance.ConstructPolygonSymbol(
        null, outline);//hollow fill

 //create the predefined shape
 var graphic = GraphicFactory.Instance.CreatePredefinedShapeGraphic(PredefinedShape.X, env, poly_sym);
 //create an element
 var ge_x = ElementFactory.Instance.CreateGraphicElement(layout, graphic);

 var coord2D = new Coordinate2D(3,3);
 //create the predefined shape, width of 20 points. Height will default to width in this case
 var graphic = GraphicFactory.Instance.CreatePredefinedShapeGraphic(PredefinedShape.Triangle,
                  coord2D.ToMapPoint(), 20.0);
 //create an element
 var ge_triangle = ElementFactory.Instance.CreateGraphicElement(layout, graphic);
 
 //2. Arrow heads
 var 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));
 var linePl = PolylineBuilderEx.CreatePolyline(plCoords);

 var arrowInfo = new ArrowInfo() {
   ArrowHeadKey = ArrowInfo.DefaultArrowHeadKeys[1],
   ArrowOnBothEnds = true,
   ArrowSizePoints = 30,
   LineWidthPoints = 15
 };
 //create the line graphic with arrow heads
 var graphic = GraphicFactory.Instance.CreateArrowGraphic(linePl, arrowInfo);
 //create an element
 var ge_line_elem = ElementFactory.Instance.CreateGraphicElement(
   layout, graphic, "Arrow Line");

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

 var pic_path = 
   @"https://www.esri.com/content/dam/esrisites/en-us/home/" +
    "homepage-tile-podcast-business-resilience-climate-change.jpg";

 //create the graphic
 var graphic = GraphicFactory.Instance.CreatePictureGraphic(new Coordinate2D(3.5, 2).ToMapPoint(), 
                                                              picPath);
 //create an element
 var ge_pic_elem = ElementFactory.Instance.CreateGraphicElement(layout, graphic);

 var map = ... 
 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

  //1. create a map frame
  //aquire a map
  var mapItem = Project.Current.GetItems<MapProjectItem>().First();
  var map = mapItem.GetMap();

  var ll = new Coordinate2D(2.0, 4.5);
  var ur = new Coordinate2D(4.0, 6.5);
  var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
  //create the map frame
  var map_frame = ElementFactory.Instance.CreateMapFrameElement(layout, env, map);

  //2. Create a legend
  //get associated map frame
  var map_frame = layout.FindElement("Map Frame1") as MapFrame;
  //Create the surround info - use default styling
  var legend_info = new LegendInfo() {
    MapFrameName = map_frame.Name
  };
  //Create the surround
  var legend_elem = (Legend)ElementFactory.Instance.CreateMapSurroundElement(
                         layout, new Coordinate2D(4, 9).ToMapPoint(), legend_info);

  //3. Create a North Arrow
  var center = new Coordinate2D(7, 5.5);

  //get associated map frame
  var map_frame = layout.FindElement("Map Frame1") as MapFrame;

  //Reference a North Arrow in a style
  var proj_style = Project.Current.GetItems<StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
  var na_style = proj_style.SearchNorthArrows("ArcGIS North 10")[0];

  //Create the surround info
  var narrow_info = new NorthArrowInfo() {
    MapFrameName = map_frame.Name,
    NorthArrowStyleItem = na_style //Apply styling
  };

  //Create the surround
  var legend_elem = (Legend)ElementFactory.Instance.CreateMapSurroundElement(
                         layout, center.ToMapPoint(), narrow_info);

  //4. Create a scale bar
  //get associated map frame
  var map_frame = layout.FindElement("Map Frame1") as MapFrame;

  var ll = new Coordinate2D(5.0, 6);
  var ur = new Coordinate2D(6.0, 7);
  var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

  //Reference a North Arrow in a style
  var proj_style = Project.Current.GetItems<StyleProjectItem>().FirstOrDefault(item => item.Name == "ArcGIS 2D");
  var sb_style = proj_style.SearchScaleBars("Alternating Scale Bar 1")[0];

  //Create the surround info
  var sbar_info = new ScaleBarInfo() {
        MapFrameName = mapFrame.Name
        ScaleBarStyleItem = sb_style
  };

  //Create the surround
  var sbar_elem = (ScaleBar)ElementFactory.Instance.CreateMapSurroundElement(
                         layout, env, sbar_info);

  //5. Create a table frame
  var ll = new Coordinate2D(1, 1);
  var ur = new Coordinate2D(5, 4);
  var env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);

  var feat_layer = map.GetLayersAsFlattenedList().OfType<FeatureLayer>().First();

  var tableFrameInfo = new TableFrameInfo() {
        MapFrameName = mapFrameName,
        MapMemberUri = feat_layer.URI //Required
  };
  //Create the surround
  var table_elem = ElementFactory.Instance.CreateMapSurroundElement(layout, env.Center, tableFrameInfo,
        "New Table Frame", false, new ElementInfo() { Anchor = Anchor.CenterPoint });

  var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {
   
   //Create an empty group element at the root level of the layout
   var grp1 = ElementFactory.Instance.CreateGroupElement(layout);

   //Create a group element containing "elems" at the root level of the layout
   var grp2 = ElementFactory.Instance.CreateGroupElement(layout, elems, "Group2");

   //Create an empty group element within the group element "grp1"
   var grp3 = LayoutElementFactory.Instance.CreateGroupElement(grp1);

 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

   //Find specific elements by name
   var ge_rect = layout.FindElement("Rectangle") as GraphicElement;
   var na = layout.FindElement("North Arrow") as NorthArrow;
   var elems = layout.FindElements(new List<string> { "Legend", "Scale Bar", "Text2" });

  //Get elements retaining hierarchy
  var top_level_elems = 
      layout.GetElements()/layout.Elements/group_elem.Elements;//can bind XAML to Elements

  //Flatten hierarchy
  var all_elems = layout.GetElementsAsFlattenedList()/group_elem.GetElementsAsFlattenedList();

  //Use LINQ with any of the collections
  //Retrieve just those elements that are GraphicElements and are Visible
  var some_elems = all_elems.OfType<GraphicElement>().Where(ge => ge.IsVisible).ToList();

 var layoutView = LayoutView.Active;
 var layout = LayoutView.Active.Layout;
 //Must be on QueuedTask
 QueuedTask.Run(()=> {

   //Select/unselect some elements...
   var elems = layout.GetElementsAsFlattenedList();
   //select any element not a group element
   layout.SelectElements(elems.Where(e => !e.Name.StartsWith("Group")));//or layoutView
   layout.UnSelectElements(elems.Where(e => !e.Name.StartsWith("Group")));//or layoutView

   //Select/unselect all visible, graphic elements
   var ge_elems = all_elems.OfType<GraphicElement>().Where(ge => ge.IsVisible).ToList();
   layout.SelectElements(ge_elems);//or layoutView
   layout.UnSelectElements(ge_elems);//or layoutView

   //Select/unselect a specific element
   var na = layout.FindElement("North Arrow");
   layout.SelectElement(na);//or layoutView
   layout.UnSelectElement(na);//or layoutView

   //Select everything
   layoutView.SelectAllElements();//on LayoutView -only-

   //enumerate the selected elements
   foreach(var sel_elem in layout.GetSelectedElements()) {//or layoutView
     //TODO..process selection
   }

   //Clear the selection
   layout.ClearElementSelection();//or layoutView

   //Use within QueuedTask.Run
   //Get the Style project items in the project
   var styleProjectItems = Project.Current?.GetItems<StyleProjectItem>();
   //Get the ArcGIS 2D Style Project Item
   var styleProjectItem = styleProjectItems.FirstOrDefault(s => s.Name == "ArcGIS 2D");
   //Get the north arrow style item you need
   var northArrowStyleItem = 
                 styleProjectItem.SearchSymbols(StyleItemType.NorthArrow, "ArcGIS North 18").FirstOrDefault();

    //Use within QueuedTask.Run   
    //Select a North arrow layout element
    var northArrowElement = layout.GetSelectedElements().OfType<NorthArrow>().FirstOrDefault();
    if (northArrowElement != null) {
      //Check if the input style can be applied to the element
      if (northArrowElement.CanApplyStyle(northArrowStyleItem))
         //Apply the style
         northArrowElement.ApplyStyle(northArrowStyleItem);
    }     

   if (layoutPointElement.CanApplyStyle(pointStyleItem)) {           
       //Preserve current symbol size. 
       ge.ApplyStyle(pointStyleItem, true);           
   }

 var layout = LayoutView.Active.Layout;
 var mf = layout.GetElementsAsFlattenedList().OfType<MapFrame>().First(
                                                mf => mf.Name == "MapFrame1");
 QueuedTask.Run(() => {
   
   //1. Display constraint "None"
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.None;

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //2. Display constraint "FixedExtent"
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.Fixed;
   autoCamera.AutoCameraType = AutoCameraType.Extent;

   //set the extent for the frame - your extent will be different
   var extent = EnvelopeBuilderEx.CreateEnvelope(
     400748.62, 800296.4, 1310669.05, 1424520.74, mf.Map.SpatialReference);
   autoCamera.Extent = extent;
 
   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //3. Display constraint "FixedCenter"
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.Fixed;
   autoCamera.AutoCameraType = AutoCameraType.Center;

   var camera = mf.GetMapView(LayoutView.Active).Camera;
   var center = mf.GetViewCenter();
      
   //set a camera for the fixed center point
   //use values suitable for your particular map
   var camera2 = new CIMViewCamera() {
      Heading = 0,
      Pitch = -90,
      Roll = 0,
      Scale = 21169571,
      X = 855708,
      Y = 1112409,
      Z = double.NaN
   };
   autoCamera.Camera = camera2;
   //optionally, set a layer (in the map) to use for the center point
   var states = mf.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
   autoCamera.IntersectLayerPath = states.URI;

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //4. Display constraint "FixedCenterAndScale"
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.Fixed;
   autoCamera.AutoCameraType = AutoCameraType.CenterAndScale;

   var camera = mf.GetMapView(LayoutView.Active).Camera;
   var center = mf.GetViewCenter();

   //set a camera for the fixed center point and scale
   //use values suitable for your particular map
   var camera2 = new CIMViewCamera()
   {
      Heading = 0,
      Pitch = -90,
      Roll = 0,
      Scale = 21169571,
      X = 1310669.0 + ((400748.5 - 1310669.0) / 2.0),
      Y = 800296.4 + ((1424520.74 - 800296.4) / 2.0),
      Z = double.NaN
   };
   autoCamera.Camera = camera2;

  //always validate and check we do not have a map series map frame
  if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //5. Display constraint "FixedScale"
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.Fixed;
   autoCamera.AutoCameraType = AutoCameraType.Scale;

   var camera = mf.GetMapView(LayoutView.Active).Camera;
   var center = mf.GetViewCenter();

   //set a camera for the fixed scale
   //use values suitable for your particular map
   var camera2 = new CIMViewCamera()
   {
      Heading = 0,
      Pitch = -90,
      Roll = 0,
      Scale = 21169571,
      X = 1310669.0 + ((400748.5 - 1310669.0) / 2.0),
      Y = 800296.4 + ((1424520.74 - 800296.4) / 2.0),
      Z = double.NaN
   };
   autoCamera.Camera = camera2;

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //6. Display constraint "LinkedExtent" - there must be at least 2
   //map frames in the layout - the one on which to set the constraint 
   //and the one to link to
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.MapFrameLink;
   autoCamera.AutoCameraType = AutoCameraType.Extent;
   autoCamera.MapFrameLinkName = "MapFrame2";

   var states = mf.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
   //optional, set intersecting layer to use for the linked extent
   autoCamera.IntersectLayerPath = states.URI;
   
   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //7. Display constraint "LinkedCenter" - there must be at least 2
   //map frames in the layout - the one on which to set the constraint 
   //and the one to link to
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.MapFrameLink;
   autoCamera.AutoCameraType = AutoCameraType.Center;
   autoCamera.MapFrameLinkName = "MapFrame2";

   var states = mf.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
   //optional, set intersecting layer to use for the linked center
   autoCamera.IntersectLayerPath = states.URI;

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //8. Display constraint "LinkedCenterAndScale" - there must be at least 2
   //map frames in the layout - the one on which to set the constraint 
   //and the one to link to
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.MapFrameLink;
   autoCamera.AutoCameraType = AutoCameraType.CenterAndScale;
   autoCamera.MapFrameLinkName = "MapFrame2";//controls center and scale

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //9. Display constraint "LinkedScale" - there must be at least 2
   //map frames in the layout - the one on which to set the constraint 
   //and the one to link to
   var mf = GetMapFrame(mapFrame);
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.MapFrameLink;
   autoCamera.AutoCameraType = AutoCameraType.Scale;
   autoCamera.MapFrameLinkName = "MapFrame2";//scale

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //10. Display constraint "LinkedMapSeriesShape" - there must be at least 2
   //map frames in the layout - the one which is set as the linked map series
   //frame and the one on which to set the constraint. There must also be
   //a map series defined on the layout.
   var mf = GetMapFrame(mapFrame);
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.MapSeriesLink;
   autoCamera.AutoCameraType = AutoCameraType.Extent;//set to the extent
                                                     //of the index feature

   //optional - can also set autoCamera.IntersectLayerPath

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

   //11. Display constraint "LinkedMapSeriesCenter" - there must be at least 2
   //map frames in the layout - the one which is set as the linked map series
   //frame and the one on which to set the constraint. There must also be
   //a map series defined on the layout.

   var mf = GetMapFrame(mapFrame);
   var autoCamera = mf.GetAutoCamera();
   autoCamera.Source = AutoCameraSource.MapSeriesLink;
   autoCamera.AutoCameraType = AutoCameraType.Center;//set to center of
                                                     //index feature

   //optional - intersect "IntersectLayerPath" extent with index feature
   var states = mf.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
   autoCamera.IntersectLayerPath = states.URI;

   //always validate and check we do not have a map series map frame
   if (mf.ValidateAutoCamera(autoCamera) && !mf.IsMapSeriesMapFrame())
      mf.SetAutoCamera(autoCamera);

 //Supports access and update of metadata
 public interface IMetadataInfo {
   // Returns true if the metadata can be edited otherwise false
   bool GetCanEditMetadata();
   // Returns the xml formatted metadata
   string GetMetadata();
   //Set the metadata xml. The requirements of the current style
   //should be met
   void SetMetadata(string metadataXml);
 }

 var layout = LayoutView.Active.Layout; //Assume null check...

 QueuedTask.Run(() => {
   //read the layout metadata and set it back if the metadata
   //is editable
   var metadata_xml = layout.GetMetadata();
   if (layout.GetCanEditMetadata())
      layout.SetMetadata(metadata_xml);
 });

//Check to see if a layout view exists.  If it does, activate it.

//Confirm if layout exists as a project item
LayoutProjectItem layoutItem = Project.Current.GetItems<LayoutProjectItem>().FirstOrDefault(
                                                      item => item.Name.Equals("some layout"));
if (layoutItem != null)
{
  Layout lyt = await QueuedTask.Run(() => layoutItem.GetLayout());
        
  //Next check to see if a layout view is already open that referencs the Game Board layout
  foreach (var pane in ProApp.Panes)
  {
    var lytPane = pane as ILayoutPane; 

    //if not a layout view, continue to the next pane
    if (lytPane == null)  //if not a layout view, continue to the next pane
      continue;
    
    //if there is a match, activate the view
    if (lytPane.LayoutView.Layout == lyt) 
    {
      (lytPane as Pane).Activate();
      return;
    }
  }

  //Must be on the UI thread
  await ProApp.Panes.CreateLayoutPaneAsync(layout);
  return;

  //a layout view must be active
  if (LayoutView.Active == null)
        return;
  //Check if "our" map frame is on the current layout and can be activated
  var layout = LayoutView.Active.Layout;
  var lv = LayoutView.Active;
  var mapFrame = layout.GetElementsAsFlattenedList().OfType<MapFrame>()
                       .First(mf => mf.Name == "Map 1");
  
  //Can we activate the map frame? - checks mapframe is visible, is on the active layout
  //view, has a valid map, and no other map frame (including this one) is currently activated
  //Note: we are on the UI thread!
  if (!lv.CanActivateMapFrame(mapFrame))
    return;
  //activate it
  lv.ActivateMapFrame(mapFrame);

  //Access the map and/or map view on the activated map frame
  //Note: Now we move to the QueuedTask as usual!
  QueuedTask.Run(() => {
    //zoom the map on the activated map frame
    var ext = lv.ActivatedMapView.Extent;
    var new_ext = GeometryEngine.Instance.Scale(ext, ext.Center, 2.0, 2.0);
    lv.ActivatedMapView.ZoomTo(new_ext, new TimeSpan(0, 0, 0, 0, 1500));
    //select some features
    lv.ActivatedMapView.SelectFeatures(new_ext, SelectionCombinationMethod.New);

    //note: activated map frame property is also available
    var activated_mf = LayoutView.Active.ActivatedMapFrame;//null if no activated map frame

  //a layout view must be active
  if (LayoutView.Active == null)
        return;
  //call deactivation - no map frame param needed
  //Deactivation can only be called on the active layout view. Must be called on the
  //UI thread.
  LayoutView.Active.DeactivateMapFrame();//no-op if no mapframe is activated

  //...Or 
  //To check for an activated map frame first...
  if (LayoutView.Active.ActivatedMapFrame != null)
    LayoutView.Active.DeactivateMapFrame();
  

// Find two graphic rectangle elements and set them to be selected and then zoom the page to the selection.    
if (LayoutView.Active != null)
{
  LayoutView lytView = LayoutView.Active;
  Layout lyt = await QueuedTask.Run(() => lytView.Layout);
  Element rec = lyt.FindElement("Rectangle");
  Element rec2 = lyt.FindElement("Rectangle 2");

  List<Element> elmList = new List<Element>();
  elmList.Add(rec);
  elmList.Add(rec2);
  
  //Set selection
  lytView.SelectElements(elmList);

  //Zoom to selection
  await QueuedTask.Run(() => lytView.ZoomToSelectedElements());
}

 //Detect adds and deletes of layouts
 ProjectItemsChangedEvent.Subscribe(OnProjectCollectionChanged)

 private void OnProjectCollectionChanged(ProjectItemsChangedEventArgs args) {
   if (args == null)
     return;
   var layoutItem = args.ProjectItem as LayoutProjectItem;
   if (layoutItem  == null) return;//not a layout

   Check what triggered the event and take appropriate action
   switch (args.Action) {
     //a layout is being added
     case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
         //TODO handle layout being added
         //layoutItem is the layout item being added
         var layout_name = layoutProjectItem.Name; 
         var layout = layoutProjectItem.GetLayout();//must be on QTR to call GetLayout
         break;
     case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
         //TODO handle layout being removed
         //layoutItem is the layout item being removed
         var layout_name_del = layoutProjectItem.Name; //Dont call GetLayout()!
         break;
    }
 }

 //Detect changes to the layout map series, page, and modifications to
 //layout properties (eg name) - listen for the relevant hint
 ArcGIS.Desktop.Layouts.Events.LayoutEvent.Subscribe((args) => {
    var layout = args.Layout;//The layout that was changed

    //Check what triggered the event and take appropriate action
    switch (args.Hint) {
      case LayoutEventHint.MapSeriesPageChanged:
        //TODO handle map series changed
        break;
      case LayoutEventHint.MapSeriesRefreshed:
        //TODO handle page changed
        break;
      case LayoutEventHint.PageChanged:
        var old_page = args.OldPage;
        //TODO handle page changed
        break;
      case LayoutEventHint.PropertyChanged:
        //TODO handle property changed
        break;
    }
 });

 //For UI context changes associated with a layout, subscribe to the LayoutView
 //event - views activated/deactivated, views opened/closed
 ArcGIS.Desktop.Layouts.Events.LayoutViewEvent.Subscribe((args) =>{
  //get the affected view and layout
  var layout = args.LayoutView?.Layout;
  if (layout == null) {
     //FYI layoutview and/or layout can be null...
     //eg closed, deactivation
  }
  //Check what triggered the event and take appropriate action
  switch (args.Hint) {
    case LayoutViewEventHint.Closed:
      //Layout view closed
      break;
    case LayoutViewEventHint.Opened:
      //A LayoutView has been initialized
      break;
    case LayoutViewEventHint.Activated:
      break;
    case LayoutViewEventHint.Deactivated:
      break;
    case LayoutViewEventHint.Closing:
      //Set args.Cancel = true to prevent closing
      break;
    case LayoutViewEventHint.ExtentChanged:
      //Layout extent has changed
      break;
    case LayoutViewEventHint.DrawingComplete:
      break;
    case LayoutViewEventHint.PauseDrawingChanged:
      break;
  }
});
 

ArcGIS.Desktop.Layouts.Events.ElementEvent.Subscribe((args) => {

  //Container can be Layout, GraphicsLayer, or GroupElement
  var layout = args.Container as Layout;
  if (layout == null)
    return;//we are only interested in layout
  var elems = args.Elements;//can be null or empty

  //Can also get elements/selected elements from the container
  //as needed
  var sel_elems = layout.GetSelectedElements();
  var all_elems = layout.GetElementsAsFlattenedList();

  //Check what triggered the event and take appropriate action
  switch (args.Hint) {
    case ElementEventHint.ElementAdded:
  	break;
    case ElementEventHint.ElementRemoved:
  	break;
    case ElementEventHint.SelectionChanged:
  	break;
    case ElementEventHint.MapFrameActivated:
  	break;
    case ElementEventHint.MapFrameDeactivated:
  	break;
    case ElementEventHint.MapFrameNavigated:
  	break;
    case ElementEventHint.PlacementChanged:
  	break;
    case ElementEventHint.PropertyChanged:
  	break;
    case ElementEventHint.StyleChanged:
  	break;
   }
});

///<summary>PolygonGraphicsTool derives from the LayoutTool class. Note: PolygonGraphicsTool is 
///referenced in the className attribute of
///its <tool> element in the Config.daml</summary>
internal class PolygonGraphicsTool : LayoutTool 
{
        public PolygonGraphicsTool() 
        {
         ...
        }
    ...
}

internal class PolygonGraphicsTool : LayoutTool 
{        
   public PolygonGraphicsTool() {
      SketchType = SketchGeometryType.Polygon;
   }

   protected override Task OnToolActivateAsync(bool active)
   {
      return base.OnToolActivateAsync(active);
   }
	
    protected override Task<bool> OnSketchCompleteAsync(Geometry geometry)
    {
      //if we have an active container, place a polygon graphic
      if (ActiveElementContainer == null)
        Task.FromResult(true);

      return QueuedTask.Run(() => {
        //create the polygon graphic and add it to the active container
        //use default symbology
        var cimGraphic = GraphicFactory.Instance.CreateSimpleGraphic(geometry);
        ElementFactory.Instance.CreateGraphicElement(
          this.ActiveElementContainer, cimGraphic);
        return true;
      });
    }
 }

  SketchType = SketchGeometryType.Point;
  private string _text = ".....";

 //Place text
 protected override Task<bool> OnSketchCompleteAsync(Geometry geometry)
 {
   if (ActiveElementContainer == null)
     Task.FromResult(true);

   return QueuedTask.Run(() =>  {
     //create the text graphic and add it to the active container
     //use default symbology
     var cimGraphic = GraphicFactory.Instance.CreateSimpleTextGraphic(TextType.PointText,
                      geometry, null, _text);
     ElementFactory.Instance.CreateGraphicElement(this.ActiveElementContainer, cimGraphic);
     //The new text graphic element has been created
     //To switch to Pro's out of box "esri_layouts_inlineEditTool" 
     //to allow inline editing of the text, activate the tool below...
     //This tool will work on graphics on both map view and layouts
     //FrameworkApplication.SetCurrentToolAsync("esri_layouts_inlineEditTool");
     return true;
   });
 }

 //Curved line graphics
 SketchType = SketchGeometryType.BezierLine;

 protected override Task<bool> OnSketchCompleteAsync(Geometry geometry)
 {
    return QueuedTask.Run(() => {
        //create the curved line graphic and add it to the active container
        //use default symbology
        var cimGraphic = GraphicFactory.Instance.CreateSimpleGraphic(geometry);
        ElementFactory.Instance.CreateGraphicElement(
          this.ActiveElementContainer, cimGraphic);
        return true;
   });
 }

  //Event handlers to control auto close behavior of tray button 
  private void PopupOpened(object sender, EventArgs e)
  {
    var vm = (DataContext as testtraybuttonPopupViewModel);
    vm.CanPopupAutoClose = false;
  }

  private void PopupClosed(object sender, EventArgs e)
  {
    var vm = (DataContext as testtraybuttonPopupViewModel);
    vm.CanPopupAutoClose = true;
  }

  //Property to control auto close behavior of tray button 
  private bool _canPopupAutoClose;
  public bool CanPopupAutoClose
  {
    get => _canPopupAutoClose;
    set => SetProperty(ref _canPopupAutoClose, value);
  }

    private void testtraybuttonPopupViewModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    {
      if (_popupVM == null)
        return;
      // make sure LayoutTrayButton class has correct checked state when it changes on the VM
      if (e.PropertyName == nameof(testtraybuttonPopupViewModel.IsChecked))
      {
        // Since we are changing IsChecked in OnButtonChecked
        //We don't want property notification to trigger (another) callback to OnButtonChecked
        this.SetCheckedNoCallback(_popupVM.IsChecked);
      }
      //Control auto close behavior of tray button 
      else if (e.PropertyName == nameof(testtraybuttonPopupViewModel.CanPopupAutoClose))
      {
        this.CanAutoClose = _popupVM.CanPopupAutoClose;
      }
    }

  //Construct map series on worker thread
  await QueuedTask.Run(() =>
  {
     //SpatialMapSeries constructor - required parameters
     var SMS = MapSeries.CreateSpatialMapSeries(layout, mapFrame, countiesLayer, "US Counties");
  
     //Set optional, non-default values
     SMS.CategoryField = "State";
     SMS.SortField = "Population";
     SMS.ExtentOptions = ExtentFitType.BestFit;
     SMS.MarginType = ArcGIS.Core.CIM.UnitType.PageUnits;
     SMS.MarginUnits = ArcGIS.Core.Geometry.LinearUnit.Centimeters;
     SMS.Margin = 1;

     layout.SetMapSeries(SMS);  //Will overwrite an existing map series.
  });

   //Export a map series with multiple pages to a single PDF from the active layout.
   var layout = LayoutView.Active.Layout;
   await QueuedTask.Run(() => {
      if (layout == null) return;

      // create the name of the pdf file 
      var pdf = System.IO.Path.Combine(
                     System.IO.Path.GetTempPath(), 
                     "US States.pdf");
      if (System.IO.File.Exists(pdf))
         System.IO.File.Delete(pdf);

      //Specify the exportFormat - PDF, 
      var exportFormat = new PDFFormat() {
         OutputFileName = pdf,
         Resolution = 300,
         DoCompressVectorGraphics = true,
         DoEmbedFonts = true,
         HasGeoRefInfo = true,
         ImageCompression = ImageCompression.Adaptive,
         ImageQuality = ImageQuality.Better,
         LayersAndAttributes = LayersAndAttributes.LayersAndAttributes
     };

     //Set up map series export options, 
     //this is new at 2.3
     var mapSeriesExportOptions = new MapSeriesExportOptions() {
          ExportPages = ExportPages.Custom, //All, Current, SelectedIndexFeatures
          CustomPages = "1-3",
          ExportFileOptions = ExportFileOptions.ExportAsSinglePDF,
     };
     //Note:
     //use ExportFileOptions.ExportMultipleNames or ExportFileOptions.ExportMultipleNumbers
     //for multi file exports. Your pdf file name is modified with a suffix per map sheet

     //Check to see if the path is valid and export
     if (exportFormat.ValidateOutputFilePath()) {
         layout.Export(exportFormat, mapSeriesExportOptions);
         //pop the pdf
         System.Diagnostics.Process.Start(pdf);
     }
 });

 //Gets and sets the application layout options,
 public class LayoutOptions {
   //Gets and sets whether the insert tool stays active or reverts back to select after 
   //adding a new element.
   public bool KeepLastToolActive { get; set; }
   //Gets and sets whether a warning will be shown when deleting a map frame will
   //result in other elements in the layout being deleted.
   public bool WarnAboutAssociatedSurrounds { get; set; }
   //Gets and sets the default path for the location of the layout template gallery
   public string LayoutTemplatePath { get; set; }

   //Gets the application default layout guide color.
   public CIMColor DefaultGuideColor { get; }
   //Gets the application layout guide color. This method must be called on the MCT.
   //Use QueuedTask.Run.
   public CIMColor GetGuideColor();
   //Sets the layout guide color. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetGuideColor(CIMColor color);
 }

 //Get current layout options
 var lastToolActive = ApplicationOptions.LayoutOptions.KeepLastToolActive;
 var warnOnSurrounds = ApplicationOptions.LayoutOptions.WarnAboutAssociatedSurrounds;
 //eg <Install_Path>\Resources\LayoutTemplates\en-US
 var gallery_path = ApplicationOptions.LayoutOptions.LayoutTemplatePath;
 var defaultGuideColor = ApplicationOptions.LayoutOptions.DefaultGuideColor;

 //Set layout options
 //keep graphic element insert tool active
 ApplicationOptions.LayoutOptions.KeepLastToolActive = true;
 //no warning when deleting a map frame results in other elements being deleted
 ApplicationOptions.LayoutOptions.WarnAboutAssociatedSurrounds = false;
 //path to .pagx files used as templates
 ApplicationOptions.LayoutOptions.LayoutTemplatePath = @"D:\data\layout_templates";
 QueuedTask.Run(() =>
 {
    var guideColor = ApplicationOptions.LayoutOptions.GetGuideColor();
    // set guide color
    ApplicationOptions.LayoutOptions.SetGuideColor(ColorFactory.Instance.RedRGB);
 });

 //Gets and sets the application options for default font and graphic element symbology.
 public class TextAndGraphicsElementsOptions {
   //Gets the list of available fonts in the application for the Pro session. This
   //method must be called on the MCT. Use QueuedTask.Run.
   public IReadOnlyList<(string fontName, List<string> fontStyles)> GetAvailableFonts();
   //Gets the application default font family name and style. This method must be called on 
   //the MCT. Use QueuedTask.Run.
   public (string fontName, string styleName) GetDefaultFont();
   //Gets the application default line symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public CIMLineSymbol GetDefaultLineSymbol();
   //Gets the application default point symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public CIMPointSymbol GetDefaultPointSymbol();
   //Gets the application default polygon symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public CIMPolygonSymbol GetDefaultPolygonSymbol();
   //Gets the application default text symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public CIMTextSymbol GetDefaultTextSymbol();

   //Sets the application default font family name with a default style. This method must be called on the MCT. 
   //Use QueuedTask.Run.
   public void SetDefaultFont(string familyName);
   //Sets the application default font family name and style. This method must be called on the MCT. Use 
   //QueuedTask.Run.
   public void SetDefaultFont(string familyName, string styleName);
   //Sets the application default line symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetDefaultLineSymbol(CIMLineSymbol lineSymbol);
   //Sets the application default point symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetDefaultPointSymbol(CIMPointSymbol pointSymbol);
   //Sets the application default polygon symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetDefaultPolygonSymbol(CIMPolygonSymbol polygonSymbol);
   //Sets the application default text symbol. This method must be called on the MCT. Use QueuedTask.Run.
   public void SetDefaultTextSymbol(CIMTextSymbol textSymbol);
}

 //Get a list of all the available fonts (or use 'SymbolFactory.Instance.GetAvailableFonts()')
 QueuedTask.Run(() =>  {
    //A list of tuples of Font name + associated Font Styles, one tuple per
    //font, is returned
    var fonts = ApplicationOptions.TextAndGraphicsElementsOptions.GetAvailableFonts();
    StringBuilder sb = new StringBuilder();
    sb.AppendLine("Pro Fonts\r\n============================");
    foreach (var font in fonts) {
       var styles = string.Join(",", font.fontStyles);
       sb.AppendLine($"{font.fontName}, [{styles}]");
    }
    System.Diagnostics.Debug.WriteLine(sb.ToString());
 });

 //Get and Set the default TextAndGraphicsElementsOptions options values
 QueuedTask.Run(() => {
   //Get the default font (see also 'SymbolFactory.Instance.DefaultFont')
   var def_font = ApplicationOptions.TextAndGraphicsElementsOptions.GetDefaultFont();
   System.Diagnostics.Debug.WriteLine(
        $"\r\ndefault font: {def_font.fontName}, {def_font.styleName}");
      
   //Get the default graphics element symbols - point, line, poly, text
   var ptSymbol = ApplicationOptions.TextAndGraphicsElementsOptions.GetDefaultPointSymbol();
   var lineSymbol = ApplicationOptions.TextAndGraphicsElementsOptions.GetDefaultLineSymbol();
   var polySymbol = ApplicationOptions.TextAndGraphicsElementsOptions.GetDefaultPolygonSymbol();
   var textSymbol = ApplicationOptions.TextAndGraphicsElementsOptions.GetDefaultTextSymbol();

   //Set the options
   //Create some symbols
   var ptSymbol2 = SymbolFactory.Instance.ConstructPointSymbol(
        ColorFactory.Instance.RedRGB, 14, SimpleMarkerStyle.Diamond);
   var lineSymbol2 = SymbolFactory.Instance.ConstructLineSymbol(
        ColorFactory.Instance.RedRGB, 2, SimpleLineStyle.Dash);
   var polySymbol2 = SymbolFactory.Instance.ConstructPolygonSymbol(
        ColorFactory.Instance.RedRGB, SimpleFillStyle.DiagonalCross);
   var textSymbol2 = SymbolFactory.Instance.ConstructTextSymbol(
        ColorFactory.Instance.RedRGB, 12);

   //Set a default font. Use its default style
   ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultFont("tahoma");
   //or specify an explicit style
   ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultFont("tahoma", "bold");

   //Set default point, line, poly, text graphics element symbols
   ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultPointSymbol(ptSymbol2);
   ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultLineSymbol(lineSymbol2);
   ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultPolygonSymbol(polySymbol2);
   ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultTextSymbol(textSymbol2);
 });