private static Layer Convert(Esri.ArcGISRuntime.Mapping.ILayerContent item)
{
Layer layer = null;
if (item is Esri.ArcGISRuntime.Mapping.ArcGISTiledLayer tile)
{
layer = new ArcGISTiledMapServiceLayer
{
Url = tile.Source.ToString()
};
}
if (item is Esri.ArcGISRuntime.Mapping.ArcGISMapImageLayer dynamic)
{
layer = new ArcGISDynamicMapServiceLayer
{
Url = dynamic.Source.ToString(),
};
}
if (layer != null)
{
layer.Visible = item.IsVisible;
layer.ID = item.Name;
layer.InitializationFailed += InitializationFailed;
layer.Initialized += Layer_Initialized;
}
return(layer);
}
/// <summary>
/// Toggle the visibility of a feature layer in an ArcGIS Dynamic Map Service Layer
/// </summary>
private void OnToggleFeatureLayer(object sender, RoutedEventArgs e)
{
HideConextMenu();
TOCNodeInfo nodeInfo = null;
TreeViewItem treeNode = null;
if (sender is CheckBox)
{
CheckBox checkBox = sender as CheckBox;
treeNode = checkBox.Tag as TreeViewItem;
nodeInfo = treeNode.Tag as TOCNodeInfo;
}
else if (sender is RadioButton)
{
RadioButton radioBox = sender as RadioButton;
treeNode = radioBox.Tag as TreeViewItem;
nodeInfo = treeNode.Tag as TOCNodeInfo;
}
if (treeNode != null && nodeInfo != null)
{
TreeViewItem mapNode = GetMapLayerNode(treeNode);
ArcGISDynamicMapServiceLayer dynamicLayer = this.MapControl.Layers[nodeInfo.MapID] as ArcGISDynamicMapServiceLayer;
int[] oldVisibles = (int[])dynamicLayer.VisibleLayers.Clone();
List <int> visLayers = new List <int>();
GetVisibleLayerIDs(mapNode, visLayers);
dynamicLayer.VisibleLayers = visLayers.ToArray();
EventCenter.DispatchMapLayerVisibilityChangeEvent(this, new MapLayerVisibilityChangeEventArgs(dynamicLayer, oldVisibles));
}
}
private void GeoprocessorTask_JobCompleted(object sender, ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs e)
{
WaitGrid.Visibility = Visibility.Collapsed;
if (e.JobInfo.JobStatus == esriJobStatus.esriJobSucceeded)
{
Geoprocessor geoprocessorTask = sender as Geoprocessor;
System.Threading.Thread.Sleep(2000);
resultLayer = geoprocessorTask.GetResultMapServiceLayer(e.JobInfo.JobId);
resultLayer.InitializationFailed += new EventHandler <EventArgs>(resultLayer_InitializationFailed);
resultLayer.DisplayName = e.JobInfo.JobId;
if (resultLayer != null)
{
_displayViewshedInfo = true;
MyMap.Layers.Add(resultLayer);
}
}
else
{
MessageBox.Show("Geoprocessor service failed");
_displayViewshedInfo = false;
}
}
private void OnMapLoadComplete(object sender, RoutedEventArgs e)
{
LivingMapLayer[] livingMaps = this.AppConfig.MapConfig.LivingMaps;
if (livingMaps != null && livingMaps.Length > 0)
{
for (int i = 0; i < livingMaps.Length; i++)
{
// Create Map Layer Nodes
TreeViewItem tvItem = CreateMapLayerNode(livingMaps[i]);
MapContentTree.Items.Add(tvItem);
if (this.MapControl.Layers[livingMaps[i].ID] is ArcGISTiledMapServiceLayer)
{
ArcGISTiledMapServiceLayer cachedLayer = this.MapControl.Layers[livingMaps[i].ID] as ArcGISTiledMapServiceLayer;
cachedLayer.QueryLegendInfos((legendInfo => OnLegendInfoSucceed(legendInfo, tvItem)), (exception => OnLegendInfoFailed(exception, livingMaps[i].Title)));
}
else if (this.MapControl.Layers[livingMaps[i].ID] is ArcGISDynamicMapServiceLayer)
{
ArcGISDynamicMapServiceLayer dynamicLayer = this.MapControl.Layers[livingMaps[i].ID] as ArcGISDynamicMapServiceLayer;
dynamicLayer.QueryLegendInfos((legendInfo => OnLegendInfoSucceed(legendInfo, tvItem)), (exception => OnLegendInfoFailed(exception, livingMaps[i].Title)));
}
else if (this.MapControl.Layers[livingMaps[i].ID] is FeatureLayer)
{
FeatureLayer featureLayer = this.MapControl.Layers[livingMaps[i].ID] as FeatureLayer;
featureLayer.QueryLegendInfos((legendInfo => OnLegendInfoSucceed(legendInfo, tvItem)), (exception => OnLegendInfoFailed(exception, livingMaps[i].Title)));
}
}
}
}
private void GeoprocessorTask_JobCompleted(object sender, ESRI.ArcGIS.Client.Tasks.JobInfoEventArgs e)
{
WaitGrid.Visibility = Visibility.Collapsed;
if (e.JobInfo.JobStatus == esriJobStatus.esriJobSucceeded)
{
Geoprocessor geoprocessorTask = sender as Geoprocessor;
System.Threading.Thread.Sleep(2000);
resultLayer = geoprocessorTask.GetResultMapServiceLayer(e.JobInfo.JobId);
resultLayer.InitializationFailed += new EventHandler<EventArgs>(resultLayer_InitializationFailed);
resultLayer.DisplayName = e.JobInfo.JobId;
if (resultLayer != null)
{
_displayViewshedInfo = true;
MyMap.Layers.Add(resultLayer);
}
}
else
{
MessageBox.Show("Geoprocessor service failed");
_displayViewshedInfo = false;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public AgsDynamicLayer(AgsServer server, MapLayer layer)
: base(layer)
{
Debug.Assert(layer.MapServiceInfo != null);
LayerType = AgsLayerType.Dynamic;
Server = server;
if (String.IsNullOrEmpty(layer.MapServiceInfo.Url))
{
throw new SettingsException((string)App.Current.FindResource("InvalidMapLayerURL"));
}
// format REST URL
string restUrl = FormatRestUrl(layer.MapServiceInfo.Url);
if (restUrl == null)
{
throw new SettingsException((string)App.Current.FindResource("FailedFormatRESTURL"));
}
// create ArcGIS layer
ArcGISDynamicMapServiceLayer arcGISDynamicMapServiceLayer = new ArcGISDynamicMapServiceLayer();
arcGISDynamicMapServiceLayer.ID = "map";
arcGISDynamicMapServiceLayer.Url = restUrl;
arcGISDynamicMapServiceLayer.Visible = layer.MapServiceInfo.IsVisible;
arcGISDynamicMapServiceLayer.Opacity = layer.MapServiceInfo.Opacity;
ArcGISLayer = arcGISDynamicMapServiceLayer;
UpdateTokenIfNeeded();
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public AgsDynamicLayer(AgsServer server, MapLayer layer)
: base(layer)
{
Debug.Assert(layer.MapServiceInfo != null);
LayerType = AgsLayerType.Dynamic;
Server = server;
if (String.IsNullOrEmpty(layer.MapServiceInfo.Url))
throw new SettingsException((string)App.Current.FindResource("InvalidMapLayerURL"));
// format REST URL
string restUrl = FormatRestUrl(layer.MapServiceInfo.Url);
if (restUrl == null)
throw new SettingsException((string)App.Current.FindResource("FailedFormatRESTURL"));
// create ArcGIS layer
ArcGISDynamicMapServiceLayer arcGISDynamicMapServiceLayer = new ArcGISDynamicMapServiceLayer();
arcGISDynamicMapServiceLayer.ID = "map";
arcGISDynamicMapServiceLayer.Url = restUrl;
arcGISDynamicMapServiceLayer.Visible = layer.MapServiceInfo.IsVisible;
arcGISDynamicMapServiceLayer.Opacity = layer.MapServiceInfo.Opacity;
ArcGISLayer = arcGISDynamicMapServiceLayer;
UpdateTokenIfNeeded();
}
/// <summary>
/// Gets the measurable sub-layers within a map service layer
/// </summary>
/// <param name="dynLayer">The <see cref="ArcGISDynamicMapServiceLayer"/> containing the sub-layers</param>
/// <param name="map">The <see cref="Map"/> containing the map service layer</param>
internal static ObservableCollection <LayerInfo> GetMeasurableSubLayers(
this ArcGISDynamicMapServiceLayer dynLayer, Map map)
{
ObservableCollection <LayerInfo> subLayers = new ObservableCollection <LayerInfo>();
if (dynLayer.VisibleLayers == null) // sub-layer visibility has not been altered from its default state
{
// Add layer to measurable layers if it is visible by default and is not hidden due to
// scale dependency
foreach (LayerInfo info in dynLayer.Layers)
{
if (info.DefaultVisibility && info.IsInVisibleRange(map))
{
subLayers.Add(info);
}
}
}
else // sub-layer visibility is not default
{
// Add layer to measurable layers if it is currently visible is not hidden due to scale dependency
foreach (int visibleLayerIndex in dynLayer.VisibleLayers)
{
if (dynLayer.Layers[visibleLayerIndex].IsInVisibleRange(map))
{
subLayers.Add(dynLayer.Layers[visibleLayerIndex]);
}
}
}
return(subLayers);
}
void layer_InitializationFailed(object sender, EventArgs e)
{
ArcGISDynamicMapServiceLayer dynamic = sender as ArcGISDynamicMapServiceLayer;
if (dynamic != null)
{
if (dynamic.ProxyURL == null)
{
_status = "ArcGIS FAILED using Proxy";
ArcGISDynamicMapServiceLayer newDynamic = new ArcGISDynamicMapServiceLayer();
newDynamic.InitializationFailed += new EventHandler <EventArgs>(layer_InitializationFailed);
newDynamic.Url = dynamic.Url;
newDynamic.ID = dynamic.ID;
//newDynamic.ProxyURL = MyProxy;
newDynamic.ProxyURL = _proxyUrl;
_map.Layers.Remove(dynamic);
_map.Layers.Add(newDynamic);
}
else
{
MessageBox.Show("Cannot access that service");
}
}
}
void Layers_LayersInitialized(object sender, System.EventArgs args)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(string.Format("Spatial Reference: {0}", MyMap.SpatialReference.WKT != null ? MyMap.SpatialReference.WKT : MyMap.SpatialReference.WKID.ToString()));
sb.AppendLine(string.Format("Minimum Resolution: {0}", MyMap.MinimumResolution));
sb.AppendLine(string.Format("Maximum Resolution: {0}", MyMap.MaximumResolution));
sb.AppendLine(string.Format("Width (pixels): {0}", MyMap.ActualWidth));
sb.AppendLine(string.Format("Height (pixels): {0}", MyMap.ActualHeight));
sb.AppendLine();
sb.AppendLine(string.Format("---Map Layers ({0})---", MyMap.Layers.Count));
sb.AppendLine();
foreach (Layer layer in MyMap.Layers)
{
sb.AppendLine(string.Format("ID: {0}", layer.ID));
sb.AppendLine(string.Format("Type: {0}", layer.GetType().ToString()));
sb.AppendLine(string.Format("Visibility : {0}", layer.Visible));
sb.AppendLine(string.Format("Opacity : {0}", layer.Opacity));
if (layer is ArcGISDynamicMapServiceLayer)
{
ArcGISDynamicMapServiceLayer dynLayer = layer as ArcGISDynamicMapServiceLayer;
sb.AppendLine(string.Format("\t---Layers ({0})---", dynLayer.Layers.Length));
foreach (LayerInfo layerinfo in dynLayer.Layers)
{
sb.AppendLine(string.Format("\tID: {0}", layerinfo.ID));
sb.AppendLine(string.Format("\tName: {0}", layerinfo.Name));
sb.AppendLine(string.Format("\tDefault Visibility: {0}", layerinfo.DefaultVisibility));
sb.AppendLine(string.Format("\tMinimum Scale: {0}", layerinfo.MinScale));
sb.AppendLine(string.Format("\tMaximum Scale: {0}", layerinfo.MaxScale));
if (layerinfo.SubLayerIds != null)
{
sb.AppendLine(string.Format("\tSubLayer IDs: {0}", layerinfo.SubLayerIds.ToString()));
}
sb.AppendLine();
}
}
if (layer is ArcGISTiledMapServiceLayer)
{
ArcGISTiledMapServiceLayer tiledLayer = layer as ArcGISTiledMapServiceLayer;
TileInfo ti = tiledLayer.TileInfo;
sb.AppendLine("Levels and Resolution :");
for (int i = 0; i < ti.Lods.Length; i++)
{
if (i < 10)
{
sb.Append(string.Format("Level: {0} \t \tResolution: {1}\r", i, ti.Lods[i].Resolution));
}
else
{
sb.Append(string.Format("Level: {0} \tResolution: {1}\r", i, ti.Lods[i].Resolution));
}
}
}
sb.AppendLine();
}
PropertiesTextBlock.Text = sb.ToString();
}
async void mapView1_Loaded(object sender, RoutedEventArgs e)
{
//iterate over all layers
var taskResults = new List<Task<AllLayersServiceInfo>>();
foreach (var layer in mapView1.Map.Layers)
{
if (layer is ArcGISDynamicMapServiceLayer)
taskResults.Add((layer as ArcGISDynamicMapServiceLayer).GetAllDetailsAsync());
else if (layer is ArcGISTiledMapServiceLayer)
taskResults.Add((layer as ArcGISTiledMapServiceLayer).GetAllDetailsAsync());
}
var allLayers = await Task.WhenAll(taskResults);
//show single node for tiledLayers
//show sub-layer list for Dynamic Layers
dynamicServiceLayer = mapView1.Map.Layers["DynamicLayerCalifornia"] as ArcGISDynamicMapServiceLayer;
if (dynamicServiceLayer != null)
{
await dynamicServiceLayer.InitializeAsync();
var dyn = dynamicServiceLayer.CreateDynamicLayerInfosFromLayerInfos();
dynamicServiceLayer.VisibleLayers = GetDefaultVisibleLayers(dyn);
DataContext = this;
Layers = new ObservableCollection<DynamicLayerInfo>(dyn);
var test = Layers.Select(x => new { Name = x.Name, Visibility = x.DefaultVisibility, Id = x.ID }).ToList();
}
}
/// <summary>
/// Checkes whether a sub-layer (LayerInfo) is in a measurable state
/// </summary>
/// <param name="subLayer">The sub-layer to check</param>
/// <param name="parentLayer">The map service layer containing the sub-layer</param>
/// <param name="map">The map containing the map service layer</param>
/// <returns>True if the sub-layer is measurable, false if not</returns>
internal static bool IsMeasurable(this LayerInfo subLayer, ArcGISDynamicMapServiceLayer parentLayer, Map map)
{
if (parentLayer.VisibleLayers == null)
return subLayer.DefaultVisibility && subLayer.IsInVisibleRange(map);
else
return parentLayer.VisibleLayers.Contains(subLayer.ID) && subLayer.IsInVisibleRange(map);
}
public ArcGISDynamicMapServiceLayerSample()
{
this.InitializeComponent();
mapView.LayerLoaded += mapView_LayerLoaded;
_usaLayer = mapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
}
public ArcGISDynamicMapServiceLayerSample()
{
this.InitializeComponent();
MyMapView.Map.SpatialReference = SpatialReferences.WebMercator;
_usaLayer = MyMapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
MyMapView.LayerLoaded += MyMapView_LayerLoaded;
}
public ArcGISDynamicMapServiceLayerSample()
{
this.InitializeComponent();
MyMapView.Map.SpatialReference = SpatialReferences.WebMercator;
_usaLayer = MyMapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
MyMapView.LayerLoaded += MyMapView_LayerLoaded;
}
public ArcGISDynamicMapServiceLayerSample()
{
InitializeComponent();
mapView.LayerLoaded += mapView_LayerLoaded;
_usaLayer = mapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
}
// Initializes the Layer property
private void initializeLayer()
{
Layer layer = null;
// Create the layer based on the type of service encapsulated by the search result
if (Service is MapService)
{
MapService mapService = (MapService)Service;
if (mapService.IsTiled &&
mapService.SpatialReference.WKID == MapApplication.Current.Map.SpatialReference.WKID)
{
layer = new ArcGISTiledMapServiceLayer()
{
Url = Service.Url, ProxyURL = ProxyUrl
}
}
;
else
{
layer = new ArcGISDynamicMapServiceLayer()
{
Url = Service.Url, ProxyURL = ProxyUrl
}
};
}
else if (Service is ImageService)
{
layer = new ArcGISImageServiceLayer()
{
Url = Service.Url, ProxyURL = ProxyUrl
};
}
else if (Service is FeatureLayerService || (Service is FeatureService && ((FeatureService)Service).Layers.Count() == 1))
{
string url = Service is FeatureService?string.Format("{0}/0", Service.Url) : Service.Url;
layer = new FeatureLayer()
{
Url = url,
ProxyUrl = ProxyUrl,
OutFields = new OutFields()
{
"*"
}
};
}
// Initialize the layer's ID and display name
if (layer != null)
{
string id = Guid.NewGuid().ToString("N");
string name = propertyExists("Title") ? Result.Title : id;
layer.ID = id;
MapApplication.SetLayerName(layer, name);
}
Layer = layer;
}
public DynamicLayerLabeling()
{
this.InitializeComponent();
mapView.Loaded += mapView_Loaded;
_usaLayer = mapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
_usaLayer.VisibleLayers = new ObservableCollection<int>() { 0, 1, 2 };
}
public void CloseLayer()
{
ArcGISDynamicMapServiceLayer graphicsLayer = myMap.Layers[layerId.ToString()] as ArcGISDynamicMapServiceLayer;
if (graphicsLayer != null)
{
myMap.Layers.Remove(graphicsLayer);
}
}
private void cboPlacement_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (MyMap == null)
{
return;
}
ArcGISDynamicMapServiceLayer dynamicLayer =
MyMap.Layers["PopulationDynamicLayer"] as ArcGISDynamicMapServiceLayer;
LabelPlacement placment = new LabelPlacement();
switch (cboPlacement.SelectedIndex)
{
case 0:
placment = LabelPlacement.PointLabelPlacementAboveCenter;
break;
case 1:
placment = LabelPlacement.PointLabelPlacementAboveLeft;
break;
case 2:
placment = LabelPlacement.PointLabelPlacementAboveRight;
break;
case 3:
placment = LabelPlacement.PointLabelPlacementBelowCenter;
break;
case 4:
placment = LabelPlacement.PointLabelPlacementBelowLeft;
break;
case 5:
placment = LabelPlacement.PointLabelPlacementBelowRight;
break;
case 6:
placment = LabelPlacement.PointLabelPlacementCenterCenter;
break;
case 7:
placment = LabelPlacement.PointLabelPlacementCenterLeft;
break;
case 8:
placment = LabelPlacement.PointLabelPlacementCenterRight;
break;
}
foreach (LabelClass lClass in dynamicLayer.LayerDrawingOptions[0].LabelClasses)
{
lClass.LabelPlacement = placment;
}
dynamicLayer.Refresh();
}
protected virtual void OnDownloadConfigXMLCompleted(object sender, DownloadStringCompletedEventArgs e)
{
OverviewConfig = (OverviewMapConfig)OverviewMapConfig.Deserialize(e.Result, typeof(OverviewMapConfig));
if (OverviewConfig != null)
{
this.IsOpen = OverviewConfig.OpenInitial;
this.Position = (OverviewConfig.Position == OverviewMapPosition.Undefined) ? OverviewMapPosition.LowerRight : OverviewConfig.Position;
myOverviewMap.Width = (OverviewConfig.Width > 0) ? OverviewConfig.Width : 250;
myOverviewMap.Height = (OverviewConfig.Height > 0) ? OverviewConfig.Height : 200;
myOverviewMap.MaximumExtent = OverviewConfig.MaximumExtent.ToEnvelope(this.CurrentPage.MapSRWKID);
if (OverviewConfig.MapLayer != null)
{
myOverviewMap.Layer = new ArcGISTiledMapServiceLayer()
{
ID = "Overview_Layer", Url = OverviewConfig.MapLayer.RESTURL, ProxyURL = OverviewConfig.MapLayer.ProxyURL
};
}
else if (this.MapControl.Layers[0] is ArcGISTiledMapServiceLayer)
{
ArcGISTiledMapServiceLayer agisTiledLayer = this.MapControl.Layers[0] as ArcGISTiledMapServiceLayer;
myOverviewMap.Layer = new ArcGISTiledMapServiceLayer()
{
ID = "Overview_Layer", Url = agisTiledLayer.Url, ProxyURL = agisTiledLayer.ProxyURL
};
}
else if (this.MapControl.Layers[0] is ArcGISDynamicMapServiceLayer)
{
ArcGISDynamicMapServiceLayer agisDynamicLayer = this.MapControl.Layers[0] as ArcGISDynamicMapServiceLayer;
myOverviewMap.Layer = new ArcGISDynamicMapServiceLayer()
{
ID = "Overview_Layer", Url = agisDynamicLayer.Url, ProxyURL = agisDynamicLayer.ProxyURL
};
}
else if (this.MapControl.Layers[0] is ESRI.ArcGIS.Client.Bing.TileLayer)
{
TileLayer bingTiledLayer = this.MapControl.Layers[0] as TileLayer;
myOverviewMap.Layer = new TileLayer()
{
ID = "Overview_Layer", ServerType = bingTiledLayer.ServerType, LayerStyle = bingTiledLayer.LayerStyle, Token = bingTiledLayer.Token
};
}
// Initialize Map extent here to sychronize with OverviewMap extent on the first loading
if (this.CurrentPage.InitMapExtent != null)
{
this.MapControl.ZoomTo(this.CurrentPage.InitMapExtent);
}
else if (this.CurrentPage.FullMapExtent != null)
{
this.MapControl.ZoomTo(this.CurrentPage.FullMapExtent);
}
}
}
// When map service item selected in Listbox, choose appropriate type and add to the map
void webclient_DownloadStringCompleted(object sender, ArcGISWebClient.DownloadStringCompletedEventArgs e)
{
try
{
if (e.Error != null)
{
throw new Exception(e.Error.Message);
}
// Get the service url from the user object
string svcUrl = e.UserState as string;
//only available in Silverlight or .Net 4.5
// Abstract JsonValue holds json response
// JsonValue serviceInfo = JsonObject.Parse(e.Result);
string[] jsonPairs = e.Result.Split(',');
string mapCachePair = jsonPairs.Where(json => json.Contains("singleFusedMapCache")).FirstOrDefault();
string[] mapCacheKeyAndValue = mapCachePair.Split(':');
bool isTiledMapService = Boolean.Parse(mapCacheKeyAndValue[1]);
// Use "singleFusedMapCache" to determine if a tiled or dynamic layer should be added to the map
//bool isTiledMapService = Boolean.Parse(serviceInfo["singleFusedMapCache"].ToString());
Layer lyr = null;
if (isTiledMapService)
{
lyr = new ArcGISTiledMapServiceLayer()
{
Url = svcUrl
}
}
;
else
{
lyr = new ArcGISDynamicMapServiceLayer()
{
Url = svcUrl
}
};
if (lyr != null)
{
lyr.InitializationFailed += (a, b) =>
{
throw new Exception(lyr.InitializationFailure.Message);
};
MyMap.Layers.Add(lyr);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void Refresh()
{
ArcGISDynamicMapServiceLayer layer = myMap.Layers[layerId.ToString()] as ArcGISDynamicMapServiceLayer;
if (layer != null)
{
myMap.Layers.Remove(layer);
RenderServerImage(this.url, this.visibleLayers);
}
}
public Traffic()
{
InitializeComponent();
IdentityManager.Current.OAuthAuthorizeHandler = new OAuthAuthorizeHandler();
IdentityManager.Current.ChallengeHandler = new ChallengeHandler(PortalSecurity.Challenge);
_trafficLayer = MyMapView.Map.Layers["Traffic"] as ArcGISDynamicMapServiceLayer;
MyMapView.LayerLoaded += MyMapView_LayerLoaded;
}
public Traffic()
{
InitializeComponent();
IdentityManager.Current.OAuthAuthorizeHandler = new OAuthAuthorizeHandler();
IdentityManager.Current.ChallengeHandler = new ChallengeHandler(PortalSecurity.Challenge);
_trafficLayer = MyMapView.Map.Layers["Traffic"] as ArcGISDynamicMapServiceLayer;
MyMapView.LayerLoaded += MyMapView_LayerLoaded;
}
public DynamicLayerLabeling()
{
this.InitializeComponent();
MyMapView.Map.SpatialReference = SpatialReferences.WebMercator;
MyMapView.SpatialReferenceChanged += MyMapView_SpatialReferenceChanged;
_usaLayer = MyMapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
_usaLayer.VisibleLayers = new ObservableCollection<int>() { 0, 1, 2 };
}
public Traffic()
{
InitializeComponent();
IdentityManager.Current.ChallengeMethod = PortalSecurity.Challenge;
_trafficLayer = mapView.Map.Layers["Traffic"] as ArcGISDynamicMapServiceLayer;
mapView.Map.InitialExtent = new Envelope(-13230693.582, 3941779.273, -12928937.030, 4095486.517, SpatialReferences.WebMercator);
mapView.LayerLoaded += mapView_LayerLoaded;
}
/// <summary>
/// Checkes whether a sub-layer (LayerInfo) is in a measurable state
/// </summary>
/// <param name="subLayer">The sub-layer to check</param>
/// <param name="parentLayer">The map service layer containing the sub-layer</param>
/// <param name="map">The map containing the map service layer</param>
/// <returns>True if the sub-layer is measurable, false if not</returns>
internal static bool IsMeasurable(this LayerInfo subLayer, ArcGISDynamicMapServiceLayer parentLayer, Map map)
{
if (parentLayer.VisibleLayers == null)
{
return(subLayer.DefaultVisibility && subLayer.IsInVisibleRange(map));
}
else
{
return(parentLayer.VisibleLayers.Contains(subLayer.ID) && subLayer.IsInVisibleRange(map));
}
}
public Traffic()
{
InitializeComponent();
IdentityManager.Current.ChallengeMethod = PortalSecurity.Challenge;
_trafficLayer = mapView.Map.Layers["Traffic"] as ArcGISDynamicMapServiceLayer;
mapView.Map.InitialExtent = new Envelope(-13230693.582, 3941779.273, -12928937.030, 4095486.517, SpatialReferences.WebMercator);
mapView.LayerLoaded += mapView_LayerLoaded;
}
/// <summary>Construct Generate Geodatabase sample control</summary>
public SyncGeodatabase()
{
InitializeComponent();
_syncTask = new GeodatabaseSyncTask(new Uri(BASE_URL));
_onlineBirdsLayer = MyMapView.Map.Layers.OfType <ArcGISDynamicMapServiceLayer>().First();
_graphicsOverlay = MyMapView.GraphicsOverlays["graphicsOverlay"];
_localBirdsLayer = null;
CanGenerate = true;
this.DataContext = this;
}
public DynamicLayerLabeling()
{
this.InitializeComponent();
mapView.Loaded += mapView_Loaded;
_usaLayer = mapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
_usaLayer.VisibleLayers = new ObservableCollection <int>()
{
0, 1, 2
};
}
private void OKButton_Click(object sender, RoutedEventArgs e)
{
if (this._layers.Count > 0)
{
foreach (string key in _layers.Keys)
{
ArcGISDynamicMapServiceLayer lyr = new ArcGISDynamicMapServiceLayer();
lyr.Url = key;
BoundMap.Layers.Add(lyr);
}
}
this.DialogResult = true;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
dynamicLayer = (ArcGISDynamicMapServiceLayer)MyMap.Layers[0];
LabelClassCollection lcc = getLabelClassCollection();
LayerDrawingOptionsCollection options = new LayerDrawingOptionsCollection();
options.Add(new LayerDrawingOptions() { LayerID = 0, ShowLabels = true, LabelClasses = lcc });
dynamicLayer.LayerDrawingOptions = options;
dynamicLayer.Refresh();
}
public DynamicLayerLabeling()
{
this.InitializeComponent();
MyMapView.Map.SpatialReference = SpatialReferences.WebMercator;
MyMapView.SpatialReferenceChanged += MyMapView_SpatialReferenceChanged;
_usaLayer = MyMapView.Map.Layers["USA"] as ArcGISDynamicMapServiceLayer;
_usaLayer.VisibleLayers = new ObservableCollection <int>()
{
0, 1, 2
};
}
public async void CreateLocalServiceAndDynamicLayer()
{
LocalMapService localMapService = new LocalMapService(this.MapPackage);
await localMapService.StartAsync();
ArcGISDynamicMapServiceLayer arcGISDynamicMapServiceLayer = new ArcGISDynamicMapServiceLayer()
{
ID = "Restaurants",
ServiceUri = localMapService.UrlMapService,
};
this.mapView.Map.Layers.Add(arcGISDynamicMapServiceLayer);
}
public Traffic()
{
this.InitializeComponent();
IdentityManager.Current.OAuthAuthorizeHandler = new OAuthAuthorizeHandler();
IdentityManager.Current.ChallengeHandler = new ChallengeHandler(PortalSecurity.Challenge);
_trafficLayer = MyMapView.Map.Layers["Traffic"] as ArcGISDynamicMapServiceLayer;
_trafficLayer.VisibleLayers = new ObservableCollection<int>() { 2, 3, 4, 6, 7 };
_trafficOverlay = MyMapView.Overlays.Items[0] as FrameworkElement;
MyMapView.LayerLoaded += MyMapView_LayerLoaded;
}
/// <summary>
/// Toggle the Visibilities of a Group of Layers
/// </summary>
private void MenuItemToggleGroup_Click(object sender, MenuItemClickEventArgs e)
{
if (e.ItemTag is TreeViewItem)
{
bool show = (sender == MenuItemShowAll);
TreeViewItem treeItem = e.ItemTag as TreeViewItem;
ToggleChildNodes(treeItem, show);
string mapID = "";
bool isMapNode = false;
TreeViewItem mapLayerNode = null;
if (treeItem.Tag is LivingMapLayer)
{
mapID = (treeItem.Tag as LivingMapLayer).ID;
mapLayerNode = treeItem;
isMapNode = true;
}
else if (treeItem.Tag is TOCNodeInfo)
{
mapID = (treeItem.Tag as TOCNodeInfo).MapID;
mapLayerNode = GetMapLayerNode(treeItem);
}
if (treeItem.Header is CheckBox)
{
(treeItem.Header as CheckBox).IsChecked = show;
}
else if (treeItem.Header is RadioButton)
{
(treeItem.Header as RadioButton).IsChecked = show;
}
if (mapID != "")
{
ArcGISDynamicMapServiceLayer dynamicMap = this.MapControl.Layers[mapID] as ArcGISDynamicMapServiceLayer;
int[] oldVisibles = (int[])dynamicMap.VisibleLayers.Clone();
List <int> layerIDs = new List <int>();
GetVisibleLayerIDs(mapLayerNode, layerIDs);
dynamicMap.VisibleLayers = layerIDs.ToArray();
if (isMapNode)
{
dynamicMap.Visible = show;
}
EventCenter.DispatchMapLayerVisibilityChangeEvent(this, new MapLayerVisibilityChangeEventArgs(dynamicMap, oldVisibles));
}
HideConextMenu();
}
}
/// <summary>Construct Generate Geodatabase sample control</summary>
public SyncGeodatabase()
{
InitializeComponent();
mapView.Map.InitialExtent = new Envelope(-13446093.133, 4183761.731, -13432118.570, 4190880.0245, SpatialReferences.WebMercator);
_syncTask = new GeodatabaseSyncTask(new Uri(BASE_URL));
_onlineBirdsLayer = mapView.Map.Layers.OfType <ArcGISDynamicMapServiceLayer>().First();
_graphicsLayer = mapView.Map.Layers.OfType <GraphicsLayer>().First();
_localBirdsLayer = null;
CanGenerate = true;
this.DataContext = this;
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
}
else
{
// Code runs "for real"
ConfigService config = new ConfigService();
this.myModel = config.LoadJSON();
this.SearchRelayCommand = new RelayCommand<int>(Search);
this.ZoomRelayCommand = new RelayCommand(Zoom);
// added
Messenger.Default.Register<Esri.ArcGISRuntime.Controls.MapView>(this, (mapView) =>
{
this.mapView = mapView;
this.mapView.MapGrid = new LatLonMapGrid(LatLonMapGridLabelStyle.DegreesMinutesSeconds);
this.mapView.InteractionOptions.PanOptions.IsEnabled = true;
this.mapView.InteractionOptions.PanOptions.IsDragEnabled = true;
this.mapView.InteractionOptions.PanOptions.IsFlickEnabled = true;
this.mapView.InteractionOptions.PanOptions.IsKeyboardEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsDoubleTappedEnabled = false;
this.mapView.InteractionOptions.ZoomOptions.IsMouseWheelEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsPinchEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsTwoFingerTapEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsKeyboardEnabled = true;
Uri uriBasemap = new Uri(this.BasemapUri);
ArcGISTiledMapServiceLayer basemapLayer = new ArcGISTiledMapServiceLayer(uriBasemap);
Uri uriUSA = new Uri(this.USAUri);
ArcGISDynamicMapServiceLayer dynamicMapLayer = new ArcGISDynamicMapServiceLayer(uriUSA);
this.mapView.Map.Layers.Add(basemapLayer);
this.mapView.Map.Layers.Add(dynamicMapLayer);
this.SetInitialExtent();
});
}
}
// When map service item selected in Listbox, choose appropriate type and add to the map
void webclient_DownloadStringCompleted(object sender, ArcGISWebClient.DownloadStringCompletedEventArgs e)
{
try
{
if (e.Error != null)
{
throw new Exception(e.Error.Message);
}
// Get the service url from the user object
string svcUrl = e.UserState as string;
// Abstract JsonValue holds json response
JsonValue serviceInfo = JsonObject.Parse(e.Result);
// Use "singleFusedMapCache" to determine if a tiled or dynamic layer should be added to the map
bool isTiledMapService = Boolean.Parse(serviceInfo["singleFusedMapCache"].ToString());
Layer lyr = null;
if (isTiledMapService)
{
lyr = new ArcGISTiledMapServiceLayer()
{
Url = svcUrl
}
}
;
else
{
lyr = new ArcGISDynamicMapServiceLayer()
{
Url = svcUrl
}
};
if (lyr != null)
{
lyr.InitializationFailed += (a, b) =>
{
throw new Exception(lyr.InitializationFailure.Message);
};
MyMap.Layers.Add(lyr);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
}
else
{
// Code runs "for real"
ConfigService config = new ConfigService();
this.myModel = config.LoadJSON();
this.SearchRelayCommand = new RelayCommand <int>(Search);
this.ZoomRelayCommand = new RelayCommand(Zoom);
// added
Messenger.Default.Register <Esri.ArcGISRuntime.Controls.MapView>(this, (mapView) =>
{
this.mapView = mapView;
this.mapView.MapGrid = new LatLonMapGrid(LatLonMapGridLabelStyle.DegreesMinutesSeconds);
this.mapView.InteractionOptions.PanOptions.IsEnabled = true;
this.mapView.InteractionOptions.PanOptions.IsDragEnabled = true;
this.mapView.InteractionOptions.PanOptions.IsFlickEnabled = true;
this.mapView.InteractionOptions.PanOptions.IsKeyboardEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsDoubleTappedEnabled = false;
this.mapView.InteractionOptions.ZoomOptions.IsMouseWheelEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsPinchEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsTwoFingerTapEnabled = true;
this.mapView.InteractionOptions.ZoomOptions.IsKeyboardEnabled = true;
Uri uriBasemap = new Uri(this.BasemapUri);
ArcGISTiledMapServiceLayer basemapLayer = new ArcGISTiledMapServiceLayer(uriBasemap);
Uri uriUSA = new Uri(this.USAUri);
ArcGISDynamicMapServiceLayer dynamicMapLayer = new ArcGISDynamicMapServiceLayer(uriUSA);
this.mapView.Map.Layers.Add(basemapLayer);
this.mapView.Map.Layers.Add(dynamicMapLayer);
this.SetInitialExtent();
});
}
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
ArcGISDynamicMapServiceLayer dynLayer = value as ArcGISDynamicMapServiceLayer;
if (dynLayer == null)
{
return(null);
}
List <TreeViewItem> items = new List <TreeViewItem> {
};
items.Add(new TreeViewItem()
{
});
return(items);
}
private void popupButton_Click(object sender, RoutedEventArgs e)
{
if (mapTipsConfig == null)
{
ArcGISDynamicMapServiceLayer dummyLayer = new ArcGISDynamicMapServiceLayer();
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetLayerInfos(dummyLayer, LayerInfos);
mapTipsConfig = new MapTipsConfig()
{
VerticalAlignment = VerticalAlignment.Stretch,
Layer = dummyLayer,
Style = ResourceUtility.LoadEmbeddedStyle("Themes/MapTipsConfig.Theme.xaml", "MapTipsConfigStyle"),
Margin = new Thickness(10)
};
}
MapApplication.Current.ShowWindow(Resources.Strings.ConfigurePopups, mapTipsConfig, true, null, null, WindowType.DesignTimeFloating);
}
public async void CreateLocalServiceAndDynamicLayer()
{
try
{
LocalMapService localMapService = new LocalMapService(@"..\..\..\samples-data\maps\water-distribution-network.mpk");
await localMapService.StartAsync();
ArcGISDynamicMapServiceLayer arcGISDynamicMapServiceLayer = new ArcGISDynamicMapServiceLayer()
{
ID = "arcGISDynamicMapServiceLayer",
ServiceUri = localMapService.UrlMapService,
};
MyMapView.Map.Layers.Add(arcGISDynamicMapServiceLayer);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
}
else
{
// Code runs "for real"
ConfigService config = new ConfigService();
this.myModel = config.LoadJSON();
this.SearchRelayCommand = new RelayCommand<int>(Search);
this.ZoomRelayCommand = new RelayCommand(Zoom);
//this.LayerLoadedCommand = new RelayCommand<LayerLoadedEventArgs>(e => MyMapView_LayerLoaded(e));
Messenger.Default.Register<Esri.ArcGISRuntime.Controls.SceneView>(this, (sceneView) =>
{
this.sceneView = sceneView;
Uri uriBasemap = new Uri("http://services.arcgisonline.com/arcgis/rest/services/World_Imagery/MapServer");
ArcGISTiledMapServiceLayer basemapLayer = new ArcGISTiledMapServiceLayer(uriBasemap);
Uri uriUSA = new Uri(this.USAUri);
ArcGISDynamicMapServiceLayer dynamicMapLayer = new ArcGISDynamicMapServiceLayer(uriUSA);
this.sceneView.Scene.Layers.Add(basemapLayer);
this.sceneView.Scene.Layers.Add(dynamicMapLayer);
//DrawSphere();
//DrawModel();
this.camera = this.sceneView.Camera;
});
}
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
if (IsInDesignMode)
{
// Code runs in Blend --> create design time data.
}
else
{
// Code runs "for real"
Messenger.Default.Register<Esri.ArcGISRuntime.Controls.MapView>(this, (mapView) =>
{
this.mapView = mapView;
Uri uriTopo = new Uri("http://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer");
ArcGISDynamicMapServiceLayer dynamicMapLayer = new ArcGISDynamicMapServiceLayer(uriTopo);
dynamicMapLayer.InitializeAsync();
this.mapView.Map.Layers.Add(dynamicMapLayer);
});
}
}
private void GeoprocessorTask_JobCompleted(object sender, JobInfoEventArgs e)
{
MyMap.Cursor = System.Windows.Input.Cursors.Hand;
if (e.JobInfo.JobStatus == esriJobStatus.esriJobSucceeded)
{
Geoprocessor geoprocessorTask = sender as Geoprocessor;
System.Threading.Thread.Sleep(2000);
resultLayer = geoprocessorTask.GetResultMapServiceLayer(e.JobInfo.JobId);
resultLayer.InitializationFailed += new EventHandler<EventArgs>(resultLayer_InitializationFailed);
resultLayer.DisplayName = e.JobInfo.JobId;
if (resultLayer != null)
{
_displayViewshedInfo = true;
MyMap.Layers.Add(resultLayer);
}
}
else
{
MessageBox.Show("Geoprocessor service failed");
_displayViewshedInfo = false;
}
}
// Initializes the Layer property
private void initializeLayer()
{
Layer layer = null;
// Create the layer based on the type of service encapsulated by the search result
if (Service is MapService)
{
MapService mapService = (MapService)Service;
if (mapService.IsTiled &&
mapService.SpatialReference.WKID == MapApplication.Current.Map.SpatialReference.WKID)
layer = new ArcGISTiledMapServiceLayer() { Url = Service.Url, ProxyURL = ProxyUrl };
else
layer = new ArcGISDynamicMapServiceLayer() { Url = Service.Url, ProxyURL = ProxyUrl };
}
else if (Service is ImageService)
{
layer = new ArcGISImageServiceLayer() { Url = Service.Url, ProxyURL = ProxyUrl };
}
else if (Service is FeatureLayerService || (Service is FeatureService && ((FeatureService)Service).Layers.Count() == 1))
{
string url = Service is FeatureService ? string.Format("{0}/0", Service.Url) : Service.Url;
layer = new FeatureLayer()
{
Url = url,
ProxyUrl = ProxyUrl,
OutFields = new OutFields() { "*" }
};
}
// Initialize the layer's ID and display name
if (layer != null)
{
string id = Guid.NewGuid().ToString("N");
string name = propertyExists("Title") ? Result.Title : id;
layer.ID = id;
MapApplication.SetLayerName(layer, name);
}
Layer = layer;
}
// When map service item selected in Listbox, choose appropriate type and add to the map
void webclient_DownloadStringCompleted(object sender, ArcGISWebClient.DownloadStringCompletedEventArgs e)
{
try
{
if (e.Error != null)
throw new Exception(e.Error.Message);
// Get the service url from the user object
string svcUrl = e.UserState as string;
//only available in Silverlight or .Net 4.5
// Abstract JsonValue holds json response
// JsonValue serviceInfo = JsonObject.Parse(e.Result);
string[] jsonPairs = e.Result.Split(',');
string mapCachePair = jsonPairs.Where(json => json.Contains("singleFusedMapCache")).FirstOrDefault();
string[] mapCacheKeyAndValue = mapCachePair.Split(':');
bool isTiledMapService = Boolean.Parse(mapCacheKeyAndValue[1]);
// Use "singleFusedMapCache" to determine if a tiled or dynamic layer should be added to the map
//bool isTiledMapService = Boolean.Parse(serviceInfo["singleFusedMapCache"].ToString());
Layer lyr = null;
if (isTiledMapService)
lyr = new ArcGISTiledMapServiceLayer() { Url = svcUrl };
else
lyr = new ArcGISDynamicMapServiceLayer() { Url = svcUrl };
if (lyr != null)
{
lyr.InitializationFailed += (a, b) =>
{
throw new Exception(lyr.InitializationFailure.Message);
};
MyMap.Layers.Add(lyr);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// When map service item selected in Listbox, choose appropriate type and add to the map
void webclient_DownloadStringCompleted(object sender, ArcGISWebClient.DownloadStringCompletedEventArgs e)
{
try
{
if (e.Error != null)
throw new Exception(e.Error.Message);
// Get the service url from the user object
string svcUrl = e.UserState as string;
// Abstract JsonValue holds json response
JsonValue serviceInfo = JsonObject.Parse(e.Result);
// Use "singleFusedMapCache" to determine if a tiled or dynamic layer should be added to the map
bool isTiledMapService = Boolean.Parse(serviceInfo["singleFusedMapCache"].ToString());
Layer lyr = null;
if (isTiledMapService)
lyr = new ArcGISTiledMapServiceLayer() { Url = svcUrl };
else
lyr = new ArcGISDynamicMapServiceLayer() { Url = svcUrl };
if (lyr != null)
{
lyr.InitializationFailed += (a, b) =>
{
throw new Exception(lyr.InitializationFailure.Message);
};
MyMap.Layers.Add(lyr);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>Construct Generate Geodatabase sample control</summary>
public SyncGeodatabase()
{
InitializeComponent();
_syncTask = new GeodatabaseSyncTask(new Uri(BASE_URL));
_onlineBirdsLayer = MyMapView.Map.Layers.OfType<ArcGISDynamicMapServiceLayer>().First();
_graphicsOverlay = MyMapView.GraphicsOverlays["graphicsOverlay"];
_localBirdsLayer = null;
CanGenerate = true;
this.DataContext = this;
}
private void AfterMapServiceRequest(IAsyncResult result)
{
try
{
HttpWebRequest request = result.AsyncState as HttpWebRequest;
HttpWebResponse response = request.EndGetResponse(result) as HttpWebResponse;
Stream stream = response.GetResponseStream();
StreamReader reader = new StreamReader(stream);
if (reader.ReadLine() != null)
{
Dispatcher.BeginInvoke(() =>
{
ArcGISDynamicMapServiceLayer lyr = new ArcGISDynamicMapServiceLayer();
int counter = Map.Layers.Count();
lyr.ID = "mapServiceLyr" + counter;
GraphicsLayer gridWindowLyr = Map.Layers[Map.Layers.Count - 1] as GraphicsLayer;
lyr.Url = _completeMapServiceUrl;
lyr.InitializationFailed += new EventHandler<EventArgs>(lyr_InitializationFailed);
Map.Layers.RemoveAt(Map.Layers.Count - 1);
Map.Layers.Add(lyr);
Map.Layers.Add(gridWindowLyr);
});
}
else
{
MessageBox.Show("Unable to add this Map Service.");
}
response.Close();
}
catch (Exception ex)
{
MessageBox.Show("Unable to add this Map Service. An error has occurred: " + ex.Message);
}
}
private void BuildUI()
{
if (ParamContainer == null || ParameterConfigs == null ||
ParameterConfigs.Count < 1) return;
if ((Results == null || Results.Count < 1) && (Errors == null || Errors.Count < 1))
return;
if (!inputLayerInfoAvailable())
return;
ParamContainer.Children.Clear();
ParamContainer.ColumnDefinitions.Clear();
ParamContainer.RowDefinitions.Clear();
ParamContainer.ColumnDefinitions.Add(new ColumnDefinition() { Width = GridLength.Auto });
ParamContainer.ColumnDefinitions.Add(new ColumnDefinition() );// { Width = new GridLength(0, GridUnitType.Star) });
HasSimpleResults = false;
layerParamNameIDLookup = InputLayers != null ?
new Dictionary<string, string>(InputLayers) : new Dictionary<string, string>();
int pendingGPResultImageLayers = 0;
#region Results
if (Results != null && Results.Count > 0)
{
#region GP mapserver result
MapServiceLayerParameterConfig mapServiceLayerParameterConfig = ParameterConfigs.FirstOrDefault(p => p.Type == GPParameterType.MapServiceLayer) as MapServiceLayerParameterConfig;
if (mapServiceLayerParameterConfig != null && mapServiceLayerParameterConfig.SupportsJobResource)
{
string t = "/rest/services/";
string url = string.Format("{0}/{1}/MapServer/jobs/{2}", TaskUrl.Substring(0, TaskUrl.IndexOf(t, StringComparison.OrdinalIgnoreCase) + t.Length - 1), mapServiceLayerParameterConfig.Name, JobID);
ArcGISDynamicMapServiceLayer layer = new ArcGISDynamicMapServiceLayer { Url = url, };
layer.SetValue(ESRI.ArcGIS.Mapping.Core.LayerExtensions.ExcludeSerializationProperty, true);
addToMap(mapServiceLayerParameterConfig, layer);
}
#endregion
#region display each result
foreach (ParameterConfig config in ParameterConfigs)
{
MapServiceLayerParameterConfig cfg;
if (config.Type == GPParameterType.MapServiceLayer && (cfg = config as MapServiceLayerParameterConfig) != null && !cfg.SupportsJobResource)
{
pendingGPResultImageLayers++;
Geoprocessor gp = new Geoprocessor(TaskUrl);
gp.OutputSpatialReference = Map.SpatialReference.Clone();
gp.GetResultImageLayerCompleted += (s, e) =>
{
GPResultImageLayer gpImageLayer = e.GPResultImageLayer;
setLayerProps(cfg, gpImageLayer);
Map.Layers.Add(gpImageLayer);
layerParamNameIDLookup.Add(cfg.Name, gpImageLayer.ID);
pendingGPResultImageLayers--;
if (layerParamNameIDLookup.Count > 1 && pendingGPResultImageLayers == 0)
LayerOrderer.OrderLayers(Map, LayerOrder, layerParamNameIDLookup);
};
gp.GetResultImageLayerAsync(JobID, cfg.Name);
continue;
}
GPParameter param = getParameter(config.Name);
if (param == null) continue;
string value = ParameterBase.ParameterToDisplayString(config.Type, param);
switch (config.Type)
{
case GPParameterType.Boolean:
case GPParameterType.Double:
case GPParameterType.Long:
case GPParameterType.String:
case GPParameterType.Date:
case GPParameterType.LinearUnit:
if (value == null)
value = string.Empty;
addparamUI(config.Label, value, false);
break;
case GPParameterType.FeatureLayer:
addToMap(param as GPFeatureRecordSetLayer, config);
break;
case GPParameterType.RecordSet:
if (string.IsNullOrEmpty(value) && param is GPRecordSet)
{
GPRecordSet rs = param as GPRecordSet;
if (string.IsNullOrEmpty(rs.Url) && rs.FeatureSet != null)
value = ESRI.ArcGIS.Mapping.GP.Resources.Strings.OnlyUrlOutputIsSupportedForRecordsets;
else
value = string.Empty;
addparamUI(config.Label, value, false);
}
else
addparamUI(config.Label, value, true);
break;
case GPParameterType.DataFile:
case GPParameterType.RasterData:
case GPParameterType.RasterDataLayer:
if (value == null)
value = string.Empty;
addparamUI(config.Label, value, true);
break;
}
}
#endregion
if (layerParamNameIDLookup.Count > 1 && pendingGPResultImageLayers ==0)
LayerOrderer.OrderLayers(Map, LayerOrder, layerParamNameIDLookup);
}
#endregion
#region Errors
if (Errors != null && Errors.Count > 0)
{
foreach (Exception error in Errors)
{
addparamUI(ESRI.ArcGIS.Mapping.GP.Resources.Strings.LabelError + " ", error.Message, false);
HasSimpleResults = true;
}
}
#endregion
}
private void addToMap(ParameterConfig config, ArcGISDynamicMapServiceLayer layer)
{
setLayerProps(config, layer);
Map.Layers.Add(layer);
layerParamNameIDLookup.Add(config.Name, layer.ID);
}
public override void CreateLayerAsync(Resource resource, SpatialReference mapSpatialReference, object userState)
{
if(resource == null)
return;
ESRI.ArcGIS.Client.Layer layer = null;
switch (resource.ResourceType)
{
case ResourceType.MapServer:
case ResourceType.FeatureServer:
{
string url = resource.Url;
if (resource.ResourceType == ResourceType.FeatureServer)
{
int i = url.LastIndexOf(string.Format("/{0}", ResourceType.FeatureServer.ToString()));
if (i >= 0)
{
url = url.Remove(i);
url = string.Format("{0}/{1}", url, ResourceType.MapServer.ToString());
}
}
_service = ServiceFactory.CreateService(ResourceType.MapServer, url, resource.ProxyUrl);
if (_service != null)
{
_service.ServiceDetailsDownloadFailed += (o, e) =>
{
OnCreateLayerFailed(e);
};
_service.ServiceDetailsDownloadCompleted += (o, e) =>
{
MapService mapService = o as MapService;
if (mapService.ServiceInfo == null)
{
OnCreateLayerFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionUnableToRetrieveMapServiceDetails), e.UserState));
return;
}
if (mapService.ServiceInfo.TileInfo != null && mapService.ServiceInfo.SingleFusedMapCache)
{
#region Create tiled layer
if (mapSpatialReference != null && !mapSpatialReference.Equals(mapService.ServiceInfo.SpatialReference))
{
OnCreateLayerFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionCachedMapServiceSpatialReferenceDoesNotMatch), e.UserState));
return;
}
layer = new ArcGISTiledMapServiceLayer()
{
Url = url,
ProxyURL = getCleanProxyUrl(mapService.ProxyUrl),
};
if (mapService.ServiceInfo.TileInfo.LODs != null)
{
double maxResolution = 0;
double minResolution = 0;
foreach (LODInfo lod in mapService.ServiceInfo.TileInfo.LODs)
{
if (lod.Resolution > maxResolution)
maxResolution = lod.Resolution;
if (minResolution <= 0 || minResolution > lod.Resolution)
minResolution = lod.Resolution;
}
if (maxResolution > 0 )
layer.MaximumResolution = maxResolution * 4;
if (minResolution > 0)
layer.MinimumResolution = minResolution / 4;
}
#endregion
}
else
{
#region create dynamic layer
layer = new ArcGISDynamicMapServiceLayer()
{
Url = url,
ProxyURL = getCleanProxyUrl(mapService.ProxyUrl),
};
#endregion
}
//Set layer's attached properties
if (layer != null)
{
layer.SetValue(MapApplication.LayerNameProperty, resource.DisplayName);
layer.SetValue(Core.LayerExtensions.DisplayUrlProperty, url);
if (!string.IsNullOrEmpty(resource.ProxyUrl))
Core.LayerExtensions.SetUsesProxy(layer, true);
layer.ID = Guid.NewGuid().ToString("N");
}
OnCreateLayerCompleted(new CreateLayerCompletedEventArgs() { Layer = layer, UserState = e.UserState });
};
_service.GetServiceDetails(null);
}
} break;
case ResourceType.ImageServer:
{
layer = new ArcGISImageServiceLayer()
{
Url = resource.Url,
ProxyURL = getCleanProxyUrl(resource.ProxyUrl),
ID = Guid.NewGuid().ToString("N"),
};
//Set layer's attached properties
layer.SetValue(MapApplication.LayerNameProperty, resource.DisplayName);
layer.SetValue(Core.LayerExtensions.DisplayUrlProperty, resource.Url);
if (!string.IsNullOrEmpty(resource.ProxyUrl))
Core.LayerExtensions.SetUsesProxy(layer, true);
// Need to declare handler separate from lambda expression to avoid erroneous
// "use of unassigned variable" build error
EventHandler<EventArgs> initialized = null;
// Need to populate the layer's metadata to handle initialization of image format
// and band IDs
initialized = (o, e) =>
{
layer.Initialized -= initialized;
ArcGISImageServiceLayer imageLayer = (ArcGISImageServiceLayer)layer;
if (imageLayer.Version < 10)
{
// Pre v10, band IDs must be specified explicitly. But no more than
// 3 can be used. Just take up to the first 3 by default.
List<int> bandIDs = new List<int>();
for (int i = 0; i < imageLayer.BandCount; i++)
{
bandIDs.Add(i);
if (i == 2)
break;
}
imageLayer.BandIds = bandIDs.ToArray();
// Use png format to support transparency
imageLayer.ImageFormat = ArcGISImageServiceLayer.ImageServiceImageFormat.PNG8;
}
else
{
// At v10 and later, band IDs do not need to be specified, and jpg/png
// format introduces some intelligence about which format is best
imageLayer.ImageFormat =
ArcGISImageServiceLayer.ImageServiceImageFormat.JPGPNG;
}
OnCreateLayerCompleted(new CreateLayerCompletedEventArgs() { Layer = layer, UserState = userState });
};
EventHandler<EventArgs> initFailed = null;
initFailed = (o, e) =>
{
layer.InitializationFailed -= initFailed;
OnCreateLayerCompleted(new CreateLayerCompletedEventArgs() { Layer = layer, UserState = userState });
};
layer.Initialized += initialized;
layer.InitializationFailed += initFailed;
layer.Initialize();
}
break;
case ResourceType.Layer:
case ResourceType.EditableLayer:
{
featureLayer = new Layer(resource.Url, resource.ProxyUrl);
featureLayer.GetLayerDetailsFailed += (o, e) =>
{
OnCreateLayerFailed(e);
};
featureLayer.GetLayerDetailsCompleted += (o, e) =>
{
if (e.LayerDetails == null)
{
OnCreateLayerFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionUnableToRetrieveLayerDetails), e.UserState));
return;
}
if (Utility.RasterLayer.Equals(e.LayerDetails.Type))
{
OnCreateLayerFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionRasterLayersNotSupported), e.UserState));
return;
}
else if (Utility.ImageServerLayer.Equals(e.LayerDetails.Type))
{
OnCreateLayerFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionImageServerLayersNotSupported), e.UserState));
return;
}
if (Utility.CapabilitiesSupportsQuery(e.LayerDetails.Capabilities) == false)
{
OnCreateLayerFailed(new ExceptionEventArgs(new Exception(Resources.Strings.ExceptionLayerDoesNotSupportQuery), e.UserState));
return;
}
GeometryType GeometryType = GeometryType.Unknown;
switch (e.LayerDetails.GeometryType)
{
case "esriGeometryPoint":
GeometryType = GeometryType.Point;
break;
case "esriGeometryMultipoint":
GeometryType = GeometryType.MultiPoint;
break;
case "esriGeometryPolyline":
GeometryType = GeometryType.Polyline;
break;
case "esriGeometryPolygon":
GeometryType = GeometryType.Polygon;
break;
}
FeatureLayer newFeatureLayer = new FeatureLayer()
{
Url = featureLayer.Uri,
ProxyUrl = getCleanProxyUrl(featureLayer.ProxyUrl),
ID = Guid.NewGuid().ToString("N"),
Mode = FeatureLayer.QueryMode.OnDemand,
Renderer = new ESRI.ArcGIS.Mapping.Core.Symbols.HiddenRenderer()
};
newFeatureLayer.SetValue(MapApplication.LayerNameProperty, resource.DisplayName);
newFeatureLayer.SetValue(Core.LayerExtensions.DisplayUrlProperty, resource.Url);
newFeatureLayer.SetValue(Core.LayerExtensions.GeometryTypeProperty, GeometryType);
if (!string.IsNullOrEmpty(resource.ProxyUrl))
Core.LayerExtensions.SetUsesProxy(newFeatureLayer, true);
if (e.LayerDetails.Fields != null)
{
Collection<ESRI.ArcGIS.Mapping.Core.FieldInfo> fields = FieldInfosFromFields(e.LayerDetails.Fields);
newFeatureLayer.SetValue(Core.LayerExtensions.FieldsProperty, fields);
Core.LayerExtensions.SetDisplayField(newFeatureLayer, e.LayerDetails.DisplayField);
}
newFeatureLayer.OutFields.Add("*"); // Get all fields at configuration time
OnCreateLayerCompleted(new CreateLayerCompletedEventArgs() { Layer = newFeatureLayer, UserState = e.UserState, GeometryType = GeometryType });
};
featureLayer.GetLayerDetails(userState);
} break;
default:
throw new Exception(string.Format(Resources.Strings.ExceptionCannotCreateLayerForResourceType, resource.ResourceType.ToString()));
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
layer = (map.Layers[0] as ArcGISDynamicMapServiceLayer);
DynamicLayerInfoCollection myDynamicLayerInfos = layer.DynamicLayerInfos;
if (myDynamicLayerInfos == null)
{
myDynamicLayerInfos = layer.CreateDynamicLayerInfosFromLayerInfos();
}
#region TableDataSource
DynamicLayerInfo info = new DynamicLayerInfo()
{
ID = 1,
Source = new LayerDataSource()
{
DataSource = new QueryDataSource()
{
GeometryType = ESRI.ArcGIS.Client.Tasks.GeometryType.Polyline,
OIDFields = new string[] { "OBJECTID" },
Query = "SELECT * FROM SDE.china_road where FNODE_ > 1000",
WorkspaceID = "MyDatabaseWorkspaceID"
}
}
};
#endregion
#region QueryDataSource
DynamicLayerInfo info = new DynamicLayerInfo()
{
ID = 1,
Source = new LayerDataSource()
{
DataSource = new QueryDataSource()
{
GeometryType = ESRI.ArcGIS.Client.Tasks.GeometryType.Polyline,
OIDFields = new string[] { "OBJECTID" },
Query = "SELECT * FROM SDE.china_road where FNODE_ > 1000",
WorkspaceID = "MyDatabaseWorkspaceID"
}
}
};
#endregion
#region UserDefine Simple Render Line
//LayerDrawingOptions layerDrawOptions = new LayerDrawingOptions();
//layerDrawOptions.LayerID = 1;
//layerDrawOptions.Renderer = new SimpleRenderer()
//{
// Symbol = new SimpleLineSymbol()
// {
// Color = new SolidColorBrush(Color.FromArgb((int)255, (int)0, (int)0, (int)255)),
// Width = 2
// }
//};
//layer.LayerDrawingOptions = new LayerDrawingOptionsCollection() { layerDrawOptions };
#endregion
#region UserDefine Simple Render Poly
LayerDrawingOptions layerDrawOptions = new LayerDrawingOptions();
layerDrawOptions.LayerID = 1;
layerDrawOptions.Renderer = new SimpleRenderer()
{
Symbol = new SimpleFillSymbol()
{
Fill = new SolidColorBrush(Color.FromArgb((int)255, (int)0, (int)0, (int)255)),
}
};
layer.LayerDrawingOptions =
new LayerDrawingOptionsCollection() { layerDrawOptions };
#endregion
#region JoinDataSource
DynamicLayerInfo info = new DynamicLayerInfo()
{
ID = 1,
Source = new LayerDataSource()
{
DataSource = new JoinDataSource()
{
JoinType = JoinType.LeftInnerJoin,
LeftTableSource = new LayerDataSource()
{
DataSource = new TableDataSource()
{
DataSourceName = "SDE.china_county",
WorkspaceID = "MyDatabaseWorkspaceID"
}
},
LeftTableKey = "OBJECTID",
RightTableSource = new LayerDataSource()
{
DataSource = new TableDataSource()
{
DataSourceName = "SDE.china_road",
WorkspaceID = "MyDatabaseWorkspaceID"
}
},
RightTableKey = "OBJECTID"
}
}
};
#endregion
#region RasterDataSource
//DynamicLayerInfo info = new DynamicLayerInfo()
//{
// ID = 1,
// Source = new LayerDataSource()
// {
// DataSource = new RasterDataSource()
// {
// DataSourceName = "rr1",
// WorkspaceID = "MyRasterWorkspaceID"
// }
// }
//};
#endregion
myDynamicLayerInfos.Add(info);
layer.DynamicLayerInfos = myDynamicLayerInfos;
layer.VisibleLayers = new int[] { 1 };
//layer.Refresh();
//map.ZoomTo(new Envelope(11.8435360079, 49.4443060783, 11.8568721432, 49.4528247773));
//map.ZoomTo(layer.Layers[1].e)
#region Generate Render Class Break
ClassBreaksDefinition classBreaksDefinition = new ClassBreaksDefinition()
{
ClassificationField = "FNODE_",
ClassificationMethod = ClassificationMethod.StandardDeviation,
BreakCount = 10,
StandardDeviationInterval = ESRI.ArcGIS.Client.Tasks.StandardDeviationInterval.OneQuarter
};
classBreaksDefinition.ColorRamps.Add(new ColorRamp()
{
From = Colors.Blue,
To = Colors.Red,
Algorithm = Algorithm.HSVAlgorithm
});
GenerateRendererParameters rendererParams = new GenerateRendererParameters()
{
ClassificationDefinition = classBreaksDefinition,
Source = info.Source
};
generateRendererTask.ExecuteAsync(rendererParams, rendererParams.Where);
#endregion
#region Generate Render Unique Value
UniqueValueDefinition uniqueValueDefinition = new UniqueValueDefinition()
{
Fields = new List<string>() { "FNODE_" }
};
uniqueValueDefinition.ColorRamps.Add(new ColorRamp()
{
From = Colors.Blue,
To = Colors.Red,
Algorithm = Algorithm.CIELabAlgorithm
});
GenerateRendererParameters rendererParams = new GenerateRendererParameters()
{
ClassificationDefinition = uniqueValueDefinition,
Source = info.Source
};
generateRendererTask.ExecuteAsync(rendererParams, rendererParams.Where);
#endregion
}
private void popupButton_Click(object sender, RoutedEventArgs e)
{
if (mapTipsConfig == null)
{
ArcGISDynamicMapServiceLayer dummyLayer = new ArcGISDynamicMapServiceLayer();
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetLayerInfos(dummyLayer, LayerInfos);
mapTipsConfig = new MapTipsConfig()
{
VerticalAlignment = VerticalAlignment.Stretch,
Layer = dummyLayer,
Style = ResourceUtility.LoadEmbeddedStyle("Themes/MapTipsConfig.Theme.xaml", "MapTipsConfigStyle"),
Margin = new Thickness(10)
};
}
MapApplication.Current.ShowWindow(Resources.Strings.ConfigurePopups, mapTipsConfig, true, null, null, WindowType.DesignTimeFloating);
}
public async void CreateLocalServiceAndDynamicLayer()
{
LocalMapService localMapService = new LocalMapService(this.MapPackage);
await localMapService.StartAsync();
ArcGISDynamicMapServiceLayer arcGISDynamicMapServiceLayer = new ArcGISDynamicMapServiceLayer()
{
ID = "Restaurants",
ServiceUri = localMapService.UrlMapService,
};
this.mapView.Map.Layers.Add(arcGISDynamicMapServiceLayer);
}
public void RenderServerImage(string url, int[] visibleLayers)
{
this.url = url;
ArcGISDynamicMapServiceLayer shapeLayer = myMap.Layers[layerId.ToString()] as ArcGISDynamicMapServiceLayer;
if (shapeLayer != null)
{
myMap.Layers.Remove(shapeLayer);
}
shapeLayer = new ArcGISDynamicMapServiceLayer();
shapeLayer.ID = layerId.ToString();
shapeLayer.Url = url;
if (visibleLayers != null)
{
shapeLayer.VisibleLayers = visibleLayers;
}
myMap.Layers.Add(shapeLayer);
myMap.Extent = shapeLayer.FullExtent;
}
private async Task<ArcGISDynamicMapServiceLayer> AddFileDatasetToDynamicMapServiceLayer(WorkspaceFactoryType workspaceType, string directoryPath, List<string> fileNames)
{
try
{
// Create a new WorkspaceInfo object with a unique ID.
string uniqueId = Guid.NewGuid().ToString();
WorkspaceInfo workspaceInfo = new WorkspaceInfo(uniqueId, workspaceType, "DATABASE=" + directoryPath);
// Create and initialize a new LocalMapService instance.
LocalMapService localMapService = new LocalMapService(_emptyMapPackage) { EnableDynamicLayers = true };
localMapService.DynamicWorkspaces.Add(workspaceInfo);
await localMapService.StartAsync();
// Create and initialize new ArcGISLocalDynamicMapServiceLayer over the local service.
var dynLayer = new ArcGISDynamicMapServiceLayer()
{
ID = "Workspace: " + (new DirectoryInfo(directoryPath)).Name,
ServiceUri = localMapService.UrlMapService
};
await dynLayer.InitializeAsync();
// Create a DynamicLayerInfoCollection to hold the new datasets as "dynamic layers".
DynamicLayerInfoCollection dynamicLayerInfoCollection = new DynamicLayerInfoCollection();
dynLayer.DynamicLayerInfos = dynamicLayerInfoCollection;
// Create a LayerDrawingOptionsCollection to specify the symbology for each layer.
LayerDrawingOptionCollection layerDrawingOptionsCollection = new LayerDrawingOptionCollection();
dynLayer.LayerDrawingOptions = layerDrawingOptionsCollection;
// Iterate over each of the selected files in the workspace.
int counter = 0;
foreach (string fileName in fileNames)
{
// Create a new DynamicLayerInfo (to make changes to existing map service layers use the CreateDynamicLayerInfosFromLayerInfos() method.
DynamicLayerInfo dynamicLayerInfo = new DynamicLayerInfo { ID = counter, Name = "Dataset: " + fileName };
// Create a DataSource object to represent the physical datasource implementation (table or raster) which will become the DataSource
// property of a new LayerDataSource in the map service. Other supported datasource types are JoinDataSource and QueryDataSource.
DataSource dataSource = null;
// If the workspace type is Raster create a new RasterDataSource.
if (workspaceInfo.FactoryType == WorkspaceFactoryType.Raster)
{
// Create a new RasterDataSource object
dataSource = new RasterDataSource
{
// Match the DataSourceName to the physical filename on disk (including extension).
DataSourceName = fileName,
// Provide the WorkspaceID (the unique workspace identifier created earlier). A LocalMapService may have multiple dynamic workspaces.
WorkspaceID = workspaceInfo.Id
};
}
else
{
// Else if the workspace is not Raster create a new TableDataSource
dataSource = new TableDataSource
{
// Match the DataSourceName to the physical filename on disk (excluding extension).
DataSourceName = fileName,
// Provide the WorkspaceID (the unique workspace identifier created earlier). A LocalMapService may have multiple dynamic workspaces.
WorkspaceID = workspaceInfo.Id
};
}
// Set the Source property of the DynamicLayerInfo object.
dynamicLayerInfo.Source = new LayerDataSource { DataSource = dataSource };
// Add the new DynamicLayerInfo object to the collection.
dynamicLayerInfoCollection.Add(dynamicLayerInfo);
// Create a new LayerDrawingOptions object to hold the renderer information.
var layerDrawOpt = new LayerDrawingOptions()
{
// Match up the LayerID to the ID of the layer within the service.
LayerID = counter,
};
// Use the GetDetails method which now supports dynamic data sources to determine the geometry type of the new datasource.
var featureLayerInfo = await dynLayer.GetDetailsAsync(dynamicLayerInfo.ID);
switch (featureLayerInfo.GeometryType)
{
case GeometryType.Envelope:
layerDrawOpt.Renderer = new SimpleRenderer() { Symbol = new SimpleFillSymbol() { Color = GetRandomColor(), Outline = new SimpleLineSymbol() { Color = GetRandomColor() } } };
break;
case GeometryType.MultiPoint:
layerDrawOpt.Renderer = new SimpleRenderer() { Symbol = new SimpleMarkerSymbol() { Color = GetRandomColor(), Size = 8 } };
break;
case GeometryType.Point:
layerDrawOpt.Renderer = new SimpleRenderer() { Symbol = new SimpleMarkerSymbol() { Color = GetRandomColor(), Size = 8 } };
break;
case GeometryType.Polygon:
layerDrawOpt.Renderer = new SimpleRenderer() { Symbol = new SimpleFillSymbol() { Color = GetRandomColor(), Outline = new SimpleLineSymbol() { Color = GetRandomColor() } } };
break;
case GeometryType.Polyline:
layerDrawOpt.Renderer = new SimpleRenderer() { Symbol = new SimpleLineSymbol() { Color = GetRandomColor() } };
break;
default:
break;
}
// Set the LayerDrawingOptions property on the local dynamic map service layer (the LayerID property ties this to the DynamicLayerInfo object).
layerDrawingOptionsCollection.Add(layerDrawOpt);
counter++;
}
return dynLayer;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return null;
}
}
