private async Task QueryRows(object query)
{
string where = "";
if (query != null)
{
where = query.ToString();
}
IsLoading = true;
lock (_theLock) {
ListOfRows.Clear();
}
if (_layerSource == null)
{
_layerSource = await _selectedLayer.getFeatureClass();
}
if (_layerSource != null)
{
var data = new List <DynamicDataRow>();
await QueuingTaskFactory.StartNew(() => {
var queryFilter = new ArcGIS.Core.Data.QueryFilter {
WhereClause = where
};
int maxcols = 6;
RowCursor cursor = _layerSource.Search(queryFilter);
if (cursor.MoveNext())
{
ExtendListView.Columns = new List <ArcGIS.Core.Data.Field>();
maxcols = cursor.Current.Fields.Count() > 6 ? 6 : cursor.Current.Fields.Count();
for (int c = 0; c < maxcols; c++)
{
ExtendListView.Columns.Add(cursor.Current.Fields[c]);
}
do
{
var row = new DynamicDataRow();
for (int v = 0; v < maxcols; v++)
{
row[GetName(cursor.Fields[v])] = cursor.Current[v].ToString();
}
data.Add(row);
} while (cursor.MoveNext());
}
});
lock (_theLock) {
ListOfRows = null;
ListOfRows = data;
}
}
RaisePropertyChanged("ListOfRows");
Status = string.Format("{0} rows loaded", ListOfRows.Count());
IsLoading = false;
}
protected override async void OnClick()
{
var result = await QueuedTask.Run(() =>
{
var mapView = MapView.Active;
if (mapView == null)
return false;
//Get the collection of line layers that have at least one feature selected.
var selection = mapView.Map.GetSelection();
var keyValuePairs = selection.Where(kvp => (kvp.Key is BasicFeatureLayer)
&& (kvp.Key as BasicFeatureLayer).ShapeType == esriGeometryType.esriGeometryPolyline);
foreach (var kvp in keyValuePairs)
{
var layer = kvp.Key as BasicFeatureLayer;
var oid = kvp.Value.First();
//Get a cursor for the layer using the OID of the first selected feature.
var oidField = layer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter() { WhereClause = string.Format("{0} = {1}", oidField, oid) };
var cursor = layer.Search(qf);
Feature row = null;
if (cursor.MoveNext())
row = cursor.Current as Feature;
if (row == null)
continue;
//If the feature doesn't have Z values in the geometry continue to the next layer.
var polyline = row.GetShape();
if (!polyline.HasZ)
continue;
//If the layer doesn't have 3D properties set continue to the next layer.
var layerDef = layer.GetDefinition();
var layer3DProperties = layerDef.Layer3DProperties;
if (layer3DProperties == null)
continue;
//Get the vertical unit set on the layer and send it and the line feature to the module method to construct the keyframes.
var verticalUnit = layer3DProperties.VerticalUnit;
Animation.Current.CreateKeyframesAlongPath(polyline as Polyline, verticalUnit);
return true;
}
return false;
});
//If at least 1 selected 3D feature was not found show a message box.
if (!result)
MessageBox.Show("Select at least one 3D line feature.", "No 3D line features selected.");
}
/// <summary>
/// Called when the sketch is finished.
/// </summary>
protected override async Task<bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
//Get the instance of the ViewModel from the dock pane
var featureSelVM = Module1.FeatureSelectionVM;
if (featureSelVM == null || featureSelVM.SelectedLayer == null)
return true;
return await QueuedTask.Run(() =>
{
//Return all the features that intersect the sketch geometry
var result = MapView.Active.GetFeatures(geometry);
var layerSelection = result.FirstOrDefault(kvp => kvp.Key == featureSelVM.SelectedLayer);
//Clear the selection if no features where returned
if (!result.ContainsKey(featureSelVM.SelectedLayer))
{
featureSelVM.SelectedLayer.Select(null, SelectionCombinationMethod.Subtract);
return true;
}
//Construct a query filter using the OIDs of the features that intersected the sketch geometry
var oidList = result[featureSelVM.SelectedLayer];
var oid = featureSelVM.SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter() { WhereClause = string.Format("({0} in ({1}))", oid, string.Join(",", oidList)) };
//Add to the clause using the where clause specified in the dock pane.
if (featureSelVM.WhereClause != "" && featureSelVM.WhereClause != null)
qf.WhereClause += string.Format(" AND ({0})", featureSelVM.WhereClause);
//Return if the expression is not valid.
if (!featureSelVM.ValidateExpresion(false))
return true;
//Change the method depending on the hot keys that are pressed.
var method = SelectionCombinationMethod.New;
if (_ctrlPressed && _shiftPressed)
method = SelectionCombinationMethod.And;
else if (_ctrlPressed)
method = SelectionCombinationMethod.Subtract;
else if (_shiftPressed)
method = SelectionCombinationMethod.Add;
try
{
//Create the new selection
featureSelVM.SelectedLayer.Select(qf, method);
}
catch (Exception){} //May occur if expression validates but is still invalid expression.
return true;
});
}
private Task ShowAttributes()
{
return(QueuedTask.Run(() =>
{
try
{
_fieldAttributes.Clear();
if (SelectedLayer == null || SelectedOID == null)
{
return;
}
var oidField = SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("{0} = {1}", oidField, SelectedOID)
};
var cursor = SelectedLayer.Search(qf);
Row row = null;
if (cursor.MoveNext())
{
row = cursor.Current;
}
if (row == null)
{
return;
}
var fields = row.GetFields();
lock (_lock)
{
foreach (ArcGIS.Core.Data.Field field in fields)
{
if (field.FieldType == FieldType.Geometry)
{
continue;
}
var val = row[field.Name];
FieldAttributeInfo fa = new FieldAttributeInfo(field, (val is DBNull || val == null) ? null : val.ToString());
_fieldAttributes.Add(fa);
}
}
}
catch (Exception)
{
}
}));
}
public void SearchAndUpdate()
{
#region Search for layer features and update a field
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//find layer
var disLayer = ArcGIS.Desktop.Mapping.MapView.Active.Map.FindLayers("Distribution mains").FirstOrDefault() as BasicFeatureLayer;
//Search by attribute
var queryFilter = new ArcGIS.Core.Data.QueryFilter();
queryFilter.WhereClause = "CONTRACTOR = 'KCGM'";
var oidSet = new List <long>();
using (var rc = disLayer.Search(queryFilter))
{
//Create list of oids to update
while (rc.MoveNext())
{
oidSet.Add(rc.Current.GetObjectID());
}
}
//Create edit operation
var op = new ArcGIS.Desktop.Editing.EditOperation();
op.Name = "Update date";
// load features into inspector and update field
var insp = new ArcGIS.Desktop.Editing.Attributes.Inspector();
insp.Load(disLayer, oidSet);
insp["InspDate"] = "9/21/2013";
// modify and execute
op.Modify(insp);
op.Execute();
});
#endregion
}
private Task ShowAttributes()
{
return QueuedTask.Run(() =>
{
try
{
_fieldAttributes.Clear();
if (SelectedLayer == null || SelectedOID == null)
return;
var oidField = SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter() { WhereClause = string.Format("{0} = {1}", oidField, SelectedOID) };
var cursor = SelectedLayer.Search(qf);
Row row = null;
if (cursor.MoveNext())
row = cursor.Current;
if (row == null)
return;
var fields = row.GetFields();
lock (_lock)
{
foreach (ArcGIS.Core.Data.Field field in fields)
{
if (field.FieldType == FieldType.Geometry)
continue;
var val = row[field.Name];
FieldAttributeInfo fa = new FieldAttributeInfo(field, (val is DBNull || val == null) ? null : val.ToString());
_fieldAttributes.Add(fa);
}
}
}
catch (Exception ex)
{
}
});
}
public void EditOperations()
{
var featureLayer = MapView.Active.Map.GetLayersAsFlattenedList()[0] as FeatureLayer;
var polygon = new PolygonBuilder().ToGeometry();
var clipPoly = new PolygonBuilder().ToGeometry();
var cutLine = new PolylineBuilder().ToGeometry();
var modifyLine = cutLine;
var oid = 1;
var layer = featureLayer;
#region Edit Operation Create Features
var createFeatures = new EditOperation();
createFeatures.Name = "Create Features";
//Create a feature with a polygon
createFeatures.Create(featureLayer, polygon);
//with a callback
createFeatures.Create(featureLayer, polygon, (object_id) => {
//TODO - use the oid of the created feature
//in your callback
});
//Do a create features and set attributes
var attributes = new Dictionary <string, object>();
attributes.Add("SHAPE", polygon);
attributes.Add("NAME", "Corner Market");
attributes.Add("SIZE", 1200.5);
attributes.Add("DESCRIPTION", "Corner Market");
createFeatures.Create(featureLayer, attributes);
//Create features using the current template
//Must be within a MapTool
createFeatures.Create(this.CurrentTemplate, polygon);
//Execute to execute the operation
//Must be called within QueuedTask.Run
createFeatures.Execute();
//or use async flavor
//await createFeatures.ExecuteAsync();
#endregion
#region Create a feature using the current template
var myTemplate = ArcGIS.Desktop.Editing.Templates.EditingTemplate.Current;
var myGeometry = _geometry;
//Create edit operation and execute
var op = new ArcGIS.Desktop.Editing.EditOperation();
op.Name = "Create my feature";
op.Create(myTemplate, myGeometry);
op.Execute();
#endregion
#region Create feature from a modified inspector
var insp = new ArcGIS.Desktop.Editing.Attributes.Inspector();
insp.Load(layer, 86);
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
// modify attributes if necessary
// insp["Field1"] = newValue;
//Create new feature from an existing inspector (copying the feature)
var createOp = new ArcGIS.Desktop.Editing.EditOperation();
createOp.Name = "Create from insp";
createOp.Create(insp.MapMember, insp.ToDictionary(a => a.FieldName, a => a.CurrentValue));
createOp.Execute();
});
#endregion
var csvData = new List <CSVData>();
#region Create features from a CSV file
//Run on MCT
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//Create the edit operation
var createOperation = new ArcGIS.Desktop.Editing.EditOperation();
createOperation.Name = "Generate points";
createOperation.SelectNewFeatures = false;
// determine the shape field name - it may not be 'Shape'
string shapeField = layer.GetFeatureClass().GetDefinition().GetShapeField();
//Loop through csv data
foreach (var item in csvData)
{
//Create the point geometry
ArcGIS.Core.Geometry.MapPoint newMapPoint = ArcGIS.Core.Geometry.MapPointBuilder.CreateMapPoint(item.X, item.Y);
// include the attributes via a dictionary
var atts = new Dictionary <string, object>();
atts.Add("StopOrder", item.StopOrder);
atts.Add("FacilityID", item.FacilityID);
atts.Add(shapeField, newMapPoint);
// queue feature creation
createOperation.Create(layer, atts);
}
// execute the edit (feature creation) operation
return(createOperation.Execute());
});
#endregion
#region Edit Operation Clip Features
var clipFeatures = new EditOperation();
clipFeatures.Name = "Clip Features";
clipFeatures.Clip(featureLayer, oid, clipPoly, ClipMode.PreserveArea);
//Execute to execute the operation
//Must be called within QueuedTask.Run
clipFeatures.Execute();
//or use async flavor
//await clipFeatures.ExecuteAsync();
#endregion
#region Edit Operation Cut Features
var select = MapView.Active.SelectFeatures(clipPoly);
var cutFeatures = new EditOperation();
cutFeatures.Name = "Cut Features";
cutFeatures.Split(featureLayer, oid, cutLine);
//Cut all the selected features in the active view
//Select using a polygon (for example)
var kvps = MapView.Active.SelectFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
cutFeatures.Split(kvps, cutLine);
//Execute to execute the operation
//Must be called within QueuedTask.Run
cutFeatures.Execute();
//or use async flavor
//await cutFeatures.ExecuteAsync();
#endregion
#region Edit Operation Delete Features
var deleteFeatures = new EditOperation();
deleteFeatures.Name = "Delete Features";
var table = MapView.Active.Map.StandaloneTables[0];
//Delete a row in a standalone table
deleteFeatures.Delete(table, oid);
//Delete all the selected features in the active view
//Select using a polygon (for example)
var selection = MapView.Active.SelectFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
deleteFeatures.Delete(selection);
//Execute to execute the operation
//Must be called within QueuedTask.Run
deleteFeatures.Execute();
//or use async flavor
//await deleteFeatures.ExecuteAsync();
#endregion
#region Edit Operation Duplicate Features
var duplicateFeatures = new EditOperation();
duplicateFeatures.Name = "Duplicate Features";
//Duplicate with an X and Y offset of 500 map units
duplicateFeatures.Duplicate(featureLayer, oid, 500.0, 500.0, 0.0);
//Execute to execute the operation
//Must be called within QueuedTask.Run
duplicateFeatures.Execute();
//or use async flavor
//await duplicateFeatures.ExecuteAsync();
#endregion
#region Edit Operation Explode Features
var explodeFeatures = new EditOperation();
explodeFeatures.Name = "Explode Features";
//Take a multipart and convert it into one feature per part
//Provide a list of ids to convert multiple
explodeFeatures.Explode(featureLayer, new List <long>()
{
oid
}, true);
//Execute to execute the operation
//Must be called within QueuedTask.Run
explodeFeatures.Execute();
//or use async flavor
//await explodeFeatures.ExecuteAsync();
#endregion
var destinationLayer = featureLayer;
#region Edit Operation Merge Features
var mergeFeatures = new EditOperation();
mergeFeatures.Name = "Merge Features";
//Merge three features into a new feature using defaults
//defined in the current template
mergeFeatures.Merge(this.CurrentTemplate as EditingFeatureTemplate, featureLayer, new List <long>()
{
10, 96, 12
});
//Merge three features into a new feature in the destination layer
mergeFeatures.Merge(destinationLayer, featureLayer, new List <long>()
{
10, 96, 12
});
//Use an inspector to set the new attributes of the merged feature
var inspector = new Inspector();
inspector.Load(featureLayer, oid);//base attributes on an existing feature
//change attributes for the new feature
inspector["NAME"] = "New name";
inspector["DESCRIPTION"] = "New description";
//Merge features into a new feature in the same layer using the
//defaults set in the inspector
mergeFeatures.Merge(featureLayer, new List <long>()
{
10, 96, 12
}, inspector);
//Execute to execute the operation
//Must be called within QueuedTask.Run
mergeFeatures.Execute();
//or use async flavor
//await mergeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Modify single feature
var modifyFeature = new EditOperation();
modifyFeature.Name = "Modify a feature";
//use an inspector
var modifyInspector = new Inspector();
modifyInspector.Load(featureLayer, oid);//base attributes on an existing feature
//change attributes for the new feature
modifyInspector["SHAPE"] = polygon; //Update the geometry
modifyInspector["NAME"] = "Updated name"; //Update attribute(s)
modifyFeature.Modify(modifyInspector);
//update geometry and attributes using overload
var featureAttributes = new Dictionary <string, object>();
featureAttributes["NAME"] = "Updated name";//Update attribute(s)
modifyFeature.Modify(featureLayer, oid, polygon, featureAttributes);
//Execute to execute the operation
//Must be called within QueuedTask.Run
modifyFeature.Execute();
//or use async flavor
//await modifyFeatures.ExecuteAsync();
#endregion
#region Edit Operation Modify multiple features
//Search by attribute
var queryFilter = new QueryFilter();
queryFilter.WhereClause = "OBJECTID < 1000000";
//Create list of oids to update
var oidSet = new List <long>();
using (var rc = featureLayer.Search(queryFilter))
{
while (rc.MoveNext())
{
using (var record = rc.Current)
{
oidSet.Add(record.GetObjectID());
}
}
}
//create and execute the edit operation
var modifyFeatures = new EditOperation();
modifyFeatures.Name = "Modify features";
modifyFeatures.ShowProgressor = true;
var muultipleFeaturesInsp = new Inspector();
muultipleFeaturesInsp.Load(featureLayer, oidSet);
muultipleFeaturesInsp["MOMC"] = 24;
modifyFeatures.Modify(muultipleFeaturesInsp);
modifyFeatures.ExecuteAsync();
#endregion
#region Search for layer features and update a field
ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run(() =>
{
//find layer
var disLayer = ArcGIS.Desktop.Mapping.MapView.Active.Map.FindLayers("Distribution mains").FirstOrDefault() as BasicFeatureLayer;
//Search by attribute
var filter = new ArcGIS.Core.Data.QueryFilter();
filter.WhereClause = "CONTRACTOR = 'KCGM'";
var oids = new List <long>();
using (var rc = disLayer.Search(filter))
{
//Create list of oids to update
while (rc.MoveNext())
{
using (var record = rc.Current)
{
oidSet.Add(record.GetObjectID());
}
}
}
//Create edit operation
var modifyOp = new ArcGIS.Desktop.Editing.EditOperation();
modifyOp.Name = "Update date";
// load features into inspector and update field
var dateInsp = new ArcGIS.Desktop.Editing.Attributes.Inspector();
dateInsp.Load(disLayer, oids);
dateInsp["InspDate"] = "9/21/2013";
// modify and execute
modifyOp.Modify(insp);
modifyOp.Execute();
});
#endregion
#region Move features
//Get all of the selected ObjectIDs from the layer.
var firstLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault();
var selectionfromMap = firstLayer.GetSelection();
// set up a dictionary to store the layer and the object IDs of the selected features
var selectionDictionary = new Dictionary <MapMember, List <long> >();
selectionDictionary.Add(firstLayer as MapMember, selectionfromMap.GetObjectIDs().ToList());
var moveFeature = new EditOperation();
moveFeature.Name = "Move features";
moveFeature.Move(selectionDictionary, 10, 10); //specify your units along axis to move the geometry
moveFeature.Execute();
#endregion
#region Move feature to a specific coordinate
//Get all of the selected ObjectIDs from the layer.
var abLayer = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault();
var mySelection = abLayer.GetSelection();
var selOid = mySelection.GetObjectIDs().FirstOrDefault();
var moveToPoint = new MapPointBuilder(1.0, 2.0, 3.0, 4.0, MapView.Active.Map.SpatialReference); //can pass in coordinates.
var modifyFeatureCoord = new EditOperation();
modifyFeatureCoord.Name = "Move features";
modifyFeatureCoord.Modify(abLayer, selOid, moveToPoint.ToGeometry()); //Modify the feature to the new geometry
modifyFeatureCoord.Execute();
#endregion
#region Edit Operation Planarize Features
var planarizeFeatures = new EditOperation();
planarizeFeatures.Name = "Planarize Features";
//Planarize one or more features
planarizeFeatures.Planarize(featureLayer, new List <long>()
{
oid
});
//Execute to execute the operation
//Must be called within QueuedTask.Run
planarizeFeatures.Execute();
//or use async flavor
//await planarizeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Reshape Features
var reshapeFeatures = new EditOperation();
reshapeFeatures.Name = "Reshape Features";
reshapeFeatures.Reshape(featureLayer, oid, modifyLine);
//Reshape a set of features that intersect some geometry....
var selFeatures = MapView.Active.GetFeatures(modifyLine).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
reshapeFeatures.Reshape(selFeatures, modifyLine);
//Execute to execute the operation
//Must be called within QueuedTask.Run
reshapeFeatures.Execute();
//or use async flavor
//await reshapeFeatures.ExecuteAsync();
#endregion
var origin = MapPointBuilder.CreateMapPoint(0, 0, null);
#region Edit Operation Rotate Features
var rotateFeatures = new EditOperation();
rotateFeatures.Name = "Rotate Features";
//Rotate works on a selected set of features
//Get all features that intersect a polygon
var rotateSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
//Rotate selected features 90 deg about "origin"
rotateFeatures.Rotate(rotateSelection, origin, Math.PI / 2);
//Execute to execute the operation
//Must be called within QueuedTask.Run
rotateFeatures.Execute();
//or use async flavor
//await rotateFeatures.ExecuteAsync();
#endregion
#region Edit Operation Scale Features
var scaleFeatures = new EditOperation();
scaleFeatures.Name = "Scale Features";
//Rotate works on a selected set of features
var scaleSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
//Scale the selected features by 2.0 in the X and Y direction
scaleFeatures.Scale(scaleSelection, origin, 2.0, 2.0, 0.0);
//Execute to execute the operation
//Must be called within QueuedTask.Run
scaleFeatures.Execute();
//or use async flavor
//await scaleFeatures.ExecuteAsync();
#endregion
var mp1 = MapPointBuilder.CreateMapPoint(0, 0, null);
var mp2 = mp1;
var mp3 = mp1;
#region Edit Operation Split Features
var splitFeatures = new EditOperation();
splitFeatures.Name = "Split Features";
var splitPoints = new List <MapPoint>()
{
mp1, mp2, mp3
};
//Split the feature at 3 points
splitFeatures.Split(featureLayer, oid, splitPoints);
// split using percentage
var splitByPercentage = new SplitByPercentage()
{
Percentage = 33, SplitFromStartPoint = true
};
splitFeatures.Split(featureLayer, oid, splitByPercentage);
// split using equal parts
var splitByEqualParts = new SplitByEqualParts()
{
NumParts = 3
};
splitFeatures.Split(featureLayer, oid, splitByEqualParts);
// split using single distance
var splitByDistance = new SplitByDistance()
{
Distance = 27.3, SplitFromStartPoint = false
};
splitFeatures.Split(featureLayer, oid, splitByDistance);
// split using varying distance
var distances = new List <double>()
{
12.5, 38.2, 89.99
};
var splitByVaryingDistance = new SplitByVaryingDistance()
{
Distances = distances, SplitFromStartPoint = true, ProportionRemainder = true
};
splitFeatures.Split(featureLayer, oid, splitByVaryingDistance);
//Execute to execute the operation
//Must be called within QueuedTask.Run
splitFeatures.Execute();
//or use async flavor
//await splitAtPointsFeatures.ExecuteAsync();
#endregion
var linkLayer = featureLayer;
#region Edit Operation Transform Features
var transformFeatures = new EditOperation();
transformFeatures.Name = "Transform Features";
//Transform a selected set of features
var transformSelection = MapView.Active.GetFeatures(polygon).Select(
k => new KeyValuePair <MapMember, List <long> >(k.Key as MapMember, k.Value));
transformFeatures.Transform(transformSelection, linkLayer);
//Transform just a layer
transformFeatures.Transform(featureLayer, linkLayer);
//Perform an affine transformation
transformFeatures.TransformAffine(featureLayer, linkLayer);
//Execute to execute the operation
//Must be called within QueuedTask.Run
transformFeatures.Execute();
//or use async flavor
//await transformFeatures.ExecuteAsync();
#endregion
#region Edit Operation Perform a Clip, Cut, and Planarize
//Multiple operations can be performed by a single
//edit operation.
var clipCutPlanarizeFeatures = new EditOperation();
clipCutPlanarizeFeatures.Name = "Clip, Cut, and Planarize Features";
clipCutPlanarizeFeatures.Clip(featureLayer, oid, clipPoly);
clipCutPlanarizeFeatures.Split(featureLayer, oid, cutLine);
clipCutPlanarizeFeatures.Planarize(featureLayer, new List <long>()
{
oid
});
//Note: An edit operation is a single transaction.
//Execute the operations (in the order they were declared)
clipCutPlanarizeFeatures.Execute();
//or use async flavor
//await clipCutPlanarizeFeatures.ExecuteAsync();
#endregion
#region Edit Operation Chain Edit Operations
//Chaining operations is a special case. Use "Chained Operations" when you require multiple transactions
//to be undo-able with a single "Undo".
//The most common use case for operation chaining is creating a feature with an attachement.
//Adding an attachment requires the object id (of a new feature) has already been created.
var editOperation1 = new EditOperation();
editOperation1.Name = string.Format("Create point in '{0}'", CurrentTemplate.Layer.Name);
long newFeatureID = -1;
//The Create operation has to execute so we can get an object_id
editOperation1.Create(this.CurrentTemplate, polygon, (object_id) => newFeatureID = object_id);
//Must be within a QueuedTask
editOperation1.Execute();
//or use async flavor
//await editOperation1.ExecuteAsync();
//Now, because we have the object id, we can add the attachment. As we are chaining it, adding the attachment
//can be undone as part of the "Undo Create" operation. In other words, only one undo operation will show on the
//Pro UI and not two.
var editOperation2 = editOperation1.CreateChainedOperation();
//Add the attachement using the new feature id
editOperation2.AddAttachment(this.CurrentTemplate.Layer, newFeatureID, @"C:\data\images\Hydrant.jpg");
//editOperation1 and editOperation2 show up as a single Undo operation on the UI even though
//we had two transactions
//Must be within a QueuedTask
editOperation2.Execute();
//or use async flavor
//await editOperation2.ExecuteAsync();
#endregion
#region Edit Operation add attachment via RowToken
//ArcGIS Pro 2.5 extends the EditOperation.AddAttachment method to take a RowToken as a paramter.
//This allows you to create a feature, using EditOperation.CreateEx, and add an attachment in one transaction.
var editOpAttach = new EditOperation();
editOperation1.Name = string.Format("Create point in '{0}'", CurrentTemplate.Layer.Name);
var attachRowToken = editOpAttach.CreateEx(this.CurrentTemplate, polygon);
editOpAttach.AddAttachment(attachRowToken, @"c:\temp\image.jpg");
//Must be within a QueuedTask
editOpAttach.Execute();
#endregion
#region SetOnUndone, SetOnRedone, SetOnComitted
// SetOnUndone, SetOnRedone and SetOnComittedManage can be used to manage
// external actions(such as writing to a log table) that are associated with
// each edit operation.
//get selected feature and update attribute
var selectedFeatures = MapView.Active.Map.GetSelection();
var testInspector = new Inspector();
testInspector.Load(selectedFeatures.Keys.First(), selectedFeatures.Values.First());
testInspector["Name"] = "test";
//create and execute the edit operation
var updateTestField = new EditOperation();
updateTestField.Name = "Update test field";
updateTestField.Modify(insp);
//actions for SetOn...
updateTestField.SetOnUndone(() =>
{
//Sets an action that will be called when this operation is undone.
Debug.WriteLine("Operation is undone");
});
updateTestField.SetOnRedone(() =>
{
//Sets an action that will be called when this editoperation is redone.
Debug.WriteLine("Operation is redone");
});
updateTestField.SetOnComitted((bool b) => //called on edit session save(true)/discard(false).
{
// Sets an action that will be called when this editoperation is committed.
Debug.WriteLine("Operation is committed");
});
updateTestField.Execute();
}
private async void OnSelectionChanged(MapSelectionChangedEventArgs obj)
{
if (MapView.Active != null && MapView.Active.Map != null && obj.Selection.Count == 1)
{
var fl = obj.Selection.FirstOrDefault().Key as FeatureLayer;
if (fl == null || fl.SelectionCount != 1 || fl.ShapeType != esriGeometryType.esriGeometryPoint)
{
return;
}
var pointd = await QueuedTask.Run(() =>
{
try
{
var SelectedOID = fl.GetSelection().GetObjectIDs().FirstOrDefault();
if (SelectedOID < 0)
{
return(null);
}
var SelectedLayer = fl as BasicFeatureLayer;
var oidField = SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("{0} = {1}", oidField, SelectedOID)
};
var cursor = SelectedLayer.Search(qf);
Row row = null;
if (cursor.MoveNext())
{
row = cursor.Current;
}
if (row == null)
{
return(null);
}
var fields = row.GetFields();
lock (_lock)
{
foreach (ArcGIS.Core.Data.Field field in fields)
{
if (field.FieldType == FieldType.Geometry)
{
// have mappoint here
var val = row[field.Name];
if (val is MapPoint)
{
var temp = val as MapPoint;
return(temp);
}
break;
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
return(null);
});
if (pointd != null)
{
Mediator.NotifyColleagues(CoordinateConversionLibrary.Constants.NewMapPointSelection, pointd);
}
}
}
protected override async void OnClick()
{
var result = await QueuedTask.Run(() =>
{
var mapView = MapView.Active;
if (mapView == null)
{
return(false);
}
//Get the collection of line layers that have at least one feature selected.
var selection = mapView.Map.GetSelection();
var keyValuePairs = selection.ToDictionary().Where(kvp => (kvp.Key is BasicFeatureLayer) &&
(kvp.Key as BasicFeatureLayer).ShapeType == esriGeometryType.esriGeometryPolyline);
foreach (var kvp in keyValuePairs)
{
var layer = kvp.Key as BasicFeatureLayer;
var oid = kvp.Value.First();
//Get a cursor for the layer using the OID of the first selected feature.
var oidField = layer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("{0} = {1}", oidField, oid)
};
var cursor = layer.Search(qf);
if (cursor.MoveNext())
{
using (var row = cursor.Current as Feature)
{
if (row == null)
{
continue;
}
//If the feature doesn't have Z values in the geometry continue to the next layer.
var polyline = row.GetShape();
if (!polyline.HasZ)
{
continue;
}
//If the layer doesn't have 3D properties set continue to the next layer.
var layerDef = layer.GetDefinition();
var layer3DProperties = layerDef.Layer3DProperties;
if (layer3DProperties == null)
{
continue;
}
//Get the vertical unit set on the layer and send it and the line feature to the module method to construct the keyframes.
var verticalUnit = layer3DProperties.VerticalUnit;
Animation.Current.CreateKeyframesAlongPath(polyline as Polyline, verticalUnit);
return(true);
}
}
}
return(false);
});
//If at least 1 selected 3D feature was not found show a message box.
if (!result)
{
MessageBox.Show("Select at least one 3D line feature.", "No 3D line features selected.");
}
}
/// <summary>
/// Execute a query against the selected layer's feature class and
/// display the resulting datatable
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
private async Task QueryRows(object query)
{
var where = string.Empty;
if (query != null) where = query.ToString();
IsLoading = true;
var rowCount = 0;
// get the features using the query
if (_selectedLayer != null)
{
await QueuedTask.Run(() =>
{
var basicFl = _selectedLayer as BasicFeatureLayer;
if (basicFl != null)
{
Table layerTable = basicFl.GetTable();
var dt = new DataTable();
var queryFilter = new ArcGIS.Core.Data.QueryFilter
{
WhereClause = where
};
RowCursor cursor;
// Use try catch to catch invalid SQL statements in queryFilter
try
{
cursor = layerTable.Search(queryFilter);
}
catch (GeodatabaseGeneralException gdbEx)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Error searching data. " + gdbEx.Message,
"Search Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
if (cursor.MoveNext())
{
var maxcols = cursor.Current.GetFields().Count() > 6
? 6
: cursor.Current.GetFields().Count();
for (var c = 0; c < maxcols; c++)
{
Type colType = typeof(string);
var format = string.Empty;
var fldDefinition = cursor.Current.GetFields()[c];
switch (fldDefinition.FieldType)
{
case FieldType.Blob:
format = "Blob";
break;
case FieldType.Raster:
format = "Raster";
break;
case FieldType.Geometry:
format = "Geom";
break;
case FieldType.Date:
colType = typeof(DateTime);
format = @"mm/dd/yyyy";
break;
case FieldType.Double:
format = "0,0.0##";
break;
case FieldType.Integer:
case FieldType.OID:
case FieldType.Single:
case FieldType.SmallInteger:
format = "0,0";
break;
case FieldType.GlobalID:
case FieldType.GUID:
case FieldType.String:
case FieldType.XML:
default:
break;
}
var col = new DataColumn(fldDefinition.Name, colType)
{
Caption = fldDefinition.AliasName
};
dt.Columns.Add(col);
}
do
{
var row = dt.NewRow();
rowCount++;
for (var colIdx = 0; colIdx < maxcols; colIdx++)
{
row[colIdx] = cursor.Current[colIdx];
}
dt.Rows.Add(row);
} while (cursor.MoveNext());
}
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
(Action)(() => UpdateDataTableOnUI(dt)));
}
});
}
Status = string.Format("{0} rows loaded", rowCount);
IsLoading = false;
}
private async Task QueryRows(object query)
{
string where = "";
if (query != null)
{
where = query.ToString();
}
IsLoading = true;
lock (_theLock)
{
ListOfRows.Clear();
}
if (_layerSource == null)
{
_layerSource = await _selectedLayer.getFeatureClass();
}
if (_layerSource != null)
{
var data = new List <DynamicDataRow>();
await QueuedTask.Run(() =>
{
var queryFilter = new ArcGIS.Core.Data.QueryFilter
{
WhereClause = where
};
int maxcols = 6;
RowCursor cursor = null;
// Use try catch to catch invalid SQL statements in queryFilter
try
{
cursor = _layerSource.Search(queryFilter);
}
catch (GeodatabaseGeneralException gdbEx)
{
System.Windows.MessageBox.Show("Error searching data. " + gdbEx.Message, "Search Error",
System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Exclamation);
return;
}
if (cursor.MoveNext())
{
ExtendListView.Columns = new List <ArcGIS.Core.Data.Field>();
maxcols = cursor.Current.GetFields().Count() > 6 ? 6 : cursor.Current.GetFields().Count();
for (int c = 0; c < maxcols; c++)
{
ExtendListView.Columns.Add(cursor.Current.GetFields()[c]);
}
do
{
var row = new DynamicDataRow();
for (int v = 0; v < maxcols; v++)
{
if (cursor.Current[v] != null)
{
row[GetName(cursor.GetFields()[v])] = cursor.Current[v].ToString();
}
}
data.Add(row);
} while (cursor.MoveNext());
}
});
lock (_theLock)
{
ListOfRows = null;
ListOfRows = data;
}
}
RaisePropertyChanged("ListOfRows");
Status = string.Format("{0} rows loaded", ListOfRows.Count());
IsLoading = false;
}
protected override async void OnClick()
{
Polygon polygone = null;
await QueuedTask.Run(() =>
{
try
{
//Get the active map view.
var mapView = MapView.Active;
if (mapView == null)
{
return;
}
//Get the selected features from the map and filter out the standalone table selection.
var selectedFeatures = mapView.Map.GetSelection()
.Where(kvp => kvp.Key is BasicFeatureLayer)
.ToDictionary(kvp => (BasicFeatureLayer)kvp.Key, kvp => kvp.Value);
foreach (var item in selectedFeatures)
{
Console.WriteLine(item.Key);
}
var rowCursor = mapView.Map.GetSelection();
var selection = mapView.Map.GetSelection();
var keyValuePairs = selection.Where(kvp => (kvp.Key is BasicFeatureLayer) &&
(kvp.Key as BasicFeatureLayer).ShapeType == esriGeometryType.esriGeometryPolygon);
foreach (var kvp in keyValuePairs)
{
var layer = kvp.Key as BasicFeatureLayer;
if (kvp.Value.Count > 1)
{
var oid = kvp.Value.First();
var oidField = layer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("{0} = {1}", oidField, oid)
};
var cursor = layer.Search(qf);
Feature row = null;
if (cursor.MoveNext())
{
row = cursor.Current as Feature;
}
if (row == null)
{
continue;
}
polygone = (Polygon)row.GetShape();
}
else
{
var oid = kvp.Value.First();
var oidField = layer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("{0} = {1}", oidField, oid)
};
var cursor = layer.Search(qf);
Feature row = null;
if (cursor.MoveNext())
{
row = cursor.Current as Feature;
}
if (row == null)
{
continue;
}
polygone = (Polygon)row.GetShape();
}
}
}
catch (Exception ex)
{
MessageBox.Show("There was an error getting the geometry of the selected shape. Please try your selection again." + Environment.NewLine + "Error: " + ex.Message);
Console.WriteLine("Error getting select shape geom");
return;
}
});
if (polygone.PointCount > 500)
{
MessageBox.Show("Too many vertices. Please simplify the selected Polygon or choose another one. Max vertices: 500");
return;
}
DockPane pane = FrameworkApplication.DockPaneManager.Find("Planet_Data_DocPane");
Data_DocPaneViewModel data_DocPaneViewModel = (Data_DocPaneViewModel)pane;
data_DocPaneViewModel.AOIGeometry = (Geometry)polygone;
pane.IsVisible = true;
data_DocPaneViewModel.Activate(true);
}
private async Task QueryRows(object query) {
string where = "";
if (query != null)
where = query.ToString();
IsLoading = true;
lock (_theLock) {
ListOfRows.Clear();
}
if (_layerSource == null)
_layerSource = await _selectedLayer.getFeatureClass();
if (_layerSource != null) {
var data = new List<DynamicDataRow>();
await QueuingTaskFactory.StartNew(() => {
var queryFilter = new ArcGIS.Core.Data.QueryFilter {
WhereClause = where
};
int maxcols = 6;
RowCursor cursor = _layerSource.Search(queryFilter);
if (cursor.MoveNext()) {
ExtendListView.Columns = new List<ArcGIS.Core.Data.Field>();
maxcols = cursor.Current.Fields.Count() > 6 ? 6 : cursor.Current.Fields.Count();
for (int c = 0; c < maxcols; c++) {
ExtendListView.Columns.Add(cursor.Current.Fields[c]);
}
do {
var row = new DynamicDataRow();
for (int v = 0; v < maxcols; v++) {
row[GetName(cursor.Fields[v])] = cursor.Current[v].ToString();
}
data.Add(row);
} while (cursor.MoveNext());
}
});
lock (_theLock) {
ListOfRows = null;
ListOfRows = data;
}
}
RaisePropertyChanged("ListOfRows");
Status = string.Format("{0} rows loaded", ListOfRows.Count());
IsLoading = false;
}
private async void OnSelectionChanged(MapSelectionChangedEventArgs obj)
{
if (MapView.Active.Map != null && obj.Selection.Count == 1)
{
var fl = obj.Selection.FirstOrDefault().Key as FeatureLayer;
if (fl == null || fl.SelectionCount != 1 || fl.ShapeType != esriGeometryType.esriGeometryPoint)
return;
var pointd = await QueuedTask.Run(() =>
{
try
{
var SelectedOID = fl.GetSelection().GetObjectIDs().FirstOrDefault();
if (SelectedOID < 0)
return string.Empty;
var SelectedLayer = fl as BasicFeatureLayer;
var oidField = SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter() { WhereClause = string.Format("{0} = {1}", oidField, SelectedOID) };
var cursor = SelectedLayer.Search(qf);
Row row = null;
if (cursor.MoveNext())
row = cursor.Current;
if (row == null)
return string.Empty;
var fields = row.GetFields();
lock (_lock)
{
foreach (ArcGIS.Core.Data.Field field in fields)
{
if (field.FieldType == FieldType.Geometry)
{
// have mappoint here
var val = row[field.Name];
if (val is MapPoint)
{
var temp = val as MapPoint;
// project to WGS1984
proCoordGetter.Point = temp;
proCoordGetter.Project(4326);
return string.Format("{0:0.0####} {1:0.0####}", proCoordGetter.Point.Y, proCoordGetter.Point.X);
}
break;
}
}
}
}
catch (Exception ex)
{
}
return string.Empty;
});
if (!string.IsNullOrWhiteSpace(pointd))
{
InputCoordinate = pointd;
}
}
}
/// <summary>
/// Execute a query against the selected layer's feature class and
/// display the resulting datatable
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
private async Task QueryRows(object query)
{
var where = string.Empty;
if (query != null)
{
where = query.ToString();
}
IsLoading = true;
var rowCount = 0;
// get the features using the query
if (_selectedLayer != null)
{
await QueuedTask.Run(() =>
{
var basicFl = _selectedLayer as BasicFeatureLayer;
if (basicFl != null)
{
Table layerTable = basicFl.GetTable();
var dt = new DataTable();
var queryFilter = new ArcGIS.Core.Data.QueryFilter
{
WhereClause = where
};
RowCursor cursor;
// Use try catch to catch invalid SQL statements in queryFilter
try
{
cursor = layerTable.Search(queryFilter);
}
catch (GeodatabaseGeneralException gdbEx)
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("Error searching data. " + gdbEx.Message,
"Search Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
if (cursor.MoveNext())
{
using (Row currentRow = cursor.Current)
{
var maxcols = currentRow.GetFields().Count() > 6
? 6
: currentRow.GetFields().Count();
for (var c = 0; c < maxcols; c++)
{
Type colType = typeof(string);
var format = string.Empty;
var fldDefinition = currentRow.GetFields()[c];
switch (fldDefinition.FieldType)
{
case FieldType.Blob:
format = "Blob";
break;
case FieldType.Raster:
format = "Raster";
break;
case FieldType.Geometry:
format = "Geom";
break;
case FieldType.Date:
colType = typeof(DateTime);
format = @"mm/dd/yyyy";
break;
case FieldType.Double:
format = "0,0.0##";
break;
case FieldType.Integer:
case FieldType.OID:
case FieldType.Single:
case FieldType.SmallInteger:
format = "0,0";
break;
case FieldType.GlobalID:
case FieldType.GUID:
case FieldType.String:
case FieldType.XML:
default:
break;
}
var col = new DataColumn(fldDefinition.Name, colType)
{
Caption = fldDefinition.AliasName
};
dt.Columns.Add(col);
}
do
{
var row = dt.NewRow();
rowCount++;
for (var colIdx = 0; colIdx < maxcols; colIdx++)
{
row[colIdx] = currentRow[colIdx];
}
dt.Rows.Add(row);
} while (cursor.MoveNext());
}
}
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
(Action)(() => UpdateDataTableOnUI(dt)));
}
});
}
Status = string.Format("{0} rows loaded", rowCount);
IsLoading = false;
}
public Task<bool> SelectFeaturesInDxLayers()
{
try
{
File.Delete(Common.GetConfiguration("DesignTxt"));
}
catch { }
string designNameAndExpressDesignID = SelectedDesign.ToString();
int firstParen = designNameAndExpressDesignID.IndexOf("(");
int lastParen = designNameAndExpressDesignID.IndexOf(")");
int selectedDesign = Convert.ToInt32(designNameAndExpressDesignID.Substring(firstParen + 1, lastParen - firstParen - 1));
var featuresInDesign = DxCommisionModel.GetFeaturesInDesign(selectedDesign);
Dictionary<string, int> idsByName = new Dictionary<string, int>();
foreach (KeyValuePair<int, string> kvp in DxCommisionModel.GetNameByID)
{
if (kvp.Value != null && kvp.Key != null)
{
idsByName.Add(kvp.Value, kvp.Key);
}
}
Dictionary<string, string> objectIDsToSelectByLayer = new Dictionary<string, string>();
foreach (var dxFe in featuresInDesign)
{
string className = DxCommisionModel.GetNameByID[dxFe.FeatureClassID];
if (objectIDsToSelectByLayer.ContainsKey(className) == false)
{
objectIDsToSelectByLayer.Add(className,dxFe.FeatureOID.ToString());
}
else
{
objectIDsToSelectByLayer[className] += "," + dxFe.FeatureOID.ToString();
}
}
return QueuedTask.Run(() =>
{
EnvelopeBuilder envBuilder = new EnvelopeBuilder();
if (true) {
#region Get Extent from ArcGIS Pro
StreamWriter sw = File.CreateText(Common.GetConfiguration("DesignTxt"));
//Determine the extent
//EnvelopeBuilder envBuilder = new EnvelopeBuilder();
envBuilder.XMin = 0;
envBuilder.XMax = 0;
envBuilder.YMin = 0;
envBuilder.YMax = 0;
var env = envBuilder.ToGeometry().Extent;
List<FeatureLayer> dxLayers = GetDxLayers();
foreach (var f in dxLayers)
{
try
{
if (objectIDsToSelectByLayer.ContainsKey(f.Name))
{
var oids = objectIDsToSelectByLayer[f.Name];
if (oids.Count() > 0)
{
Table table = f.GetTable();
sw.WriteLine(f.Name);
foreach (string oid in oids.Split(','))
{
List<Row> features = null;
features = GetRowListFor(table, new QueryFilter
{
WhereClause = "OBJECTID = " + oid
});
using (var feature = features[0])
{
Geometry shape = feature.GetOriginalValue(feature.FindField("SHAPE")) as Geometry;
Common.UnionEnvelopes(envBuilder, shape);
sw.WriteLine(oid);
}
}
}
}
}
catch (Exception ex) {
if (Common.GetConfiguration("DebugMessages") == "True")
{
MessageBox.Show("ERROR : " + ex.ToString());
}
}
finally
{
}
}
//Select the features
//if (Common.GetConfiguration("DebugMessages") == "True")
//{
// MessageBox.Show("About to close the stream");
//}
sw.Close();
//if (Common.GetConfiguration("DebugMessages") == "True")
//{
//MessageBox.Show("closed the stream stream");
//}
ArcGIS.Core.Data.QueryFilter qf = new ArcGIS.Core.Data.QueryFilter();
//if (Common.GetConfiguration("DebugMessages") == "True")
//{
// MessageBox.Show("dx layer count is " + dxLayers.Count);
//}
foreach (FeatureLayer fl in dxLayers)
{
if (objectIDsToSelectByLayer.ContainsKey(fl.Name))
{
qf.WhereClause = "OBJECTID in (" + objectIDsToSelectByLayer[fl.Name] + ")";
//if (Common.GetConfiguration("DebugMessages") == "True")
//{
// MessageBox.Show("Where clause for " + fl.Name + " : " + qf.WhereClause);
//}
try
{
fl.Select(qf, ArcGIS.Desktop.Mapping.SelectionCombinationMethod.New); //New works, add throws error
}
catch (Exception ex)
{
//MessageBox.Show("Selection Error " + ex.ToString());
}
}
}
//Zoom to it
//if (Common.GetConfiguration("DebugMessages") == "True")
//{
// MessageBox.Show("About to zoom");
//}
#endregion
}
else
{
//Get from ArcObjects
}
Map activeMap = MapView.Active.Map;
var extent = envBuilder.ToGeometry().Extent;
var expandedExtent = extent.Expand(1.2, 1.2, true);
MapView.Active.ZoomTo(expandedExtent);
return true;
});
//return Task.FromResult(true);
}
private async void OnSelectionChanged(MapSelectionChangedEventArgs obj)
{
if (MapView.Active.Map != null && obj.Selection.Count == 1)
{
var fl = obj.Selection.FirstOrDefault().Key as FeatureLayer;
if (fl == null || fl.SelectionCount != 1 || fl.ShapeType != esriGeometryType.esriGeometryPoint)
{
return;
}
var pointd = await QueuedTask.Run(() =>
{
try
{
var SelectedOID = fl.GetSelection().GetObjectIDs().FirstOrDefault();
if (SelectedOID < 0)
{
return(string.Empty);
}
var SelectedLayer = fl as BasicFeatureLayer;
var oidField = SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("{0} = {1}", oidField, SelectedOID)
};
var cursor = SelectedLayer.Search(qf);
Row row = null;
if (cursor.MoveNext())
{
row = cursor.Current;
}
if (row == null)
{
return(string.Empty);
}
var fields = row.GetFields();
lock (_lock)
{
foreach (ArcGIS.Core.Data.Field field in fields)
{
if (field.FieldType == FieldType.Geometry)
{
// have mappoint here
var val = row[field.Name];
if (val is MapPoint)
{
var temp = val as MapPoint;
// project to WGS1984
proCoordGetter.Point = temp;
proCoordGetter.Project(4326);
return(string.Format("{0:0.0####} {1:0.0####}", proCoordGetter.Point.Y, proCoordGetter.Point.X));
}
break;
}
}
}
}
catch (Exception ex)
{
}
return(string.Empty);
});
if (!string.IsNullOrWhiteSpace(pointd))
{
InputCoordinate = pointd;
}
}
}
public Task<bool> SelectFeaturesAsync(object obj)
{
string designNameAndExpressDesignID = SelectedDesign.ToString();
int firstParen = designNameAndExpressDesignID.IndexOf("(");
int lastParen = designNameAndExpressDesignID.IndexOf(")");
int selectedDesign = Convert.ToInt32(designNameAndExpressDesignID.Substring(firstParen + 1, lastParen - firstParen - 1));
//int selectedDesign = Convert.ToInt32( SelectedDesign);
var featuresInDesign = DxCommisionModel.GetFeaturesInDesign(selectedDesign);
List<FeatureLayer> dxLayers = Common.GetDxLayers();
Dictionary<string, int> idsByName = new Dictionary<string, int>();
foreach (KeyValuePair<int, string> kvp in DxCommisionModel.GetNameByID)
{
if (kvp.Value != null && kvp.Key != null)
{
idsByName.Add(kvp.Value, kvp.Key);
}
}
try
{
QueuedTask.Run(() =>
{
ArcGIS.Core.Data.QueryFilter qf = new ArcGIS.Core.Data.QueryFilter();
foreach (FeatureLayer fl in dxLayers)
{
string name = fl.Name;
int idToLookFor = idsByName[name];
// DxCommisionModel.GetNameByID(1);
foreach (var feInDesign in featuresInDesign)
{
if (feInDesign.FeatureClassID == idToLookFor )
{
string name2 = name;
int feClassID = feInDesign.FeatureClassID;
qf.WhereClause = "OBJECTID = " + feInDesign.FeatureOID;
var selection = fl.Select(qf, ArcGIS.Desktop.Mapping.SelectionCombinationMethod.Add);
}
}
}
return true;
});
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.ToString());
}
return Task.FromResult(true);
}
/// <summary>
/// Called when the sketch is finished.
/// </summary>
protected override async Task <bool> OnSketchCompleteAsync(ArcGIS.Core.Geometry.Geometry geometry)
{
//Get the instance of the ViewModel from the dock pane
var featureSelVM = Module1.FeatureSelectionVM;
if (featureSelVM == null || featureSelVM.SelectedLayer == null)
{
return(true);
}
return(await QueuedTask.Run(() =>
{
//Return all the features that intersect the sketch geometry
var result = MapView.Active.GetFeatures(geometry);
var layerSelection = result.FirstOrDefault(kvp => kvp.Key == featureSelVM.SelectedLayer);
//Clear the selection if no features where returned
if (!result.ContainsKey(featureSelVM.SelectedLayer))
{
featureSelVM.SelectedLayer.Select(null, SelectionCombinationMethod.Subtract);
return true;
}
//Construct a query filter using the OIDs of the features that intersected the sketch geometry
var oidList = result[featureSelVM.SelectedLayer];
var oid = featureSelVM.SelectedLayer.GetTable().GetDefinition().GetObjectIDField();
var qf = new ArcGIS.Core.Data.QueryFilter()
{
WhereClause = string.Format("({0} in ({1}))", oid, string.Join(",", oidList))
};
//Add to the clause using the where clause specified in the dock pane.
if (featureSelVM.WhereClause != "" && featureSelVM.WhereClause != null)
{
qf.WhereClause += string.Format(" AND ({0})", featureSelVM.WhereClause);
}
//Return if the expression is not valid.
if (!featureSelVM.ValidateExpresion(false))
{
return true;
}
//Change the method depending on the hot keys that are pressed.
var method = SelectionCombinationMethod.New;
if (_ctrlPressed && _shiftPressed)
{
method = SelectionCombinationMethod.And;
}
else if (_ctrlPressed)
{
method = SelectionCombinationMethod.Subtract;
}
else if (_shiftPressed)
{
method = SelectionCombinationMethod.Add;
}
try
{
//Create the new selection
featureSelVM.SelectedLayer.Select(qf, method);
}
catch (Exception) {} //May occur if expression validates but is still invalid expression.
return true;
}));
}
private async Task QueryRows(object query)
{
string where = "";
if (query != null)
where = query.ToString();
IsLoading = true;
lock (_theLock)
{
ListOfRows.Clear();
}
if (_layerSource == null)
_layerSource = await _selectedLayer.getFeatureClass();
if (_layerSource != null)
{
var data = new List<DynamicDataRow>();
await QueuedTask.Run(() =>
{
var queryFilter = new ArcGIS.Core.Data.QueryFilter
{
WhereClause = where
};
int maxcols = 6;
RowCursor cursor = null;
// Use try catch to catch invalid SQL statements in queryFilter
try
{
cursor = _layerSource.Search(queryFilter);
}
catch (GeodatabaseGeneralException gdbEx)
{
System.Windows.MessageBox.Show("Error searching data. " + gdbEx.Message, "Search Error",
System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Exclamation);
return;
}
if (cursor.MoveNext())
{
ExtendListView.Columns = new List<ArcGIS.Core.Data.Field>();
maxcols = cursor.Current.GetFields().Count() > 6 ? 6 : cursor.Current.GetFields().Count();
for (int c = 0; c < maxcols; c++)
{
ExtendListView.Columns.Add(cursor.Current.GetFields()[c]);
}
do
{
var row = new DynamicDataRow();
for (int v = 0; v < maxcols; v++)
{
if (cursor.Current[v] != null)
{
row[GetName(cursor.GetFields()[v])] = cursor.Current[v].ToString();
}
}
data.Add(row);
} while (cursor.MoveNext());
}
});
lock (_theLock)
{
ListOfRows = null;
ListOfRows = data;
}
}
RaisePropertyChanged("ListOfRows");
Status = string.Format("{0} rows loaded", ListOfRows.Count());
IsLoading = false;
}
