ArcGIS Server Development Blog

The ArcGIS Server Development Blog has moved

Sterling — Wed, 09 May 2007 16:00:00 GMT

The ArcGIS Server Development Blog has moved to the ESRI blogs home at http://blogs.esri.com/arcgisserver. Please update your bookmarks and RSS feeds to reference the new location.

As part of the move, any current accounts you’ve created on this blog will be unavailable on the new site. Instead, you can use your ESRI Global Account if you wish to sign in to the new site. Creating an ESRI Global Account is free and available to everyone.

The blog will still be written by the ArcGIS Server development team, and you’ll be able to see all previous posts and comments. We apologize for any inconvenience caused by this move, and look forward to your continued support and readership.

Follow-up to Extending the QueryAttributes Task: Zooming to selected features

Sterling — Thu, 03 May 2007 19:15:00 GMT

From Bryan Baker, a product engineer working on the .NET SDK:

I wrote an earlier post that showed how to extend the QueryAttributes task so that all features are immediately highlighted. Several users have asked about also zooming to the selected features. I'll show that here, though keep in mind that the user can also zoom to the selected features by right-clicking on the node for the layer (Cities in the graphic at the top of the earlier post) and choosing to zoom to selected features.

It turns out that it's a little more difficult to zoom to the features than I originally thought, because the FullExtent property of the graphics layer is null for queries like this. Instead, we have to construct our own envelope around all the features by looping through them. This isn't that difficult, though of course it does require more processing.

I’ve included code below that does the zooming. This code should be added to near the bottom of the existing code in the earlier post. If for some reason you didn’t want to highlight all the features, you could omit or comment out the line in the loop that sets the selectedCol to true.

The code below first creates an envelope to use, then in the existing loop that selects each feature, it widens the envelope to surround each feature. Once it has the envelope, it gets a reference to the Map control so it can set the Map’s extent. This takes some work, since the task itself has no reference to the Map. We have to get the ID of the Map and then search the page’s control tree. Since the Map control could be nested within another control, such as in a FloatingPanel, we search for it recursively using a custom function (found at the bottom of this listing).

One more thing before we zoom the map: the task could be querying a point layer, and if only one point is found, the “envelope” around all features is a point. We can’t zoom to a point, so instead we set the envelope to a percentage of the full extent of the Map (five percent—this value is hard-coded here, and you can change it depending on tightly you want to zoom in this one-point case).

Finally, we’ve got an envelope that will work, and we set the Map to this extent, refresh the Map, and copy its CallbackResults to the task’s CallbackResults. This last step is necessary because a callback only works with one control (the task in this case), and we need to tell another control (the Map) to update its contents.

' Set up the items to hold the extent of all features

Dim geom As ESRI.ArcGIS.ADF.Web.Geometry.Geometry

Dim layerEnv As New _

ESRI.ArcGIS.ADF.Web.Geometry.Envelope( _

Double.MaxValue, Double.MaxValue, _

Double.MinValue, Double.MinValue)

' Set each feature to selected (this loop is

' at the end the code in my previous blog post)

For Each row As DataRow In graphicsLayer.Rows

row(selectedCol) = True

' Enlarge the overall envelope to

' include the current feature

geom = graphicsLayer.GeometryFromRow(row)

layerEnv.Union(geom)

' If any records found, zoom to them

If graphicsLayer.Rows.Count > 0 Then

' Get a reference to the Map - have to search the Page since

' task itself has no direct reference to the Map

' (the task's TaskResults does have the ID of the map)

Dim mapCtrl As Map = Nothing

Dim taskResultsId As String =

Me.TaskResultsContainers(0).Name

Dim taskResults As TaskResults = _

CType(FindControlRecursive( _

Me.Page, taskResultsId), TaskResults)

If Not TaskResults Is Nothing Then

mapCtrl = CType(FindControlRecursive( _

Me.Page, taskResults.Map), Map)

End If

If Not mapCtrl Is Nothing Then

' If only one point found, envelope will be a point

' -- set to a percentage of the full extent

If layerEnv.XMin = layerEnv.XMax AndAlso _

layerEnv.YMin = layerEnv.YMax AndAlso _

Not IsNothing(mapCtrl) Then

' Percentage of the full extent to use when zooming to point

Dim zoomToPointPercentage As Integer = 5

Dim NewWidth As Double = mapCtrl.GetFullExtent().Width _

* (zoomToPointPercentage / 100)

Dim NewHeight As Double = mapCtrl.GetFullExtent().Height _

* (zoomToPointPercentage / 100)

layerEnv.XMin -= NewWidth / 2

layerEnv.XMax += NewWidth / 2

layerEnv.YMin -= NewHeight / 2

layerEnv.YMax += NewHeight / 2

End If

' Now we can zoom the map to the extent of the features

mapCtrl.Extent = layerEnv

mapCtrl.Refresh()

' We have to tell the client to refresh, using CallbackResults

Me.CallbackResults.CopyFrom(mapCtrl.CallbackResults)

End If

Below is the function called in the above code. This searches the page and its child controls for the control with the given ID. Put this after the end of the Execute method (End Sub), but inside the Class (before the End Class statement).

' Finds the control in the Page's control tree

Public Function FindControlRecursive(ByVal root As _

Control, ByVal id As String) As Control

If root.ID = id Then

Return root

End If

Dim c As Control

For Each c In root.Controls

Dim t As Control = FindControlRecursive(c, id)

If Not t Is Nothing Then

Return t

End If

Return Nothing

End Function

If you add the code above to the custom task as outlined in the earlier blog post, it should automatically zoom to the extent of all features found by the task.

Customizing the Web Editor task

Sterling — Wed, 02 May 2007 17:30:00 GMT

James Goodrich, a developer on the .NET Web ADF team, contributed this information about some Service Pack 2 enhancements to the Editor task:

When the Editor task was released at version 9.2 of the Web ADF for the .NET Framework, a common question was "How can I customize the Editor task?". Service Pack 2 provides an answer to this question. You can now customize the Editor task with custom tools and Editor Panels and we have added more events that allow you to hook into the Editor task.

In addition to these new customization options for developers, the Editor task has another key change at Service Pack 2 which it allows it to be configured with a pooled map service. You can edit non-versioned data using a pooled map service.

See the Editor Task control discussion in the Developer Help for samples and instructions.

How to track pending tiles and display a busy indicator in a Web mapping application

Sterling — Tue, 01 May 2007 19:05:00 GMT

Rex Hansen contributed this post about how to use some of the enhanced JavaScript in Service Pack 2 to track pending tiles and display a busy indicator (such as an animated "Loading" graphic) over the Web ADF's Map control:

As a Web ADF developer working in an asynchronous communication environment, it is often beneficial to provide an end user with some indication that a user action is being processed. Since most Web ADF applications are centered on working with a map, the ability of an end user to effectively interact with map contents is essential. The Web ADF has the ability to asynchronously retrieve map data from multiple sources and consolidate it in a single map control. In general, data sources often differ in the time it takes to respond to a request. Since the Web ADF Map control is capable of rendering map data as it is returned to the browser, it’s possible that some portion of data in the map is visible and accessible before another portion. In this case, it will likely be important to let the end user know when the map control has finished loading map data from any and all sources.

To support this capability, 9.2 service pack 2 includes an enhanced Web ADF JavaScript Map object. The JavaScript Map object has a set of “event handlers” on the pendingTiles property. The pendingTiles property references an array of map image tiles to be rendered. The array is updated when the map needs new image tiles based on the current extent. Events on the pendingTiles property are listed below:

Event	Description
add_onRequestsPending	Triggered when the number of items in the pendingTiles array changes from 0 to a higher value
add_onRequestsRemove	Triggered when an item is removed from the pendingTiles array
add_onRequestsCompleted	Triggered when the number of item in the pendingTiles array changes to 0

Use these handlers on the Map object’s pendingTiles property to register a JavaScript function with the event. For example:

map.pendingTiles.add_onRequestsPending(showBusyIndicator)

where map is the Map object and showBusyIndicator is a JavaScript function to call when the number of items in the pendingTiles array changes from 0 to a higher value.

The JavaScript function showBusyIndicator may appear as follows.

function showBusyIndicator(sender) {

showLayer("BusyIndicator");

if (sender!=null) {

window.status = "Pending Tiles: " + sender.pendingTiles.length;

}

The argument to the function is a reference to the JavaScript Map object. This argument can be used to gain access to map properties, such as the number of map image tiles left in the pendingTiles array. In this example, the number of pending tiles is output to the browser window’s status bar. If the argument is null, the pendingTiles array contains 0 items. The Web ADF includes two convenient JavaScript functions to show or hide a layer (div) based on its id, named showLayer and hideLayer, respectively. The functions are contained in the display_common.js file which is by default embedded with the Web ADF controls. In this example, the showLayer function is used to make the contents in the div tag with an id of “BusyIndicator” visible.

Included below is a simple Web page with a MapResourceManager, Map, and a div tag containing an image. The JavaScript Map object events are handled after the form to let the content of the form load before interacting with it.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>

<%@ Register Assembly="ESRI.ArcGIS.ADF.Web.UI.WebControls, Version=9.2.2.1350, Culture=neutral, PublicKeyToken=8fc3cc631e44ad86"

Namespace="ESRI.ArcGIS.ADF.Web.UI.WebControls" TagPrefix="esri" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<title>Untitled Page</title>

</head>

<body>

<div>

<esri:MapResourceManager ID="MapResourceManager1" runat="server">

</ResourceItems>

</esri:MapResourceManager>

<esri:Map ID="Map1" runat="server" Height="453px" Width="556px" MapResourceManager="MapResourceManager1">

</esri:Map>

</div>

</div>

</form>

function showBusyIndicator(sender) {

showLayer("BusyIndicator");

if (sender!=null) {

window.status = "Pending Tiles: " + sender.pendingTiles.length;

}

function showPendingTiles(sender) {

if (sender!=null) {

window.status = "Pending Tiles: " + sender.pendingTiles.length;

}

function hideBusyIndicator(sender) {

hideLayer("BusyIndicator");

if (sender!=null) {

window.status = "";

}

// add busy indicator functions to the map

map = Maps["Map1"];

map.pendingTiles.add_onRequestsPending(showBusyIndicator);

map.pendingTiles.add_onRequestsRemove(showPendingTiles);

map.pendingTiles.add_onRequestsCompleted(hideBusyIndicator);

</script>

</body>

</html>

Configuring your server to display a "Data not available" tile for empty map cache areas

Jeremy — Thu, 12 Apr 2007 16:00:00 GMT

Sterling Quinn of the Server team contributed this post on configuring your web server to display custom tiles in areas where you have not yet completed your map cache.

At the ESRI Developer Summit, several of you asked how we displayed a “Data not available” tile in empty areas of the ArcGIS Online services. This kind of tile can be useful if someone pans to the edge of the map or navigates to an area that you have not completed caching. Configuring your server to return a “Data not available” tile can in some cases yield a better user experience than returning nothing.

To display the tile, you need to create a custom error response on your virtual cache directory for HTTP Error 404: “Not Found”. Instead of an error message, the Web server returns the tile.

Following are steps for this process in IIS. Before you perform these steps, you should put the blank or “Data not available” tile in your cache directory. The tile you use must have the same dimensions and image format as the other tiles in the cache.

1. In IIS Manager, right-click the Virtual Directory for the specific cache and select Properties.

2. Click the Custom Errors tab, scroll down, and select the 404 error code.

3. Click the Edit button. In the URL box, specify the tile that IIS should return whenever a tile is missing. It is important to use a URL and not just a path to a file.

4. Click OK. Your dialog should look similar to the one below. Click OK again to return to IIS Manager.

You can download a sample, "Map data not yet available" tile (512 X 512 JPG) that you can use here.

Using ASP.NET AJAX with the Web ADF

Jeremy — Mon, 02 Apr 2007 14:21:00 GMT

Bryan Baker of the .NET SDK team wrote this great article on integration ASP.NET AJAX with the Web ADF.

Microsoft's new ASP.NET AJAX enables developers to refresh portions of a Web page in a relatively simple way. To enable a control to use AJAX, the developer can put the control inside an UpdatePanel. Then any events on the control are automatically handled via AJAX, and updates are passed back without refreshing the entire page. For example, a page might have two drop-down lists. The first lists types of features, such as Cities and Countries. When the user picks a value in the first drop-down, the second list is populated with new values corresponding to the first list's value, such as a list of cities.

Web ADF developers might want to use this approach to update the Map or other ADF controls. For example, when the user selects a city in the second drop-down list, the Map would zoom to the selected city. The problem is that ASP.NET AJAX was released after the 9.2 version of the Web ADF, and these new features were not available to be incorporated. Putting Web ADF controls inside an UpdatePanel will not work correctly, and is not supported. At 9.3 ESRI does plan to support Web ADF controls with ASP.NET AJAX.

You can have both Web ADF and ASP.NET AJAX controls on the page. The challenge is doing something like the example above, where controls in an UpdatePanel communicate with Web ADF controls. This post shows one approach for this. It turns out that it takes less than a dozen lines of code beyond what would have been needed had the Map been inside the UpdatePanel! You can follow along if you have installed Visual Studio 2005, the Web ADF, and the ASP.NET AJAX 1.0 extensions.

Add the controls

I first created a new website using the "ASP.NET AJAX-Enabled Web Site" template in Visual Studio. This creates a website and adds some extra items to support AJAX into both the Default.aspx page and the web.config file. You'll notice the ScriptManager control already added to the Default.aspx page, which is a non-visual control that handles the AJAX functionality. If you wanted to add ASP.NET AJAX into an existing page or website, you'd need to add these same items that the template adds in. See the ASP.NET AJAX documentation for details.

On the Default.aspx page, I added an UpdatePanel from the AJAX Extensions toolbox tab. I dragged two standard DropDownList controls into the UpdatePanel. The first DropDownList will display a list of layers. We could obtain these from the Web ADF controls on page startup, but I just added them manually for now to the Items property. I added two items: Cities and Countries. I also set the AutoPostBack property for both DropDownList controls to True. We need to do this to trigger a postback (actually a "partial postback" as ASP.NET AJAX calls it) when the user changes the selection.

Next I added a Map control and a MapResourceManager control from the ArcGIS Web Controls. Tip: having a drop-down list just above the map inteferes with the drop-down's functioning, so I put the map above the drop-down lists for this demo. I set the MapResourceManager property of the Map, and I added a resource item (map service) to the MapResourceManager as required to enable the map to display the service. In my case I used a world map with cities and countries. My simple page looks like the example here.

Update DropDownList items with ASP.NET AJAX

When the user changes the first drop-down list, the second list should display a list of cities or countries. Using ASP.NET AJAX allows us to treat this like a standard postback event. Behind the scenes, ASP.NET AJAX handles the request using AJAX methods rather than a full postback. Fortunately we don't have to deal with those details here.

I double-clicked on the DropDownList1 on the design page, which creates the method to handle the user selection in the code-behind page. We need to also fill the second DropDownList at startup, so we'll create a separate method and call it from both the drop-down's change method and the Page load method (which we can create by double-clicking on the design page). The UpdatePlaceList method fills the second DropDownList with locations and coordinates that we'll use later for zooming the map. The code below is in VB; both C# and VB versions are available in the download link at the end of this post.

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

    If Not Page.IsPostBack Then

        UpdatePlaceList()

    End If

End Sub





Protected Sub DropDownList1_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs)

    UpdatePlaceList()

End Sub



Sub UpdatePlaceList()

    DropDownList2.Items.Clear()

    If DropDownList1.SelectedValue = "Cities" Then

        DropDownList2.Items.Add(New ListItem("Cape Town", "17|-36|21|-32"))

        DropDownList2.Items.Add(New ListItem("Oslo", "9|58|13|62"))

        DropDownList2.Items.Add(New ListItem("Washington", "-79|37|-75|41"))

    ElseIf DropDownList1.SelectedValue = "Countries" Then

        DropDownList2.Items.Add(New ListItem("Australia", "112|-43|157|-10"))

        DropDownList2.Items.Add(New ListItem("Brazil", "-73|-33|-31|6"))

        DropDownList2.Items.Add(New ListItem("China", "75|16|136|55"))

    End If



End Sub

Zoom the Map when user selects a place

When the user selects a place in the second DropDownList, we need to zoom the map to the coordinates of that place. The challenge is to have the map's new extent be communicated to the client. Since the Map control cannot be in the UpdatePanel, we have to use another approach to communicate the results of the extent change to the Map.

The user selection in DropDownList2 triggers another partial postback. To set up the code for this, I double-clicked on DropDownList2 in design mode to create the method to handle the selected-index change. Inside this new method, I obtained the coordinates to zoom to from the DropDownList2.SelectedValue property. I parsed this value into an array of coordinate values, created a new envelope, and set the envelope's extent to these coordinates. I then set the Map's extent to this new envelope. This changes the map extent on the server. However, the client won't be aware of the change and won't obtain a new map unless we tell it to.

To get the client to update the map, we use a feature in ASP.NET AJAX to pass information to the client. The ScriptManager.RegisterDataItem method adds information that will be passed back and evaluated on the client.

The Map's CallbackResults will have the information required to update the map on the client. We pass this information to the client using the RegisterDataItem method. We'll see shortly how the client uses this information to update the map.

The code below obtains the callback results and registers them with the ASP.NET AJAX RegisterDataItem method. The ScriptManager1.IsInAsyncPostBack property ensures that we're doing an AJAX partial postback rather than a full page postback.

Protected Sub DropDownList2_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs)



    Dim zoomString As String = DropDownList2.SelectedValue

    Dim coordArr() As String = zoomString.Split("|")



    Dim new_extent As New ESRI.ArcGIS.ADF.Web.Geometry.Envelope

    new_extent.XMin = Double.Parse(coordArr(0))

    new_extent.YMin = Double.Parse(coordArr(1))

    new_extent.XMax = Double.Parse(coordArr(2))

    new_extent.YMax = Double.Parse(coordArr(3))

    Map1.Extent = new_extent



    If ScriptManager1.IsInAsyncPostBack Then

        Dim callbackString As String = Map1.CallbackResults.ToString()

        ScriptManager1.RegisterDataItem(Map1, callbackString)

    End If



End Sub

Handle the results on the client

The results that we just registered with ScriptManager need to be handled on the client. ASP.NET AJAX has a handler approach to process items passed back to the client. I inserted the code below into the .aspx page, at a point below the asp:ScriptManager tag. This code registers a client-side handler, the PageLoadingHandler function, that will run when the page loads. This handler obtains the items registered on the server with RegisterDataItem, and checks whether any items for the map control are present. Since our server-side code added an item for the map, the code runs the next line.

This next line calls processCallbackResult and passes it the callback results we registered on the server. The processCallbackResult function is part of the Web ADF JavaScript library, which is automatically downloaded when the page uses Web ADF controls. The processCallbackResult function applies the callback results on the client by retrieving a new map. One caveat: the objects and methods in the client-side library can change, so this method could change with future versions of the Web ADF.

<asp:ScriptManager ID="ScriptManager1" runat="server" />



<script type="text/javascript" language="javascript">



    Sys.WebForms.PageRequestManager.getInstance().add_pageLoading(PageLoadingHandler);





    function PageLoadingHandler(sender, args) {

        var dataItems = args.get_dataItems();

        if (dataItems['Map1'] != null)

            processCallbackResult(dataItems['Map1'], 'Map1');

    }



</script>

With this code in place, when the user selects an item in the places drop-down list, the server sets the map extent to that place, and the map on the client gets notified to retrieve a new map.

Tip: be careful about dragging controls around the page in Design mode when script blocks are within the page body. Doing so caused Visual Studio to remove my script block, which disabled the map update since no handler was available on the client!

Conclusion

We've seen how you can use controls in an ASP.NET AJAX UpdatePanel to control a Map in the Web ADF. Although it takes more work than if the Web ADF controls were embedded in the UpdatePanel, it is possible to do these tasks now. In our case it required less than a dozen lines of additional code compared to when the controls are all inside the UpdatePanel.

Download the code for this demo (includes C# and VB)

Try it out here.

Using custom logos in ArcGIS Explorer

Jeremy — Mon, 19 Mar 2007 17:00:00 GMT

Mark Bockenhauer of the ArcGIS Explorer team contributed the following post on how to display a custom logo in ArcGIS Explorer.

It is common with paper maps to display a logo perhaps a company logo or government seal. The same can be done on digital ArcGIS Explorer maps by leveraging the Home Server.

The Home Server is a user defined server that ArcGIS Explorer connects to when it starts up. Typically ArcGIS Explorer checks the home server to see if its version is up to date and to get the default map to display. It does this by referencing information in the ‘explorer’ folder on the server. This folder is part of the ArcGIS Server install.

Download the explorer.zip folder before continuing with this example. This folder contains example resources for all of the ArcGIS Server Home Server settings that can be applied to ArcGIS Explorer.

Once you have downloaded the file unzip it and place it in the appropriate location on your server.

Default Locations:
.NET C:\Inetpub\wwwroot\ArcGIS\Explorer
JAVA C:\Program Files\ArcGIS\java\web_output\Explorer

To display your own custom logo on ArcGIS Explorer applications that specify your server as their home server you will need to modify the following files:

explorer\config\e2config.xml
explorer\skins\example_skin_file.xml

In the e2config.xml file the <skins> section is commented out (highlighted in bold below). Un-comment this section by removing “<!- -“ prior to the section and “- ->” following the section. You will also want type in the appropriate URL for the <skinurl> tag.

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

</Permissions>

<!-- To use a server skin file, uncomment the 'skins' tags below by removing the exclamation point and hyphens.

Type your server name into the skin url. The server install contains an example skin file and resources -->

<!--<skins>

<skinfile>example_skin_file.xml</skinfile>

<skinurl>http://TYPE_IN_YOUR_SERVER_NAME_HERE/arcgis/explorer/skins/</skinurl>

</skins>-->

</E2Config>

Next we will modify the skin file referenced in the <skins> tags to display the desired logo. In the explorer\skins\example_skin_file you will see that all of the lines are commented out. You will also notice that there are two sections to the file. The tags in the upper section all control the ArcGIS Explorer color scheme. The tags in the lower section pertain to ArcGIS Explorer graphic elements. Un-comment this section.

<!--

<HUDFont type="Font">Verdana</HUDFont>

<ApplicationTitle type="Application">ExampleApplicationTitle</ApplicationTitle>

<DocumentPrefix type="Application">ExampleDocumentPrefix</DocumentPrefix>

<SplashScreenBitmap type="Application">example_splash_screen.png</SplashScreenBitmap>

<DisplayCustomLogo type="Application">example_custom_logo.png</DisplayCustomLogo>

<NorthArrowBitmap type="Application">example_north_arrow.png</NorthArrowBitmap>

-->

At this point if you start ArcGIS Explorer and specify your server as the Home Server, you will see the Example Custom Logo.

Setting the Home Server to your server.
1.    In Explorer, click File > Set Home Server
2.    Click “Connect to the Home Server located at”, then enter the URL to your server in the format http://<server name>/<instance name> (Example: http://myServer/ArcGIS)
3.    Click the Test button to test the connection, or click OK to return to Explorer.
ArcGIS Explorer will restart and apply the Home Server Settings.

To use your own logo you will want to change the .PNG referenced in the <DisplayCustomLogo> tag. Your .PNG file should be located in the skins folder with the skin file.

Notice that the example logo makes use of the <DisplayCustomLogoMaskColor> to display a rectangular logo.

Actual .PNG on the left, what is displayed on the Right.

For more information on making your server the ArcGIS Explorer Home Server see "Making your system an ArcGIS Explorer Home Server" under "Administering the Server" at: http://webhelp.esri.com/arcgisserver/9.2/dotNet/

Working with the Web ADF resources in a custom task at run-time

Jeremy — Mon, 12 Feb 2007 19:27:00 GMT

Rex Hansen of the .NET SDK team wrote this very useful post on accessing the Web ADF components at run-time.

When creating a custom task, you may often find it necessary to access Web ADF components (controls, resources, etc.) that share the same Web page with the task. How the task will be used will dictate the technique for accessing Web ADF components. There are three situations to consider:

1) Task run-time

2) Visual Studio design-time

3) Manager run-time

“Task run-time” defines the technique for working with Web ADF components in a Web application at run-time. “Visual Studio design-time” uses custom verbs on the custom task control to access to Web ADF components during task configuration in Visual Studio. “Manager run-time” defines a situation where a custom task must utilize Web ADF components when configuring the task in the Manager Web application.

This discussion and walkthrough will focus on working with Web ADF resources in a custom task at run-time (situation 1). The custom task will do the following:

Extend FloatingPanelTask
Expose a public property to buddy the task with a MapResourceManager
Use a DropDownList control to list the map resources in the MapResourceManager control
Populate the DropDownList upon initial load of the task

1) Create a custom task control that extends FloatingPanelTask. As a composite control, the custom task will contain multiple controls. Define two private member variables to store references to controls that will be used in the custom task. In this case, a Label will be used to display the MapResourceManager id and a DropDownList will display a list of map resources.

namespace TestTask_CSharp

{

public class TestTask_Demo : FloatingPanelTask

{

private Label label = null;

private DropDownList dropDownListResources = null;

2) Create a property on the custom task control to store a reference to the unique id of a MapResourceManager control. The property will be maintained in state for the duration of a user session. The property can be set declaratively in the aspx page using the MapResourceManagerID attribute (source view).

[Browsable(true)]

[DefaultValue("")]

[PersistenceMode(PersistenceMode.Attribute)]

public string MapResourceManagerID

{

get

{

object obj = StateManager.GetProperty("mapResourceManagerID");

if (obj == null) return "";

return obj as string;

}

set

{

StateManager.SetProperty("mapResourceManagerID", value);

}

3) As with other composite Web controls, override the CreateChildControls method to construct the custom task control at runtime. The Label and DropDownList are created and added to the custom task. Note the DropDownList is empty. The Controls property is inherited from the System.Web.UI.WebControls.CompositeControl class and maintains a collection of controls to be rendered at runtime.

protected override void CreateChildControls()

{

Controls.Clear();

base.CreateChildControls();

label = new Label();

label.Text = MapResourceManagerID;

label.ID = "label_mrm";

dropDownListResources = new DropDownList();

dropDownListResources.ID = "dropdownlist_resources";

Controls.Add(label);

Controls.Add(dropDownListResources);

}

4) At this time we only need to populate the DropDownList (dropDownListResources) with a list of map resources upon initial load of the custom task. Since interrogating the MapResourceManager to get a list of resources during every callback is not necessary and can be expensive, we only want it to occur during a full page postback. The PreRender step in the page lifecycle offers a good location to modify page or control content before the final rendering step, and it's only called during a full page postback. Override the OnPreRender event of the custom task control and call the UpdateResourceDropDownList() method. The method will contain the logic to update the dropDownListResources control. This logic was placed in a separate method so it can be called from other locations in the custom task code, if necessary in the future.

protected override void OnPreRender(EventArgs e)

{

base.OnPreRender(e);

UpdateResourceDropDownList();

}

5) The UpdateResourceDropDownList() method uses the MapResourceManagerID property to find a MapResourceManager control on the page and get a list of map resources. The GetMapResourcesFromMRM() method returns a collection of resources from the MapResourceManager. If the MapResourceManager has not been initialized, it will be explicitly initialized. Including code to return a collection of resources from a MapResourceManager was placed in a separate method so it can be called from other locations in the custom task that do not involve the dropDownListResources control. Once a list of resources is returned to the UpdateResourceDropDownList method, only those that are an ArcGIS Server map resource are added to the dropDownListResources control.

protected void UpdateResourceDropDownList()

{

if (!string.IsNullOrEmpty(MapResourceManagerID))

{

GISResourceCollection grcoll = GetMapResourcesFromMRM(MapResourceManagerID);

foreach (IGISResource gr in grcoll)

{

if (gr is ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceBase)

{

dropDownListResources.Items.Add(gr.Name);

}

protected GISResourceCollection GetMapResourcesFromMRM(string mrmID)

{

GISResourceCollection gisRC = new GISResourceCollection();

MapResourceManager rm = (MapResourceManager)Page.FindControl(mrmID);

if (rm == null)

return null;

if (!rm.Initialized)

rm.Initialize();

foreach (MapResourceItem mri in rm.ResourceItems)

{

gisRC.Add(mri.Resource);

}

return gisRC;

}

6) Override a set of methods associated with task implementation to complete the custom task control. Further details on these methods will be provided in future blog posts.

public override string GetCallbackResult()

{

return base.GetCallbackResult();

}

public override void ExecuteTask()

{}

public override List<GISResourceItemDependency> GetGISResourceItemDependencies()

{

List<GISResourceItemDependency> list = new List<GISResourceItemDependency>();

return list;

}

7) Build the custom task in Visual Studio and add a reference to it in a Web page. Add the custom task and a MapResourceManager control to the page. Add one or more ArcGIS Server resources to the MapResourceManager. Run the Web app and you should see a drop down list containing the name of each ArcGIS Server map resource item in the MapResourceManager. It should look similar to the following screenshot:

You can download the sample here.

Extending the QueryAttributesTask to highlight selected features

Jeremy — Mon, 12 Feb 2007 17:50:00 GMT

Bryan Baker of the .NET SDK team wrote the following great post on extending a task to modify its behavior and then adding that task to the .NET Global Assembly Cache so it can be reused across applications.

Note: Also see the follow-up to this post from May 3, 2007.

Highlighting all task results

With the Web ADF at 9.2, a website can have one or more tasks to allow users to find features or locations on the map. For example, you might add a QueryAttributesTask to the website to allow users to find cities by name, by typing the first few characters in the name.

The out-of-the-box tasks at 9.2 do not automatically highlight found features on the map. Instead, the user can highlight features by clicking individual check-boxes of features in the task results (see graphic, with two cities selected).

What if you want to have all features highlighted immediately when the task runs? There is currently no setting to enable this. But such immediate highlighting is possible through customization. Let’s look at one relatively easy approach for someone with modest programming skills. We’re looking specifically at the Web ADF for the Microsoft .NET Framework here, by the way.

We will extend a task control to modify its behavior. The object-oriented nature of .NET allows us to create a new class (a task, in this case) that inherits all of the behavior and properties of the original class. We only need to add or modify the original class where we need it to act differently from the original class (task). Some aspects of tasks may be difficult or impossible to change, but modifying the task results output is not difficult.

The approach we’ll look at can apply to any task that produces a task result in the form of a graphics layer, where users can click on feature check-boxes to highlight them on the map. This includes the SearchAttributesTask, FindAddressTask, FindPlaceTask and QueryAttributesTask. We’ll look specifically at the QueryAttributesTask in this example.

Extending an out-of-the-box task

First, I open Visual Studio 2005 and create a new project (not a new website), a Class Library project to be specific. One great thing about .NET is that even though the original class was written in C#, we can extend it in any language—we’ll use VB to show this here. We can put our new class library anywhere; it doesn’t have to go into a web folder. I’ll call my project QuerySelectTaskVB. By the way, we could also use either Visual Basic Express or Visual C# Express, but it’s more difficult to debug with a linked web application.

Visual Studio creates the project and adds a new class called Class1.vb. I right-clicked on it in the Solution Explorer and renamed it QuerySelectTaskVB. This also renames the class in the code view—nice.

We need to add some references to the project to the libraries we’ll be using. I right-click on the project in Solution Explorer, and chose Add Reference, and in the pop up dialog I select these libraries and then click OK:

ESRI.ArcGIS.ADF.Tasks
ESRI.ArcGIS.ADF.Web
ESRI.ArcGIS.ADF.Web.DataSources
ESRI.ArcGIS.ADF.Web.UI.WebControls
System.Web

To start creating our class, we add some Imports statements at the top of the class file so we can use classes without having to type the full path. We’ll also add a Namespace around our class to better identify it.

Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Data
Imports System.Web
imports System.Web.UI
Imports ESRI.ArcGIS.ADF.Tasks
Imports ESRI.ArcGIS.ADF.Web.Display.Graphics
Imports ESRI.ArcGIS.ADF.Web.UI.WebControls

Namespace QuerySelect
Public Class QuerySelectTaskVB
End Class
End Namespace

We tell the class to extend (inherit) the existing QueryAttributesTask by adding to the class declaration we’ve already created:

Public Class QuerySelectTaskVB
Inherits QueryAttributesTask
End Class

The only thing we want to change in the task is how it outputs the results to the TaskResults control. The task creates this output in the standard task method called ExecuteTask(). We want the QueryAttributesTask to create its output as usual, but we will modify the results once they’re created. So we create our own version of ExecuteTask() that overrides the original. Our version will call the base (parent) class version of the method, then modify the results that have been created. The following code goes inside the Class definition we saw above:

    Public Overrides Sub ExecuteTask()
        ' QueryAttributesTask creates its results
        MyBase.ExecuteTask()
        ' We'll modify the Results next
    End Sub

Once the parent class has run its ExecuteTask, we can modify the results. The results are stored in a task property object called Results (makes sense, eh?). If the query finds features, those get stored in Results as a standard .NET DataSet, which contains one or more DataTable objects. But if nothing was found, the Results contains a different type, a SimpleTaskResult. Also, if the map service isn’t working right, the results might have a DataSet, but the name (caption) just has an error message. Let’s make sure we have valid results:

' We'll modify the Results next
' Make sure features were found

If TypeOf Results Is DataSet Then

Dim resultsDS As DataSet = CType(Results, DataSet)
' Check for errors during query

            If resultsDS.DataSetName.IndexOf("Error") > 0 Then
                Return
            End If

' Next we can get the table of results
End If

Now we can get the table from the DataSet. With the QueryAttributesTask, only one DataTable will be in the DataSet (other tasks may have multiple tables). One more error check: after the task performs its query using the Web ADF common API, it converts the data table to a GraphicsLayer object, so that it contains rendering (symbology) information. If it had any problems making that conversion, then features can’t be selected on the map.

            ' Next we can get the table of results
            ' Get the one table in the QueryAttributesTask result
            Dim resultsTable As DataTable = resultsDS.Tables(0)

' Make sure no problems creating a GraphicsLayer from the results
If resultsTable Is Nothing OrElse Not TypeOf resultsTable Is GraphicsLayer Then

Return

End If

' Now we can modify the table results

Now we can actually set the selection for the features found! The GraphicsLayer, which extends the DataTable type, will have a Boolean-type column indicating whether the row (map feature) is selected. We can get this column, and use it when looping through the features to set all features as selected:

            ' Now we can modify the table results
            Dim graphicsLayer As GraphicsLayer = _
              CType(resultsTable, GraphicsLayer)

' Get the column that holds the selection attribute
Dim selectedCol As DataColumn = graphicsLayer.IsSelectedColumn

            ' Set each feature to selected
            For Each row As DataRow In graphicsLayer.Rows
                row(selectedCol) = True

That’s it! Now each feature will be selected in the TaskResults tree and also on the map….that is, once our task is inside a website, which we’ll show shortly.

We compile the code by choosing Build—Build Solution from the menu (no errors, of course!). This puts a compiled .dll file into the Bin directory of the project (you can see that by looking at the project folder with Windows Explorer).

Adding the task to Visual Studio

The easiest way to add the task to a website is when it’s in the Visual Studio toolbox. It can be added manually to an individual website, but requires more editing of the source of the page. Let’s get the task into Visual Studio. There’s more on this in the Developer Help for ArcGIS Server and ArcIMS, so we’ll go over this quickly.

First, in the code for the task itself, we add some information so Visual Studio sets properties for task when we drag it onto the page from the toolbox. This goes just above the class declaration:

<ToolboxData("<{0}:QuerySelectTaskVB runat=""server"" Width=""200px"" Transparency=""35""" _

+ "BackColor=""White"" TitleBarColor=""WhiteSmoke"" TitleBarSeparatorLine=""False""" _

+ "TitleBarHeight=""20px"" BorderColor=""LightSteelBlue"" BorderStyle=''Outset''' _

+ "BorderWidth=""1px"" Font-Names=""Verdana"" Font-Size=""8pt"" ForeColor=""Black"">" _

+ "</{0}: QuerySelectTaskVB >")> _

Public Class QuerySelectTaskVB

Inherits QueryAttributesTask

Next we will add the task to .NET’s Global Assembly Cache. This makes it easier to add the task to various websites. Before we can do this, we must create a strong name to sign the task. We open the .NET command prompt and type:

sn –k QuerySelectVB.snk

This creates a key file (QuerySelectVB.snk) in the folder indicated by the command prompt (probably C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0). I moved that file using Windows Explorer to the project directory where my task .vb file is located. I then added that to my project by right-clicking on the project in Visual Studio’s Solution Explorer, choosing Add-Existing Item, changing the type to All Files, and clicking on the .snk file. I used the keypair to sign the assembly by right-clicking on the project and choosing Properties. In the Properties page, I clicked the Signing tab. I checked the box Sign the assembly and clicked my .snk file in the drop-down list. Finally, I recompiled the code (Build-Build Solution).

Now we can add the task to the Global Assembly Cache. Here’s the easy way: I opened two Windows Explorer windows, one to my project folder’s bin directory where the .dll is located, the other to C:\Windows\Assembly. I dragged the QuerySelectTaskVB.dll into the C:\Windows\Assembly window. This doesn’t actually move the file. It just registers the assembly so it’s available to all applications on the system.

Finally let’s add the task to Visual Studio. Open Visual Studio and then any .aspx page (you can create a website and page if necessary). Open the toolbox if necessary. Right-click where you want to add the task and click Choose Items (you can also create a new tab with New Tab). In the Choose Toolbox Items dialog, click Browse, and navigate to your DLL’s location. Highlight it and click Open. This adds the task to the list of available assemblies. Make sure its check box is checked, and click OK. This adds the task to the Visual Studio toolbox.

Now the task is available whenever you design an ASP.NET web page. Notice it has an icon—the same one as the QueryAttributesTask. It inherits this along with other properties of the parent task.

Using the custom task in a website

We can use the task in any website. I created a new website using the Web Mapping Application template. I could have added this website to the same solution as my task code if I’m using Visual Studio (useful for debugging the task), or in a new instance of Visual Studio. I could also open a website created with ArcGIS Server Manager or ArcIMS Web Manager, and add the task to it.

Once we have our web page open in Visual Studio, we can drag our new task from the toolbox into the Task Manager. Once it’s there, we can click its “smart tag” in its upper right to set the task’s properties.

Yet another great thing about extending an existing task: we get its designer tools with no coding required. We can set the Task Results container and use Edit the Query to create the query, exactly the same as with the standard QueryAttributesTask (see the Developer Help for tips on that).

The demo site for this page uses this custom task to query a water-well point layer for estimated yield. Choose a value from the drop-down list, and up to 50 features will be found. Notice that all features are immediately highlighted. Our custom task acts like the standard QueryAttributesTask, except that it highlights all features returned.

Try it out: http://serverx.esri.com/QuerySelectTaskDemo/.

Discussion

You can do other interesting things with the Results of the task. For instance, you could add a hyperlink to the task results output by adding the <a href…> tag to the DataSet’s DataSetName property, or to the DataTable.TableName. The hyperlink is displayed in the tree of the task results. You can also modify the DataTable itself, such as by hiding columns you don’t want displayed. Another example would be to display the results as a table, by creating a GridView from the DataTable and getting the HTML output from the GridView. You’d then create a new TaskResultsNode, add the output to that, and set it as the Results instead of the DataSet.

You might be tempted to customize other aspects of tasks, such as modifying the task’s user interface. Although some customizations are possible, you’ll probably find that in many cases it would be easier to author your own task from scratch. The Developer Help has a good discussion of writing tasks, and the Web ADF has a couple of samples that can help get you started.

You might have noticed that the task user interface does not have the look-and-feel of other tasks—the colors, fonts, etc. The standard tasks have properties defined in the Theme of the website, specifically in the Default.skin file. If you want the same look-and-feel of the standard tasks, you can create your own control skin by copying properties from one of the standard tasks in Default.skin.

We haven’t discussed how to make our custom task available within Manager, so that non-programmers could use your task. This is a much more complex chore than adding the task to Visual Studio. Tasks are configured in Manager using a separate class called a web configurator. The standard task’s web configurators are hard-coded to output information specifically for that task. It is not possible to easily modify them to instead output tags and properties for tasks that extend them. It would be necessary to rewrite most or all of the web configurator in order for it to properly output your task from Manager. The Developer Help has information on writing web configurators, if you are ambitious.

Download the code for this sample:

- QuerySelectTaskVB.zip (VB source code)

- QuerySelectTaskCS.zip (C# source code)

ArcGIS Server for the Microsoft .Net Framework 9.2 Service Pack 1

Jeremy — Wed, 31 Jan 2007 16:50:00 GMT

Anne Reuland of the Server Development team has contributed the following excellent detailed writeup on what is in service pack 1 for ArcGIS Server for the Microsoft .Net Framework 9.2.

There’s a very good overview of what’s new in ArcGIS Server 9.2 on the ArcGIS Server Product Documentation page. Open the Whats New In ArcGIS Desktop 9.2 document; you’ll need to enter your ESRI global account. The Table of Contents has a listing for ArcGIS Server and ArcIMS.

I’ve had several folks ask for an overview on what’s included in our Service Pack 1 release. The main purpose of the ArcGIS Server for the Microsoft .Net Framework 9.2 Service Pack 1 release was to address support issues with Internet Explorer 7. The problems we saw with ArcGIS Server 9.2 Final and Internet Explorer 7 were display problems with the map or Web Mapping Application related to certain tools and changes to the application layout. We also found formatting problems with buttons and panels in the Web Mapping Application, Manager, and several samples in our Software Developer Kit. Here is the full list of bug fixes for Internet Explorer 7 support:

NIM005055 - Samples: In IE7, HTML buttons without a defined width will span the width of the browser.
NIM005056 - Samples: In IE7, resizable divs should not define a width or height.
NIM005539 - When using the Web Mapping Application in Internet Explorer 7, clicking the FullExtent or Magnifier tool causes the page to go blank.
NIM005540 - When using the Web Mapping Application in Internet Explorer 7, docking a floating panel causes the page to go blank.
NIM005564 - When running Manager in an Internet Explorer 7 browser, the Apply button on the Preview Layers tab may be partially obscured or missing completely.
NIM005565 - When running Manager in an Internet Explorer 7 browser, the 'Preview Map Service' panel is excessively wide.
NIM005566 - When running Manager in an Internet Explorer 7 browser and configuring a task, the message informing the user that a supporting service is required does not display.
NIM005567 - When running Manager in an Internet Explorer 7 browser and editing an existing application, the Configure button on the Tasks panel is partially obscured.
NIM005569 - After digitizing a new feature with the Geoprocessing Task in Internet Explorer 7, the Help button, Submit button and selection of features will not work until clicked twice.
NIM005602 - Visual Studio 2005 SDK help system displays with incorrect style and formatting when viewed on a machine with Internet Explorer 7 installed.

Once you install Service Pack 1, newly created web applications will take advantage of these fixes for Internet Explorer 7. If you have already built applications with Manager or the Web Mapping Application template that you would like to update with these fixes, we have written a migration utility that will make these changes to your Web Mapping applications. You can download the migration utility from our support site.

We’re always looking to improve performance for the web applications and web services. Jeremy has already posted about the changes to with map cache image formats to support JGP, PNG8, and PNG32. These changes allow you to choose the image format that works best for your application’s functionality and performance needs.

Other performance improvements made at Service Pack 1 affect web service authentication and geocoding with ArcWeb Services. In the Web Mapping Application, we made improvements on how fast the map and task results are initialized. These bug fixes are:

NIM005590 - Improve Web services authentication performance.
NIM005598 - Optimize the display of task results when using ArcGIS Server Internet resources.
NIM005623 - Optimize initialization within the Map control
NIM005619 - Optimize geocoding with ArcWeb Services resources.

When using caches map services, if you have secured both your map service and the cache directories that hold your map tiles, Service Pack 1 includes a fix to allow the Web Mapping Application to access those secured tile directories without prompting the end-user of the application for a username and password. Once a username and password has been specified during creation of the Web Mapping Application, that account will be used to access the secured map service and the secured tile directories. The bug fix for this change is:

NIM005541 - Use the Identity information provided when defining a map resource to access cache directories that have been secured.

If you are using ArcWeb Services in your Web Mapping Application, you may have been affected by this bug fixed at Service Pack 1:

NIM005593 - ArcWeb services randomly return the error 'The underlying connection was closed: A connection that was expected to be kept alive was closed by the server'.

We also fixed problems with some of the query operators for the Query Attributes task at Service Pack 1. :

NIM005323 - Web applications containing a Query Task expression using either the < or <= operators will fail to build.
NIM005571 - Web applications published from Manager containing a Query Task expression using the LIKE operator do not return the correct results.
NIM005572 - Web applications containing a Query Task expression using the != operator do not return the correct results.

In the Web Mapping Application, after running a task to get a list of results, the Zoom To option for point features was not zooming in far enough. This problem was addressed at Service Pack 1 by adding a property named ZoomToPointFactor to the Task Results control to allow you to control the zooming:

NIM005594 - Add a ZoomToPointFactor property to the TaskResults control to specify the scale change when using the ZoomTo context menu option.

Also in the Web Mapping Application, fixes were made to ensure the scale bar displays in the expected location:

NIM005622 – Fix cases where the Scalebar is displayed outside the Map control on initial startup of the Web Mapping Application.

You can get the full list of issues that were addressed on the Service Pack page.

ArcGIS Server Code Challenge

Jeremy — Wed, 24 Jan 2007 18:45:00 GMT

Hey everyone. I hope to see you in Palm Springs at the 2007 ESRI Developer's Summit.

If you have not heard already, there is going to be an ArcGIS Server Code Challenge. Give it a shot and let us know if you have any questions.

Share your development creativity and expertise with the GIS developer community by submitting your original code sample to the ArcGIS Server Code Challenge! You and your peers will have an opportunity to review and vote for the top three entries based on originality, creativity, applicability, and relevance of the code sample. Entries could include a simple task or tool or an attribute or spatial query.

Read more on the ArcGIS Server Code Challenge.

Jeremy

Antialiasing with multiple cached resources

Jeremy — Fri, 19 Jan 2007 21:03:00 GMT

Combining multiple cached map services is one of the more powerful aspects of the ADF for ArcGIS Server. High performance mapping applications can be built off of multiple fused cached map services combined within the ADF. Lets build on the cached aerial photography example from the other day and add a cached dataset of a street network. In order to get the best performance when combining cached datasets in the Web ADF for the Microsoft .NET Framework you need to ensure that your cache configurations are identical (same scales, projection, tile size, etc) and that the map services share similar dataframe extents. When building a map cache you have the option of taking advantage of Antialiasing to smooth the edges of labels and lines for improved display quality). Of course you want to have smooth lines and labels! So what does antialiasing really do? Let's look at some comparisons of similar tiles with and without antialiasing.

The image on the left is without antialiasing enabled. The image to the right has been built using antialiasing. See the difference? The image with antialiasing of the 2000 Census Roadways dataset looks crisper, not as choppy. Antialiasing is designed to minimize jagged, blocky aliasing when representing higher resolution data at a lower resolution. So let's see what happens when we publish the data on top of our ortho cache...

Wait a minute...where did my roads go? Let's look at the same area without antialiasing...

That is what I get for implementing something without understanding the logic behind the process! The way we have implemented antialiasing from ArcGIS server is to generate tiles four times as large as the specified tile size so that we can average the RGB color of the four pixels that intersect the feature or label. So instead of a tiled pixel being completely black or not, it will be an average of the subpixels contained by the pixel. What does it average if it is just a line that is either black or not black? It uses the background color of the dataframe to compute the average pixel value. The background color is used as the transparent color by cache generation process and if you don't set the background color of your map the default is to set the background equal to 253,253,253 or almost white. So in my example I have ended up with gray roads (which don't show up well on a dark image) instead of what I originally designed as black roads. If I rebuild my map cache of my road dataset with a background color set to an average color within the image of the ortho tile (RGB: 129,129,116--pulled from this slick freeware tool) I end up with a tile that looks like this...

Try the application with each of the antialiasing options here: http://serverx.esri.com/antialiasingexamples/

Jeremy

Embedding globe services within other globes

Jeremy — Thu, 18 Jan 2007 16:54:00 GMT

James posted a comment regarding publishing Globe services with other embedded Globe services. This can be done, but it is not the recommended workflow. Sterling from the Server Dev team wrote up this response.

As you create 3D views using ArcGIS Explorer and ArcGlobe, you may want to use a layer from someone else’s globe service in addition to your own. For example, you might want to get your base layers from an ArcGIS Online globe service, and your thematic layers from your own globe service.

Resist the temptation to create a new globe service that embeds one or more other globe services. Your client applications will perform better and you will avoid redundancy of caches on your server if you have the clients connect to the globe services directly. The workflow below explains how you can create an easily-distributable globe that will allow clients to connect directly to all of the globe services it contains. This example uses an ArcGIS Online service, but you could substitute any globe service that you might want to embed in your own globes:

Create a new ArcGIS Explorer map (NMF) or ArcGlobe document (3DD) and add the ArcGIS Online service
Add your local data to a separate ArcGlobe document and publish it as an ArcGIS Server globe service.
Add your globe service to the ArcGIS Explorer map or ArcGlobe document that you created in Step 1.
Distribute the ArcGIS Explorer map or ArcGlobe document. Optionally, you can publish the ArcGlobe document as a PMF file so that clients with ArcReader can view the globe. Both ArcGIS Explorer and ArcReader are available as free downloads from ESRI.

ArcGIS Server Service Pack 1

Jeremy — Thu, 04 Jan 2007 00:47:00 GMT

ArcGIS Server Service Pack 1 is out and available for download. It has many fixes along with some very key enhancements. One of the biggest enhancements is the ability to create map caches in different image type formats. At 9.2 final you only had the option of creating PNG24 images for you map cache. While PNG24 images are visually appealing and work well with images with a lot of vector data they are inefficient for continuous raster images like aerial photography or satellite imagery. For example here are two tiles of orthophotography in both png (on the left) and jpeg (on the right):

The JPEG tile is 16.39kb. The PNG tile is 85.93kb. That makes the JPEG in this case 1/5 the size of the PNG. While that does not really make that much difference while you are on an internal network, it makes a big difference for web applications. It is important to note that JPEGs do not support transparency so PNG images would be ideal for map caches that need to be transparent (a roads cache on top of an ortho cache for example).

Try out a demo here: http://serverx.esri.com/dgaerialsws

This example uses 2 meter FSA NAIP color imagery and six inch black and white orthophotos courtesy of the City of Lawrence, Kansas.

Jeremy

Using the Callback control framework with a map resource

Jeremy — Mon, 18 Dec 2006 23:51:00 GMT

Let's build on the sample that Ryan put together and use the callback control framework to refresh a map control. In this case we need to send back callback results of the map control to the control being called back to (the callback button). To illustrate this lets add a map, map control, and a couple of Callback Button controls to the map design time in Microsoft's Visual Studio 2005. We want to give the user the ability to add and remove a dynamic dataset via the CallbackButtonCustomControl.

To do this we need a method that adds a dynamic resource to the MapResourceManagerInstance.

private void createAndAddResource(string resourceName, GISResourceItemDefinition definition, bool insertIntoBeginning)

{

MapResourceItem resourceItem = new MapResourceItem();

resourceItem.Definition = definition;

resourceItem.Name = resourceName;

resourceItem.DisplaySettings = new ESRI.ArcGIS.ADF.Web.DisplaySettings();

resourceItem.DisplaySettings.Visible = true;

resourceItem.DisplaySettings.Transparency = 20;

resourceItem.DisplaySettings.DisplayInTableOfContents = false;

resourceItem.DisplaySettings.ImageDescriptor.TransparentBackground = true;

resourceItem.DisplaySettings.ImageDescriptor.TransparentColor = System.Drawing.Color.FromArgb(1, 2, 3);

if (insertIntoBeginning)

{

Map1.MapResourceManagerInstance.ResourceItems.Insert(0, resourceItem);

}

else

{

Map1.MapResourceManagerInstance.ResourceItems.Add(resourceItem);

}

resourceItem.CreateResource();

Map1.InitializeFunctionalities();

}

Within the CallbackButton1_Clicked event we call the method to create and display the dynamic resource and then use the callback control framework to pass the CallbackResults from the map to the control.

string resourceName = "Dynamic Data";

GISResourceItemDefinition definition = null;

definition = new GISResourceItemDefinition();

definition.ResourceDefinition = "(default)@DGCountyAerialPhotos";

definition.DataSourceDefinition = "http://localhost/arcgis/services";

definition.DataSourceType = "ArcGIS Server Internet";

definition.DataSourceShared = true;

createAndAddResource(resourceName, definition, false);

if (Map1.ImageBlendingMode == ImageBlendingMode.WebTier)

{

Map1.Refresh();

}

else

{

Map1.RefreshResource(resourceName);

}

CallbackButton1.CallbackResults.CopyFrom(Map1.CallbackResults);

So now we can add dynamic data to a map on a callback.

Try the sample app out here: http://serverx.esri.com/callbackbuttonsample/map.aspx

Jeremy