ArcGIS Add Dynamic Data
ArcGIS_AddDynamicData_CSharp\MoveLayer_ADF.aspx.cs
// Copyright 2009 ESRI
// 
// All rights reserved under the copyright laws of the United States
// and applicable international laws, treaties, and conventions.
// 
// You may freely redistribute and use this sample code, with or
// without modification, provided you include the original copyright
// notice and use restrictions.
// 
// See the use restrictions.
// 

// Illustrates how the move an existing layer in a pooled ArcGIS Server map service
public partial class MoveLayer_ADF : System.Web.UI.Page, System.Web.UI.ICallbackEventHandler
{
    #region Instance Variable Declarations

    public string m_adfCallbackFunctionString;
    private ESRI.ArcGIS.ADF.Web.UI.WebControls.CallbackResultCollection m_callbackResultCollection = 
        new ESRI.ArcGIS.ADF.Web.UI.WebControls.CallbackResultCollection();
    private ServerObjectStateModifier m_serverObjectStateModifier = null;

    // Specify the name of the resource containing the layer to move
    private string m_targetResourceName = "MapResourceItem0";
    // Specify the name of the layer to move
    private string m_targetLayerName = "Highways";

    #endregion

    #region ASP.NET Page Life Cycle Event Handlers

    protected void Page_PreInit(object sender, System.EventArgs e)
    {
        // Instantiate a class-level ServerObjectStateModifier to use in moving the layer
        m_serverObjectStateModifier = new ServerObjectStateModifier();
    }

    protected void Page_Load(object sender, System.EventArgs e)
    {
        try
        {
            // Define the parameters for a browser call to the WebForm_DoCallback JavaScript function
            // via the GetCallbackEventReference function.  The GetCallbackEventReference function returns 
            // the syntax for initiating a callback (i.e a call to WebForm_DoCallback) with the passed-in 
            // parameters.  Here the parameters are defined as follows:
            // this - the Page will handle the callback request
            // "message" - a JavaScript variable named "message" will contain argument-value pairs passed 
            //      to the callback server-side
            // "processCallbackResult" - name of the JavaScript function to process the callback 
            //      results from the server.  This function is the callback results handler included with 
            //      the Web ADF JavaScript Library.
            // "context" - a JavaScript variable named "context" which can be used by the client to
            //      indicate the origin of the callback
            // "postBackError" - name of the JavaScript function that will process errors returned during 
            //      callback processing.  This is the callback error handler included with the Web ADF 
            //      JavaScript Library
            // true - define whether the callback is synchronous or asynchronous.  True is asynchronous.        
            m_adfCallbackFunctionString = Page.ClientScript.GetCallbackEventReference(this, "message",
                "processCallbackResult", "context", "postBackError", true);

            // If the target layer has been moved (indicated by the session variable storing the moved layer's current index
            // being populated), then we need to move it again to the last index at which it was located so that the Web ADF 
            // components accessing the map resource are aware of the correct layer position.  
            if (Session["currentLayerIndex"] != null)
            {
                // Get the layer's target resource and call the method to move the target layer to its current index, as stored
                // in session
                ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapFunctionality agsMapFunctionality =
                    (ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapFunctionality)Map1.GetFunctionality(m_targetResourceName);
                ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal mapResourceLocal =
                    (ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal)agsMapFunctionality.Resource;

                m_serverObjectStateModifier.MoveLayer(mapResourceLocal, m_targetLayerName, (int)Session["currentLayerIndex"]);
            }

            MapResourceManager1.ResourcesDispose += new System.EventHandler(MapResourceManager1_ResourcesDispose);
        }
        catch (System.Exception exception)
        {
            // Check whether the page is loading as a result of a callback.  If not, assume that a full page postback
            // is occuring, since this page implements the callback framework (and not partial postback).
            if (Page.IsCallback)
            {
                // Get a callback result that will show an alert with information pertaining to the exception
                ESRI.ArcGIS.ADF.Web.UI.WebControls.CallbackResult errorCallbackResult =
                    Utility.GetErrorCallback(exception);
                // Get the control that initiated the postback
                System.Web.UI.Control control = Utility.GetPostBackControl(Page);

                // If the control is a Web ADF Control (i.e. WebCotnrol or CompositeControl), add the error 
                // callback to that control's callback results.  Otherwise, add the error callback to the 
                // callback results collection member variable, which will be passed to the client in 
                // GetCallbackResult.
                if (control is ESRI.ArcGIS.ADF.Web.UI.WebControls.WebControl)
                {
                    ESRI.ArcGIS.ADF.Web.UI.WebControls.WebControl adfWebControl = control as
                        ESRI.ArcGIS.ADF.Web.UI.WebControls.WebControl;
                    adfWebControl.CallbackResults.Add(errorCallbackResult);
                }
                else if (control is ESRI.ArcGIS.ADF.Web.UI.WebControls.CompositeControl)
                {
                    ESRI.ArcGIS.ADF.Web.UI.WebControls.CompositeControl adfCompositeControl = control as
                        ESRI.ArcGIS.ADF.Web.UI.WebControls.CompositeControl;
                    adfCompositeControl.CallbackResults.Add(errorCallbackResult);
                }
                else
                {
                    m_callbackResultCollection.Add(errorCallbackResult);
                }
            }
            else
            {
                // Since the page is in full postback, write the javascript alert code directly to the response
                string jsErrorAlert = string.Format("<script>{0}</script>",
                    Utility.GetJavaScriptErrorString(exception));
                Response.Write(jsErrorAlert);
            }
        }
    }

    #endregion

    #region Web ADF Control Event Handlers

    void MapResourceManager1_ResourcesDispose(object sender, System.EventArgs e)
    {
        // If the target layer has been moved (indicated by the session variable storing the layer's initial position), then we 
        // need to move it back to its original position in the map resource before the server context created as a result of 
        // the current page request is released.  Otherwise, the target layer will be in the altered position outside the scope
        // of this page request, so clients accessing the map service will see the layer in the new position
        if (Session["originalLayerIndex"] != null)
        {
            // Get the layer's target resource and call the method to move the layer back to its original position
            ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapFunctionality agsMapFunctionality =
                (ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapFunctionality)Map1.GetFunctionality(m_targetResourceName);
            ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal mapResourceLocal =
                (ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal)agsMapFunctionality.Resource;

            m_serverObjectStateModifier.MoveLayer(mapResourceLocal, m_targetLayerName, (int)Session["originalLayerIndex"]);
        }
    }

    #endregion

    #region ICallbackEventHandler Members

    // Receives the arguments packaged in the callback on the client.  We parse those arguments here and 
    // initiate server-side logic accordingly.
    public void RaiseCallbackEvent(string eventArgs)
    {
        try
        {
            // Get the resource containing the layer to be moved
            ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapFunctionality agsMapFunctionality =
                (ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapFunctionality)Map1.GetFunctionality(m_targetResourceName);
            ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal mapResourceLocal =
                (ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal)agsMapFunctionality.Resource;

            // Parse the callback string passed from the client to the server into separate
            // arguments using the Web ADF's callback parsing utility.
            System.Collections.Specialized.NameValueCollection callbackArgsCollection =
                ESRI.ArcGIS.ADF.Web.UI.WebControls.CallbackUtility.ParseStringIntoNameValueCollection(eventArgs);

            // Get the current index of the layer.  If the session variable storing the layer's original index has not
            // been populated, populate it with the current index.  This will be used to restore the layer to its
            // original position in the map service.
            int currentLayerIndex;
            if (Session["originalLayerIndex"] == null)
            {
                currentLayerIndex = GetLayerIndex(mapResourceLocal, m_targetLayerName);
                Session["originalLayerIndex"] = currentLayerIndex;
                Session["currentLayerIndex"] = currentLayerIndex;
            }
            else
                currentLayerIndex = (int)Session["currentLayerIndex"];

            // Check the callback event argument
            switch (callbackArgsCollection["EventArg"])
            {
                case "moveLayerUp":
                    // Call the method to move the layer, passing in a layer index one less than the current one, which will move the
                    // layer up one position.
                    currentLayerIndex = m_serverObjectStateModifier.MoveLayer(mapResourceLocal, m_targetLayerName, currentLayerIndex - 1);
                    if (currentLayerIndex != -1)
                    {
                        // If a non-negative layer index was returned then the layer was moved successfully.  Update the current layer
                        // index session variable and refresh the Map and Toc so they reflect the layer's new position.
                        Session["currentLayerIndex"] = currentLayerIndex;
                        RefreshMapAndToc();
                    }
                    break;
                case "moveLayerDown":
                    // Call the method to move the layer, passing in a layer index one more than the current one, which will move the
                    // layer up one position.
                    currentLayerIndex = m_serverObjectStateModifier.MoveLayer(mapResourceLocal, m_targetLayerName, currentLayerIndex + 1);
                    if (currentLayerIndex != -1)
                    {
                        // If a non-negative layer index was returned then the layer was moved successfully.  Update the current layer
                        // index session variable and refresh the Map and Toc so they reflect the layer's new position.
                        Session["currentLayerIndex"] = currentLayerIndex;
                        RefreshMapAndToc();
                    }
                    break;
            }
        }
        catch (System.Exception exception)
        {
            // Get a callback result that will alert the user of the error and add it to the callback results collection
            ESRI.ArcGIS.ADF.Web.UI.WebControls.CallbackResult errorCallbackResult =
                Utility.GetErrorCallback(exception);
            m_callbackResultCollection.Add(errorCallbackResult);
        }
    }

    // The last server-side method called before the callback returns to the browser, GetCallbackResult
    // is where the server-side result of the callback is passed back to the browser as a string for
    // processing by the client.
    public string GetCallbackResult()
    {
        return m_callbackResultCollection.ToString();
    }

    #endregion

    #region Instance Properties

    // Property allowing client-side access to the client callback function string.  This string
    // contains the necessary JavaScript syntax to initiate a callback with the parameters specified
    // in GetCallbackEventReference (in Page_Load).
    public string AdfCallbackFunctionString
    {
        get
        {
            return m_adfCallbackFunctionString;
        }
        set
        {
            m_adfCallbackFunctionString = value;
        }
    }

    #endregion

    #region Instance Methods

    // Retrieves the index of the layer indicated by the passed-in name from the passed-in resource
    private int GetLayerIndex(ESRI.ArcGIS.ADF.Web.DataSources.ArcGISServer.MapResourceLocal mapResourceLocal, string layerName)
    {
        // Get the map underlying the passed-in map resource
        ESRI.ArcGIS.Carto.IMapServerObjects mapServerObjects =
            (ESRI.ArcGIS.Carto.IMapServerObjects)mapResourceLocal.MapServer;
        ESRI.ArcGIS.Carto.IMap aoMap = mapServerObjects.get_Map(mapResourceLocal.DataFrame);

        // Get a reference to the layer with the passed-in name from the map
        ESRI.ArcGIS.Carto.IEnumLayer enumLayer = aoMap.get_Layers(null, true);
        ESRI.ArcGIS.Carto.ILayer currentLayer = null;
        int layerIndex = 0;
        while ((currentLayer = enumLayer.Next()) != null)
        {
            if (currentLayer.Name == layerName)
                break;

            layerIndex++;
        }

        return layerIndex;
    }

    // Refreshes the Map and Toc controls and populates the callback results member variable with the
    // resulting callback results 
    private void RefreshMapAndToc()
    {
        Toc1.Refresh();
        Map1.CallbackResults.CopyFrom(Toc1.CallbackResults);

        Map1.RefreshResource(m_targetResourceName);
        m_callbackResultCollection.CopyFrom(Map1.CallbackResults);
    }

    #endregion
}