public Geometry Read(GeometryType geometryType, DimensionType dimension)
{
switch (geometryType)
{
case GeometryType.GEOMETRY:
throw new NotSupportedException(geometryType.ToString());
case GeometryType.POINT:
return(ReadPoint(dimension));
case GeometryType.LINESTRING:
return(ReadLineString(dimension));
case GeometryType.POLYGON:
return(ReadPolygon(dimension));
case GeometryType.MULTIPOINT:
return(ReadMultiPoint(dimension));
case GeometryType.MULTILINESTRING:
return(ReadMultiLineString(dimension));
case GeometryType.MULTIPOLYGON:
case GeometryType.GEOMETRYCOLLECTION:
case GeometryType.CIRCULARSTRING:
case GeometryType.COMPOUNDCURVE:
case GeometryType.CURVEPOLYGON:
case GeometryType.MULTICURVE:
case GeometryType.MULTISURFACE:
case GeometryType.CURVE:
case GeometryType.SURFACE:
case GeometryType.POLYHEDRALSURFACE:
case GeometryType.TIN:
case GeometryType.TRIANGLE:
case GeometryType.CIRCLE:
case GeometryType.GEODESICSTRING:
case GeometryType.ELLIPTICALCURVE:
case GeometryType.URBSCURVE:
case GeometryType.CLOTHOID:
case GeometryType.SPIRALCURVE:
case GeometryType.COMPOUNDSURFACE:
case GeometryType.BREPSOLID:
case GeometryType.AFFINEPLACEMENT:
default:
throw new NotSupportedException(geometryType.ToString());
}
throw new NotImplementedException();
}
public Geometry CreateEmpty(GeometryType geometryType)
{
switch (geometryType)
{
case GeometryType.GEOMETRY:
throw new NotSupportedException(geometryType.ToString());
case GeometryType.POINT:
return(new Point());
case GeometryType.LINESTRING:
return(new LineString());
case GeometryType.POLYGON:
return(new Polygon());
case GeometryType.MULTIPOINT:
return(new MultiPoint());
case GeometryType.MULTILINESTRING:
return(new MultiLineString());
case GeometryType.MULTIPOLYGON:
//return new Multip
case GeometryType.GEOMETRYCOLLECTION:
case GeometryType.CIRCULARSTRING:
case GeometryType.COMPOUNDCURVE:
case GeometryType.CURVEPOLYGON:
case GeometryType.MULTICURVE:
case GeometryType.MULTISURFACE:
case GeometryType.CURVE:
case GeometryType.SURFACE:
case GeometryType.POLYHEDRALSURFACE:
case GeometryType.TIN:
case GeometryType.TRIANGLE:
case GeometryType.CIRCLE:
case GeometryType.GEODESICSTRING:
case GeometryType.ELLIPTICALCURVE:
case GeometryType.URBSCURVE:
case GeometryType.CLOTHOID:
case GeometryType.SPIRALCURVE:
case GeometryType.COMPOUNDSURFACE:
case GeometryType.BREPSOLID:
case GeometryType.AFFINEPLACEMENT:
default:
throw new NotSupportedException(geometryType.ToString());
}
}
private static void CheckGeometryType(int geometryTypes, List <string> geomTypes, GeometryType gtype)
{
if ((geometryTypes & (int)gtype) == (int)gtype)
{
geomTypes.Add(gtype.ToString());
}
}
protected virtual void WriteWktType(GeometryType geometryType, Dimension dimension, bool isEmpty, bool skipType = false)
{
if (!skipType)
{
wktBuilder.Append(geometryType.ToString().ToUpperInvariant());
switch (dimension)
{
case Dimension.Xyz: wktBuilder.Append(" Z "); break;
case Dimension.Xym: wktBuilder.Append(" M "); break;
case Dimension.Xyzm: wktBuilder.Append(" ZM "); break;
}
}
if (isEmpty && dimension == Dimension.Xy)
{
wktBuilder.Append(" ");
}
if (isEmpty)
{
wktBuilder.Append("EMPTY");
}
}
public void BeginGeometry(GeometryType type)
{
if ((_Builder.Length > 0) && (_Builder[_Builder.Length - 1] == ')'))
{
_Builder.Append(", ");
}
if ((_CurrentType.Count == 0) || (_CurrentType.Peek() == GeometryType.GeometryCollection))
{
_Builder.Append(type.ToString("G").ToUpperInvariant());
_Builder.Append(" ");
}
_CurrentType.Push(type);
switch (type)
{
case GeometryType.GeometryCollection:
case GeometryType.MultiLineString:
case GeometryType.MultiPoint:
case GeometryType.MultiPolygon:
case GeometryType.Polygon:
_Builder.Append("(");
break;
}
}
public override void BeginGeometry(GeometryType type)
{
if ((_CurrentType.Count == 0) || (_CurrentType.Peek() == GeometryType.GeometryCollection))
{
_Writer.WriteStartObject();
_Writer.WritePropertyName("type");
_Writer.WriteValue(type.ToString("G"));
if (type != GeometryType.GeometryCollection)
{
if ((type != GeometryType.LineString) && (type != GeometryType.Point))
{
_WriteBox();
}
_Writer.WritePropertyName("coordinates");
}
else
{
_Writer.WritePropertyName("geometries");
}
}
_CurrentType.Push(type);
switch (type)
{
case GeometryType.GeometryCollection:
case GeometryType.MultiLineString:
case GeometryType.MultiPoint:
case GeometryType.MultiPolygon:
case GeometryType.Polygon:
_Writer.WriteStartArray();
break;
}
}
public void CreateEmpty(GeometryType geometry, DimensionType dimension)
{
this.Type = geometry;
this.Dimension = dimension;
//Array to store the byte form
m_arr = new BinaryArray();
m_arr.AddBytes(intToBytes((int)geometry + (int)dimension));
this.wkt = geometry.ToString() + " " + dimension.WktEncode() + " EMPTY";
this.ewkt = "SRID=4326;" + geometry.ToString() + " " + dimension.WktEncode() + " EMPTY";
this.wkb_big = m_arr.BigEndian.ToArray();
this.wkb_little = m_arr.LittleEndian.ToArray();
this.Validation = Activator.CreateInstance(geometry.GetEquivalentType()) as Geometry;
}
protected override void WriteWktType(GeometryType geometryType, Dimension dimension, bool isEmpty)
{
wktBuilder.Append(geometryType.ToString().ToUpperInvariant());
if (dimension == Dimension.Xym)
wktBuilder.Append("M");
if (isEmpty)
wktBuilder.Append(" EMPTY");
}
void setupBase <T>(DimensionType dimension, GeometryType geometry) where T : Geometry, new()
{
this.Type = geometry;
this.Dimension = dimension;
m_arr = new BinaryArray();
m_arr.AddBytes(intToBytes((int)this.Type + (int)dimension));
this.wkt = geometry.ToString() + " " + dimension.WktEncode() + "(";
this.ewkt = "SRID=4326;" + this.Type.ToString() + " " + dimension.WktEncode() + "(";
this.Validation = new T();
}
internal Geometry Read()
{
wkbReader.IsBigEndian = !wkbReader.ReadBoolean();
uint type = wkbReader.ReadUInt32();
GeometryType geometryType = ReadGeometryType(type);
Dimension dimension = ReadDimension(type);
int? srid = ReadSrid(type);
Geometry geometry = null;
switch (geometryType)
{
case GeometryType.Point: geometry = ReadPoint(dimension); break;
case GeometryType.LineString: geometry = ReadLineString(dimension); break;
case GeometryType.Polygon: geometry = ReadPolygon(dimension); break;
case GeometryType.MultiPoint: geometry = ReadMultiPoint(dimension); break;
case GeometryType.MultiLineString: geometry = ReadMultiLineString(dimension); break;
case GeometryType.MultiPolygon: geometry = ReadMultiPolygon(dimension); break;
case GeometryType.GeometryCollection: geometry = ReadGeometryCollection(dimension); break;
case GeometryType.CircularString: geometry = ReadCircularString(dimension); break;
case GeometryType.CompoundCurve: geometry = ReadCompoundCurve(dimension); break;
case GeometryType.CurvePolygon: geometry = ReadCurvePolygon(dimension); break;
case GeometryType.MultiCurve: geometry = ReadMultiCurve(dimension); break;
case GeometryType.MultiSurface: geometry = ReadMultiSurface(dimension); break;
case GeometryType.PolyhedralSurface: geometry = ReadPolyhedralSurface(dimension); break;
case GeometryType.Tin: geometry = ReadTin(dimension); break;
case GeometryType.Triangle: geometry = ReadTriangle(dimension); break;
default: throw new NotSupportedException(geometryType.ToString());
}
geometry.Dimension = dimension;
geometry.Srid = srid;
return(geometry);
}
protected override void WriteWktType(GeometryType geometryType, Dimension dimension, bool isEmpty, bool skipType = false)
{
if (!skipType)
{
wktBuilder.Append(geometryType.ToString().ToUpperInvariant());
if (dimension == Dimension.Xym)
{
wktBuilder.Append("M");
}
}
if (isEmpty)
{
wktBuilder.Append(" EMPTY");
}
}
protected virtual void WriteWktType(GeometryType geometryType, Dimension dimension, bool isEmpty)
{
wktBuilder.Append(geometryType.ToString().ToUpperInvariant());
switch (dimension)
{
case Dimension.Xyz: wktBuilder.Append(" Z "); break;
case Dimension.Xym: wktBuilder.Append(" M "); break;
case Dimension.Xyzm: wktBuilder.Append(" ZM "); break;
}
if (isEmpty && dimension == Dimension.Xy)
wktBuilder.Append(" ");
if (isEmpty)
wktBuilder.Append("EMPTY");
}
protected Geometry CreateGeometry(GeometryType geometryType, Dimension dimension)
{
Geometry geometry = null;
switch (geometryType)
{
case GeometryType.Point: geometry = new Point(); break;
case GeometryType.LineString: geometry = new LineString(); break;
case GeometryType.Polygon: geometry = new Polygon(); break;
case GeometryType.MultiPoint: geometry = new MultiPoint(); break;
case GeometryType.MultiLineString: geometry = new MultiLineString(); break;
case GeometryType.MultiPolygon: geometry = new MultiPolygon(); break;
case GeometryType.GeometryCollection: geometry = new GeometryCollection(); break;
case GeometryType.CircularString: geometry = new CircularString(); break;
case GeometryType.CompoundCurve: geometry = new CompoundCurve(); break;
case GeometryType.CurvePolygon: geometry = new CurvePolygon(); break;
case GeometryType.MultiCurve: geometry = new MultiCurve(); break;
case GeometryType.MultiSurface: geometry = new MultiSurface(); break;
case GeometryType.PolyhedralSurface: geometry = new PolyhedralSurface(); break;
case GeometryType.Tin: geometry = new Tin(); break;
case GeometryType.Triangle: geometry = new Triangle(); break;
default: throw new NotSupportedException(geometryType.ToString());
}
geometry.Dimension = dimension;
return(geometry);
}
protected Geometry Read(GeometryType geometryType, Dimension dimension)
{
switch (geometryType)
{
case GeometryType.Point: return(ReadPoint(dimension));
case GeometryType.LineString: return(ReadLineString(dimension));
case GeometryType.Polygon: return(ReadPolygon(dimension));
case GeometryType.MultiPoint: return(ReadMultiPoint(dimension));
case GeometryType.MultiLineString: return(ReadMultiLineString(dimension));
case GeometryType.MultiPolygon: return(ReadMultiPolygon(dimension));
case GeometryType.GeometryCollection: return(ReadGeometryCollection(dimension));
case GeometryType.CircularString: return(ReadCircularString(dimension));
case GeometryType.CompoundCurve: return(ReadCompoundCurve(dimension));
case GeometryType.CurvePolygon: return(ReadCurvePolygon(dimension));
case GeometryType.MultiCurve: return(ReadMultiCurve(dimension));
case GeometryType.MultiSurface: return(ReadMultiSurface(dimension));
case GeometryType.PolyhedralSurface: return(ReadPolyhedralSurface(dimension));
case GeometryType.Tin: return(ReadTin(dimension));
case GeometryType.Triangle: return(ReadTriangle(dimension));
default: throw new NotSupportedException(geometryType.ToString());
}
}
public void BeginGeometry(GeometryType type)
{
if ((_Builder.Length>0) && (_Builder[_Builder.Length-1]==')'))
_Builder.Append(", ");
if ((_CurrentType.Count==0) || (_CurrentType.Peek()==GeometryType.GeometryCollection))
{
_Builder.Append(type.ToString("G").ToUpperInvariant());
_Builder.Append(" ");
}
_CurrentType.Push(type);
switch (type)
{
case GeometryType.GeometryCollection:
case GeometryType.MultiLineString:
case GeometryType.MultiPoint:
case GeometryType.MultiPolygon:
case GeometryType.Polygon:
_Builder.Append("(");
break;
}
}
private GeometryWkbType GetWkbType(GeometryType geomType)
{
if (geomType == GeometryType.Point)
{
return(GeometryWkbType.Point);
}
else if (geomType == GeometryType.LineString)
{
return(GeometryWkbType.LineString);
}
else if (geomType == GeometryType.Polygon)
{
return(GeometryWkbType.Polygon);
}
else if (geomType == GeometryType.MultiPoint)
{
return(GeometryWkbType.MultiPoint);
}
else if (geomType == GeometryType.MultiLineString)
{
return(GeometryWkbType.MultiLineString);
}
else if (geomType == GeometryType.MultiPolygon)
{
return(GeometryWkbType.MultiPolygon);
}
else if (geomType == GeometryType.GeometryCollection)
{
return(GeometryWkbType.GeometryCollection);
}
else
{
throw new GeometryIOException("The well-known binary format for "
+ "this Geometry does not exist: " + geomType.ToString());
}
}
internal Geometry Read()
{
int?geomStart = spatialiteWkbReader.ReadByte();
spatialiteWkbReader.IsBigEndian = !spatialiteWkbReader.ReadBoolean();
int? srid = spatialiteWkbReader.ReadInt32();
double?minX = spatialiteWkbReader.ReadDouble();
double?minY = spatialiteWkbReader.ReadDouble();
double?maxX = spatialiteWkbReader.ReadDouble();
double?maxY = spatialiteWkbReader.ReadDouble();
int? geomEnd = spatialiteWkbReader.ReadByte();
if (geomStart != 0 || geomEnd != 124)
{
throw new NotSupportedException("Not valid Spatialite Geometry");
}
uint type = spatialiteWkbReader.ReadUInt32();
GeometryType geometryType = ReadGeometryType(type);
Dimension dimension = ReadDimension(type);
Geometry geometry = null;
switch (geometryType)
{
case GeometryType.Point: geometry = ReadPoint(dimension); break;
case GeometryType.LineString: geometry = ReadLineString(dimension); break;
case GeometryType.Polygon: geometry = ReadPolygon(dimension); break;
case GeometryType.MultiPoint: geometry = ReadMultiPoint(dimension); break;
case GeometryType.MultiLineString: geometry = ReadMultiLineString(dimension); break;
case GeometryType.MultiPolygon: geometry = ReadMultiPolygon(dimension); break;
case GeometryType.GeometryCollection: geometry = ReadGeometryCollection(dimension); break;
case GeometryType.CircularString: geometry = ReadCircularString(dimension); break;
case GeometryType.CompoundCurve: geometry = ReadCompoundCurve(dimension); break;
case GeometryType.CurvePolygon: geometry = ReadCurvePolygon(dimension); break;
case GeometryType.MultiCurve: geometry = ReadMultiCurve(dimension); break;
case GeometryType.MultiSurface: geometry = ReadMultiSurface(dimension); break;
case GeometryType.PolyhedralSurface: geometry = ReadPolyhedralSurface(dimension); break;
case GeometryType.Tin: geometry = ReadTin(dimension); break;
case GeometryType.Triangle: geometry = ReadTriangle(dimension); break;
default: throw new NotSupportedException(geometryType.ToString());
}
geometry.Dimension = dimension;
geometry.Srid = srid;
return(geometry);
}
public override void BeginGeometry(GeometryType type)
{
if ((_CurrentType.Count==0) || (_CurrentType.Peek()==GeometryType.GeometryCollection))
{
_Writer.WriteStartObject();
_Writer.WritePropertyName("type");
_Writer.WriteValue(type.ToString("G"));
if (type!=GeometryType.GeometryCollection)
{
if ((type!=GeometryType.LineString) && (type!=GeometryType.Point))
_WriteBox();
_Writer.WritePropertyName("coordinates");
} else
_Writer.WritePropertyName("geometries");
}
_CurrentType.Push(type);
switch (type)
{
case GeometryType.GeometryCollection:
case GeometryType.MultiLineString:
case GeometryType.MultiPoint:
case GeometryType.MultiPolygon:
case GeometryType.Polygon:
_Writer.WriteStartArray();
break;
}
}
private static void CheckGeometryType(int geometryTypes, List<string> geomTypes, GeometryType gtype)
{
if ((geometryTypes & (int)gtype) == (int)gtype)
geomTypes.Add(gtype.ToString());
}
void mSceneControlObjectSelectedCon(object sender, ObjectSelectedEventArgs e)
{
mIsPipe1Selected = true;
Recordset recordset = null;
Selection3D[] selection3d = null;
try
{
// 无对象被选中
if (e.Count == 0)
{
MessageBox.Show("未选择对象!");
}
//有对象选中
if (e.Count > 0)
{
mSceneControl.Action = Action3D.Pan2;
selection3d = mSceneControl.Scene.FindSelection(true);
recordset = selection3d[0].ToRecordset();
switch (mFlag)//判断是第几个被选中的点 第一个点用于获得图层 网络数据集等，第二个点要判断是否与一 一致
{
#region case1
case 1: mPipeTypeConId1 = recordset.GetFieldValue("PipeType").ToString().Trim();
switch (mPipeTypeConId1)
{
case "给水":
mConNetWorkName = mUseData.SupplyWaterNetWork;
mConLayerName = "给水管网@127.0.0.1_UnderPipeLine";
mPipeAltitude = -2;
break;
case "排水":
mConNetWorkName = mUseData.OutWaterNetWork;
mConLayerName = "排水管网@127.0.0.1_UnderPipeLine";
mPipeAltitude = -3.5;
break;
default:
MessageBox.Show("请选择其他类型管线");
mFlag = 0;
break;
}
if (mConNetWorkName != null)
{
mPipeConId1 = Convert.ToInt32(recordset.GetFieldValue("SmID"));
Geometry geo1 = recordset.GetGeometry();
recordsetTypeConId1 = geo1.Type;
if (recordsetTypeConId1 == GeometryType.GeoLine3D)
{
MessageBox.Show("当前选择管线ID为" + mPipeConId1.ToString());
}
else if (recordsetTypeConId1 == GeometryType.GeoPoint3D)
{
MessageBox.Show("当前选择管点ID为" + mPipeConId1.ToString());
}
else
{
MessageBox.Show("请选择管点或管线对象");
}
}
break;
#endregion
#region case2
case 2:
//判断图层-----------------------------------
mPipeTypeConId2 = recordset.GetFieldValue("PipeType").ToString().Trim();
if (mPipeTypeConId2 != mPipeTypeConId1 || mPipeTypeConId2 == null)
{
MessageBox.Show("请选择" + mPipeTypeConId1 + "管线对象");
break;
}
//----------------------------------------------------
//判断类型--------------------------------------
Geometry geo2 = recordset.GetGeometry();
recordsetTypeConId2 = geo2.Type;
if (recordsetTypeConId2 != recordsetTypeConId1)
{
MessageBox.Show("请选择当前图层" + recordsetTypeConId1.ToString() + "对象");
break;
}
mPipeConId2 = Convert.ToInt32(recordset.GetFieldValue("SmID"));
if (recordsetTypeConId2 == GeometryType.GeoLine3D)
{
MessageBox.Show("当前选择管线ID为" + mPipeConId2.ToString());
}
else if (recordsetTypeConId2 == GeometryType.GeoPoint3D)
{
MessageBox.Show("当前选择管点ID为" + mPipeConId2.ToString());
}
//------------------------------------------------
break;
#endregion
default:
break;
}
}
}
catch (System.Exception ex)
{
Trace.Write(ex.Message);
}
finally
{
if (recordset != null)
{
recordset.Close();
recordset.Dispose();
}
}
}
protected void WriteGraphicsLayerElements(GraphicsLayer layer)
{
GeometryType geomType = (GeometryType)layer.GetValue(LayerExtensions.GeometryTypeProperty);
if (geomType != default(GeometryType))
{
writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.GeometryType", Constants.esriMappingNamespace, geomType.ToString());
}
LinearGradientBrush defaultBrush = LayerExtensions.GetGradientBrush(layer);
if (defaultBrush != null)
{
writer.WriteStartElement(Constants.esriMappingPrefix, "LayerExtensions.GradientBrush", Constants.esriMappingNamespace);
BrushXamlWriter brushWriter = new BrushXamlWriter(writer, Namespaces);
brushWriter.WriteBrush(defaultBrush);
writer.WriteEndElement();
}
string rendererAttributeDisplayName = LayerExtensions.GetRendererAttributeDisplayName(layer);
if (!string.IsNullOrEmpty(rendererAttributeDisplayName))
{
writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.RendererAttributeDisplayName", Constants.esriMappingNamespace, rendererAttributeDisplayName);
}
//string geomServiceUrl = layer.GetValue(LayerExtensions.GeometryServiceUrlProperty) as string;
//if (!string.IsNullOrEmpty(geomServiceUrl))
//{
// writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.GeometryServiceUrl", Constants.esriMappingNamespace, geomServiceUrl);
//}
//SpatialReference mapSpatialRef = (SpatialReference)layer.GetValue(LayerExtensions.MapSpatialReferenceProperty);
//if (mapSpatialRef != null)
//{
// writer.WriteStartElement(Constants.esriMappingPrefix, "LayerExtensions.MapSpatialReference", Constants.esriMappingNamespace);
// WriteSpatialReference(writer, Namespaces, mapSpatialRef);
// writer.WriteEndElement();
//}
//SpatialReference layerSpatialRef = (SpatialReference)layer.GetValue(LayerExtensions.LayerSpatialReferenceProperty);
//if (layerSpatialRef != null)
//{
// writer.WriteStartElement(Constants.esriMappingPrefix, "LayerExtensions.LayerSpatialReference", Constants.esriMappingNamespace);
// WriteSpatialReference(writer, Namespaces, layerSpatialRef);
// writer.WriteEndElement();
//}
Collection <FieldInfo> fields = (Collection <FieldInfo>)layer.GetValue(LayerExtensions.FieldsProperty);
if (fields != null)
{
writer.WriteStartElement(Constants.esriMappingPrefix, "LayerExtensions.Fields", Constants.esriMappingNamespace);
FieldInfo.WriteFieldInfos(fields, writer);
writer.WriteEndElement();
}
string displayField = LayerExtensions.GetDisplayField(layer);
if (!string.IsNullOrEmpty(displayField))
{
writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.DisplayField", Constants.esriMappingNamespace, displayField);
}
if (LayerExtensions.GetPopUpsOnClick(layer))
{
writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.PopUpsOnClick", Constants.esriMappingNamespace, "True");
}
else
{
writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.PopUpsOnClick", Constants.esriMappingNamespace, "False");
}
//string mapTipContainerXaml = layer.GetValue(LayerExtensions.MapTipContainerXamlProperty) as string;
//if (!string.IsNullOrEmpty(mapTipContainerXaml))
//{
// writer.WriteElementString(Constants.esriMappingPrefix, "LayerExtensions.MapTipContainerXaml", Constants.esriMappingNamespace, mapTipContainerXaml);
// writer.WriteStartElement("GraphicsLayer.MapTip", Constants.esriNamespace);
// writer.WriteStartElement("ContentControl");
// writer.WriteRaw(mapTipContainerXaml);
// writer.WriteEndElement();
// writer.WriteEndElement();
//}
if (layer.Clusterer != null)
{
WriteLayerClusterer(layer.Clusterer);
}
if (layer.Renderer != null)
{
WriteRenderer(layer.Renderer);
}
if (layer.Graphics.Count > 0)
{
WriteGraphicsDataset(layer);
}
//if (layer.MapTip != null)
//{
//writer.WriteStartElement("GraphicsLayer.MapTip", Namespaces[Constants.esriPrefix]);
//if (LayerMapTipFormatting != null)
//{
// LayerMapTipFormattingEventArgs args = new LayerMapTipFormattingEventArgs
// {
// Layer = layer
// };
// LayerMapTipFormatting(this, args);
// string mapTipXaml = args.LayerMapTipXaml;
// if (!string.IsNullOrEmpty(mapTipXaml))
// {
// writer.WriteRaw(mapTipXaml);
// //Write(MapTipXaml);
// }
// else
// {
// // Must write a content template.
// writer.WriteRaw("<ContentControl />");
// }
//}
//writer.WriteEndElement();
//}
}
