public static string GetGeomFieldName(MapServerInfo mapinfo, int layerID)
{
MapLayerInfo[] mapLayerInfos = mapinfo.MapLayerInfos;
string empty = string.Empty;
MapLayerInfo[] array = mapLayerInfos;
for (int i = 0; i < array.Length; i++)
{
MapLayerInfo mapLayerInfo = array[i];
if (layerID == mapLayerInfo.LayerID)
{
Field[] fieldArray = mapLayerInfo.Fields.FieldArray;
Field[] array2 = fieldArray;
for (int j = 0; j < array2.Length; j++)
{
Field field = array2[j];
if (field.Type == esriFieldType.esriFieldTypeGeometry)
{
empty = field.Name;
break;
}
}
}
}
return(empty);
}
public AGSThemeRasterClass(IDataset dataset, MapLayerInfo layerInfo)
{
_dataset = dataset;
_name = layerInfo.Name;
_id = layerInfo.LayerID.ToString();
}
private MapImage GetMapImage(esriImageReturnType returnType)
{
MapDescription mapDescription = ((AgsDataFrame)DataFrame).MapServerInfo.NewMapDescription(Extent);
mapDescription.SetAllLayersNotVisible();
for (int i = 0; i < _layerList.Count; ++i)
{
AgsLayer layer = _layerList[i];
string query = _queryList[i];
MapLayerInfo mapLayerInfo = layer.MapLayerInfo;
while (mapLayerInfo != null)
{
LayerDescription layerDescription = mapDescription.LayerDescriptions.First(ld => ld.LayerID == mapLayerInfo.LayerID);
layerDescription.Visible = true;
if (!String.IsNullOrEmpty(query))
{
layerDescription.DefinitionExpression = query;
}
mapLayerInfo = mapLayerInfo.Parent;
query = null;
}
}
ImageDescription imageDescription = new ImageDescription();
imageDescription.ImageDisplay = new ImageDisplay(Convert.ToInt32(Width * Resolution), Convert.ToInt32(Height * Resolution), DataFrame.Dpi * Resolution);
imageDescription.ImageType = new ImageType(returnType);
switch (ImageType)
{
case CommonImageType.Png:
imageDescription.ImageType.ImageFormat = esriImageFormat.esriImagePNG32;
if (TransparentBackground)
{
mapDescription.TransparentColor = mapDescription.BackgroundSymbol.Color;
}
break;
default:
imageDescription.ImageType.ImageFormat = esriImageFormat.esriImageJPG;
break;
}
return(_service.MapServer.ExportMapImage(mapDescription, imageDescription));
}
public static string GetOIDFieldName(MapServerInfo mapinfo, int layerID)
{
MapLayerInfo[] mapLayerInfos = mapinfo.MapLayerInfos;
MapLayerInfo[] array = mapLayerInfos;
for (int i = 0; i < array.Length; i++)
{
MapLayerInfo mapLayerInfo = array[i];
if (layerID == mapLayerInfo.LayerID)
{
return(mapLayerInfo.IDField);
}
}
return(string.Empty);
}
private void CalcParentLayerIds(MapLayerInfo[] mapLayerInfos, int layerId)
{
MapLayerInfo layer = MapLayerInfoById(mapLayerInfos, layerId);
if (layer == null || layer.ParentLayerID < 0)
{
return;
}
List <int> parentIds = new List <int>();
while (layer != null)
{
parentIds.Add(layer.ParentLayerID);
layer = MapLayerInfoById(mapLayerInfos, layer.ParentLayerID);
}
_parentIds[layerId] = parentIds;
}
public AgsLayer(AgsDataFrame dataFrame, MapLayerInfo mapLayerInfo, MapServerLegendInfo mapServerLegendInfo, bool defaultVisible)
{
_service = dataFrame.Service as AgsMapService;
_mapLayerInfo = mapLayerInfo;
_mapServerLegendInfo = mapServerLegendInfo;
DataFrame = dataFrame;
DefaultVisible = defaultVisible;
ID = mapLayerInfo.LayerID.ToString();
Name = mapLayerInfo.Name;
double toPixels = 1.0 / (12 * dataFrame.Dpi);
if (dataFrame.MapServerInfo.Units == esriUnits.esriMeters)
{
toPixels *= MetersPerFoot;
}
if (mapLayerInfo.MaxScale > 0)
{
MinimumPixelSize = mapLayerInfo.MaxScale * toPixels;
}
if (mapLayerInfo.MinScale > 0)
{
MaximumPixelSize = mapLayerInfo.MinScale * toPixels;
}
if (mapLayerInfo.IsFeatureLayer && mapLayerInfo.LayerType != "Annotation Layer" && mapLayerInfo.LayerType != "Raster Catalog Layer")
{
Selectable = mapLayerInfo.CanSelect;
Fields = new List <CommonField>();
foreach (Field proxyField in mapLayerInfo.Fields.FieldArray)
{
AgsField field = new AgsField(proxyField);
Fields.Add(field);
if (field.Type == CommonFieldType.ID)
{
FeatureIDField = field;
}
else if (field.Type == CommonFieldType.Geometry)
{
GeometryField = field;
switch (proxyField.GeometryDef.GeometryType)
{
case esriGeometryType.esriGeometryPoint: FeatureType = OgcGeometryType.Point; break;
case esriGeometryType.esriGeometryMultipoint: FeatureType = OgcGeometryType.MultiPoint; break;
case esriGeometryType.esriGeometryPolyline: FeatureType = OgcGeometryType.MultiLineString; break;
case esriGeometryType.esriGeometryPolygon: FeatureType = OgcGeometryType.MultiPolygon; break;
}
}
}
Legend = new AgsLegend(mapServerLegendInfo);
}
else
{
switch (mapLayerInfo.LayerType)
{
case "Raster Catalog Layer":
case "Raster Layer":
Type = CommonLayerType.Image;
break;
case "Annotation Layer": Type = CommonLayerType.Annotation; break;
case "Group Layer": Type = CommonLayerType.Group; break;
}
}
}
public AGSThemeClass(IDataset dataset, MapLayerInfo layerInfo)
{
_dataset = dataset;
_layerInfo = layerInfo;
}
public AGSThemeFeatureClass(AGSDataset dataset, MapLayerInfo layerInfo, geometryType geomType)
{
if (dataset is IFeatureDataset)
{
_envelope = ((IFeatureDataset)dataset).Envelope;
_sRef = ((IFeatureDataset)dataset).SpatialReference;
}
_dataset = dataset;
_name = layerInfo.Name;
_id = layerInfo.LayerID.ToString();
_geomType = geomType;
#region Fields
foreach (Proxy.Field fieldInfo in layerInfo.Fields.FieldArray)
{
gView.Framework.Data.Field field = new gView.Framework.Data.Field(fieldInfo.Name);
switch (fieldInfo.Type)
{
case esriFieldType.esriFieldTypeBlob:
field.type = FieldType.binary;
break;
case esriFieldType.esriFieldTypeDate:
field.type = FieldType.Date;
break;
case esriFieldType.esriFieldTypeDouble:
field.type = FieldType.Double;
break;
case esriFieldType.esriFieldTypeGeometry:
_shapeFieldName = field.name;
field.type = FieldType.Shape;
break;
case esriFieldType.esriFieldTypeGlobalID:
field.type = FieldType.unknown;
break;
case esriFieldType.esriFieldTypeGUID:
field.type = FieldType.guid;
break;
case esriFieldType.esriFieldTypeInteger:
field.type = FieldType.integer;
break;
case esriFieldType.esriFieldTypeOID:
_idFieldName = field.name;
field.type = FieldType.ID;
break;
case esriFieldType.esriFieldTypeRaster:
field.type = FieldType.binary;
break;
case esriFieldType.esriFieldTypeSingle:
field.type = FieldType.Float;
break;
case esriFieldType.esriFieldTypeSmallInteger:
field.type = FieldType.smallinteger;
break;
case esriFieldType.esriFieldTypeString:
case esriFieldType.esriFieldTypeXML:
field.type = FieldType.String;
break;
}
_fields.Add(field);
}
#endregion
}
public bool Open(gView.MapServer.IServiceRequestContext context)
{
if (_class == null)
{
_class = new AGSClass(this);
}
#region Parameters
string server = ConfigTextStream.ExtractValue(ConnectionString, "server");
string service = ConfigTextStream.ExtractValue(ConnectionString, "service");
string user = ConfigTextStream.ExtractValue(ConnectionString, "user");
string pwd = ConfigTextStream.ExtractValue(ConnectionString, "pwd");
if ((user == "#" || user == "$") &&
context != null && context.ServiceRequest != null && context.ServiceRequest.Identity != null)
{
string roles = String.Empty;
if (user == "#" && context.ServiceRequest.Identity.UserRoles != null)
{
foreach (string role in context.ServiceRequest.Identity.UserRoles)
{
if (String.IsNullOrEmpty(role))
{
continue;
}
roles += "|" + role;
}
}
user = context.ServiceRequest.Identity.UserName + roles;
pwd = context.ServiceRequest.Identity.HashedPassword;
}
#endregion
try
{
_proxy = ProxySettings.Proxy(server);
_themes.Clear();
_parentIds.Clear();
_mapServer = new gView.Interoperability.AGS.Proxy.MapServer(service);
_mapServer.Proxy = gView.Framework.Web.ProxySettings.Proxy(service);
MapServerInfo msi = _mapServer.GetServerInfo(_mapServer.GetDefaultMapName());
_mapDescription = msi.DefaultMapDescription;
MapLayerInfo[] mapLayerInfos = msi.MapLayerInfos;
foreach (MapLayerInfo layerInfo in mapLayerInfos)
{
if (layerInfo.Extent is EnvelopeN)
{
EnvelopeN env = (EnvelopeN)layerInfo.Extent;
if (_envelope == null)
{
_envelope = new gView.Framework.Geometry.Envelope(env.XMin, env.YMin, env.XMax, env.YMax);
}
else
{
_envelope.Union(new gView.Framework.Geometry.Envelope(env.XMin, env.YMin, env.XMax, env.YMax));
}
}
CalcParentLayerIds(mapLayerInfos, layerInfo.LayerID);
IClass themeClass = null;
IWebServiceTheme theme = null;
LayerDescription ld = LayerDescriptionById(layerInfo.LayerID);
if (ld == null)
{
continue;
}
if (layerInfo.LayerType == "Feature Layer")
{
#region Geometry Type (Point, Line, Polygon)
geometryType geomType = geometryType.Unknown;
if (layerInfo.Fields != null)
{
foreach (Proxy.Field fieldInfo in layerInfo.Fields.FieldArray)
{
if (fieldInfo.Type == esriFieldType.esriFieldTypeGeometry &&
fieldInfo.GeometryDef != null)
{
switch (fieldInfo.GeometryDef.GeometryType)
{
case esriGeometryType.esriGeometryMultipoint:
case esriGeometryType.esriGeometryPoint:
geomType = geometryType.Point;
break;
case esriGeometryType.esriGeometryPolyline:
geomType = geometryType.Polyline;
break;
case esriGeometryType.esriGeometryPolygon:
geomType = geometryType.Polygon;
break;
case esriGeometryType.esriGeometryMultiPatch:
break;
}
}
}
}
#endregion
themeClass = new AGSThemeFeatureClass(this, layerInfo, geomType);
theme = LayerFactory.Create(themeClass, _class as IWebServiceClass) as IWebServiceTheme;
if (theme == null)
{
continue;
}
}
else if (layerInfo.LayerType == "Raster Layer" ||
layerInfo.LayerType == "Raster Catalog Layer")
{
themeClass = new AGSThemeRasterClass(this, layerInfo);
theme = LayerFactory.Create(themeClass, _class as IWebServiceClass) as IWebServiceTheme;
if (theme == null)
{
continue;
}
}
else
{
MapLayerInfo parentLayer = MapLayerInfoById(mapLayerInfos, layerInfo.ParentLayerID);
if (parentLayer != null && parentLayer.LayerType == "Annotation Layer")
{
themeClass = new AGSThemeFeatureClass(this, layerInfo, geometryType.Polygon);
theme = LayerFactory.Create(themeClass, _class as IWebServiceClass) as IWebServiceTheme;
if (theme == null)
{
continue;
}
}
}
if (theme != null)
{
theme.MinimumScale = layerInfo.MaxScale;
theme.MaximumScale = layerInfo.MinScale;
theme.Visible = ld.Visible;
_themes.Add(theme);
}
}
_state = DatasetState.opened;
return(true);
}
catch (Exception ex)
{
_state = DatasetState.unknown;
_errMsg = ex.Message;
return(false);
}
}
