private static Dictionary <Table, List <long> > GetOidsByTable(
IReadOnlyDictionary <MapMember, IReadOnlyCollection <long> > oidsByMapMember)
{
var result = new Dictionary <Table, List <long> >();
foreach (KeyValuePair <MapMember, IReadOnlyCollection <long> > pair in oidsByMapMember)
{
MapMember mapMember = pair.Key;
if (!(mapMember is FeatureLayer featureLayer))
{
continue;
}
Table table = featureLayer.GetTable();
if (!result.ContainsKey(table))
{
result.Add(table, pair.Value.ToList());
}
else
{
result[table].AddRange(pair.Value);
}
}
return(result);
}
/// <summary>
/// Initialize a QueryBuilderControlProperties with the specified mapMember. Use the current definition query of that mapMember (if it exists) to extend the
/// initialization.
/// </summary>
/// <param name="mapMember">MapMember to initialize the QueryBuilderControlProperties. </param>
private void BuildControlProperties(MapMember mapMember)
{
// find the current definition query for the mapMember
string expression = "";
BasicFeatureLayer fLayer = mapMember as BasicFeatureLayer;
StandaloneTable table = mapMember as StandaloneTable;
if (fLayer != null)
{
expression = fLayer.DefinitionQuery;
}
else if (table != null)
{
expression = table.DefinitionQuery;
}
// create it
var props = new QueryBuilderControlProperties()
{
MapMember = mapMember,
Expression = expression,
};
// set the binding properties
this.ControlProperties = props;
MapMemberName = mapMember?.Name ?? "";
// keep track of the original expression
_origExpression = expression;
}
/// <summary>
/// Use a null mapMember to reset the QueryBuilderControlProperties.
/// </summary>
private void ClearControlProperties()
{
// reset the control
MapMember mapMember = null;
BuildControlProperties(mapMember);
}
public static void ValidateDefinition(this MapMember mm, string xmlDefinition)
{
if (mm != null)
{
ValidateXML(xmlDefinition);
}
}
/// <summary>
/// Constructor initializing the base class with the layer and object id associated with the pop-up content
/// </summary>
//public DynamicPopupContent(MapMember mapMember, long id, List<HierarchyRow> hierarchyRows) : base(mapMember, id)
public DynamicPopupContent(MapMember mapMember, long id, string featureClassName, RelateInfo relateInfo) : base(mapMember, id)
{
//Set property indicating the html content will be generated on demand when the content is viewed.
IsDynamicContent = true;
_featureClassName = featureClassName;
_id = id;
_relateInfo = relateInfo;
}
/// <summary>
/// Constructor initializing the base class with the layer and object id associated with the pop-up content
/// </summary>
//public DynamicPopupContent(MapMember mapMember, long id, List<HierarchyRow> hierarchyRows) : base(mapMember, id)
public DynamicPopupContent(MapMember mapMember, long id, string featureClassName, RelateInfo relateInfo) : base(mapMember, id)
{
//Set property indicating the html content will be generated on demand when the content is viewed.
IsDynamicContent = true;
_featureClassName = featureClassName;
_id = id;
_relateInfo = relateInfo;
}
private void CreateTableControlContent(MapMember mapTableToAdd)
{
TableControlContent tableContent = null;
if (TableControlContentFactory.IsMapMemberSupported(mapTableToAdd))
{
tableContent = TableControlContentFactory.Create(mapTableToAdd);
}
LabelsTableContent = tableContent;
}
protected async void ChangeParcelType()
{
await QueuedTask.Run(async() =>
{
//check for selected layer
if (MapView.Active.GetSelectedLayers().Count == 0)
{
System.Windows.MessageBox.Show("Please select a source layer in the table of contents", "Change Parcel Type");
return;
}
//first get the feature layer that's selected in the table of contents
var sourcePolygonL = MapView.Active.GetSelectedLayers().First() as FeatureLayer;
var layers = MapView.Active.Map.GetLayersAsFlattenedList();
var pfL = layers.FirstOrDefault(l => l is ParcelLayer) as ParcelLayer;
string sTargetParcelType = "Tax"; //Microsoft.VisualBasic.Interaction.InputBox("Target Parcel Type:", "Copy Parcel Lines To", "Tax");
if (sTargetParcelType.Trim().Length == 0)
{
return;
}
#region Change parcel type
var targetFeatLyr = layers.FirstOrDefault(l => l.Name == "Tax" && l is FeatureLayer) as FeatureLayer; //the target parcel polygon feature layer
if (pfL == null || sourcePolygonL == null)
{
return;
}
//add polygon layers and the feature ids to change the type on to a new KeyValuePair
MapMember mapMemberSource = sourcePolygonL as MapMember;
var ids = new List <long>(sourcePolygonL.GetSelection().GetObjectIDs());
var kvp = new KeyValuePair <MapMember, List <long> >(mapMemberSource, ids);
var sourceFeatures = new List <KeyValuePair <MapMember, List <long> > > {
kvp
};
var editOper = new EditOperation()
{
Name = "Change Parcel Type",
ProgressMessage = "Change Parcel Type...",
ShowModalMessageAfterFailure = true,
SelectNewFeatures = true,
SelectModifiedFeatures = false
};
editOper.ChangeParcelType(pfL, sourceFeatures, targetFeatLyr, -1);
await editOper.ExecuteAsync();
#endregion
});
}
public void ShowPopup(MapMember mapMember, long objectID)
{
//Get the active map view.
var mapView = MapView.Active;
if (mapView == null)
{
return;
}
mapView.ShowPopup(mapMember, objectID);
}
public PickableFeatureItem(MapMember mapMember, Feature feature, string text)
{
_feature = feature;
_featureLayer = mapMember as FeatureLayer;
Oid = feature.GetObjectID();
ItemText = text;
QueuedTask.Run(() =>
{
Geometry = feature.GetShape();
_itemImageUri = GetImagePath(Geometry);
});
}
private void GetLayerNode(Layer lyr, XmlDocument doc)
{
Layer plyr = MapView.Active.Map.FindLayer(lyr.URI, true);
MapMember mm = lyr;
XmlNode lnd;
lnd = doc.SelectSingleNode("//Layers/String[text()='" + lyr.URI + "']");
CIMService cs = new MapMemberService((MapMember)lyr);
//var xmlLayer = GetlayerDefinitionAsync(lyr);
var xmlLayer = cs.GetDefinitionAsync();
XmlDocumentFragment xfrag = doc.CreateDocumentFragment();
xfrag.InnerXml = xmlLayer.Result;
XmlNode nd = xfrag.FirstChild;
switch (lyr.GetType().Name)
{
case "GroupLayer":
lnd.AppendChild(xfrag);
GroupLayer glyr = (GroupLayer)lyr;
foreach (var layer in glyr.Layers)
{
lnd = doc.SelectSingleNode("//Layers/String[text()='" + lyr.URI + "']");
GetLayerNode(layer, doc);
}
break;
case "FeatureLayer":
var cfl = CIMFeatureLayer.FromXml(xmlLayer.Result);
GetRenderer(cfl.Renderer, nd, ReportDir);
lnd.AppendChild(nd);
break;
case "RasterLayer":
var crl = CIMRasterLayer.FromXml(xmlLayer.Result);
//GetRenderer(crl., nd, ReportDir);
lnd.AppendChild(nd);
break;
case "StandaloneTable":
lnd = doc.SelectSingleNode("//StandaloneTables/String[text()='" + lyr.URI + "']");
lnd.AppendChild(nd);
break;
default:
lnd.AppendChild(nd);
break;
}
}
public static Task <string> GetDefinitionXmlAsync(this MapMember mm)
{
return(QueuedTask.Run(() => {
if (mm == null)
{
return "";
}
if (mm is Layer)
{
return ((Layer)mm).GetDefinition().ToXml();
}
return ((StandaloneTable)mm).GetDefinition().ToXml();
}));
}
protected async void AssignFeaturesToRecord()
{
await QueuedTask.Run(async() =>
{
//check for selected layer
if (MapView.Active.GetSelectedLayers().Count == 0)
{
System.Windows.MessageBox.Show("Please select a source feature layer in the table of contents", "Assign Features To Record");
return;
}
//first get the feature layer that's selected in the table of contents
var srcFeatLyr = MapView.Active.GetSelectedLayers().First() as FeatureLayer;
var layers = MapView.Active.Map.GetLayersAsFlattenedList();
var myParcelFabricLayer = layers.FirstOrDefault(l => l is ParcelLayer) as ParcelLayer;
if (myParcelFabricLayer == null)
{
return;
}
var theActiveRecord = myParcelFabricLayer.GetActiveRecord();
if (theActiveRecord == null)
{
System.Windows.MessageBox.Show("There is no Active Record. Please set the active record and try again.", "Copy Line Features To");
return;
}
#region Assign features to active record
var guid = theActiveRecord.Guid;
var editOper = new EditOperation()
{
Name = "Assign Features to Record",
ProgressMessage = "Assign Features to Record...",
ShowModalMessageAfterFailure = true,
SelectNewFeatures = true,
SelectModifiedFeatures = false
};
//add parcel type layers and their feature ids to a new KeyValuePair
MapMember mapMemberSource = srcFeatLyr as MapMember;
var ids = new List <long>(srcFeatLyr.GetSelection().GetObjectIDs());
var kvp = new KeyValuePair <MapMember, List <long> >(mapMemberSource, ids);
var sourceFeatures = new List <KeyValuePair <MapMember, List <long> > > {
kvp
};
editOper.AssignFeaturesToRecord(myParcelFabricLayer, sourceFeatures, guid, ParcelRecordAttribute.CreatedByRecord);
await editOper.ExecuteAsync();
#endregion
});
}
public static IEnumerable <Feature> GetFeatures([NotNull] MapMember mapMember,
[NotNull] List <long> oidList,
bool recycling = false)
{
var basicFeatureLayer = mapMember as BasicFeatureLayer;
if (basicFeatureLayer == null)
{
yield break;
}
foreach (Feature feature in GetFeatures(basicFeatureLayer, oidList, recycling))
{
yield return(feature);
}
}
public static Task SetDefinitionAsync(this MapMember mm, string xmlDefinition)
{
ValidateXML(xmlDefinition);//This can throw!
return(QueuedTask.Run(() => {
if (mm is Layer)
{
var baseLayer = DeserializeXmlDefinition <CIMBaseLayer>(xmlDefinition);
((Layer)mm).SetDefinition(baseLayer);
}
else
{
var table = DeserializeXmlDefinition <CIMStandaloneTable>(xmlDefinition);
((StandaloneTable)mm).SetDefinition(table);
}
}));
}
public TabItemViewModel(MapMember mapMember,
DependencyObject visualTreeRoot)
{
TableContent = TableControlContentFactory.Create(mapMember);
MapMember = mapMember;
VisualTreeRoot = visualTreeRoot;
MenuItem zoomItem = new MenuItem()
{
Header = "Zoom to Feature",
Command = ZoomToRowCommand,
CommandParameter = this
};
RowContextMenu = new ContextMenu();
RowContextMenu.Items.Add(zoomItem);
}
public DefinitionFilterItem(MapMember mapMember, DefinitionQuery definitionQuery)
{
//if (definitionFilter == null) return;
_mapMember = mapMember;
_queryExpression = definitionQuery?.WhereClause;
_expressionName = definitionQuery?.Name;
_definitionFilter = definitionQuery;
var queryBuilderControlProps = new QueryBuilderControlProperties
{
Expression = CurrentDefinitionQuery?.WhereClause,
EditClauseMode = true,
MapMember = ItemMapMember,
AutoValidate = true
};
ControlProperties = queryBuilderControlProps;
_isActiveFilter = IsDefinitionFilterActive();
}
public DefinitionFilterItem(MapMember mapMember, CIMDefinitionFilter definitionFilter)
{
//if (definitionFilter == null) return;
_mapMember = mapMember;
_queryExpression = definitionFilter?.DefinitionExpression;
_expressionName = definitionFilter?.Name;
_definitionFilter = definitionFilter;
var queryBuilderControlProps = new QueryBuilderControlProperties
{
Expression = DefinitionFilter?.DefinitionExpression,
EditClauseMode = true,
MapMember = ItemMapMember,
AutoValidate = true
};
ControlProperties = queryBuilderControlProps;
_isActiveFilter = IsDefinitionFilterActive();
}
public void ShowPopupWithWindowDef(MapMember mapMember, long objectID)
{
if (MapView.Active == null)
{
return;
}
// Sample code: https://github.com/ArcGIS/arcgis-pro-sdk-community-samples/blob/master/Map-Exploration/CustomIdentify/CustomIdentify.cs
var topLeftCornerPoint = new System.Windows.Point(200, 200);
var popupDef = new PopupDefinition()
{
Append = true, // if true new record is appended to existing (if any)
Dockable = true, // if true popup is dockable - if false Append is not applicable
Position = topLeftCornerPoint, // Position of top left corner of the popup (in pixels)
Size = new System.Windows.Size(200, 400) // size of the popup (in pixels)
};
MapView.Active.ShowPopup(mapMember, objectID, popupDef);
}
private async Task GetStyleItemForLayerAsync(MapMember mapMember)
{
StyleItemType styleItemType = StyleItemType.Color;
//Selected layer is a FeatureLayer
if (mapMember is FeatureLayer)
{
var featureLayer = mapMember as FeatureLayer;
var featureShapeType = featureLayer.ShapeType;
switch (featureShapeType)
{
case esriGeometryType.esriGeometryPoint:
styleItemType = StyleItemType.PointSymbol;
break;
case esriGeometryType.esriGeometryMultipoint:
styleItemType = StyleItemType.PointSymbol;
break;
case esriGeometryType.esriGeometryLine:
styleItemType = StyleItemType.LineSymbol;
break;
case esriGeometryType.esriGeometryPolyline:
styleItemType = StyleItemType.LineSymbol;
break;
case esriGeometryType.esriGeometryPolygon:
styleItemType = StyleItemType.PolygonSymbol;
break;
default:
break;
}
SelectedStyleItemType = styleItemType;
}
//Selected Layer is a GraphicsLayer
if (mapMember is GraphicsLayer)
{
await GetStyleItemForGraphicsLayerAsync(mapMember as GraphicsLayer);
}
}
/// PopupContent.IsDynamicContent, PopupContent.OnCreateHtmlContent
/// <example>
/// <code title="Show A Dynamic Pop-up" description="Show a custom pop-up with dynamically generated content." region="Show A Dynamic Pop-up" source="..\..\ArcGIS\SharedArcGIS\SDK\Examples\ArcGIS.Desktop.Mapping\MapExploration\Popup_Examples.cs" lang="CS"/>
/// </example>
#region Show A Dynamic Pop-up
public void ShowDynamicPopup(MapMember mapMember, List <long> objectIDs)
{
//Get the active map view.
var mapView = MapView.Active;
if (mapView == null)
{
return;
}
//Create popup whose content is created the first time the item is requested.
var popups = new List <PopupContent>();
foreach (var id in objectIDs)
{
popups.Add(new DynamicPopupContent(mapMember, id));
}
mapView.ShowCustomPopup(popups);
}
private void ApplyFilterChangesToLayer(MapMember mapMember)
{
QueuedTask.Run(() => {
//Apply these filters to the Selected Map Member
if (mapMember is BasicFeatureLayer)
{
var selectedMapMemberAsLayer = mapMember as BasicFeatureLayer;
selectedMapMemberAsLayer.InsertDefinitionQuery(new DefinitionQuery {
WhereClause = ThisDefinitionFilterItem.QueryExpression
});
}
if (mapMember is StandaloneTable)
{
var selectedMapMemberAsTable = mapMember as StandaloneTable;
selectedMapMemberAsTable.InsertDefinitionQuery(new DefinitionQuery {
WhereClause = ThisDefinitionFilterItem.QueryExpression
});
}
});
}
// todo daro Use MapViewInitialized or DrawComplete?
//private void OnMapViewInitialized(MapViewEventArgs e)
//{
// // https://community.esri.com/t5/arcgis-pro-sdk-questions/how-to-wait-for-mapview-to-load/td-p/831290
// // https://community.esri.com/t5/arcgis-pro-sdk-questions/initialize-module-when-map-loaded/m-p/816108#M2596
// // fires every time a view is initialized
// // todo daro obj.MapView or MapView.Active?
// foreach (var pair in _uriByWorklistName)
// {
// // ReSharper disable once UnusedVariable
// string worklistName = pair.Key;
// // ReSharper disable once UnusedVariable
// string uri = pair.Value;
// }
//}
private void OnMapMemberPropertiesChanged(MapMemberPropertiesChangedEventArgs e)
{
ViewUtils.Try(() =>
{
List <MapMember> mapMembers = e.MapMembers.ToList();
List <MapMemberEventHint> eventHints = e.EventHints.ToList();
if (mapMembers.Count == 0)
{
return;
}
Assert.AreEqual(mapMembers.Count, eventHints.Count,
$"Unequal count of {nameof(MapMember)} and {nameof(MapMemberEventHint)}");
for (var index = 0; index < mapMembers.Count; index++)
{
if (eventHints[index] != MapMemberEventHint.Name)
{
continue;
}
MapMember mapMember = mapMembers[index];
string uri = LayerUtils.GetUri(mapMember);
string name = WorkListUtils.ParseName(uri);
if (!_viewsByWorklistName.TryGetValue(name, out IWorkListObserver view))
{
continue;
}
if (view.View == null)
{
continue;
}
ViewUtils.RunOnUIThread(() => { view.View.Title = mapMember.Name; });
}
}, _msg);
}
public static async Task <IEnumerable <long> > GetSelectedIdsFor(MapMember layer)
{
if (layer == null)
{
return(Enumerable.Empty <long>());
}
var selection = await GetSelection(layer.Map);
return(selection
.SelectMany(pair => {
if (pair.Key is BasicFeatureLayer selectedLayer)
{
if (selectedLayer == layer)
{
return pair.Value;
}
}
return null;
}));
}
private void ApplyFilterChangesToLayer(MapMember mapMember, System.Collections.ObjectModel.ObservableCollection <DefinitionFilterItem> definitionFilters)
{
//Get the definition filters from the collection of DefinitionFilters
var defFilters = new List <CIMDefinitionFilter>();
foreach (var filter in definitionFilters)
{
defFilters.Add(filter.DefinitionFilter);
}
QueuedTask.Run(() => {
//Apply these filters to the Selected Map Member
if (mapMember is BasicFeatureLayer)
{
var selectedMapMemberAsLayer = mapMember as BasicFeatureLayer;
selectedMapMemberAsLayer.SetDefinitionFilters(defFilters);
}
if (mapMember is StandaloneTable)
{
var selectedMapMemberAsTable = mapMember as StandaloneTable;
selectedMapMemberAsTable.SetDefinitionFilters(defFilters);
}
});
}
private void CreateTableControlContent()
{
TableControlContent tableContent = null;
var selectedLyrs = MapView.Active.GetSelectedLayers();
var selectedSTs = MapView.Active.GetSelectedStandaloneTables();
MapMember item = null;
if (selectedLyrs != null && selectedLyrs.Count == 1)
{
item = selectedLyrs[0];
}
else if (selectedSTs != null && selectedSTs.Count == 1)
{
item = selectedSTs[0];
}
if (TableControlContentFactory.IsMapMemberSupported(item))
{
tableContent = TableControlContentFactory.Create(item);
}
TableContent = tableContent;
}
private async void OnMapSelectionChanged(MapSelectionChangedEventArgs args)
{
bool contains = false;
foreach (var selection in args.Selection)
{
MapMember mapMember = selection.Key;
FeatureLayer layer = mapMember as FeatureLayer;
if (layer == Layer)
{
_selection = selection.Value;
contains = true;
await GenerateGmlAsync();
if (IsVisibleInGlobespotter)
{
if (_vectorLayerList.EditTool != EditTools.SketchPointTool)
{
Measurements = await ReloadSelectionAsync();
}
else
{
_updateMeasurements = true;
}
}
}
}
if ((!contains) && (_selection != null))
{
Measurements = null;
_selection = null;
await GenerateGmlAsync();
}
}
/// <summary>
/// Build a QueryBuilderControlProperties for the specified mapView. Finds the first BasicFeatureLayer or StandAloneTable highlighted in the TOC.
/// </summary>
/// <param name="mapView">a mapView.</param>
private void BuildControlProperties(MapView mapView)
{
MapMember mapMember = null;
if (mapView != null)
{
// only interested in basicFeatureLayers ... they are the ones with definition queries
var selectedTOCLayers = mapView.GetSelectedLayers().OfType <BasicFeatureLayer>();
var selectedTOCTables = mapView.GetSelectedStandaloneTables();
// take layers over tables... but only take the first
if (selectedTOCLayers.Count() > 0)
{
mapMember = selectedTOCLayers.First();
}
else if (selectedTOCTables.Count() > 0)
{
mapMember = selectedTOCTables.First();
}
}
// build the control properties
BuildControlProperties(mapMember);
}
/// <summary>
/// Constructor initializing the base class with the layer and object id associated with the pop-up content
/// </summary>
public DynamicPopupContent(MapMember mapMember, long id) : base(mapMember, id)
{
//Set property indicating the html content will be generated on demand when the content is viewed.
IsDynamicContent = true;
}
/// <summary>
/// Constructor initializing the base class with the layer and object id associated with the pop-up content
/// </summary>
public DynamicPopupContent(MapMember mapMember, long id) : base(mapMember, id)
{
//Set property indicating the html content will be generated on demand when the content is viewed.
IsDynamicContent = true;
}
public DynamicPopupContent(MapMember mapMember, long objectID)
{
MapMember = mapMember;
ID = objectID;
IsDynamicContent = true;
}
public static string GetUri([NotNull] MapMember mapMember)
{
return(mapMember.URI);
}
