// perform the query
            System.Data.DataTable queryResults = lyrQuery.DoQuery();

            #endregion

            #region Convert results to graphics layer

            FeatureGraphicsLayer grLayer = null;
            if (queryResults != null)
            {
                System.Drawing.Color hiliteColor = SelectedSetColor;
                if (!RenderSelectedSet)
                    hiliteColor = System.Drawing.Color.Empty;

                grLayer =
                    ESRI.ArcGIS.ADF.Web.UI.WebControls.Converter.ToGraphicsLayer(
                    queryResults, hiliteColor, FeatureSelectionColor)
                    as FeatureGraphicsLayer;
            }
            
            if (grLayer == null)
            {
                Results = new SimpleTaskResult(
                    String.Concat(this.ID, ": No features found"), "");
                return;
            }
            #endregion

            #region Modify renderer and selected renderer

            if (grLayer != null)
            {
                FeatureSymbol symbol;

                // .Renderer present if RenderSelectedSet is true
                if (grLayer.Renderer != null)
                {
                    symbol =
                        ((ESRI.ArcGIS.ADF.Web.Display.Renderer.SimpleRenderer)grLayer.Renderer).Symbol;

                    // change polygon symbol to diagonal fill, using outline color
                    if (symbol is SimpleFillSymbol)
                    {
                        SimpleFillSymbol sfs = (SimpleFillSymbol)symbol;
                        sfs.BoundaryColor = SelectedSetColor;
                        sfs.BoundaryWidth = 2;
                        sfs.Transparency = 30;
                        sfs.FillType = PolygonFillType.FDiagonal;
                    }
                }

                symbol = ((ESRI.ArcGIS.ADF.Web.Display.Renderer.SimpleRenderer)grLayer.SelectedRenderer).Symbol;
                if (symbol is SimpleFillSymbol)
                {
                    symbol.Transparency = 0;
                    SimpleFillSymbol sfs = (SimpleFillSymbol)symbol;
                    sfs.BoundaryColor = FeatureSelectionColor;
                    sfs.BoundaryWidth = 2;
                    sfs.FillType = PolygonFillType.FDiagonal;
                    sfs.Color = FeatureSelectionColor;
                }
                
            #endregion

            #region Set Results for use by TaskResults

                GraphicsDataSet outputDataSet = new GraphicsDataSet();
                outputDataSet.DataSetName = String.Format("{0} - {1} ({2})",
                    ResultsTitle, grLayer.TableName, queryResults.Rows.Count);
                if (grLayer != null)
                    outputDataSet.Tables.Add(grLayer);

                Results = outputDataSet;
            }
            #endregion

            #region Turn off previous selections if enabled in properties

            if (HidePreviousSelections)
            {

                List<TaskResults> taskResList = Utilities.GetTaskResultsControls(
                    this.TaskResultsContainers, this.Page);
                //bool refreshTasks;
                List<string> resourcesToRefresh = new List<string>();

                // possible to have multiple TaskResults controls buddied to the task
                foreach (TaskResults taskRes in taskResList)
                {
                    //refreshTasks = false;
                    foreach (TreeViewPlusNode rNode in taskRes.Nodes)
                    {
                        if (rNode is TaskResultNode)
                        {
                            // Turn off only results from this instance of the selection task
                            if (((TaskResultNode)rNode).TaskID == this.UniqueID)
                            {
                                // Make sure the result node is actually a graphicslayer node
                                //  (No-features-found node will have a subnode, but not GraphicsLayerNode)
                                if (rNode.Nodes.Count > 0 &&
                                    rNode.Nodes[0] is GraphicsLayerNode)
                                {
                                    GraphicsLayerNode glNode = rNode.Nodes[0] as GraphicsLayerNode;
                                    // if layer is visible, turn it off
                                    if (glNode.GetVisibility(taskRes))
                                    {
                                        // must BOTH turn off checkbox AND turn off layer!
                                        glNode.Checked = false;
                                        glNode.SetVisibility(taskRes, false);

                                        // add resource to list if not already there
                                        string resourceName = glNode.GetResourceName(taskRes);
                                        if (resourcesToRefresh.IndexOf(resourceName) < 0)
                                            resourcesToRefresh.Add(resourceName);
                                    }
                                }
                            }
                        }
                    }

                    // must explicitly refresh resources if browser blends images
                    if (resourcesToRefresh.Count > 0)
                    {
                        if (mapCtrl.ImageBlendingMode == ImageBlendingMode.Browser)
                        {
                            foreach (string resourceName in resourcesToRefresh)
                                mapCtrl.RefreshResource(resourceName);

                            CallbackResults.CopyFrom(mapCtrl.CallbackResults);
                        }
                    }
                }
            }
            
            #endregion

            // Clean up query functionality
            lyrQuery.Close();
        }
        #endregion

        #region Private methods
       
        #region EnsureMapControl method
        private bool EnsureMapControl()
        {
            if (mapCtrl == null)
                mapCtrl = (ESRI.ArcGIS.ADF.Web.UI.WebControls.Map)Utilities.FindControlRecursive(Page, this.Map);
            // if Map property blank/null or not found, try to find first map in page
            if (mapCtrl == null)
            {
                List<Control> maps = Utilities.FindControls(typeof(Map), Page.Controls);
                if (maps.Count > 0)
                    mapCtrl = maps[0] as Map;
            }
            return (mapCtrl != null);
        }
        #endregion

        #region SetSelectionGeometry method
        /// <summary>
        /// Called by SelectTool, which passes in the user's tool geometry (point, rectangle, etc.).
        /// Sets up the selection on the map.
        /// </summary>
        /// <param name="selectionGeometry">Geometry for selection</param>
        protected internal void SetSelectionGeometry (ESRI.ArcGIS.ADF.Web.Geometry.Geometry selectionGeometry){
            
            EnsureMapControl();

            SelectionGeometry = selectionGeometry;
            
            // Call execute task via callback 
            //  (is there a way to do this directly that works with callback framework?)

            string layerList = String.Format("var gstLayers=document.getElementById(\"{0}\");", 
                ddlLayerList.ClientID);
            string layerValue = "var argument=\"layerId=\"+gstLayers.options[gstLayers.selectedIndex].value;";
            string taskCall = string.Format("var tmp=\"executeTask('\" + argument + \"', \\\"{0}\\\")\";",
                CallbackFunctionString);
            // Must include a delay, otherwise causes repeated client callback loop
            string timeoutCall = "window.setTimeout(tmp,200);";
            string jsString = String.Concat(layerList, layerValue, taskCall, timeoutCall);

            CallbackResult cbr = new CallbackResult(this, "javascript", new object[] { jsString });
            this.mapCtrl.CallbackResults.Add(cbr);

            ResetCursor(mapCtrl);
        }
        #endregion

        #region ResetCursor method
        private void ResetCursor(Map mapCtrl)
        {
            Object[] oa = new Object[1];

            // Issue with the map control as the context for callback: need to tell map to reset the cursor
            oa[0] = "map.divObject.style.cursor = 'pointer';";// map.cursor";

            CallbackResult cr1 = new CallbackResult(mapCtrl, "javascript", oa);
            mapCtrl.CallbackResults.Add(cr1);
        }
        #endregion

        #region ParseLayerId method
        private void ParseLayerId(string inputString, out string layerId, out string resourceName)
        {
            layerId = null; // String.Empty; 
            resourceName = null; // String.Empty;

            int dPos = inputString.IndexOf(idStringDelim);
            if (dPos > 0)
            {
                layerId = inputString.Substring(0, dPos);
                resourceName = inputString.Substring(dPos + idStringDelim.Length);
            }
        }
        #endregion

        #endregion

        #region Geometry serialization methods

        public static string SerializeGeometry(Geometry geometry)
        {
            string serGeom = String.Empty;
            StringBuilder sbGeom;

            if (geometry is Point)
            {
                Point p = (Point)geometry;
                serGeom = String.Format("{0}:{1}", p.X.ToString(), p.Y.ToString());
            }
            else if (geometry is Envelope)
            {
                Envelope env = (Envelope)geometry;
                serGeom = String.Format("{0}:{1}:{2}:{3}", env.XMin.ToString(),
                    env.YMin.ToString(), env.XMax.ToString(), env.YMax.ToString());
            }
            else if (geometry is Polyline)
            {
                Polyline pl = (Polyline)geometry;
                sbGeom = new StringBuilder();
                foreach (Path path in pl.Paths)
                    sbGeom.AppendFormat("{0}~", PointsToString(path.Points));
                sbGeom.Remove(sbGeom.Length - 1, 1);
                serGeom = sbGeom.ToString();
            }
            else if (geometry is Polygon)
            {
                Polygon poly = (Polygon)geometry;
                sbGeom = new StringBuilder();
                foreach (Ring ring in poly.Rings)
                    sbGeom.AppendFormat("{0}~", PointsToString(ring.Points));
                sbGeom.Remove(sbGeom.Length - 1, 1);
                serGeom = sbGeom.ToString();
            }

            return serGeom;
        }

        public static Geometry DeserializeGeometry(string geometryString, Type geometryType)
        {
            Geometry geom = null;
            string[] gArr;
            char[] xyDelim = new char[] { ':' };
            char ptDelim = '|';
            char pathDelim = '~';

            if (geometryType == typeof(Point))
            {
                gArr = geometryString.Split(xyDelim);
                geom = new Point(double.Parse(gArr[0]), double.Parse(gArr[1]));
            }
            else if (geometryType == typeof(Envelope))
            {
                gArr = geometryString.Split(xyDelim);
                geom = new Envelope(double.Parse(gArr[0]), double.Parse(gArr[1]),
                    double.Parse(gArr[2]), double.Parse(gArr[3]));
            }
            else if (geometryType == typeof(Polyline))
            {
                gArr = geometryString.Split(pathDelim);
                Polyline pLine = new Polyline();
                foreach (string pathStr in gArr)
                    pLine.Paths.Add(new Path(pathStr, ptDelim, xyDelim[0]));
                geom = pLine;
            }
            else if (geometryType == typeof(Polygon))
            {
                gArr = geometryString.Split(pathDelim);
                Polygon poly = new Polygon();
                foreach (string ringStr in gArr)
                    poly.Rings.Add(new Ring(ringStr, ptDelim, xyDelim[0]));
                geom = poly;
            }

            return geom;
        }

        private static string PointsToString(PointCollection ptColl)
        {
            StringBuilder sbPts = new StringBuilder();
            foreach (Point p in ptColl)
                sbPts.AppendFormat("{0}:{1}|", p.X.ToString(), p.Y.ToString());
            // remove last |
            sbPts.Remove(sbPts.Length - 1, 1);
            return sbPts.ToString();
        }
        #endregion
    }
}