eSearchWidget.mxml

<?xml version="1.0" encoding="utf-8"?>
<!--
	////////////////////////////////////////////////////////////////////////////////
	//
	// Copyright © 2010 ESRI
	//
	// All rights reserved under the copyright laws of the United States.
	// You may freely redistribute and use this software, with or
	// without modification, provided you include the original copyright
	// and use restrictions.  See use restrictions in the file:
	// <install location>/FlexViewer/License.txt
	//
	////////////////////////////////////////////////////////////////////////////////
-->

<!-- 
	See ReadMe.txt for Version updates and bug fixes
--> 
<viewer:BaseWidget xmlns:esri			="http://www.esri.com/2008/ags"
				   xmlns:fx				="http://ns.adobe.com/mxml/2009"
				   xmlns:s				="library://ns.adobe.com/flex/spark"
				   xmlns:mx				="library://ns.adobe.com/flex/mx"
				   xmlns:mxeffects     	="com.adobe.ac.mxeffects.*"
				   xmlns:viewer        	="com.esri.viewer.*"
				   xmlns:Search       	="widgets.eSearch.*"
				   xmlns:supportClasses ="com.esri.ags.tasks.supportClasses.*"
				   currentState			="textInput"
				   widgetConfigLoaded	="init()">
	
	<viewer:states>
		<s:State name="graphicalInput"/>
		<s:State name="textInput"/>
		<s:State name="spatialInput" />
		<s:State name="resultsList"/>
	</viewer:states>
	
	<viewer:transitions>
		<s:Transition autoReverse="true" toState="*">
			<s:Fade targets="{[graphicalInput, textInput, spatialInput, resultsList]}"/>
		</s:Transition>
	</viewer:transitions>
	
	<fx:Declarations>
		<s:GlowFilter id="glowFilter"
					  alpha="1"
					  color="{getStyle('focusColor')}"
					  inner="true"
					  strength="2"/>
		<esri:GeometryService id="geometryService"
							  fault="geometryService_faultHandler(event)"
							  url="http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"/>
		<s:ColorMatrixFilter id="cOver" matrix="[0.5,0.5,0.5,0,0,0.5,0.5,0.5,0,0,0.5,0.5,0.5,0,0,0,0,0,0.6,0]"/>
		<supportClasses:RelationshipQuery id="relatesQuery" outFields="[*]"/>
		<s:Animate id="anim" duration="500">
			<s:motionPaths>
				<s:SimpleMotionPath id="pth" property="verticalScrollPosition" />
			</s:motionPaths>
		</s:Animate>
		<s:Sequence id="showGraPops">
			<s:SetAction target="{graphicPopUp}" property="displayPopUp" value="true"/>
			<s:Scale target="{graphicPopUp.popUp}" 
					 scaleXFrom=".0001"
					 scaleYFrom=".0001"
					 scaleXTo="1"
					 scaleYTo="1"
					 duration="200"/>
		</s:Sequence>
		<s:Sequence id="hideGraPops">
			<s:Scale target="{graphicPopUp.popUp}" 
					 scaleXFrom="1"
					 scaleYFrom="1"
					 scaleXTo=".0001" 
					 scaleYTo=".0001"
					 duration="250"/>
			<s:SetAction target="{graphicPopUp}" property="displayPopUp" value="false"/>
		</s:Sequence>
		
		<s:Sequence id="showGraPops2">
			<s:SetAction target="{graphicPopUp2}" property="displayPopUp" value="true"/>
			<s:Scale target="{graphicPopUp2.popUp}" 
					 scaleXFrom=".0001"
					 scaleYFrom=".0001"
					 scaleXTo="1"
					 scaleYTo="1"
					 duration="200"/>
		</s:Sequence>
		<s:Sequence id="hideGraPops2">
			<s:Scale target="{graphicPopUp2.popUp}" 
					 scaleXFrom="1"
					 scaleYFrom="1"
					 scaleXTo=".0001" 
					 scaleYTo=".0001"
					 duration="250"/>
			<s:SetAction target="{graphicPopUp2}" property="displayPopUp" value="false"/>
		</s:Sequence>
		
	</fx:Declarations>
	
	<fx:Script>
		<![CDATA[
			import com.esri.ags.FeatureSet;
			import com.esri.ags.Graphic;
			import com.esri.ags.Map;
			import com.esri.ags.SpatialReference;
			import com.esri.ags.events.DrawEvent;
			import com.esri.ags.events.ExtentEvent;
			import com.esri.ags.events.GeometryServiceEvent;
			import com.esri.ags.events.GraphicEvent;
			import com.esri.ags.events.GraphicsLayerEvent;
			import com.esri.ags.events.LayerEvent;
			import com.esri.ags.events.MapEvent;
			import com.esri.ags.geometry.Extent;
			import com.esri.ags.geometry.Geometry;
			import com.esri.ags.geometry.MapPoint;
			import com.esri.ags.geometry.Multipoint;
			import com.esri.ags.geometry.Polygon;
			import com.esri.ags.geometry.Polyline;
			import com.esri.ags.layers.ArcGISDynamicMapServiceLayer;
			import com.esri.ags.layers.FeatureLayer;
			import com.esri.ags.layers.GraphicsLayer;
			import com.esri.ags.layers.Layer;
			import com.esri.ags.layers.supportClasses.CodedValue;
			import com.esri.ags.layers.supportClasses.CodedValueDomain;
			import com.esri.ags.layers.supportClasses.FeatureType;
			import com.esri.ags.layers.supportClasses.Field;
			import com.esri.ags.layers.supportClasses.LayerDetails;
			import com.esri.ags.layers.supportClasses.RangeDomain;
			import com.esri.ags.layers.supportClasses.Relationship;
			import com.esri.ags.portal.PopUpRenderer;
			import com.esri.ags.portal.supportClasses.PopUpInfo;
			import com.esri.ags.portal.supportClasses.PopUpMediaInfo;
			import com.esri.ags.symbols.PictureMarkerSymbol;
			import com.esri.ags.symbols.SimpleFillSymbol;
			import com.esri.ags.symbols.SimpleLineSymbol;
			import com.esri.ags.symbols.SimpleMarkerSymbol;
			import com.esri.ags.symbols.Symbol;
			import com.esri.ags.tasks.GeometryService;
			import com.esri.ags.tasks.GeometryServiceSingleton;
			import com.esri.ags.tasks.QueryTask;
			import com.esri.ags.tasks.supportClasses.BufferParameters;
			import com.esri.ags.tasks.supportClasses.Query;
			import com.esri.ags.tools.DrawTool;
			import com.esri.ags.utils.GeometryUtil;
			import com.esri.ags.utils.GraphicUtil;
			import com.esri.ags.utils.StringUtil;
			import com.esri.viewer.AppEvent;
			import com.esri.viewer.ViewerContainer;
			import com.esri.viewer.components.TitlebarButton;
			import com.esri.viewer.components.toc.utils.MapUtil;
			
			import mx.collections.*;
			import mx.controls.Alert;
			import mx.controls.ToolTip;
			import mx.core.FlexGlobals;
			import mx.core.IToolTip;
			import mx.core.IUIComponent;
			import mx.core.IVisualElement;
			import mx.core.UIComponent;
			import mx.events.FlexEvent;
			import mx.events.ListEvent;
			import mx.events.ScrollEvent;
			import mx.events.ToolTipEvent;
			import mx.events.ValidationResultEvent;
			import mx.managers.PopUpManager;
			import mx.managers.PopUpManagerChildList;
			import mx.managers.ToolTipManager;
			import mx.rpc.AsyncResponder;
			import mx.rpc.Fault;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			import mx.utils.ObjectUtil;
			import mx.utils.StringUtil;
			import mx.validators.NumberValidator;
			
			import spark.components.supportClasses.ItemRenderer;
			import spark.formatters.CurrencyFormatter;
			import spark.formatters.DateTimeFormatter;
			import spark.formatters.NumberFormatter;
			
			//labels
			[Bindable] private var lblInclueTextQuery:String;
			[Bindable] private var lblbufferUserGraphic:String;
			[Bindable] private var noRelatesFound:String;
			[Bindable] private var noRelatesFoundAlertTitle:String;
			[Bindable] private var enableMultiPartSearch:String;
			[Bindable] private var lblTolerance:String;
			[Bindable] private var layerLabel:String;
			[Bindable] private var layerExprLabel:String;
			[Bindable] private var submitLabel:String;	
			[Bindable] private var pointLabel:String;
			[Bindable] private var buffergrapicpropsLbl:String;
			[Bindable] private var bufferAlphaLabel:String;
			[Bindable] private var bufferColorLabel:String;
			[Bindable] private var nobuffercolorlbl:String;
			[Bindable] private var bufferoutlinecolorlbl:String;
			[Bindable] private var nobufferoutlinecolorlbl:String;
			[Bindable] private var bufferoutlinewidthlbl:String;
			[Bindable] private var configbuffergraTip:String;
			[Bindable] private var includetextquerywarnTip:String;
			[Bindable] private var lineLabel:String;
			[Bindable] private var rectangleLabel:String;
			[Bindable] private var polygonLabel:String;
			[Bindable] private var clearLabel:String;
			[Bindable] private var zoomallLabel:String;
			[Bindable] private var zoomallTip:String;	
			[Bindable] private var drawGraLabel:String;
			[Bindable] private var bufferGraLabel:String;
			[Bindable] private var msgVisible:Boolean = false;
			[Bindable] private var searchLayerLabel:String;
			[Bindable] private var relatLayerWhereLabel:String;
			[Bindable] private var bufferLabel:String;
			[Bindable] private var drawGraphicsLayer:GraphicsLayer;
			[Bindable] private var bufferGraphicsLayer:GraphicsLayer;
			private var graphicalsearchLabel:String;
			private var textsearchLabel:String;
			private var resultsLabel:String;
			private var gridresultsLabel:String;
			private var loadingLabel:String;	
			private var selectionLabel:String;	
			private var nolayerLabel:String;
			
			//Properties
			[Bindable] private var graphicsLayer:GraphicsLayer;
			[Bindable] public var searchResultAC:ArrayCollection;
			[Bindable] private var eDrawEnabled:Boolean = false;
			[Bindable] private var pBufferEnabled:Boolean = false;
			[Bindable] private var applyBufferLabel:String;
			[Bindable] private var multiPartGraphicSearch:Boolean;
			[Bindable] private var applyTolleranceByDefault:Boolean;
			[Bindable] private var widgetAndGridIteract:Boolean;
			private var layerDetails:*;
			private var gridFields:Array = [];
			private var gridHyperFields:Array = [];
			private var relateFields:Array = [];
			private var qrelateFields:Array = [];
			private var relateHyperFields:Array = [];
			private var configSearchGraphical:Array;
			private var configSearchText:Array;
			private var configDomainVals:Array;
			private var configUserVals:Array;
			private var queryLayerRels:Array;
			private var qLinks:Array = [];
			private var lyrQLinks:Array = [];
			private var configLayerExprs:Array;
			private var configLayerExprsVals:Array;
			private var configTableExprs:Array;
			private var configTableExprsVals:Array;
			private var configLayerRels:Array;
			private var configTableRels:Array;
			private var configBufferUnits:Array;
			private var configSpatialSearchLayers:Array;
			private var configSpatialSearchRelation:Array;
			private var geomArr:Array;
			private var wFields:ArrayCollection;
			private var keepGraSearchEnabled:Boolean;
			private var autoZoom:Boolean;
			private var queryLinkIconIsField:Boolean;
			private var queryEnableExport:Boolean;
			private var queryExprForSpatRel:Boolean;
			private var queryAttachments:Boolean;
			private var openDataGrid:Boolean;
			private var executingURLquery:Boolean;
			private var disRelatesInFixed:Boolean;
			private var qLayer:FeatureLayer;
			private var queryLayer:FeatureLayer;
			private var relqueryLayer:FeatureLayer;
			private var resultsFeatureSet:FeatureSet;
			private var queryGeom:Geometry;
			private var graphicsLayerBuffer:GraphicsLayer;
			private var graGraphicsLayer:GraphicsLayer;
			private var selectedDrawingIcon:Image;
			private var zoomScale:Number = 5000;
			private var zoomPercent:Number = 1.2;
			private var pointSearchTolerance:Number = 6;
			private var numberValidator:NumberValidator;
			private var gridDataProvider:Object;
			private var fldAliases:Object;
			private var relfldAliases:Object;
			private var popUpRenderer:PopUpRenderer = new PopUpRenderer();
			private var rWindow:RelatesWindow;
			private var myfloatdg:SearchWidgetFloatDG;
			private var relfloatdg:SearchWidgetRelateFloatDG;
			private var sWidget:eSearchWidget;
			private var sReff:SpatialReference;
			private var relateIcon:String;
			private var relateToolTip:String;
			private var queryExpr:String;
			private var queryDefExpr:String = "";
			private const ICON_URL:String = "assets/images/";
			[Bindable] private var WIDGET_URL:String = "widgets/eSearch/assets/images/";
			private var _csvName:String;
			private var relatescsvName:String;
			private var queryMultiImgField:String;
			private var csvSep:String;
			private var expBtnLbl:String;
			private var exp2csvOptLbl:String;
			private var exp2txtOptLbl:String;
			private var lblSum:String;
			private var sumField:String;
			private var disableButtons:String;
			private var spatialsearchLabel:String;
			private var floatorfixed:String;
			private var selectedGraphicalTool:String;
			private var lastTool:String;
			private var lState:String = "textInput";
			private var queryTitleField:String;
			private var defaultSelectionOption:String;
			private var timer:Timer;
			private var myTip:ToolTip;
			private var queryFields:XMLList;

			//Formatters
			private var dateFormatter:DateTimeFormatter = new DateTimeFormatter();
			private var numFormatter:NumberFormatter = new NumberFormatter();
			private var currFormatter:CurrencyFormatter = new CurrencyFormatter();
			
			//Symbols
			private var drawSymbol:Symbol;
			private var resultMarkerSymbol:Symbol;
			private var resultLineSymbol:Symbol;
			private var resultFillSymbol:Symbol;
			private var resultSATSymbol:Symbol;
			private var overFillSymbol:Symbol;
			
			//Build Constants
			protected const VERSION:String = "3.0.7";
			protected const BUILDDATE:String = "8/21/2012";
			
			//Resources
			[Embed(source="assets/images/i_about.png")]
			private var iconClass:Class;
			
			[Embed(source="widgets/eSearch/assets/images/i_relate.png")]
			private var relateClass:Class;
			
			[Embed(source="assets/images/i_table.png")]
			private var satClass:Class;
			
			private function init():void
			{					
				sWidget = this;
				WIDGET_URL = config.substring(0,config.lastIndexOf("/")) + "/assets/images/";
				if (configXML){
					if (GeometryServiceSingleton.instance.url){
						geometryService.url = GeometryServiceSingleton.instance.url;
						geometryService.token = GeometryServiceSingleton.instance.token;
						geometryService.proxyURL = GeometryServiceSingleton.instance.proxyURL;
					}
					relateIcon = configXML.relateicon || WIDGET_URL + "i_relate.png";
					//labels
					lblInclueTextQuery = configXML.labels.includetextquery || "include text query in selection criteria";
					lblbufferUserGraphic = configXML.labels.bufferusergraphics || "Buffer Graphic";
					noRelatesFound = configXML.labels.norelatesfound || "No related features found";
					noRelatesFoundAlertTitle = configXML.labels.norelatesfoundalerttitle || "No Results";
					buffergrapicpropsLbl = configXML.labels.buffergrapicprops || "Buffer graphic properties";
					bufferColorLabel = configXML.labels.buffercolor || "Select buffer color";
					bufferAlphaLabel = configXML.labels.bufferalpha || "Adjust buffer alpha";
					nobuffercolorlbl = configXML.labels.nobuffercolor || "No fill color";
					bufferoutlinecolorlbl = configXML.labels.bufferoutlinecolor || "Outline color";
					nobufferoutlinecolorlbl = configXML.labels.nobufferoutlinecolor || "No outline color";
					bufferoutlinewidthlbl = configXML.labels.bufferoutlinewidth || "Outline Width";
					configbuffergraTip = configXML.labels.configbuffergra || "Configure buffer graphic properties...";
					lblTolerance = configXML.labels.addtolerance || "Add search tolerance to point selection";
					drawGraLabel = configXML.labels.existingdrawgraphicslabel || "Use Existing Draw Widget Graphics";
					bufferGraLabel = configXML.labels.existingbuffergraphicslabel || "Use Existing Point Buffer Widget Graphics";
					graphicalsearchLabel = configXML.labels.graphicalsearchlabel || "Graphical Search";
					textsearchLabel = configXML.labels.textsearchlabel || "Text Search";
					includetextquerywarnTip = configXML.labels.includetextquerywarn || "Must be the same search layer in both\ngraphical and text search pages.";
					resultsLabel = configXML.labels.resultslabel || "Results";
					layerLabel = configXML.labels.layerlabel || "Search Layer:";
					layerExprLabel = configXML.labels.layerfieldlabel || "Search Layer Field:";
					nolayerLabel = configXML.labels.nolayerlabel || "No search layer defined.";
					submitLabel = configXML.labels.submitlabel || "Search";
					pointLabel = configXML.labels.pointlabel || "Select by Point";
					lineLabel = configXML.labels.linelabel || "Select by Line";
					rectangleLabel = configXML.labels.rectanglelabel || "Select by Rectangle";
					polygonLabel = configXML.labels.polygonlabel || "Select by Polygon";
					clearLabel = configXML.labels.clearlabel || "Clear";
					zoomallLabel = configXML.labels.zoomalllabel || "Zoom";
					zoomallTip = configXML.labels.zoomalltip || "Zoom to all results";
					loadingLabel = configXML.labels.loadinglabel || "Loading...";
					selectionLabel = configXML.labels.selectionlabel || "Features Selected:";
					gridresultsLabel = configXML.labels.gridresultslabel || "Show Results in Grid";
					exp2csvOptLbl = configXML.labels.export2csvbuttonlabel || "Export to CSV...";
					exp2txtOptLbl = configXML.labels.export2txtbuttonlabel || "Export to Txt...";
					expBtnLbl = configXML.labels.exportbtnlabel || "Export...";
					_csvName = configXML.labels.csvdefaultname || "Selected Records";
					relatescsvName = configXML.labels.relatescsvdefaultname || "Related Records";
					csvSep = configXML.csvseparator;
					spatialsearchLabel = configXML.labels.spatialsearchlabel || "Spatial search";
					searchLayerLabel = configXML.labels.searchlayerlabel || "Search entities of:";
					bufferLabel = configXML.labels.bufferlabel || "apply a search distance:";
					applyBufferLabel = configXML.labels.applybufferlabel || "Apply buffer";
					relateToolTip = configXML.relatetooltip || "Show Relates";
					sReff = new SpatialReference(configXML.spatialreference);
					defaultSelectionOption = configXML.defaultselectionoption || "textInput";
					currentState = defaultSelectionOption;
					disableButtons = configXML.disablebuttons || "";
					selectedGraphicalTool = configXML.selectedgraphicaltool || "";
					enableMultiPartSearch = configXML.labels.enablemultipartsearch || "enable multi-part graphics";
					applyTolleranceByDefault = configXML.tolerancebydefault && configXML.tolerancebydefault == "true";
					widgetAndGridIteract = configXML.enabledatagridinteractionwithwidget && configXML.enabledatagridinteractionwithwidget == "true";
					
					configSpatialSearchRelation = [];
					var operList:XMLList = configXML..spatialrelationship;
					var sOpBtn:Image;
					for (var s:Number = 0; s < operList.length(); s++){
						var srName:String = operList[s].name;
						var srLabel:String = operList[s].label;
						var spatialRelationship:Object = {
							name: srName,
							label: srLabel
						};
						sOpBtn = new Image();
						sOpBtn.name = srName;
						sOpBtn.source = getSopImg(srName);
						sOpBtn.toolTip = srLabel;
						sOpBtn.addEventListener(MouseEvent.CLICK, sOpBtnClickHandler);
						sOpBtn.useHandCursor = true;
						sOpBtn.buttonMode = true;
						SpatialOps.addElement(sOpBtn);
						configSpatialSearchRelation.push(spatialRelationship);
					}
					if(operList.length() == 0){
						lblSearchLayerSpatial.visible = false;
						cboSearchLayerSpatial.visible = false;
						SpatialOps.visible = false;
						lblSearchLayerSpatial.includeInLayout = false;
						cboSearchLayerSpatial.includeInLayout = false;
						SpatialOps.includeInLayout = false;
					}
					
					keepGraSearchEnabled = configXML.keepgraphicalsearchenabled && configXML.keepgraphicalsearchenabled == "true";
					autoZoom = configXML.autozoomtoresults && configXML.autozoomtoresults == "true";
					eDrawEnabled = configXML.enabledrawgraphicbutton && configXML.enabledrawgraphicbutton == "true";
					pBufferEnabled = configXML.enablebuffergraphicbutton && configXML.enablebuffergraphicbutton == "true";
					multiPartGraphicSearch = configXML.multipartgraphicsearch && configXML.multipartgraphicsearch == "true";
					(multiPartGraphicSearch.valueOf() == true) ? graFeatureQueryBtn.visible = true : graFeatureQueryBtn.visible = false;
					floatorfixed = configXML.floatorfixed || "float";
					disRelatesInFixed = configXML.floatorfixed.@disablerelatestabinfixed && configXML.floatorfixed.@disablerelatestabinfixed == "true";
					
					if(eDrawEnabled){
						eDrawBtn.filters = [cOver];
						eDrawBtn.buttonMode = eDrawBtn.useHandCursor = eDrawBtn.enabled = false;
						map.addEventListener(MapEvent.LAYER_ADD, checkForeDrawGL);					
						MapUtil.forEachMapLayer(map, function(layer:Layer):void
						{
							if(layer.name.toLowerCase() == "draw features"){
								drawGraphicsLayer = layer as GraphicsLayer;
								if(drawGraphicsLayer.numGraphics > 0){
									checkeDrawNumGras(null);
								}
								drawGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_ADD, checkeDrawNumGras);
								drawGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_REMOVE, checkeDrawNumGras);
								drawGraphicsLayer.addEventListener(GraphicsLayerEvent.GRAPHICS_CLEAR, checkeDrawNumGras);
							}
						});
					}
					
					if(pBufferEnabled){
						pBufferBtn.filters = [cOver];
						pBufferBtn.buttonMode = pBufferBtn.useHandCursor = pBufferBtn.enabled = false;
						map.addEventListener(MapEvent.LAYER_ADD, checkForpntBufferGL);					
						MapUtil.forEachMapLayer(map, function(layer:Layer):void
						{
							if(layer.name.toLowerCase() == "buffer results"){
								bufferGraphicsLayer = layer as GraphicsLayer;
								if(bufferGraphicsLayer.numGraphics > 0){
									checkBufferNumGras(null);
								}
								bufferGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_ADD, checkBufferNumGras);
								bufferGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_REMOVE, checkBufferNumGras);
								bufferGraphicsLayer.addEventListener(GraphicsLayerEvent.GRAPHICS_CLEAR, checkBufferNumGras);
							}
						});
					}
					
					configBufferUnits = [];
					var bufferUnitsList:XMLList = configXML..bufferunit;
					for (var b:int = 0; b < bufferUnitsList.length(); b++){
						var buffUnitName:String = bufferUnitsList[b].name;
						var buffUnitLabel:String = bufferUnitsList[b].label;
						var bufferUnit:Object = {
							name: buffUnitName,
							label: buffUnitLabel
						};
						configBufferUnits.push(bufferUnit);
					}
					cboGraBufferUnit.dataProvider = new ArrayCollection(configBufferUnits);
					cboGraBufferUnit.width = determineDropDownWidth(configBufferUnits);
					if((cboGraBufferUnit.width + 102 + bufferUserGraphic.measureText(lblbufferUserGraphic).width + 37) > wTemplate.width){
						cboGraBufferUnit.width = (wTemplate.width - (102 + bufferUserGraphic.measureText(lblbufferUserGraphic).width + 37));
					}
					cboGraBufferUnit.selectedIndex = 0;
										
					configSearchGraphical = [];
					configSearchText = [];
					configSpatialSearchLayers = [];
					configDomainVals = [];
					var r:Number;
					var i:Number;
					var j:Number;
					var l:Number;
					var v:Number;
					var lyrList:XMLList = configXML..layer;
					for (i = 0; i < lyrList.length(); i++){
						configLayerExprs = [];
						configLayerRels = [];
						var lyrURL:String = lyrList[i].url;
						var lyrLabel:String = lyrList[i].name;
						var lyrGraphicalLabel:String = lyrList[i].graphicalsearchlabel;
						var lyrRelList:XMLList = configXML.layers.layer[i]..relate;
						for (r = 0; r < lyrRelList.length(); r++){
							var lyrRelLabel:String = lyrRelList[r].@label;
							var lyrRelId:String = lyrRelList[r].@id;
							var lyrRelIcon:String = lyrRelList[r].@icon || WIDGET_URL + "i_relate.png";
							var lyrRelFields:XMLList = lyrRelList[r].fields;
							var lyrRelEnableExport:Boolean = lyrRelList[r].@enableexport && lyrRelList[r].@enableexport == "true";
							var lyrRel:Object = {
								id: lyrRelId,
								fields: lyrRelFields,
								label: lyrRelLabel,
								enableexport: lyrRelEnableExport,
								icon: lyrRelIcon
							};
							configLayerRels.push(lyrRel);
						}
						var lyrExprList:XMLList = configXML.layers.layer[i]..expression;
						for (j = 0; j < lyrExprList.length(); j++){
							var lyrExprAlias:String = lyrExprList[j].@alias;
							var lyrTextLabel:String = lyrExprList[j].@textsearchlabel;
							var lyrRequiresAValue:Boolean = lyrExprList[j].@isValueRequired && lyrExprList[j].@isValueRequired == "true";
							var lyrExprVals:XMLList = lyrExprList[j]..value;
							configLayerExprsVals = [];
							for (v = 0; v < lyrExprVals.length(); v++){
								var valPrompt:String = lyrExprVals[v].@prompt;
								var valExpr:String = lyrExprVals[v];
								var valField:String = lyrExprVals[v].@field;
								var valUserList:String = lyrExprVals[v].@userlist;
								var valDomain:Boolean = lyrExprVals[v].@usedomain && lyrExprVals[v].@usedomain == "true";
								// if config is given and set to false explicitly, then make it optional (aka not required). Otherwise, default to being required
								var isOptional:Boolean = lyrExprVals[v].@isValueRequired && lyrExprVals[v].@isValueRequired == "false";
								var prependToValue:String =  lyrExprVals[v].@prepend;
								
								var exprVals:Object = {
									prompt: valPrompt,
									expression: valExpr,
									field: valField,
									usedomain: valDomain,
									userlist: valUserList,
									isValueRequired : !isOptional,
									prepend : prependToValue
								};
								configLayerExprsVals.push(exprVals)
							}
							var expr:Object = {
								label: lyrExprAlias,
								textlabel: lyrTextLabel,
								values: configLayerExprsVals,
								isValueRequired : lyrRequiresAValue
								
							};
							configLayerExprs.push(expr);
						}
						var lyrDefExpr:String = lyrList[i].definitionexpression;
						var lyrFields:XMLList = lyrList[i].fields;
						var lyrTitleField:String = lyrList[i].titlefield;
						
						var lyrLinks:Array = [];
						var lyrLinkList:XMLList = lyrList[i]..link;
						for (l = 0; l < lyrLinkList.length(); l++){
							var lyrLink:String = XML(lyrLinkList[l]).text() || "";
							var lyrLinkAlias:String = lyrLinkList[l].@alias || "";
							var lyrIcon:String = XML(lyrLinkList[l]).child("icon") || "";
							var linkObj:Object = {
								link: lyrLink,
								alias: lyrLinkAlias,
								icon: lyrIcon
							};
							lyrLinks.push(linkObj);
						}
						var lyrQueryAttach:Boolean = lyrList[i].queryattachments && lyrList[i].queryattachments == "true";
						var lyrEnableExport:Boolean = lyrList[i].enableexport && lyrList[i].enableexport == "true";
						var lyrMultiImgField:String = lyrList[i].multiimagefield;
						var useProxy:Boolean = lyrList[i].useproxy && lyrList[i].useproxy == "true";
						var useAMF:String = lyrList[i].useamf;
						var openDG:Boolean = lyrList[i].autoopendatagrid && lyrList[i].autoopendatagrid == "true";
						if ((lyrList[i].zoomscale.@usegeometry) && (lyrList[i].zoomscale.@usegeometry == "true")){
							zoomScale = Number.NaN;
							if(lyrList[i].zoomscale.@zoompercent){
								zoomPercent = Number(lyrList[i].zoomscale.@zoompercent)
							}else{
								zoomPercent = 1.2
							}
						}else{
							if (Number(lyrList[i].zoomscale) > 0){
								zoomScale = Number(lyrList[i].zoomscale);
							}
						}
						
						var lyrSpatialLabel:String = lyrList[i].spatialquerylabel;
						var lyrSpatialSearchLyr:String = lyrList[i].spatialsearchlayer;
						
						const layer:FeatureLayer = new FeatureLayer(lyrURL);
						layer.name = layer.id = lyrLabel;
						if (useProxy && configData.proxyUrl){
							layer.proxyURL = configData.proxyUrl;
						}
						if (useAMF){
							layer.useAMF = useAMF == "true";
						}
						if (lyrFields && lyrFields[0].@all[0] == "true"){
							layer.outFields = ["*"];
						}else if (lyrFields){
							var fields:XMLList = lyrFields.field;
							layer.outFields = [];
							for each (var fieldXML:XML in fields){
								if (fieldXML.@name[0]){
									layer.outFields.push(fieldXML.@name[0]);
								}
							}
						}
						
						var searchLayer:Object = {
							layer: layer,
							label: lyrLabel,
							titlefield: lyrTitleField,
							spatialsearchlabel: lyrSpatialLabel,
							spatialsearchlayer: lyrSpatialSearchLyr,
							graphicallabel: lyrGraphicalLabel,
							expr: configLayerExprs,
							fields: lyrFields,
							links: lyrLinks,
							multi: lyrMultiImgField,
							zoomscale: zoomScale,
							zoompercent: zoomPercent,
							enableexport: lyrEnableExport,
							defexpr: lyrDefExpr,
							opendg: openDG,
							relates: configLayerRels,
							attachments: lyrQueryAttach
						};
						configSearchGraphical.push(searchLayer);
						
						if (searchLayer.spatialsearchlayer == "true"){
							configSpatialSearchLayers.push(searchLayer);
						}
						if (configLayerExprs && configLayerExprs.length > 0){
							configSearchText.push(searchLayer);
						}
					}

					var tblList:XMLList = configXML..table;
					for (i = 0; i < tblList.length(); i++){
						configTableExprs = [];
						configTableRels = [];
						var tblURL:String = tblList[i].url;
						var tblLabel:String = tblList[i].name;
						var tblRelList:XMLList = configXML.tables.table[i]..relate;
						for (r = 0; r < tblRelList.length(); r++){
							var tblRelLabel:String = tblRelList[r].@label;
							var tblRelId:String = tblRelList[r].@id;
							var tblRelIcon:String = tblRelList[r].@icon || WIDGET_URL + "i_relate.png";
							var tblRelFields:XMLList = tblRelList[r].fields;
							var tblRelEnableExport:Boolean = tblRelList[r].@enableexport && tblRelList[r].@enableexport == "true";
							var tblRel:Object = {
								id: tblRelId,
								fields: tblRelFields,
								label: tblRelLabel,
								enableexport: tblRelEnableExport,
								icon: tblRelIcon
							};
							configTableRels.push(tblRel);
						}
						var tblExprList:XMLList = configXML.tables.table[i]..expression;
						for (j = 0; j < tblExprList.length(); j++){
							var tblExprAlias:String = tblExprList[j].@alias;
							var tblTextLabel:String = tblExprList[j].@textsearchlabel;
							var tblRequiresAValue:Boolean = tblExprList[j].@isValueRequired && tblExprList[j].@isValueRequired == "true";
							var tblExprVals:XMLList = tblExprList[j]..value;
							configTableExprsVals = [];
							for (v = 0; v < tblExprVals.length(); v++){
								var tblPrompt:String = tblExprVals[v].@prompt;
								var tblExpr:String = tblExprVals[v];
								var tblField:String = tblExprVals[v].@field;
								var tblUserList:String = tblExprVals[v].@userlist;
								var tblDomain:Boolean = tblExprVals[v].@usedomain && tblExprVals[v].@usedomain == "true";
								// if config is given and set to false explicitly, then make it optional (aka not required). Otherwise, default to being required
								var isOptional:Boolean = tblExprVals[v].@isValueRequired && tblExprVals[v].@isValueRequired == "false";
								var prependToValue:String =  tblExprVals[v].@prepend;

								var tblexprVals:Object = {
									prompt: tblPrompt,
									expression: tblExpr,
									field: tblField,
									usedomain: tblDomain,
									userlist: tblUserList,
									isValueRequired : !isOptional,
									prepend : prependToValue
								};
								configTableExprsVals.push(tblexprVals)
							}
							var tblexpr:Object ={
								label: tblExprAlias,
								textlabel: tblTextLabel,
								values: configTableExprsVals,
								isValueRequired : tblRequiresAValue
							};
							configTableExprs.push(tblexpr);
						}
						var tblDefExpr:String = tblList[i].definitionexpression;
						var tblFields:XMLList = tblList[i].fields;
						var tblTitleField:String = tblList[i].titlefield;
						
						var tblLinks:Array = [];
						var tblLinkList:XMLList = tblList[i]..link;
						for (l = 0; l < tblLinkList.length(); l++){
							var tblLink:String = XML(tblLinkList[l]).text() || "";
							var tblLinkAlias:String = tblLinkList[l].@alias || "";
							var tblIcon:String = XML(tblLinkList[l]).child("icon") || "";
							var tbllinkObj:Object = {
								link: tblLink,
								alias: tblLinkAlias,
								icon: tblIcon
							};
							tblLinks.push(tbllinkObj);
						}	
						var tblEnableExport:Boolean = tblList[i].enableexport && tblList[i].enableexport == "true";
						var tblMultiImgField:String = tblList[i].multiimagefield;
						var tbluseProxy:Boolean = tblList[i].useproxy && tblList[i].useproxy == "true";
						var tbluseAMF:String = tblList[i].useamf;
						var tblopenDG:Boolean = tblList[i].autoopendatagrid && tblList[i].autoopendatagrid == "true";
						var tblQueryAttach:Boolean = tblList[i].@queryattachments && tblList[i].@queryattachments == "true";
	
						var table:FeatureLayer = new FeatureLayer(tblURL);
						if (useProxy && configData.proxyUrl){
							table.proxyURL = configData.proxyUrl;
						}
						if (useAMF){
							table.useAMF = useAMF == "true";
						}
						if (tblFields && tblFields[0].@all[0] == "true"){
							table.outFields = ["*"];
						}else if (tblFields){
							var tblfields:XMLList = tblFields.field;
							table.outFields = [];
							for each (var tblfieldXML:XML in tblfields){
								if (tblfieldXML.@name[0]){
									table.outFields.push(tblfieldXML.@name[0]);
								}
							}
						}
						
						var searchTable:Object = {
							table: table,
							label: tblLabel,
							titlefield: tblTitleField,
							expr: configTableExprs,
							fields: tblFields,
							links: tblLinks,
							multi: tblMultiImgField,
							enableexport: tblEnableExport,
							defexpr: tblDefExpr,
							opendg: tblopenDG,
							relates: configTableRels,
							attachments: tblQueryAttach
						};						
						
						if (configTableExprs && configTableExprs.length > 0){
							configSearchText.push(searchTable);
						}
					}
					
					//marker symbol
					if(configXML.symbols.picturemarkersymbol.@url[0] != null){
						const resultMarkerSymbolURL:String = configXML.symbols.picturemarkersymbol.@url || widgetIcon;
						const resultMarkerSymbolHeight:Number = (configXML.symbols.picturemarkersymbol.@height[0] != null) ? configXML.symbols.picturemarkersymbol.@height : 30;
						const resultMarkerSymbolWidth:Number = (configXML.symbols.picturemarkersymbol.@width[0] != null) ? configXML.symbols.picturemarkersymbol.@width : 30;
						const resultMarkerSymbolXOffset:Number = (configXML.symbols.picturemarkersymbol.@xoffset[0] != null) ? configXML.symbols.picturemarkersymbol.@xoffset : 0;
						const resultMarkerSymbolYOffset:Number = (configXML.symbols.picturemarkersymbol.@yoffset[0] != null) ? configXML.symbols.picturemarkersymbol.@yoffset : 0;
						const resultMarkerSymbolAngle:Number = (configXML.symbols.simplemarkersymbol.@angle[0] != null) ? configXML.symbols.simplemarkersymbol.@angle : 0;
						resultMarkerSymbol = new PictureMarkerSymbol(resultMarkerSymbolURL, resultMarkerSymbolWidth, resultMarkerSymbolHeight, resultMarkerSymbolXOffset, resultMarkerSymbolYOffset, resultMarkerSymbolAngle);
					}else{
						const resultMarkerSymbolStyle:String = configXML.symbols.simplemarkersymbol.@style || "circle";
						const resultMarkerSymbolSize:Number = (configXML.symbols.simplemarkersymbol.@size[0] != null) ? configXML.symbols.simplemarkersymbol.@size : 15;
						const resultMarkerSymbolColor:uint = (configXML.symbols.simplemarkersymbol.@color[0] != null) ? configXML.symbols.simplemarkersymbol.@color : 0xFF0000;
						const resultMarkerSymbolAlpha:Number = (configXML.symbols.simplemarkersymbol.@alpha[0] != null) ? configXML.symbols.simplemarkersymbol.@alpha : 0.8;
						const resultMarkerSymbolXOffset2:Number = (configXML.symbols.simplemarkersymbol.@xoffset[0] != null) ? configXML.symbols.simplemarkersymbol.@xoffset : 0;
						const resultMarkerSymbolYOffset2:Number = (configXML.symbols.simplemarkersymbol.@yoffset[0] != null) ? configXML.symbols.simplemarkersymbol.@yoffset : 0;
						const resultMarkerSymbolAngle2:Number = (configXML.symbols.simplemarkersymbol.@angle[0] != null) ? configXML.symbols.simplemarkersymbol.@angle : 0;
						const resultMarkerSymbolOutlineStyle:String = configXML.symbols.simplemarkersymbol.outline.@style || "solid";
						const resultMarkerSymbolOutlineColor:uint = (configXML.symbols.simplemarkersymbol.outline.@color[0] != null) ? configXML.symbols.simplemarkersymbol.outline.@color : 0x0000ff;
						const resultMarkerSymbolOutlineAlpha:Number = (configXML.symbols.simplemarkersymbol.outline.@alpha[0] != null) ? configXML.symbols.simplemarkersymbol.outline.@alpha : 0.8;
						const resultMarkerSymbolOutlineWidth:Number = (configXML.symbols.simplemarkersymbol.outline.@width[0] != null) ? configXML.symbols.simplemarkersymbol.outline.@width : 2;
						resultMarkerSymbol = new SimpleMarkerSymbol(resultMarkerSymbolStyle,resultMarkerSymbolSize,resultMarkerSymbolColor,resultMarkerSymbolAlpha,resultMarkerSymbolXOffset2,resultMarkerSymbolYOffset2,resultMarkerSymbolAngle2,new SimpleLineSymbol(resultMarkerSymbolOutlineStyle, resultMarkerSymbolOutlineColor, resultMarkerSymbolOutlineAlpha, resultMarkerSymbolOutlineWidth));
					}
					
					//Symbol for stand alone tables
					resultSATSymbol = new PictureMarkerSymbol(satClass,20,20);
					
					//line symbol
					const resultLineSymbolColor:uint = (configXML.symbols.simplelinesymbol.@color[0] != null) ? configXML.symbols.simplelinesymbol.@color : 0xFF0000;
					const resultLineSymbolAlpha:Number = (configXML.symbols.simplelinesymbol.@alpha[0] != null) ? configXML.symbols.simplelinesymbol.@alpha : 0.8;
					const resultLineSymbolWidth:Number = (configXML.symbols.simplelinesymbol.@width[0] != null) ? configXML.symbols.simplelinesymbol.@width : 2;
					resultLineSymbol = new SimpleLineSymbol(SimpleLineSymbol.STYLE_SOLID, resultLineSymbolColor, resultLineSymbolAlpha, resultLineSymbolWidth);
					
					// fill symbol
					const resultFillSymbolColor:uint = (configXML.symbols.simplefillsymbol.@color[0] != null) ? configXML.symbols.simplefillsymbol.@color : 0xFF0000;
					const resultFillSymbolAlpha:Number = (configXML.symbols.simplefillsymbol.@alpha[0] != null) ? configXML.symbols.simplefillsymbol.@alpha : 0.5; 
					const resultFillSymbolOutlineColor:uint = (configXML.symbols.simplefillsymbol.outline.@color[0] != null) ? configXML.symbols.simplefillsymbol.outline.@color : 0xFF0000;
					const resultFillSymbolOutlineAlpha:Number = (configXML.symbols.simplefillsymbol.outline.@alpha[0] != null) ? configXML.symbols.simplefillsymbol.outline.@alpha : 0.8;
					const resultFillSymbolOutlineWidth:Number = (configXML.symbols.simplefillsymbol.outline.@width[0] != null) ? configXML.symbols.simplefillsymbol.outline.@width : 2;
					resultFillSymbol = new SimpleFillSymbol(SimpleFillSymbol.STYLE_SOLID, resultFillSymbolColor, resultFillSymbolAlpha, new SimpleLineSymbol(SimpleLineSymbol.STYLE_SOLID, resultFillSymbolOutlineColor, resultFillSymbolOutlineAlpha, resultFillSymbolOutlineWidth));
					
					graphicsLayerBuffer = new GraphicsLayer();
					graphicsLayerBuffer.name = "Search Buffer Results";
					map.addLayer(graphicsLayerBuffer);
					
					graphicsLayer = new GraphicsLayer();
					graphicsLayer.name = "eSearch Results";
					graphicsLayer.symbol = resultMarkerSymbol;
					graphicsLayer.addEventListener(FlexEvent.HIDE, graphicsLayer_hideHandler);
					map.addLayer(graphicsLayer);
					
					graGraphicsLayer = new GraphicsLayer();
					graGraphicsLayer.name = "Graphical Search Layer";
					map.addLayer(graGraphicsLayer);
					
					var userTolerance:Number = Number(configXML.toleranceforpointgraphicalselection);
					if (userTolerance > 0){
						pointSearchTolerance = userTolerance;
					}
					if (selectedGraphicalTool != "" && defaultSelectionOption == "graphicalInput"){
						activateSearchTool(null, selectedGraphicalTool);
					}
				}
				
				if(disableButtons != ""){
					var dbArr:Array = disableButtons.split(",");
				}
				var disText:Boolean = false;
				var disGra:Boolean = false;
				var disSpat:Boolean = false;
				var disGrid:Boolean = false;
				var disDataGrid:Boolean = false;
				if(dbArr){
					for (var d:int = 0; d<dbArr.length; d++){
						switch (dbArr[d]){
							case "text":{
								disText = true;
								break;
							}
							case "graphic":{
								disGra = true;
								break;
							}
							case "spatial":{
								disSpat = true;
								break;
							}
							case "grid":{
								disGrid = true;
								break;
							}
							case "datagrid":{
								disDataGrid = true;
								break;
							}
						}
					}
				}
				if(floatorfixed != "fixed" && !disDataGrid){
					wTemplate.addTitlebarButton(WIDGET_URL + "i_table2.png", gridresultsLabel,showGridResults,false);
				}
				if(!disGra){
					wTemplate.addTitlebarButton(ICON_URL + "i_searchgraphical.png", graphicalsearchLabel, showStateGraphicalSearch);
				}
				if (configSearchText.length && disText != true){
					wTemplate.addTitlebarButton(ICON_URL + "i_searchtext.png", textsearchLabel, showStateTextSearch);
				}
				if (configSpatialSearchLayers.length && disSpat != true){
					wTemplate.addTitlebarButton(WIDGET_URL + "i_searchspatial.png", spatialsearchLabel, showStateSpatialSearch);
				}
				if(!disGrid){
					wTemplate.addTitlebarButton(ICON_URL + "i_table.png", resultsLabel, showStateResults);
				}
				
				//Setup Text Search
				var sItemVal:SearchExpValueItem;
				if (configSearchText.length){
					cboLayerText.dataProvider = new ArrayCollection(configSearchText);
					cboLayerText.width = determineDropDownWidth(configSearchText);
					if((cboLayerText.width + lblLayerText.measureText(layerLabel).width + 57) > wTemplate.width){
						cboLayerText.width = (wTemplate.width - (lblLayerText.measureText(layerLabel).width + 57));
					}
					cboLayerText.selectedIndex = 0;
					txtLabelText.text = configSearchText[0].expr[0].textlabel;
					
					for(v=0; v<configSearchText[0].expr[0].values.length; v++){
						var cfg = configSearchText[0].expr[0].values[v];
						if(v == 0){
							sItemVal = searchGroup.getElementAt(0) as SearchExpValueItem;
							sItemVal.changeToTextBox();
							sItemVal.setPrompt = cfg.prompt;
							sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
							if (cfg.prepend)
							{
								sItemVal.prepend = cfg.prepend;
							};
							sItemVal.addEventListener("valueChanged", onValueChanged);
							sItemVal.addEventListener("submitSearch", onSearchSubmitted);
							sItemVal.addEventListener(FocusEvent.FOCUS_IN, searchGroupItem_focusInHandler);
						}else{
							sItemVal = new SearchExpValueItem;
							sItemVal.wTemplateWidth = wTemplate.width;
							sItemVal.percentWidth = 100;
							sItemVal.setPrompt = cfg.prompt;
							sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
							if (cfg.prepend)
							{
								sItemVal.prepend = cfg.prepend;
							};
							sItemVal.addEventListener("valueChanged", onValueChanged);
							sItemVal.addEventListener("submitSearch", onSearchSubmitted);
							sItemVal.addEventListener(FocusEvent.FOCUS_IN, searchGroupItem_focusInHandler);
							searchGroup.addElement(sItemVal);
						}
						
						var cfg:Object = configSearchText[0].expr[0].values[v];
						// set the required property from the config
						sItemVal.isValueRequired = cfg.isValueRequired;
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						
						
						if(configSearchText[0].expr[0].values[v].usedomain){
							popCBwithDomain(configSearchText[0].expr[0].values[v].field, sItemVal);
						}else if(configSearchText[0].expr[0].values[v].userlist != ""){
							popCBwithUserList(configSearchText[0].expr[0].values[v].userlist, sItemVal);
						}
					}
					
					if (configSearchText.length == 1){
						boxText.visible = false;
						boxText.includeInLayout = false;
					}
					cboLayerExpr.dataProvider = new ArrayCollection(configSearchText[0].expr);
					cboLayerExpr.width = determineDropDownWidth(configSearchText[0].expr);
					if((cboLayerExpr.width + lblExprText.measureText(layerExprLabel).width + 57) > wTemplate.width){
						cboLayerExpr.width = (wTemplate.width - (lblExprText.measureText(layerExprLabel).width + 57));
					}
					cboLayerExpr.selectedIndex = 0;
					if (configSearchText[0].expr.length == 1){
						boxTextexpr.visible = false;
						boxTextexpr.includeInLayout = false;
					}
				}else{
					boxText.visible = false;
					txtLabelText.text = nolayerLabel;
				}
				
				//Setup Graphical Search
				if (configSearchGraphical.length){
					cboLayerGraphical.dataProvider = new ArrayCollection(configSearchGraphical);
					cboLayerGraphical.width = determineDropDownWidth(configSearchGraphical);
					if((cboLayerGraphical.width + lblLayerGraphical.measureText(layerLabel).width + 57) > wTemplate.width){
						cboLayerGraphical.width = wTemplate.width - (lblLayerGraphical.measureText(layerLabel).width + 57);
					}
					cboLayerGraphical.selectedIndex = 0;
					txtLabelGraphical.text = configSearchGraphical[0].graphicallabel;
					if (configSearchGraphical.length == 1){
						boxGraphical.visible = false;
						boxGraphical.includeInLayout = false;
					}
				}else{
					boxGraphical.visible = false;
					txtLabelGraphical.text = nolayerLabel;
				}
				
				if (configSpatialSearchLayers.length){
					cboSearchLayerSpatial.dataProvider = new ArrayCollection(configSpatialSearchLayers);
					cboSearchLayerSpatial.width = determineDropDownWidth(configSpatialSearchLayers);
					if(cboSearchLayerSpatial.width > (wTemplate.width - 57)){
						cboSearchLayerSpatial.width = (wTemplate.width - 57);
					}
					cboSearchLayerSpatial.selectedIndex = 0;
					cboBufferUnit.dataProvider = new ArrayCollection(configBufferUnits);
					cboBufferUnit.width = determineDropDownWidth(configBufferUnits);
					if((cboBufferUnit.width + 117) > wTemplate.width){
						cboBufferUnit.width = (wTemplate.width - 117);
					}
					cboBufferUnit.selectedIndex = 0;
				}
				
				//Determine which button to select based on the default selection option
				for(var tb:int=0; tb < wTemplate.headerToolGroup.numElements; tb++){
					var tbb:TitlebarButton = wTemplate.headerToolGroup.getElementAt(tb) as TitlebarButton;
					if(tbb.toolTip == graphicalsearchLabel && defaultSelectionOption == "graphicalInput"){
						wTemplate.selectedTitlebarButtonIndex = tb;
					}
					if(tbb.toolTip == textsearchLabel && defaultSelectionOption == "textInput"){
						wTemplate.selectedTitlebarButtonIndex = tb;
					}
					if(tbb.toolTip == spatialsearchLabel && defaultSelectionOption == "spatialInput"){
						wTemplate.selectedTitlebarButtonIndex = tb;
					}
				}
				
				AppEvent.addListener(AppEvent.DATA_PUBLISH, sharedDataUpdated);
				
				if(ViewerContainer.urlConfigParams.search != null){
					callLater(queryFromURL,[ViewerContainer.urlConfigParams.search,ViewerContainer.urlConfigParams.slayer,ViewerContainer.urlConfigParams.exprnum]);
				}
				wTemplate.visible = true;
				wTemplate.header.addEventListener(MouseEvent.CLICK, DisplayVersion);
				searchBtn.addEventListener(MouseEvent.CLICK, equeryFeaturesText);
				
				// a new (default) search form is shown
				onSearchFormChanged();
			}
			
			/* 
			* when a new search is selected, validate the new search
			* @method
			* @private
			*/
			private function onSearchFormChanged():void
			{
				// when value changes, check that search criteria are valid
				validateSearch();				
			}
			
			/* 
			* when a value is changed (such as each character in textbox or value selected from combo)
			*  validate the Search
			* @method
			* @private
			*/
			private function onValueChanged(evt:Event):void
			{
				// when value changes, check that search criteria are valid
				validateSearch();				
			}
			
			/* 
			 * when a value triggers a submit such as when Enter is pressed in text box
			 * perform the search
			 * @method
			 * @private
			 */
			private function onSearchSubmitted(evt:Event):void
			{
				// TODO: validate here?
				
				// if single value, then automatically submit
				// TODO: if >1 value and all are valid, then submit
				if(searchGroup.numElements == 1){
					equeryFeaturesText(null);
				};
			}
			
			private function equeryFeaturesText(evt:Event):void
			{
				queryFeaturesText();	
			}

			//Added for URL Query			
			public function queryFromURL(value:String, slayerId:int = 0, exprNum:int = 0):void
			{
				//First check if the layer or table is loaded.
				var typeQ:String = "layer";
				if(configSearchText[slayerId].layer){
					queryLayer = configSearchText[slayerId].layer;
				}else if(configSearchText[slayerId].table){
					queryLayer = configSearchText[slayerId].table;
					typeQ = "table";
				}
				
				if (queryLayer && !queryLayer.loaded){
					queryLayer.addEventListener(LayerEvent.LOAD, queryLayer_loadHandler);
					function queryLayer_loadHandler(event:LayerEvent):void
					{
						//queryFromURL(value, slayerId, exprNum);
						callLater(queryFromURL,[value,slayerId,exprNum]);
					}
					return;
				}
				
				if(searchGroup.numElements > 1){
					for(var sgi:Number = searchGroup.numElements - 1; sgi >= 1; sgi--){
						searchGroup.removeElementAt(sgi);
					}
				}
				var v:int;
				var sItemVal:SearchExpValueItem;
				for(v=0; v<configSearchText[slayerId].expr[exprNum].values.length; v++){
					var cfg:Object = configSearchText[slayerId].expr[exprNum].values[v];
					if(v == 0){
						sItemVal = searchGroup.getElementAt(0) as SearchExpValueItem;
						sItemVal.setPrompt = cfg.prompt;
						// set the required property from the config
						sItemVal.isValueRequired = cfg.isValueRequired;
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						sItemVal.changeToTextBox();
					}else{
						sItemVal = new SearchExpValueItem;
						sItemVal.wTemplateWidth = wTemplate.width;
						sItemVal.percentWidth = 100;
						sItemVal.setPrompt = cfg.prompt;						
						sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						sItemVal.addEventListener("valueChanged", onValueChanged);
						sItemVal.addEventListener("submitSearch", onSearchSubmitted);
						sItemVal.addEventListener(FocusEvent.FOCUS_IN, searchGroupItem_focusInHandler);
						searchGroup.addElement(sItemVal);
					}
					if(configSearchText[slayerId].expr[exprNum].values[v].usedomain){
						popCBwithDomain(configSearchText[slayerId].expr[exprNum].values[v].field, sItemVal);
					}else if(configSearchText[slayerId].expr[exprNum].values[v].userlist != ""){
						popCBwithUserList(configSearchText[slayerId].expr[exprNum].values[v].userlist, sItemVal);
					}
				}
				searchBtn.addEventListener(MouseEvent.CLICK, equeryFeaturesText);

				txtLabelText.text = configSearchText[slayerId].expr[exprNum].textlabel;
				cboLayerExpr.dataProvider = new ArrayCollection(configSearchText[slayerId].expr);
				if (configSearchText[slayerId].expr.length == 1){
					boxTextexpr.visible = false;
					boxTextexpr.includeInLayout = false;
				}else{
					boxTextexpr.visible = true;
					boxTextexpr.includeInLayout = true;
				}
				
				//hide infowindow if any
				hideInfoWindow();
				
				executingURLquery = true;
				
				cboLayerText.selectedIndex = slayerId;
				cboLayerExpr.selectedIndex = exprNum;

				sItemVal.textValue = value;
				
				var qFields:Array;
				 if(configSearchText[slayerId].layer){
					zoomScale = configSearchText[slayerId].zoomscale;
					if(configSearchText[slayerId].zoompercent){
						zoomPercent = configSearchText[slayerId].zoompercent;
					}else{ 
						zoomPercent = 1.2;
					}
				} 

				queryExpr = configSearchText[slayerId].expr[exprNum].values[0].expression;
				queryFields = configSearchText[slayerId].fields;
				queryLayerRels = configSearchText[slayerId].relates;
				queryDefExpr = configSearchText[slayerId].defexpr;
	
				var gfields:XMLList;
				sumField = "";
				gridFields = [];
				gridHyperFields = [];
				
				if (queryFields){
					gfields = queryFields.field;
					for each (var fieldXML:XML in gfields){
						if (fieldXML.@gridfield[0]){
							if(fieldXML.@gridfield[0]=="true"){
								if(fieldXML.@sum[0] && fieldXML.@sum[0] == "true"){
									if(fieldXML.@sumlabel[0]){
										lblSum = fieldXML.@sumlabel[0];
									}
									sumField = fieldXML.@name[0];
								}
								var str:String = fieldXML.@name[0] + "~";
								if(fieldXML.@alias[0]){
									if(fieldXML.@alias[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@alias[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@dateformat[0]){
									if(fieldXML.@dateformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@dateformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@currencyformat[0]){
									if(fieldXML.@currencyformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@currencyformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@numberformat[0]){
									if(fieldXML.@numberformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@numberformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@useutc[0]){
									if(fieldXML.@useutc[0] == "false"){
										str += "false~";
									}else{
										str += "true~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@sort[0]){
									if(fieldXML.@sort[0] == ""){
										str += "NA";
									}else{
										str += fieldXML.@sort[0];
									}
								}else{
									str += "NA";
								}
								gridFields.push(str);
							}
						}
						if (fieldXML.@hyperlinkgridfield[0]){
							if (fieldXML.@hyperlinkgridfield[0]=="true"){
								var str2:String = fieldXML.@name[0] + "~";
								if(fieldXML.@alias[0]){
									if(fieldXML.@alias[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@alias[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@hyperlinkaliastext[0]){
									if(fieldXML.@hyperlinkaliastext[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@hyperlinkaliastext[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@linkprefix[0]){
									if(fieldXML.@linkprefix[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@linkprefix[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@linksuffix[0]){
									if(fieldXML.@linksuffix[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@linksuffix[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@hyperlinkgridicon[0]){
									if(fieldXML.@hyperlinkgridicon[0] == ""){
										str2 += "NA";
									}else{
										str2 += fieldXML.@hyperlinkgridicon[0];
									}
								}else{
									str2 += "NA";
								}
								gridHyperFields.push(str2);
							}
						}
					}
				}
				
				queryTitleField = configSearchText[slayerId].titlefield;
				qLinks = configSearchText[slayerId].links;
				queryMultiImgField = configSearchText[slayerId].multi;
				queryAttachments = configSearchText[slayerId].attachments;
				queryEnableExport = configSearchText[slayerId].enableexport;
				var fields:XMLList;
				
				if(configSearchText[slayerId].layer){
					queryLayer = configSearchText[slayerId].layer;
				}else if(configSearchText[slayerId].table){
					queryLayer = configSearchText[slayerId].table;
					typeQ = "table";
				}
				
				if (queryLayer){
					var query:Query = new Query();
					var myPattern:RegExp = /\[value\]/g;
					var expr:String;
					var eVal:String;
					if(queryExpr != "[value]"){//meaning an open SQL expression
						eVal = value.replace("'","''");
					}else{
						eVal = value;
					}
					expr = queryExpr.replace(myPattern, eVal);
					query.where = expr;
					query.outSpatialReference = map.spatialReference;
					if(queryDefExpr != ""){
						queryLayer.definitionExpression = queryDefExpr;
					}
					queryLayer.queryFeatures(query, new AsyncResponder(onResult, onFault, queryFields)); 
					showMessage(loadingLabel, true); 
					showStateResults();     
					
					// on result
					function onResult(featureSet:FeatureSet, token:XMLList = null):void                 
					{   
						try{
							var gid:Number = 0;
							for each (var gra:Graphic in featureSet.features){   
								var obj:Object = gra.attributes;
								if(typeQ == "layer"){
									if(!queryLayer.layerDetails.objectIdField){
										obj["oid"] = gid;
										gid ++;
									}else{
										obj["oid"] = gra.attributes[queryLayer.layerDetails.objectIdField];
									}
								}else{
									if(!queryLayer.tableDetails.objectIdField){
										obj["oid"] = gid;
										gid ++;
									}else{
										obj["oid"] = gra.attributes[queryLayer.tableDetails.objectIdField];
									}
								}
							}
							gridDataProvider = featureSet.attributes;
							resultsFeatureSet = featureSet;
							if(queryLayerRels && queryLayerRels.length > 0){
								searchResultAC = createSearchResults(featureSet, token, queryLayerRels);
							}else{
								searchResultAC = createSearchResults(featureSet, token);
							}
							// share data
							addSharedData(widgetTitle, searchResultAC);
							showMessage(selectionLabel + " " + featureSet.features.length, false);
							msgVisible = true;
							map.cursorManager.removeBusyCursor();
							if(typeQ == "layer"){
								if(isNaN(zoomScale)){
									zoomAll();
								}else{
									if (map.scale > zoomScale){
										map.scale = zoomScale;
									}
									map.centerAt(searchResultAC[0].point);
								}
							}
							if(ViewerContainer.urlConfigParams.showdatagrid != null){
								if(ViewerContainer.urlConfigParams.showdatagrid == "true" && floatorfixed == "float"){
									showGridResults();
								}
							}
							
							if(floatorfixed == "fixed"){
								var dgConfig:Object = {
									widgetTitle: widgetTitle,
									csvExportOptionLbl: exp2csvOptLbl,
									txtExportOptionLbl: exp2txtOptLbl,
									ExportButtonLbl: expBtnLbl,
									csvSeperator: csvSep,
									dgFieldAliases: fldAliases,
									csvName: _csvName,
									sumField: sumField,
									labelSum: lblSum,
									hasRelates: (queryLayerRels && queryLayerRels.length > 0),
									dgColumns: gridFields,
									dgHyperColumns: gridHyperFields,
									dProvider: gridDataProvider,
									graphicslayer: graphicsLayer,
									zoomScale: zoomScale,
									zoomPercent: zoomPercent,
									ownerWidget: sWidget,
									layerDetails: (queryLayer.layerDetails)?queryLayer.layerDetails:queryLayer.tableDetails,
									enableExport: queryEnableExport,
									widgetInteract: widgetAndGridIteract,
									disableRelateTab: disRelatesInFixed
								};
								var dgconfigArr:ArrayCollection = new ArrayCollection();
								dgconfigArr.addItem(dgConfig);
								addSharedData("configFixedDatagrid", dgconfigArr);
							}
							executingURLquery = false;
						}
						catch (error:Error){
							showMessage(error.message, false);
						}
					}
					//on fault
					function onFault(info:Object, token:Object = null) : void
					{      
						showMessage(info.toString(), false);
					}
				}  
			}

			private function sOpBtnClickHandler(event:Event):void
			{
				intersectResults(event.currentTarget.name);
			}
			
			private function getSopImg(value:String):String
			{
				var retVal:String = ""
				switch(value){
					case "esriSpatialRelIntersects":{
						retVal = WIDGET_URL + "i_intersect.png";
						break;
					}
					case "esriSpatialRelContains":{
						retVal = WIDGET_URL + "i_contain.png";
						break;
					}
					case "esriSpatialRelCrosses":{
						retVal = WIDGET_URL + "i_crosses.png";
						break;
					}
					case "esriSpatialRelEnvelopeIntersects":{
						retVal = WIDGET_URL + "i_envintersects.png";
						break;
					}
					case "esriSpatialRelIndexIntersects":{
						retVal = WIDGET_URL + "i_index.png";
						break;
					}
					case "esriSpatialRelOverlaps":{
						retVal = WIDGET_URL + "i_overlaps.png";
						break;
					}
					case "esriSpatialRelTouches":{
						retVal = WIDGET_URL + "i_touches.png";
						break;
					}
					case "esriSpatialRelWithin":{
						retVal = WIDGET_URL + "i_within.png";
						break;
					}
				}
				return retVal;
			}			
			
			private function searchLayerChangedText():void
			{
				if(searchGroup.numElements > 1){
					for(var sgi:Number = searchGroup.numElements - 1; sgi >= 1; sgi--){
						searchGroup.removeElementAt(sgi);
					}
				}
				var v:int;
				var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
				var sItemVal:SearchExpValueItem;
				for(v=0; v<configSearchText[i].expr[0].values.length; v++){
					var cfg = configSearchText[i].expr[0].values[v];
					if(v == 0){
						sItemVal = searchGroup.getElementAt(0) as SearchExpValueItem;
						sItemVal.setPrompt = cfg.prompt;
						sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						sItemVal.changeToTextBox();
					}else{
						sItemVal = new SearchExpValueItem;
						sItemVal.wTemplateWidth = wTemplate.width;
						sItemVal.percentWidth = 100;
						sItemVal.setPrompt = cfg.prompt;
						sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						sItemVal.addEventListener("valueChanged", onValueChanged);
						sItemVal.addEventListener("submitSearch", onSearchSubmitted);
						sItemVal.addEventListener(FocusEvent.FOCUS_IN, searchGroupItem_focusInHandler);
						searchGroup.addElement(sItemVal);
					}
					if(configSearchText[i].expr[0].values[v].usedomain){
						popCBwithDomain(configSearchText[i].expr[0].values[v].field, sItemVal);
					}else if(configSearchText[i].expr[0].values[v].userlist != ""){
						popCBwithUserList(configSearchText[i].expr[0].values[v].userlist, sItemVal); 
					}
				}
				searchBtn.addEventListener(MouseEvent.CLICK, equeryFeaturesText);

				txtLabelText.text = configSearchText[i].expr[0].textlabel;
				cboLayerExpr.dataProvider = new ArrayCollection(configSearchText[i].expr);
				cboLayerExpr.width = determineDropDownWidth(configSearchText[i].expr);
				if((cboLayerExpr.width + lblExprText.measureText(layerExprLabel).width + 57) > wTemplate.width){
					cboLayerExpr.width = (wTemplate.width - (lblExprText.measureText(layerExprLabel).width + 57));
				}
				cboLayerExpr.selectedIndex = 0;
				if (configSearchText[i].expr.length == 1){
					boxTextexpr.visible = false;
					boxTextexpr.includeInLayout = false;
				}else{
					boxTextexpr.visible = true;
					boxTextexpr.includeInLayout = true;
				}
				
				// a new (default) search form is shown for the selected layer
				onSearchFormChanged();
			}
			
			private function searchLayerExprChangedText():void
			{
				var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
				var j:Number = (cboLayerExpr.selectedIndex < 0) ? 0 : cboLayerExpr.selectedIndex;
				if(searchGroup.numElements > 1){
					for(var sgi:Number = searchGroup.numElements - 1; sgi >= 1; sgi--){
						searchGroup.removeElementAt(sgi);
					}
				}
				var sItemVal:SearchExpValueItem;
				for(var v:int=0; v<configSearchText[i].expr[j].values.length; v++){
					var cfg = configSearchText[i].expr[j].values[v];
					if(v == 0){
						sItemVal = searchGroup.getElementAt(0) as SearchExpValueItem;
						sItemVal.setPrompt = cfg.prompt;
						sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						sItemVal.changeToTextBox();
					}else{
						sItemVal = new SearchExpValueItem;
						sItemVal.wTemplateWidth = wTemplate.width;
						sItemVal.percentWidth = 100;
						sItemVal.setPrompt = cfg.prompt;
						sItemVal.isValueRequired = cfg.isValueRequired;// set the required property from the config
						if (cfg.prepend)
						{
							sItemVal.prepend = cfg.prepend;
						};
						sItemVal.addEventListener("valueChanged", onValueChanged);
						sItemVal.addEventListener("submitSearch", onSearchSubmitted);
						sItemVal.addEventListener(FocusEvent.FOCUS_IN, searchGroupItem_focusInHandler);
						searchGroup.addElement(sItemVal);
					}
					if(configSearchText[i].expr[j].values[v].usedomain){
						popCBwithDomain(configSearchText[i].expr[j].values[v].field, sItemVal);
					}else if(configSearchText[i].expr[j].values[v].userlist != ""){
						popCBwithUserList(configSearchText[i].expr[j].values[v].userlist, sItemVal);
					}
				}
				searchBtn.addEventListener(MouseEvent.CLICK, equeryFeaturesText);
				txtLabelText.text = configSearchText[i].expr[j].textlabel;
				
				// new search so validate
				onSearchFormChanged();
			}
			
			private function searchLayerChangedGraphical():void
			{
				var i:Number = (cboLayerGraphical.selectedIndex < 0) ? 0 : cboLayerGraphical.selectedIndex;
				txtLabelGraphical.text = configSearchText[i].graphicallabel;
			}
			
			private function activateSearchTool(event:MouseEvent, lTool:String = ""):void
			{
				addSharedData("Deactivate_DrawTool", null); // to be able to deactivate drawTool on other widgets
				
				if(event){
					graGraphicsLayer.clear();
					selectedDrawingIcon = Image(event.currentTarget);
				}else{
					switch(lTool){
						case DrawTool.EXTENT :{
							selectedDrawingIcon = iSearchExt;
							break;
						}
						case DrawTool.POLYGON :{
							selectedDrawingIcon = iSearchPoly;
							break;
						}
						case DrawTool.MAPPOINT :{
							selectedDrawingIcon = iSearchPnt;
							break;
						}
						case DrawTool.POLYLINE :{
							selectedDrawingIcon = iSearchLine;
							break;
						}
						default:{
							selectedDrawingIcon = iSearchPnt;
						}
					}
				}
				clearSelectionFilter();
				selectedDrawingIcon.filters = [ glowFilter ];
				
				var status:String;
				var value:String = lastTool = selectedDrawingIcon.name;
				switch (value){
					case DrawTool.MAPPOINT:{
						status = pointLabel;
						drawSymbol = new SimpleMarkerSymbol(SimpleMarkerSymbol.STYLE_CIRCLE, 15, 0x3FAFDC, 1);
						break;
					}
					case DrawTool.POLYLINE:{
						status = lineLabel;
						drawSymbol = new SimpleLineSymbol(SimpleLineSymbol.STYLE_SOLID, 0x3FAFDC, 1, 1);
						break;
					}
					case DrawTool.EXTENT:{
						status = rectangleLabel;
						drawSymbol = new SimpleFillSymbol(SimpleFillSymbol.STYLE_SOLID, 0x3FAFDC, 0.5, new SimpleLineSymbol(SimpleLineSymbol.STYLE_SOLID, 0x3FAFDC, 1, 1));
						break;
					}
					case DrawTool.POLYGON:{
						status = polygonLabel;
						drawSymbol = new SimpleFillSymbol(SimpleFillSymbol.STYLE_SOLID, 0x3FAFDC, 0.5, new SimpleLineSymbol(SimpleLineSymbol.STYLE_SOLID, 0x3FAFDC, 1, 1));
						break;
					}
				}
				setMapAction(value, status, drawSymbol, searchDrawEnd);
			}			
			
			private function searchDrawEnd(event:DrawEvent):void
			{
				activateSearchTool(null,lastTool);
				var geom:Geometry = event.graphic.geometry;
				var graGraphic:Graphic = new Graphic(geom, drawSymbol);
				graGraphicsLayer.add(graGraphic);
				if(!graMultiChk.selected){
					queryFeaturesGra();
				}
			}
			
			private function graMultiChanged():void
			{
				(graMultiChk.selected) ? graFeatureQueryBtn.visible = true : graFeatureQueryBtn.visible = false;
			}
			
			private function unionGeoms2(gl:GraphicsLayer):Geometry
			{
				var retGeom:Geometry;
				var mPoint:Multipoint = new Multipoint(null);
				mPoint.spatialReference = map.spatialReference;
				var mPoly:Polygon = new Polygon(null);
				mPoly.spatialReference = map.spatialReference;
				var mPolyL:Polyline = new Polyline(null);
				mPolyL.spatialReference = map.spatialReference;
				var rType:String;
				for each (var graphic:Graphic in gl.graphicProvider){
					if(graphic.geometry.type == "esriGeometryPoint" && !addTolerance.selected){
						mPoint.addPoint(graphic.geometry as MapPoint);
						rType = "point";
					}else if (graphic.geometry.type == "esriGeometryPoint" && addTolerance.selected){
						var ext2:Extent = createExtentAroundMapPoint(graphic.geometry as MapPoint, pointSearchTolerance) as Extent;
						var pA2:Array = [];
						pA2.push(new MapPoint(ext2.xmin,ext2.ymin,ext2.spatialReference));
						pA2.push(new MapPoint(ext2.xmin,ext2.ymax,ext2.spatialReference));
						pA2.push(new MapPoint(ext2.xmax,ext2.ymax,ext2.spatialReference));
						pA2.push(new MapPoint(ext2.xmax,ext2.ymin,ext2.spatialReference));
						pA2.push(new MapPoint(ext2.xmin,ext2.ymin,ext2.spatialReference));
						mPoly.addRing(pA2);
						rType = "poly";
						mPoly.spatialReference = ext2.spatialReference;
					}
					
					if(graphic.geometry.type == "esriGeometryMultipoint"){
						var mp:Multipoint = graphic.geometry as Multipoint
						var pnts:MapPoint;
						for (var p:int=0;p < mp.points.length; p++){
							mPoint.addPoint(mp.points[p]);
						}
						rType = "point";
					}
					
					if(graphic.geometry.type == "esriGeometryPolygon"){
						var poly:Polygon = graphic.geometry as Polygon;
						for (var i2:int = poly.rings.length - 1; i2 >= 0; i2--){
							var ringArray:Array = [];
							for (var j1:int = 0; j1 < poly.rings[i2].length; j1++){
								var mp2:MapPoint = poly.getPoint(i2,j1) as MapPoint;
								mp2.spatialReference = poly.spatialReference;
								ringArray.push(mp2);
							}
							mPoly.addRing(ringArray);
						}
						rType = "poly";
						mPoly.spatialReference = poly.spatialReference;
					}
					
					if(graphic.geometry.type == "esriGeometryPolyline"){
						var polyl:Polyline = graphic.geometry as Polyline;
						for(var l:int=polyl.paths.length-1; l >= 0; l--){
							var pathArray:Array = [];
							for (var j2:int = 0; j2 < polyl.paths[l].length; j2++){
								var mp3:MapPoint = polyl.getPoint(l,j2) as MapPoint;
								mp3.spatialReference = polyl.spatialReference;
								pathArray.push(mp3);
							}
							mPolyL.addPath(pathArray);
						}
						rType = "line";
					}
					
					if(graphic.geometry.type == "esriGeometryEnvelope"){
						var ext:Extent = graphic.geometry as Extent;
						var pA:Array = [];
						pA.push(new MapPoint(ext.xmin,ext.ymin,ext.spatialReference));
						pA.push(new MapPoint(ext.xmin,ext.ymax,ext.spatialReference));
						pA.push(new MapPoint(ext.xmax,ext.ymax,ext.spatialReference));
						pA.push(new MapPoint(ext.xmax,ext.ymin,ext.spatialReference));
						pA.push(new MapPoint(ext.xmin,ext.ymin,ext.spatialReference));
						mPoly.addRing(pA);
						rType = "poly";
					}
				}
				
				switch(rType){
					case "point":{
						retGeom = mPoint;
						break;
					}
					case "poly":{
						retGeom = mPoly;
						break;
					}
					case "line":{
						retGeom = mPolyL;
						break;
					}
				}
				return retGeom;
			}
			
			private function queryFeaturesGra():void
			{
				if(keepGraSearchEnabled == false){
					addSharedData("Deactivate_DrawTool", null); // to be able to deactivate drawTool on other widgets
				}
				var geom:Geometry
				var graLayAC:ArrayCollection = graGraphicsLayer.graphicProvider as ArrayCollection;
				if (graLayAC.length > 1){
					 geom = unionGeoms2(graGraphicsLayer);
				}else if (graLayAC.length == 1){
					geom = (graLayAC[0] as Graphic).geometry;
				}else{
					return;
				}
				if(keepGraSearchEnabled == false){
					selectedDrawingIcon = null;
					clearSelectionFilter();
				}
				clearBuffer();
				if (geom is Polygon && GeometryUtil.polygonSelfIntersecting(geom as Polygon)){
					geometryService.simplify([geom], new AsyncResponder(simpResult, null));
					function simpResult(item:Object ,spatialRelat:String):void{
						var simpGeoms:Array = item as Array;
						if(bufferUserGraphic.selected){
							applyBuffer(true);
						}else{
							queryFeaturesGraphical(simpGeoms[0] as Polygon, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex < 0)?0:cboLayerGraphical.selectedIndex]);
						}
					}
				}else{
					//create extent around map point to improve search results
					if (geom.type == Geometry.MAPPOINT && addTolerance.selected){
						geom = createExtentAroundMapPoint(geom as MapPoint, pointSearchTolerance);
					}
					if(bufferUserGraphic.selected){
						applyBuffer(true);
					}else{
						queryFeaturesGraphical(geom, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex < 0)?0:cboLayerGraphical.selectedIndex]);
					}
				}
				graGraphicsLayer.clear();
			}
			
			private function createExtentAroundMapPoint(centerPoint:MapPoint, tolerance:Number):Extent
			{
				var screenPoint:Point = map.toScreen(centerPoint as MapPoint);
				
				var upperLeftScreenPoint:Point = new Point(screenPoint.x - tolerance, screenPoint.y - tolerance);
				var lowerRightScreenPoint:Point = new Point(screenPoint.x + tolerance, screenPoint.y + tolerance);
				
				var upperLeftMapPoint:MapPoint = map.toMap(upperLeftScreenPoint);
				var lowerRightMapPoint:MapPoint = map.toMap(lowerRightScreenPoint);
				
				return new Extent(upperLeftMapPoint.x, upperLeftMapPoint.y, lowerRightMapPoint.x, lowerRightMapPoint.y, map.spatialReference);
			}
			
			//query features text
			private function queryFeaturesText():void
			{
				//hide infowindow if any
				hideInfoWindow();
				var typeQ:String = "layer";
				var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
				
				if(configSearchText[i].layer){
					queryLayer = configSearchText[i].layer;
				}else if(configSearchText[i].table){
					queryLayer = configSearchText[i].table;
					typeQ = "table";
				}
				if (queryLayer && !queryLayer.loaded){
					queryLayer.addEventListener(LayerEvent.LOAD, queryLayer_loadHandler);
					function queryLayer_loadHandler(event:LayerEvent):void
					{
						queryFeaturesText()
					}
					return;
				}
				
				var oidFld:String;
				if(queryLayer.layerDetails){
					oidFld = queryLayer.layerDetails.objectIdField;
				}else{
					oidFld = queryLayer.tableDetails.objectIdField;
				}
				var qFields:Array;
				zoomScale = configSearchText[i].zoomscale;
				zoomPercent = configSearchText[i].zoompercent;
				queryLayer = (typeQ == "layer") ? configSearchText[i].layer : configSearchText[i].table;
				var j:Number = (cboLayerExpr.selectedIndex < 0) ? 0 : cboLayerExpr.selectedIndex;
				queryFields = configSearchText[i].fields;
				queryDefExpr = configSearchText[i].defexpr;
				queryLayerRels = configSearchText[i].relates;
				var gfields:XMLList;
				sumField = "";
				gridFields = [];
				gridHyperFields = [];
				if (queryFields){
					gfields = queryFields.field;
					for each (var fieldXML:XML in gfields){
						if (fieldXML.@gridfield[0]){
							if(fieldXML.@gridfield[0]=="true"){
								if(fieldXML.@sum[0] && fieldXML.@sum[0] == "true"){
									if(fieldXML.@sumlabel[0]){
										lblSum = fieldXML.@sumlabel[0];
									}
									sumField = fieldXML.@name[0];
								}
								var str:String = fieldXML.@name[0] + "~";
								if(fieldXML.@alias[0]){
									if(fieldXML.@alias[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@alias[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@dateformat[0]){
									if(fieldXML.@dateformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@dateformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@currencyformat[0]){
									if(fieldXML.@currencyformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@currencyformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@numberformat[0]){
									if(fieldXML.@numberformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@numberformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@useutc[0]){
									if(fieldXML.@useutc[0] == "false"){
										str += "false~";
									}else{
										str += "true~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@sort[0]){
									if(fieldXML.@sort[0] == ""){
										str += "NA";
									}else{
										str += fieldXML.@sort[0];
									}
								}else{
									str += "NA";
								}
								gridFields.push(str);
							}
						}
						if (fieldXML.@hyperlinkgridfield[0]){
							if (fieldXML.@hyperlinkgridfield[0]=="true"){
								var str2:String = fieldXML.@name[0] + "~";
								if(fieldXML.@alias[0]){
									if(fieldXML.@alias[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@alias[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@hyperlinkaliastext[0]){
									if(fieldXML.@hyperlinkaliastext[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@hyperlinkaliastext[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@linkprefix[0]){
									if(fieldXML.@linkprefix[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@linkprefix[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@linksuffix[0]){
									if(fieldXML.@linksuffix[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@linksuffix[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@hyperlinkgridicon[0]){
									if(fieldXML.@hyperlinkgridicon[0] == ""){
										str2 += "NA";
									}else{
										str2 += fieldXML.@hyperlinkgridicon[0];
									}
								}else{
									str2 += "NA";
								}
								gridHyperFields.push(str2);
							}
						}
					}
				}
				
				queryTitleField = configSearchText[i].titlefield;
				qLinks = configSearchText[i].links;
				queryMultiImgField = configSearchText[i].multi;
				queryAttachments = configSearchText[i].attachments;
				queryEnableExport = configSearchText[i].enableexport;
				openDataGrid = configSearchText[i].opendg;
				//var isAllInputsfilled:Boolean;
				var sItemVal:SearchExpValueItem;
				/* if(searchGroup.numElements > 1){
					isAllInputsfilled = true;
					for(var sgi:Number = 0; sgi < searchGroup.numElements; sgi++){
						sItemVal = searchGroup.getElementAt(sgi) as SearchExpValueItem;
						if(sItemVal.textValue == ""){
							isAllInputsfilled = false;
							break;
						}
					}
				}else{
					sItemVal = searchGroup.getElementAt(0) as SearchExpValueItem;
					isAllInputsfilled = (sItemVal.textValue !="")?true:false;
				} */
				
				var fields:XMLList;
				//if ((queryLayer) && (isAllInputsfilled))
				if(queryLayer){
					var query:Query = new Query();
					var myPattern:RegExp = /\[value\]/g;
					var expr:String = "";
					var eVal:String = "";
					
					for(var sg:Number = 0; sg < searchGroup.numElements; sg++){
						sItemVal = searchGroup.getElementAt(sg) as SearchExpValueItem;
						queryExpr = configSearchText[i].expr[j].values[sg].expression;
						
						if(queryExpr != "[value]"){//meaning an open SQL expression
							eVal = sItemVal.textValue.replace("'","''");
						}else{
							eVal = sItemVal.textValue;
						}
						
						if (sItemVal.isValueRequired && !sItemVal.hasAValue())
						{
							// no value specified so skip this part of where clause
							continue;
						};
						
						if(sItemVal.textValue.toLowerCase() == "all" && !sItemVal.isTextBox()){
							var mExpr:String = queryExpr.replace("=", "IN(") + ")";
							var uList:String = configSearchText[i].expr[j].values[sg].userlist;
							uList = uList.replace(",all", "");
							uList = uList.replace(",ALL", "");
							var uaList:Array = uList.split(",");
							
							if(mExpr.indexOf("'[value]'") > -1){
								uList = uaList.join("','");
							}
							var criteriaFromValue:String = mExpr.replace(myPattern, uList);
							expr = AppendTo(expr, criteriaFromValue, sItemVal.prepend);
						}
						else
						{
							//don't add the expression if there is no user input
							if(eVal != ""){
								var criteriaFromValue:String = queryExpr.replace(myPattern, eVal);
								expr = AppendTo(expr, criteriaFromValue, sItemVal.prepend);
							};
						}
					}
					
					query.where = expr;
					query.outSpatialReference = map.spatialReference;
					if(queryDefExpr != ""){
						queryLayer.definitionExpression = queryDefExpr; 
					}
					queryLayer.queryFeatures(query, new AsyncResponder(onResult, onFault, queryFields));

					showMessage(loadingLabel, true); 
					showStateResults();   
					// on result
					function onResult(featureSet:FeatureSet, token:XMLList = null):void                
					{   
						try{ 
							var gid:Number = 0;
							for each (var gra:Graphic in featureSet.features){   
								var obj:Object = gra.attributes;
								if(typeQ == "layer"){
									if(!queryLayer.layerDetails.objectIdField){
										obj["oid"] = gid;
										gid ++;
									}else{
										obj["oid"] = gra.attributes[queryLayer.layerDetails.objectIdField];
									}
								}else{
									if(!queryLayer.tableDetails.objectIdField){
										obj["oid"] = gid;
										gid ++;
									}else{
										obj["oid"] = gra.attributes[queryLayer.tableDetails.objectIdField];
									}
								}
							}
							gridDataProvider = featureSet.attributes;
							resultsFeatureSet = featureSet;
							if(queryLayerRels && queryLayerRels.length > 0){
								searchResultAC = createSearchResults(featureSet, token, queryLayerRels);
							}else{
								searchResultAC = createSearchResults(featureSet, token);
							}
							// share data
							addSharedData(widgetTitle, searchResultAC);
							showMessage(selectionLabel + " " + featureSet.features.length, false);
							if(floatorfixed == "float"){
								if (myfloatdg){
									if(myfloatdg.datagrid.dataProvider){
										myfloatdg.datagrid.dataProvider.removeAll();
									}
									myfloatdg.csvExportOptionLbl = exp2csvOptLbl;
									myfloatdg.txtExportOptionLbl = exp2txtOptLbl;
									myfloatdg.ExportButtonLbl = expBtnLbl;
									myfloatdg.csvSeperator = csvSep;
									myfloatdg.dgFieldAliases = fldAliases;
									myfloatdg.csvName = _csvName;
									myfloatdg.sumField = sumField;
									myfloatdg.labelSum = lblSum;
									myfloatdg.hasRelates = (queryLayerRels && queryLayerRels.length > 0);
									myfloatdg.RelateIcon = relateIcon;
									myfloatdg.RelateToolTip = relateToolTip;
									myfloatdg.dgColumns = gridFields;
									myfloatdg.dgHyperColumns = gridHyperFields;
									myfloatdg.dProvider = gridDataProvider;
									myfloatdg.graphicslayer = graphicsLayer;
									myfloatdg.zoomScale = zoomScale;
									myfloatdg.zoomPercent = zoomPercent;
									myfloatdg.ownerWidget = sWidget;
									myfloatdg.featLayer = queryLayer;
									myfloatdg.layerDetails = (queryLayer.layerDetails)?queryLayer.layerDetails:queryLayer.tableDetails;
									myfloatdg.enableExport = queryEnableExport;
									myfloatdg.widgetInteract = widgetAndGridIteract;
								}
							}else if(floatorfixed == "fixed"){
								if(!gridFields){
									gridFields = configSearchText[i].gridfields;
								}
								var dgConfig:Object = {
									widgetTitle: widgetTitle,
									csvExportOptionLbl: exp2csvOptLbl,
									txtExportOptionLbl: exp2txtOptLbl,
									ExportButtonLbl: expBtnLbl,
									csvSeperator: csvSep,
									dgFieldAliases: fldAliases,
									csvName: _csvName,
									sumField: sumField,
									labelSum: lblSum,
									hasRelates: (queryLayerRels && queryLayerRels.length > 0),
									dgColumns: gridFields,
									dgHyperColumns: gridHyperFields,
									dProvider: gridDataProvider,
									graphicslayer: graphicsLayer,
									zoomScale: zoomScale,
									zoomPercent: zoomPercent,
									ownerWidget: sWidget,
									featLayer: queryLayer,
									layerDetails: (queryLayer.layerDetails)?queryLayer.layerDetails:queryLayer.tableDetails,
									enableExport: queryEnableExport,
									widgetInteract: widgetAndGridIteract,
									disableRelateTab: disRelatesInFixed,
									relateIcon: relateIcon,
									relateToolTip: relateToolTip
								};
								var dgconfigArr:ArrayCollection = new ArrayCollection();
								dgconfigArr.addItem(dgConfig);
								addSharedData("configFixedDatagrid", dgconfigArr);
							}
							
							if (openDataGrid && floatorfixed != "fixed"){
								showGridResults(); 
							}
							if(autoZoom && searchResultAC.length > 0){
								if(typeQ == "layer"){
									if(searchResultAC.length == 1){
										if (map.scale > zoomScale){
											map.scale = zoomScale;
										}
										map.centerAt(searchResultAC[0].point);
									}else{
										zoomAll();
									}
								}
							}
						}
						catch (error:Error){
							showMessage(error.message, false);
						}
					}
					
					//on fault
					function onFault(info:Object, token:Object = null) : void
					{                    
						showMessage(info.toString(), false);         
					}
				}  
			}				
			/*
			 * Append string2 to string1 (if set) using conjunction 
			 * @param String string1 the first string
		     * @param String string2 the 2nd string
			 * @param String conjunction string to put between the strings
			 * @returns String
			 */
		   private function AppendTo(string1:String, string2:String, conjunction:String = "AND"): String 
		   {
			   var combined:String = "";
			   if (string1.length > 0)
			   {
				   return string1 + " " + conjunction + " " + string2;
			   }
			   else
			   {
			   	 return string2;
			   };
		   }
			
			//query features graphical
			private function queryFeaturesGraphical(geom:Geometry, querySpatialRel:String, layerConfig:Object):void
			{
				//hide infowindow if any
				hideInfoWindow();
				
				var qFields:Array;
				queryLayer = layerConfig.layer;
				
				var oidFld:String;
				if(queryLayer.layerDetails){
					oidFld = queryLayer.layerDetails.objectIdField;
				}
				queryGeom = geom;
				zoomScale = layerConfig.zoomscale;
				zoomPercent = layerConfig.zoompercent;
				queryFields = layerConfig.fields;
				queryExpr = layerConfig.expr;
				var gfields:XMLList;
				gridFields = [];
				gridHyperFields = [];
				sumField = "";
				if (queryFields){
					gfields = queryFields.field;
					for each (var fieldXML:XML in gfields){
						if (fieldXML.@gridfield[0]){
							if(fieldXML.@gridfield[0]=="true"){
								if(fieldXML.@sum[0] && fieldXML.@sum[0] == "true"){
									if(fieldXML.@sumlabel[0]){
										lblSum = fieldXML.@sumlabel[0];
									}
									sumField = fieldXML.@name[0];
								}
								var str:String = fieldXML.@name[0] + "~";
								if(fieldXML.@alias[0]){
									if(fieldXML.@alias[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@alias[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@dateformat[0]){
									if(fieldXML.@dateformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@dateformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@currencyformat[0]){
									if(fieldXML.@currencyformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@currencyformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@numberformat[0]){
									if(fieldXML.@numberformat[0] == ""){
										str += "NA~";
									}else{
										str += fieldXML.@numberformat[0] + "~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@useutc[0]){
									if(fieldXML.@useutc[0] == "false"){
										str += "false~";
									}else{
										str += "true~";
									}
								}else{
									str += "NA~";
								}
								if(fieldXML.@sort[0]){
									if(fieldXML.@sort[0] == ""){
										str += "NA";
									}else{
										str += fieldXML.@sort[0];
									}
								}else{
									str += "NA";
								}
								gridFields.push(str);
							}
						}
						if (fieldXML.@hyperlinkgridfield[0]){
							if (fieldXML.@hyperlinkgridfield[0]=="true"){
								var str2:String = fieldXML.@name[0] + "~";
								if(fieldXML.@alias[0]){
									if(fieldXML.@alias[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@alias[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@hyperlinkaliastext[0]){
									if(fieldXML.@hyperlinkaliastext[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@hyperlinkaliastext[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@linkprefix[0]){
									if(fieldXML.@linkprefix[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@linkprefix[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@linksuffix[0]){
									if(fieldXML.@linksuffix[0] == ""){
										str2 += "NA~";
									}else{
										str2 += fieldXML.@linksuffix[0] + "~";
									}
								}else{
									str2 += "NA~";
								}
								if(fieldXML.@hyperlinkgridicon[0]){
									if(fieldXML.@hyperlinkgridicon[0] == ""){
										str2 += "NA";
									}else{
										str2 += fieldXML.@hyperlinkgridicon[0];
									}
								}else{
									str2 += "NA";
								}
								gridHyperFields.push(str2);
							}
						}
					}
				}
				queryTitleField = layerConfig.titlefield;
				qLinks = layerConfig.links;

				queryMultiImgField = layerConfig.multi;
				queryAttachments = layerConfig.attachments;
				queryExprForSpatRel = layerConfig.useforspatial;
				queryEnableExport = layerConfig.enableexport;
				queryDefExpr = layerConfig.defexpr;
				openDataGrid = layerConfig.opendg;
				queryLayerRels = layerConfig.relates;
				
				var fields:XMLList;
				if (queryLayer){
					var query:Query = new Query();
					query.geometry = queryGeom;
					if(includeTextQuery.selected && includeTextQuery.enabled){
						var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
						var j:Number = (cboLayerExpr.selectedIndex < 0) ? 0 : cboLayerExpr.selectedIndex;
						//var isAllInputsfilled:Boolean;
						var sItemVal:SearchExpValueItem;
						/* if(searchGroup.numElements > 1){
							isAllInputsfilled = true;
							for(var sgi:Number = 0; sgi < searchGroup.numElements; sgi++){
								sItemVal = searchGroup.getElementAt(sgi) as SearchExpValueItem;
								if(sItemVal.textValue == ""){
									isAllInputsfilled = false;
									break;
								}
							}
						}else{
							sItemVal = searchGroup.getElementAt(0) as SearchExpValueItem;
							isAllInputsfilled = (sItemVal.textValue !="")?true:false;
						} */
						
						var myPattern:RegExp = /\[value\]/g;
						var expr:String = "";
						var eVal:String = "";
						
						for(var sg:Number = 0; sg < searchGroup.numElements; sg++){
							sItemVal = searchGroup.getElementAt(sg) as SearchExpValueItem;
							queryExpr = configSearchText[i].expr[j].values[sg].expression;
							
							if(queryExpr != "[value]"){//meaning an open SQL expression
								eVal = sItemVal.textValue.replace("'","''");
							}else{
								eVal = sItemVal.textValue;
							}
							if(sItemVal.textValue.toLowerCase() == "all" && !sItemVal.isTextBox()){
								var mExpr:String = queryExpr.replace("=", "IN(") + ")";
								var uList:String = configSearchText[i].expr[j].values[sg].userlist;
								uList = uList.replace(",all", "");
								uList = uList.replace(",ALL", "");
								if(mExpr.indexOf("'[value]'") > -1){
									uList = uList.replace(",", "','");
								}
								expr += mExpr.replace(myPattern, uList);
							}else{
								if(eVal != ""){
									//don't add the expression if there is no user input
									expr += queryExpr.replace(myPattern, eVal);
								}
							}
						}
						query.where = expr;
					}
					query.returnGeometry = true;
					query.spatialRelationship = querySpatialRel;
					query.outSpatialReference = map.spatialReference;
					if(queryDefExpr != ""){
						queryLayer.definitionExpression = queryDefExpr;
					}
					queryLayer.queryFeatures(query, new AsyncResponder(onResult, onFault, queryFields));
					showMessage(loadingLabel, true); 
					showStateResults();   
					// on result
					function onResult(featureSet:FeatureSet, token:XMLList = null):void
					{   
						try{
							var gid:Number = 0;
							for each (var gra:Graphic in featureSet.features){   
								var obj:Object = gra.attributes;
								if(!queryLayer.layerDetails.objectIdField){
									obj["oid"] = gid;
									gid ++;
								}else{
									obj["oid"] = gra.attributes[queryLayer.layerDetails.objectIdField];
								}
							}
							gridDataProvider = featureSet.attributes;
							resultsFeatureSet = featureSet;
							if(queryLayerRels && queryLayerRels.length > 0){
								searchResultAC = createSearchResults(featureSet, token, queryLayerRels);
							}else{
								searchResultAC = createSearchResults(featureSet, token);
							}
							showMessage(selectionLabel + " " + featureSet.features.length, false);
							if(floatorfixed == "float"){
								if (myfloatdg){
									if(myfloatdg.datagrid.dataProvider){
										myfloatdg.datagrid.dataProvider.removeAll();
									}
									myfloatdg.RelateIcon = relateIcon;
									myfloatdg.RelateToolTip = relateToolTip;
									myfloatdg.csvExportOptionLbl = exp2csvOptLbl;
									myfloatdg.txtExportOptionLbl = exp2txtOptLbl;
									myfloatdg.ExportButtonLbl = expBtnLbl;
									myfloatdg.csvSeperator = csvSep;
									myfloatdg.dgFieldAliases = fldAliases;
									myfloatdg.csvName = _csvName;
									myfloatdg.sumField = sumField;
									myfloatdg.labelSum = lblSum;
									myfloatdg.hasRelates = (queryLayerRels && queryLayerRels.length > 0);
									myfloatdg.dgColumns = gridFields;
									myfloatdg.dgHyperColumns = gridHyperFields;
									myfloatdg.dProvider = gridDataProvider;
									myfloatdg.graphicslayer = graphicsLayer;
									myfloatdg.zoomScale = zoomScale;
									myfloatdg.zoomPercent = zoomPercent;
									myfloatdg.ownerWidget = sWidget;
									myfloatdg.layerDetails = queryLayer.layerDetails;
									myfloatdg.featLayer = queryLayer;
									myfloatdg.enableExport = queryEnableExport;
									myfloatdg.widgetInteract = widgetAndGridIteract;
								}
								if (openDataGrid && floatorfixed != "fixed"){
									showGridResults();
								}
								if(autoZoom && searchResultAC.length > 0){
									if(searchResultAC.length == 1){
										if (map.scale > zoomScale){
											map.scale = zoomScale;
										}
										map.centerAt(searchResultAC[0].point);
									}else{
										zoomAll();
									}
								}
							}else if(floatorfixed == "fixed"){
								var dgConfig:Object = {
									widgetTitle: widgetTitle,
									csvExportOptionLbl: exp2csvOptLbl,
									txtExportOptionLbl: exp2txtOptLbl,
									ExportButtonLbl: expBtnLbl,
									csvSeperator: csvSep,
									dgFieldAliases: fldAliases,
									csvName: _csvName,
									sumField: sumField,
									labelSum: lblSum,
									hasRelates: (queryLayerRels && queryLayerRels.length > 0),
									dgColumns: gridFields,
									dgHyperColumns: gridHyperFields,
									dProvider: gridDataProvider,
									graphicslayer: graphicsLayer,
									zoomScale: zoomScale,
									zoomPercent: zoomPercent,
									ownerWidget: sWidget,
									featLayer: queryLayer,
									layerDetails: (queryLayer.layerDetails)?queryLayer.layerDetails:queryLayer.tableDetails,
									enableExport: queryEnableExport,
									widgetInteract: widgetAndGridIteract,
									disableRelateTab: disRelatesInFixed,
									relateIcon: relateIcon,
									relateToolTip: relateToolTip
								};
								var dgconfigArr:ArrayCollection = new ArrayCollection();
								dgconfigArr.addItem(dgConfig);
								addSharedData("configFixedDatagrid", dgconfigArr);
								if(autoZoom && searchResultAC.length > 0){
									if(searchResultAC.length == 1){
										if (map.scale > zoomScale){
											map.scale = zoomScale;
										}
										map.centerAt(searchResultAC[0].point);
									}else{
										zoomAll();
									}
								}
							}
						}
						catch (error:Error){
							showMessage(error.message, false);
						}	
					}
					
					//on fault
					function onFault(info:Object, token:Object = null) : void
					{                    
						showMessage(info.toString(), false);         
					}
				}
			}
			
			private function unionGeoms(featureSet:FeatureSet):Geometry
			{
				var graphic:Graphic;
				var retGeom:Geometry;
				var mPoint:Multipoint = new Multipoint(null);
				var mPoly:Polygon = new Polygon(null);
				var mPolyL:Polyline = new Polyline(null);
				var rType:String;
				for each (graphic in featureSet.features){
					if(graphic.geometry.type == "esriGeometryPoint"){
						mPoint.addPoint(graphic.geometry as MapPoint);
						rType = "point";
					}
					
					if(graphic.geometry.type == "esriGeometryMultipoint"){
						var mp:Multipoint = graphic.geometry as Multipoint
						var pnts:MapPoint;
						for (var p:int=0;p < mp.points.length; p++){
							mPoint.addPoint(mp.points[p]);
						}
						rType = "point";
					}
					
					if(graphic.geometry.type == "esriGeometryPolygon"){
						var poly:Polygon = graphic.geometry as Polygon;
						for (var i2:int = poly.rings.length - 1; i2 >= 0; i2--){
							var ringArray:Array = [];
							for (var j1:int = 0; j1 < poly.rings[i2].length; j1++){
								var mp2:MapPoint = poly.getPoint(i2,j1) as MapPoint;
								mp2.spatialReference = poly.spatialReference;
								ringArray.push(mp2);
							}
							mPoly.addRing(ringArray);
						}
						rType = "poly";
						mPoly.spatialReference = poly.spatialReference;
					}
					
					if(graphic.geometry.type == "esriGeometryPolyline"){
						var polyl:Polyline = graphic.geometry as Polyline;
						for(var l:int=polyl.paths.length-1; l >= 0; l--){
							var pathArray:Array = [];
							for (var j2:int = 0; j2 < polyl.paths[l].length; j2++){
								var mp3:MapPoint = polyl.getPoint(l,j2) as MapPoint;
								mp3.spatialReference = polyl.spatialReference;
								pathArray.push(mp3);
							}
							mPolyL.addPath(pathArray);
						}
						rType = "line";
					}
					
					if(graphic.geometry.type == "esriGeometryEnvelope"){
						var ext:Extent = graphic.geometry as Extent;
						var pA:Array = [];
						pA.push(new MapPoint(ext.xmin,ext.ymin,ext.spatialReference));
						pA.push(new MapPoint(ext.xmin,ext.ymax,ext.spatialReference));
						pA.push(new MapPoint(ext.xmax,ext.ymax,ext.spatialReference));
						pA.push(new MapPoint(ext.xmax,ext.ymin,ext.spatialReference));
						pA.push(new MapPoint(ext.xmin,ext.ymin,ext.spatialReference));
						mPoly.addRing(pA);
						rType = "poly";
					}
				}
				var graphic2:Graphic = new Graphic();
				var sfs:SimpleFillSymbol = new SimpleFillSymbol();
				sfs.color = 0x0000FF;
				sfs.alpha = 0.2;
				var sms:SimpleMarkerSymbol = new SimpleMarkerSymbol();
				sms.color = 0x0000FF;
				sms.style = SimpleMarkerSymbol.STYLE_CIRCLE;
				sms.size = 8;
				sfs.alpha = 0.4;
				var sls:SimpleLineSymbol = new SimpleLineSymbol();
				sls.color = 0x0000FF;
				sls.style = SimpleLineSymbol.STYLE_SOLID;
				sls.width = 1;
				sls.alpha = 0.4;
				
				switch(rType){
					case "point":{
						graphic2.geometry = mPoint;
						graphic2.symbol = sms;
						graphicsLayerBuffer.clear();
						graphicsLayerBuffer.add(graphic2);
						retGeom = mPoint;
						break;
					}
					case "poly":{
						graphic2.geometry = mPoly;
						graphic2.symbol = sfs;
						graphicsLayerBuffer.clear();
						graphicsLayerBuffer.add(graphic2);
						retGeom = mPoly;
						break;
					}
					case "line":{
						graphic2.geometry = mPolyL;
						graphic2.symbol = sls;
						graphicsLayerBuffer.clear();
						graphicsLayerBuffer.add(graphic2);
						retGeom = mPolyL;
						break;
					}
				}
				return retGeom;
			}
			
			private function applyBuffer(isGraphicalBufferOp:Boolean=false):void
			{
				var graLayAC:ArrayCollection;
				if(isGraphicalBufferOp){
					graLayAC = graGraphicsLayer.graphicProvider as ArrayCollection;
				}else{
					graLayAC = graphicsLayer.graphicProvider as ArrayCollection;
				}
				if (graLayAC.length > 0){
					geomArr = [];
					var buffUnit:Number;
					
					if(isGraphicalBufferOp){
						for each (var graphic:Graphic in graGraphicsLayer.graphicProvider){
							geomArr.push(graphic.geometry);
						}
						buffUnit = GeometryService[configBufferUnits[(cboGraBufferUnit.selectedIndex < 0)?0:cboGraBufferUnit.selectedIndex].name];
						bufferGeometries(geomArr,sReff,[textGraInputBuffer.text],buffUnit,isGraphicalBufferOp);
					}else{
						for each (var graphic2:Graphic in graphicsLayer.graphicProvider){
							geomArr.push(graphic2.geometry);
						}
						buffUnit = GeometryService[configBufferUnits[(cboBufferUnit.selectedIndex < 0)?0:cboBufferUnit.selectedIndex].name];
						bufferGeometries(geomArr,sReff,[textInputBuffer.text],buffUnit,isGraphicalBufferOp);
					}
				}else{
					showStateResults();
					showMessage("There is no result to buffer, please make a graphical or text search first.",false);
				}
			}
			
			private function bufferGeometries(geomArr:Array, sr:SpatialReference, dist:Array, unit:Number, isGraphicalBufferOp:Boolean=false):void
			{
				if (geomArr){
					var bufferParameters:BufferParameters = new BufferParameters();
					var resultEvent:Polygon = new Polygon;
					bufferParameters.geometries = geomArr;
					bufferParameters.bufferSpatialReference = sr;
					bufferParameters.unit = unit;
					bufferParameters.distances = dist;
					bufferParameters.unionResults = true;
					geometryService.addEventListener(GeometryServiceEvent.BUFFER_COMPLETE, bufferCompleteHandler);
					geometryService.buffer(bufferParameters);
					
					function bufferCompleteHandler(event:GeometryServiceEvent):void
					{
						geometryService.removeEventListener(GeometryServiceEvent.BUFFER_COMPLETE, bufferCompleteHandler);
						resultEvent = event.result[0];
						try{
							var graphic:Graphic = new Graphic();
							var sfs:SimpleFillSymbol = new SimpleFillSymbol();
							var sls:SimpleLineSymbol = new SimpleLineSymbol();
							
							if(isGraphicalBufferOp){
								if(chkNoBufferFill){
									sfs.style = (chkNoBufferFill.selected) ? SimpleFillSymbol.STYLE_NULL : SimpleFillSymbol.STYLE_SOLID;
								}else{
									SimpleFillSymbol.STYLE_SOLID;
								}
								if(chkNoBufferOutline){
									sls.style = (chkNoBufferOutline.selected)? SimpleLineSymbol.STYLE_NULL : SimpleLineSymbol.STYLE_SOLID;
								}else{
									SimpleLineSymbol.STYLE_SOLID;
								}
								if(cpGraBufferOLColor){
									sls.color = cpGraBufferOLColor.selectedColor;
								}else{
									sls.color = 0x01b9fd;
								}
								if(linewidth){
									sls.width = linewidth.value;
								}else{
									sls.width = 1;
								}
								sfs.outline = sls;
								if(cpGraBufferColor){
									sfs.color = cpGraBufferColor.selectedColor;
								}else{
									sfs.color = 0x01b9fd;
								}
								if(hsGraBufferAlpha){
									sfs.alpha = hsGraBufferAlpha.value;
								}else{
									sfs.alpha = 0.3;
								}
							}else{
								if(chkNoBufferFill2){
									sfs.style = (chkNoBufferFill2.selected) ? SimpleFillSymbol.STYLE_NULL : SimpleFillSymbol.STYLE_SOLID;
								}else{
									SimpleFillSymbol.STYLE_SOLID;
								}
								if(chkNoBufferOutline2){
									sls.style = (chkNoBufferOutline2.selected)? SimpleLineSymbol.STYLE_NULL : SimpleLineSymbol.STYLE_SOLID;
								}else{
									SimpleLineSymbol.STYLE_SOLID;
								}
								if(cpBufferOLColor){
									sls.color = cpBufferOLColor.selectedColor;
								}else{
									sls.color = 0x01b9fd;
								}
								if(linewidth2){
									sls.width = linewidth2.value;
								}else{
									sls.width = 1;
								}
								sfs.outline = sls;
								if(cpBufferColor){
									sfs.color = cpBufferColor.selectedColor;
								}else{
									sfs.color = 0x01b9fd;
								}
								if(hsBufferAlpha){
									sfs.alpha = hsBufferAlpha.value;
								}else{
									sfs.alpha = 0.3;
								}
							}
							graphic.geometry = resultEvent;
							graphic.symbol = sfs;
							
							graphicsLayerBuffer.clear();
							graphicsLayerBuffer.add(graphic);
							if(isGraphicalBufferOp){
								queryFeaturesGraphical(resultEvent, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex < 0)?0:cboLayerGraphical.selectedIndex]);
							}
						}
						catch (error:Error){
							showMessage(error.message, false);
						}
					}					
				}
			}
			
			private function intersectResults(spatialRelat:String):void
			{
				geomArr = [];
				var graLayBufferAC:ArrayCollection = graphicsLayerBuffer.graphicProvider as ArrayCollection;
				var graLayAC:ArrayCollection = graphicsLayer.graphicProvider as ArrayCollection;
				var intersectGeom:Geometry;
				if (graLayBufferAC.length >0){
					var gra:Graphic = graLayBufferAC[0] as Graphic;
					intersectGeom =  gra.geometry;
					queryFeaturesGraphical(intersectGeom, spatialRelat,configSpatialSearchLayers[(cboSearchLayerSpatial.selectedIndex < 0)?0:cboSearchLayerSpatial.selectedIndex]);
				} else if (graLayAC.length >0) {
					intersectGeom = unionGeoms(resultsFeatureSet);
					if (GeometryUtil.polygonSelfIntersecting(intersectGeom as Polygon)){
						geometryService.simplify([intersectGeom], new AsyncResponder(simpResult, null, spatialRelat));
						function simpResult(item:Object ,spatialRelat:String):void{
							var simpGeoms:Array = item as Array;
							queryFeaturesGraphical(simpGeoms[0] as Polygon, spatialRelat,configSpatialSearchLayers[(cboSearchLayerSpatial.selectedIndex < 0)?0:cboSearchLayerSpatial.selectedIndex]);
						}
					}else{
						queryFeaturesGraphical(intersectGeom, spatialRelat,configSpatialSearchLayers[(cboSearchLayerSpatial.selectedIndex < 0)?0:cboSearchLayerSpatial.selectedIndex]);
					}					
				}else{
					showStateResults();
					showMessage("There is no result to intersect, please make a graphical or text search first.",false);
				}
			}
			
			//create Search Results
			private function createSearchResults(featureSet:FeatureSet, queryFields:XMLList, queryRelates:Array = null):ArrayCollection
			{
				var a:int;
				graphicsLayer.clear();
				if(queryLayer.layerDetails){
					layerDetails = queryLayer.layerDetails;
				}else{
					layerDetails = queryLayer.tableDetails;
				}
				var fields:XMLList = queryFields ? queryFields.field : null;
				
				var result:ArrayCollection = new ArrayCollection();
				if (!queryTitleField){
					queryTitleField = featureSet.displayFieldName;
				}
				for each (var graphic:Graphic in featureSet.features){
					var value:String = "";
					var title:String = "";
					var content:String = "";
					var multi:String = "";
					fldAliases = featureSet.fieldAliases;
					lyrQLinks = [];
					
					//work with the links now
					for (a = 0; a < qLinks.length; a++){
						var link:String = "";
						var alias:String = "";
						var linkicon:String = "";
						link = com.esri.ags.utils.StringUtil.substitute(qLinks[a].link, graphic.attributes);
						alias = qLinks[a].alias;
						linkicon = com.esri.ags.utils.StringUtil.substitute(qLinks[a].icon, graphic.attributes);
						
						var lObj:Object ={
							link: link,
							icon: linkicon,
							alias: alias
						};
						lyrQLinks.push(lObj);
					}
					
					if (queryFields && queryFields[0].@all[0] == "true"){
						if (layerDetails.fields){
							for each (var field2:Field in layerDetails.fields){
								if (field2.name in graphic.attributes){
									displayFields(field2.name, getFieldXML(field2.name, fields), field2);
								}
							}
						}else{
							for (var fieldName2:String in graphic.attributes){
								displayFields(fieldName2, getFieldXML(fieldName2, fields), null);
							}
						}
					}else{
						for each (var fieldXML2:XML in fields){ // display the fields in the same order as specified
							if (fieldXML2.@name[0] in graphic.attributes){
								displayFields(fieldXML2.@name[0], fieldXML2, getField(fieldXML2.@name[0]));
							}
						}
					}
					
					function displayFields(fieldName:String, fieldXML:XML, field:Field):void
					{
						value = (graphic.attributes[fieldName] != null) ? String(graphic.attributes[fieldName]) : "";						
						if (value){
							var isDateField:Boolean;
							var dateFormat:String;
							var numFormat:String;
							var curFormat:String;
							var useUTC:Boolean;
							if (fieldXML){
								numFormat = fieldXML.@numberformat[0];
								curFormat = fieldXML.@currencyformat[0];
								useUTC = fieldXML.@useutc[0] == "true";
								dateFormat = fieldXML.@dateformat[0];
								if (dateFormat)
									isDateField = true;
							}
							if (!isDateField && field){
								isDateField = field.type == Field.TYPE_DATE;
							}
							if (isDateField){
								var dateMS:Number = Number(value);
								if (!isNaN(dateMS)){
									//Fix the date format to use the Spark format
									dateFormat = dateFormat.replace(/D/g, "d").replace(/Y/g, "y");
									value = msToDate(dateMS, dateFormat, useUTC);
								}
							}
							
							if(numFormat){
								var args:Array = numFormat.split("|");
								if(args[0]){
									numFormatter.fractionalDigits = args[0];
								}
								if(args[1]){
									numFormatter.useGrouping = true;
									numFormatter.groupingSeparator = args[1];
								}else{
									numFormatter.useGrouping = false;
								}
								if(args[2]){
									numFormatter.decimalSeparator = args[2];
								}
								value = numFormatter.format(value);
							}
							
							if(curFormat){
								var args2:Array = curFormat.split("|");
								if(args2[0]){
									currFormatter.currencySymbol = args2[0];
								}
								if(args2[1])
									currFormatter.fractionalDigits = args2[1];
								if(args2[2]){
									currFormatter.useGrouping = true;
									currFormatter.groupingSeparator = args2[2];
								}else{
									currFormatter.useGrouping = false;
								}
								if(args2[3]){
									currFormatter.decimalSeparator = args2[3];
								}
								value = currFormatter.format(value);
							}
							if(layerDetails && field){
								var typeID:String = layerDetails.typeIdField ? graphic.attributes[fieldName] : null;
								if (layerDetails.typeIdField && fieldName.toUpperCase() == layerDetails.typeIdField.toUpperCase()){
									// replace value with feature type name
									var featureType:FeatureType = getFeatureType(typeID);
									if (featureType && featureType.name){
										value = featureType.name;
									}
								}else{
									// replace value with coded value name if one exists
									var codedValue:CodedValue = getCodedValue(fieldName, value, typeID);
									if (codedValue){
										value = codedValue.name;
									}
								}
							}
						}						
						if (fieldName.toUpperCase() == queryTitleField.toUpperCase()){
							title = value;
							if (!title){
								title = widgetTitle;
							}
						}
						if (fieldName.toUpperCase() == queryMultiImgField.toUpperCase()){
							multi = value;
						}
						if (fieldName.toUpperCase() != "SHAPE_LENGTH" 
							&& fieldName.toUpperCase() != "SHAPE_AREA"
							&& fieldName.toUpperCase() != queryMultiImgField.toUpperCase() 
							&& fieldName.toUpperCase() != queryTitleField.toUpperCase()){
							if(fieldXML){
								if(fieldXML.@gridfieldonly[0] && fieldXML.@gridfieldonly[0] == "true" || 
									fieldXML.@hyperlinkgridfieldonly[0] && fieldXML.@hyperlinkgridfieldonly[0] == "true"){
									//ignore
								}else{
									if(!fieldXML.@visible[0] || (fieldXML.@visible[0] && fieldXML.@visible[0] != "false")){
										if (fieldXML && fieldXML.@alias[0]){
											content += "<b>" + fieldXML.@alias[0];
										}else{
											content += "<b>" + featureSet.fieldAliases[fieldName];
										}
										content += ": </b><i>" + value + "</i><br>";
									}
								}
							}else{
								if(fieldName != "oid"){
									content += "<b>" + featureSet.fieldAliases[fieldName];
									content += ": </b><i>" + value + "</i><br>";
								}
							} 
						}
					}						
					graphic.checkForMouseListeners = false;
					
					var searchResult:SearchResult = new SearchResult();
					searchResult.title = title;
					searchResult.content = content.substr(0,content.length - 4);
					if(graphic.geometry){
						searchResult.point = getGeomCenter(graphic);
					}
					searchResult.links = lyrQLinks;
					searchResult.relateicon = relateIcon ? relateIcon : null;
					searchResult.multi = multi ? multi :null;
					if(graphic.geometry){
						searchResult.zoomscale = zoomScale;
						searchResult.zoompercent = zoomPercent;
					}
					
					if(!queryLayer.layerDetails){
						if(!queryLayer.tableDetails.objectIdField){
							searchResult.oid = graphic.attributes["oid"];
						}else{
							searchResult.oid = graphic.attributes[queryLayer.tableDetails.objectIdField];
						}
					}else{
						if(!queryLayer.layerDetails.objectIdField){
							searchResult.oid = graphic.attributes["oid"];
						}else{
							searchResult.oid = graphic.attributes[queryLayer.layerDetails.objectIdField];
						}
					}
					searchResult.graphic = graphic;
					searchResult.relates = queryRelates;
					if(queryRelates && queryRelates.length == 1){
						searchResult.relateicon = queryRelates[0].icon;
					}
					searchResult.relatetooltip = relateToolTip;
					
					if(graphic.geometry){
						switch (graphic.geometry.type){
							case Geometry.MAPPOINT:{
								graphic.symbol = resultMarkerSymbol;
								break;
							}
							case Geometry.POLYLINE:{
								graphic.symbol = resultLineSymbol;
								break;
							}
							case Geometry.POLYGON:{
								graphic.symbol = resultFillSymbol;
								break;
							}
						}
					}else{
						graphic.symbol = resultSATSymbol;
					}
					var Atts:Object = {
						oid: searchResult.oid,
						content: searchResult.content,
						title: searchResult.title
					};
					if(!queryLayer.layerDetails){
						if(!queryLayer.tableDetails.objectIdField){
							Atts["ObjectID"] = searchResult.oid;
						}else{
							Atts[queryLayer.tableDetails.objectIdField] = searchResult.oid;
						}
					}else{
						if(!queryLayer.layerDetails.objectIdField){
							Atts["ObjectID"] = searchResult.oid;
						}else{
							Atts[queryLayer.layerDetails.objectIdField] = searchResult.oid;
						}
					}
					
					graphic.attributes = Atts;
					result.addItem(searchResult);
					
					var isValidPoint:Boolean = searchResult.point && !isNaN(searchResult.point.x) && !isNaN(searchResult.point.y);
					
					if (isValidPoint){
						graphicsLayer.add(graphic);
					}

					// infoWindowRenderer on each graphic
					var infoWindowRenderer:ClassFactory = new ClassFactory(PopUpRenderer);
					infoWindowRenderer.properties = {popUpInfo:configurePopUpInfo(lyrQLinks)};
					graphic.infoWindowRenderer = infoWindowRenderer;
				}
				return result;
			}
			
			private function getFieldXML(fieldName:String, fields:XMLList):XML
			{
				var result:XML;
				
				for each (var fieldXML:XML in fields){
					if (fieldName == fieldXML.@name[0]){
						result = fieldXML;
						break;
					}
				}
				return result;
			}
			
			private function getField(fieldName:String):Field
			{
				var result:Field;
				
				if (queryLayer && queryLayer.layerDetails){
					for each (var field:Field in queryLayer.layerDetails.fields){
						if (fieldName == field.name){
							result = field;
							break;
						}
					}
				}
				if(queryLayer && queryLayer.tableDetails){
					for each (var field2:Field in queryLayer.tableDetails.fields){
						if (fieldName == field2.name){
							result = field2;
							break;
						}
					}
				}
				return result;
			}
			
			private function getFeatureType(typeID:String):FeatureType
			{
				var result:FeatureType;
				var featureType:FeatureType;
				
				if (queryLayer && queryLayer.layerDetails){
					for each (featureType in queryLayer.layerDetails.types){
						if (typeID == featureType.id){
							result = featureType;
							break;
						}
					}
				}
				if(queryLayer && queryLayer.tableDetails){
					for each (featureType in queryLayer.tableDetails.types){
						if (typeID == featureType.id){
							result = featureType;
							break;
						}
					}
				}
				return result;
			}
			
			private function msToDate(ms:Number, dateFormat:String, useUTC:Boolean):String
			{
				var date:Date = new Date(ms);
				if (date.milliseconds == 999){ // workaround for REST bug
					date.milliseconds++;
				}
				if (useUTC){
					date.minutes += date.timezoneOffset;
				}
				if (dateFormat){
					dateFormatter.dateTimePattern = dateFormat;
					var result:String = dateFormatter.format(date);
					if (result){
						return result;
					}else{
						return dateFormatter.errorText;
					}
				}else{
					return date.toLocaleString();
				}
			}
			
			private var layerDomainsCache:Dictionary = new Dictionary(); // map from queryLayer to domainsCache
			
			private function getCodedValue(fieldName:String, fieldValue:String, typeID:String):CodedValue
			{
				var result:CodedValue;
				
				var domainsCache:Object = layerDomainsCache[queryLayer];
				if (!domainsCache){
					domainsCache = {}; // map from (fieldName + typeID) to CodedValueDomain
					layerDomainsCache[queryLayer] = domainsCache;
				}
				
				var domainsKey:String = fieldName + typeID;
				var codedValueDomain:CodedValueDomain;
				
				if (domainsKey in domainsCache){
					codedValueDomain = domainsCache[domainsKey];
				}else{
					if (typeID){
						var featureType:FeatureType = getFeatureType(typeID);
						if (featureType){
							codedValueDomain = featureType.domains[fieldName] as CodedValueDomain;
						}
					}else{
						var field:Field = getField(fieldName);
						if (field){
							codedValueDomain = field.domain as CodedValueDomain;
						}
					}
					domainsCache[domainsKey] = codedValueDomain;
				}
				
				if (codedValueDomain){
					for each (var codedValue:CodedValue in codedValueDomain.codedValues){
						if (fieldValue == codedValue.code){
							result = codedValue;
							break;
						}
					}
				}
				return result;
			}
			
			private function popCBwithUserList(userList:String, sItemVal:SearchExpValueItem):void
			{
				configUserVals = [];
				
				var uArray:Array = mx.utils.StringUtil.trimArrayElements(userList,",").split(",");
				
				// add an empty entry if the value is not required
				if (!sItemVal.isValueRequired)
				{
					configUserVals.push({
						value: sItemVal.noValue,
						label: sItemVal.noValue
					});
				};
				
				for each (var val:String in uArray){
					var uval:String = val;
					var ulbl:String = val;
					var uVal:Object = {
						value: uval,
						label: ulbl
					};
					configUserVals.push(uVal);
				}
				sItemVal.setCBDataProvider(configUserVals);
			}
			
			private function popCBwithDomain(fieldName:String, sItemVal:SearchExpValueItem):void
			{
				configDomainVals = [];
				
				var tfield:Field;
				
				var i:int = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
				if (i == -1){
					if(configSearchText[0].layer){
						queryLayer = configSearchText[0].layer;
					}else{
						queryLayer = configSearchText[0].table;
					}
				}else{
					if(configSearchText[i].layer){
						queryLayer = configSearchText[i].layer;
					}else{
						queryLayer = configSearchText[i].table;
					}
				}
				
				if (queryLayer && !queryLayer.loaded){
					queryLayer.addEventListener(LayerEvent.LOAD, queryLayer_loadHandler);
					function queryLayer_loadHandler(event:LayerEvent):void
					{
						popCBwithDomain(fieldName, sItemVal);
					}
					return;
				}

				var domainsCache:Object = layerDomainsCache[queryLayer];
				if (!domainsCache){
					domainsCache = {}; // map from fieldName to CodedValueDomain
					layerDomainsCache[queryLayer] = domainsCache;
				}
				
				var domainsKey:String = fieldName;
				var codedValueDomain:CodedValueDomain;
				var rangeDomain:RangeDomain;
				
				if (domainsKey in domainsCache){
					if(domainsCache[domainsKey].hasOwnProperty("codedValues")){
						codedValueDomain = domainsCache[domainsKey];
					}else if (domainsCache[domainsKey].hasOwnProperty("minValue")){
						rangeDomain = domainsCache[domainsKey];
					}
				}else{
					var field:Field = getField(fieldName);
					if (field && field.domain && field.domain is CodedValueDomain){
						codedValueDomain = field.domain as CodedValueDomain;
						domainsCache[domainsKey] = codedValueDomain;
					}else if (field && field.domain && field.domain is RangeDomain){
						rangeDomain = field.domain as RangeDomain;
						domainsCache[domainsKey] = rangeDomain;						
					}else{
						var stype:FeatureType;
						if(queryLayer.layerDetails){
							for each (stype in queryLayer.layerDetails.types){
								if(stype.domains[fieldName].hasOwnProperty("codedValues")){
									codedValueDomain = stype.domains[fieldName];
									domainsCache[domainsKey] = codedValueDomain;
								}
								else if (stype.domains[fieldName].hasOwnProperty("minValue")){
									rangeDomain = stype.domains[fieldName];
									domainsCache[domainsKey] = rangeDomain;
								}
							}
						}else{
							for each (stype in queryLayer.tableDetails.types){
								if(stype.domains[fieldName].hasOwnProperty("codedValues")){
									codedValueDomain = stype.domains[fieldName];
									domainsCache[domainsKey] = codedValueDomain;
								}else if (stype.domains[fieldName].hasOwnProperty("minValue")){
									rangeDomain = stype.domains[fieldName];
									domainsCache[domainsKey] = rangeDomain;
								}
							}
						}
					}					
				}
				
				if(codedValueDomain){
					for each (var codedValue:CodedValue in codedValueDomain.codedValues){
						var dVal:String = codedValue.code;
						var dLbl:String = codedValue.name;
						var domVal:Object = {
							value: dVal,
							label: dLbl
						};
						configDomainVals.push(domVal);
					}
					sItemVal.setCBDataProvider(configDomainVals);
				}
				if(rangeDomain){
					sItemVal.restrictTextBox(rangeDomain);
					searchBtn.addEventListener(MouseEvent.CLICK, inputValidate);
					function inputValidate(evt:Event):void
					{
						sItemVal.validateNum();
					}
				}
			}

			//get geom center
			private function getGeomCenter(gra:Graphic):MapPoint
			{
				var pt:MapPoint;
				switch (gra.geometry.type){
					case Geometry.MAPPOINT:{
						pt = gra.geometry as MapPoint;
						break;
					}
					case Geometry.POLYLINE:{
						var pl:Polyline = gra.geometry as Polyline;
						var pathCount:Number = pl.paths.length;
						var pathIndex:int = int((pathCount / 2) - 1);
						var midPath:Array = pl.paths[pathIndex];
						var ptCount:Number = midPath.length;
						var ptIndex:int = int((ptCount / 2) - 1);
						pt = pl.getPoint(pathIndex, ptIndex);
						break;
					}
					case Geometry.POLYGON:{
						var poly:Polygon = gra.geometry as Polygon;
						pt = poly.extent.center;
						break;
					}
				}
				return pt;
			}			
					
			private function getDrawGra():void
			{
				if(drawGraphicsLayer){
					var geom:Geometry
					var graLayAC:ArrayCollection = drawGraphicsLayer.graphicProvider as ArrayCollection;
					if (graLayAC.length > 1){
						geom = unionGeoms2(drawGraphicsLayer);
						queryFeaturesGraphical(geom, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex<0)?0:cboLayerGraphical.selectedIndex]);
					}else if (graLayAC.length == 1){
						geom = (graLayAC[0] as Graphic).geometry;
						queryFeaturesGraphical(geom, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex<0)?0:cboLayerGraphical.selectedIndex]);
					}else if(drawGraphicsLayer.graphicProvider.length == 0){
						showStateResults();
						showMessage("There are no graphics available",false);
					}
				}else{
					showStateResults();
					showMessage("There are no graphics available",false);
				}
			}
			
			private function getBufferGra():void
			{
				if(bufferGraphicsLayer){
					var geom:Geometry
					var graLayAC:ArrayCollection = bufferGraphicsLayer.graphicProvider as ArrayCollection;
					if (graLayAC.length > 1){
						geom = unionGeoms2(bufferGraphicsLayer);
						queryFeaturesGraphical(geom, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex<0)?0:cboLayerGraphical.selectedIndex]);
					}else if (graLayAC.length == 1){
						geom = (graLayAC[0] as Graphic).geometry;
						queryFeaturesGraphical(geom, "esriSpatialRelIntersects", configSearchGraphical[(cboLayerGraphical.selectedIndex<0)?0:cboLayerGraphical.selectedIndex]);
					}else if(bufferGraphicsLayer.graphicProvider.length == 0){
						showStateResults();
						showMessage("There are no graphics availible",false);
					}
				} else {
					showStateResults();
					showMessage("There are no graphics availible",false);
				}
			}
			
			private function checkForeDrawGL(evt:Event):void
			{
				MapUtil.forEachMapLayer(map, function(layer:Layer):void
				{
					if(layer.name.toLowerCase() == "draw features"){
						drawGraphicsLayer = layer as GraphicsLayer;
						drawGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_ADD, checkeDrawNumGras);
						drawGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_REMOVE, checkeDrawNumGras);
						drawGraphicsLayer.addEventListener(GraphicsLayerEvent.GRAPHICS_CLEAR, checkeDrawNumGras);
					}
				});
			}
			
			private function checkeDrawNumGras(event:Event):void
			{
				if (!executingURLquery){
					clearMessage();
				}
				if(drawGraphicsLayer){
					eDrawBtn.filters = (drawGraphicsLayer.numGraphics > 0)?[]:[cOver];
					eDrawBtn.buttonMode = eDrawBtn.useHandCursor = eDrawBtn.enabled = (drawGraphicsLayer.numGraphics > 0);
				}
			}
			
			private function checkForpntBufferGL(evt:Event):void
			{
				MapUtil.forEachMapLayer(map, function(layer:Layer):void
				{
					if(layer.name.toLowerCase() == "buffer results"){
						bufferGraphicsLayer = layer as GraphicsLayer;
						bufferGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_ADD, checkBufferNumGras);
						bufferGraphicsLayer.addEventListener(GraphicEvent.GRAPHIC_REMOVE, checkBufferNumGras);
						bufferGraphicsLayer.addEventListener(GraphicsLayerEvent.GRAPHICS_CLEAR, checkBufferNumGras);
					}
				});
			}
			
			private function checkBufferNumGras(event:Event):void
			{
				if (!executingURLquery){
					clearMessage();
				}
				if(bufferGraphicsLayer){
					pBufferBtn.filters = (bufferGraphicsLayer.numGraphics > 0)?[]:[cOver];
					pBufferBtn.buttonMode = pBufferBtn.useHandCursor = pBufferBtn.enabled = (bufferGraphicsLayer.numGraphics > 0);
				}
			}
			
			private function clear():void
			{
				addSharedData("Deactivate_DrawTool", null); // to be able to deactivate drawTool on other widgets
				
				//hide infowindow if any
				hideInfoWindow();
				
				if(currentState == "resultsList"){
					currentState = lState;
					if(lState == "graphicalInput"){
						wTemplate.selectedTitlebarButtonIndex = 1;
					}else if (lState == "textInput"){
						wTemplate.selectedTitlebarButtonIndex = 2;
					}else{
						wTemplate.selectedTitlebarButtonIndex = 3;
					}
				}
				graphicsLayer.clear();
				graphicsLayerBuffer.clear();
				graGraphicsLayer.clear();
				clearMessage();
				var sItemVal:SearchExpValueItem;
				for(var sgi:int = 0; sgi < searchGroup.numElements; sgi++){
					sItemVal = searchGroup.getElementAt(sgi) as SearchExpValueItem;
					if(sItemVal.isTextBox()){
						sItemVal.textValue = "";
						sItemVal.resetTxtSearch();
					}
				}
				sumField = "";
				searchResultAC = null;
				if (myfloatdg){
					myfloatdg.datagrid.dataProvider.removeAll();
					gridDataProvider = null;
					myfloatdg.sumField = "";
					//Reset the datagrids sort indicators
					var reset:Vector.<int> = Vector.<int>([]);
					myfloatdg.datagrid.columnHeaderGroup.visibleSortIndicatorIndices = reset;
				}
				if (relfloatdg){
					relfloatdg.datagrid.dataProvider.removeAll();
					relfloatdg.sumField = "";
					//Reset the datagrids sort indicators
					var rreset:Vector.<int> = Vector.<int>([]);
					relfloatdg.datagrid.columnHeaderGroup.visibleSortIndicatorIndices = rreset;
					PopUpManager.removePopUp(relfloatdg);
				}
				if(floatorfixed == "fixed"){
					addSharedData("clearFixedDatagrid", null);
				}
				if(floatorfixed == "fixed"){
					addSharedData("clearRelateFixedDatagrid", null);
				}
			}
			
			private function clearBuffer():void
			{
				graphicsLayerBuffer.clear();
			}		
			
			private var hitimer:uint;
			private var Hits:Array = new Array();									
			
			private function showMessage(msg:String, swfVisible:Boolean):void
			{
				txtMessage.text = msg;
				swfMessage.visible = swfVisible;
				msgVisible = true;
			}			
			
			private function clearMessage():void
			{
				msgVisible = false;
			}
			
			private function preClickSearchRelateResult(event:Event):void
			{
				var searchResult:SearchResult = ItemRenderer(event.target).data as SearchResult;
				clickSearchRelateResult(searchResult);
			}
			
			public function standaloneRelate(roid:Number):void
			{
				for (var i:Number = 0; i < searchResultAC.length; i++){
					var sr:SearchResult = searchResultAC[i];
					if(sr.oid == roid){
						clickSearchRelateResult(sr);
						break;
					}
				}
			}
			
			public function clickSearchRelateResult(searchResult:SearchResult):void
			{
				var relId:int;
				var relLbl:String;
				var relFields:XMLList;
				var relExportEnabled:Boolean;
				var rFields:XMLList;
				qrelateFields = [];
				relateFields = [];
				relateHyperFields = [];
				sumField = "";
				
				var selRelateURL:String;
				
				var relArr:Array;
				if(queryLayer.layerDetails){
					relArr = queryLayer.layerDetails.relationships;
				}else{
					relArr = queryLayer.tableDetails.relationships;
				}
				
				if(searchResult.relates.length == 1){
					var relation:Relationship;
					for (var ri:int=0; ri < relArr.length; ri++){
						if(relArr[ri].id == searchResult.relates[0].id){
							relation = relArr[ri] as Relationship;
							break;
						}
					}
					selRelateURL = queryLayer.url.substring(0,queryLayer.url.lastIndexOf("/")) + "/" + (relation.relatedTableId);
					if(!relqueryLayer)
						relqueryLayer = new FeatureLayer(selRelateURL);
					
					if (relqueryLayer && !relqueryLayer.loaded){
						relqueryLayer.addEventListener(LayerEvent.LOAD, queryLayer_loadHandler);
						function queryLayer_loadHandler(levent:LayerEvent):void
						{
							clickSearchRelateResult(searchResult);
						}
						return;
					}
					
					relId = searchResult.relates[0].id;
					relLbl = searchResult.relates[0].label;
					relFields = searchResult.relates[0].fields;
					relExportEnabled = searchResult.relates[0].enableexport;
					if(relFields.@all[0] == "true"){
						relatesQuery.outFields = ["*"];
						relatesQuery.relationshipId = relId;
						relatesQuery.objectIds = [searchResult.oid];
						queryLayer.queryRelatedFeatures(relatesQuery, new AsyncResponder(onRelateResult, onFault, searchResult.oid));
					}else{
						rFields = relFields.field;
						for each (var fieldXML:XML in rFields){
							if(fieldXML.@sum[0] && fieldXML.@sum[0] == "true"){
								if(fieldXML.@sumlabel[0]){
									lblSum = fieldXML.@sumlabel[0];
								}
								sumField = fieldXML.@name[0];
							}
							qrelateFields.push(fieldXML.@name[0]);
							var str:String = fieldXML.@name[0] + "~";
							if(fieldXML.@alias[0]){
								if(fieldXML.@alias[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@alias[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@dateformat[0]){
								if(fieldXML.@dateformat[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@dateformat[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@currencyformat[0]){
								if(fieldXML.@currencyformat[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@currencyformat[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@numberformat[0]){
								if(fieldXML.@numberformat[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@numberformat[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@useutc[0]){
								if(fieldXML.@useutc[0] == "false"){
									str += "false~";
								}else{
									str += "true~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@sort[0]){
								if(fieldXML.@sort[0] == ""){
									str += "NA";
								}else{
									str += fieldXML.@sort[0];
								}
							}else{
								str += "NA";
							}
							if(!fieldXML.@hyperlinkgridfield[0])
								relateFields.push(str);
							if (fieldXML.@hyperlinkgridfield[0]){
								if (fieldXML.@hyperlinkgridfield[0]=="true"){
									var str2:String = fieldXML.@name[0] + "~";
									if(fieldXML.@alias[0]){
										if(fieldXML.@alias[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@alias[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@hyperlinkaliastext[0]){
										if(fieldXML.@hyperlinkaliastext[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@hyperlinkaliastext[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@linkprefix[0]){
										if(fieldXML.@linkprefix[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@linkprefix[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@linksuffix[0]){
										if(fieldXML.@linksuffix[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@linksuffix[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@hyperlinkgridicon[0]){
										if(fieldXML.@hyperlinkgridicon[0] == ""){
											str2 += "NA";
										}else{
											str2 += fieldXML.@hyperlinkgridicon[0];
										}
									}else{
										str2 += "NA";
									}
									relateHyperFields.push(str2);
								}
							}
						}
						relatesQuery.outFields = qrelateFields;
						relatesQuery.relationshipId = relId;
						relatesQuery.objectIds = [searchResult.oid];
						queryLayer.queryRelatedFeatures(relatesQuery, new AsyncResponder(onRelateResult, onFault, searchResult.oid));
					}
				}else{
					relqueryLayer = null;
					var relArrayColl:ArrayCollection = new ArrayCollection();
					for(var r:int=0; r < searchResult.relates.length; r++){
						var relRslt:RelateResult = new RelateResult();
						relRslt.id = searchResult.relates[r].id;
						relRslt.name = searchResult.relates[r].label;
						relRslt.fields = searchResult.relates[r].fields;
						relRslt.enableexport = searchResult.relates[r].enableexport;
						relRslt.oid = searchResult.oid;
						relRslt.icon = searchResult.relates[r].icon;
						relArrayColl.addItem(relRslt);
					}
					
					if(!rWindow){
						rWindow = new RelatesWindow();
						rWindow.dProvider = relArrayColl;
						rWindow.addEventListener("relateClicked", relateChoosen);
						PopUpManager.addPopUp(rWindow,map,true,PopUpManagerChildList.POPUP);
						PopUpManager.centerPopUp(rWindow);
						PopUpManager.bringToFront(rWindow);
					}else{
						var exists:Boolean = false;
						for (var p:Number=0;p<systemManager.popUpChildren.numChildren;p++) {
							if(systemManager.popUpChildren.getChildAt(p) is RelatesWindow){
								exists = true;
								break;
							}
						}
						if(exists == false){
							PopUpManager.addPopUp(rWindow,map,true,PopUpManagerChildList.POPUP); 
						}
						PopUpManager.centerPopUp(rWindow);
						PopUpManager.bringToFront(rWindow);
					}
					rWindow.dProvider = relArrayColl;
				}
				
				function relateChoosen(evt:Event):void{
					var relArr:Array;
					if(queryLayer.layerDetails){
						relArr = queryLayer.layerDetails.relationships;
					}else{
						relArr = queryLayer.tableDetails.relationships;
					}
					var relation:Relationship;
					for (var ri:int=0; ri < relArr.length; ri++){
						if(relArr[ri].id == rWindow.selectedRelateId){
							relation = relArr[ri] as Relationship;
							break;
						}
					}
					relId = rWindow.selectedRelateId;
					relLbl = rWindow.selectedRelateName;
					relFields = rWindow.selectedRelateFields;
					relExportEnabled = rWindow.selectedRelateExportEnabled;
					var relOid:Number = rWindow.oid;
					PopUpManager.removePopUp(rWindow);
					 
					selRelateURL = queryLayer.url.substring(0,queryLayer.url.lastIndexOf("/")) + "/" + (relation.relatedTableId);
					if(!relqueryLayer){
						relqueryLayer = new FeatureLayer(selRelateURL);
					}
					if (relqueryLayer && !relqueryLayer.loaded){
						relqueryLayer.addEventListener(LayerEvent.LOAD, queryLayer_loadHandler);
						function queryLayer_loadHandler(levent:LayerEvent):void
						{
							relateChoosen(evt)
						}
						return;
					}
					
					if(relFields.@all[0] == "true"){
						relatesQuery.outFields = ["*"];
						relatesQuery.relationshipId = relId;
						relatesQuery.objectIds = [relOid];
						queryLayer.queryRelatedFeatures(relatesQuery, new AsyncResponder(onRelateResult, onFault, relOid));
					}else{
						rFields = relFields.field;
						for each (var fieldXML:XML in rFields){
							if(fieldXML.@sum[0] && fieldXML.@sum[0] == "true"){
								if(fieldXML.@sumlabel[0]){
									lblSum = fieldXML.@sumlabel[0];
								}
								sumField = fieldXML.@name[0];
							}
							qrelateFields.push(fieldXML.@name[0]);
							var str:String = fieldXML.@name[0] + "~";
							if(fieldXML.@alias[0]){
								if(fieldXML.@alias[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@alias[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@dateformat[0]){
								if(fieldXML.@dateformat[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@dateformat[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@currencyformat[0]){
								if(fieldXML.@currencyformat[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@currencyformat[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@numberformat[0]){
								if(fieldXML.@numberformat[0] == ""){
									str += "NA~";
								}else{
									str += fieldXML.@numberformat[0] + "~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@useutc[0]){
								if(fieldXML.@useutc[0] == "false"){
									str += "false~";
								}else{
									str += "true~";
								}
							}else{
								str += "NA~";
							}
							if(fieldXML.@sort[0]){
								if(fieldXML.@sort[0] == ""){
									str += "NA";
								}else{
									str += fieldXML.@sort[0];
								}
							}else{
								str += "NA";
							}
							if(!fieldXML.@hyperlinkgridfield[0]){
								relateFields.push(str);
							}
							if (fieldXML.@hyperlinkgridfield[0]){
								if (fieldXML.@hyperlinkgridfield[0]=="true"){
									var str2:String = fieldXML.@name[0] + "~";
									if(fieldXML.@alias[0]){
										if(fieldXML.@alias[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@alias[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@hyperlinkaliastext[0]){
										if(fieldXML.@hyperlinkaliastext[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@hyperlinkaliastext[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@linkprefix[0]){
										if(fieldXML.@linkprefix[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@linkprefix[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@linksuffix[0]){
										if(fieldXML.@linksuffix[0] == ""){
											str2 += "NA~";
										}else{
											str2 += fieldXML.@linksuffix[0] + "~";
										}
									}else{
										str2 += "NA~";
									}
									if(fieldXML.@hyperlinkgridicon[0]){
										if(fieldXML.@hyperlinkgridicon[0] == ""){
											str2 += "NA";
										}else{
											str2 += fieldXML.@hyperlinkgridicon[0];
										}
									}else{
										str2 += "NA";
									}
									relateHyperFields.push(str2);
								}
							}
						}
						relatesQuery.outFields = qrelateFields;
						relatesQuery.relationshipId = relId;
						relatesQuery.objectIds = [relOid];
						queryLayer.queryRelatedFeatures(relatesQuery, new AsyncResponder(onRelateResult, onFault, relOid));
					}
				}
				
				function onRelateResult(relatedRecords:Object, token:Object = null):void
				{
					// get related records for the first feature
					var fset:FeatureSet = (relatedRecords[token]);
					if (!fset){
						Alert.show(noRelatesFound + " " + relLbl,noRelatesFoundAlertTitle,4,wTemplate,null,relateClass);
						return;
					}
					relfldAliases = fset.fieldAliases;
					if(relateFields.length == 0){
						var rfld:Field;
						for each (rfld in fset.fields){
							var str0:String = rfld.name + "~";
							str0 += rfld.alias + "~";
							str0 += "NA~";
							str0 += "NA~";
							str0 += "NA~";
							str0 += "NA";
							relateFields.push(str0);
						}
					}
					if (fset is FeatureSet){
						if(floatorfixed == "float"){
							if(!relfloatdg){
								relfloatdg = new SearchWidgetRelateFloatDG();
								PopUpManager.addPopUp(relfloatdg,map,false,PopUpManagerChildList.POPUP);
								PopUpManager.centerPopUp(relfloatdg);
							}else{
								var exists:Boolean = false;
								for (var p:Number=0;p<systemManager.popUpChildren.numChildren;p++) {
									if(systemManager.popUpChildren.getChildAt(p) is SearchWidgetRelateFloatDG){
										exists = true;
										break;
									}
								}
								if(exists == false){
									PopUpManager.addPopUp(relfloatdg,map,false,PopUpManagerChildList.POPUP); 
									PopUpManager.centerPopUp(relfloatdg);
								}
							}
							
							if(relfloatdg.datagrid.dataProvider){
								relfloatdg.datagrid.dataProvider.removeAll();
							}
							relfloatdg.csvExportOptionLbl = exp2csvOptLbl;
							relfloatdg.txtExportOptionLbl = exp2txtOptLbl;
							relfloatdg.ExportButtonLbl = expBtnLbl;
							relfloatdg.csvSeperator = csvSep;
							relfloatdg.dgFieldAliases = relfldAliases;
							relfloatdg.csvName = relatescsvName;
							relfloatdg.sumField = sumField;
							relfloatdg.labelSum = lblSum;
							relfloatdg.dgColumns = relateFields;
							relfloatdg.dgHyperColumns = relateHyperFields;
							relfloatdg.layerDetails = (relqueryLayer.layerDetails)?relqueryLayer.layerDetails:relqueryLayer.tableDetails;
							relfloatdg.dProvider = fset.attributes;
							relfloatdg.enableExport = relExportEnabled;
							relfloatdg.dgtitle = relLbl;
						}else if(floatorfixed == "fixed"){
							var dgConfig:Object = {
								dgFieldAliases: relfldAliases,
								csvName: relatescsvName,
								sumField: sumField,
								labelSum: lblSum,
								dgColumns: relateFields,
								dgHyperColumns: relateHyperFields,
								dProvider: fset.attributes,
								featLayer: queryLayer,
								layerDetails: (relqueryLayer.layerDetails)?relqueryLayer.layerDetails:relqueryLayer.tableDetails,
								enableExport: relExportEnabled
							};
							var dgconfigArr:ArrayCollection = new ArrayCollection();
							dgconfigArr.addItem(dgConfig);
							addSharedData("configRelateFixedDatagrid", dgconfigArr);
							addSharedData("switch2RelateTabFixedDataGrid", null);
						}
					}
				}
				
				//on fault
				function onFault(event:Fault,data:Object):void
				{                    
					Alert.show(event.faultDetail.toString(), "Fault", 4, wTemplate);         
				}
			}
			
			private function clickSearchResult(event:Event):void
			{
				var recAC:ArrayCollection = searchResultDG.dataProvider as ArrayCollection;
				var searchResult:SearchResult = ItemRenderer(event.target).data as SearchResult;
				unhighlightDataGroupItems();
				searchResult.selected = true;
				
				if(lState == "textInput"){
					var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
					zoomScale = configSearchText[i].zoomscale;
					zoomPercent = configSearchText[i].zoompercent;
				} else if(lState == "graphicalInput"){
					var i2:Number = cboLayerGraphical.selectedIndex;
					zoomScale = configSearchGraphical[i2].zoomscale;
					zoomPercent = configSearchGraphical[i2].zoompercent;
				}
				
				if (searchResult.graphic.geometry){
					if (searchResult.graphic.geometry.type == Geometry.MAPPOINT){
						if(isNaN(zoomScale)){
							map.zoom(1 / 16, searchResult.point);
							map.centerAt(searchResult.point);
						}else{
							if (map.scale > zoomScale){
								map.scale = zoomScale;
							}
							map.centerAt(searchResult.point);
						}
					}else{
						if(isNaN(zoomScale)){
							map.extent = searchResult.graphic.geometry.extent.expand(zoomPercent);
							if (!map.extent.contains(searchResult.graphic.geometry)){
								map.level--;
							}
						}else{
							if (map.scale > zoomScale){
								map.scale = zoomScale;
							}
							map.centerAt(searchResult.point);
						}
					}
				}
				
				Hits.length = 0;
				
				if(myfloatdg && myfloatdg.visible){
					if(myfloatdg.datagrid.dataProvider){
						for each(var attributes:Object in gridDataProvider){
							if (attributes.oid === searchResult.oid){
								var myCursor:IViewCursor = (myfloatdg.datagrid.dataProvider as ArrayCollection).createCursor();
								while(!myCursor.afterLast){
									if(myCursor.current.oid == attributes.oid){
										Hits.push(myCursor.current);
									}
									myCursor.moveNext();
								}
								myfloatdg.datagrid.selectedIndex = myfloatdg.datagrid.dataProvider.getItemIndex(Hits[0])                        
							}
						}                
						myfloatdg.datagrid.ensureCellIsVisible(myfloatdg.datagrid.selectedIndex);
					}
				}
				if(floatorfixed == "fixed"){
					var dgConfig:Object = {
						searchResultoid: searchResult.oid
					}
					var dgconfigArr:ArrayCollection = new ArrayCollection();
					dgconfigArr.addItem(dgConfig);
					addSharedData("scrollFixedDataGrid", dgconfigArr);
				}
			}
			
			private function mouseOverSearchResult(event:Event):void
			{
				clearTimeout(hitimer);
				var searchResult:SearchResult = ItemRenderer(event.target).data as SearchResult;
				if(searchResult.point){
					if (map.extent.containsXY(searchResult.point.x, searchResult.point.y)){ // only show infowindow if search result in contained within map extent
						hitimer = setTimeout(showHighlight, 300, [ searchResult ]);
					}else{
						hideInfoWindow();
					}
				}
				
				Hits.length = 0;
				
				if(myfloatdg && myfloatdg.visible){
					if(myfloatdg.datagrid && myfloatdg.datagrid.dataProvider){
						for each(var attributes:Object in gridDataProvider){
							if (attributes.oid === searchResult.oid){
								var myCursor:IViewCursor = (myfloatdg.datagrid.dataProvider as ArrayCollection).createCursor();
								while(!myCursor.afterLast){
									if(myCursor.current.oid == attributes.oid){
										Hits.push(myCursor.current);
									}
									myCursor.moveNext();
								}
								myfloatdg.datagrid.selectedIndex = myfloatdg.datagrid.dataProvider.getItemIndex(Hits[0])                        
							}
						}                
						myfloatdg.datagrid.ensureCellIsVisible(myfloatdg.datagrid.selectedIndex);
					}
				}
				if(floatorfixed == "fixed"){
					var dgConfig:Object = {
						searchResultoid: searchResult.oid
					}
					var dgconfigArr:ArrayCollection = new ArrayCollection();
					dgconfigArr.addItem(dgConfig);
					addSharedData("scrollFixedDataGrid", dgconfigArr);
				}
			}
			
			private function mouseOutSearchResult(event:Event):void
			{
				clearTimeout(hitimer);
			}
			
			private function widgetOpenedHandler(event:Event):void
			{				
				if(graphicsLayer){
					graphicsLayer.visible = true;
				}
				if (graphicsLayerBuffer){
					graphicsLayerBuffer.visible = true;
				}
				if (graGraphicsLayer){
					graGraphicsLayer.visible = true;
				}
			}
			
			private function showGridResults():void
			{
				try{
					if(gridFields.length == 0){
						showMessage("No Datagrid configured for this layer", false);
						return;
					}
					
					if(floatorfixed == "float"){
						if(!myfloatdg){
							myfloatdg = new SearchWidgetFloatDG();
							PopUpManager.addPopUp(myfloatdg,map,false,PopUpManagerChildList.POPUP)
							PopUpManager.centerPopUp(myfloatdg);
						}else{
							var exists:Boolean = false;
							for (var p:Number=0;p<systemManager.popUpChildren.numChildren;p++) {
								if(systemManager.popUpChildren.getChildAt(p) is SearchWidgetFloatDG){
									exists = true;
									break;
								}
							}
							if(exists == false){
								PopUpManager.addPopUp(myfloatdg,map,false,PopUpManagerChildList.POPUP); 
							}
							PopUpManager.centerPopUp(myfloatdg);
						}
						if(!gridFields){
							gridFields = configSearchText[0].gridfields;
						}
						myfloatdg.RelateIcon = relateIcon;
						myfloatdg.RelateToolTip = relateToolTip;
						myfloatdg.enableExport = configSearchText[0].enableexport;
						myfloatdg.featLayer = queryLayer;
						myfloatdg.layerDetails = (queryLayer.layerDetails)?queryLayer.layerDetails:queryLayer.tableDetails;
						myfloatdg.csvSeperator = csvSep;
						myfloatdg.csvExportOptionLbl = exp2csvOptLbl;
						myfloatdg.txtExportOptionLbl = exp2txtOptLbl;
						myfloatdg.ExportButtonLbl = expBtnLbl;
						myfloatdg.csvName = _csvName;
						myfloatdg.sumField = sumField;
						myfloatdg.labelSum = lblSum;
						myfloatdg.dgFieldAliases = fldAliases;
						myfloatdg.hasRelates = (queryLayerRels && queryLayerRels.length > 0);
						myfloatdg.dgColumns = gridFields;
						myfloatdg.dgHyperColumns = gridHyperFields;
						myfloatdg.dProvider = gridDataProvider;
						myfloatdg.graphicslayer = graphicsLayer;
						myfloatdg.widgetInteract = widgetAndGridIteract;
						if(lState == "graphicalInput"){
							var i2:Number = (cboLayerGraphical.selectedIndex<0)?0:cboLayerGraphical.selectedIndex;
							zoomScale = configSearchGraphical[i2].zoomscale;
							zoomPercent = configSearchGraphical[i2].zoompercent;
							myfloatdg.enableExport = configSearchGraphical[i2].enableexport;
						}else if (lState == "textInput"){
							var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
							zoomScale = configSearchText[i].zoomscale;
							zoomPercent = configSearchText[i].zoompercent;
							myfloatdg.enableExport = configSearchText[i].enableexport;
						}
						myfloatdg.zoomPercent = zoomPercent;
						myfloatdg.zoomScale = zoomScale;
						myfloatdg.ownerWidget = this;
					}
					
				}
				catch (error:Error){
					showMessage(error.message, false);
				}
			}
			
			public function highlightDataGroupItemByOID(oid:Number):void
			{
				if(widgetAndGridIteract){
					for (var i:Number = 0; i < searchResultAC.length; i++){
						var sr:SearchResult = searchResultAC[i];
						if(sr.oid == oid){
							sr.selected = true;
							var spDelta:Point = searchResultDG.layout.getScrollPositionDeltaToElement(i);
							if (spDelta){
								searchResultDG.verticalScrollPosition += spDelta.y;
							}
							break;
						}
					}
				}
			}
			
			public function highlightDataGroupItem(gra:Graphic):void
			{
				if(widgetAndGridIteract){
					var recAC:ArrayCollection = searchResultDG.dataProvider as ArrayCollection;
					if(gra){
						var sr:Object = gra.attributes;	
						for (var i:Number = 0; i < recAC.length; i++){
							var sr1:SearchResult = searchResultAC[i];
							if(sr1.oid === sr.oid){
								sr1.selected = true;
								var spDelta:Point = searchResultDG.layout.getScrollPositionDeltaToElement(i);
								if (spDelta){
									searchResultDG.verticalScrollPosition += spDelta.y;
								}
								break;
							}
						}
					}
				}
			}
			
			public function clearSelected():void
			{
				var recAC:ArrayCollection = searchResultDG.dataProvider as ArrayCollection;
				if(recAC){
					for (var i:Number = 0; i < recAC.length; i++){
						var sr:SearchResult = searchResultAC[i];
						sr.selected = false;
					}
				}
			}
			
			public function unhighlightDataGroupItems():void
			{
				if(widgetAndGridIteract){
					var recAC:ArrayCollection = searchResultDG.dataProvider as ArrayCollection;
					if(!recAC){return;}
					for (var i:Number = 0; i < recAC.length; i++){
						var sr:SearchResult = searchResultAC[i];
						if(sr.oid == sr.oid){
							sr.selected = false;
						}
					}
				}
			}
			
			private function showHighlight(params:Array):void
			{
				var searchResult:SearchResult = params[0];
				var showHighlightPoint:MapPoint = searchResult.point as MapPoint;
				popUpRenderer.popUpInfo = configurePopUpInfo(searchResult.links);
				popUpRenderer.graphic = searchResult.graphic;
				popUpRenderer.setStyle("skinClass", widgets.eSearch.skins.PopUpRendererSkin);
				
				map.infoWindow.content = popUpRenderer;
				map.infoWindow.contentOwner = popUpRenderer.graphic;
				map.infoWindow.show(showHighlightPoint);
			}
			
			private function configurePopUpInfo(links:Array):EnhancedPopUpInfo
			{
				var popUpInfo:EnhancedPopUpInfo = new EnhancedPopUpInfo;
				popUpInfo.title = "{title}";
				popUpInfo.description = "{content}";
				if(queryAttachments){
					popUpInfo.showAttachments = true;
				}
				popUpInfo.featLayer = queryLayer;
				var pminfos:Array = [];
				
				for(var l:int=0; l<links.length; l++){
					if (links[l].link){
						var pos:Number = links[l].link.length - 4;
						var sfx:String = String(links[l].link).substr(pos, 4).toLowerCase();
						if ((sfx == ".jpg") || (sfx == ".png") || (sfx == ".gif")){ // use PopUpMediaInfo if it is an image
							var popUpMediaInfo:PopUpMediaInfo = new PopUpMediaInfo;
							popUpMediaInfo.type = PopUpMediaInfo.IMAGE;
							popUpMediaInfo.imageLinkURL = links[l].link;
							popUpMediaInfo.imageSourceURL = links[l].link;
							pminfos.push(popUpMediaInfo);
						}else{
							var lText:String = (links[l].alias != "") ? links[l].alias : links[l].link;
							popUpInfo.description += "<br /><a href='" + links[l].link + "'>" + lText + "</a>"
						}
					}
				}
				popUpInfo.popUpMediaInfos = pminfos;
				
				return popUpInfo;
			}
			
			private function showStateGraphicalSearch():void
			{
				lState = currentState;
				currentState = "graphicalInput";
			}
			
			private function showStateTextSearch():void
			{
				addSharedData("Deactivate_DrawTool", null);
				lState = currentState;
				currentState = "textInput";
			}				
			
			private function showStateResults():void
			{
				lState = currentState;
				currentState = "resultsList";
				if(configSearchText.length){
					if(configSpatialSearchLayers.length){
						wTemplate.selectedTitlebarButtonIndex = 4;
					}else{
						wTemplate.selectedTitlebarButtonIndex = 3;
					}
				}else{
					if(configSpatialSearchLayers.length){
						wTemplate.selectedTitlebarButtonIndex = 3;
					}else{
						wTemplate.selectedTitlebarButtonIndex = 2;
					}
				}
			}
			
			private function showStateSpatialSearch():void
			{
				lState = currentState;
				currentState = "spatialInput";
			}
			
			private function widgetClosedHandler(event:Event):void
			{
				setMapAction(null, null, null, null);
				graphicsLayer.visible = false;
				if(graGraphicsLayer){
					graGraphicsLayer.visible = false;
				}
				hideInfoWindow();
				setMapNavigation(null, null);
				
				if (selectedDrawingIcon){
					selectedDrawingIcon = null;
				}
			}
			
			private function graphicsLayer_hideHandler(event:FlexEvent):void
			{
				hideInfoWindow();
			}
			
			private function sldrDataTipFormatter(value:Number):String 
			{ 
				return int(value * 100) + "%"; 
			}
			
			private function zoomAll():void
			{
				if(resultsFeatureSet){
					if (resultsFeatureSet.features.length == 1 
						&& resultsFeatureSet.features[0].geometry.type == Geometry.MAPPOINT){
						var mp:MapPoint = resultsFeatureSet.features[0].geometry as MapPoint;
						map.zoom(1 / 16, mp);
						map.centerAt(mp);
					}else{
						var graphicsExtent:Extent = GraphicUtil.getGraphicsExtent(resultsFeatureSet.features);
						map.extent = graphicsExtent.expand(zoomPercent);
						// make sure the whole extent is visible
						if (!map.extent.contains(graphicsExtent.expand(zoomPercent))){
							map.level--;
						}
					}
				}
			}
			
			private function geometryService_faultHandler(event:FaultEvent):void
			{
				Alert.show(event.fault.toString(), wTemplate.widgetTitle, 4, wTemplate);
			}
			
			private function iconRollOverHandler(event:MouseEvent):void
			{
				clearSelectionFilter();
				event.target.filters = [ glowFilter ];
			}
			
			private function iconRollOutHandler(event:MouseEvent):void
			{
				clearSelectionFilter();
			}
			
			private function clearSelectionFilter():void
			{
				for (var i:int = 0; i < imageGroup.numChildren; i++){
					if (imageGroup.getChildAt(i).filters && imageGroup.getChildAt(i).filters.length > 0){
						if (!(selectedDrawingIcon && imageGroup.getChildAt(i) === selectedDrawingIcon)){
							if(imageGroup.getChildAt(i)!== eDrawBtn && imageGroup.getChildAt(i)!== pBufferBtn){
								imageGroup.getChildAt(i).filters = [];
							}
						}
					}
				}
			}
			
			private function sharedDataUpdated(event:AppEvent):void
			{
				var data:Object = event.data;
				
				if (data.key == "Deactivate_DrawTool"){
					setMapAction(null, null, null, null);
					if (selectedDrawingIcon){
						selectedDrawingIcon.filters = [];
						selectedDrawingIcon = null;
					}
				}
			}
			
			private function hideInfoWindow():void
			{
				if (map.infoWindow.contentOwner &&
					((map.infoWindow.contentOwner is Graphic && Graphic(map.infoWindow.contentOwner).graphicsLayer === graphicsLayer) || map.infoWindow.contentOwner is Map)){
					map.infoWindow.hide();
				}
			}
			
			private function DisplayVersion(evt:MouseEvent):void
			{
				if(evt.altKey){
					Alert.show("Enhanched Search Widget Version: " + VERSION + "\nBuild Date: " + BUILDDATE, 
						wTemplate.widgetTitle, 4, null, null, iconClass);
				}
			}
			
			protected function searchGroupItem_focusInHandler(evt:FocusEvent):void {
				var idx:int = searchGroup.getElementIndex(evt.currentTarget as IVisualElement);
				var lay:VerticalLayout = searchGroup.layout as VerticalLayout;
				if (lay.fractionOfElementInView(idx) < 1) {
					pth.valueBy = lay.getScrollPositionDeltaToElement(idx).y + 3;
					anim.play([lay]);
				}
			}			
			
			protected function buffGraCfgBtn_clickHandler(event:MouseEvent):void
			{
				showGraPops.play();
			}
			
			protected function buffCfgBtn_clickHandler(event:MouseEvent):void
			{
				showGraPops2.play();
			}
			
			protected function bufGraPropsApplyBtn_clickHandler(event:MouseEvent):void
			{
				hideGraPops.play();
			}
			
			protected function bufPropsApplyBtn_clickHandler(event:MouseEvent):void
			{
				hideGraPops2.play();
			}
			
			protected function determineDropDownWidth(arr:Object):Number
			{
				var maxLength:Number = 0;
				var i:int=0;
				
				for ( i = 0; i < arr.length; i++ ) {
					var o:Object = arr[i];
					if ( ObjectUtil.isSimple(o["label"]) ) {
						var cellMetrics:TextLineMetrics = lblLayerText.measureText(o["label"]+"");
						if ( cellMetrics.width + 40 > maxLength ) {
							maxLength = cellMetrics.width + 40;
						}
					}
				}
				return maxLength;
			}
			
			/*
			* gets the configuration object for the currently selected search expression
			* 	@method
			*   @private
			*   @returns Object			
			*/
			private function currentSearchExpression(): Object{
				
				var i:Number = (cboLayerText.selectedIndex < 0) ? 0 : cboLayerText.selectedIndex;
				var j:Number = (cboLayerExpr.selectedIndex < 0) ? 0 : cboLayerExpr.selectedIndex;

				return configSearchText[i].expr[j];
			}
			
			/*
			 * checks that requirements have been met to allow a search 
			 *  and enables the search button
			 * 	@method
			 *  @public		
			*/
			public function validateSearch():void
			{
				// check that child searchexpvalueitems are valid
				
				var sItemVal:SearchExpValueItem;
				var isValid:Boolean = true;
				var hasAValue:Boolean = false; // does at least one criteria have a value
				for(var sgi:Number = 0; sgi < searchGroup.numElements; sgi++){
					sItemVal = searchGroup.getElementAt(sgi) as SearchExpValueItem;
					if (!sItemVal.isValid())
					{
						isValid = false;
					};
					
					if (sItemVal.hasAValue())
					{
						hasAValue = true;
					}
				};
				
				var expression:Object = currentSearchExpression();
				var isRequired:Boolean = expression.isValueRequired; // does the expression require that at least 1 value is given
				
				var canSearch:Boolean = false;
				if (isRequired && !hasAValue)
				{
					canSearch = false;
				}
				else
				{
					canSearch = true;
				};
				
				searchBtn.enabled = (canSearch && isValid);	
			}
			
			
		]]>
	</fx:Script>
	
	<viewer:WidgetTemplate id="wTemplate"
						   closed="widgetClosedHandler(event)"
						   open="widgetOpenedHandler(event)"
						   width="400" height="240"
						   minHeight="160"
						   minWidth="210"
						   visible="false" >
		<s:Group id="textInput"
				 width="100%" height="100%"
				 visible="false"
				 visible.textInput="true">
			<s:layout>
				<s:VerticalLayout gap="4" horizontalAlign="center"/>
			</s:layout>
			<s:HGroup id="boxText"
					  width="100%"
					  gap="15"
					  horizontalAlign="center" verticalAlign="middle">
				<s:Label id="lblLayerText" text="{layerLabel}"/>
				<s:DropDownList id="cboLayerText" change="searchLayerChangedText()"/>
			</s:HGroup>
			<s:HGroup id="boxTextexpr"
					  width="100%"
					  gap="15"
					  horizontalAlign="center"  verticalAlign="middle">
				<s:Label id="lblExprText" text="{layerExprLabel}" />
				<s:DropDownList id="cboLayerExpr" change="searchLayerExprChangedText()"/>
			</s:HGroup>
			<s:RichEditableText id="txtLabelText"
			 		 selectable="true"
					 editable="false"
					 width="100%"
					 text=""
					 textAlign="center"
					 tabEnabled="false" tabFocusEnabled="false"/>
			<s:Scroller width="100%" height="100%" hasFocusableChildren="true">
				<s:VGroup id="searchGroup" width="100%" paddingTop="3" paddingBottom="3">
					<Search:SearchExpValueItem width="100%" wTemplateWidth="{wTemplate.width}" />
				</s:VGroup>
			</s:Scroller>
			<s:HGroup width="100%" horizontalAlign="center"  verticalAlign="middle">
				<s:Button id="searchBtn" label="{submitLabel}"/>
				<s:Button click="clear()" label="{clearLabel}"/>
			</s:HGroup>
		</s:Group>
		<s:Group id="graphicalInput"
				 width="100%" height="100%"
				 visible="false"
				 visible.graphicalInput="true">
			<s:layout>
				<s:VerticalLayout gap="6" horizontalAlign="center"/>
			</s:layout>
			<s:HGroup id="boxGraphical"
					  width="100%"
					  gap="15"
					  horizontalAlign="center" verticalAlign="middle">
				<s:Label id="lblLayerGraphical" text="{layerLabel}"/>
				<s:DropDownList id="cboLayerGraphical" change="searchLayerChangedGraphical()"/>
			</s:HGroup>
			<s:Label id="txtLabelGraphical"
					 width="100%"
					 text=""
					 textAlign="center"/>
			<s:HGroup id="imageGroup"
					  width="100%"
					  gap="10"
					  horizontalAlign="center">
				<s:Image id="eDrawBtn"
						  width="40" height="40"
						  click="getDrawGra()"
						  source= "{WIDGET_URL + 'i_draw_draw.png'}"
						  toolTip="{drawGraLabel}" 
						  visible="{eDrawEnabled}"
						  includeInLayout="{eDrawEnabled}" />
				<s:Image id="pBufferBtn"
						  width="40" height="40"
						  click="getBufferGra()"
						  source= "{WIDGET_URL + 'i_draw_buffer.png'}"
						  toolTip="{bufferGraLabel}" 
						  visible="{pBufferEnabled}"
						  includeInLayout="{pBufferEnabled}" />
				<s:Image id="iSearchPnt"
						  name="{DrawTool.MAPPOINT}"
						  width="40" height="40"
						  buttonMode="true"
						  click="{activateSearchTool(event)}"
						  rollOut="iconRollOutHandler(event)"
						  rollOver="iconRollOverHandler(event)"
						  source="assets/images/i_draw_point.png"
						  toolTip="{pointLabel}"
						  useHandCursor="true"/>
				<s:Image id="iSearchLine"
						  name="{DrawTool.POLYLINE}"
						  width="40" height="40"
						  buttonMode="true"
						  click="{activateSearchTool(event)}"
						  rollOut="iconRollOutHandler(event)"
						  rollOver="iconRollOverHandler(event)"
						  source="assets/images/i_draw_line.png"
						  toolTip="{lineLabel}"
						  useHandCursor="true"/>
				<s:Image id="iSearchExt"
						  name="{DrawTool.EXTENT}"
						  width="40" height="40"
						  buttonMode="true"
						  click="{activateSearchTool(event)}"
						  rollOut="iconRollOutHandler(event)"
						  rollOver="iconRollOverHandler(event)"
						  source="assets/images/i_draw_rect.png"
						  toolTip="{rectangleLabel}"
						  useHandCursor="true"/>
				<s:Image id="iSearchPoly"
						  name="{DrawTool.POLYGON}"
						  width="40" height="40"
						  buttonMode="true"
						  click="{activateSearchTool(event)}"
						  rollOut="iconRollOutHandler(event)"
						  rollOver="iconRollOverHandler(event)"
						  source="assets/images/i_draw_poly.png"
						  toolTip="{polygonLabel}"
						  useHandCursor="true"/>
			</s:HGroup>
			<s:HGroup width="100%"
					  horizontalAlign="center"
					  verticalAlign="middle"
					  paddingRight="10"
					  paddingTop="2" gap="10">
				<s:CheckBox id="graMultiChk" selected="{multiPartGraphicSearch}" label="{enableMultiPartSearch}" change="graMultiChanged()"/>
				<s:Button id="graFeatureQueryBtn" click="queryFeaturesGra()" label="{submitLabel}"/>
				<s:Label buttonMode="true"
						 click="clear()"
						 fontWeight="bold"
						 text="{clearLabel}"
						 textDecoration="underline"/>
			</s:HGroup>
			<s:CheckBox id="addTolerance" selected="{applyTolleranceByDefault}" label="{lblTolerance}"/>
			<s:Group>
				<s:layout>
					<s:BasicLayout />
				</s:layout>
				<s:Image toolTip="{includetextquerywarnTip}" visible="{(cboLayerGraphical.selectedItem != cboLayerText.selectedItem)}"
						 width="{includeTextQuery.width}" height="{includeTextQuery.height}"
						 source="{WIDGET_URL + 'blank.png'}" fillMode="repeat"
						 includeInLayout="{(cboLayerGraphical.selectedItem != cboLayerText.selectedItem)}"/>
				<s:CheckBox id="includeTextQuery" selected="false" label="{lblInclueTextQuery}"
					 	enabled="{(cboLayerGraphical.selectedItem == cboLayerText.selectedItem)}" />
			</s:Group>
			<s:HGroup verticalAlign="middle">
				<s:CheckBox id="bufferUserGraphic" selected="false" label="{lblbufferUserGraphic}"/>
				<s:TextInput id="textGraInputBuffer" text="50" width="40" />
				<s:DropDownList id="cboGraBufferUnit" />
				<s:Group>
					<s:Image source="{WIDGET_URL + 'i_gearsmall.png'}" width="22" height="22" smooth="true"
						 toolTip="{configbuffergraTip}" buttonMode="true" 
						 useHandCursor="true" id="buffGraCfgBtn" click="buffGraCfgBtn_clickHandler(event)"/>
					<s:PopUpAnchor id="graphicPopUp" 
								   left="0" bottom="22" 
								   popUpPosition="right" 
								   styleName="popUpBox">
						<s:BorderContainer width="225" height="160" 
										   backgroundAlpha="{getStyle('backgroundAlpha')}" 
										   backgroundColor="{getStyle('chromeColor')}"
										   borderColor="{getStyle('accentColor')}"
										   cornerRadius="8">
							<s:VGroup width="100%" height="100%" horizontalAlign="center" verticalAlign="middle"
									  paddingBottom="2" paddingLeft="5" paddingRight="5" paddingTop="2">
								<s:Label text="{buffergrapicpropsLbl}" />
								<s:HGroup width="100%" gap="10" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferColorLabel}" />
									<mx:ColorPicker id="cpGraBufferColor" selectedColor="#01b9fd" enabled="{!chkNoBufferFill.selected}"/>
									<s:CheckBox id="chkNoBufferFill" label="{nobuffercolorlbl}" selected="false" />
								</s:HGroup>
								<s:HGroup width="100%" gap="5" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferAlphaLabel}" />
									<s:HSlider id="hsGraBufferAlpha" width="55" value="0.3" minimum="0" maximum="1" snapInterval="0.1"
											   dataTipFormatFunction="sldrDataTipFormatter"
											   skinClass="widgets.eSearch.skins.alphaSliderSkin"/>
								</s:HGroup>
								<s:HGroup width="100%" gap="5" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferoutlinecolorlbl}" />
									<mx:ColorPicker id="cpGraBufferOLColor" selectedColor="#01b9fd" enabled="{!chkNoBufferOutline.selected}"/>
									<s:CheckBox id="chkNoBufferOutline" label="{nobufferoutlinecolorlbl}" selected="false" />
								</s:HGroup>
								<s:HGroup width="100%" gap="5" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferoutlinewidthlbl}" />
									<s:NumericStepper id="linewidth"
													   maximum="5"
													   minimum="0.1"
													   stepSize="0.1"
													   value="1" width="50"/>
								</s:HGroup>
								<s:HGroup horizontalAlign="right" width="100%" paddingRight="5">
									<s:Button label="Apply" id="bufGraPropsApplyBtn" click="bufGraPropsApplyBtn_clickHandler(event)" />
								</s:HGroup>
							</s:VGroup>
						</s:BorderContainer>
					</s:PopUpAnchor>
				</s:Group>
			</s:HGroup>
		</s:Group>
		<s:Group id="spatialInput"
				 width="100%" height="100%"
				 visible="false"
				 visible.spatialInput="true">
			<s:layout>
				<s:VerticalLayout gap="6" horizontalAlign="center"/>
			</s:layout>
			<s:Label id="lblBuffer" text="{bufferLabel}" width="100%"/>
			<s:HGroup verticalAlign="middle">
				<s:TextInput id="textInputBuffer" text="50" width="40" />
				<s:DropDownList id="cboBufferUnit" />
				<s:Group>
					<s:Image source="{WIDGET_URL + 'i_gearsmall.png'}" width="22" height="22" smooth="true"
							 toolTip="{configbuffergraTip}" buttonMode="true" 
							 useHandCursor="true" id="buffCfgBtn" click="buffCfgBtn_clickHandler(event)"/>
					<s:PopUpAnchor id="graphicPopUp2" 
								   left="0" bottom="22" 
								   popUpPosition="right" 
								   styleName="popUpBox">
						<s:BorderContainer width="225" height="160" 
										   backgroundAlpha="{getStyle('backgroundAlpha')}" 
										   backgroundColor="{getStyle('chromeColor')}"
										   borderColor="{getStyle('accentColor')}"
										   cornerRadius="8">
							<s:VGroup width="100%" height="100%" horizontalAlign="center" verticalAlign="middle"
									  paddingBottom="2" paddingLeft="5" paddingRight="5" paddingTop="2">
								<s:Label text="{buffergrapicpropsLbl}" />
								<s:HGroup width="100%" gap="10" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferColorLabel}" />
									<mx:ColorPicker id="cpBufferColor" selectedColor="#01b9fd" enabled="{!chkNoBufferFill.selected}"/>
									<s:CheckBox id="chkNoBufferFill2" label="{nobuffercolorlbl}" selected="false" />
								</s:HGroup>
								<s:HGroup width="100%" gap="5" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferAlphaLabel}" />
									<s:HSlider id="hsBufferAlpha" width="55" value="0.3" minimum="0" maximum="1" snapInterval="0.1"
											   toolTip="{bufferAlphaLabel}" dataTipFormatFunction="sldrDataTipFormatter"
											   skinClass="widgets.eSearch.skins.alphaSliderSkin"/>
								</s:HGroup>
								<s:HGroup width="100%" gap="5" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferoutlinecolorlbl}" />
									<mx:ColorPicker id="cpBufferOLColor" selectedColor="#01b9fd" toolTip="{bufferColorLabel}" />
									<s:CheckBox id="chkNoBufferOutline2" label="{nobufferoutlinecolorlbl}" selected="false" />
								</s:HGroup>
								<s:HGroup width="100%" gap="5" horizontalAlign="left" verticalAlign="middle">
									<s:Label text="{bufferoutlinewidthlbl}" />
									<s:NumericStepper id="linewidth2"
													  maximum="5"
													  minimum="0.1"
													  stepSize="0.1"
													  value="1" width="50"/>
								</s:HGroup>
								<s:HGroup horizontalAlign="right" width="100%" paddingRight="5">
									<s:Button label="Apply" id="bufPropsApplyBtn" click="bufPropsApplyBtn_clickHandler(event)" />
								</s:HGroup>
							</s:VGroup>
						</s:BorderContainer>
					</s:PopUpAnchor>
				</s:Group>
			</s:HGroup>
			<s:HGroup width="100%" gap="20" horizontalAlign="center" verticalAlign="middle">
				<s:Image width="40" height="40"
						  buttonMode="true"
						  click="applyBuffer()"
						  source="{WIDGET_URL + 'i_buffer.png'}"
						  toolTip="{applyBufferLabel}"
						  useHandCursor="true"/>
				<s:Image width="40" height="40"
						  buttonMode="true"
						  click="clearBuffer()"
						  source="assets/images/i_clear.png"
						  toolTip="{clearLabel}"
						  useHandCursor="true"/>
			</s:HGroup>	
			<s:Line xFrom="0" xTo="350" yFrom="0" yTo="0">
				<s:stroke>
					<s:SolidColorStroke color="0xFFFFFF" weight="1"/>
				</s:stroke>
			</s:Line>
			<s:Label id="lblSearchLayerSpatial" text="{searchLayerLabel}" width="100%"/>
			<s:DropDownList id="cboSearchLayerSpatial" />
			<s:HGroup id="SpatialOps" width="100%" gap="0" horizontalAlign="center" verticalAlign="middle" />		
		</s:Group>
		<!-- result-->
		<s:Group id="resultsList"
				 width="100%" height="100%"
				 visible="false"
				 visible.resultsList="true">
			<s:layout>
				<s:VerticalLayout gap="1"/>
			</s:layout>
			<s:HGroup id="boxMessage"
					  width="100%"
					  includeInLayout="{msgVisible}"
					  visible="{msgVisible}" verticalAlign="middle" horizontalAlign="center">
				<s:SWFLoader id="swfMessage"
							 source="assets/images/loader.swf"
							 visible="false"/>
				<s:Label id="txtMessage"
						 width="90%"
						 text=""/>
				<s:Label buttonMode="true" textAlign="right"
						 click="zoomAll()"
						 fontWeight="bold"
						 includeInLayout="{graphicsLayer.numGraphics &gt; 0}"
						 text="{zoomallLabel}"
						 textDecoration="underline"
						 toolTip="{zoomallTip}"
						 visible="{graphicsLayer.numGraphics &gt; 0}"/>
				<s:Label buttonMode="true" textAlign="right"
						 click="clear()"
						 fontWeight="bold"
						 includeInLayout="{searchResultAC.length &gt; 0}"
						 text="{clearLabel}"
						 textDecoration="underline"
						 visible="{searchResultAC.length &gt; 0}"/>
			</s:HGroup>
			<s:Scroller id="recVbox" width="100%" height="100%">
				<Search:SearchResultDataGroup id="searchResultDG"
											  dataProvider="{searchResultAC}"
											  searchResultClick="clickSearchResult(event)"
											  searchResultMouseOut="mouseOutSearchResult(event)"
											  searchResultMouseOver="mouseOverSearchResult(event)"
											  searchResultRelateClick="preClickSearchRelateResult(event)">
					<Search:layout>
						<s:VerticalLayout gap="2"
										  horizontalAlign="justify"
										  useVirtualLayout="true"/>
					</Search:layout>
				</Search:SearchResultDataGroup>
			</s:Scroller>
		</s:Group>
	</viewer:WidgetTemplate>
</viewer:BaseWidget>