internal static Geometry MakeFishnetPolygon(Polygon inputPoly)
{
Envelope envPoly = inputPoly.Extent;
var interval = GetFishnetIntervalDistance(envPoly);
var pb = new PolygonBuilderEx(inputPoly.SpatialReference)
{
HasZ = true
};
for (var dX = envPoly.XMin; dX < envPoly.XMax + interval; dX += interval)
{
for (var dY = envPoly.YMin; dY < envPoly.YMax + interval; dY += interval)
{
var cutEnv = EnvelopeBuilderEx.CreateEnvelope(dX, dY, dX + interval, dY + interval, envPoly.SpatialReference);
if (GeometryEngine.Instance.Intersects(cutEnv, inputPoly))
{
var addPolygonPart = GeometryEngine.Instance.Clip(inputPoly, cutEnv) as Polygon;
if (addPolygonPart.Area < 0)
{
System.Diagnostics.Debug.WriteLine($@"area: {addPolygonPart.Area}");
}
pb.AddPart(addPolygonPart.Points);
}
}
}
return(pb.ToGeometry());
}
/// <summary>
/// This method must be called on the MCT
/// </summary>
/// <remarks>If multiple features are selected just the ObjectID of the first feature
/// in the selected set is returned</remarks>
/// <param name="point"></param>
/// <returns>The object id of the selected feature or -1</returns>
internal static Polyline SelectLineFeature(MapPoint point)
{
if (OnUIThread)
{
throw new CalledOnWrongThreadException();
}
var pt = MapView.Active.MapToClient(point);
double llx = pt.X - 5;
double lly = pt.Y - 5;
double urx = pt.X + 5;
double ury = pt.Y + 5;
var sr = point.SpatialReference;
if (sr == null)
{
sr = MapView.Active.Map.SpatialReference;
}
var envelope = EnvelopeBuilderEx.CreateEnvelope(MapView.Active.ClientToMap(new Point(llx, lly)),
MapView.Active.ClientToMap(new Point(urx, ury)), sr);
return(SelectLineFeature(envelope));
}
protected override async Task <bool> OnSketchCompleteAsync(Geometry geometry)
{
var bottomRight = new Point();
IList <Tuple <string, string, long> > tripleTuplePoints = new List <Tuple <string, string, long> >();
var hasSelection = await QueuedTask.Run(() =>
{
// geometry is a point
var clickedPnt = geometry as MapPoint;
if (clickedPnt == null)
{
return(false);
}
// pixel tolerance
var tolerance = 3;
//Get the client point edges
var topLeft = new Point(clickedPnt.X - tolerance, clickedPnt.Y + tolerance);
bottomRight = new Point(clickedPnt.X + tolerance, clickedPnt.Y - tolerance);
//convert the client points to Map points
var mapTopLeft = MapView.Active.ClientToMap(topLeft);
var mapBottomRight = MapView.Active.ClientToMap(bottomRight);
//create a geometry using these points
Geometry envelopeGeometry = EnvelopeBuilderEx.CreateEnvelope(mapTopLeft, mapBottomRight);
if (envelopeGeometry == null)
{
return(false);
}
//Get the features that intersect the sketch geometry.
var result = ActiveMapView.GetFeatures(geometry);
foreach (var kvp in result.ToDictionary())
{
var bfl = kvp.Key as BasicFeatureLayer;
if (bfl is null)
{
continue;
}
// only look at points
if (bfl.ShapeType != esriGeometryType.esriGeometryPoint)
{
continue;
}
var layerName = bfl.Name;
var oidName = bfl.GetTable().GetDefinition().GetObjectIDField();
foreach (var oid in kvp.Value)
{
tripleTuplePoints.Add(new Tuple <string, string, long>(layerName, oidName, oid));
}
}
return(true);
});
if (hasSelection)
{
ShowContextMenu(bottomRight, tripleTuplePoints);
}
return(true);
}
/// <summary>
/// Zoom to the specified location
/// </summary>
/// <param name="extent">The extent of the geocoded candidate</param>
/// <returns></returns>
public static Task ZoomToLocation(CandidateExtent extent)
{
return(QueuedTask.Run(() =>
{
ArcGIS.Core.Geometry.SpatialReference spatialReference = SpatialReferenceBuilder.CreateSpatialReference(extent.WKID);
ArcGIS.Core.Geometry.Envelope envelope = EnvelopeBuilderEx.CreateEnvelope(extent.XMin, extent.YMin, extent.XMax, extent.YMax, spatialReference);
//apply extent
MapView.Active.ZoomTo(GeometryEngine.Instance.Expand(envelope, 3, 3, true));
}));
}
private EnvelopeBuilderEx GetExtentFromRowCursor(EnvelopeBuilderEx envelopeBuilder, RowCursor rowCursor)
{
while (rowCursor.MoveNext())
{
using (Feature feature = rowCursor.Current as Feature)
{
Envelope newEnvelope = feature.GetShape().Extent;
envelopeBuilder = Union(envelopeBuilder, newEnvelope);
}
}
return(envelopeBuilder);
}
private EnvelopeBuilderEx Union(EnvelopeBuilderEx envelopeBuilder, Envelope newEnvelope)
{
if (envelopeBuilder.IsEmpty)
{
return(new EnvelopeBuilderEx(newEnvelope));
}
else
{
envelopeBuilder.Union(newEnvelope);
return(envelopeBuilder);
}
}
private EnvelopeBuilderEx GetExtentFromDifferenceCursor(EnvelopeBuilderEx envelopeBuilder, DifferenceCursor differenceCursor)
{
while (differenceCursor.MoveNext())
{
using (Feature differenceFeature = differenceCursor.Current as Feature)
{
Envelope newEnvelope = differenceFeature.GetShape().Extent;
envelopeBuilder = Union(envelopeBuilder, newEnvelope);
}
}
return(envelopeBuilder);
}
internal static async Task <Multipatch> MakeFishnetRingMultiPatchAsync(Polygon inputPoly)
{
Envelope envPoly = inputPoly.Extent;
var interval = GetFishnetIntervalDistance(envPoly);
var mColor = System.Windows.Media.Colors.LightCyan;
var materialRed = new BasicMaterial
{
Color = mColor,
EdgeColor = mColor,
EdgeWidth = 0
};
// create the multipatchBuilderEx object
var mpb = new MultipatchBuilderEx();
// create a list of patch objects
var patches = new List <Patch>();
var first = true;
for (var dX = envPoly.XMin; dX < envPoly.XMax + interval; dX += interval)
{
for (var dY = envPoly.YMin; dY < envPoly.YMax + interval; dY += interval)
{
var cutEnv = EnvelopeBuilderEx.CreateEnvelope(dX, dY, dX + interval, dY + interval,
envPoly.SpatialReference);
if (GeometryEngine.Instance.Intersects(cutEnv, inputPoly))
{
var addPolygonPart = GeometryEngine.Instance.Clip(inputPoly, cutEnv) as Polygon;
if (addPolygonPart.Area < 0)
{
System.Diagnostics.Debug.WriteLine($@"area: {addPolygonPart.Area}");
}
var result = await Module1.CurrentMapView.Map.GetZsFromSurfaceAsync(addPolygonPart);
if (result.Status == SurfaceZsResultStatus.Ok)
{
addPolygonPart = GeometryEngine.Instance.Move(result.Geometry, 0, 0, Module1.Elevation) as Polygon;
}
var patch = mpb.MakePatch(first ? PatchType.FirstRing : PatchType.Ring);
first = false;
patch.InsertPoints(0, addPolygonPart.Points);
patch.Material = materialRed;
patches.Add(patch);
}
}
} // assign the patches to the multipatchBuilder
mpb.Patches = patches;
// call ToGeometry to get the multipatch
return(mpb.ToGeometry() as Multipatch);
}
internal static List <Geometry> MakeFishnetPolygons(Polygon inputPoly)
{
List <Geometry> polygons = new List <Geometry>();
Envelope envPoly = inputPoly.Extent;
var interval = GetFishnetIntervalDistance(envPoly);
for (var dX = envPoly.XMin; dX < envPoly.XMax + interval; dX += interval)
{
for (var dY = envPoly.YMin; dY < envPoly.YMax + interval; dY += interval)
{
var cutEnv = EnvelopeBuilderEx.CreateEnvelope(dX, dY, dX + interval, dY + interval, envPoly.SpatialReference);
if (GeometryEngine.Instance.Intersects(cutEnv, inputPoly))
{
var addPolygonPart = GeometryEngine.Instance.Clip(inputPoly, cutEnv);
polygons.Add(addPolygonPart);
}
}
}
return(polygons);
}
/// <summary>
/// Get the extent for the dataset (if it has one)
/// </summary>
/// <remarks>Ideally, your plugin table should return an extent even if it is
/// empty</remarks>
/// <returns><see cref="Envelope"/></returns>
public override Envelope GetExtent()
{
if (_gisExtent == null)
{
var builder = new EnvelopeBuilderEx(EnvelopeBuilderEx.CreateEnvelope(
_tableInfo.ExtentLeft,
_tableInfo.ExtentBottom,
_tableInfo.ExtentRight,
_tableInfo.ExtentTop,
_spatialReference));
//Assume 0 for Z
{
builder.ZMin = 0;
builder.ZMax = 0;
}
builder.HasZ = false;
builder.HasM = false;
return(builder.ToGeometry());
}
return(_gisExtent);
}
async protected override void OnClick()
{
//Check to see if the Game Board layout already exists
LayoutProjectItem layoutItem = Project.Current.GetItems <LayoutProjectItem>().FirstOrDefault(item => item.Name.Equals("Game Board"));
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 (lytPane == null) //if not a layout view, continue to the next pane
{
continue;
}
if (lytPane.LayoutView.Layout == lyt) //if there is a match, activate the view
{
(lytPane as Pane).Activate();
System.Windows.MessageBox.Show("Activating existing pane");
return;
}
}
//If panes don't exist, then open a new pane
await ProApp.Panes.CreateLayoutPaneAsync(lyt);
System.Windows.MessageBox.Show("Opening already existing layout");
return;
}
//The layout does not exist so create a new one
Layout layout = await ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run <Layout>(() =>
{
//*** CREATE A NEW LAYOUT ***
//Set up a page
CIMPage newPage = new CIMPage();
//required properties
newPage.Width = 17;
newPage.Height = 11;
newPage.Units = LinearUnit.Inches;
//optional rulers
newPage.ShowRulers = true;
newPage.SmallestRulerDivision = 0.5;
layout = LayoutFactory.Instance.CreateLayout(newPage);
layout.SetName("Game Board");
//*** INSERT MAP FRAME ***
// create a new map with an ArcGIS Online basemap
Map map = MapFactory.Instance.CreateMap("World Map", MapType.Map, MapViewingMode.Map, Basemap.NationalGeographic);
//Build map frame geometry
Coordinate2D ll = new Coordinate2D(4, 0.5);
Coordinate2D ur = new Coordinate2D(13, 6.5);
Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
//Create map frame and add to layout
MapFrame mfElm = ElementFactory.Instance.CreateMapFrameElement(layout, env, map);
mfElm.SetName("Main MF");
//Set the camera
Camera camera = mfElm.Camera;
camera.X = 3365;
camera.Y = 5314468;
camera.Scale = 175000000;
mfElm.SetCamera(camera);
//*** INSERT TEXT ELEMENTS ***
//Title text
var titleTxt_ll = MapPointBuilderEx.CreateMapPoint(new Coordinate2D(6.5, 10));
CIMTextSymbol arial36bold = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlueRGB, 36, "Arial", "Bold");
GraphicElement titleTxtElm = ElementFactory.Instance.CreateTextGraphicElement(layout, TextType.PointText, titleTxt_ll, arial36bold, "Feeling Puzzled?");
titleTxtElm.SetName("Title");
//Instuctions text
Coordinate2D recTxt_ll = new Coordinate2D(4.25, 6.5);
Coordinate2D recTxt_ur = new Coordinate2D(13, 9.75);
Envelope recEnv = EnvelopeBuilderEx.CreateEnvelope(recTxt_ll, recTxt_ur);
CIMTextSymbol arial18 = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.GreyRGB, 20, "Arial", "Regular");
string text = "<bol>Instructions:</bol> " +
"\n\n - Activate the map frame below and pan / zoom to desired extent" +
"\n\n - Close map frame activation" +
"\n\n - Click the 'Scramble Pieces' command" as String;
GraphicElement recTxtElm = ElementFactory.Instance.CreateTextGraphicElement(layout, TextType.RectangleParagraph, recEnv, arial18, text);
recTxtElm.SetName("Instructions");
//Service layer credits
Coordinate2D slcTxt_ll = new Coordinate2D(0.5, 0.2);
Coordinate2D slcTxt_ur = new Coordinate2D(16.5, 0.4);
Envelope slcEnv = EnvelopeBuilderEx.CreateEnvelope(slcTxt_ll, slcTxt_ur);
CIMTextSymbol arial8reg = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlackRGB, 8, "Arial", "Regular");
String slcText = "<dyn type='layout' name='Game Board' property='serviceLayerCredits'/>";
GraphicElement slcTxtElm = ElementFactory.Instance.CreateTextGraphicElement(layout, TextType.RectangleParagraph, slcEnv, arial8reg, slcText);
slcTxtElm.SetName("SLC");
//Status and results text (blank to start)
var statusTxt_ll = MapPointBuilderEx.CreateMapPoint(new Coordinate2D(4.5, 7));
CIMTextSymbol arial24bold = SymbolFactory.Instance.ConstructTextSymbol(ColorFactory.Instance.BlackRGB, 24, "Arial", "Bold");
GraphicElement statusTxtElm = ElementFactory.Instance.CreateTextGraphicElement(layout, TextType.PointText, statusTxt_ll, arial24bold, "");
statusTxtElm.SetName("Status");
return(layout);
});
//*** OPEN LAYOUT VIEW (must be in the GUI thread) ***
var layoutPane = await ProApp.Panes.CreateLayoutPaneAsync(layout);
var sel = layoutPane.LayoutView.GetSelectedElements();
if (sel.Count > 0)
{
layoutPane.LayoutView.ClearElementSelection();
}
}
async public void MoveMF(string elmName)
{
Globals.i_correct = Globals.i_correct + 1;
LayoutView layoutView = LayoutView.Active;
Layout layout = layoutView.Layout;
if (elmName == "Rectangle 1")
{
MapFrame mf1 = layout.FindElement("MF1") as MapFrame;
await QueuedTask.Run(() => mf1.SetX(4));
await QueuedTask.Run(() => mf1.SetY(0.5));
}
if (elmName == "Rectangle 2")
{
MapFrame mf2 = layout.FindElement("MF2") as MapFrame;
await QueuedTask.Run(() => mf2.SetX(7));
await QueuedTask.Run(() => mf2.SetY(0.5));
}
if (elmName == "Rectangle 3")
{
MapFrame mf3 = layout.FindElement("MF3") as MapFrame;
await QueuedTask.Run(() => mf3.SetX(10));
await QueuedTask.Run(() => mf3.SetY(0.5));
}
if (elmName == "Rectangle 4")
{
MapFrame mf4 = layout.FindElement("MF4") as MapFrame;
await QueuedTask.Run(() => mf4.SetX(10));
await QueuedTask.Run(() => mf4.SetY(3.5));
}
if (elmName == "Rectangle 5")
{
MapFrame mf5 = layout.FindElement("MF5") as MapFrame;
await QueuedTask.Run(() => mf5.SetX(7));
await QueuedTask.Run(() => mf5.SetY(3.5));
}
if (elmName == "Rectangle 6")
{
MapFrame mf6 = layout.FindElement("MF6") as MapFrame;
await QueuedTask.Run(() => mf6.SetX(4));
await QueuedTask.Run(() => mf6.SetY(3.5));
}
TextElement statusText = layout.FindElement("Status") as TextElement;
TextProperties statusProp = statusText.TextProperties;
if (Globals.i_correct == 1)
{
statusProp.Text = "Nice job! You got " + Globals.i_correct.ToString() + " correct out of " + Globals.i_guesses + " attempt.";
}
else
{
statusProp.Text = "Nice job! You got " + Globals.i_correct.ToString() + " correct out of " + Globals.i_guesses + " attempts.";
}
await QueuedTask.Run(() => statusText.SetTextProperties(statusProp));
if (Globals.i_correct == 6) //YOU WIN
{
statusProp.Text = "GAME OVER! You got " + Globals.i_correct.ToString() + " correct out of " + Globals.i_guesses + " attempts.";
await QueuedTask.Run(() => statusText.SetTextProperties(statusProp));
//Turn off rectangles
GraphicElement rec1 = layout.FindElement("Rectangle 1") as GraphicElement;
await QueuedTask.Run(() => rec1.SetVisible(false));
GraphicElement rec2 = layout.FindElement("Rectangle 2") as GraphicElement;
await QueuedTask.Run(() => rec2.SetVisible(false));
GraphicElement rec3 = layout.FindElement("Rectangle 3") as GraphicElement;
await QueuedTask.Run(() => rec3.SetVisible(false));
GraphicElement rec4 = layout.FindElement("Rectangle 4") as GraphicElement;
await QueuedTask.Run(() => rec4.SetVisible(false));
GraphicElement rec5 = layout.FindElement("Rectangle 5") as GraphicElement;
await QueuedTask.Run(() => rec5.SetVisible(false));
GraphicElement rec6 = layout.FindElement("Rectangle 6") as GraphicElement;
await QueuedTask.Run(() => rec6.SetVisible(false));
//Toggle MFs
MapFrame mf1 = layout.FindElement("MF1") as MapFrame;
await QueuedTask.Run(() => mf1.SetVisible(false));
MapFrame mf2 = layout.FindElement("MF2") as MapFrame;
await QueuedTask.Run(() => mf2.SetVisible(false));
MapFrame mf3 = layout.FindElement("MF3") as MapFrame;
await QueuedTask.Run(() => mf3.SetVisible(false));
MapFrame mf4 = layout.FindElement("MF4") as MapFrame;
await QueuedTask.Run(() => mf4.SetVisible(false));
MapFrame mf5 = layout.FindElement("MF5") as MapFrame;
await QueuedTask.Run(() => mf5.SetVisible(false));
MapFrame mf6 = layout.FindElement("MF6") as MapFrame;
await QueuedTask.Run(() => mf6.SetVisible(false));
MapFrame mainMF = layout.FindElement("Main MF") as MapFrame;
await QueuedTask.Run(() => mainMF.SetVisible(true));
//Update title
TextElement titleText = layout.FindElement("Title") as TextElement;
TextProperties titleProp = titleText.TextProperties;
titleProp.Text = "Not any more!";
await QueuedTask.Run(() => titleText.SetTextProperties(titleProp));
//New Game
TextElement instrText = layout.FindElement("Instructions") as TextElement;
TextProperties instrProp = instrText.TextProperties;
instrProp.Text = "<bol>Instructions: </bol> " +
"\n\n\n\n\n\n\n\n\n - Click the 'New Game' command if you want to play again.";
await QueuedTask.Run(() => instrText.SetTextProperties(instrProp));
//Zoomto finished puzzle area
Coordinate2D ll = new Coordinate2D(3, 0);
Coordinate2D ur = new Coordinate2D(14, 7.5);
await QueuedTask.Run(() =>
{
Envelope env = EnvelopeBuilderEx.CreateEnvelope(ll, ur);
layoutView.ZoomTo(env);
});
//Turn off selection changed events
Globals.selEvents = false;
}
}
private void AddTableToLayout(Layout layout, Map theMap, MapFrame mfElm, string layerName, SetPage setPage, double yOffset)
{
var lyrs = theMap.FindLayers(layerName, true);
if (lyrs.Count > 0)
{
Layer lyr = lyrs[0];
var ptSymbol = GetPointSymbolFromLayer(lyr);
if (ptSymbol != null)
{
Coordinate2D llSym = new Coordinate2D(setPage.XOffsetMapMarginalia, setPage.YOffsetSymbol + yOffset);
var geom = MapPointBuilderEx.CreateMapPoint(llSym);
var sym = ElementFactory.Instance.CreateGraphicElement(layout, geom, ptSymbol);
Coordinate2D llText = new Coordinate2D(setPage.XOffsetMapMarginalia + sym.GetWidth(), setPage.YOffsetSymbol + yOffset - sym.GetHeight() / 2);
var geomLLText = MapPointBuilderEx.CreateMapPoint(llText);
var text = ElementFactory.Instance.CreateTextGraphicElement(layout, TextType.PointText, geomLLText);
text.SetAnchor(Anchor.CenterPoint);
text.SetHeight(text.GetHeight());
if (text.GetHeight() > sym.GetHeight())
{
sym.SetLockedAspectRatio(true);
sym.SetHeight(text.GetHeight());
}
else
{
text.SetLockedAspectRatio(true);
text.SetHeight(sym.GetHeight());
}
}
Coordinate2D llTab1 = new Coordinate2D(setPage.XOffsetMapMarginalia, yOffset - setPage.HeightPartsMarginalia);
Coordinate2D urTab1 = new Coordinate2D(setPage.XOffsetMapMarginalia + setPage.XWidthMapMarginalia, yOffset);
var tableFrameInfo = new TableFrameInfo()
{
MapFrameName = mfElm.Name,
MapMemberUri = lyr.URI
};
var table1 = ElementFactory.Instance.CreateMapSurroundElement(layout, EnvelopeBuilderEx.CreateEnvelope(llTab1, urTab1), tableFrameInfo) as TableFrame;
}
}
private string ValidateChangedFeatures(Layer layer)
{
StringBuilder resultString = new StringBuilder();
// Get utility network and geodatabase
using (UtilityNetwork utilityNetwork = UtilityNetworkUtils.GetUtilityNetworkFromLayer(layer))
using (Geodatabase geodatabase = utilityNetwork.GetDatastore() as Geodatabase)
{
// Determine what to validate
// File geodatabase - validate everything, synchronously
// Default version - validate everything, asynchronously
// Branch version - validate changes only, synchronously
bool shouldValidateEverything;
bool runAsync;
if (!geodatabase.IsVersioningSupported())
{
shouldValidateEverything = true;
runAsync = false;
}
else
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
using (Version currentVersion = versionManager.GetCurrentVersion())
{
if (IsDefaultVersion(currentVersion))
{
shouldValidateEverything = true;
runAsync = true;
}
else
{
shouldValidateEverything = false;
runAsync = false;
}
}
}
// If we validating everything, get an envelope from the dirty areas table
EnvelopeBuilderEx envelopeBuilder = new EnvelopeBuilderEx(layer.GetSpatialReference());
if (shouldValidateEverything)
{
using (Table dirtyAreaTable = utilityNetwork.GetSystemTable(SystemTableType.DirtyAreas))
using (RowCursor rowCursor = dirtyAreaTable.Search())
{
envelopeBuilder = GetExtentFromRowCursor(envelopeBuilder, rowCursor);
}
}
// else get an envelope using version differences
else
{
using (VersionManager versionManager = geodatabase.GetVersionManager())
using (Version currentVersion = versionManager.GetCurrentVersion())
using (Version defaultVersion = currentVersion.GetParent())
using (Geodatabase defaultGeodatabase = defaultVersion.Connect())
using (UtilityNetwork defaultUtilityNetwork = defaultGeodatabase.OpenDataset <UtilityNetwork>(utilityNetwork.GetName()))
using (Table dirtyAreaTable = utilityNetwork.GetSystemTable(SystemTableType.DirtyAreas))
using (Table defaultDirtyAreaTable = defaultUtilityNetwork.GetSystemTable(SystemTableType.DirtyAreas))
using (DifferenceCursor inserts = dirtyAreaTable.Differences(defaultDirtyAreaTable, DifferenceType.Insert))
{
envelopeBuilder = GetExtentFromDifferenceCursor(envelopeBuilder, inserts);
}
}
// Run validate topology on our envelope
Envelope extent = envelopeBuilder.ToGeometry();
ValidationResult result = utilityNetwork.ValidateNetworkTopologyInEditOperation(extent, runAsync ? ServiceSynchronizationType.Asynchronous : ServiceSynchronizationType.Synchronous);
if (result.HasErrors)
{
resultString.AppendLine("Errors found.");
}
else
{
resultString.AppendLine("No errors found.");
}
}
return(resultString.ToString());
}
async protected override void OnClick()
{
LayoutView layoutView = LayoutView.Active;
//Prevent tool from executing based on some conditions
if (layoutView == null)
{
System.Windows.MessageBox.Show("Can't find layout view, try clicking New Game Board");
return;
}
if (layoutView.Layout.Name != "Game Board")
{
System.Windows.MessageBox.Show("Wrong layout view: should be Game Board");
return;
}
await QueuedTask.Run(() =>
{
//Reference the layout for moving map frames and adding new layout elements
Layout layout = layoutView.Layout;
//Check to see if elements were already scrambled
MapFrame mfTest = layout.FindElement("MF1") as MapFrame;
if (mfTest != null)
{
System.Windows.MessageBox.Show("Game pieces already scrambled");
return;
}
//Build 6 envelopes to represent the locations of puzzle pieces along the outer edges
Coordinate2D env1_ll = new Coordinate2D(0.5, 0.5);
Coordinate2D env1_ur = new Coordinate2D(3.5, 3.5);
Envelope env1 = EnvelopeBuilderEx.CreateEnvelope(env1_ll, env1_ur);
Coordinate2D env2_ll = new Coordinate2D(0.5, 4);
Coordinate2D env2_ur = new Coordinate2D(3.5, 7);
Envelope env2 = EnvelopeBuilderEx.CreateEnvelope(env2_ll, env2_ur);
Coordinate2D env3_ll = new Coordinate2D(0.5, 7.5);
Coordinate2D env3_ur = new Coordinate2D(3.5, 10.5);
Envelope env3 = EnvelopeBuilderEx.CreateEnvelope(env3_ll, env3_ur);
Coordinate2D env4_ll = new Coordinate2D(13.5, 0.5);
Coordinate2D env4_ur = new Coordinate2D(16.5, 3.5);
Envelope env4 = EnvelopeBuilderEx.CreateEnvelope(env4_ll, env4_ur);
Coordinate2D env5_ll = new Coordinate2D(13.5, 4);
Coordinate2D env5_ur = new Coordinate2D(16.5, 7);
Envelope env5 = EnvelopeBuilderEx.CreateEnvelope(env5_ll, env5_ur);
Coordinate2D env6_ll = new Coordinate2D(13.5, 7.5);
Coordinate2D env6_ur = new Coordinate2D(16.5, 10.5);
Envelope env6 = EnvelopeBuilderEx.CreateEnvelope(env6_ll, env6_ur);
//Randomize the envelopes by assigning new envelope variables used for map frame creation
//Also remove the assigned env before selecting the next random env
List <Envelope> envList = new List <Envelope> {
env1, env2, env3, env4, env5, env6
};
Random r1 = new Random();
int i1 = r1.Next(envList.Count);
Envelope e1 = envList[i1];
envList.Remove(e1);
Random r2 = new Random();
int i2 = r2.Next(envList.Count);
Envelope e2 = envList[i2];
envList.Remove(e2);
Random r3 = new Random();
int i3 = r3.Next(envList.Count);
Envelope e3 = envList[i3];
envList.Remove(e3);
Random r4 = new Random();
int i4 = r4.Next(envList.Count);
Envelope e4 = envList[i4];
envList.Remove(e4);
Random r5 = new Random();
int i5 = r5.Next(envList.Count);
Envelope e5 = envList[i5];
envList.Remove(e5);
Random r6 = new Random();
int i6 = r6.Next(envList.Count);
Envelope e6 = envList[i6];
envList.Remove(e6);
//Reference the active map view and gets its center location
//MapView map = MapView.Active;
MapFrame mapFrame = layout.FindElement("Main MF") as MapFrame;
Camera cam = mapFrame.Camera;
double x = cam.X;
double y = cam.Y;
double scale = cam.Scale;
double delta = scale * 1.5 / 12 / 3.28084; //scale * 1/2 of a 3" MF / 12" per foot / 3.28084 feet per meter
//Insert Map Frame 1 at random location
MapFrame mf1Elm = ElementFactory.Instance.CreateMapFrameElement(layout, e1, mapFrame.Map);
mf1Elm.SetName("MF1");
Camera mf1cam = mf1Elm.Camera;
mf1cam.X = x - (delta * 2);
mf1cam.Y = y - delta;
mf1cam.Scale = scale;
mf1Elm.SetCamera(mf1cam);
//Insert Map Frame 2 at random location
MapFrame mf2Elm = ElementFactory.Instance.CreateMapFrameElement(layout, e2, mapFrame.Map);
mf2Elm.SetName("MF2");
Camera mf2cam = mf2Elm.Camera;
mf2cam.X = x;
mf2cam.Y = y - delta;
mf2cam.Scale = scale;
mf2Elm.SetCamera(mf2cam);
//Insert Map Frame 3 at random location
MapFrame mf3Elm = ElementFactory.Instance.CreateMapFrameElement(layout, e3, mapFrame.Map);
mf3Elm.SetName("MF3");
Camera mf3cam = mf3Elm.Camera;
mf3cam.X = x + (delta * 2);
mf3cam.Y = y - delta;
mf3cam.Scale = scale;
mf3Elm.SetCamera(mf3cam);
//Insert Map Frame 4 at random location
MapFrame mf4Elm = ElementFactory.Instance.CreateMapFrameElement(layout, e4, mapFrame.Map);
mf4Elm.SetName("MF4");
Camera mf4cam = mf4Elm.Camera;
mf4cam.X = x + (delta * 2);
mf4cam.Y = y + delta;
mf4cam.Scale = scale;
mf4Elm.SetCamera(mf4cam);
//Insert Map Frame 5 at random location
MapFrame mf5Elm = ElementFactory.Instance.CreateMapFrameElement(layout, e5, mapFrame.Map);
mf5Elm.SetName("MF5");
Camera mf5cam = mf5Elm.Camera;
mf5cam.X = x;
mf5cam.Y = y + delta;
mf5cam.Scale = scale;
mf5Elm.SetCamera(mf5cam);
//Insert Map Frame 6 at random location
MapFrame mf6Elm = ElementFactory.Instance.CreateMapFrameElement(layout, e6, mapFrame.Map);
mf6Elm.SetName("MF6");
Camera mf6cam = mf6Elm.Camera;
mf6cam.X = x - (delta * 2);
mf6cam.Y = y + delta;
mf6cam.Scale = scale;
mf6Elm.SetCamera(mf6cam);
//Create 6 polygon boxes that represent where the outer map frames need to be placed.
Coordinate2D box1_ll = new Coordinate2D(4, 0.5);
Coordinate2D box1_ur = new Coordinate2D(7, 3.5);
Envelope box1_env = EnvelopeBuilderEx.CreateEnvelope(box1_ll, box1_ur);
GraphicElement box1 = ElementFactory.Instance.CreateGraphicElement(layout, box1_env);
box1.SetName("Rectangle 1");
Coordinate2D box2_ll = new Coordinate2D(7, 0.5);
Coordinate2D box2_ur = new Coordinate2D(10, 3.5);
Envelope box2_env = EnvelopeBuilderEx.CreateEnvelope(box2_ll, box2_ur);
GraphicElement box2 = ElementFactory.Instance.CreateGraphicElement(layout, box2_env);
box2.SetName("Rectangle 2");
Coordinate2D box3_ll = new Coordinate2D(10, 0.5);
Coordinate2D box3_ur = new Coordinate2D(13, 3.5);
Envelope box3_env = EnvelopeBuilderEx.CreateEnvelope(box3_ll, box3_ur);
GraphicElement box3 = ElementFactory.Instance.CreateGraphicElement(layout, box3_env);
box3.SetName("Rectangle 3");
Coordinate2D box4_ll = new Coordinate2D(10, 3.5);
Coordinate2D box4_ur = new Coordinate2D(13, 6.5);
Envelope box4_env = EnvelopeBuilderEx.CreateEnvelope(box4_ll, box4_ur);
GraphicElement box4 = ElementFactory.Instance.CreateGraphicElement(layout, box4_env);
box4.SetName("Rectangle 4");
Coordinate2D box5_ll = new Coordinate2D(7, 3.5);
Coordinate2D box5_ur = new Coordinate2D(10, 6.5);
Envelope box5_env = EnvelopeBuilderEx.CreateEnvelope(box5_ll, box5_ur);
GraphicElement box5 = ElementFactory.Instance.CreateGraphicElement(layout, box5_env);
box5.SetName("Rectangle 5");
Coordinate2D box6_ll = new Coordinate2D(4, 3.5);
Coordinate2D box6_ur = new Coordinate2D(7, 6.5);
Envelope box6_env = EnvelopeBuilderEx.CreateEnvelope(box6_ll, box6_ur);
GraphicElement box6 = ElementFactory.Instance.CreateGraphicElement(layout, box6_env);
box6.SetName("Rectangle 6");
//Find MainMF and set invisible
MapFrame mainMF = layout.FindElement("Main MF") as MapFrame;
mainMF.SetVisible(false);
//Update Instructions
TextElement steps = layout.FindElement("Instructions") as TextElement;
string text = "<bol>Instructions: </bol>\n\n - Click the 'Play Game' command" as String;
var stepsProp = steps.TextProperties;
stepsProp.Text = text;
steps.SetTextProperties(stepsProp);
});
layoutView.ClearElementSelection();
}
private void AddTableToLayout(Layout layout, Map theMap, MapFrame mfElm, string layerName, SetPage setPage, double yOffset)
{
var lyrs = theMap.FindLayers(layerName, true);
if (lyrs.Count > 0)
{
Layer lyr = lyrs[0];
Coordinate2D llTab1 = new Coordinate2D(setPage.XOffsetMapMarginalia, yOffset - 2 * setPage.HeightPartsMarginalia);
Coordinate2D urTab1 = new Coordinate2D(setPage.XOffsetMapMarginalia + setPage.XWidthMapMarginalia, yOffset);
var tableFrameInfo = new TableFrameInfo()
{
MapFrameName = mfElm.Name,
MapMemberUri = lyr.URI
};
var theTable = ElementFactory.Instance.CreateMapSurroundElement(layout, EnvelopeBuilderEx.CreateEnvelope(llTab1, urTab1), tableFrameInfo) as TableFrame;
var def = theTable.GetDefinition() as CIMTableFrame;
def.FittingStrategy = TableFrameFittingStrategy.AdjustColumnsAndSize;
def.FillingStrategy = TableFrameFillingStrategy.ShowAllRows;
theTable.SetDefinition(def);
}
}
/// <summary>
/// Updates the report with the new field and the title of the field.
/// </summary>
/// <remarks>
/// New Field: The new field gets added to the ReportDetails section.
/// Field title: If the report is grouped, the title goes in the "GroupHeader". If not, the title goes in the PageHeader section.
/// </remarks>
/// <returns></returns>
private async Task UpdateReport()
{
await GetReportsInProjectAsync();
await QueuedTask.Run(() =>
{
//report to update
var reportToUpdate = _reportsInProject.FirstOrDefault(r => r.Name == ReportName);
//Create field
foreach (var field in _fieldsAddToReport)
{
//Get the "ReportSectionElement"
var mainReportSection = reportToUpdate.Elements.OfType<ReportSection>().FirstOrDefault();
if (mainReportSection == null) return;
#region Field content
//Get the "ReportDetails" within the ReportSectionElement. ReportDetails is where "fields" are.
var reportDetailsSection = mainReportSection?.Elements.OfType<ReportDetails>().FirstOrDefault();
if (reportDetailsSection == null) return;
//Within ReportDetails find the envelope that encloses a field.
//We get the first CIMParagraphTextGraphic in the collection so that we can add the new field next to it.
var lastFieldGraphic = reportDetailsSection.Elements.FirstOrDefault((r) =>
{
var gr = r as GraphicElement;
if (gr == null) return false;
return (gr.GetGraphic() is CIMParagraphTextGraphic ? true : false);
});
//Get the Envelope of the last field
var graphicBounds = lastFieldGraphic.GetBounds();
//Min and Max values of the envelope
var xMinOfFieldEnvelope = graphicBounds.XMin;
var yMinOfFieldEnvelope = graphicBounds.YMin;
var xMaxOfFieldEnvelope = graphicBounds.XMax;
var YMaxOfFieldEnvelope = graphicBounds.YMax;
//create the new Envelope to be offset from the existing field
MapPoint newMinPoint = MapPointBuilderEx.CreateMapPoint(xMinOfFieldEnvelope + fieldIncrement, yMinOfFieldEnvelope);
MapPoint newMaxPoint = MapPointBuilderEx.CreateMapPoint(xMaxOfFieldEnvelope + fieldIncrement, YMaxOfFieldEnvelope);
Envelope newFieldEnvelope = EnvelopeBuilderEx.CreateEnvelope(newMinPoint, newMaxPoint);
#endregion
//Create field
GraphicElement fieldGraphic = ReportElementFactory.Instance.CreateFieldValueTextElement(reportDetailsSection, newFieldEnvelope, field);
#region Field title
Envelope envelopeOfLastField = null;
IElementContainer reportsSection;
//Field title in Page Header.
//Get the Page header section
var pageHeaderSection = mainReportSection?.Elements.OfType<ReportPageHeader>().FirstOrDefault();
//Check if there are any elements in the page header section. If there are none, the report is "Grouped"
if (pageHeaderSection.Elements.Count() == 0) //Page header has no child elements. The report is grouped on a field.
{
//Get Group Header.
// the title needs to be in the GroupHeader section.
var reportGroupHeader = mainReportSection?.Elements.OfType<ReportGroupHeader>().FirstOrDefault();
List<Element> textGraphicsInReportHeader = new List<Element>();
foreach (var elm in reportGroupHeader.Elements)
{
var elmGraphic = elm as GraphicElement;
if (elmGraphic == null) continue;
var graphic = elmGraphic.GetGraphic();
var cimParaGraphic = graphic as CIMParagraphTextGraphic;
if (cimParaGraphic != null)
textGraphicsInReportHeader.Add(elmGraphic);
}
//Get the Envelope of the last field header
envelopeOfLastField = textGraphicsInReportHeader?.FirstOrDefault().GetBounds();
//The IElementContainer is the "GroupHeader". Needed for the CreateRectangleParagraphGraphicElement method
reportsSection = reportGroupHeader;
}
else //not grouped
{
//Get the "ReportPageHeader" within the ReportSectionElement. ReportPageHeader is where "fields titles" are.
//var reportPageHeader = mainReportSection?.Elements.OfType<ReportPageHeader>().FirstOrDefault();
//Get the paragraph text element (the last title)
List<Element> textGraphicsInPageHeader = new List<Element>();
foreach (var elm in pageHeaderSection.Elements)
{
var elmGraphic = elm as GraphicElement;
if (elmGraphic == null) continue;
var graphic = elmGraphic.GetGraphic();
var cimParaGraphic = graphic as CIMParagraphTextGraphic;
if (cimParaGraphic != null)
textGraphicsInPageHeader.Add(elmGraphic);
}
if (textGraphicsInPageHeader.Count > 0)
{
//Get the Envelope of the last field header
envelopeOfLastField = textGraphicsInPageHeader.FirstOrDefault().GetBounds();
}
}
if (envelopeOfLastField != null)
{
//Min and Max values of the envelope
var xMinOfHeaderFieldEnvelope = envelopeOfLastField.XMin;
var yMinOfHeaderFieldEnvelope = envelopeOfLastField.YMin;
var xMaxOfHeaderFieldEnvelope = envelopeOfLastField.XMax;
var YMaxOfHeaderFieldEnvelope = envelopeOfLastField.YMax;
//create the new Envelope to be offset from the existing field
MapPoint newHeaderMinPoint = MapPointBuilderEx.CreateMapPoint(xMinOfHeaderFieldEnvelope + fieldIncrement, yMinOfHeaderFieldEnvelope);
MapPoint newHeaderMaxPoint = MapPointBuilderEx.CreateMapPoint(xMaxOfHeaderFieldEnvelope + fieldIncrement, YMaxOfHeaderFieldEnvelope);
Envelope newHeaderFieldEnvelope = EnvelopeBuilderEx.CreateEnvelope(newHeaderMinPoint, newHeaderMaxPoint);
#endregion
//The ILayoutElementContainer is the "PageHeader". Needed for the CreateRectangleParagraphGraphicElement method
reportsSection = pageHeaderSection;
//Create field header title
GraphicElement fieldHeaderGraphic = ReportElementFactory.Instance.CreateRectangleParagraphGraphicElement(reportsSection, newHeaderFieldEnvelope, field.Name);
}
}
});
}
