private LayerInformation ToLayerInfo(MetaData.GPParameter param, int id)
{
LayerInformation layerInfo = new LayerInformation()
{
Name = param.Name,
ID = id
};
MetaData.GPFeatureRecordSetLayer frs = param.DefaultValue as MetaData.GPFeatureRecordSetLayer;
if (frs != null && frs.Fields != null && frs.Fields.Length > 0)
{
foreach (MetaData.Field field in frs.Fields)
{
if (FieldHelper.IsFieldFilteredOut(field.Type))
{
continue;
}
layerInfo.Fields.Add(new ESRI.ArcGIS.Mapping.Core.FieldInfo()
{
DisplayName = field.Alias,
FieldType = mapFieldType(field.Type),
Name = field.Name,
VisibleInAttributeDisplay = true,
VisibleOnMapTip = true,
});
if (string.IsNullOrEmpty(layerInfo.DisplayField))
{
layerInfo.DisplayField = field.Name;
}
}
}
return(layerInfo);
}
void singleLayerRequestCompleted(LayerInformation info, object userState)
{
pendingRequests--;
if (info != null)
{
singleRequestLayerInfos.Add(info);
}
if (pendingRequests < 1)
{
Collection <LayerInformation> layerinfos = new Collection <LayerInformation>();
foreach (int id in singleRequestLayerIds)
{
foreach (LayerInformation item in singleRequestLayerInfos)
{
if (item.ID == id)
{
layerinfos.Add(item);
break;
}
}
}
onLayerInfosCompleted(new LayerInfosEventArgs()
{
LayerInfos = layerinfos, UserState = userState
});
}
}
private void bindToGraphicsLayer(GraphicsLayer graphicsLayer)
{
object fields = graphicsLayer.GetValue(LayerExtensions.FieldsProperty);
if (fields is IEnumerable <FieldInfo> )
{
string displayField = LayerExtensions.GetDisplayField(graphicsLayer);
if (string.IsNullOrEmpty(displayField))
{
displayField = FieldInfo.GetDefaultDisplayField(fields as IEnumerable <FieldInfo>);
if (!string.IsNullOrEmpty(displayField))
{
LayerExtensions.SetDisplayField(graphicsLayer, displayField);
}
}
#region Set data context
MapTipsConfigInfo info = new MapTipsConfigInfo()
{
LayerSelectionVisibility = false,
PopUpsOnClick = LayerExtensions.GetPopUpsOnClick(graphicsLayer),
IsPopupEnabled = ESRI.ArcGIS.Client.Extensibility.LayerProperties.GetIsPopupEnabled(graphicsLayer),
Layer = graphicsLayer,
};
setFromWebMap(info);
info.SupportsOnClick = true;
info.Layers = new Collection <LayerInformation>();
LayerInformation item = new LayerInformation();
item.PopUpsEnabled = true;
item.ID = 0;
item.Name = LayerExtensions.GetTitle(Layer);
item.DisplayField = displayField;
item.Fields = fields as Collection <FieldInfo>;
if (graphicsLayer is FeatureLayer)
{
foreach (FieldInfo field in item.Fields)
{
if (field.DomainSubtypeLookup == DomainSubtypeLookup.NotDefined)
{
field.DomainSubtypeLookup = FieldInfo.GetDomainSubTypeLookup(graphicsLayer, field);
}
}
}
info.Layers.Add(item);
info.SelectedItem = item;
info.PropertyChanged += info_PropertyChanged;
this.DataContext = info;
#endregion
}
}
private void getLayerInfos(Layer layer)
{
if (layer == null)
{
return;
}
string layerUrl = IdentifySupport.GetLayerUrl(layer);
if (!string.IsNullOrWhiteSpace(layerUrl))
{
MapServiceLayerInfoHelper helper = new MapServiceLayerInfoHelper(layerUrl, layer, IdentifySupport.GetLayerProxyUrl(layer));
helper.GetLayerInfosCompleted += (s, e) =>
{
Collection <LayerInformation> gpResultMapServerLayerInfos = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetGPResultMapServerLayerInfos(layer);
Collection <LayerInformation> layerInfos = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetLayerInfos(layer);
if (gpResultMapServerLayerInfos != null)
{
Collection <int> layerIds = new Collection <int>();
foreach (LayerInformation layerInfo in layerInfos)
{
LayerInformation gpResultMapServerLayerInfo = gpResultMapServerLayerInfos.FirstOrDefault(p => p.ID == layerInfo.ID);
if (gpResultMapServerLayerInfo != null)
{
layerInfo.PopUpsEnabled = gpResultMapServerLayerInfo.PopUpsEnabled;
if (!string.IsNullOrEmpty(gpResultMapServerLayerInfo.DisplayField))
{
layerInfo.DisplayField = gpResultMapServerLayerInfo.DisplayField;
}
if (layerInfo.PopUpsEnabled)
{
layerIds.Add(layerInfo.ID);
}
foreach (FieldInfo field in layerInfo.Fields)
{
FieldInfo gpField = gpResultMapServerLayerInfo.Fields.FirstOrDefault(p => p.Name == field.Name);
if (gpField != null)
{
field.DisplayName = gpField.DisplayName;
field.VisibleOnMapTip = gpField.VisibleOnMapTip;
}
}
}
}
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetIdentifyLayerIds(layer, layerIds);
}
};
helper.GetLayerInfos(null);
}
}
public static List <PopupItem> GetPopupItems(IEnumerable <Graphic> graphics, Layer layer, int?layerId = null)
{
List <PopupItem> popupItems = new List <PopupItem>();
IEnumerable <FieldInfo> fields = null;
LayerInformation layerInfo = null;
if (layer is GraphicsLayer)
{
fields = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetFields(layer as GraphicsLayer);
}
else if (layerId != null)
{
Collection <LayerInformation> layerInfos = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetLayerInfos(layer);
if (layerInfos != null)
{
layerInfo = layerInfos.FirstOrDefault(l => l.ID == layerId);
if (layerInfo != null)
{
fields = layerInfo.Fields;
}
}
}
string layerName = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetLayerName(layer);
foreach (Graphic graphic in graphics)
{
PopupItem popupItem = GetPopupItem(graphic, layer, fields, layerInfo, layerName);
if (popupItem != null)
{
popupItems.Add(popupItem);
}
}
return(popupItems);
}
void reportResults(IdentifyEventArgs args)
{
if (doNotShowResults)
{
removeBusyIndicator(); return;
}
if (args.IdentifyResults != null && args.IdentifyResults.Count > 0)
{
Layer layer = (args.UserState as UserState).Layer;
Collection <LayerInformation> layerInfos = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetLayerInfos(layer);
foreach (IdentifyResult result in args.IdentifyResults)
{
LayerInformation layerInfo = layerInfos.FirstOrDefault(l => l.ID == result.LayerId);
if (layerInfo != null)
{
PopupItem popupItem = PopupHelper.GetPopupItem(result.Feature, layer, layerInfo.Fields, layerInfo, result.LayerName, result.Value.ToString(), result.LayerId);
if (popupItem != null)
{
_popupInfo.PopupItems.Add(popupItem);
}
}
}
}
removeBusyIndicator();
if (_popupInfo.PopupItems.Count > 0)
{
if (_popupInfo.SelectedIndex < 0)
{
_popupInfo.SelectedIndex = 0;
}
PopupHelper.ShowPopup(_popupInfo, clickPoint);
}
}
private static void GetMappedAttributes(IDictionary <string, object> originalAttributes, LayerInformation info)
{
if (info == null || info.Fields == null)
{
return;
}
Dictionary <string, object> atts = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> origAtt in originalAttributes)
{
FieldInfo field = GetFieldByAliasOnServer(origAtt.Key, info.Fields);
if (field != null)
{
if (!atts.ContainsKey(field.Name))
{
atts.Add(field.Name, origAtt.Value);
}
}
}
foreach (var item in atts)
{
if (!originalAttributes.ContainsKey(item.Key))
{
originalAttributes.Add(item);
}
}
return;
}
public static PopupItem GetPopupItem(Graphic graphic, Layer layer, IEnumerable <FieldInfo> fields, LayerInformation layerInfo, string layerName, string title = null, int?layerId = null)
{
if (layerInfo != null || layer is GraphicsLayer)
{
PopupItem popupItem = new PopupItem()
{
Graphic = graphic,
Layer = layer,
Title = title,
LayerName = layerName,
};
if (layerId.HasValue)
{
popupItem.LayerId = layerId.Value;
}
if (layerInfo != null)
{
GetMappedAttributes(graphic.Attributes, layerInfo);
}
popupItem.FieldInfos = MapTipsHelper.ToFieldSettings(fields);
MapTipsHelper.GetTitle(popupItem, layerInfo);
bool hasContent = true;
DataTemplate dt = MapTipsHelper.BuildMapTipDataTemplate(popupItem, out hasContent, layerInfo);
if (!hasContent)
{
popupItem.DataTemplate = null;
}
else if (dt != null)
{
popupItem.DataTemplate = dt;
}
if (hasContent || (!string.IsNullOrWhiteSpace(popupItem.Title)))
{
return(popupItem);
}
}
return(null);
}
private void processPre10LayerInfoResult(ArcGISWebClient.DownloadStringCompletedEventArgs e)
{
#region Parse layer ids from json
if (e.Cancelled)
{
return;
}
if (e.Error != null)
{
onLayerInfosCompleted(new LayerInfosEventArgs()
{
LayerInfos = null, UserState = e
});
return;
}
string json = null;
try
{
json = e.Result;
}
catch (Exception exception)
{
if (exception != null)
{
onLayerInfosCompleted(new LayerInfosEventArgs()
{
LayerInfos = null, UserState = e
});
return;
}
}
Exception ex = ESRI.ArcGIS.Mapping.DataSources.Utils.CheckJsonForException(json);
if (ex != null)
{
onLayerInfosCompleted(new LayerInfosEventArgs()
{
LayerInfos = null, UserState = e
});
return;
}
MapServiceInfo mapServiceInfo = JsonSerializer.Deserialize <MapServiceInfo>(json);
if (mapServiceInfo == null || mapServiceInfo.Layers == null)
{
onLayerInfosCompleted(new LayerInfosEventArgs()
{
LayerInfos = null, UserState = e
});
return;
}
singleRequestLayerIds = new List <int>();
foreach (MapServiceLayerInfo layer in mapServiceInfo.Layers)
{
LayerInformation info = new LayerInformation()
{
ID = layer.ID,
Name = layer.Name,
PopUpsEnabled = false
};
if (layer.SubLayerIds == null || layer.SubLayerIds.Length < 1)
{
singleRequestLayerIds.Add(layer.ID);
}
}
if (singleRequestLayerIds.Count < 1)
{
onLayerInfosCompleted(new LayerInfosEventArgs()
{
LayerInfos = null, UserState = e
});
}
else
{
singleRequestLayerInfos = new List <LayerInformation>();
singleRequestWebClients = new List <ArcGISWebClient>();
cancelSingleRequests = false;
pendingRequests = singleRequestLayerIds.Count;
foreach (int id in singleRequestLayerIds)
{
getLayerInfo(id, e.UserState);
}
}
#endregion
}
private void processLayerInfoResult(ArcGISWebClient.DownloadStringCompletedEventArgs e)
{
#region Parse layer info from json
if (e.Cancelled)
{
return;
}
if (e.Error != null)
{
singleLayerRequestCompleted(null, e);
return;
}
string json = null;
try
{
json = e.Result;
}
catch (Exception exception)
{
if (exception != null)
{
singleLayerRequestCompleted(null, e);
return;
}
}
Exception ex = ESRI.ArcGIS.Mapping.DataSources.Utils.CheckJsonForException(json);
if (ex != null)
{
singleLayerRequestCompleted(null, e);
return;
}
json = "{\"layerDefinition\":" + json + "}";
FeatureLayer featureLayer = FeatureLayer.FromJson(json);
FeatureLayerInfo featurelayerinfo = featureLayer.LayerInfo;
if (featurelayerinfo == null)
{
singleLayerRequestCompleted(null, e);
return;
}
LayerInformation info = new LayerInformation()
{
ID = featurelayerinfo.Id,
DisplayField = featurelayerinfo.DisplayField,
Name = featurelayerinfo.Name,
PopUpsEnabled = false,
LayerJson = json,
FeatureLayer = featureLayer
};
Collection <ESRI.ArcGIS.Mapping.Core.FieldInfo> fieldInfos = new Collection <ESRI.ArcGIS.Mapping.Core.FieldInfo>();
if (featurelayerinfo.Fields != null)
{
foreach (ESRI.ArcGIS.Client.Field field in featurelayerinfo.Fields)
{
if (FieldHelper.IsFieldFilteredOut(field.Type))
{
continue;
}
ESRI.ArcGIS.Mapping.Core.FieldInfo fieldInfo = ESRI.ArcGIS.Mapping.Core.FieldInfo.FieldInfoFromField(featureLayer, field);
fieldInfos.Add(fieldInfo);
}
}
info.Fields = fieldInfos;
if (fieldInfos.Count > 0)
{
singleLayerRequestCompleted(info, e);
}
else
{
singleLayerRequestCompleted(null, e);
}
#endregion
}
