void findNearbyToolWindow_FindNearby(object sender, FindNearbyEventArgs e)
{
if (Layer == null)
{
return;
}
GraphicsLayer graphicsLayer = Layer as GraphicsLayer;
if (graphicsLayer == null)
{
return;
}
if (graphicsLayer.SelectionCount < 1)
{
findNearbyToolWindow.StopBusyIndicator();
MessageBoxDialog.Show(Resources.Strings.MsgNoFeaturesSelected, Resources.Strings.ErrorCaption, MessageBoxButton.OK);
return;
}
BufferParameters bufferParams = new BufferParameters();
switch (e.LinearUnit)
{
case LinearUnit.Miles:
bufferParams.Unit = ESRI.ArcGIS.Client.Tasks.LinearUnit.StatuteMile;
break;
case LinearUnit.Meters:
bufferParams.Unit = ESRI.ArcGIS.Client.Tasks.LinearUnit.Meter;
break;
case LinearUnit.Kilometers:
bufferParams.Unit = ESRI.ArcGIS.Client.Tasks.LinearUnit.Kilometer;
break;
}
bufferParams.UnionResults = true;
bufferParams.OutSpatialReference = Map.SpatialReference;
SpatialReference gcs = new SpatialReference(4326);
bufferParams.BufferSpatialReference = gcs;
bufferParams.Geodesic = true;
bufferParams.Distances.Add(e.Distance);
// Check the spatial reference of the first graphic
Graphic firstGraphic = graphicsLayer.SelectedGraphics.ElementAt(0);
bool isInGcs = firstGraphic.Geometry != null &&
firstGraphic.Geometry.SpatialReference != null &&
firstGraphic.Geometry.SpatialReference.Equals(gcs);
// In order to perform geodesic buffering we need to pass geometries in GCS to the geom service
if (isInGcs)
{
foreach (Graphic selectedGraphic in graphicsLayer.SelectedGraphics)
{
bufferParams.Features.Add(selectedGraphic);
}
buffer(GeometryServiceUrl, bufferParams, e);
}
else
{
GeometryServiceOperationHelper helper = new GeometryServiceOperationHelper(GeometryServiceUrl);
helper.ProjectGraphicsCompleted += (o, args) => {
foreach (Graphic selectedGraphic in args.Graphics)
{
bufferParams.Features.Add(selectedGraphic);
}
buffer(GeometryServiceUrl, bufferParams, e);
};
helper.ProjectGraphics(graphicsLayer.SelectedGraphics.ToList(), new SpatialReference(4326));
}
}
private void PerformPostLayerInitializationActions(Layer layer, bool initializationSuccess)
{
GraphicsLayer gLayer = layer as GraphicsLayer;
if (gLayer != null)
{
GeometryType geometryType = Core.LayerExtensions.GetGeometryType(gLayer);
Collection <FieldInfo> layerFields = Core.LayerExtensions.GetFields(gLayer);
FeatureLayer featureLayer = layer as FeatureLayer;
if (layerFields.Count == 0 &&
featureLayer != null && featureLayer.LayerInfo != null && featureLayer.LayerInfo.Fields != null)
{
foreach (ESRI.ArcGIS.Client.Field field in featureLayer.LayerInfo.Fields)
{
if (FieldHelper.IsFieldFilteredOut(field.Type))
{
continue;
}
ESRI.ArcGIS.Mapping.Core.FieldInfo fieldInfo = ESRI.ArcGIS.Mapping.Core.FieldInfo.FieldInfoFromField(featureLayer, field);
layerFields.Add(fieldInfo);
}
}
if (gLayer.Graphics != null)
{
#region Get geometry type, start getting symbology
if (geometryType == GeometryType.Unknown && gLayer.Graphics.Count > 0)
{
geometryType = LayerUtils.GetGeometryTypeFromGraphic(gLayer.Graphics.ElementAtOrDefault(0));
Core.LayerExtensions.SetGeometryType(gLayer, geometryType);
if ((gLayer.Renderer == null || gLayer.Renderer is HiddenRenderer) && !Symbology.DefaultSymbols.ContainsKey(geometryType))
{
if (geometryType == GeometryType.Unknown)
{
gLayer.SetValue(ESRI.ArcGIS.Client.Extensibility.LayerExtensions.ErrorMessageProperty, "Layer has unspecified geometry type.");
}
else
{
Core.LayerExtensions.SetRunLayerPostInitializationActions(gLayer, true);
SymbolConfigProvider.GetDefaultLinearGradientBrush(gLayer, ColorRampType.ClassBreaks);
}
return;
}
}
#endregion
#region Project graphics if necessary
if (graphicsRequireReprojection(gLayer.Graphics))
{
GeometryServiceOperationHelper helper = new GeometryServiceOperationHelper(
new ConfigurationStoreHelper().GetGeometryServiceUrl(ConfigurationStore)
);
helper.ProjectGraphicsCompleted += (sender, args) =>
{
GraphicsLayer targetLayer = args.UserState as GraphicsLayer;
if (targetLayer != null)
{
targetLayer.Graphics.Clear();
foreach (Graphic graphic in args.Graphics)
{
targetLayer.Graphics.Add(graphic);
}
}
};
helper.ProjectGraphics(gLayer.Graphics, Map.SpatialReference, gLayer);
}
#endregion
#region Get field information
if (layerFields.Count == 0) // fields not determined yet
{
determineFieldsFromGraphic(layerFields, gLayer.Graphics.ElementAtOrDefault(0));
}
#endregion
}
#region Get renderer from feature layer's layer info, if necessary
if (gLayer.Renderer == null || gLayer.Renderer is HiddenRenderer)
{
FeatureLayer lay = gLayer as FeatureLayer;
if (lay != null && lay.LayerInfo != null && lay.LayerInfo.Renderer != null)
{
lay.Renderer = lay.LayerInfo.Renderer;
}
}
#endregion
#region Change PictureMarkerSymbol to ImageFillSymbol
if (gLayer.Renderer != null && (geometryType == GeometryType.Point || geometryType == GeometryType.MultiPoint))
{
SimpleRenderer sr = gLayer.Renderer as SimpleRenderer;
ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol pms = null;
if (sr != null)
{
pms = sr.Symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol;
if (pms != null)
{
sr.Symbol = SymbolJsonHelper.ToImageFillSymbol(pms);
}
}
else
{
ClassBreaksRenderer cbr = gLayer.Renderer as ClassBreaksRenderer;
if (cbr != null)
{
foreach (ClassBreakInfo info in cbr.Classes)
{
pms = info.Symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol;
if (pms != null)
{
info.Symbol = SymbolJsonHelper.ToImageFillSymbol(pms);
}
}
}
else
{
UniqueValueRenderer uvr = gLayer.Renderer as UniqueValueRenderer;
if (uvr != null)
{
foreach (UniqueValueInfo info in uvr.Infos)
{
pms = info.Symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol;
if (pms != null)
{
info.Symbol = SymbolJsonHelper.ToImageFillSymbol(pms);
}
}
}
}
}
}
#endregion
if (gLayer.Renderer == null || gLayer.Renderer is HiddenRenderer)
{
ApplyDefaultRenderer(gLayer, geometryType);
}
ApplyDefaultGradientBrush(gLayer);
}
else if ((layer is ArcGISDynamicMapServiceLayer || layer is ArcGISTiledMapServiceLayer) &&
!((bool)layer.GetValue(ESRI.ArcGIS.Client.WebMap.Document.IsBaseMapProperty)))
{
//get layer infos - used later for figuring out domain/subtypes, etc
if ((layer.GetValue(ESRI.ArcGIS.Mapping.Core.LayerExtensions.LayerInfosProperty) as Collection <LayerInformation>)
== null)
{
getLayerInfos(layer);
}
}
bool doSelect = false;
layer.SetValue(ESRI.ArcGIS.Client.Extensibility.LayerExtensions.InitialUpdateCompletedProperty, true);
if (!initializationSuccess)
{
layer.SetValue(ESRI.ArcGIS.Client.Extensibility.LayerExtensions.InitialUpdateFailedProperty, true);
}
else
{
bool hasId = !string.IsNullOrEmpty(layer.ID) || !string.IsNullOrEmpty(layer.GetValue(ESRI.ArcGIS.Client.Extensibility.MapApplication.LayerNameProperty) as string);
// Certain layers get added when the map draw mode is changed (An empty graphics layer is added)
// We don't want to auto-select this layer
if (hasId || !(layer is GraphicsLayer))
{
doSelect = true;
}
}
if (doSelect)
{
SetSelectedLayer(new LayerEventArgs()
{
Layer = layer
});
}
SubscribeToLayerInitializationEvents(layer, false);
}
public override void Execute(object parameter)
{
if (Layer == null)
{
return;
}
bool isServerLayer = false;
Envelope targetExtent = null;
TiledLayer tiledLayer = Layer as TiledLayer;
if (tiledLayer != null)
{
isServerLayer = true;
targetExtent = LayerExtentExtensions.GetTiledLayerFullExtent(tiledLayer); // get the cached value (if any) which will likely be in the map's spRef already
if (targetExtent == null) // value not known, use value on service metadata (will likely be in the services' spatial ref and not neccesarily in map's spRef)
{
targetExtent = tiledLayer.FullExtent;
}
if (tiledLayer is ESRI.ArcGIS.Client.Bing.TileLayer)
{
if (targetExtent.SpatialReference == null)
{
targetExtent.SpatialReference = new SpatialReference(102100);
}
}
}
DynamicLayer dynamicLayer = Layer as DynamicLayer;
if (dynamicLayer != null)
{
isServerLayer = true;
targetExtent = LayerExtentExtensions.GetDynamicLayerFullExtent(dynamicLayer); // get the cached value (if any) which will likely be in the map's spRef already
if (targetExtent == null) // value not known, use value on service metadata (will likely be in the services' spatial ref and not neccesarily in map's spRef)
{
targetExtent = dynamicLayer.FullExtent;
}
}
if (isServerLayer)
{
if (targetExtent == null || Map == null || Map.SpatialReference == null)
{
return;
}
if (Map.SpatialReference.Equals(targetExtent.SpatialReference))
{
// spatial reference matches. can directly zoom
Map.ZoomTo(targetExtent);
}
else
{
if (string.IsNullOrEmpty(GeometryServiceUrl))
{
throw new Exception(Resources.Strings.ExceptionNoGeometryServiceUrlSpecifiedLayerZoomedIsDifferentSpatialReference);
}
GeometryServiceOperationHelper helper = new GeometryServiceOperationHelper(GeometryServiceUrl);
helper.ProjectExtentCompleted += (o, e) =>
{
// Cache (save) the projected extent values
if (tiledLayer != null)
{
LayerExtentExtensions.SetTiledLayerFullExtent(tiledLayer, e.Extent);
}
else if (dynamicLayer != null)
{
LayerExtentExtensions.SetDynamicLayerFullExtent(dynamicLayer, e.Extent);
}
Map.ZoomTo(e.Extent);
};
helper.ProjectExtent(targetExtent, Map.SpatialReference);
}
return;
}
// Non server rendererd layers follow
GraphicsLayer graphicsLayer = Layer as GraphicsLayer;
if (graphicsLayer == null)
{
return;
}
if (Map != null)
{
Envelope newMapExtent = null;
if (graphicsLayer.Graphics.Count < 1)
{
FeatureLayer featureLayer = graphicsLayer as FeatureLayer;
if (featureLayer != null && featureLayer.LayerInfo != null && featureLayer.LayerInfo.Extent != null)
{
Envelope env = featureLayer.LayerInfo.Extent;
SpatialReference sr = env.SpatialReference;
if (sr == null)
{
sr = featureLayer.LayerInfo.DefaultSpatialReference;
}
if (Map.SpatialReference.Equals(sr))
{
Map.PanTo(env);
}
else if (sr != null)
{
GeometryServiceOperationHelper geomHelper = new GeometryServiceOperationHelper(
new ConfigurationStoreHelper().GetGeometryServiceUrl(View.Instance.ConfigurationStore));
geomHelper.GeometryServiceOperationFailed += (o, args) =>
{
Logger.Instance.LogError(args.Exception);
throw args.Exception;
};
geomHelper.ProjectExtentCompleted += (o, args) =>
{
MapZoomOrPan(args.Extent);
};
geomHelper.ProjectExtent(env, Map.SpatialReference);
}
}
}
else
{
foreach (Graphic graphic in graphicsLayer.Graphics)
{
if (graphic.Geometry != null && graphic.Geometry.Extent != null)
{
newMapExtent = graphic.Geometry.Extent.Union(newMapExtent);
}
}
newMapExtent = MapZoomOrPan(newMapExtent);
}
}
}
