[GeoServer활용]ArcGIS / FingerEyes-Xr for Flex 적용_V1

[공공칠빵]

[GeoServer활용]ArcGIS /  FingerEyes-Xr  for Flex에 적용 1단계

기존 응용개발한 프로그램들은 안정적으로 구축하거나 발주처에서 지정하여 상용 GIS서버엔진을 사용해왔습니다.

예전엔 여러 국내/국외 엔진으로 구축을 요청하다가, 거의 악악(Arc GIS)거려서 아크로 개발하다가

요즘은 또 프로젝트 규모에 따른 비용절감과 Open Source Open API  Open Data을 좋아해서

특정업체에 얽매이지 않는 GIS서버엔진을 사용해 달라는 주문이 들어오기 시작했다 ㅠㅠ.

1단계에서 GeoServer를 사용해 기존 개발툴에 적용해보기로하였습니다.

point, polyline, polygon Shape형식을 반영하였습니다.

"ArcGIS for Flex"엔진을 기반으로한 F-GIS/Pro와 "FingerEyes-Xr"을 기반으로한 Xr-GIS/Pro를 대상으로 함.

* GeoServer 쿼리 등 참조 사이트

  https://wiki.state.ma.us/confluence/display/massgis/GeoServer+-+WFS+-+Examples

이전글, [GeoServer활용]GeoServer설치/설정 

        , [GeoServer활용]ArcGIS for Flex기반의 F-GIS/Pro에 적용

        , [GeoServer활용]FingerEyes-Xr  for Flex기반의 Xr-GIS/Pro에 적용

1.  "ArcGIS for Flex"엔진을 기반으로한 F-GIS/Pro를 GeoServer의 벡터데이터로 중첩하는 기능입니다.

    예제실행 : http://smartwater.gsconst.co.kr/ArcBizGIS_Pro.html

2.  "FingerEyes-Xr  for Flex"엔진을 기반으로한 Xr-GIS/Pro를 GeoServer의 벡터데이터로 중첩하는 기능입니다.

    예제실행 : http://smartwater.gsconst.co.kr/WebGIS_Xr.html

* 가상포트 IP를 사용하는 PC급 서버라서 매우 느린 환경에서 테스트중입니다. 다소 쿼리가 느리지만 객체 파서와 캐시로

  표출은 빠르게 유지하며 테스트 중입니다.

 GeoServer는 공유, 분석 및 개방형 표준을 사용하여 모든 주요 공간 데이터 소스 지리 공간 데이터를 편집하는 강력한지도 기능 서버입니다. 먼저 윈도우 또는 맥, 리눅스용 설치본을 다운로드 받아 서버에 설치합니다.

GeoServer를 설치하고 실행하면, GeoServer설정할수있는 웹사이트창으로 설정할 수 있는데 오픈인지만 설정 UI가 참 잘 구성되어 있습니다. 국내용은 이런 설정이나 번들 프로그램에 목숨걸고 개발하지는 않지요 ㅠㅠ

GeoServer에 여러 형식의 레이어를 올릴 수 있습니다

위 사이트에서 새 작업 공간과 데이터 저장소를 순서대로 만듭니다.(생략)

Shapefile파일을 특정 폴더에 넣습니다, 그리고 레이어 생성창에서 아래처럼 설정합니다.

스타일 설정도 있는데 TMS나 WMS로 사용할게 아니고 벡터 그대로 WFS방식을 사용할것임므로 스타일 설정은 응용 프로그램에서 해도 됩니다, 필드로 주제도도 만들려면 벡터로 사용하는것이 좋습니다,

 다만 많은 개수를 뿌릴려면 스타일을 예쁘게해서 WMS나 KML등으로 해도됩니다.

 * DBF등 언어설정 EUC-KR, 좌표계정의, crossdomain문제

주요소스

1.  "ArcGIS for Flex"엔진을 기반으로한 F-GIS/Pro

 package com.esri.wfs.tasks
{
 import com.esri.ags.FeatureSet;
 import com.esri.ags.Graphic;
 import com.esri.ags.SpatialReference;
 import com.esri.ags.geometry.MapPoint;
 import com.esri.ags.geometry.Polygon;
 import com.esri.ags.geometry.Polyline;
 import com.esri.wfs.events.WFSQueryEvent;
 
 import flash.events.EventDispatcher;
 import flash.net.URLRequest;
 import flash.utils.ByteArray;
 
 import mx.collections.ArrayCollection;
 import mx.rpc.AsyncResponder;
 import mx.rpc.AsyncToken;
 import mx.rpc.Fault;
 import mx.rpc.IResponder;
 import mx.rpc.events.FaultEvent;
 import mx.rpc.events.ResultEvent;
 import mx.rpc.http.mxml.HTTPService;

 /**
  * Dispatched when a task call fails.
  * @eventType mx.rpc.events.FaultEvent.FAULT
  */
 [Event(name="fault", type="mx.rpc.events.FaultEvent")]
 
 /**
  * Dispatched when a query task successfully completes.
  * @eventType com.esri.wfs.events.WFSQueryEvent.EXECUTE_COMPLETE
  */
 [Event(name="executeComplete", type="com.esri.wfs.events.WFSQueryEvent")]
 
 [Bindable]
 
 /**
  * Executes a query operation on a WFS endpoint exposed by the ArcGIS Server.
  * @see com.esri.ags.tasks.FeatureSet
  * @see com.esri.wfs.events.WFSQueryEvent
  * @see com.esri.wfs.tasks.WFSQuery
  */
 public class WFSQueryTask extends EventDispatcher
 {
  private static const SERVICE :String = "WFS";
  private static const VERSION :String = "1.1.0";
  private static const OUTPUT_FORMAT :String = "text/xml; subType=gml/3.1.1";
  private static const WFS :Namespace = new Namespace("http://www.opengis.net/wfs");
  private static const GML :Namespace = new Namespace("http://www.opengis.net/gml");
  private static const OGC :Namespace = new Namespace("http://www.opengis.net/ogc");
  private static const OWS :Namespace = new Namespace("http://www.opengis.net/ows");
  private static const XLINK :Namespace = new Namespace("http://www.w3.org/1999/xlink");
  
  private var m_url :String;
  private var m_proxyURL :String;
  
  
  protected var id :String = "";
  
  /** The last result of the execute function. */
  public var executeLastResult :FeatureSet;
  
  /** The request timeout in seconds. A value less than or equal to zero prevents request timeout. */
  public var requestTimeout :Number = -1;
  
  /** Shows the busy cursor until the task has completed. */
     public var showBusyCursor : Boolean = false;

  /**
      * Creates a new WFSQueryTask object used to execute a query on the WFS endpoint identified by the URL.
      * @param url [optional] URL to the ArcGIS Server WFS endpoint.
      */
  public function WFSQueryTask( url :String = null )
  {
   super();
         m_url = url;
  }
  
  /** The whole set of features.
  public function get featureSetAttributes() :ArrayCollection
  {
   return attributes;
  }
  */
  
  /**
      * @private
      * Called after the implementing object has been created and all component properties specified on the MXML tag have been initialized.
      * @param document The MXML document that created this object.
      * @param id The identifier used by document to refer to this object.
      */
  public function initialized( document :Object, id :String ) :void
  {
   this.id = id;
  }
  
  /**
      * URL to the ArcGIS Server WFS endpoint. For more information on constructing a URL, see Using ArcGIS Services Directory.
      */
  public function get url() :String
  {
      return m_url;
  }

  /** @private */
  public function set url( value :String ) :void
  {
   if( m_url != value )
   {
       m_url = value;
    }
  }
  
  /** The URL to proxy the request through. */
  public function get proxyURL() :String
  {
   return m_proxyURL;
  }
  
  /** @private */
  public function set proxyURL( value :String ) :void
  {
   if( m_proxyURL != value )
   {
    m_proxyURL = value;
   }
  }
  
  /**
   * Executes the WFS query. The final results or fault will be directed to the given responder, if one is set.
   * @param query The WFSQuery object which controls aspects of the response and parsing of the response.
   * @param responder The IResponder which will handle the results, or fault, if one is set.
   */
  public function execute( query :WFSQuery = null, responder :IResponder = null ) :void
  {
   if( query == null )
   {
    return;
   }
   getFeatures( query, responder );
  }
  
  /**
   * @private
   * Executes a WFS GetFeature request. The final results or fault will be directed to the given responder, if one is set.
   * @param query the WFSQuery object which controls aspects of the GetFeature request and parsing of the response.
   * @param responder the IResponder which will handle the results, or fault, if one is set.
   */
  private function getFeatures( query :WFSQuery, responder :IResponder ) :void
  {
   //var getFeatureXML :XML = createGetFeatureRequest( query );
   var service :HTTPService = createService();
   
   var extentParam:String = "";
   if( query.extent != null )
   {
    extentParam = "&CQL_FILTER=BBOX("+ query.shapeField +","
     + getCoordinates( query.extent.xmin, query.extent.ymin, query.swapCoordinates )
     + "," + getCoordinates( query.extent.xmax, query.extent.ymax, query.swapCoordinates )
     + ")";
   }
   service.url = service.url + extentParam;
   //service.url = service.url + "&CQL_FILTER=(OBJECTID=6 AND DMA="+ encodeURIComponent("'산수6'") +")";
              //"&FILTER=" + getFeatureXML.toXMLString();
            var token :AsyncToken = service.send( ); //getFeatureXML
   token.addResponder( new AsyncResponder(
    function onSuccess( result :ResultEvent, token :Object = null ) :void
    {
     handleResult( query, result, responder, handleFeatures );
    },
    function onFailure( error :FaultEvent, token :Object = null ) :void
    {
     handleFault( error, responder );
    },
    this
   ) );
  }
  
  //***********************************************************************************************************
  //한글깨짐
  public static function convertStringToByteArray(key:String):ByteArray
  {
   var bytes:ByteArray;
   if ( key) {
    bytes = new ByteArray();
    // writeUTFBytes(value:String) let UTF-8 String write into byte stream;
    bytes.writeUTFBytes(key);
   }
   return bytes;
  }
  public function encodeUtf8(key:String):String
  {
   if(key){     
    var oriByteArr:ByteArray = new ByteArray();
    oriByteArr.writeUTFBytes(key);
    
    oriByteArr.position=0
    //if(getFileType(oriByteArr)!="ANSI") return key;
    
    var tempByteArr : ByteArray = new ByteArray();
    for (var i:int = 0; i<oriByteArr.length; i++)
    {
     if (oriByteArr[i] == 194)
     {
      tempByteArr.writeByte(oriByteArr[i+1]);
      i++;
     } else if (oriByteArr[i] == 195)
     {
      tempByteArr.writeByte(oriByteArr[i+1] + 64);
      i++;
     } else
     {
      tempByteArr.writeByte(oriByteArr[i]);
     }
    }
    tempByteArr.position = 0;
    convertStringToByteArray(key);
    return tempByteArr.readMultiByte(tempByteArr.bytesAvailable,"euc-kr");
    //return tempByteArr.readMultiByte(tempByteArr.bytesAvailable,"utf-8");
   }else{
    return key;
   }
  }
  /**
   * @private
   * Creates and returns the FeatureSet based on the given XML.
   * @param query the WFSQuery object which controls aspects of the parsing of the FeatureSet.
   * @param xml the XML from which the FeatureSet will be created.
   * @return the new FeatureSet object.
   */
  private function toFeatures( query :WFSQuery, xml :XML ) :FeatureSet
  {
   var swapCoordinates :Boolean = query.swapCoordinates;
   var featureSet :FeatureSet = new FeatureSet();
   
   // retrieve the well known id from the srsName ex: urn:x-ogc:def:crs:EPSG:6.9:4326
   //var wkids :Array = xml..GML::Envelope.@srsName.split( ":" );
   var wkids :Array = query.srsName.split( ":" );
   var wkid :Number = new Number( wkids[wkids.length - 1] );
   featureSet.spatialReference = new SpatialReference( wkid );
   
   // retrieve all features
   var features :ArrayCollection = new ArrayCollection();
   var attributes :ArrayCollection = new ArrayCollection();
   var aliases :Object = new Object();
   //trace(xml.toXMLString());
   //for each( var featureMember :XML in xml..GML::featureMember )
   for each( var featureMember :XML in xml.children() )
   {
    try{
     var children :XMLList = featureMember.children();
     for each( var child :XML in children )
     {
      var graphic :Graphic = createGraphic( attributes, aliases, child, query, featureSet.spatialReference );
      features.addItem( graphic );
     } 
    } catch (err:Error) {
    }
   }
   
   
   featureSet.features = features.source;
   //featureSet.attributes = attributes.source;
   featureSet.fieldAliases = aliases;
   return featureSet;
  }
  
  /**
   * @private
   * Creates and returns a new Graphic based on the XML feature.
   * @param attributes an ArrayCollection containing a list of all attributes that will be updated if new attributes are found.
   * @param aliases an Object that maps all attribute names with their aliases. At this time all aliases are equal to the attribute name.
   * @param feature the XML feature definition.
   * @param query the WFSQuery object that controls aspects of the feature parsing.
   * @param spatialReference the SpatialReference object that will be applied to the geometry, if query.returnGeometry is true.
   * @return the new Graphic object.
   */
  private function createGraphic(
   attributes :ArrayCollection,
   aliases :Object,
   feature :XML,
   query :WFSQuery,
   spatialReference :SpatialReference ) :Graphic
  {
   var graphic :Graphic = new Graphic;
   graphic.attributes = new Object();
   
   // save the GML feature id as GML_FEATURE_ID
   graphic.attributes.GML_FEATURE_ID = feature.@fid.toString();//feature.@GML::id;
   
   // retrieve the feature attributes
   for each( var attribute :XML in feature.children() )
   {
    var attributeName :String = attribute.name().toString();
    var nameElements :Array = attributeName.split( "::" );
    var name :String = nameElements[nameElements.length - 1];
    // create the feature geometry
    if( name.toLowerCase() == query.shapeField.toLowerCase() && query.returnGeometry )
    {
     createGeometry( graphic, attribute.children(), query, spatialReference );
    }
    // add the attribute if appropriate
    else
    {
     if( ( query.excludeFields && !query.excludeFields.contains( name.toLowerCase() ) ) || query.excludeFields == null )
     {
      if( !attributes.contains( name ) )
      {
       attributes.addItem( name );
       aliases[name] = name;
      }
      graphic.attributes[name] = attribute;
     }
    }
   }
   return graphic;
  }

  /**
   * @private
   * Creates and sets the Graphic.geometry based on the GML shape.
   * @param graphic the Graphic which the geometry will be applied to.
   * @param geometry the XMLList of GML shapes.
   * @param query the WFSQuery object which controls aspects of the geometry parsing.
   * @param spatialReference the SpatialReference object to apply to the geometry.
   */
  private function createGeometry(
   graphic :Graphic,
   geometry :XMLList,
   query :WFSQuery,
   spatialReference :SpatialReference ) :void
  {
   for each( var shape :XML in geometry )
   {
    var shapeType :String = shape.name();
    var typeElements :Array = shapeType.split( "::" );
    var type :String = typeElements[typeElements.length - 1];
    
    if( type == "Point" )
    {
     graphic.geometry = createPoint( shape, query.swapCoordinates, spatialReference );
    }
    else if( type == "Polygon" || type == "Surface" )
    {
     graphic.geometry = createPolygon( shape, query.swapCoordinates, spatialReference );
    }
    else if( type == "LineString" || type == "Curve")
    {
     graphic.geometry = createLine( shape, query.swapCoordinates, spatialReference );
    }
    else if( type == "MultiSurface" || type == "MultiPolygon")
    {
     graphic.geometry = createMultiPolygon( shape, query.swapCoordinates, spatialReference );
    }
    else if( type == "MultiCurve" || type == "MultiLineString" )
    {
     graphic.geometry = createMultiLine( shape, query.swapCoordinates, spatialReference );
    }
   }
  }
  
  /**
   * @private
   * Creates and returns a Polyline object based on the GML "MultiCurve" shape.
   * @param shape the XML object which contains the GML shape.
   * @param swapCoordinates if true, use the "y x" format to define points, otherwise use the "x y" format.
   * @param spatialReference the SpatialReference object to apply to the Polyline.
   * @return the Polyline object.
   */
  private function createMultiLine( shape :XML, swapCoordinates :Boolean, spatialReference :SpatialReference ) :Polyline
  {
   var line :Polyline = new Polyline();
   line.spatialReference = spatialReference;
   for each( var path :String in shape..GML::LineString..GML::coordinates ) //posList
   {
    line.addPath( createPointArray( path, swapCoordinates, spatialReference ) );
   }
   for each( path in shape..GML::Curve..GML::coordinates ) //posList
   {
    line.addPath( createPointArray( path, swapCoordinates, spatialReference ) );
   }
   
   
   return line;
  }
  
  /**
   * @private
   * Creates and returns a Polyline object based on the GML "Curve" or "LineString" shape.
   * @param shape the XML object which contains the GML shape.
   * @param swapCoordinates if true, use the "y x" format to define points, otherwise use the "x y" format.
   * @param spatialReference the SpatialReference object to apply to the Polyline.
   * @return the Polyline object.
   */
  private function createLine( shape :XML, swapCoordinates :Boolean, spatialReference :SpatialReference ) :Polyline
  {
   var line :Polyline = null;
   var lines :XML = shape..GML::coordinates; //posList
   if( lines )
   {
    line = new Polyline();
    for each( var coordinates :String in lines )
    {
     line.addPath( createPointArray( coordinates, swapCoordinates, spatialReference ) );
    }
   }
   return line;
  }
  
  /**
   * @private
   * Creates and returns a Polygon object based on the GML "MutliSurface" shape.
   * @param shape the XML object which contains the GML shape.
   * @param swapCoordinates if true, use the "y x" format to define points, otherwise use the "x y" format.
   * @param spatialReference the SpatialReference object to apply to the Polygon.
   * @return the Polygon object.
   */
  private function createMultiPolygon( shape :XML, swapCoordinates :Boolean, spatialReference :SpatialReference ) :Polygon
  {
   // grab both the gml:exterior and gml:interior gml:posList elements and let Flash decide what is a hole using the even/odd algorithm
   // if we have to deal with winding direction in the future, simply grab the gml:exterior and gml:interior gml:posList elements separately,
   // and then make sure to reverse the array returned by createRing() for the gml:interior gml:posList
   //trace(shape.toXMLString());
   
   var polygon :Polygon = new Polygon();
   polygon.spatialReference = spatialReference;
   for each( var ring :String in shape..GML::Polygon..GML::coordinates ) //posList
   {
    polygon.addRing( createPointArray( ring, swapCoordinates, spatialReference ) );
   }
   for each( ring in shape..GML::Surface..GML::coordinates ) //posList
   {
    polygon.addRing( createPointArray( ring, swapCoordinates, spatialReference ) );
   }
   polygon.extent.spatialReference = spatialReference;
   polygon.extent.center.spatialReference = spatialReference;
   return polygon;
  }
  
  /**
   * @private
   * Creates and returns a Polygon object based on the GML "Surface" or "Polygon" shape.
   * @param shape the XML object which contains the GML shape.
   * @param swapCoordinates if true, use the "y x" format to define points, otherwise use the "x y" format.
   * @param spatialReference the SpatialReference object to apply to the Polygon.
   * @return the Polygon object.
   */
  private function createPolygon( shape :XML, swapCoordinates :Boolean, spatialReference :SpatialReference ) :Polygon
  {
   // grab both the gml:exterior and gml:interior gml:posList elements and let Flash decide what is a hole using the even/odd algorithm
   // if we have to deal with winding direction in the future, simply grab the gml:exterior and gml:interior gml:posList elements separately,
   // and then make sure to reverse the array returned by createRing() for the gml:interior gml:posList
   var polygon :Polygon = null;
   var rings :XML = shape..GML::coordinates; //posList
   if( rings )
   {
    polygon = new Polygon();
    for each( var ring :String in rings )
    {
     polygon.addRing( createPointArray( ring, swapCoordinates, spatialReference ) );
    }
   }
   return polygon;
  }
  
  /**
   * @private
   * Creates and returns an array of MapPoint objects based on the string of coordinates.
   * @param coordinates a space-delimited set of point coordinates.
   * @param swapCoordinates if true, use the "y x" format to define points, otherwise use the "x y" format.
   * @param spatialReference the SpatialReference object to apply to the MapPoint objects within the Array.
   * @return the Array of MapPoint objects.
   */
  private function createPointArray( coordinates :String, swapCoordinates :Boolean, spatialReference :SpatialReference ) :Array
  {
   var points :Array = new Array();
   var coords :Array = coordinates.split( " " );
   for( var i :int = 0; i < coords.length; i++)
   {
    var PointXY :Array = coords[i].split( "," );
    
    if( swapCoordinates )
    {
     points.push( new MapPoint( PointXY[1], PointXY[0], spatialReference ) );
    }
    else
    {
     points.push( new MapPoint( PointXY[0], PointXY[1], spatialReference ) );
    }
   }
   return points;
  }
  
  /**
   * @private
   * Creates and retuns a MapPoint based on the GML "Point" shape.
   * @param shape the XML object which contains the GML shape.
   * @param swapCoordinates if true, use the "y x" format to define points, otherwise use the "x y" format.
   * @param spatialReference the SpatialReference object to apply to the MapPoint.
   * @return the MapPoint object.
   */
  private function createPoint( shape :XML, swapCoordinates :Boolean, spatialReference :SpatialReference ) :MapPoint
  {
   var point :MapPoint = null;
   for each( var pos :String in shape..GML::coordinates )
   {
    var coords :Array = pos.split( "," );
    if( swapCoordinates )
    {
     point = new MapPoint( coords[1], coords[0], spatialReference);
    }
    else
    {
     point = new MapPoint( coords[0], coords[1], spatialReference );
    }
   }
   return point;
  }
  
  /**
   * @private
   * Handle a successful WFS FeatureCollection response.
   * @param query the WFSQuery object which controls aspects of a successful FeatureCollection response.
   * @param xml the FeatureCollection XML object.
   * @param responder the IResponder that will handle the result, if one is given.
   */
  private function handleFeatures( query :WFSQuery, xml :XML, responder :IResponder ) :void
  {
   executeLastResult = toFeatures( query, xml );
   if( responder )
   {
    responder.result( executeLastResult );
   }
   dispatchEvent( new WFSQueryEvent( WFSQueryEvent.EXECUTE_COMPLETE, executeLastResult ) );
  }
  
  /**
   * @private
   * Handles the result of a given WFS request.
   * @param query the WFSQuery object which controls aspects of a successful response.
   * @param result the ResultEvent.
   * @param responder the IResponder that will handle the final successful result, if one is given.
   * @param operation the operation that will handle a successful result response.'
   */
  private function handleResult( query :WFSQuery, result :ResultEvent, responder :IResponder, operation :Function ) :void
  {
   if( result.result == "" )
   {
    handleStrErr( "Empty Result. Check Input Parameters.", responder );
   }
   else
   {
    try
             {
     var xml :XML = new XML(result.result);//result.result as XML;
     //trace(xml.toXMLString());
     if( xml.name() == OWS + "::ExceptionReport" )
                 {
                     this.handleErr( xml, responder );
                 }
                 else
                 {
                     operation.call( this, query, xml, responder );
                 }
             }
             catch( resultError :Error )
             {  
                 var resultFault : Fault = new Fault( null, resultError.message );
                 if( responder )
                 {
                     responder.fault( new FaultEvent( FaultEvent.FAULT, false, true, resultFault ) );
                 }
             }
   }
  }
  
  /**
   * @private
   * Handles a simple error.
   * @param error the error message as a String.
   * @param responder the IResponder that will handle the generated Fault.
   */
  private function handleStrErr( error :String, responder :IResponder ) :void
  {
   var stringFault :Fault = new Fault( null, error );
         if( responder )
         {
             responder.fault( stringFault );
         }
         dispatchEvent( new FaultEvent( FaultEvent.FAULT, false, true, stringFault ) );
  }
  
  /**
   * @private
   * Handles a WFS ExceptionReport. Also creates and passes a Fault to the provided responder, if one is given.
   * @param xml the ExceptionReport XML object.
   * @param responder the IResponder that will handle the generated Fault.
   */
  private function handleErr( xml :XML, responder :IResponder ) :void
  {
   var faultCode :String = xml.OWS::Exception.@exceptionCode;
   var faultString :String = xml..OWS::ExceptionText;
   var fault : Fault = new Fault( faultCode, faultString );
   fault.rootCause = xml;
   if( responder )
   {
       responder.fault( fault );
   }
   dispatchEvent( new FaultEvent( FaultEvent.FAULT, false, true, fault ));
  }

  /**
   * @private
   * Handles a fault event. Also passes the Fault to the responder, if one is given.
   * @param event the FaultEvent.
   * @param responder the IResponder that will handle the generated Fault.
   */
  private function handleFault( event :Object, responder :IResponder ) :void
  {
   if( responder )
   {
       responder.fault( event );
   }
   
   if( event is Fault )
   {
    event = new FaultEvent( FaultEvent.FAULT, false, true, event as Fault );
   }
   if( event is Object )
   {
    event = new FaultEvent( FaultEvent.FAULT, false, true, new Fault( "", event.toString() ) );
   }
   dispatchEvent( event as FaultEvent );
  }
  
  /**
   * @private
   * Creates and returns an HTTPService object.
   * @return the new HTTPService object for sending a WFS request.
   */
  private function createService() :HTTPService
  {
   var service :HTTPService = new HTTPService();
   if( proxyURL )
   {
    service.url = proxyURL + "?" + url;
   }
   else
   {
    service.url = url;
   }
   service.method = "POST";
   //service.contentType = "application/xml";
      service.resultFormat = "text"; //"e4x";
      service.requestTimeout = requestTimeout;
      service.showBusyCursor = showBusyCursor;
   service.useProxy = false;
   return service;
  }
  
  /**
   * @private
   * Creates and returns the XML for a WFS GetFeature request. The method uses the WFSQuery input to control variable aspects of the GetFeature request.
   * @param query the WFSQuery object that provides input for the variable aspects of the request.
   * @return the GetFeature request as an XML object.
   */
  private function createGetFeatureRequest( query :WFSQuery ) :XML
  {
   //outputFormat={OUTPUT_FORMAT} //not supported by tinyows
   var xml :XML =
    <wfs:GetFeature xmlns:wfs={WFS} xmlns:gml={GML} xmlns:ogc={OGC} xmlns:ows={OWS} xmlns:xlink={XLINK}
   xmlns:ns={query.featureNamespace}
   version={VERSION} service={SERVICE} >
    <wfs:Query typeName={"ns:" + query.featureName} srsName={query.srsName}>
    </wfs:Query>
   </wfs:GetFeature>;
   
    
   // limit the number of features in the response
   if( query.maxFeatures > 0 )
   {
    xml.@maxFeatures = query.maxFeatures;
   }
   
   // limit the response to include specific feature properties
   // this is according to the WFS-T 1.1.0 spec, but doesn't alter the ArcGIS output
   if( query.outFields != null )
   {
    for each( var field :String in query.outFields )
    {
     var outField :XML = <ogc:PropertyName xmlns:ogc={OGC} xmlns:ns={query.featureNamespace}>{"ns:" + field}</ogc:PropertyName>;
     xml.WFS::Query.appendChild( outField );
    }
   }
   
   // limit the response to include features within the given extent
   if( query.extent != null )
   {
    //<gml:lowerCorner>{getCoordinates( query.extent.xmin, query.extent.ymin, query.swapCoordinates )}</gml:lowerCorner>
    //<gml:upperCorner>{getCoordinates( query.extent.xmax, query.extent.ymax, query.swapCoordinates )}</gml:upperCorner>
    /*
    var filter :XML =
     <ogc:Filter xmlns:ogc={OGC} xmlns:gml={GML} xmlns:wfs={WFS}>
      <ogc:BBOX>
       <ogc:PropertyName>{query.shapeField}</ogc:PropertyName>
       <gml:Envelope xmlns:gml={GML} >
        <gml:lowerCorner xmlns:gml={GML}>{getCoordinates( query.extent.xmin, query.extent.ymin, query.swapCoordinates )}</gml:lowerCorner>
        <gml:upperCorner xmlns:gml={GML}>{getCoordinates( query.extent.xmax, query.extent.ymax, query.swapCoordinates )}</gml:upperCorner>
       </gml:Envelope>
      </ogc:BBOX>
     </ogc:Filter>;
    */
    var filter :XML =
     <ogc:Filter xmlns:ogc={OGC} xmlns:gml={GML} xmlns:wfs={WFS}>
      <ogc:BBOX>
       <ogc:PropertyName>{query.shapeField}</ogc:PropertyName>
              <gml:Box>
                 <gml:coordinates>{getCoordinates( query.extent.xmin, query.extent.ymin, query.swapCoordinates ) + " " + getCoordinates( query.extent.xmax, query.extent.ymax, query.swapCoordinates )}</gml:coordinates>
              </gml:Box>
      </ogc:BBOX>
     </ogc:Filter>;
    
    xml..WFS::Query.appendChild( filter );
   }
   
   var filter2 :XML =
    <ogc:Filter xmlns:ogc={OGC} xmlns:gml={GML} xmlns:wfs={WFS}>
      <ogc:PropertyIsEqualTo matchCase="true">
           <ogc:PropertyName>DMA</ogc:PropertyName>
           <ogc:Literal>산수6</ogc:Literal>
                 </ogc:PropertyIsEqualTo>
    </ogc:Filter>;
   //xml.WFS::Query.appendChild( filter2 );
   
   trace(xml.toXMLString());
   return filter2;
  }
  
  /**
   * @private
   * Return the coordinates of a point in the format "x y". If swapCoordinates is true, returns the coordinates in "y x" format.
   * @param x the x coordinate.
   * @param y the y coordinate.
   * @return the coordinate string.
   */
  private function getCoordinates( x :Number, y :Number, swapCoordinates :Boolean ) :String
  {
   return ( swapCoordinates ? y + "," + x : x + "," + y );
  }
 }
}

2.  "FingerEyes-Xr  for Flex"엔진을 기반으로한 Xr-GIS

 package draw
{
 import com.adobe.xml.syndication.kml.Feature;
 
 import draw.wfs.tasks.WFSQuery;
 
 import flash.display.DisplayObject;
 import flash.display.Shape;
 import flash.display.Sprite;
 import flash.events.Event;
 import flash.events.IOErrorEvent;
 import flash.events.SecurityErrorEvent;
 import flash.filters.GlowFilter;
 import flash.geom.Point;
 import flash.net.URLLoader;
 import flash.net.URLLoaderDataFormat;
 import flash.net.URLRequest;
 import flash.net.URLRequestMethod;
 import flash.utils.ByteArray;
 import flash.utils.Endian;
 
 import geoservice.XrMapSprite;
 import geoservice.base.*;
 import geoservice.data.*;
 import geoservice.data.XrShapeSet;
 import geoservice.edit.*;
 import geoservice.edit.sketch.*;
 import geoservice.events.XrAfterUpdateLayerEvent;
 import geoservice.services.XrSpatialQueryResult;
 import geoservice.view.label.XrLabel;
 import geoservice.view.layers.XrLayer;
 import geoservice.view.layers.XrShapeMapLayer;
 import geoservice.view.themes.*;
 
 import mx.collections.ArrayCollection;
 import mx.core.*;
 import mx.messaging.AbstractConsumer;
 import mx.messaging.management.Attribute;
 import mx.rpc.AsyncResponder;
 import mx.rpc.AsyncToken;
 import mx.rpc.Fault;
 import mx.rpc.IResponder;
 import mx.rpc.events.FaultEvent;
 import mx.rpc.events.ResultEvent;
 import mx.rpc.http.HTTPService;

 public final class XrShapeMapLayerEx extends XrLayer implements IXrEditableLayer, IXrSnapableLayer
 {
  private var _shapeSet:XrShapeSet = null;
  private var _attributeSet:XrAttributeSet = null;
  private var _theme:IXrShapeThemeEx = null;
  private var _svrUrl:String = null;
  private var _layerNameServerSide:String = null;
  private var _connected:Boolean = false;
  private var _bCallUpdateButFailed_:Boolean = false;
  private var _ldr:URLLoader = null;
  //private var _bitmapBuffer:XrBitmapBuffer = null;
  private var _label:XrLabelEx = null;
  private var _highlightRow:int = -1;
  private var _requestAttributeAlways:Boolean = false;
  private var _queryByGeometryCallbackFunction:Function = null;
  private var _noCache:Boolean = false;  
  public var filterFunction:Function = null;
  
  private var bNowUpdatingByService:Boolean = false;
  public var beforeUpdatingByServiceFunction:Function = null;
  public var afterUpdatingByServiceFunction:Function = null;
  
  private var _shapeAsBitmap:Boolean = false;
  
  private var _whereClause:String = "null";

  private var _polygonClipMode:Boolean = false;  //srhong007 ClipMode
  private var SetCoord_TMtoLongitude:Function;
  private var SetCoord_LongitudeToTM:Function;
  public var org_Coordinate:int = 4;
  public var current_Coordinate:int = 2;
  
  private var m_proxyURL :String;
  public var requestTimeout :Number = -1;
  public var showBusyCursor : Boolean = false;
  private static const SERVICE :String = "WFS";
  private static const VERSION :String = "1.1.0";
  private static const OUTPUT_FORMAT :String = "text/xml; subType=gml/3.1.1";
  private static const WFS :Namespace = new Namespace("http://www.opengis.net/wfs");
  private static const GML :Namespace = new Namespace("http://www.opengis.net/gml");
  private static const OGC :Namespace = new Namespace("http://www.opengis.net/ogc");
  private static const OWS :Namespace = new Namespace("http://www.opengis.net/ows");
  private static const XLINK :Namespace = new Namespace("http://www.w3.org/1999/xlink");
  
  private var service :HTTPService;
  private var m_wfsQuery :WFSQuery = new WFSQuery();
  private var Shp_type:int = -1;
  
  private var _MinX:Number = Number.MAX_VALUE;
  private var _MinY:Number = Number.MAX_VALUE;
  private var _MaxX:Number = -Number.MAX_VALUE;
  private var _MaxY:Number = -Number.MAX_VALUE;
  
  // connectionString example
  //  http://127.0.0.1:8080/Xr?layerName=sbld
  public function XrShapeMapLayerEx(_Shp_type:int, name:String, connectionString:String, TMtoLLFunction:Function = null, LLtoTMFunction:Function = null, CoordinateNum:int = 4)
  {
   super(name, connectionString);
   
   //_Shp_type POINT_TYPE:int = 0; // "p", POLYLINE_TYPE:int = 1; // "L", POLYGON_TYPE:int = 2; // "A", MULTIPOINT_TYPE:int = 3; // 'P'
   Shp_type = _Shp_type;
   
   this.SetCoord_TMtoLongitude=TMtoLLFunction!=null?TMtoLLFunction:_TMtoLongitude;
   this.SetCoord_LongitudeToTM=LLtoTMFunction!=null?LLtoTMFunction:_LongitudeToTM;
   
   _ldr = new URLLoader();
   _ldr.dataFormat = URLLoaderDataFormat.TEXT;
   
   var strArr:Array = connectionString.split("?");
   if(strArr.length == 2)
   {
    _svrUrl = connectionString;//srhong strArr[0];
    
    var strLayerNameElement:String = strArr[1].toString();
    var strQueryStringLayerName:String = "typeName";//srhong "layerName=";
    var indexEqualChar:int = strLayerNameElement.indexOf(strQueryStringLayerName);
    if(indexEqualChar >= 0)
    {
     _layerNameServerSide = strLayerNameElement.substr(indexEqualChar + strQueryStringLayerName.length);
    }  
   }
   
   _label = new XrLabelEx(null, this);
   _theme = new XrSingleColorThemeEx();
   
   m_wfsQuery.returnGeometry = true;
   m_wfsQuery.featureName = _layerNameServerSide;
   m_wfsQuery.featureNamespace = _layerNameServerSide;
   m_wfsQuery.outFields = new ArrayCollection();
   m_wfsQuery.swapCoordinates = false;
   //m_wfsQuery.extent = map.extent;
   
  }
  
  public function get outFields() :ArrayCollection
  {
   return m_wfsQuery.outFields;
  }
  
  /** @private */
  public function set outFields( value :ArrayCollection ) :void
  {
   if( m_wfsQuery.outFields != value )
   {
    m_wfsQuery.outFields = value;
   }
  }
  
  override public function connect():Boolean
  {
   if(!_connected)
   {
    var reqeustString:String = _svrUrl.substr(0, _svrUrl.indexOf("?")+1)  + "SERVICE=WFS&REQUEST=GetCapabilities"
    var request:URLRequest = new URLRequest(reqeustString);
    _ldr.addEventListener(IOErrorEvent.IO_ERROR, onConnectRequestIOError);
    _ldr.addEventListener(Event.COMPLETE, onConnectRequestCompleted);
    _ldr.addEventListener(SecurityErrorEvent.SECURITY_ERROR, function (event:SecurityErrorEvent):void{
    });
    try
    {
     _ldr.load(request);
    }
    catch(error:SecurityError)
    {
     trace("A SecurityError has occurred.");
     return false;
    }
   }
   
   return true;
  }
  
  private function onConnectRequestCompleted(e:Event):void
  {
   try
   {
    var data:XML = new XML(_ldr.data);
    if(data == null)
    {
     trace("data is null");
    }
    else
    {
     _connected = processConnectionData(data);
     
     if(_connected)
     {
      _ldr.addEventListener(IOErrorEvent.IO_ERROR, updateErrorHandler);
      _ldr.addEventListener(Event.COMPLETE, updateCompleteHandler);      
     }
     
     if(_bCallUpdateButFailed_)
     {
      update(true, false, false, true, 0, 0);
     }      
    }
   }
   catch(e:TypeError)
   {
    trace("Could not parsing connection data.", layerName);
   }
   finally
   {
    _ldr.removeEventListener(IOErrorEvent.IO_ERROR, onConnectRequestIOError);
    _ldr.removeEventListener(Event.COMPLETE, onConnectRequestCompleted);  
   } 
  }
  
  private function processConnectionData(data:XML):Boolean
  {
   //var totalDataLength:int = data.readInt();
   //if(totalDataLength == 0) return false;
   /* Layer MBR
   var LayerLisr:XMLList = data.FeatureTypeList;
   trace(LayerLisr.toXMLString())
   for each( var LayerInfoS:XML in LayerLisr)
   {
    trace(LayerInfoS.toXMLString());
   }
   
   mbr.min.x = data.readFloat();
   mbr.min.y = data.readFloat();
   mbr.max.x = data.readFloat();
   mbr.max.y = data.readFloat();
   
   var pLatLngMax :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.max.x, mbr.max.y);
   var cenMaxXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMax[0], pLatLngMax[1]);
   mbr.max.x = cenMaxXY.x;
   mbr.max.y = cenMaxXY.y;
   var pLatLngMin :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.min.x, mbr.min.y);
   var cenMinXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMin[0], pLatLngMin[1]);
   mbr.min.x = cenMinXY.x;
   mbr.min.y = cenMinXY.y;
   */
   _shapeSet = new XrShapeSet(Shp_type);
   _attributeSet = new XrAttributeSet();
   
   var fieldCount: int = outFields.length;
   for(var iField:int=0; iField<fieldCount; ++iField)
   {
    var _Field:XrField = new XrField("X", outFields[iField]); //STRING_TYPE:String = "X";
    this._attributeSet.fieldSet.addField( _Field );
   }
   
   return true;
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  override public function update(bLevelChanged:Boolean, bMouseMove:Boolean, bLButtonDown:Boolean, bLButtonUp:Boolean, xMouseMoveOffset:int, yMouseMoveOffset:int):void
  {
   if(_connected)
   {    
    if(bLevelChanged)// && dynamicMode)
    {
     removeAllChild();
     
     if(_label.labelView == null)
     {
      //trace("setting labelView");
      _label.labelView = map.labelView;
     }
     
     _label.labelView.removeAllLabels();
    }
    
    //.   layerVisible   visibleByLevel
    //trace(this.layerName, "needDraw", needDraw, layerVisible, visibleByLevel); 
    if(!needDraw && !_label.needDraw(viewControls))
    {
     return; 
    }
    //.   
        
    if(bLButtonUp || bLevelChanged)
    {
     var currentMBR:XrExtent = new XrExtent();
     currentMBR.min.x = coordMapper.V2W_X(0);
     if(isNaN(currentMBR.min.x)) {
      return;
      trace("Current MBR is NULL so stop.."); 
     }     
     
     currentMBR.min.y = coordMapper.V2W_Y(_height);
     currentMBR.max.x = coordMapper.V2W_X(_width);
     currentMBR.max.y = coordMapper.V2W_Y(0); 
     
     var pLatLngMax :Array = SetCoord_TMtoLongitude(current_Coordinate, currentMBR.max.x, currentMBR.max.y);
     var cenMaxXY :Point = SetCoord_LongitudeToTM(org_Coordinate, pLatLngMax[0], pLatLngMax[1]);
     currentMBR.max.x = cenMaxXY.x;
     currentMBR.max.y = cenMaxXY.y;
     var pLatLngMin :Array = SetCoord_TMtoLongitude(current_Coordinate, currentMBR.min.x, currentMBR.min.y);
     var cenMinXY :Point = SetCoord_LongitudeToTM(org_Coordinate, pLatLngMin[0], pLatLngMin[1]);
     currentMBR.min.x = cenMinXY.x;
     currentMBR.min.y = cenMinXY.y;
     
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////
     try
     {
      if(beforeUpdatingByServiceFunction != null) beforeUpdatingByServiceFunction(layerName);

      if(bNowUpdatingByService)
      {
       if(service)service.cancel();
       if(afterUpdatingByServiceFunction != null) afterUpdatingByServiceFunction(layerName, false);
      }
      
      //trace(this.layerName + "requested!");
      bNowUpdatingByService = true;
      
      m_wfsQuery.extent = currentMBR;
      //var getFeatureXML :XML = createGetFeatureRequest( m_wfsQuery );
      service = createService();
      var extentParam:String = "";
      if( m_wfsQuery.extent != null )
      {
       extentParam = "&CQL_FILTER=BBOX("+ m_wfsQuery.shapeField +","
        + getCoordinates( m_wfsQuery.extent.min.x, m_wfsQuery.extent.min.y, m_wfsQuery.swapCoordinates )
        + "," + getCoordinates( m_wfsQuery.extent.max.x, m_wfsQuery.extent.max.y, m_wfsQuery.swapCoordinates )
        + ")";
      }
      service.url = service.url + extentParam;
      var token :AsyncToken = service.send(  );//getFeatureXML
      
      token.addResponder( new AsyncResponder(
       function onSuccess( result :ResultEvent, token :Object = null ) :void
       {
        handleResult( m_wfsQuery, result, handleFeatures );
       },
       function onFailure( error :FaultEvent, token :Object = null ) :void
       {
        updateErrorHandler(null);
       }
      ) );
     }
     catch(error:SecurityError)
     {
      trace("A SecurityError has occurred.");
      return;
     }
     
     //trace("ShapeMapLayer update");
    }
    else
    {
     var cntShapes:int = numChildren;
     for(var iShape:int=0; iShape<cntShapes; ++iShape)
     {
      var shape:XrShapeSprite = getChildAt(iShape) as XrShapeSprite;
      
      shape.x = coordMapper.W2V_X(shape.originX);
      shape.y = coordMapper.W2V_Y(shape.originY);
     }
     //srhong007 ClipMode
     if(this._polygonClipMode && (this._shapeSet.shapeType == XrShape.POLYGON_TYPE)){
      _theme.drawToGraphicEx(this);
     }
    }
   }
   else
   {
    //trace("not ready", layerName);
    _bCallUpdateButFailed_ = true;
   }
  } 
  /////////////////////////////////////////////////////////////////////////////////
  private function updateErrorHandler(e:IOErrorEvent):void
  {
   bNowUpdatingByService = false;
   
   trace("update fail: " + layerName);
   
   if(afterUpdatingByServiceFunction != null) afterUpdatingByServiceFunction(layerName, false);
  }
  
  private function updateCompleteHandler(e:Event):void
  {
   bNowUpdatingByService = false;
   
   var data:ByteArray = _ldr.data as ByteArray;
   
   if(data == null)
   {
    trace("data is null");
   }
   else
   {
    processRequestData(data);
   }
   
   if(afterUpdatingByServiceFunction != null) {
    afterUpdatingByServiceFunction(layerName, true);
   }
  }
  private function processRequestData(data:ByteArray):void
  {
   data.endian = Endian.LITTLE_ENDIAN;
   
   var totalDataLength:int = data.readInt();
   if(totalDataLength > 0)
   {
    var shapeDataLength:int = data.readInt();
    var attributeDataLength:int = data.readInt();
    
    var fidList:Array = processShapeDataPart(data, shapeDataLength, shapeSet, attributeSet);
    processAttributeDataPart(data, attributeDataLength, fidList, attributeSet);
    
    if(filterFunction != null)
    {
     var cntFids:uint = fidList.length;
     //var shps:Object = shapeSet.rows;
     //var atts:Object = attributeSet.rows;
     var fid:uint;
     for(var i:uint=0; i<cntFids; ++i)
     {
      fid = fidList[i];
      filterFunction(fid, this, i, cntFids);
     }     
    }
    
    drawShape();   
   }
  }
  ////////////////////////////////////////////////////////////////////////////////
  private function handleFeatures( query :WFSQuery, xml :XML ) :void
  {
   bNowUpdatingByService = false;
   trace(xml.toXMLString());
   
   var shp:IXrShape;
   var shapes:Object = shapeSet.rows;
   for each (shp in shapes)
   {
    if(shp.editCount == 0)
    {
     //shapeSet.removeRow(shp.fid);
     //attributeSet.removeRow(shp.fid);
     
     shp.invalid = true;
    }
   }
   //shapeSet.clear();
   /////////////////////////////////////////////////////////////
   var swapCoordinates :Boolean = query.swapCoordinates;
   var wkids :Array = query.srsName.split( ":" );
   var wkid :Number = new Number( wkids[wkids.length - 1] );
   var fidList:Array = new Array();
   for each( var featureMember :XML in xml.children() )
   {
    try{
     var children :XMLList = featureMember.children();
     for each( var feature :XML in children )
     {
      var fidString:String = feature.@fid.toString();
      if(!fidString){
       continue;
      }
      var fid:uint = int(fidString.substr(fidString.indexOf(".")+1));
      
      shp = shapeSet.rows[fid];
      if(shp){
       shp.invalid = false;
      }else{
       fidList.push(fid);
       var Xr_attribute:XrAttribute = new XrAttribute();
       for each( var attribute :XML in feature.children() )
       {
        var attributeName :String = attribute.name().toString();
        var nameElements :Array = attributeName.split( "::" );
        var name :String = nameElements[nameElements.length - 1];
        if( name.toLowerCase() == query.shapeField.toLowerCase() && query.returnGeometry )
        {
         createGeometry( fid, attribute.children(), query );
        }else{
         if( ( query.excludeFields && !query.excludeFields.contains( name.toLowerCase() ) ) || query.excludeFields == null )
         {
          /*
          if( this._attributeSet.fieldSet.getFieldIndex( name ) < 0){
           var _Field:XrField = new XrField("X", name); //STRING_TYPE:String = "X";
           this._attributeSet.fieldSet.addField( _Field ); 
          }
          */
          if( this._attributeSet.fieldSet.getFieldIndex( name ) >= 0)
          {
           var stringTypeVal‎ue:String = attribute.toString();
           Xr_attribute.addValue(stringTypeVal‎ue);
           
          }
         }
        }
       }
       this._attributeSet.addRow(fid, Xr_attribute);
      }
     } 
    } catch (err:Error) {
    }
   }
   /////////////////////////////////////////////////////
   for each (shp in shapes)
   {
    if(shp.editCount == 0 && shp.invalid)
    {
     shapeSet.removeRow(shp.fid);
     attributeSet.removeRow(shp.fid);
    }
   }
   
   if(afterUpdatingByServiceFunction != null) {
    afterUpdatingByServiceFunction(layerName, true);
   }
   ////////////////////////////////////////////////////
   if(filterFunction != null)
   {
    var cntFids:uint = fidList.length;
    //var shps:Object = shapeSet.rows;
    //var atts:Object = attributeSet.rows;
    for(var i:uint=0; i<cntFids; ++i)
    {
     fid = fidList[i];
     filterFunction(fid, this, i, cntFids);
    }     
   }
   
   drawShape();
  }
  private function createGeometry(
   fid:uint,
   geometry :XMLList,
   query :WFSQuery) :void
  {
   var newShp:IXrShape;
   for each( var shape :XML in geometry )
   {
    newShp = null;
    
    var shapeType :String = shape.name();
    var typeElements :Array = shapeType.split( "::" );
    var type :String = typeElements[typeElements.length - 1];
    
    if( type == "Point" )
    {
     newShp = createPoint(fid, shape, query.swapCoordinates );
    }
    else if( type == "Polygon" || type == "Surface" )
    {
     //graphic.geometry = createPolygon( shape, query.swapCoordinates, spatialReference );
    }
    else if( type == "LineString" || type == "Curve" )
    {
     //graphic.geometry = createLine( shape, query.swapCoordinates, spatialReference );
    }
    else if( type == "MultiSurface" || type == "MultiPolygon")
    {
     newShp = createMultiPolygon(fid, shape, query.swapCoordinates );
    }
    else if( type == "MultiCurve" || type == "MultiLineString" )
    {
     newShp = createMultiLine(fid, shape, query.swapCoordinates ); 
    }
    
    if(newShp != null)
    {
     shapeSet.addRow(newShp);
    }
   }
  }

  private function createMultiPolygon( fid:uint, shape :XML, swapCoordinates :Boolean ) :IXrShape
  {
   var coord:XrCoordinate = null;
   var part:Vector.<XrCoordinate>;
   var parts:Vector.<Vector.<XrCoordinate>> = new Vector.<Vector.<XrCoordinate>>();
   _MinX = Number.MAX_VALUE;
   _MinY = Number.MAX_VALUE;
   _MaxX = -Number.MAX_VALUE;
   _MaxY = -Number.MAX_VALUE;
   
   for each( var ring :String in shape..GML::Polygon..GML::coordinates ) //posList
   {
    part = createPointArray( ring, swapCoordinates );
    parts.push(part);
   }
   for each( ring in shape..GML::Surface..GML::coordinates ) //posList
   {
    part = createPointArray( ring, swapCoordinates );
    parts.push(part);
   }
   
   var mbr : XrExtent = new XrExtent(_MinX, _MinY, _MaxX, _MaxY);
   
   return new XrPolygonShape(fid, mbr, parts);
  }
  
  private function createMultiLine( fid:uint, shape :XML, swapCoordinates :Boolean ) :IXrShape
  {
   var coord:XrCoordinate = null;
   var part:Vector.<XrCoordinate>;
   var parts:Vector.<Vector.<XrCoordinate>> = new Vector.<Vector.<XrCoordinate>>();
   _MinX = Number.MAX_VALUE;
   _MinY = Number.MAX_VALUE;
   _MaxX = -Number.MAX_VALUE;
   _MaxY = -Number.MAX_VALUE;
   
   for each( var ring :String in shape..GML::LineString..GML::coordinates ) //posList
   {
    part = createPointArray( ring, swapCoordinates );
    parts.push(part);
   }
   for each( ring in shape..GML::Curve..GML::coordinates ) //posList
   {
    part = createPointArray( ring, swapCoordinates );
    parts.push(part);
   }
   
   var mbr : XrExtent = new XrExtent(_MinX, _MinY, _MaxX, _MaxY);
   
   return new XrPolylineShape(fid, mbr, parts);
  }
  
  private function createPoint( fid:uint, shape :XML, swapCoordinates :Boolean ) :IXrShape
  {
   var coord:XrCoordinate = null;
   var pts:Array = new Array();
   
   _MinX = Number.MAX_VALUE;
   _MinY = Number.MAX_VALUE;
   _MaxX = -Number.MAX_VALUE;
   _MaxY = -Number.MAX_VALUE;
   
   for each( var pos :String in shape..GML::coordinates )
   {
    var coords :Array = pos.split( "," );
    if( swapCoordinates )
    {
     coord = new XrCoordinate(coords[1], coords[0]);
    }
    else
    {
     coord = new XrCoordinate(coords[0], coords[1]);
    }
    var pLatLng :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
    var cenXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLng[0], pLatLng[1]);
    coord.x = cenXY.x;
    coord.y = cenXY.y;
    
    _MinX = Math.min(_MinX, coord.x);
    _MinY = Math.min(_MinY, coord.y);
    _MaxX = Math.max(_MaxX, coord.x);
    _MaxY = Math.max(_MaxY, coord.y);
    
    pts.push(coord);
   }
   
   var mbr : XrExtent = new XrExtent(_MinX, _MinY, _MaxX, _MaxY);
   return new XrPointShape(fid, mbr, pts);
  }
  
  private function createPointArray( coordinates :String, swapCoordinates :Boolean) :Vector.<XrCoordinate>
  {
   var points:Vector.<XrCoordinate> = new Vector.<XrCoordinate>();
   var coords :Array = coordinates.split( " " );
   for( var i :int = 0; i < coords.length; i++)
   {
    var PointXY :Array = coords[i].split( "," );
    var coord : XrCoordinate;
    if( swapCoordinates )
    {
     coord = new XrCoordinate(PointXY[1], PointXY[0]);
    }
    else
    {
     coord = new XrCoordinate(PointXY[0], PointXY[1]);
    }
    
    var pLatLngPG :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
    var cenXYPG :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngPG[0], pLatLngPG[1]);
    coord.x = cenXYPG.x;
    coord.y = cenXYPG.y;
    
    _MinX = Math.min(_MinX, coord.x);
    _MinY = Math.min(_MinY, coord.y);
    _MaxX = Math.max(_MaxX, coord.x);
    _MaxY = Math.max(_MaxY, coord.y);
    
    points.push(coord);
   }
   
   return points;
  }
  /////////////////////////////////////////////////////////////////////////////////////////////////////
  private function handleResult( query :WFSQuery, result :ResultEvent, operation :Function ) :void
  {
   if( result.result == "" )
   {
    //handleStrErr( "Empty Result. Check Input Parameters.", responder );
   }
   else
   {
    try
    {
     var xml :XML = new XML(result.result);//result.result as XML;
     trace(xml.toXMLString());
     if( xml.name() == OWS + "::ExceptionReport" )
     {
      //this.handleErr( xml, responder );
     }
     else
     {
      operation.call( this, query, xml );
     }
    }
    catch( resultError :Error )
    {  
     
    }
   }
  }
  
  /////////////////////////////////////////////////////////////////////////////////
  private function createGetFeatureRequest( query :WFSQuery ) :XML
  {
   //outputFormat={OUTPUT_FORMAT} //not supported by tinyows
   var xml :XML =
    <wfs:GetFeature xmlns:wfs={WFS} xmlns:gml={GML} xmlns:ogc={OGC} xmlns:ows={OWS} xmlns:xlink={XLINK}
   xmlns:ns={query.featureNamespace}
   version={VERSION} service={SERVICE} >
    <wfs:Query typeName={"ns:" + query.featureName} srsName={query.srsName}>
    </wfs:Query>
   </wfs:GetFeature>;
   
   
   // limit the number of features in the response
   if( query.maxFeatures > 0 )
   {
    xml.@maxFeatures = query.maxFeatures;
   }
   
   // limit the response to include specific feature properties
   // this is according to the WFS-T 1.1.0 spec, but doesn't alter the ArcGIS output
   if( query.outFields != null )
   {
    for each( var field :String in query.outFields )
    {
     var outField :XML = <ogc:PropertyName xmlns:ogc={OGC} xmlns:ns={query.featureNamespace}>{"ns:" + field}</ogc:PropertyName>;
     xml.WFS::Query.appendChild( outField );
    }
   }
   
   // limit the response to include features within the given extent
   if( query.extent != null )
   {
    //<gml:lowerCorner>{getCoordinates( query.extent.xmin, query.extent.ymin, query.swapCoordinates )}</gml:lowerCorner>
    // <gml:upperCorner>{getCoordinates( query.extent.xmax, query.extent.ymax, query.swapCoordinates )}</gml:upperCorner>
    var filter :XML =
     <ogc:Filter xmlns:ogc={OGC} xmlns:gml={GML} xmlns:wfs={WFS}>
      <ogc:BBOX>
       <ogc:PropertyName>{query.shapeField}</ogc:PropertyName>
       <gml:Envelope xmlns:gml={GML} >
        <gml:lowerCorner xmlns:gml={GML}>{getCoordinates( query.extent.min.x, query.extent.min.y, query.swapCoordinates )}</gml:lowerCorner>
        <gml:upperCorner xmlns:gml={GML}>{getCoordinates( query.extent.max.x, query.extent.max.y, query.swapCoordinates )}</gml:upperCorner>
       </gml:Envelope>
      </ogc:BBOX>
     </ogc:Filter>;
    xml..WFS::Query.appendChild( filter );
   }
   return xml;
  }
  private function getCoordinates( x :Number, y :Number, swapCoordinates :Boolean ) :String
  {
   return ( swapCoordinates ? y + "," + x : x + "," + y );
  }
  
  private function createService() :HTTPService
  {
   var service :HTTPService = new HTTPService();
   if( m_proxyURL )
   {
    service.url = m_proxyURL + "?" + _svrUrl;
   }
   else
   {
    service.url = _svrUrl;
   }
   service.method = "POST";
   //service.contentType = "application/xml";
   service.resultFormat = "text"; //"e4x";
   service.requestTimeout = requestTimeout;
   service.showBusyCursor = showBusyCursor;
   service.useProxy = false;
   return service;
  }
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // IXrSnapableLayer
  public function get layerID():String
  {
   // http://127.0.0.1:8080/Xr?layerName=tst_Table
   var keyString:String = "layerName=";
   var startIndex:int = connectionString.indexOf(keyString);
   if(startIndex == -1) return  null;
   
   startIndex += keyString.length;
   var result:String = connectionString.substring(startIndex);
   return result;
  }
  
  public function set requestAttributeAlways(value:Boolean):void
  {
   _requestAttributeAlways = value;
  }
  
  public function get requestAttributeAlways():Boolean
  {
   return _requestAttributeAlways;
  }
  
  private var bToggleHighlighting:Boolean = false;
  private var previousHighlightingTime:Number = 0;
  private function onHighlightingRow(event:Event):void
  {
   //trace("?", highlightRow.toString());
   
   var startHighlighting:Number = flash.utils.getTimer();
   if((startHighlighting-previousHighlightingTime)>300)
   {
    if(highlightRow != -1)
    {
     var shape:DisplayObject = getChildByName(highlightRow.toString());
     if(shape != null)
     {
      if(bToggleHighlighting)
      {
       //trace("- ON");
       shape.filters = [ new GlowFilter(0x00ffff, 1, 6, 6, 3) ];
      }
      else
      {
       //trace("- OFF");
       shape.filters = null
      }
      
      bToggleHighlighting = !bToggleHighlighting;
     }
    }
    
    previousHighlightingTime = startHighlighting;
   }
  }
  
  public function set highlightRow(fid:int):void
  {
   if(hasEventListener(Event.ENTER_FRAME))
    removeEventListener(Event.ENTER_FRAME, onHighlightingRow);
   
   var shape:DisplayObject = getChildByName(highlightRow.toString());
   if(shape != null)
   {
    _highlightRow = -1;
    shape.filters = null;
   }
   
   if(fid != -1)
   {
    if(!hasEventListener(Event.ENTER_FRAME))
     addEventListener(Event.ENTER_FRAME, onHighlightingRow);
   }
   
   _highlightRow = fid;
  }
  
  public function get highlightRow():int
  {
   return _highlightRow;
  }
  
  // IXrSnapableLayer
  public function getSnapVertex(coord:XrCoordinate, distance:Number, edgeSnap:Boolean, vertexSnap:Boolean):XrCoordinate
  {
   var result:XrCoordinate = null;
   
   if(layerVisible && (edgeSnap || vertexSnap))
   {
    var item:IXrShape = null;;
    var snap:IXrSnapableItem;
    for each (item in _shapeSet.rows)
    {
     if(XrGeometryHelper.PointInMBR(item.mbr, coord, distance))
     {
      snap = item as IXrSnapableItem;
      
      if(edgeSnap)
      {
       result = snap.getEdgeSnap(coord, distance);
       if(result != null)
       {
        return result;
       }
      }
     
      if(vertexSnap)
      {
       result = snap.getVertexSnap(coord, distance);
       if(result != null)
       {
        return result;
       }
      }
     }
    }
   }
   
   return result;   
  }
  
  // [FID;uint] [ShapeSize;uint] [MBR;float;float;float;float] [ShapeData;ShapeSize] [AttributeSize;uint] [AttributeData;AttributeSize]
  public function toBinaryData(fid:uint, bOutputShape:Boolean, bOutputAttribute:Boolean, output:ByteArray):Boolean
  {
   var startPos:uint = output.position;
   var oldPos:uint;
   output.endian = Endian.BIG_ENDIAN;
   output.writeUnsignedInt(fid);
   trace("toBinaryData: " + fid);
   var deleted:Boolean = false;
   if(bOutputShape)
   {
    output.position += 4;
    
    var shp:IXrShape = _shapeSet.rows[fid];
    if(shp == null) return false;
    
    var mbr:XrExtent = shp.mbr;
    
    var pLatLngMax :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.max.x, mbr.max.y);
    var cenMaxXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMax[0], pLatLngMax[1]);
    mbr.max.x = cenMaxXY.x;
    mbr.max.y = cenMaxXY.y;
    var pLatLngMin :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.min.x, mbr.min.y);
    var cenMinXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMin[0], pLatLngMin[1]);
    mbr.min.x = cenMinXY.x;
    mbr.min.y = cenMinXY.y;
    
    deleted = shp.deleted;
    if(!deleted)    
    {
     output.writeFloat(mbr.min.x);
     output.writeFloat(mbr.min.y);
     output.writeFloat(mbr.max.x);
     output.writeFloat(mbr.max.y);
     
     trace(fid, mbr.min.x, mbr.min.y, mbr.max.x, mbr.max.y);
     
     var iPart:uint;
     var part:Vector.<XrCoordinate>;
     var iVtx:uint;
     var coord:XrCoordinate;
     
     output.endian = Endian.LITTLE_ENDIAN;
     
     if(shp.type == XrShape.POINT_TYPE)
     {
      var point:XrPointShape = shp as XrPointShape;
     
      if(point.count == 0) return false;

      coord = point.getCoord(0);

      var pLatLng :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
      var cenXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLng[0], pLatLng[1]);
      coord.x = cenXY.x;
      coord.y = cenXY.y;
      
      output.writeFloat(coord.x);
      output.writeFloat(coord.y);
     }
     else if(shp.type == XrShape.POLYLINE_TYPE)
     {
      var polyline:XrPolylineShape = shp as XrPolylineShape;
     
      output.writeFloat(mbr.min.x);
      output.writeFloat(mbr.min.y);
      output.writeFloat(mbr.max.x);
      output.writeFloat(mbr.max.y);
      output.writeShort(polyline.count);

      for(iPart=0; iPart<polyline.count; ++iPart)
      {
       part = polyline.getPolyline(iPart);
       //output.writeShort(part.length);
       output.writeUnsignedInt(part.length);
      }
     
      for(iPart=0; iPart<polyline.count; ++iPart)
      {
       part = polyline.getPolyline(iPart);
       for(iVtx=0; iVtx<part.length; ++iVtx)
       {
        coord = part[iVtx];
        
        var pLatLngPL :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
        var cenXYPL :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngPL[0], pLatLngPL[1]);
        coord.x = cenXYPL.x;
        coord.y = cenXYPL.y;
        
        output.writeFloat(coord.x);
        output.writeFloat(coord.y);
       }
      }        
     }
     else if(shp.type == XrShape.POLYGON_TYPE)
     {
      var polygon:XrPolygonShape = shp as XrPolygonShape;
     
      output.writeFloat(mbr.min.x);
      output.writeFloat(mbr.min.y);
      output.writeFloat(mbr.max.x);
      output.writeFloat(mbr.max.y);
      output.writeShort(polygon.count);
     
      for(iPart=0; iPart<polygon.count; ++iPart)
      {
       part = polygon.getPolygon(iPart);
       //output.writeShort(part.length); 
       output.writeUnsignedInt(part.length);      
      }

      for(iPart=0; iPart<polygon.count; ++iPart)
      {
       part = polygon.getPolygon(iPart);
       for(iVtx=0; iVtx<part.length; ++iVtx)
       {
        coord = part[iVtx];
        
        var pLatLngPG :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
        var cenXYPG :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngPG[0], pLatLngPG[1]);
        coord.x = cenXYPG.x;
        coord.y = cenXYPG.y;
        
        output.writeFloat(coord.x);
        output.writeFloat(coord.y);
       }
      }     
     }
     else
     {
      return false;
     }
    }
    else
    {
     output.writeFloat(-1.0);
     output.writeFloat(-1.0);
     output.writeFloat(-1.0);
     output.writeFloat(-1.0);
    }

    output.endian = Endian.BIG_ENDIAN;
    oldPos = output.position;
    var shpSize:uint = oldPos - (startPos) - 4 - 4 - 4*4;
    output.position = (startPos + 4);
    output.writeUnsignedInt(shpSize);
    output.position = oldPos;
    
    trace("    shp size: " + shpSize);
   }
   else
   {
    output.writeUnsignedInt(0);
   }
   
   if(bOutputAttribute && !deleted)
   {
    output.endian = Endian.LITTLE_ENDIAN;
    var att:XrAttribute = _attributeSet.rows[fid];
    if(att == null) return false;
    
    output.position += 4;
    
    var fs:XrFieldSet = _attributeSet.fieldSet;
    for(var iField:uint=0; iField<fs.length; ++iField)
    {
     var field:XrField = fs.getField(iField);
     var ft:String = field.type;
     
     if(ft == XrField.DOUBLE_TYPE)
     {
      output.writeDouble(att.getValueAsDouble(iField));
     }
     else if(ft == XrField.FLOAT_TYPE)
     {
      output.writeFloat(att.getValueAsDouble(iField));
     }
     else if(ft == XrField.INTEGER_TYPE)
     {
      trace(iField, field.name, att.getValueAsInt(iField));
      output.writeInt(att.getValueAsInt(iField)); 
     }
     else if(ft == XrField.SHORT_INTEGER_TYPE)
     {
      output.writeShort(att.getValueAsInt(iField));
     }
     else if(ft == XrField.VERY_SHORT_INTEGER_TYPE)
     {
      output.writeByte(att.getValueAsInt(iField));
     }     
     else if(ft == XrField.STRING_TYPE)
     {
      var value:String = att.getValueAsString(iField);
      var bytesStr:ByteArray = new ByteArray();
      bytesStr.writeMultiByte(value, "euc-kr");

      output.writeByte(bytesStr.length + 1);
      //output.writeMultiByte(value, "euc-kr");
      output.writeBytes(bytesStr);
      output.writeByte(0);
     }
     else
     {
      trace("Unknown Field Type");
      return false;
     }
    }

    output.endian = Endian.BIG_ENDIAN;
    oldPos = output.position;
    var attSize:uint = oldPos - (startPos) - 4 - 4 - 4*4 - shpSize - 4;
    output.position = startPos + 4 + 4 + 4*4 + shpSize;
    output.writeUnsignedInt(attSize);
    output.position = oldPos;
    trace("    att size: " + attSize);
   }
   else
   {
    output.writeUnsignedInt(0);
   }
   
   return true;
  }
  
  public function getRowEditCount(fid:uint):int
  {
   var shp:IXrShape = _shapeSet.rows[fid];
   
   if(shp == null) return -1;
   
   return shp.editCount;
  }
  
  public function isRowEdited(fid:uint):Boolean
  {
   var shp:IXrShape = _shapeSet.rows[fid];
   
   if(shp == null) return false;
   
   return (shp.editCount > 0);
  }
  
  public function reportEditedRowList():void
  {
   trace("Report Edited Rows");
   trace("------------------");
   var cntEditRows:uint = 0;
   var shp:IXrShape = null;
   var shapes:Object = _shapeSet.rows;
   for each (shp in shapes)
   {
    if(shp.editCount > 0)
    {
     trace(shp.fid, "deleted?", shp.deleted ? "YES":"NO");
     cntEditRows++;
    }
   }

   trace("\ttotal ", cntEditRows);
  }
  
  // IXrEditableLayer
  public function getSketchById(id:uint):IXrSketch
  {
   var shape:IXrShape = _shapeSet.rows[id];
   if(shape != null)
   {
    if(!shape.deleted)
    {
     return  shape.toSketch(this, coordMapper);
    }
   }
   
   return null;
  }
  
  // IXrEditableLayer
  public function getSketchByPoint(x:int, y:int):IXrSketch
  {
   var disObj:DisplayObject;
   for(var i:int=numChildren-1; i>=0; --i)
   {
    disObj = getChildAt(i);
    if(disObj.hitTestPoint(x, y, true))
    {
     var shp:IXrShape = shapeSet.rows[disObj.name];
     return shp.toSketch(this, coordMapper);
    }
   }

   return null;
  }
  
  // IXrEditableLayer
  public function getEditableItem(id:uint):IXrEditableItem
  {
   var shape:IXrShape = _shapeSet.rows[id];
   if(shape != null)
   {
    return shape as IXrEditableItem;
   }   

   return null;
  }
  
  // IXrEditableLayer
  public function addItem(item:IXrEditableItem):Boolean
  {
   var shape:IXrShape = shapeSet.rows[item.id];
   
   if(shape != null && shape.deleted)
   {
    shape.deleted = false;
    //shape.increseEditingCount(); ?
    //update(false, false, false, true, 0, 0); ?
    return true;
   }
   else
   {
    shape = item as IXrShape;
    shape.deleted = false;
    
    if(shapeSet.addRow(shape))
    {
     
     shape.increseEditingCount();
     update(false, false, false, true, 0, 0);
     
     var attr:XrAttribute = attributeSet.createAttribute();
     if(attr != null)
     {
      return attributeSet.addRow(shape.fid, attr);
     }
     else
     {
      return false;
     }
    }
    else
    {
     return false;
    }
   }
  }  
  
  public function createItemFromSketch(sketch:IXrSketch):IXrEditableItem
  {
   var bOK:Boolean = false;
   var shape:XrShape = null;
   
   if(sketch is XrPolygonSketch)
   {
    var ps:XrPolygonSketch = sketch as XrPolygonSketch;
    shape = new XrPolygonShape(sketch.id, null, ps.parts);
    shape.regenMBR();
   }
   else if(sketch is XrPolylineSketch)
   {
    var ls:XrPolylineSketch = sketch as XrPolylineSketch;
    shape = new XrPolylineShape(sketch.id, null, ls.parts);
    shape.regenMBR();
   } 
   else if(sketch is XrPointSketch)
   {
    var pts:XrPointSketch = sketch as XrPointSketch;
    var pointArray:Array = [pts.position];
    
    shape = new XrPointShape(sketch.id, null, pointArray);
    shape.regenMBR();
   }
   
   return shape;
  }

  public function invalidateItem(fid:uint):void
  {
   var shape:IXrShape = _shapeSet.rows[fid];
   if(shape != null && shape.editCount == 0)
   {
    shapeSet.removeRow(fid);
    attributeSet.removeRow(fid);
   } 
  }
  
  // IXrEditableLayer
  public function updateItem(id:uint, bUndo:Boolean):void
  {
   trace("updateItem");
   var shape:IXrShape = _shapeSet.rows[id];
   if(shape != null)
   {
    if(bUndo)
    {
     shape.decreaseEditingCount(); 
    }
    else
    {
     shape.increseEditingCount(); 
    }
    
    //if(shape.editCount == 0)
    //{
    // var disObj:DisplayObject = getChildByName(shape.fid.toString());
    // if(disObj != null)
    // {
    //  removeChild(disObj);
    // }
    //}

    if(shape.deleted)
    {
     //. 
    }
    else
    {
     shape.regenMBR();
     label.updateLabelText(shape.fid);
    }
    
    trace("editCount=", shape.editCount);
    update(false, false, false, true, 0, 0);
   } 

   if(shape == null
    || (shape != null && shape.editCount == 0)
    || (shape != null && shape.deleted))
   {
    var disObj:DisplayObject = getChildByName(id.toString());
    if(disObj != null)
    {
     removeChild(disObj);
    }
   }
  }

  // IXrEditableLayer
  public function deleteItem(id:uint):Boolean
  {
   var shape:IXrShape = _shapeSet.rows[id];
   if(shape != null)
   {
    shape.deleted = true;
    label.deleteLabelText(shape.fid);

    return true;
   } 
   
   return false;
  }

  //override public function afterAttatchingToMap(map:XrMapSprite):void
  //{
  // _label.labelView = map.labelView;
  //}

  public function get label():XrLabelEx
  {
   return _label;
  }

  public function get theme():IXrShapeThemeEx
  {
   return _theme;
  }

  public function set theme(thm:IXrShapeThemeEx):void
  {
   removeAllChild();
   _theme = thm;
  }
    
  public function get attributeSet():XrAttributeSet
  {
   return _attributeSet;
  }
  
  public function get shapeSet():XrShapeSet
  {
   return _shapeSet;
  }

  public function getLayerIDOfServerSide():String
  {
   return _layerNameServerSide;
  }
  
  public function getServerUrl():String
  {
   return _svrUrl;
  }
  
  override public function resize(width:int, height:int):void
  {
   super.resize(width, height);
   if(width == 0) return;
   
   //dynamicMode = true;
  }  
  
  override public function release():void
  {
   _ldr.removeEventListener(IOErrorEvent.IO_ERROR, updateErrorHandler);
   _ldr.removeEventListener(Event.COMPLETE, updateCompleteHandler);
  }
  
  public function get needAttribute():Boolean
  {
   return _label.needDraw(viewControls) || _theme.needAttribute || _requestAttributeAlways;
  } 
  
  override public function get connected():Boolean
  {
   return _connected;
  }
  
  private function onConnectRequestIOError(e:IOErrorEvent):void
  {
   trace("connect req error!", layerName);
   
   _ldr.removeEventListener(IOErrorEvent.IO_ERROR, onConnectRequestIOError);
   _ldr.removeEventListener(Event.COMPLETE, onConnectRequestCompleted);
  }

  private function removeAllChild():void
  {
   var cntChild:int = numChildren;
   
   for(var iChild:int=0; iChild<cntChild; ++iChild)
   {
    removeChildAt(0);
   }  
  }
  
  private function queryGeodataByRequestErrorHandler(e:IOErrorEvent):void
  {
   trace("queryByGeometry fail");
   _queryByGeometryCallbackFunction(null);
   
   _queryByGeometryCallbackFunction = null;
   var ldr:URLLoader = e.target as URLLoader;
   ldr.removeEventListener(IOErrorEvent.IO_ERROR, queryGeodataByRequestErrorHandler);
   ldr.removeEventListener(Event.COMPLETE, queryGeodataByRequestCompleteHandler);
  }
  
  private function queryGeodataByRequestCompleteHandler(e:Event):void
  {
   var ldr:URLLoader = e.target as URLLoader;
   
   var data:ByteArray = ldr.data as ByteArray;
   if(data == null)
   {
    _queryByGeometryCallbackFunction(null);
   }
   else
   {
    data.endian = Endian.LITTLE_ENDIAN;
    
    var totalDataLength:int = data.readInt();
    if(totalDataLength > 0)
    {
     var shapeDataLength:int = data.readInt();
     var attributeDataLength:int = data.readInt();
     
     var resultSet:XrSpatialQueryResult = new XrSpatialQueryResult(this as XrShapeMapLayer);
     
     var fidList:Array = processShapeDataPart(data, shapeDataLength, resultSet.shapeSet, resultSet.attributeSet);
     processAttributeDataPart(data, attributeDataLength, fidList, resultSet.attributeSet);
     
     _queryByGeometryCallbackFunction(resultSet);
    }
   }
   
   _queryByGeometryCallbackFunction = null;
   
   ldr.removeEventListener(IOErrorEvent.IO_ERROR, queryGeodataByRequestErrorHandler);
   ldr.removeEventListener(Event.COMPLETE, queryGeodataByRequestCompleteHandler);
  }
  
  private function processShapeDataPart(data:ByteArray, shapeDataLength:int,
             outputShapeSet:XrShapeSet, outputAttributeSet:XrAttributeSet):Array
  {
   var fid:uint;
   var fidList:Array = new Array();
   var chunkLength:uint;
   var mbr:XrExtent = null;
   var x:Number;
   var y:Number;
   var coord:XrCoordinate = null;

   var shp:IXrShape;
   var shapes:Object = outputShapeSet.rows;
   for each (shp in shapes)
   {
    if(shp.editCount == 0)
    {
     //shapeSet.removeRow(shp.fid);
     //attributeSet.removeRow(shp.fid);
     
     shp.invalid = true;
    }
   }
   //shapeSet.clear();
   
   var newShp:IXrShape;
   while(shapeDataLength>0)
   {
    fid = data.readUnsignedInt();
    
    fidList.push(fid);
    chunkLength = data.readInt();

    shapeDataLength -= (4 + 4 + chunkLength);

    newShp = null;
    shp = outputShapeSet.rows[fid];
    
    if(outputShapeSet.shapeType == XrShape.POINT_TYPE)
    {
     if(shp == null)
     {     
      var pts:Array = new Array();
      x = data.readFloat();
      y = data.readFloat();

      coord = new XrCoordinate(x, y);
      
      var pLatLng :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
      var cenXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLng[0], pLatLng[1]);
      coord.x = cenXY.x;
      coord.y = cenXY.y;
      
      pts.push(coord);
      
      mbr = new XrExtent(x, y, x, y);
      
      var pLatLngMax :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.max.x, mbr.max.y);
      var cenMaxXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMax[0], pLatLngMax[1]);
      mbr.max.x = cenMaxXY.x;
      mbr.max.y = cenMaxXY.y;
      var pLatLngMin :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.min.x, mbr.min.y);
      var cenMinXY :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMin[0], pLatLngMin[1]);
      mbr.min.x = cenMinXY.x;
      mbr.min.y = cenMinXY.y;
      
      newShp = new XrPointShape(fid, mbr, pts);
     }
     else
     {
      data.position += 4 + 4;
      shp.invalid = false;
     }
    }
    else if(outputShapeSet.shapeType == XrShape.POLYLINE_TYPE || outputShapeSet.shapeType == XrShape.POLYGON_TYPE)
    {
     var ringCount:int;
     var vertexCounts:Vector.<uint>;
     var iRing:int;
     var cntVtx:uint;
     var iVtx:int;
     
     if(shp == null)
     {   
      mbr = new XrExtent(data.readFloat(), data.readFloat(), data.readFloat(), data.readFloat());
      
      var pLatLngMaxPG :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.max.x, mbr.max.y);
      var cenMaxXYPG :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMaxPG[0], pLatLngMaxPG[1]);
      mbr.max.x = cenMaxXYPG.x;
      mbr.max.y = cenMaxXYPG.y;
      var pLatLngMinPG :Array = SetCoord_TMtoLongitude(org_Coordinate, mbr.min.x, mbr.min.y);
      var cenMinXYPG :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngMinPG[0], pLatLngMinPG[1]);
      mbr.min.x = cenMinXYPG.x;
      mbr.min.y = cenMinXYPG.y;
      
      ringCount = data.readUnsignedShort();

      vertexCounts = new Vector.<uint>();
      for(iRing=0; iRing<ringCount; ++iRing)
      {
       vertexCounts[iRing] = data.readUnsignedInt();
      }

      var parts:Vector.<Vector.<XrCoordinate>> = new Vector.<Vector.<XrCoordinate>>();
      for(iRing=0; iRing<ringCount; ++iRing)
      {
       var part:Vector.<XrCoordinate> = new Vector.<XrCoordinate>();
       cntVtx = vertexCounts[iRing];
       for(iVtx=0; iVtx<cntVtx; ++iVtx)
       {
        x = data.readFloat();
        y = data.readFloat();
       
        coord = new XrCoordinate(x, y);
        
        var pLatLngPG :Array = SetCoord_TMtoLongitude(org_Coordinate, coord.x, coord.y);
        var cenXYPG :Point = SetCoord_LongitudeToTM(current_Coordinate, pLatLngPG[0], pLatLngPG[1]);
        coord.x = cenXYPG.x;
        coord.y = cenXYPG.y;
        
        part.push(coord);
       }
      
       parts.push(part);
      }
     
      if(outputShapeSet.shapeType == XrShape.POLYLINE_TYPE)
       newShp = new XrPolylineShape(fid, mbr, parts);
      else     
       newShp = new XrPolygonShape(fid, mbr, parts);
     }
     else
     {
      data.position += 4 + 4 + 4 + 4;
      
      ringCount = data.readUnsignedShort();
      var totalVertexCounts:uint = 0;
      for(iRing=0; iRing<ringCount; ++iRing)
      {
       totalVertexCounts += data.readUnsignedInt();
      }
      
      data.position += (4 + 4) * totalVertexCounts;
      
      shp.invalid = false;
     }
    }
    
    if(newShp != null)
    {
     outputShapeSet.addRow(newShp);
    }
   }
   
   for each (shp in shapes)
   {
    if(shp.editCount == 0 && shp.invalid)
    {
     outputShapeSet.removeRow(shp.fid);
     outputAttributeSet.removeRow(shp.fid);
    }
   }
   
   return fidList;
  }
  
  private function processAttributeDataPart(data:ByteArray, attributeDataLength:int, fidList:Array, outputAttributeSet:XrAttributeSet):void
  {
   var chunkLength:uint;
   var fieldTypeList:Array = outputAttributeSet.fieldSet.fieldTypeList;
   var cntFields:uint = fieldTypeList.length;
   var fidIndex:int = 0;
   
   while(attributeDataLength>0)
   {
    try{
     chunkLength = data.readInt();
    } catch (err:Error) {
     trace("Error ");
     break;
    }
    attributeDataLength -= (4 + chunkLength);    
    
    if(outputAttributeSet.rows[fidList[fidIndex]] != null)
    {
     data.position += chunkLength;
     fidIndex++;
     continue;
    }
    
    var attribute:XrAttribute = new XrAttribute();
    for(var iField:uint=0; iField<cntFields; ++iField)
    {
     if(fieldTypeList[iField].toString() == XrField.DOUBLE_TYPE)
     {
      var doubleTypeVal‎ue:Number = 0;
      try{
       doubleTypeVal‎ue = data.readDouble();
      } catch (err:Error) {
       doubleTypeVal‎ue = 0;
      }
      attribute.addValue(doubleTypeVal‎ue.toString());
     }
     else if(fieldTypeList[iField].toString() == XrField.FLOAT_TYPE)
     {
      var floatTypeVal‎ue:Number = 0;
      try{
       floatTypeVal‎ue = data.readFloat();;
      } catch (err:Error) {
       floatTypeVal‎ue = 0;
      }
      attribute.addValue(floatTypeVal‎ue.toString());
     }
     else if(fieldTypeList[iField].toString() == XrField.INTEGER_TYPE)
     {
      var intTypeVal‎ue:int = 0;
      try{
       intTypeVal‎ue = data.readInt();
      } catch (err:Error) {
       intTypeVal‎ue = 0;
      }
      attribute.addValue(intTypeVal‎ue.toString()); 
     }
     else if(fieldTypeList[iField].toString() == XrField.SHORT_INTEGER_TYPE) 
     {
      var shortTypeVal‎ue:int = 0;
      try{
       shortTypeVal‎ue = data.readShort();
      } catch (err:Error) {
       shortTypeVal‎ue = 0;
      }
      attribute.addValue(shortTypeVal‎ue.toString());
     }
     else if(fieldTypeList[iField].toString() == XrField.STRING_TYPE)
     {
      var stringTypeVal‎ue:String = "";
      try{
       var lenValue:int = data.readByte();
       stringTypeVal‎ue = data.readMultiByte(Math.abs(lenValue), "euc-kr");
      } catch (err:Error) {
       stringTypeVal‎ue = "";
       trace("Error String Value " + stringTypeVal‎ue, "length: " + lenValue);
      } 
      attribute.addValue(stringTypeVal‎ue);
     }
     else if(fieldTypeList[iField].toString() == XrField.VERY_SHORT_INTEGER_TYPE)
     {
      var vertShortTypeVal‎ue:int = 0;
      try{
       vertShortTypeVal‎ue = data.readByte();
      } catch (err:Error) {
       vertShortTypeVal‎ue = 0;
      }
      attribute.addValue(vertShortTypeVal‎ue.toString());
     }
    }
    
    outputAttributeSet.addRow(fidList[fidIndex++], attribute);  
   }   
  }
 
  private function drawShape():void
  {
   if(needDraw)
   {
    _theme.drawToGraphicEx(this);//, !dynamicMode);
   }
   
   if(_label.needDraw(viewControls))
   {
    _label.draw();
   }

/*   
   if(this.highlightRow != -1)
   {
    var sprite:DisplayObject = getChildByName(highlightRow.toString());
    if(sprite != null)
    {
     sprite.filters = [ new GlowFilter(0x00ffff, 1, 6, 6, 3) ];
    }
   }
*/   
   map.parent.dispatchEvent(new XrAfterUpdateLayerEvent(layerName));
  }
  
  public function getFIDByMousePoint(x:int, y:int):int
  {
   var disObj:DisplayObject;
   for(var i:uint=0; i<numChildren; ++i)
   {
    disObj = getChildAt(i);
    
    //trace("---------> " + disObj, x, y);
    
    if(disObj.hitTestPoint(x, y, false) && disObj.hitTestPoint(x, y, true))
    {
     var shp:IXrShape = shapeSet.rows[disObj.name];

     //trace("---- " + disObj.name + " , " + shp.fid);

     return (int)(shp.fid);
    }
   }
   
   return -1;
  }
  
  public function get polygonClipMode():Boolean
  {
   return _polygonClipMode;
  }
  
  public function set polygonClipMode(v:Boolean):void
  {
   _polygonClipMode = v;
  }
  
  public function get shapeAsBitmap():Boolean
  {
   return _shapeAsBitmap;
  }
  
  public function set shapeAsBitmap(v:Boolean):void
  {
   _shapeAsBitmap = v;  
  }
  
  public function get noCache():Boolean
  {
   return _noCache;
  }
  
  public function set noCache(value:Boolean):void
  {
   _noCache = value;
  }
  
  public function get whereClause():String
  {
   return _whereClause;
  }
  
  public function set whereClause(value:String):void
  {
   if(value == null) value = "null";
   
   _whereClause = value;
  }
  
  ////////////////////////////////////////////////////////////////
  public function _TMtoLongitude(OrgProjectedCoordinate: int, MapX: Number, MapY: Number): Array{
   return [MapY, MapX];
  }
  
  //좌표변환: 경위도(WGS84)->TM
  public function _LongitudeToTM(OrgProjectedCoordinate: int, latDeg: Number, longDeg: Number):Point{
   return new Point(longDeg, latDeg);
  }
 }
}