ProSnippets Layouts
Language: C#
Subject: Layouts
Contributor: ArcGIS Pro SDK Team <[email protected]>
Organization: Esri, http://www.esri.com
Date: 11/7/2025
ArcGIS Pro: 3.6
Visual Studio: 2022
var templateFileName = "Layout.pagx";
// Get layout Template Path from the project's home folder and combine it with a file name
var projectPath = CoreModule.CurrentProject.HomeFolderPath;
var layoutTemplateFilePath = System.IO.Path.Combine(projectPath, templateFileName);
// Create a new layout project item with the layout file path
// Create an IProjectItem using a layout template pagx file
IProjectItem pagx = ItemFactory.Instance.Create(layoutTemplateFilePath) as IProjectItem;
// Add the IProjectItem to the current project
//Note: Needs QueuedTask to run
Project.Current.AddItem(pagx);LayoutProjectItem layoutItemByName = Project.Current.GetItems<LayoutProjectItem>()
.FirstOrDefault((lpi) => lpi.Name == "MyLayout");
//Note: Needs QueuedTask to run
Layout layoutByName = layoutItemByName.GetLayout();//Reference layout project items and their associated layout.
//A layout project item is an item that appears in the Layouts
//folder in the Catalog pane.
//Reference all the layout project items
IEnumerable<LayoutProjectItem> layoutProjectItems =
Project.Current.GetItems<LayoutProjectItem>();
//Or reference a specific layout project item by name
LayoutProjectItem specificLayoutItem = Project.Current.GetItems<LayoutProjectItem>()
.FirstOrDefault(item => item.Name.Equals("MyLayoutItem"));//Open a layout project item in a new view.
//A layout project item may exist but it may not be open in a view.
//Reference a layout project item by name
LayoutProjectItem layoutItemByName = Project.Current.GetItems<LayoutProjectItem>()
.FirstOrDefault(item => item.Name.Equals("MyLayoutItem"));
//Get the layout associated with the layout project item
//Note: Needs QueuedTask to run
Layout layoutFromItem = layoutItemByName.GetLayout(); //Worker thread
//Create the new pane - call on UI
ILayoutPane iNewLayoutPane = await ProApp.Panes.CreateLayoutPaneAsync(layout); //GUI thread//Activate an already open layout view.
//A layout view may be open but it may not be active.
//Find the pane that references the layout and activate it.
//Note - there can be multiple panes referencing the same layout.
foreach (var pane in ProApp.Panes)
{
var layoutPane = pane as ILayoutPane;
if (layoutPane == null) //if not a layout view, continue to the next pane
continue;
if (layoutPane.LayoutView.Layout == layout) //activate the view
{
(layoutPane as Pane).Activate();
return;
}
}//Reference the active layout view.
//Confirm if the current, active view is a layout view.
//If it is, do something.
LayoutView activeLayoutView = LayoutView.Active;
if (activeLayoutView != null)
{
// do something
}//Create a layout project item from importing a pagx file
//Note: Needs QueuedTask to run
IProjectItem pagx = ItemFactory.Instance.Create(
@"C:\Temp\Layout.pagx") as IProjectItem;
Project.Current.AddItem(pagx);//Remove a layout project item.
//Remove the layout from the project
//Note: Needs QueuedTask to run
Project.Current.RemoveItem(layoutItem);//Create a new, basic layout and open it.
//Create layout with minimum set of parameters on the worker thread
//Note: Needs QueuedTask to run
var myNewLayout = LayoutFactory.Instance.CreateLayout(8.5, 11, LinearUnit.Inches);
myNewLayout.SetName("New 8.5x11 Layout");
//Open new layout on the GUI thread
await ProApp.Panes.CreateLayoutPaneAsync(myNewLayout);//Create a new layout using a modified CIM and open it.
//The CIM exposes additional members that may not be
//available through the managed API.
//In this example, optional guides are added.
//Create a new CIMLayout on the worker thread
//Note: Needs QueuedTask to run
//Set up a CIM page
CIMPage newPage = new CIMPage
{
//required parameters
Width = 8.5,
Height = 11,
Units = LinearUnit.Inches,
//optional rulers
ShowRulers = true,
SmallestRulerDivision = 0.5,
//optional guides
ShowGuides = true
};
CIMGuide guide1 = new CIMGuide
{
Position = 1,
Orientation = Orientation.Vertical
};
CIMGuide guide2 = new CIMGuide
{
Position = 6.5,
Orientation = Orientation.Vertical
};
CIMGuide guide3 = new CIMGuide
{
Position = 1,
Orientation = Orientation.Horizontal
};
CIMGuide guide4 = new CIMGuide
{
Position = 10,
Orientation = Orientation.Horizontal
};
List<CIMGuide> guideList = new List<CIMGuide>
{
guide1,
guide2,
guide3,
guide4
};
newPage.Guides = guideList.ToArray();
//Construct the new layout using the customized cim definitions
var layout_local = LayoutFactory.Instance.CreateLayout(newPage);
layout_local.SetName("New 8.5x11 Layout");
//Open new layout on the GUI thread
await ProApp.Panes.CreateLayoutPaneAsync(layout_local);//Change the layout page size.
//Reference the layout project item
LayoutProjectItem lytItem = Project.Current.GetItems<LayoutProjectItem>()
.FirstOrDefault(item => item.Name.Equals("MyLayoutItem"));
if (layoutItem != null)
{
//Note: Needs QueuedTask to run
//Get the layout
Layout lyt = lytItem.GetLayout();
if (lyt != null)
{
//Change properties
CIMPage page = lyt.GetPage();
page.Width = 8.5;
page.Height = 11;
//Apply the changes to the layout
lyt.SetPage(page);
}
}//Note: Must be on QueuedTask.Run
//Build geometry
Coordinate2D center = new Coordinate2D(2, 4);
EllipticArcSegment circle_seg = EllipticArcBuilderEx.CreateCircle(
new Coordinate2D(2, 4), 0.5, ArcOrientation.ArcClockwise, null);
var circle_poly = PolygonBuilderEx.CreatePolygon(PolylineBuilderEx.CreatePolyline(circle_seg));
//PolylineBuilderEx.CreatePolyline(cir, AttributeFlags.AllAttributes));
//Set symbology, create and add element to layout
CIMStroke outline = SymbolFactory.Instance.ConstructStroke(
ColorFactory.Instance.BlackRGB, 2.0, SimpleLineStyle.Dash);
CIMPolygonSymbol circleSym = SymbolFactory.Instance.ConstructPolygonSymbol(
ColorFactory.Instance.RedRGB, SimpleFillStyle.Solid, outline);
SymbolFactory.Instance.ConstructPolygonSymbol(null,
SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.RedRGB, 2));
var circleGraphic = GraphicFactory.Instance.CreateSimpleGraphic(circle_poly, circleSym);
//Make an element to add to GraphicsLayer or Layout
//var elemInfo = new ElementInfo() { Anchor = Anchor.CenterPoint };
//GraphicElement cirElm = ElementFactory.Instance.CreateGraphicElement(
// layout, circleGraphic, "New Circle", true, elemInfo);//Note: Must be on 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";
var graphic = GraphicFactory.Instance.CreateSimpleTextGraphic(
TextType.CircleParagraph, poly, sym, text);
//Make an element to add to GraphicsLayer or Layout
//var ge = ElementFactory.Instance.CreateGraphicElement(layout, graphic,
// "New Circle Text", true);//Note: Must be on 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 graphic = GraphicFactory.Instance.CreateSimpleTextGraphic(
TextType.SplinedText, bezPl, sym, "Splined text");
//Make an element to add to GraphicsLayer or Layout
//var ge = ElementFactory.Instance.CreateGraphicElement(layout, graphic);//Note: Must be on QueuedTask.Run
//Build geometry
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);
var graphic = GraphicFactory.Instance.CreateLegendPatchGraphic(
PatchShape.AreaBoundary, poly.Extent, polySym);
//Make an element to add to GraphicsLayer or Layout
//
//var elemInfo = new ElementInfo()
//{
// CustomProperties = null,
// Anchor = Anchor.LeftMidPoint
//};
//var ge = ElementFactory.Instance.CreateGraphicElement(layout, graphic,
// "New Legend Patch", true, elemInfo);//Note: Must be on 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);
//Set up the arrow info
var arrowInfo = new ArrowInfo()
{
ArrowHeadKey = ArrowInfo.DefaultArrowHeadKeys[1],
ArrowOnBothEnds = true,
ArrowSizePoints = 30,
LineWidthPoints = 15
};
var graphic = GraphicFactory.Instance.CreateArrowGraphic(linePl, arrowInfo);
//Make an element to add to GraphicsLayer or Layout
//var ge = ElementFactory.Instance.CreateGraphicElement(
// layout, graphic, "Arrow Line", false);//Note: Must be on QueuedTask.Run
//Build geometry
Coordinate2D ll = new Coordinate2D(3.5, 1);
Coordinate2D ur = new Coordinate2D(5.5, 2);
Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
string picPath = System.IO.Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), "SamplePicture.jpg");
//Create and add element to layout
var graphic = GraphicFactory.Instance.CreatePictureGraphic(env.Center, picPath);
//Make an element to add to GraphicsLayer or Layout
//var ge = ElementFactory.Instance.CreateGraphicElement(layout, graphic);//given a graphic, extract its outline geometry
var graphic_outline = GraphicFactory.Instance.GetGraphicOutline(
layout, cimGraphic);
//TODO - use the geometry - eg, make another graphic
var outline_graphic = GraphicFactory.Instance.CreateSimpleGraphic(graphic_outline);
//... etc.//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.//Note: Must be on 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");//Note: Must be on 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");//Note: Must be on 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");//Note: Must be on 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.Current.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");//Note: Must be on QueuedTask.Run(() => { ...
//Build geometry
Coordinate2D coord2D = new Coordinate2D(2.0, 10.0);
//Reference a point symbol in a style
StyleProjectItem stylePrjItm = Project.Current.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);//Note: Must be on 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);//Note: Must be on 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);//Note: Must be on 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");//Note:Must be on 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);//Note: on the QueuedTask
//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);//Note: Must be on 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);//Note: Must be on 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);//Note: Must be on 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 a simple 2D point graphic and apply an existing point style item as the symbology.
//Note: Must be on 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.Current.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 a simple 2D line graphic and apply an existing line
//style item as the symbology.
//Note: Must be on 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.Current.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 a simple 2D rectangle graphic and apply simple fill and
//outline symbols.
//Note: Must be on 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 a simple point text element and assign basic symbology and text settings.
//Note: Must be on 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);//Note: Must be on 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 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
//Note: Must be on 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"));//Note: Must be on 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);//Note: Must be on 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);//Note: Must be on 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");//Note: Must be on 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);//Note: Must be on 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 });//Note: Must be on 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);PredefinedShape shapeType = PredefinedShape.Circle;
//Note: Must be on 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);//Note: Must be on 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);//Note: Must be on 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 });//Note: Must be on 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");//Note: Must be on 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 picture element and also set background and border symbology.
//Note: Must be on 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 a map frame and set its camera by zooming to the extent of an existing bookmark.
//Construct on the worker thread
//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.Current.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 a legend for an associated map frame.
//Note: Must be on 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 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");
//Note: Must be on 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 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");
//Construct on the worker thread
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 a table frame.
//Note: Must be on 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;//Note: 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);//Note: Must be on 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);//Note: Must be on 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");//Note: Must be on QueuedTask.Run
//Build geometry
Coordinate2D center = new Coordinate2D(7, 5.5);
//Reference a North Arrow in a style
StyleProjectItem stylePrjItm = Project.Current.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);//Note: Must be on 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;//Note: Must be on 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.Current.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;//Note: Must be on 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.Current.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;//Create an empty group element at the root level of the contents pane
//Note: Must be on 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 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
};
//Note: Must be on 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" };
//Note: Must be on QueuedTask.Run
var elemToGroup = layout.FindElements(elmNameList);
GroupElement groupWithListOfElementNamesAtRoot =
ElementFactory.Instance.CreateGroupElement(
layout, elemToGroup, "Group with list of element names at root");//Find an element on a layout.
//Note: Must be on QueuedTask.Run
// Reference and load the layout associated with the layout item
Layout mylayout = layoutItem.GetLayout();
if (mylayout != null)
{
//Find a single specific element
Element rect = mylayout.FindElement("Rectangle") as Element;
//Or use the Elements collection
Element rect2 = mylayout.Elements.FirstOrDefault(item => item.Name.Equals("Rectangle"));
}//Note: Must be on QueuedTask.Run
//Find elements by name
var layoutElementsToFind = layout.FindElements(new List<string>() { "Point 1", "Line 3", "Text 1" });
//Get the collection of elements from the page layout. Nesting within GroupElement is preserved.
var elementCollection = layout.GetElements();
//Get the collection of Element from the page layout as a flattened list. Nested groups within GroupElement are not preserved.
var elements = layout.GetElementsAsFlattenedList();
//Convert collection of the elements to a collection of GraphicElements.
var graphicElements = elements.ToList().ConvertAll(x => (GraphicElement)x);
//Find elements by type
//Find all point graphics in the Layout
var pointGraphics = graphicElements.Where(elem => elem.GetGraphic() is CIMPointGraphic);
//Find all line graphics in the Graphics Layer
var lineGraphics = graphicElements.Where(elem => elem.GetGraphic() is CIMLineGraphic);
////Find all polygon graphics in the Graphics Layer
var polyGraphics = graphicElements.Where(elem => elem.GetGraphic() is CIMPolygonGraphic);
////Find all text graphics in the Graphics Layer
var textGraphics = graphicElements.Where(elem => elem.GetGraphic() is CIMTextGraphic);
////Find all picture graphics in the Graphics Layer
var pictureGraphic = graphicElements.Where(elem => elem.GetGraphic() is CIMPictureGraphic);//Update an element's properties.
//Note: Must be on QueuedTask.Run
//Find a single specific element
element = layout.FindElement("Rectangle") as Element;
// update an element's name
element.SetName("New Name");
// update and element's visibility
element.SetVisible(true);//Get element's selection count.
//Count the number of selected elements on the active layout view
LayoutView activeLayoutView = LayoutView.Active;
if (activeLayoutView != null)
{
var selectedElements = activeLayoutView.GetSelectedElements();
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show($@"Selected elements: {selectedElements.Count}");
}//Set the active layout view's selection to include 2 rectangle elements.
//Reference the active view
LayoutView activeLayoutView = LayoutView.Active;
if (activeLayoutView != null)
{
//Note: Must be on QueuedTask.Run
//Reference the layout
Layout lyt = activeLayoutView.Layout;
//Reference the two rectangle elements
Element rec = lyt.FindElement("Rectangle");
Element rec2 = lyt.FindElement("Rectangle 2");
//Construct a list and add the elements
List<Element> elmList = new List<Element>
{
rec,
rec2
};
//Set the selection
activeLayoutView.SelectElements(elmList);
}//Unselect one element.
var elementToUnSelect = layout.FindElements(new List<string>() { "MyPoint" }).FirstOrDefault();
layout.UnSelectElement(elementToUnSelect);
//Unselect multiple elements.
var elementsToUnSelect = layout.FindElements(new List<string>() { "Point 1", "Line 3", "Text 1" });
layout.UnSelectElements(elementsToUnSelect);//Unselect one element.
var elementToUnSelectInView = layout.FindElements(new List<string>() { "MyPoint" }).FirstOrDefault();
layoutView.UnSelectElement(elementToUnSelectInView);
//Unselect multiple elements.
var elementsToUnSelectInView = layout.FindElements(new List<string>() { "Point 1", "Line 3", "Text 1" });
layoutView.UnSelectElements(elementsToUnSelectInView);//If the a layout view is active, clear its selection
LayoutView activeLayoutView = LayoutView.Active;
if (activeLayoutView != null)
{
activeLayoutView.ClearElementSelection();
}//Clear the layout selection.
layout.ClearElementSelection();//Note: Must be on QueuedTask.Run
var elems = layout.FindElements(new List<string>() { "Point 1", "Line 3", "Text 1" });
var copiedElements = layout.CopyElements(elems);//Note: Must be on QueuedTask.Run
var elementsToRemove = layout.GetSelectedElements();
layout.DeleteElements(elementsToRemove);//Delete an element or elements on a layout.
//Note: Must be on QueuedTask.Run
//Delete a specific element on a layout
//Find a single specific element
Element rect = layout.FindElement("Rectangle") as Element;
layout.DeleteElement(rect);
//Or delete a group of elements using a filter
layout.DeleteElements(item => item.Name.Contains("Clone"));
//Or delete all elements on a layout
layout.DeleteElements(item => true);LayoutView lytView = LayoutView.Active;
//Zoom to an element
var elementToZoomTo = layout.FindElements(new List<string>() { "MyPoint" }).FirstOrDefault();
lytView.ZoomToElement(elementToZoomTo);
//Zoom to multiple elements.
var elementsToZoomTo = layout.FindElements(new List<string>() { "Point 1", "Line 3", "Text 1" });
lytView.ZoomToElements(elementsToZoomTo);//Set the CIM halo properties of a north arrow.
//Reference the first selected north arrow element
var northArrow = LayoutView.Active.GetSelectedElements().OfType<NorthArrow>().First();
//Note: Must be on QueuedTask.Run
//Get definition of north arrow...
var cim = northArrow.GetDefinition() as CIMMarkerNorthArrow;
//this halo symbol is 50% transparent, no outline (i.e. 0 width)
//First construct a polygon symbol to use in the Halo
//Polygon symbol will need a fill and a stroke
var polyFill = SymbolFactory.Instance.ConstructSolidFill(ColorFactory.Instance.CreateRGBColor(0, 0, 0, 50));
var polyStroke = SymbolFactory.Instance.ConstructStroke(ColorFactory.Instance.BlackRGB, 0);
var haloPoly = SymbolFactory.Instance.ConstructPolygonSymbol(polyFill, polyStroke);
//Set the north arrow definition of HaloSymbol and HaloSize
((CIMPointSymbol)cim.PointSymbol.Symbol).HaloSymbol = haloPoly;
((CIMPointSymbol)cim.PointSymbol.Symbol).HaloSize = 3;//size of the halo
//Apply the CIM changes back to the element
northArrow.SetDefinition(cim);//Note: Must be on QueuedTask.Run
var elemsToGroup = layout.GetSelectedElements();
//Note: run within the QueuedTask
//group elements
var newGroupElement = layout.GroupElements(elemsToGroup);//Note: Must be on QueuedTask.Run
var selectedElements = layout.GetSelectedElements().ToList();
if (selectedElements?.Any() == false)//must be at least 1.
return;
var elementsToUnGroup = new List<GroupElement>();
//All selected elements should be grouped elements.
if (selectedElements.Count() == selectedElements.OfType<GroupElement>().Count())
{
//Convert to a GroupElement list.
elementsToUnGroup = selectedElements.ConvertAll(x => (GroupElement)x);
}
if (elementsToUnGroup.Count() == 0)
return;
//UnGroup many grouped elements
layout.UnGroupElements(elementsToUnGroup);
//Ungroup one grouped element
layout.UnGroupElement(elementsToUnGroup.FirstOrDefault());//check the parent
var parent = groupElement.Elements.First().GetParent();//will be the group element
//top-most parent
//will be a GraphicsLayer or Layout
var top_most = groupElement.Elements.First().GetParent(true);// Nested groups within ArcGIS.Desktop.Layouts.GroupElement are not preserved.
var children = groupElement.GetElementsAsFlattenedList();//Note: Must be on QueuedTask.Run
//get the current selection set
var sel_elems = layout.GetSelectedElements();
//can they be brought forward? This will also check that all elements have the same parent
if (layout.CanBringForward(sel_elems))
{
//bring forward
layout.BringForward(sel_elems);
//bring to front (of parent)
//graphicsLayer.BringToFront(sel_elems);
}
else if (layout.CanSendBackward(sel_elems))
{
//send back
layout.SendBackward(sel_elems);
//send to the back (of parent)
//graphicsLayer.SendToBack(sel_elems);
}var selElementsZOrder = layout.GetSelectedElements();
//list out the z order
foreach (var elem in selElementsZOrder)
System.Diagnostics.Debug.WriteLine($"{elem.Name}: z-order {elem.ZOrder}");//Update text element properties for an existing text element.
//Note: Must be on QueuedTask.Run
// Reference and load the layout associated with the layout item
if (layout != null)
{
// Reference a text element by name
TextElement txtElm = layout.FindElement("MyTextElement") as TextElement;
if (txtElm != null)
{
double x = 2.0;
double y = 3.0;
// Change placement properties
txtElm.SetAnchor(Anchor.CenterPoint);
txtElm.SetX(x);
txtElm.SetY(y);
// Change TextProperties
TextProperties txtProperties = new TextProperties(
"Hello world", "Times New Roman", 48, "Regular");
txtElm.SetTextProperties(txtProperties);
}//Update a picture element.
//Note: Must be on QueuedTask.Run
// Reference a picture element by name
PictureElement picElm = layout.FindElement("MyPicture") as PictureElement;
// Change the path to a new source
if (picElm != null)
picElm.SetSourcePath(@"D:\MyData\Pics\somePic.jpg");//Apply a background color to the map frame element using the CIM.
//Note: Must be on QueuedTask.Run
//Get the map frame's definition in order to modify the background.
var mapFrameDefn = mapFrame.GetDefinition() as CIMMapFrame;
//Construct the polygon symbol to use to create a background
var polySymbol = SymbolFactory.Instance.ConstructPolygonSymbol(
ColorFactory.Instance.BlueRGB, SimpleFillStyle.Solid);
//Set the background
mapFrameDefn.GraphicFrame.BackgroundSymbol =
polySymbol.MakeSymbolReference();
//Set the map frame definition
mapFrame.SetDefinition(mapFrameDefn);//Update a map surround.
//Note: Must be on QueuedTask.Run
// Reference and load the layout associated with the layout item
// Reference a scale bar element by name
MapSurround scaleBar = layout.FindElement("MyScaleBar") as MapSurround;
// Reference a map frame element by name
MapFrame mf = layout.FindElement("MyMapFrame") as MapFrame;
if ((scaleBar != null) && (mf != null))
//Set the scale bar to the newly referenced map frame
scaleBar.SetMapFrame(mf);// The Locked property is displayed in the TOC as a lock symbol next
// to each element. If locked the element can't be selected in the layout
// using the graphic selection tools.
//Note: Must be on QueuedTask.Run
//Reference an element
if (element != null)
{
// Modify the Locked property via the CIM
CIMElement CIMElement = element.GetDefinition() as CIMElement;
CIMElement.Locked = true;
element.SetDefinition(CIMElement);
}//Update an element's transparency using the CIM.
//Note: Must be on QueuedTask.Run
// Reference a element by name
GraphicElement graphicElement = layout.FindElement("MyElement") as GraphicElement;
if (graphicElement != null)
{
// Modify the Transparency property that exists only in the CIMGraphic class.
CIMGraphic CIMGraphic = graphicElement.GetGraphic() as CIMGraphic;
CIMGraphic.Transparency = 50; // mark it 50% transparent
graphicElement.SetGraphic(CIMGraphic);
}//Clone a layout graphic element and apply an offset.
//Note: Must be on QueuedTask.Run
// Reference a graphic element by name
GraphicElement graphicElement =
layout.FindElement("MyElement") as GraphicElement;
if (graphicElement != null)
{
//Clone and set the new x,y
GraphicElement cloneElement = graphicElement.Clone("Clone");
double xOffset = 0;
double yOffset = 0;
cloneElement.SetX(cloneElement.GetX() + xOffset);
cloneElement.SetY(cloneElement.GetY() + yOffset);
}//Note: Must be on 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");
if (styleProjectItem == null) return;
//Get the north arrow style item you need
var northArrowStyleItem =
styleProjectItem.SearchSymbols(StyleItemType.NorthArrow, "ArcGIS North 18").FirstOrDefault();
if (northArrowStyleItem == null) return;
//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);
}//Note: Must be on 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.OfType<StyleProjectItem>().FirstOrDefault(s => s.Name == "ArcGIS 2D");
if (styleProjectItem == null) return;
//Get the grid style item you need
var gridStyleItem =
styleProjectItem.SearchSymbols(StyleItemType.Grid, "Blue Vertical Label Graticule").FirstOrDefault();
if (gridStyleItem == null) return;
var symbolItemName = gridStyleItem.Name;
var girdGraticuleObject = gridStyleItem.GetObject() as CIMMapGrid;
var cmf = mapFrame.GetDefinition() as CIMMapFrame;
//note, if page units are _not_ inches then grid's gridline
//lengths and offsets would need to be converted to the page units
var mapGrids = new List<CIMMapGrid>();
if (cmf.Grids != null)
mapGrids.AddRange(cmf.Grids);
switch (girdGraticuleObject)
{
case CIMGraticule:
var gridGraticule = girdGraticuleObject as CIMGraticule;
gridGraticule.Name = symbolItemName;
gridGraticule.SetGeographicCoordinateSystem(mapFrame.Map.SpatialReference);
//assign grid to the frame
mapGrids.Add(gridGraticule);
break;
case CIMMeasuredGrid:
var gridMeasure = girdGraticuleObject as CIMMeasuredGrid;
gridMeasure.Name = symbolItemName;
gridMeasure.SetProjectedCoordinateSystem(mapFrame.Map.SpatialReference);
//assign grid to the frame
mapGrids.Add(gridMeasure);
break;
case CIMReferenceGrid:
var gridReference = girdGraticuleObject as CIMReferenceGrid;
gridReference.Name = symbolItemName;
//assign grid to the frame
mapGrids.Add(gridReference);
break;
}
cmf.Grids = mapGrids.ToArray();
mapFrame.SetDefinition(cmf);//Note: Run within QueuedTask context.
//Get the Style project items in the project
var styleProjectItems = Project.Current?.GetItems<StyleProjectItem>();
//Get the ArcGIS 2D Style Project Item
var styleProjectItem =
styleProjectItems.OfType<StyleProjectItem>().FirstOrDefault(s => s.Name == "ArcGIS 2D");
if (styleProjectItem == null) return;
//Get the north arrow style item you need
var pointStyleItem =
styleProjectItem.SearchSymbols(StyleItemType.PointSymbol, "Circle 3").FirstOrDefault();
if (pointStyleItem == null) return;
//Select a North arrow layout element
var layoutPointElement = layout.GetSelectedElements().FirstOrDefault();
if (layoutPointElement != null && layoutPointElement is GraphicElement ge)
{
if (layoutPointElement.CanApplyStyle(pointStyleItem))
{
//The magic happens here
//for Graphic Elements such as Point, Lines, Polys, text, preserve size.
ge.ApplyStyle(pointStyleItem, true);
}
}//enable snapping
ArcGIS.Desktop.Layouts.LayoutSnapping.IsEnabled = true;
// disable snapping
ArcGIS.Desktop.Layouts.LayoutSnapping.IsEnabled = false;// sets only the Guide snapping mode
ArcGIS.Desktop.Layouts.LayoutSnapping.SetSnapModes(new[] { LayoutSnapMode.Guide });
// sets only Element and Page snapping modes
ArcGIS.Desktop.Layouts.LayoutSnapping.SetSnapModes(new[] { LayoutSnapMode.Element, LayoutSnapMode.Page });
// clear all snap modes
ArcGIS.Desktop.Layouts.LayoutSnapping.SetSnapModes(null);
// set snap modes one at a time
ArcGIS.Desktop.Layouts.LayoutSnapping.SetSnapMode(LayoutSnapMode.Margins, true);
ArcGIS.Desktop.Layouts.LayoutSnapping.SetSnapMode(LayoutSnapMode.Guide, true);
/// LayoutSnapping.SetSnapModes(new[]{ LayoutSnapMode.Guide }); // sets only the Guide snapping mode
// get current snap modes
var snapModes = ArcGIS.Desktop.Layouts.LayoutSnapping.SnapModes;
// get state of a specific snap mode
bool isOn = ArcGIS.Desktop.Layouts.LayoutSnapping.GetSnapMode(LayoutSnapMode.Guide);//Note: Must be on QueuedTask.Run
//Gets the Layout metadata.
var layout_xml = layout.GetMetadata();
//Can metadata be edited?
if (layout.GetCanEditMetadata())
//Set the metadata back
layout.SetMetadata(layout_xml);//Change the map associated with a map frame
//Find a map frame element from a layout by the map frame's element name
MapFrame mfrm = layout.FindElement("Map Frame") as MapFrame;
//Note: Must be on QueuedTask.Run
//Reference map from the project item
Map myMap = Project.Current.GetItems<MapProjectItem>().FirstOrDefault(m => m.Name.Equals("Map1")).GetMap();
//Set the map to the map frame
mfrm.SetMap(map);//Change a map frame's camera settings.
//Reference MapFrame
MapFrame mf = layout.FindElement("Map Frame") as MapFrame;
//Reference the camera associated with the map frame and change the scale
Camera cam = mf.Camera;
cam.Scale = 100000;
//Set the map frame extent based on the new camera info
mf.SetCamera(cam);//Zoom map frame to the extent of a single layer.
//Note: Must be on QueuedTask.Run
//Reference map and layer
Map m = mapFrame.Map;
FeatureLayer lyr = m.FindLayers("GreatLakes").First() as FeatureLayer;
//Set the map frame extent to all features in the layer
mapFrame.SetCamera(lyr, false);//Change the extent of a map frame to the selected features multiple layers.
//Note: Must be on QueuedTask.Run
//Reference MapFrame
//Reference map, layers and create layer list
Map m = mapFrame.Map;
FeatureLayer fl_1 = m.FindLayers("GreatLakes").First() as FeatureLayer;
FeatureLayer fl_2 = m.FindLayers("States_WithRegions").First() as FeatureLayer;
var layers = new[] { fl_1, fl_2 };
//IEnumerable<Layer> layers = m.Layers; //This creates a list of ALL layers in map.
//Set the map frame extent to the selected features in the list of layers
mapFrame.SetCamera(layers, true);//Change map frame extent to single feature with 10 percent buffer
//Note: Must be on QueuedTask.Run
//Reference the mapframe and its associated map
Map m = mapFrame.Map;
//Reference a feature layer and build a query (to return a single feature)
FeatureLayer fl = m.FindLayers("GreatLakes").First() as FeatureLayer;
QueryFilter qf = new QueryFilter();
string whereClause = "NAME = 'Lake Erie'";
qf.WhereClause = whereClause;
//Zoom to the feature
using (ArcGIS.Core.Data.RowCursor rowCursor = fl.Search(qf))
{
while (rowCursor.MoveNext())
{
//Get the shape from the row and set extent
using (var feature = rowCursor.Current as ArcGIS.Core.Data.Feature)
{
Polygon polygon = feature.GetShape() as Polygon;
Envelope env = polygon.Extent as Envelope;
mapFrame.SetCamera(env);
//Zoom out 15 percent
Camera cam = mapFrame.Camera;
cam.Scale = cam.Scale * 1.15;
mapFrame.SetCamera(cam);
}
}
}//We can activate a map frame on the layout of the active view
var map_frame = layout.GetElementsAsFlattenedList()
.OfType<MapFrame>().FirstOrDefault(mf => mf.Name == "Map 1");
if (map_frame == null)
return;
//can we activate the map frame?
if (layoutView.CanActivateMapFrame(map_frame))
//activate it - Note: we are on the UI thread!
layoutView.ActivateMapFrame(map_frame);//Deactivate any activated map frame
//Note: we are on the UI thread!
layoutView.DeactivateMapFrame();//no-op if nothing activated
//or - check if a map frame is activated first...
if (layoutView.ActivatedMapFrame != null)
//Note: we are on the UI thread!
layoutView.DeactivateMapFrame();//The active view must be a layout view.
var lv = LayoutView.Active;
if (lv == null)
return;
var map_view = lv.ActivatedMapView;
if (map_view != null)
{
//TODO - use activated map view
}
var map_frame = lv.ActivatedMapFrame;
if (map_frame != null)
{
//TODO - use activated map frame
}var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.BlackRGB, 8);
var graphicsLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType<GraphicsLayer>().FirstOrDefault();
//Note: Must be on QueuedTask.Run
//Get a point in the center of the Map frame
var mapFrameCenterPoint = mapFrame.GetBounds().CenterCoordinate;
//Convert to MapPoint
var pointInMapFrame = MapPointBuilderEx.CreateMapPoint(mapFrameCenterPoint);
//Find the corresponding point in the MapView
var pointOnMap = mapFrame.PageToMap(pointInMapFrame);
//Create a point graphic on the MapView.
var cimGraphicElement = new CIMPointGraphic
{
Location = pointOnMap,
Symbol = pointSymbol.MakeSymbolReference()
};
graphicsLayer.AddElement(cimGraphicElement);//Note: Must be on QueuedTask.Run
var pointSymbol = SymbolFactory.Instance.ConstructPointSymbol(ColorFactory.Instance.BlackRGB, 8);
//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;
var clickedMapPoint = MapView.Active.ClientToMap(clickedPoint);
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(string.Format("X: {0} Y: {1} Z: {2}",
mapPoint.X, mapPoint.Y, mapPoint.Z), "Map Coordinates");
//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);//Modify the currently active map series and changes its sort field and page number field.
//Note: Must be on QueuedTask.Run
SpatialMapSeries SMS = layout.MapSeries as SpatialMapSeries; //cast as spatial map series for additional members
SMS.SortField = "State_Name";
SMS.SortAscending = true;
SMS.PageNumberField = "PageNum";
//Overwrite the current map series with these new settings
layout.SetMapSeries(SMS);// This example create a new spatial map series and then applies it to the active layout. This will automatically
// overwrite an existing map series if one is already present.
//Note: Must be on QueuedTask.Run;
//SpatialMapSeries constructor - required parameters
BasicFeatureLayer indexLyr = map.FindLayers("Countries").FirstOrDefault() as BasicFeatureLayer;
SpatialMapSeries SMS = MapSeries.CreateSpatialMapSeries(layout, mapFrame, indexLyr, "Name");
//Set optional, non-default values
SMS.CategoryField = "Continent";
SMS.SortField = "Population";
SMS.ExtentOptions = ExtentFitType.BestFit;
SMS.MarginType = ArcGIS.Core.CIM.UnitType.PageUnits;
SMS.MarginUnits = ArcGIS.Core.Geometry.LinearUnit.Centimeters;
SMS.Margin = 1;
SMS.ScaleRounding = 1000;
layout.SetMapSeries(SMS); //Overwrite existing map series.//Export a single page layout to PDF.
//Create a PDF format with appropriate settings
//BMP, EMF, EPS, GIF, JPEG, PNG, SVG, TGA, and TFF formats are also available for export
string filePath = @"Path and file name for the output export file";
PDFFormat PDF = new PDFFormat()
{
OutputFileName = filePath,
Resolution = 300,
DoCompressVectorGraphics = true,
DoEmbedFonts = true,
HasGeoRefInfo = true,
ImageCompression = ImageCompression.Adaptive,
ImageQuality = ImageQuality.Best,
LayersAndAttributes = LayersAndAttributes.LayersAndAttributes
};
//Check to see if the path is valid and export
if (PDF.ValidateOutputFilePath())
{
//Note: Must be on QueuedTask.Run
layout.Export(PDF); //Export the layout to PDF on the worker thread
}//Export a map frame to JPG.
string filePath = @"Path and file name for the output export file";
//Create JPEG format with appropriate settings
//BMP, EMF, EPS, GIF, PDF, PNG, SVG, TGA, and TFF formats are also available for export
JPEGFormat JPG = new JPEGFormat()
{
HasWorldFile = true,
Resolution = 300,
OutputFileName = filePath,
ColorMode = JPEGColorMode.TwentyFourBitTrueColor,
Height = 800,
Width = 1200
};
//Reference the map frame
MapFrame mf = layout.FindElement("MyMapFrame") as MapFrame;
//Export on the worker thread
//Note: Must be on QueuesTask.Run
//Check to see if the path is valid and export
if (JPG.ValidateOutputFilePath())
{
mf.Export(JPG); //Export the map frame to JPG
}//Export the map view associated with a map frame to BMP.
string filePath = @"Path and file name for the output export file";
//Create BMP format with appropriate settings
//EMF, EPS, GIF, JPEG, PDF, PNG, SVG, TGA, and TFF formats are also available for export
BMPFormat BMP = new BMPFormat()
{
Resolution = 300,
Height = 500,
Width = 800,
HasWorldFile = true,
OutputFileName = filePath
};
//Export on the worker thread
await QueuedTask.Run(() =>
{
MapView mv_bmp = mapFrame.GetMapView(layoutView);
if (mv_bmp != null)
{
//Check to see if the path is valid and export
if (BMP.ValidateOutputFilePath())
{
mv_bmp.Export(BMP); //Export to BMP
}
}
});//Export a map series with multiple pages to a single PDF.
string filePath = @"Path and file name for the output export file";
//Create PDF format with appropriate settings
PDFFormat MS_PDF = new PDFFormat()
{
OutputFileName = filePath,
Resolution = 300,
DoCompressVectorGraphics = true,
DoEmbedFonts = true,
HasGeoRefInfo = true,
ImageCompression = ImageCompression.Adaptive,
ImageQuality = ImageQuality.Best,
LayersAndAttributes = LayersAndAttributes.LayersAndAttributes
};
//Set up map series export options
MapSeriesExportOptions MS_ExportOptions = new MapSeriesExportOptions()
{
ExportPages = ExportPages.Custom, //Provide a specific list of pages
CustomPages = "1-3, 5", //Only used if ExportPages.Custom is set
ExportFileOptions = ExportFileOptions.ExportAsSinglePDF, //Export all pages to a single, multi-page PDF
ShowSelectedSymbology = false //Do no show selection symbology in the output
};
//Export on the worker thread
//Note: Must be on QueuedTask.Run
//Check to see if the path is valid and export
if (MS_PDF.ValidateOutputFilePath())
{
layout.Export(MS_PDF, MS_ExportOptions); //Export to PDF
}//Export each page of a map series to an individual TIFF file.
string filePath = @"Path and file name for the output export file";
//Create TIFF format with appropriate settings
TIFFFormat TIFF = new TIFFFormat()
{
OutputFileName = filePath,
Resolution = 300,
ColorMode = TIFFColorMode.TwentyFourBitTrueColor,
HasGeoTiffTags = true,
HasWorldFile = true,
ImageCompression = TIFFImageCompression.LZW
};
//Set up map series export options
MapSeriesExportOptions MSExportOptions_TIFF = new MapSeriesExportOptions()
{
ExportPages = ExportPages.All, //All pages
ExportFileOptions = ExportFileOptions.ExportMultipleNames, //Export each page to an individual file using page name as a suffix.
ShowSelectedSymbology = true //Include selection symbology in the output
};
//Export on the worker thread
//Note: Must be on the QueuedTask.Run()
//Check to see if the path is valid and export
if (TIFF.ValidateOutputFilePath())
{
layout.Export(TIFF, MSExportOptions_TIFF); //Export to TIFF
}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;
//Note: Must be on QueuedTask.Run.
var guideColor = ApplicationOptions.LayoutOptions.GetGuideColor();//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";
var guideColor = ApplicationOptions.LayoutOptions.GetGuideColor();
// set guide color
//Note: Must be on QueuedTask.Run
ApplicationOptions.LayoutOptions.SetGuideColor(ColorFactory.Instance.RedRGB);//Note: see also SymbolFactory.Instance.GetAvailableFonts() which returns the
//same list. Use for TextAndGraphicsElementsOptions.GetAvailableFonts() convenience
//A list of tuples of Font name + associated Font Styles, one tuple per
//font, is returned
//Note: Must be on QueuedTask.Run
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());//Note: Must be on 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();//Note: Must be on QueuedTask.Run
//Set a default font. Use its default style
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultFont("tahoma");
//or specify an explicit style
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultFont("tahoma", "bold");
//Create 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 default point, line, poly, text graphics element symbols
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultPointSymbol(ptSymbol2);
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultLineSymbol(lineSymbol2);
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultPolygonSymbol(polySymbol2);
ApplicationOptions.TextAndGraphicsElementsOptions.SetDefaultTextSymbol(textSymbol2);//Note: Must be on QueuedTask.Run
var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.None;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.Fixed;
autoCamera.AutoCameraType = AutoCameraType.Extent;
var mf_extent = mapFrame.GetViewExtent();
var extent = EnvelopeBuilderEx.CreateEnvelope(
400748.62, 800296.4, 1310669.05, 1424520.74, mapFrame.Map.SpatialReference);
autoCamera.Extent = extent;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);//Note: run within the QueuedTask
var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.Fixed;
autoCamera.AutoCameraType = AutoCameraType.Center;
var camera = mapFrame.GetMapView(LayoutView.Active).Camera;
var center = mapFrame.GetViewCenter();
//var extent = EnvelopeBuilderEx.CreateEnvelope(
// 400748.62, 800296.4, 1310669.05, 1424520.74, mf.Map.SpatialReference);
//autoCamera.Extent = extent;
var camera2 = new CIMViewCamera()
{
Heading = 0,
Pitch = -90,
Roll = 0,
Scale = 21169571,
X = 855708,
Y = 1112409,
Z = double.NaN
};
autoCamera.Camera = camera2;
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);//Note: run within the QueuedTask
var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.Fixed;
autoCamera.AutoCameraType = AutoCameraType.CenterAndScale;
var camera = mapFrame.GetMapView(LayoutView.Active).Camera;
var center = mapFrame.GetViewCenter();
//var extent = EnvelopeBuilderEx.CreateEnvelope(
// 400748.62, 800296.4, 1310669.05, 1424520.74, mf.Map.SpatialReference);
//autoCamera.Extent = extent;
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;
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
//autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);//Note: run within the QueuedTask
var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.Fixed;
autoCamera.AutoCameraType = AutoCameraType.Scale;
var camera = mapFrame.GetMapView(LayoutView.Active).Camera;
var center = mapFrame.GetViewCenter();
//var extent = EnvelopeBuilderEx.CreateEnvelope(
// 400748.62, 800296.4, 1310669.05, 1424520.74, mf.Map.SpatialReference);
//autoCamera.Extent = extent;
var camera2 = new CIMViewCamera()
{
Heading = 0,
Pitch = -90,
Roll = 0,
Scale = 20000571,
X = 1310669.0 + ((400748.5 - 1310669.0) / 2.0),
Y = 800296.4 + ((1424520.74 - 800296.4) / 2.0),
Z = double.NaN
};
autoCamera.Camera = camera2;
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
//autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.MapFrameLink;
autoCamera.AutoCameraType = AutoCameraType.Extent;
autoCamera.MapFrameLinkName = "mapFrameLink";
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.MapFrameLink;
autoCamera.AutoCameraType = AutoCameraType.Center;
autoCamera.MapFrameLinkName = "mapFrameLink";
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.MapFrameLink;
autoCamera.AutoCameraType = AutoCameraType.CenterAndScale;
autoCamera.MapFrameLinkName = "mapFrameLink";
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.MapFrameLink;
autoCamera.AutoCameraType = AutoCameraType.Scale;
autoCamera.MapFrameLinkName = "mapFrameLink";
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.MapSeriesLink;
autoCamera.AutoCameraType = AutoCameraType.Extent;
//autoCamera.MapFrameLinkName = mapFrameLink;
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera);var autoCamera = mapFrame.GetAutoCamera();
autoCamera.Source = AutoCameraSource.MapSeriesLink;
autoCamera.AutoCameraType = AutoCameraType.Center;
var states = mapFrame.Map.GetLayersAsFlattenedList().First(l => l.Name == "State_Polygons");
autoCamera.IntersectLayerPath = states.URI;
if (mapFrame.ValidateAutoCamera(autoCamera) &&
!mapFrame.IsMapSeriesMapFrame())
mapFrame.SetAutoCamera(autoCamera); 