public override void Execute(object parameter)
        {
            FeatureLayer fl = Layer as FeatureLayer;

            if (fl != null)
            {
                navigateToUrl(Utility.CreateUriWithProxy(fl.ProxyUrl, fl.Url));
                return;
            }

            ArcGISDynamicMapServiceLayer dynLayer = Layer as ArcGISDynamicMapServiceLayer;

            if (dynLayer != null)
            {
                navigateToUrl(Utility.CreateUriWithProxy(dynLayer.ProxyURL, dynLayer.Url));
                return;
            }

            ArcGISImageServiceLayer imageLayer = Layer as ArcGISImageServiceLayer;

            if (imageLayer != null)
            {
                navigateToUrl(Utility.CreateUriWithProxy(imageLayer.ProxyURL, imageLayer.Url));
                return;
            }

            ArcGISTiledMapServiceLayer tiledLayer = Layer as ArcGISTiledMapServiceLayer;

            if (tiledLayer != null)
            {
                navigateToUrl(Utility.CreateUriWithProxy(tiledLayer.ProxyURL, tiledLayer.Url));
                return;
            }

            GeoRssLayer geoRssLayer = Layer as GeoRssLayer;

            if (geoRssLayer != null)
            {
                if (geoRssLayer.Source != null)
                {
                    navigateToUrl(geoRssLayer.Source.AbsoluteUri);
                }
                return;
            }

            WmsLayer wmsLayer = Layer as WmsLayer;

            if (wmsLayer != null)
            {
                string url = wmsLayer.Url;
                if (!string.IsNullOrEmpty(url))
                {
                    if (!url.Contains("?"))
                    {
                        url += "?";
                    }
                    else
                    {
                        url += "&";
                    }
                    if (url.IndexOf("request=GetCapabilities", StringComparison.OrdinalIgnoreCase) < 0)
                    {
                        url += "request=GetCapabilities";
                    }
                    if (!string.IsNullOrEmpty(wmsLayer.Version) && url.IndexOf("version=", StringComparison.OrdinalIgnoreCase) < 0)
                    {
                        url += "&version=" + wmsLayer.Version;
                    }
                    navigateToUrl(Utility.CreateUriWithProxy(wmsLayer.ProxyUrl, url));
                }
                return;
            }

            OpenStreetMapLayer osmLayer = Layer as OpenStreetMapLayer;

            if (osmLayer != null)
            {
                navigateToUrl("http://www.openstreetmap.org");
                return;
            }

            ESRI.ArcGIS.Client.Bing.TileLayer bingLayer = Layer as ESRI.ArcGIS.Client.Bing.TileLayer;
            if (bingLayer != null)
            {
                navigateToUrl("http://www.bing.com/maps/");
                return;
            }

            ICustomGraphicsLayer customGraphicsLayer = Layer as ICustomGraphicsLayer;

            if (customGraphicsLayer != null && customGraphicsLayer.SupportsNavigateToServiceDetailsUrl())
            {
                Uri uri = customGraphicsLayer.GetServiceDetailsUrl();
                if (uri != null)
                {
                    navigateToUrl(uri.AbsoluteUri);
                }
                return;
            }
        }
Exemplo n.º 2
0
 /// <summary>
 /// Determines the map units for the map
 /// </summary>
 /// <param name="map">The map to find map units for</param>
 /// <param name="callback">The method to invoke once map units have been retrieved</param>
 /// <param name="failedCallback">The method to invoke when map unit retrieval fails</param>
 public static void GetMapUnitsAsync(this Map Map, Action <MapUnit> callback,
                                     Action <object, ExceptionEventArgs> failedCallback = null)
 {
     if (Map != null)
     {
         Layer layer = Map.Layers.FirstOrDefault();
         if (layer != null)
         {
             ESRI.ArcGIS.Client.Bing.TileLayer tiledLayer = layer as ESRI.ArcGIS.Client.Bing.TileLayer;
             if (tiledLayer != null)
             {
                 // Bing is web mercator
                 callback(Core.DataSources.MapUnit.Meters);
             }
             else
             {
                 ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer osmLayer = layer as ESRI.ArcGIS.Client.Toolkit.DataSources.OpenStreetMapLayer;
                 if (osmLayer != null)
                 {
                     // Open Streem map is web mercator
                     callback(Core.DataSources.MapUnit.Meters);
                 }
                 else
                 {
                     // ArcGIS Server Base Map
                     string layerUrl = null;
                     ArcGISTiledMapServiceLayer agsTiledlayer = layer as ArcGISTiledMapServiceLayer;
                     if (agsTiledlayer != null)
                     {
                         layerUrl = agsTiledlayer.Url;
                     }
                     else
                     {
                         ArcGISDynamicMapServiceLayer agsDynamicLayer = layer as ArcGISDynamicMapServiceLayer;
                         if (agsDynamicLayer != null)
                         {
                             layerUrl = agsDynamicLayer.Url;
                         }
                         else
                         {
                             ArcGISImageServiceLayer agsImageLayer = layer as ArcGISImageServiceLayer;
                             if (agsImageLayer != null)
                             {
                                 layerUrl = agsImageLayer.Url;
                             }
                         }
                     }
                     if (!string.IsNullOrWhiteSpace(layerUrl))
                     {
                         DataSourceProvider agsDataSource = new DataSourceProvider();
                         IBaseMapDataSource dataSource    = agsDataSource.CreateDataSourceForBaseMapType(BaseMapType.ArcGISServer) as IBaseMapDataSource;
                         dataSource.GetMapServiceMetaDataCompleted += (o, args) =>
                         {
                             callback(args.MapUnit);
                         };
                         dataSource.GetMapServiceMetaDataFailed += (o, args) =>
                         {
                             if (failedCallback != null)
                             {
                                 failedCallback(Map, args);
                             }
                         };
                         dataSource.GetMapServiceMetaDataAsync(layerUrl, null);
                         return;
                     }
                 }
             }
         }
     }
 }